Simão Melo de Sousa. Computer Science Department University of Beira Interior, Portugal

Transcrição

1 Análise Sintáctica Simão Melo de Sousa Computer Science Department University of Beira Interior, Portugal

2 Plano Eliminar a Recursividade Esquerda Factorizar a Esquerda

3 Plano

4 Alvo?

5 Lembrete Uma gramática livre de contexto (ou ainda algébrica) G = (N, T, S, P) é definida por dois alfabetos disjuntos: N (conjuntos dos símbolos não terminais) e T (conjunto dos símbolos terminais). Dos elementos de N destacamos um símbolo particular o símbolo S que é o símbolo inicial. O conjunto P de G é o conjunto das produções gramaticais. P N (N T ) cujos seus elementos são notados por X ::= ω ou X ω (com X N e ω (N T ) ). α deriva-se num passo (ou etapa) em β na gramática G (notação α = β) se α = α 1 X α 2, β = α 1 ωα 2 e (X ::= ω) P Uma derivação em zero ou mais passos (notada transitivo de =. = ) é o fecho reflexivo A palavra m T é reconhecida pela gramática G = (N, T, P, S) se S Designamos por L(G) o conjunto das palavras reconhecidas por G. É a linguagem reconhecida por G. = m.

6 Lembrete Seja α 1 = α 2 = α 3 =... = α n uma derivação. A cada passo escolhemos e desenvolvemos um Não-terminal. Dizemos que esta derivação é uma derivação esquerda se escolhemos sistematicamente o não terminal mais a esquerda. Dizemos que é uma derivação direita se escolhemos sistematicamente o não terminal mais a direita. Dizemos que é uma derivação máxima se α n T (ou seja já não é possível estender a derivação com mais um passo, visto α n não conter mais não-terminais). Vamos nesta lição contemplar exclusivamente gramáticas ditas reduzidas e atingíveis. G é reduzida quando: A N, m T, A = m G é atingível quando: A N, α, β (N T ), S = αaβ

7 Lembrete Propriedades interessantes das gramáticas livres de contexto: α 1, α 2 (N T ), Se (α 1α 2 = β) Então β 1, β 2 (N T ), α 1 = β 1 α 2 = β 2 β = β 1β 2 Esta propriedade justifica o nome de livres de contexto. Ou seja A palavra gerada por α 1 é gerada de forma independente (livremente) da palavra α 2, dito de outra forma, α 1 não incide em α 2 e reciprocamente.

8 Lembrete E ::= E + E Dada a gramática E ::= E * E E ::= x Apresentamos a seguir duas derivações esquerda e duas árvores de derivação de x+x*x (que demonstram da ambiguidade da gramática considerada). E = E + E = x + E = x + E E = x + x E = x + x x E = E E = E + E E = x + E E = x + x E = x + x x

9 Lembrete Uma gramática é ambígua se existir uma palavra reconhecida por pelo menos duas árvores de derivação. Caso contrário diz-se que a gramática é não-ambígua. As linguagens geradas por gramáticas livres de contexto coincidem exactamente com as linguagens reconhecidas por autómatos com pilhas (pushdown automata). {a n b n n N} é livre de contexto mas já não é o caso de {a n b n c n n N} (neste último caso é preciso memorizar n uma vez e utiliza-lo duas vezes. Isto não é possível com uma única pilha) o primeiro exemplo corresponde a gramática com as produções seguintes: S ::= asb e S ::= ɛ

10 Lembrete Decidabilidade e Gramática: Não é decidível saber se uma gramática livre de contexto é ambígua duas gramáticas livres de contexto são equivalentes (reconhecem a mesma linguagem) se a intersecção de duas gramáticas livres de contexto é vazia ou ascendente: Analisar uma palavra = estabelecer se uma palavra pertence ou não a linguagem gerada pela gramática considerada. Em prática: reconhecer = construir uma árvore de derivação. Construção da raíz para as folhas: Analise Descendente (em particular analise LL) Construção das folhas para a raíz: Analise Ascendente (em particular analise LR)

11 Plano

12 Definição do Autómato com Pilha Reconhecer linguagens regulares = autómatos finitos Reconhecer linguagens livres de contexto = autómatos com pilha Num autómato finito, numa transição entre dois estados como por exemplo: 1 a 2, passar de 1 para 2 basta que a entrada forneça um a. Num autómato com pilha, a diferença é que a transição é executada tendo em conta igualmente um histórico das sequências de caracteres já analisados: pilha = histórico

13 Definição do Autómato com Pilha Conjunto dos estados: Q Estado inicial: q 0 Q Estados finais: F Q Histórico/pilha: Q + Função/relação de transição: Q + (A {ɛ}) Q Princípio: A cada estado está associada uma palavra de Q + : a pilha. Uma transição = uma transformação no topo da pilha Consideremos a transição por x de m 1 Q + para m 2 Q (notação m 1 m 2), então queremos que qualquer que seja a pilha com prefixo m 1, digamos mm 1, fosse possível utilizar esta transição de cada vez que a x entrada apresente x. Notação mm 1 mm2 Extendemos às palavras de (A {ɛ}). Se m 1 ω 1 m 2 e m 2 ω 2 m 3 então m 1 ω 1 ω 2 m 3

