Compiladores FIC– Ciência da Computação Professor: Ciro Meneses Santos Bibliografia: ---------------- AHO, Alfred V. et al. Compiladores. Princípios, Técnicas e Ferramentas. Rio de Janeiro: LTC Editora, 1995. LOUDEN, Kenneth C. – Compiladores. Princípios é Práticas, Thomson, 2004 GRUNE, Dick et al. Projeto Moderno de Compiladores: Implementação e Aplicações. Rio de Janeiro: Campus, 2001.

Analisador Sintático button-up Analisador de Empilhar e reduzir (shift/reduce) A análise gramatical de empilhar e reduzir tenta construir uma árvore gramátical para uma cadeia de entrada comecando pelas folhas (o fundo) e trabalhando árvore acima em direção à raiz (o topo). Podemos pensar neste processo como o de reduzir uma cadeia w ao símbolo de partida de uma gramática. A cada passo de redução, uma subcadeia particular, que reconheça o lado direito de uma produçãon é substituida pelo símbolo à esquerda daquela produção e, se a subcadeia tiver sido escolhida corretamente a cada passo, uma derivação mais à direita terá sido rastreada na ordem invesa.

Handles Um handle é uma subcadeia que reconhece o lado direito de uma produção e cuja redução ao não-terminal do lado esquerdo da produção representa um passo ao longo do percurso de uma derivação mais à direita. Em muitos casos, a subcadeia  mais à esquerda que reconhece o lado direito de uma produção A   não é um handle porque uma redução pela produção A   produz uma cadeia que não pode ser reduzida ao símbolo de partica. Empilha um simbolo do topo da entrada para o topo da pilha. Reduz uma cadeia  do topo da pilha para um não-terminal A, para a regra A  

Handles Existem dois problemas que precisam ser resolvidos: Localizar a subcadeia a ser reduzida numa forma sentencial à direita Determinar que produção escolher no caso de existir mais de uma produção com aquela subcadeia no lado direito. (R1) S  aABe (R2) A  Abc (R3) A  b (R4) B  d abbcde aAbcde (R3) aAde (R2) aABe (R4) S (R1) abbcbcde aAbcbcde (R3) aAbcde (R2) aAde (R2) aABe (R4) S (R1)

Handles Expressão Handle Produção id + id * id id E  id E + E* id (R1) E  E + E (R2) E  E * E (R3) E  (E) (R4) E  id Expressão Handle Produção id + id * id id E  id E + E* id E * id E + E E  E + E E * E E E  E * E

Handles Pilha Entrada Produção $ id + id * id$ Empilha id $id Reduz E  id $E Empilha + $E + id * id$ $E + id * id$ $E + E Reduz E  E + E Empilha * $E * id$ $E * id $E * E Reduz E  E * E Aceita

Conflitos Existem gramática livres de contexto para os quias a analise de empilhar e reduzir não podem ser usado. O A.S. Empilhar e Reduzir para certa gramática, pode atingir uma confirguração na qual, mesmo conhecendo o conteúdo de toda a pilha e o próximo simbolo de entrada onde : Não pode decidir entre empilar ou reduzir (um conflito empilhar/reduzir). Não pode decidir qual das diversas reduções alternativas realizar (conflito reduzir/reduzir).

Empilhar / Reduzir Considere a gramática G1, Aqui há um conflito shift/reduce. Dependendo do que venhe após o simbolo e na entrada., poderia ser correto reduzir i E t S para S ou empilhar o simbolo e, em seguida procurar por outro S para completar a alternativa. Pilha --------------------------- $ i $ i E $ i E t $ i E t S | shift/reduce $ i E t S | S  i E t S $ i E t S e $ i E t S e S (R1) S  i E t S (R2) S  i E t S e S (R3) S  a (R4) E  b O yacc continua empilhando Decisão por empilhar.

Reduzir / Reduzir Considere a gramática G2, Aqui há um conflito reduce/reduce. Sempre que id estiver no topo da pilha ele deve ser reduzido, mas para que produção? A escolha correta depende do contesto. Pilha --------------------------- $ id Empilha $ X Reduz $ X + Empilha $ X + id Empilha | redure/reduce $ S | S  X + id | S  id (R1) S  X + id (R2) X  id O yacc executa a redução para a primeira regra da gramática.