14 Definição do Autómato com Pilha ω Uma palavra ω é reconhecida por um autómato com pilha se q 0 mf com f F no topo da pilha. Um autómato com pilha é determinista se e só se m 1m 2m 1m 2 Q e a, a a (A {ɛ}), se (m 1 m 2), (m 1 a m 2) e m 1 prefixo de m 1 então ambos reduzem para a mesma configuração ou seja temos necessariamente m 1 = m 1, m2 = m 2 e a = a (não há divergência possível).

15 Construção dum autómato com pilha a partir duma CFG Seja G = (N, T, S, P) uma gramática livre de contexto. Vamos considerar todos os pares possíveis (Y, α, β), designados de item, tais que Y N, α, β (N T ) e (Y ::= αβ) P. Notação [Y α.β] Alguns itens particulares: Se α = ɛ, [Y.β] Se β = ɛ, [Y α.] Este item é designado de completo Se α = β = ɛ, [Y.]

16 Construção dum autómato com pilha a partir duma CFG Para construir o autómato com pilha correspondente introduzimos, se necessário, um novo símbolo inicial S e a regra S S. (Necessário se e a gramática não tiver esta configuração). O símbolo significa: marca de fim de buffer de entrada (ou ainda: fim de analise, fim de ficheiro etc...). Assim o buffer de entrada deverá considerar como último símbolo o símbolo. Por exemplo: Dada a gramática Conjunto dos itens: E ::= E + E E ::= E * E E ::= x Nova versão : S ::= E E ::= E + E E ::= E * E E ::= x S ::=. E E ::=. E + E E ::=. E E E ::=. x S ::= E. E ::= E. + E E ::= E. E E ::= x. S ::= E. E ::= E +. E E ::= E. E E ::= E + E. E ::= E E.

17 Construção dum autómato com pilha a partir duma CFG Tendo uma gramática G = (T, N, S, P), o autómato com pilha define-se então da seguinte forma: Alfabeto: T. Estados: Conjunto dos itens associado à gramática G. Transições: T {ɛ}. Estado inicial: S.S Significa: Preparada para iniciar o reconhecimento duma frase gerada por S Estado final (único): S S. Significa: Uma frase gerada por S foi reconhecido e a marca de fim de analise foi atingida. Transições: 3 tipos de transição Expansão. Para cada Y ::= α de P (lembrete: α (N T ) ). ɛ [X β. Y γ] [X β. Y γ][y. α] Leitura de a T. a [X β. aγ] [X βa. γ] Redução da regra Y ::= α. ɛ [X β. Y γ][y α. ] [X βy. γ]

18 Exemplo Reconhecimento de aabb pela gramática S ::= asb S ::= ɛ start [S. S ] expansão S ::= asb [S. S ][S. asb] leitura a [S. S ][S a. Sb] expansão S ::= asb [S. S ][S a. Sb][S. asb] leitura a [S. S ][S a. Sb][S a. Sb] expansão S ::= ɛ [S. S ][S a. Sb][S a. Sb][S.] redução [S. S ][S a. Sb][S as. b] leitura b [S. S ][S a. Sb][S asb.] redução [S. S ][S as. b] leitura b [S. S ][S asb.] redução [S S. ] leitura [S S. ]

19 Exercício Definir um reconhecimento de id + id id com base no autómato com pilha subjacente a gramática seguinte: E ::= T E + T T ::= F T F F ::= id (E)

20 A Situação Este processo consegue lidar com todas as gramática livres de contexto, mas os autómatos gerados por este métodos são enormes. e são igualmente não-deterministas. De facto, numa execução do autómato podemos: guardar o registo das transições expansão e construir uma derivação esquerda Ou, guardar o registo das transições redução e reconstruir uma derivação direita. Em termos algorítmicos, um reconhecimento sintáctico baseado neste processo é completo mas particularmente ineficiente. Que soluções? Visar um subconjunto das gramáticas livres de contexto representativo sobre o qual outros tipos de algoritmos de reconhecimento mais eficientes possam ser definidos: as gramáticas LL e LR.

21 Plano

22 A situação Problema: Tendo em conta o não determinismo do autómato com pilha, como escolher uma regra de expansão? Uma solução possível: Olhar para o buffer de entrada um ou mais caracteres a frente. Contexto: Tomemos por exemplo as produções Y ::= α 1 α 2... α n. Se cada α i começar de forma distinta dos outros α j (i j) então ao ler um caracter a sabemos imediatamente que regras escolher: a regra Y ::= α k com α k = a (a na primeira posição).