Analisador botton-up LR A principal tarefa de um analisador sintático botton-up é encontrar o nó mais à esquerda que ainda não foi construido, mais cujo filhos foram todos construidos. Essa sequência de filhos é chamada descritor, porque é onde guardamos o próximo nó a ser construido. Todos os algoritmos de análise botton-up diferem somente no modo como eles encontram um descritor; a última fase, redução do descritor a um não-terminal, é igual para cada um deles. Uma das vantagens imediatas da análise button-up é que ela não tem nenhum problema com a recursão à esquerda.

Analisador Sintáticos LR Left to right (Scaner da entrada LR) LR (k) lookahead (Um token de entrada) Rightmost (Derivação mais a direita) Ações --------------------- [1] Empilhar /shift [2] Reduzor /redure [3] Aceita [4] Erro | SLR tipos | LALR | LR Canônico Analisador Sintáico LR Entrada Pilha Saída Ação Desvio

Analisador Sintáticos LR Para que uma gramática seja LR é suficiente existir um analisador sintático de empilhar e reduzir que processando a entrada da esquerda para a direita seja capaz de reconhecer handles desta gramática quando os mesmos surgirem no topo da pilha. As gramáticas são sempre aumentada com um novo símbolo inicial. Isso significa que, se S for o símbolo inicial S’ é acrescentado à gramática, com uma única produção unitária para o símbolo inicial anterior. S  ( S ) S S   S’  S S  ( S ) S S  

Analisador Sintáticos LR Um item LR(0) de uma gramática livre de contexto é uma escolha de produção som uma posição identificada em seu lado direito. Essa posição identificada será indicada por um ponto em alguma de suas posições no lado direito da produção. Um item indica quanto de uma produção já foi examinada a uma dada altura do processo de análise sintática. Os itens podem ser visto como os estados do AFD que mantém as informações sobre a pilha de análise sintática e o progresso de uma análisador de empilhar e reduzir, reconhecendo os prefixos viaveis. Uma coleção de conjunto de itens, que chamamos de coleção canônica, provê as bases para a construção de uma analisador sintático SLR.

Analisador Sintáticos LR Considerando as gramáticas G1 e G2 tem três escolhas de produções e oito itens. G2 G1 G1 S’  .S S’  S. S  .( S ) S S  (. S ) S S  ( S. ) S S  ( S ). S S  ( S ) S. S  . E’  .E E’  E. E  .E + n E  E. + n E  E +. n E  E + n. E  .n E  n. S’  S S  ( S ) S S   G2 E’  E E  E + n E  n

Analisador Sintáticos LR Shift – E verificado em cada interração a ocorrência de um ponto “.” antes de um terminal, quando isto ocorre e feito um shift para a interação subsequente. S  .( S ) SI2 S  .a SI3 Reduce – Para toda ocorrência de um ponto “.” no final de uma produção, essa produção e reduzida a produção da gramática. S  ( S ). R2 S  a. R3

Analisador Sintáticos LR Desvio – Um desvio acontece quando um ponto “.” ocorre antes de um não-terminal, o desvio acontece expandindo um não-terminal atráves de uma nova interação. Quando o ponto “.” ocorre antes de um não-terminal, é listado tadas as produções que o não-terminal pode gerar. Quando o ponto “.” ocorre seguindo um não-terminal, é listado todas as produções que o ponto “.” esteja seguindo o não-terminal, exceto quando estiver no final da produção. S  (. S ) DI4 S  .( S ) SI2 S  .a SI3 S  A. a SIn S  A . b SIm

Analisador Sintáticos LR (1) S’  S $ (2) S  ( S ) (3) S  a S  ( S ) S  a first follow S’ (, a $ S $, ) I1 S’  S. $ Acc S I0 I3 I4 S’  .S $ DI1 S  .( S ) SI2 S  .a SI3 a S  a. R3 S  ( S. ) SI5 a I2 S ) S  (. S ) DI4 S  .( S ) SI2 S  .a SI3 I5 S  ( S ). R2 ( (

Analisador Sintáticos LR E1  .E $ DI1 E  .E + T DI1 E  .T DI2 T  .T * F DI2 T  .F DI3 F  .(E) SI4 F  .id SI5 I0 first follow E’ (, id $ E $, ), + T $, ), +, * F (0) E1  E $ (1) E  E + T (2) E  T (3) T  T * F (4) T  F (5) F  (E) (6) F  id E1  E . $ Acc E  E. + T SI6 I1 E  T . R2 E  T. * F SI7 follow(E) = {$,),+} I2 T  F . R4 follow(T) = {$,),+, *} I3