23 Um exemplo 1 S ::= A d S 3 A ::= a A b 2 S ::= b 4 A ::= c Vamos analisar a situação mais cuidadosamente. Imaginemos que estamos numa situação em que pretendemos derivar algo de S. Se a entrada começar por a ou c então a única hipótese é escolher a regra 1. Se a entrada começar por b então a única possibilidade é escolher a regra 2 Qualquer outra entrada não pode reconhecida por S. Relativamente a A. Se a entrada for a então podemos escolher a 3 ra regra. Se a entrada for c então podemos escolher a 4 ta regra. Qualquer outra entrada não pode reconhecida por A.

24 Um exemplo 1 S ::= A d S 2 S ::= b 3 A ::= a A b 4 A ::= c Esta gramática tem então a particularidade de permitir escolher de forma certa a produção para a derivação, e isto com base na antevisão de um só caracter na entrada. Ou seja, com tal gramática a analise sintáctica é facilitada: em cada situação sabemos exactamente o que fazer entre escolher leituras, expansões de determinadas regras ou reduções.

25 Um exemplo 1 S ::= A d S 3 A ::= a A b 2 S ::= b 4 A ::= c Um exemplo: derivação da palavra acbdb (a qual juntamos para representar o fim de entrada): Estado antevisão da entrada decisão e acção 0 [.S ] Início 1 [.S ] a expansão regra 1 2 [.S ][.A d S] a expansão regra 3 3 [.S ][.A d S][.a A b] a leitura a 4 [.S ][.A d S][a. A b] c expansão regra 4 5 [.S ][.A d S][a. A b][.c] c leitura c 6 [.S ][.A d S][a. A b][c.] b redução regra 4 7 [.S ][.A d S][aA. b] b leitura b 8 [.S ][.A d S][a A b.] d redução da regra 3 9 [.S ][A. d S] d leitura d 10 [.S ][A d. S] b expansão regra 2 11 [.S ][A d. S][.b] b leitura b 12 [.S ][A d. S][b.] redução da regra 2 13 [.S ][A d S.] redução da regra 1 14 [S. ] leitura 15 [S.] ɛ sucesso Esta analise corresponde a derivação esquerda seguinte: S = S = AdS = aabds = acbds = acbdb

26 Um exemplo E se juntarmos mais uma regra? 1 S ::= A d S 2 S ::= b 3 A ::= a A b 4 A ::= c 5 A ::= ɛ O facto de A poder derivar o ɛ obriga aqui a um cuidado especial: temos de olhar para além de A para saber que regra escolher: Relativamente a S. Se a entrada começar por a, c ou d então a única hipótese é escolher a regra 1. Se a entrada começar por b então a única possibilidade é escolher a regra 2 Qualquer outra entrada não pode reconhecida por S. Relativamente a A. Se a entrada for a então podemos escolher a 3 ra regra. Se a entrada for c então podemos escolher a 4 ta regra. Se a entrada for b ou d então podemos escolher a 5 ta regra.

27 Exemplo: Conclusão por tirar Para poder ter uma analise sintáctica nestes moldes é preciso conseguir determinar para toda a palavra m de (N T ) (em particular não-terminais) se esta pode derivar a palavra vazia, que conjunto de caracteres (letras de T ) apareçam em primeira posição das palavras geradas por m e finalmente que conjunto de caracteres terminais apareçam em primeira posição a seguir a qualquer palavra gerada por m. Estes dados permitirão construir um analisador (descendente) eficiente e determinístico.

28 Como funciona a análise descendente geral Tendo uma tabela de transição Tr que, por cada não terminal Y e para cada palavra m por reconhecer devolve, se possível, o lado direito (rhs) duma produção aplicável Tr(Y, m) que permite um passo no reconhecimento de m. Construímos então o autómato com pilha da forma seguinte pilha: uma palavra p de (N T ). Enquanto este não for olhamos para o tipo da pilha. No estado inicial p = S Se o terminal a estiver no topo da pilha então efectuamos a transição a a ɛ. Ou seja a leitura de a (a é assim consumido e retirado da pilha). Se o topo da pilha for um não-terminal X então procuramos uma produção X ::= β tal que Tr(X, m) = β e então efectuamos a transição X ɛ β e colocamos todos os caracteres de β na pilha de tal forma que o primeiro caracter de β fique no topo da pilha.

29 Analise do método geral Em termos teóricos: a automatização deste processo obriga a exploração de toda a entrada por analisar. Ou seja a escolha da transição depende da palavra analisada. O conjunto das palavras por analisar é virtualmente infinito. Em termos práticos: muito dispendioso em termos de recurso Solução: limitar o tamanho da palavra na tabela de transição. Basta limita-las a um comprimento de dois ou até de um. por exemplo no exemplo anterior, um só caracter de antevisão era suficiente para determinar por completo a escolha das transições em qualquer situação. As gramáticas LL(k) que vamos explorar permitam construir tabelas de transição que só consideram a antevisão de k caracteres da entrada para permitir uma decisão. LL(k) = Left-to-right parse, Leftmost-derivation k-symbol lookahead.

30 Analizadores LL(k) imaginemos que temos a função rhs que aceite em parâmetro um não-terminal e uma palavra e que devolva a parte direita da regra de produção por aplicar. Esta função é o elemento chave do procedimento que vamos passar a descrever. Baseia-se integralmente na existência da tabela de transição Tr. Assumimos aqui a sua existência. Neste contexto é relativamente simples escrever um analisador sintáctico sem ter de utilizar o autómato de pilhas associado a gramática. Ideia de base: definir para cada não terminal X uma função f X que aceite em entrada a string m por analisar e devolve a palavra m tal que existe uma palavra p tal que m = pm X = p. De facto tal função f X consome a parte da palavra m que consegue ser reconhecida por X (ou seja uma sub-palavra de m que é derivável/reconhecida por X ) Todas as funções f X utilizam a função auxiliar recognize que dados uma palavra β de (N T ) e uma entrada m devolve a palavra m tal que m = pm β = p

31 Implementação função f X (m) = seja β = rhs(x, m) em recognize(β, m) função recognize(β, m) = se β = ɛ então m senão seja a = head(β) β = tail(β) em se a T então se a = head(m) então recognize(β, tail(m)) senão erro senão ( a N ) seja m = f a(m) em recognize(β, m )

32 Implementação Veremos a seguir como construir uma tabela de transição sobre a qual a implementação da função rhs se apoia trivialmente. A análise de m é bem sucedida se f S (m) devolve a palavra vazia (ou se o inserimos na entrada como símbolo de fim de entrada).

33 Gestão dos erros Como as gramáticas que aqui consideramos são reduzidas, um erro é detectado no local exacto onde este ocorre. Seja m 1 a palavra lida com sucesso até ao momento do erro. então existe um m 2 tal que m 1m 2 seja reconhecida pela gramática. Este m 2 existe necessariamente, visto a gramática ser produtiva. Aproveitando este facto um gestor de erros pode consumir m2 até encontrar um caracter espacial (como ; end etc.) e permitir que a analise volte a decorrer normalmente a partir daí. assim 1 fase de compilação = vários erros detectados.

34 Conceito Nas analises descendentes procuramos métodos eficientes de procura de derivações do símbolo inicial até a palavra analisada (arvore de derivação construída da raíz para as folhas). Aqui pretendemos definir um método eficiente de construção da função rhs ou seja da tabela de transição Tr. O critério de eficiência leva nos a limitar o campo de antevisão inerente a tabela de transição. O nosso focus aqui: LL(1) = um caracter de antevisão. Quando X ::= β é candidata para uma expansão (como transição a aplicar na derivação) temos a situação seguinte: o caracter de entrada tem de ser o primeiro caracter derivável de X ou o primeiro caracter que segue X (se X deriva ɛ).