Analisador Sintáticos LR F  (E. ) DI11 E  E. + T DI6 I8 F  (.E ) DI8 E  .E + T DI1 E  .T DI2 T  .T * F DI2 T  .F DI3 F  .(E) SI4 F  .id SI5 I4 E  E +. T DI9 T  .T * F DI2 T  .F DI3 F  .(E) SI4 F  .id SI5 I6 E  E + T. R1 T  T. * F SI7 follow(E) I9 T  .T * F R3 follow(T) I10 T  T * .F DI10 F  .(E) SI4 F  .id SI5 I7 F  id. R6 follow(F) I5 F  (E). R5 follow (F) I11

Analisador Sintáticos LR id + * ( ) $ E T F s5 s4 1 2 3 s6 Acc R2 s7 R4 4 8 5 R6 6 9 7 10 s11 R1 R3 11 R5

Diagrama de transição Autômato SLR F ( T id + * )

Diagrama de transição Autômato SLR F I4 I8 + I5 id ( I9 * I11 I10 T E )

Autômato pushdown SLR O autômato pushdown LR consiste em uma alternância de estados e símbolos gramáticais começando e terminando com o estdo inicial. Os símbolos gramáticais em uma pilha LR representam a entrada que já foi reduzida. É conviniente desenhar pilhas de redução LR horizontalmente com o topo da pilha à direita. O autômato LR tem dois movimentos principais e um movimento secundário. Deslocamento (shift) O movimento de deslocamento remove o primeiro símbolo da entrada atual e o empurra para a pilha (push). Um novo estado é determinado com o uso da tabela sintática indexada pelo antigo estdo e pela símbolo de entrada que é empilhada. De o novo estado for um estado de erro, será encontrado um erro de sintaxe.

Autômato pushdown SLR Redução (reduce) O movimento de reduçao é parametrizado com a regra da produção A   para ser usada na redução. os símbolos gramáticais em beta são removidos da pilha, A é então empilhado, e o novo estado e determinado com o uso da tabela de sintática empilhado na pilha. Termino: (Aceito) A entrada foi analisada com sucesso quando doi reduzida ao símbolo inicial. Entretanto, se existirem simbolos na entrada, haverá um erro de sintaxe.

Autômato pushdown SLR Pilha Inicio I0 Entrada Ação $ id + id * id $ s5 R6 ; F  id “0” $ F D3 ; R4; T  F “0” $ T D2; R2; E  T “’0” $ E D1; s6; $ E + id * id $ $ E + id * id $ R6 ; F  id ; “6” $ E + F D3 ; R4 ; T  F “6” $ E + T D9 ; s7 $ E + T * id $ s5 ; $ E + T * id R6 ; F  id ; “7” $ E + T * F D10 ; R3; T  T * F D9 E  E + T D1 Aceita

Autômato pushdown SLR Pilha Inicio I0 Entrada Ação $ 0 id + id * id $ R6 ; F  id $ 0 F 3 R4; T  F $ 0 T 2 D2; E  T $ 0 E 1 s6 $ 0 E 1 + 6 id * id $ $ 0 E 1 + 6 id 5 * id $ $ 0 E 1 + 6 F 3 R4 ; T  F $ 0 E 1 + 6 T 9 s7 $ 0 E 1 + 6 T 9 * 7 id $ $ 0 E 1 + 6 T 9 * 7 id 5 $ $ 0 E 1 + 6 T 9 * 7 F 10 R3; T  T * F E  E + T Aceita

Autômato pushdown SLR Pilha Inicio I0 Entrada Ação $ 0 id * id + id $ R6 ; F  id $ 0 F 3 R4; T  F $ 0 T 2 s7 $ 0 T 2 * 7 id + id $ $ 0 T 2 * 7 id 5 + id $ R6 $ 0 T 2 * 7 F 10 R3 R2 $ 0 E 1 s6 $ 0 E 1 + 6 id $ $ 0 E 1 + 6 id 5 $ $ 0 E 1 + 6 F 3 R4 $ 0 E 1 + 6 T 9 R1 Aceita