35 Null, Prim, Seg: Definição Null : (N T ) Bool { true if α = ɛ α false otherwise Ou seja, Null(α) é verdade se α pode derivar a palavra vazia. Prim : (N T ) P(T ) α {a T m T.α = am} Ou seja, Prim(α) devolve o conjunto dos caracteres (terminais) que podem ocorrer na primeira posição das palavras derivadas a partir de α. Temos igualmente Prim(ɛ) = Seg : N P(T ) X γ (N T ), β.s = βx γ Prim(γ). Ou seja, Seg(X ) devolve o conjunto das letras (terminais) que podem seguir imediatamente qualquer palavra derivada de X.

36 Null, Prim, Seg Estas definições permitam calcular a tabela de transição, logo a função rhs e assim completar a escrita dum analisador descendente (aqui LL(1)). Mas para de tal é preciso determinar algoritmicamente os conjuntos subjacentes a estas três definições. Vamos ver que se calculam como pontos fixos. Princípio da técnica de procura de ponto fixo: Proceder por etapas. Cada etapa recebe o resultado da etapa anterior (excepto a primeira). Assim o objectivo de cada etapa é refinar este resultado e fornecê-la a etapa seguinte. É assim preciso fornecer um valor inicial ao processo: a etapa 0. Visto deste modo o resultado pretendido é gradualmente obtido e o processo para quando a sucessão de etapa não produz mais nenhuma novidade. Dizemos que este resultado é o ponto fixo do processo de procura que termina assim neste ponto.

37 Null Qualquer que seja a palavra α, se α contém um terminal então necessariamente Null(α) = false. Logo as únicas palavras de (N T ) que podem potencialmente derivar ɛ são palavras de N. Assim, o primeiro passo é determinar que não-terminais (elementos de de N) derivam a palavra vazia. Genericamente, a ideia subjacente é: X ( N) deriva a palavra vazia ɛ se e só se existe uma produção X ::= ɛ ou X ::= X 1X 2... X n tal que X 1... X n derivam todos eles a palavra vazia. Vamos de seguida precisar esta ideia e definir um conjunto de equações para os não-terminais de N.

38 Null Para um não-terminal X de N, sejam β 1... β n o conjunto de todas as palavras de (N T ) tais que X ::= β i, (1 i n) seja uma produção. Então Null(X ) = Null(β 1) Null(β 2)... Null(β n). Vamos agora debruçar-nos sobre o valor individual dos Null(β i ): Caso β i = ɛ. Null(ɛ) = true Caso β i = X 1 X 2... X n. Null(X 1 X 2... X n ) = Null(X 1 )... Null(X n ). Caso β i ((N T ) N ). Null(β i ) = false

39 Null Como as produções (logo, as equações) podem ser recursivas temos de proceder por iteração. Vamos construir uma tabela T NULL onde as linhas são os não-terminais da gramática e as colunas as iterações do algoritmo. Assim, T NULL (X, i) representa o valor de Null(X ) na etapa i do processo de cálculo. Para começar, determinar para cada não terminal X a equação Null que lhe corresponde.

40 Null O processo de procura de ponto fixo define-se da seguinte forma: Etapa 0. Todos os não-terminais são marcados como não gerando ɛ (ou seja X N, T NULL (X, 0) = false) Etapa i + 1. Verificamos se existem não-terminais X com produção X ::= ɛ que ainda não foram marcadas como gerando ɛ na etapa i anterior. Neste caso T NULL (X, i + 1) = true. Se existir regras da forma X ::= X 1X 2... X n tais que X 1... X n são marcados como derivando ɛ na etapa i, ou seja j N, 1 j n, T NULL (X j, i) = true, então marcamos X como derivando a palavra vazia T NULL (X, i + 1) = true. Este processo acaba quando encontramos um ponto fixo, ou seja quando pela primeira vez repetimos uma coluna. O valor desta coluna (que é o ponto fixo procurado) representa o valor final de Null.

41 Exemplo 1 E ::= T E 2 E ::= + T E 3 E ::= ɛ 4 T ::= F T 5 T ::= F T 6 T ::= ɛ 7 F ::= id 8 F ::= ( E ) As regras 2, 5, 7 e 8 nunca vão gerar a palavra vazia. As regras 3 e 6 derivam explicitamente a palavra vazia As regras 1 e 4 derivam potencialmente a palavra vazia. Mas veremos já com a tabela T NULL que nunca derivarão ɛ devido ao facto de F e de T não derivarem ɛ.

42 Exemplo 1 E ::= T E 2 E ::= + T E 3 E ::= ɛ 4 T ::= F T 5 T ::= F T 6 T ::= ɛ 7 F ::= id 8 F ::= ( E ) Null(E) = Null(T E ) = Null(T) Null(E ) Null(E ) = Null(+ T E ) Null(ɛ) = false true = true Null(T ) = Null(F T ) = Null(F) Null(T ) Null(T ) = Null( F T ) Null(ɛ) = false true = true Null(F ) = Null(id) Null( ( E ) ) = false false = false

43 Exemplo 1 E ::= T E 2 E ::= + T E 3 E ::= ɛ 4 T ::= F T 5 T ::= F T 6 T ::= ɛ 7 F ::= id 8 F ::= ( E ) Como funciona o processo iterativo? Por exemplo: calcular Null(E) = Null(T ) Null(E ) na etapa i + 1 Olhar para os valores de Null(T ) e de Null(E ) na etapa i, digamos a e b. Então na etapa i + 1, Null(E) = a b

44 Exemplo 1 E ::= T E 2 E ::= + T E 3 E ::= ɛ 4 T ::= F T 5 T ::= F T 6 T ::= ɛ 7 F ::= id 8 F ::= ( E ) T NULL E false Null(T ) Null(E ) = false false E false true true T false Null(F ) Null(T ) = false false T false true true F false false false FIM

45 Exemplo 1 S ::= A B C 2 S ::= d S 3 A ::= B C 4 A ::= a A 5 B ::= C 6 B ::= b B 7 C ::= ɛ 8 C ::= c C Legenda: true = false = T NULL S A B C FIM Na etapa 1 C é marcado como verdade com base no passo 1 (devido a produção 7). Na etapa 2, B é marcado como true com base no passo 2 (devido a produção 5). Na etapa 3, A é marcado como true com base no passo 2 (devido a produção 3). etc...

46 Prim Seja α uma palavra de (N T ). Então α tem a forma seguinte α = m 1X 1m 2X 2... m nx nm n+1 (os m i s são palavras de T e os X j não-terminais) O calculo de Prim(α) baseia-se sobre a natureza de m 1. 1 se m 1 ɛ então Prim(m 1 X 1... X n m n+1 ) = {a} onde a é o primeiro caracter de m 1. 2 se m 1 = ɛ então Prim(m 1 X 1... X n m n+1 ) = Prim(X 1... X n m n+1 ). 1 se Null(X 1) = true então Prim(X 1... X nm n+1) = Prim(X 1) Prim(m 2X 3... X nm n+1) 2 senão (Null(X 1) = false) Prim(X 1... X nm n+1) = Prim(X 1) Para os não-terminais: para todo o X N, Prim(X ) = X ::=γ Prim(γ) Prim(ɛ) =

47 Prim Para calcular o conjunto Prim vamos igualmente proceder por iteração sobre uma tabela até encontrar um ponto fixo. Determinar para cada não terminal X a equação Prim que lhe corresponde. O processo vai construir uma tabela T PRIM em que as linhas são não terminais e as colunas as etapas do processo. Aplicar o algoritmo de procura de ponto fixo seguinte: Etapa 0. Todos os não terminais tem como conjunto de primeiros caracteres o conjunto vazio. Etapa i + 1: Actualizamos os conjuntos com base nas equações e os conjuntos obtidos na etapa i anterior.

48 Exemplo 1 E ::= T E 2 E ::= + T E 3 E ::= ɛ 4 T ::= F T 5 T ::= F T 6 T ::= ɛ 7 F ::= id 8 F ::= ( E ) Prim(E) = Prim(T E ) = Prim(T), (porque Null(T ) = false) Prim(E ) = Prim(+ T E ) Prim(ɛ) = {+} Prim(T ) = Prim(F T ) = Prim(F), (porque Null(F ) = false) Prim(T ) = Prim( F T ) Prim(ɛ) = { } Prim(F ) = Prim(id) Prim( ( E ) ) = {id, (}

49 Exemplo 1 E ::= T E 2 E ::= + T E 3 E ::= ɛ 4 T ::= F T 5 T ::= F T 6 T ::= ɛ 7 F ::= id 8 F ::= ( E ) T PRIM E Prim(T ) = Prim(T ) = Prim(T ) = {id, (} Prim(T ) = {id, (} E {+} {+} {+} {+} T Prim(F ) = Prim(F ) = {id, (} Prim(F ) = {id, (} Prim(F ) = {id, (} T { } { } { } { } F {id, (} {id, (} {id, (} {id, (} FIM

50 Seg Para o calculo de Seg(X ), X N, vamos ter em conta o símbolo terminal que fará sempre parte do conjunto Seg do símbolo inicial S (ou seja Seg(S)). Temos: Seg(X ) = ( Y ::=αx β (Prim(β))) ( Y ::=αx β Null(β) Seg(Y )) O primeiro passo da procura dos conjuntos Seg é estabelecer para cada não-terminal a equação a qual o seu conjunto Seg obedece. Mais uma vez vamos proceder por iteração sobre uma tabela T SEG até chegar a um ponto fixo. Etapa 0: todos os símbolos de N tem por conjunto Seg o conjunto vazio excepto o símbolo inicial S. Seg(S) = { } Etapa i + 1: Actualizamos os diferentes conjuntos Seg de acordo com os conjuntos calculados na etapa i.

51 Exemplo 1 E ::= T E 2 E ::= + T E 3 E ::= ɛ 4 T ::= F T 5 T ::= F T 6 T ::= ɛ 7 F ::= id 8 F ::= ( E ) Seg(E) = { } Prim( ) ) = {, )} Seg(E ) = (Prim(ɛ) Prim(ɛ)) Seg(E) Seg(E ) = Seg(E) Seg(E ) Seg(T ) = Prim(E ) Seg(E) Seg(E ) = {+} Seg(E) Seg(E ) Seg(T ) = (Prim(ɛ) Prim(ɛ)) Seg(T ) Seg(T ) = Seg(T) Seg(T ) Seg(F ) = Prim(T ) Prim(T ) Seg(T ) seg(t ) = { } Seg(T) seg(t )

52 Exemplo 1 E ::= T E 2 E ::= + T E 3 E ::= ɛ 4 T ::= F T 5 T ::= F T 6 T ::= ɛ 7 F ::= id 8 F ::= ( E ) T SEG E { } {, ) } {, ) } {, ) } {, ) } E Seg(E) Seg(E ) = { } {, ) } {, ) } {, ) } T {+} Seg(E) Seg(E ) = {, +} {, ), +} {, ), +} {, ), +} T Seg(T ) Seg(T ) = {, +} {, ), +} {, ), +} F { } Seg(T ) seg(t ) = { } {, +, } {, ), +, } {, ), +, } FIM

53 Exercício Calcular os conjuntos Prim e Seg para a gramática seguinte: 1 S ::= A B C 2 S ::= d S 3 A ::= B C 4 A ::= a A 5 B ::= C 6 B ::= b B 7 C ::= ɛ 8 C ::= c C

54 Construção da Tabela de Transição As construções que vimos até agora tinham como objectivo permitir a construção da tabela de transição. De facto, tendo a tabela de transição Tr a implementação de analisadores sintácticos descendentes é fácil. Pretendemos construir uma tabela Tr : N T k (no caso dos analisadores LL(1) que aqui descrevemos, k = 1) tal que Tr(A, a 1a 2... a k ) nos indique que expansão efectuar (que produção escolher) tendo em conta o não-terminal A e os k primeiros caracteres da entrada.

55 Construção da Tabela de Transição Consideremos aqui o caso k = 1. Vamos proceder assim: Para cada regra de produção A ::= α 1 Para cada terminal a de Prim(α) acrescentamos α em Tr(A, a) 2 Se Null(α) então acrescentamos α em todas as células Tr(A, b) tais que (b T b = ) b Seg(A) Qualquer célula que ficar vazia indica uma situação de erro. A função rhs tem então uma definição trivial: sejam x um não-terminal e m k os k primeiros caracteres duma palavra m, rhs(x, m) = Tr(X, m k )

56 Gramática LL(1) Uma gramática é LL(1) quando só existe no máximo uma entrada em qualquer célula de Tr com base na tabela de transição e nas funções f X (X N), recognize e rhs, o analisador lê a palavra de entrada da esquerda para a direita e constrói uma árvore de derivação sustentada por uma derivação esquerda.

57 Exemplo id ( ) + E T E T E E ɛ + T E ɛ T F T F T T ɛ ɛ F T ɛ F id ( E )

58 Exercício Construir a tabela de transição para a gramática: 1 S ::= A B C 2 S ::= d S 3 A ::= B C 4 A ::= a A 5 B ::= C 6 B ::= b B 7 C ::= ɛ 8 C ::= c C

59 Exemplo de gramática que não é LL(1) S ::= d Y ::= ɛ X ::= Y S ::= X Y S Y ::= c X ::= a Null Prim Seg X a c a c d Y c a c d S a c d a c d S XYS XYS (XYS) (d) X (a) (Y ) Y Y Y ɛ (ɛ) (c) ɛ

60 Como caracterizar gramáticas LL(1) Já sabemos que são gramáticas que permitam uma analise descendente eficiente e simples Sabemos igualmente LL(1) uma entrada no máximo em cada célula da tabela de transição mas não haverá uma forma informal ou intuitiva de caracterizar tais gramáticas? Sim: É possível prever, sempre, que regra escolher só com base nos k primeiros caracteres. Ou seja, para k = 1 e um não-terminal A tal que A ::= α 1 α 2... α n e para i e j distintos : 1 no máximo um dos α i é tal que Null(α i ) = true 2 Prim(α i ) Prim(α j ) = 3 i.null(α i ) = j.prim(α j ) Seg(A) =

61 Exemplo completo T ::= F T E ::= T E F ::= id T ::= F T F ::= num E ::= +T E T ::= /FT F ::= ( E ) E ::= T E T ::= ɛ E ::= ɛ Null Prim Seg E ( id num ) E + ) T ( id num ) + T / ) + F ( id num ) + / + / id num ( ) E TE TE TE E +TE TE ɛ ɛ T FT FT FT T ɛ ɛ FT /FT ɛ ɛ F id num ( E )

62 Plano Eliminar a Recursividade Esquerda Factorizar a Esquerda Eliminar a Recursividade Esquerda Factorizar a Esquerda

63 Eliminar a Recursividade Esquerda Factorizar a Esquerda Transformar Gramáticas CFG em Gramáticas LL(1) Já sabemos: nem todas as gramáticas CFG são LL(1). Será possível obter uma gramática LL(1) a partir duma gramática CFG? Nem sempre, mas possível em geral. Existam situações standard que são sintomas de gramáticas não-ll(1): recursividade esquerda e falta de factorização esquerda. Veremos algoritmos que permitam a resolução de tais situações. Suficiente? Em geral, não. Completar a transformação da gramática consoante diagnósticos feitas às anomalias presentes na tabela de transição (soluções Ad-Hoc). Por exemplo a redução da gramatica por remoção de não-terminais.

64 O que é a Recursividade Esquerda? Eliminar a Recursividade Esquerda Factorizar a Esquerda Uma gramática é recursiva esquerda se existir uma derivação tal X = + X α Uma gramática recursiva esquerda não pode ser LL(1) Se pretendemos obter uma gramática LL(1) então é preciso eliminar a recursividade esquerda.

65 Eliminar a Recursividade Esquerda Factorizar a Esquerda Remover a recursividade esquerda directa Situação: A ::= A α 1 A α 2 A α n A ::= β 1 β 2 β m Os β i não começam por A transformar em A ::= β 1 A β 2 A β m A A ::= α 1 A α 2 A α n A A ::= ɛ Caso particular: caso surge regras do tipo A ::= A, estas regras podem ser removidas.

66 Eliminar a Recursividade Esquerda Factorizar a Esquerda Remoção da Recursividade Esquerda Indirecta Consideremos esta gramática: S + = S d a S ::= A a S ::= b A ::= A c A ::= S d Como proceder para remover esta recursividade esquerda?

67 Eliminar a Recursividade Esquerda Factorizar a Esquerda Remoção da Recursividade Esquerda Indirecta Organizar os não-terminais de 1 a n (no caso de N = n): A 1, A 2,..., A n. Mas: ordem escolhida tem a sua importância! Preferir atribuir os índices menores aos não-terminais do fundo da gramática e o índice final ao símbolo inicial. Processo em n etapas: etapa 1: Eliminar a recursividade directa de A 1 etapa i: enquanto existir uma produção A i ::= A j α (com i > j) olhar para todas as produções tais que A j ::= β e substituir A i ::= A j α por A i ::= βα retirar então a recursividade esquerda directa (quando i = j). No final, se β começa por um A k então necessariamente k > i. O processo iterativo anterior só acaba quando temos produções A i ::= A j α tal que i < j

68 Exemplo Eliminar a Recursividade Esquerda Factorizar a Esquerda Ordem: S, A (contrária a sugestão feita...) S ::= A a S ::= b A ::= A c A ::= S d Comecemos por S: S ::= A a S ::= b Para A substituímos A a e b em A ::= S d, logo: A ::= A c A ::= A a d A ::= b d Podemos então eliminar a recursividade esquerda directa: A ::= b d A A ::= a d A A ::= c A A ::= ɛ

69 Factorizações a Esquerda Eliminar a Recursividade Esquerda Factorizar a Esquerda Conflito por prefixo comum A ::= αβ 1 A ::= αβ 2. A ::= αβ n Neste caso transformar tais regras em: A ::= αa A ::= β 1 A ::= β 2. A ::= β n Remoção prévia de Não-Terminais Pode acontecer que duas produções dum não terminal Y tenham conjuntos Prim não disjuntos sem no entanto apresentarem explicitamente prefixo comum. Pode assim ser interessante tentar explicitar estes prefixos e proceder a transformação anterior. Y ::= βx γ (X Y ) Neste caso substituir tal regra pelas regras: Y ::= βαγ para todo α tal que (X ::= α) P. Proceder então à factorização esquerda caso necessário.

70 Exercício Eliminar a Recursividade Esquerda Factorizar a Esquerda Transforme a gramática seguinte numa gramática LL(1): 1 S ::= A B C 2 S ::= d S 3 A ::= B C 4 A ::= a A 5 B ::= C 6 B ::= b B 7 C ::= ɛ 8 C ::= c C

71 Eliminar a Recursividade Esquerda Factorizar a Esquerda Considerações finais sobre Gramáticas LL(1) (+) Analisadores simples de escrever (-) As gramáticas LL(1) não são naturais (distantes das gramáticas de papel e caneta ) (-) Nem todas as gramáticas livres de contexto se traduzem facilmente em gramáticas LL(1). Em alguns casos é mesmo impossível. Por exemplo: S ::= A A ::= a A b B ::= a B b b S ::= B A ::= 0 B ::= 1 As tabelas de transição para as gramáticas LL(k) com k 1 crescem muito rapidamente e tornam estas analises pesadas.

72 Análise sintactica LL(1) em Ocaml Eliminar a Recursividade Esquerda Factorizar a Esquerda Leitura e manipulaç~ao de express~oes lógicas simples com streams Este método de leitura implementa um lexer/parser descendente para a gramática LL(1) das express~oes lógicas seguinte (N -> {TRUE, FALSE}, V -> Variáveis): E ::= T E E ::= -> T E E ::= <-> T E E ::= \epsilon T ::= F T T ::= & F T T ::= F T T ::= \epsilon F ::= N F ::= V F ::=! E F ::= ( E )

73 Análise sintactica LL(1) em Ocaml Eliminar a Recursividade Esquerda Factorizar a Esquerda let lexer = make_lexer ["("; ")"; "<->"; "->"; " "; "&" ; "!"; "TRUE"; "FALSE"] (*val parse_expr : Genlex.token stream -> unit *) let rec parse_expr = parser (* corresponde a entrada E da gramatica *) [< parse_conj; parse_more_imps >] -> () and parse_more_imps = parser (* corresponde a entrada E da gramatica *) [< Kwd "->"; parse_conj; parse_more_imps >] -> () [< Kwd "<->"; parse_conj;parse_more_imps >] -> () [< >] -> () and parse_conj = parser (* corresponde a entrada T da gramatica *) [< parse_simple; parse_more_conjs >] -> () and parse_more_conjs = parser (* corresponde a entrada T da gramatica *) [< Kwd "&"; parse_simple; parse_more_conjs >] -> () [< Kwd " "; parse_simple; parse_more_conjs >] -> () [< >] -> () and parse_simple = parser (* corresponde a entrada F da gramatica *) [< Ident s >] -> () [< Kwd "TRUE" >] -> () [< Kwd "FALSE" >] -> () [< Kwd "!"; parse_expr >] -> () [< Kwd "("; parse_expr; Kwd ")" >] -> () let parse_expression = parser [< parse_expr; _ = Stream.empty >] -> ()