Compiladores I Cristiano Damiani Vasconcellos

Apresentação em tema: "Compiladores I Cristiano Damiani Vasconcellos"— Transcrição da apresentação:

1 Compiladores I Cristiano Damiani Vasconcellos cristiano.damiani@ufpel.edu.br

2 Bibliografia Recomendada COMPILADORES Princípios, Técnicas e Ferramentas; Sethi, Ravi; Aho, Alfred V.; Ullman, Jeffrey D. LTC, 1995. Projeto Moderno de Compiladores; Bal, Henri E.; Grune, Dick; Langendoen, Koen. CAMPUS, 2001. Modern Compiler Implementation in Java Andrew W. Appel. Cambridge University Press, 2002. Introdução A Teoria dos Autômatos, Linguagens e Computação; Hopcroft, John E.; Ullman, Jeffrey D.; Motwani, Rajeev. CAMPUS, 2002.

3 Introdução Pré-processador Analisador Léxico Analisador Sintático Analisador Semântico Gerador de Código (intermediário) Otimizador Gerador de Código front-end back-end

4 Introdução final = (nota1 + nota2) / 2; Analisador Léxico Id1 = (Id2 + Id3) / 2 Analisador Sintático = Id1/ + Id2Id3 2 Id1finaldouble... Id2nota1double... Id3nota2double... Tabela de Símbolos

5 Introdução = Id1/ + Id2Id3 intToDouble(2) Id1finaldouble... Id2nota1double... Id3nota2double... Tabela de Símbolos Analisador Semântico temp1 = Id2 + Id3 temp2 = temp1 / 2.0 Id1 = temp2 Gerador de Código (intermediário)

6 Análise Léxica O Analisador Léxico (scanner) examina o programa fonte caractere por caractere agrupando-os em conjuntos com um significado coletivo (tokens): palavras chave (if, else, while, int, etc), operadores (+, -, *, /, ^, &&, etc), constantes (1, 1.0, a, 1.0f, etc), literais (Projeto Mono), símbolos de pontuação (;, {, }), labels.

7 Análise Léxica constanteInt digito digito* constanteDouble digito digito*. digito* digito {0, 1, 2, 3, 4, 5, 6, 7, 8, 9} X* Representa uma seqüência de zero ou mais X.

8 Análise Sintática Verifica se as frases obedecem as regras sintáticas da linguagem: Por exemplo, uma expressão pode ser definida como: expressão + expressão expressão – expressão (expressão) constante

9 Gramáticas Um conjunto de regras de produção, é um símbolo de partida. Uma regra de produção tem o formato, onde representa o nome da construção sintática e representa uma forma possível dessa construção: +

10 Gramáticas + | – | ( ) | | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 9

11 Derivação A verificar se uma frase faz parte da linguagem gerada pela gramática, envolve sucessivas substituições da cadeia de símbolos que ocorre do lado esquerdo da produção pela sua construção sintática correspondente, partindo do símbolo inicial. Essa substituição é chamada derivação sendo normalmente denotada pelo símbolo.

12 Derivação (10 - 2) + 3 + ( ) + ( - ) + (1 - ) + (10 - ) +...

13 Árvore Sintática + ( ) - 10 2 3 (10 – 2) + 3

14 Gramáticas Ambíguas 10 – 2 + 3 - + 10 2 3 + - 10 2 3

15 Gramáticas + | - | ( ) | + - + 10 – 2 + 3 + - 10 2 3

16 Gramáticas + | - | * | / | ( ) | + * 3 2 3 1 + 2 * 3

17 Gramáticas + | - | * | / | ( ) | * 1 + 2 * 3

18 Tradução Dirigida pela Sintaxe Analisador Sintático Analisador Léxico Analisador Semântico Tabela de Símbolos... Programa Fonte Código Intermediário Solicita tokentoken

19 Gramáticas - Exercícios 1.Considerando a gramática apresentada anteriormente derive as expressões e apresente a árvore sintática correspondente: (1 + 2) * 3 (1 – 2) + 3 * 4 2.Altere a gramática para incluir o operador unário -, esse operador deve ter precedência maior que os outros operadores. 3.Altere a gramática para que os operadores de adição, subtração, multiplicação e divisão tenham associatividade da direita para a esquerda. 4.Defina uma gramática para expressões aritméticas (operadores +, -, *, /) pós fixadas.

20 Gramáticas Dados 2 conjuntos independentes de símbolos: V t – Símbolos terminais V n – Símbolos não terminais. Uma gramática é definida como a quádrupla: {V n, V t, S, P} Onde, S V n é o símbolo inicial da gramática. P é um conjunto de regras de reescrita na forma:, sendo: (V n V t ) * V n (V n V t ) * (V n V t ) *

21 Classificação de Gramáticas Irrestritas – nenhuma restrição é imposta Sensíveis ao Contexto - | | | | Livres de Contexto - V n (V n V t ) + Regulares - V n tem a forma a ou aB, onde a V t e B V n

22 Gramáticas Regulares C 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 9 | 0C | 1C | 2C | 3C | 4C | 5C | 7C | 8C | 9C C CC | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 9 C digito digito* digito 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9

23 Especificação Análise Léxica – expressões regulares Análise Sintática – gramáticas livre de contexto. Análise Semântica – sistema de tipos (regras de inferência), semântica denotacional, semântica operacional, semântica de ações. Geração/Otimização de Código – linguagens para descrição de arquiteturas.

24 Linguagens Regulares Gerada a partir de uma gramática regular. Pode ser representada através de uma expressão regular. Pode ser reconhecida por um Autômato Finito. Considerando linguagens compostas por símbolos 0 e 1 podemos afirmar: a linguagem L 01 ={0 n 1 n | n 1} não é regular; a linguagem L 01 ={0 n 1 m | n 1, m 1} é regular;

25 Expressões Regulares Maneira compacta de representar linguagens regulares. É composta de 3 operações, sendo e 1 e e 2 expressões geradas por duas linguagens regulares L 1 e L 2 respectivamente Concatenação: e 1 e 2 = { xy | x L 1 e y L 2 } Alternação: e 1 |e 2 = { x | x L 1 ou x L 2 } Fechamento: e 1 * = zero ou mais ocorrências de e 1. É definida a precedência desses operadores como sendo: fechamento, concatenação, alternação (da maior precedência para a menor).

26 Expressões Regulares Exemplos: identificador (letra | _) (letra | digito | _)* letra a | b |... | A | B |... digito 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 constInt digito digito* constDouble digito digito*.digito* |. digito digito*

27 Autômato Finito A linguagem gerada por uma gramática regular pode ser reconhecida por um autômato finito. Um autômato finito consiste em: 1.Um conjunto finito de estados. 2.Um conjunto finito de símbolos de entrada (alfabeto). 3.Uma função de transição que tem como argumentos um estado e um símbolo de entrada e retorna a um estado. 4.Um estado inicial. 5.Um conjunto de estados finais também chamados estados de aceitação.

28 Autômato Finito letra | digito | _ letra | _ letra | digito | _ letra | _.. digito

29 Autômato Finito letra | digito | _ letra | _ f o r letra | digito | _ letra | _ f or ld Onde ld representa letra | digito | _ (com exceção da letra que faz a transição para outro estado). AFD – Autômato Finito Determinista AFN – Autômato Finito Não Determinista

30 Autômato Finito Implementação letra | digito | _ letra | _ digito 0 1 2

31 Geradores de Analisadores Léxicos delim [ \t] ws{delim}+ letra[A-Za-z] digito[0-9] id{letra}({letra}|{digito})* int{digito}+ real{digito}+\.{digito}*(E[+-]?{digito}+)? char'{letra}' string'({letra}|{digito}|[ \t\\:])*' % {char} {yylval.ptr=insereTab(&TabSimb[0], yytext);return TCCHARACTER;} {string} {yylval.ptr=insereTab(&TabSimb[0], yytext);return TCSTRING;} \n {num_linhas++;} FUNCTION {return TFUNCTION;} INTEGER {return TINTEGER;} ARRAY {return TARRAY;} IF {return TIF;} {id} {yylval.ptr=instalar(yytext); return TID;} "<" {return TMENOR;}

32 Análise Léxica - Exercícios 1.Escreva uma gramática, expressão regular e AFD que defina os números binários terminados em zero. 2.Mostre uma expressão regular e o AFD correspondente a gramática abaixo: S aS B bC C aC | aB | a 3.Escreva uma expressão regular para as constantes double da linguagem C. Dica pode-se usar o símbolo para indicar uma cadeia vazia.

33 Analisador Sintático Obtém uma seqüência de tokens fornecidos pelo analisador léxico e verifica se a mesma pode ser gerada pela gramática. Os métodos de análise sintática comumente usados em compiladores são classificados como: Métodos top-down. Métodos bottom-up. Os métodos mais eficientes, tanto top-down quanto bottom-up, trabalham com uma subclasse de gramáticas livres de contexto.

34 Métodos top-down Podem ser vistos como a tentativa de encontrar a derivação mais a esquerda para uma cadeia de entrada. Partindo do símbolo inicial da gramática são aplicadas sucessivas derivações tentado produzir a cadeia que se deseja reconhecer. Exemplos: Método descendente recursivo. Método LL(1).

35 Método Descendente Recursivo + | - 0 | 1| 2 | 3| 4 | 5 | 6 | 7 | 8| 9

36 Método Descendente Recursivo void cons() { if (isdigit(lookahead)) nextToken(); else erro("Erro sintático"); } void expr () { if (lookahead == '+' || lookahead == '-') { nextToken(); expr(); expr(); } else cons(); }

37 Analisadores Sintáticos Preditivos Escrevendo a gramática de forma cuidadosa podemos obter uma gramática processável por um analisador sintático que não necessite de retrocesso. Dado um símbolo de entrada a e um não terminal A a a ser expandido, a gramática deve possuir uma única produção que leve ao reconhecimento da cadeia iniciada com a. Analisadores sintáticos não preditivos (ou não determinísticos) necessitam de retrocesso e em geral são ineficientes.

38 Fatoração a Esquerda As vezes é necessário fazer alterações na gramática que possibilitem a implementação de um reconhecedor preditivo: if then else | if then if then else |

39 Fatoração a Esquerda A 1 | 2 |... | n | 1 | 2 |... | n A A | 1 | 2 |... | n A 1 | 2 |... | n

40 Eliminação da Recursividade a Esquerda E E + T | E - T | T T c | (E) E E – T E + T – T T + T – T * c + c - c

41 Eliminação da Recursividade a Esquerda E E + T | E - T | T T c | (E) A A 1 | A 2 |... | 1 | 2 |... | m A 1 A | 2 A |... | m A A 1 A | 2 A |... | n A | E TE E +TE | -TE | T c | (E)

42 Análise Sintática Preditiva não Recursiva LL(1) E TE E +TE | T FT T * FT | F c | (E) Não Terminal c+*()# ETE E+TE TFT T * FT Fc(E) E TE FTE cTE cE c+TE c+FTE c+cTE c+c*FTE c+c*cTE c+c*cE c+c*c

43 Analisador Sintático LL(1) Considerando w a cadeia de entrada. Empilhar #, Empilhar o símbolo inicial da gramática. Faça p apontar para o primeiro símbolo de w# Repetir Seja X o símbolo no topo da pilha e a o símbolo apontado por p; Se X for um terminal ou # então Se X = a então Remover X da pilha e avançar p; Senão erro. Senão /* X não é um terminal */ Se M[X, a] = X Y 1 Y 2...Y k então Remover X da Pilha Empilhar Y k...Y 2 Y 1 Senão erro Até que X = #

44 Analisador Sintático LL(1) Uma gramática cuja tabela não possui entradas multiplamente definidas é dita LL(1). O primeiro L indica a varredura da cadeia de entrada, que e feita da esquerda para a direita (left to right) o segundo L indica que são aplicadas derivações mais a esquerda (left linear). O 1 indica que é necessário apenas um símbolo para decidir que produção aplicar (1 lookahead).

45 Construção da Tabela LL(1) A construção de um analisador sintático preditivo e auxiliada por duas funções associadas a gramática: PRIMEIRO e SEGUINTE (FIRST e FOLLOW) Seja uma cadeia qualquer de símbolos gramaticais, PRIMEIRO( ) representa o conjunto de símbolos terminais que começam as cadeias derivadas a partir de. Se * então também é um elemento de PRIMEIRO( ). E E + T E T T T * F T F F (E) F c PRIMEIRO(E) E T F (E) E T F c = { (, c}

46 Construção da Tabela LL(1) SEGUINTES(A), para um não terminal A, é o conjunto de terminais a tais que existe uma derivação S * Aa, para algum e, onde S é o símbolo inicial da gramática. Ou seja o conjunto de símbolos que podem ocorrer após o não terminal A em alguma forma sentencial da gramática. E E + T E T T T * F T F F (E) F c E E + T T + T F + T E E + T E + T E + F # SEGUINTES(F) E T T * F F * F E T F (E) (E + T) (E + F) = { +, #, *, ) }

47 Construção da Tabela LL(1) Entrada: Gramática Saída: Tabela M Para cada produção A da gramática faça: Para cada terminal a em PRIMEIRO( ), adicione A em M[A, a]. Se estiver em PRIMEIRO( ), adicione A em M[A, b], para cada terminal b em SEGUINTE(A). Cada entrada indefinida em M indica uma situação de erro.

48 Construção da Tabela LL(1) E TE E +TE | T FT T * FT | F c | (E) PRIMEIRO (TE) = {c, ( } PRIMEIRO (+TE) = {+ } SEGUINTE (E) = { ), # } PRIMEIRO (FT) = {c, ( } PRIMEIRO (*FT) = { * } SEGUINTE (T)= { +, ), # } PRIMEIRO (c)= {c} PRIMEIRO(E) = { ( } Não Terminal c+*()# ETE E+TE TFT T * FT Fc(E)

49 Métodos bottom-up Podem ser vistos como a tentativa de se reduzir a cadeia de entrada ao símbolo inicia da gramática. Exemplos: Precedência de Operadores; SLR(1), LR(1), LALR(1)

50 Métodos LR(k) Os métodos de análise sintática LR executam uma derivação mais a direita ao contrário. O L significa que a varredura da entrada e feita a esquerda para a direita (left to right), o R que a derivação correspondente é a derivação mais a direita (rightmost derivation) e o k indica o número de símbolos de entrada que tem que ser examinados para se tomar uma decisão na análise sintática. Nós métodos SLR e LALR o que varia são as tecnicas usadas para construir a tabela sintática.

51 Métodos LR (1) E E + T (2) E T (3) T T * F (4) T F (5) F (E) (6) F c

52 Algoritmo LR(1) Considerando w a cadeia de entrada. Empilhar 0. /* Estado inicial */ Faça p apontar para o primeiro símbolo de w# Repetir para sempre Seja s o estado no topo da Pilha e a o símbolo apontado por p Se AÇÃO[s, a] = empilhar s então Empilhar a; Empilhar s; Avançar p; Senão Se AÇÂO[s, a] = reduzir A então Desempilhar 2 * | | símbolos; Seja s o estado no topo da pilha Empilhar A; Empilhar DESVIO[s, A]; Senão Se AÇÃO[s, a] = aceitar então Retornar; Senão erro fim

53 I 0 S.E# E.E + T E.T T.T * F T.F F.(E) F.c I 1 Desvio(0,E) S E.# E E. + T I 2 Desvio(0, T) E T. T T.* F I 3 Desvio(0,F) T F. I 4 Desvio(0,() F (.E) E.E + T E.T T.T * F T.F F.(E) F.c I 5 Desvio(0,c) F c. I 6 Desvio(1,+) E E +.T T.T * F T.F F.(E) F.c I 7 Desvio(2,*) T T *.F F.(E) F.c I 8 Desvio(4,E) F (E.) E E.+ T I 9 Desvio(6,T) E E +T. T T. * F I 10 Desvio(7,F) T T * F. I 11 Desvio(8, )) F (E). E T F ( c + * E T F ) F I3I3 I4I4 I5I5 c ( ( c c ( I6I6 + * Pilha : 0 Entrada: c + c #

54 I 0 S.E# E.E + T E.T T.T * F T.F F.(E) F.c I 1 Desvio(0,E) S E.# E E. + T I 2 Desvio(0, T) E T. T T.* F I 3 Desvio(0,F) T F. I 4 Desvio(0,() F (.E) E.E + T E.T T.T * F T.F F.(E) F.c I 5 Desvio(0,c) F c. I 6 Desvio(1,+) E E +.T T.T * F T.F F.(E) F.c I 7 Desvio(2,*) T T *.F F.(E) F.c I 8 Desvio(4,E) F (E.) E E.+ T I 9 Desvio(6,T) E E +T. T T. * F I 10 Desvio(7,F) T T * F. I 11 Desvio(8, )) F (E). E T F ( c + * E T F ) F I3I3 I4I4 I5I5 c ( ( c c ( I6I6 + * Pilha : 0 c 5 Entrada: c + c #

55 I 0 S.E# E.E + T E.T T.T * F T.F F.(E) F.c I 1 Desvio(0,E) S E.# E E. + T I 2 Desvio(0, T) E T. T T.* F I 3 Desvio(0,F) T F. I 4 Desvio(0,() F (.E) E.E + T E.T T.T * F T.F F.(E) F.c I 5 Desvio(0,c) F c. I 6 Desvio(1,+) E E +.T T.T * F T.F F.(E) F.c I 7 Desvio(2,*) T T *.F F.(E) F.c I 8 Desvio(4,E) F (E.) E E.+ T I 9 Desvio(6,T) E E +T. T T. * F I 10 Desvio(7,F) T T * F. I 11 Desvio(8, )) F (E). E T F ( c + * E T F ) F I3I3 I4I4 I5I5 c ( ( c c ( I6I6 + * Pilha : 0 F 3 Entrada: c + c #

56 I 0 S.E# E.E + T E.T T.T * F T.F F.(E) F.c I 1 Desvio(0,E) S E.# E E. + T I 2 Desvio(0, T) E T. T T.* F I 3 Desvio(0,F) T F. I 4 Desvio(0,() F (.E) E.E + T E.T T.T * F T.F F.(E) F.c I 5 Desvio(0,c) F c. I 6 Desvio(1,+) E E +.T T.T * F T.F F.(E) F.c I 7 Desvio(2,*) T T *.F F.(E) F.c I 8 Desvio(4,E) F (E.) E E.+ T I 9 Desvio(6,T) E E +T. T T. * F I 10 Desvio(7,F) T T * F. I 11 Desvio(8, )) F (E). E T F ( c + * E T F ) F I3I3 I4I4 I5I5 c ( ( c c ( I6I6 + * Pilha : 0 T 2 Entrada: c + c #

57 I 0 S.E# E.E + T E.T T.T * F T.F F.(E) F.c I 1 Desvio(0,E) S E.# E E. + T I 2 Desvio(0, T) E T. T T.* F I 3 Desvio(0,F) T F. I 4 Desvio(0,() F (.E) E.E + T E.T T.T * F T.F F.(E) F.c I 5 Desvio(0,c) F c. I 6 Desvio(1,+) E E +.T T.T * F T.F F.(E) F.c I 7 Desvio(2,*) T T *.F F.(E) F.c I 8 Desvio(4,E) F (E.) E E.+ T I 9 Desvio(6,T) E E +T. T T. * F I 10 Desvio(7,F) T T * F. I 11 Desvio(8, )) F (E). E T F ( c + * E T F ) F I3I3 I4I4 I5I5 c ( ( c c ( I6I6 + * Pilha : 0 E 1 Entrada: c + c #

58 I 0 S.E# E.E + T E.T T.T * F T.F F.(E) F.c I 1 Desvio(0,E) S E.# E E. + T I 2 Desvio(0, T) E T. T T.* F I 3 Desvio(0,F) T F. I 4 Desvio(0,() F (.E) E.E + T E.T T.T * F T.F F.(E) F.c I 5 Desvio(0,c) F c. I 6 Desvio(1,+) E E +.T T.T * F T.F F.(E) F.c I 7 Desvio(2,*) T T *.F F.(E) F.c I 8 Desvio(4,E) F (E.) E E.+ T I 9 Desvio(6,T) E E +T. T T. * F I 10 Desvio(7,F) T T * F. I 11 Desvio(8, )) F (E). E T F ( c + * E T F ) F I3I3 I4I4 I5I5 c ( ( c c ( I6I6 + * Pilha : 0 E 1 + 6 Entrada: c + c #

59 I 0 S.E# E.E + T E.T T.T * F T.F F.(E) F.c I 1 Desvio(0,E) S E.# E E. + T I 2 Desvio(0, T) E T. T T.* F I 3 Desvio(0,F) T F. I 4 Desvio(0,() F (.E) E.E + T E.T T.T * F T.F F.(E) F.c I 5 Desvio(0,c) F c. I 6 Desvio(1,+) E E +.T T.T * F T.F F.(E) F.c I 7 Desvio(2,*) T T *.F F.(E) F.c I 8 Desvio(4,E) F (E.) E E.+ T I 9 Desvio(6,T) E E +T. T T. * F I 10 Desvio(7,F) T T * F. I 11 Desvio(8, )) F (E). E T F ( c + * E T F ) F I3I3 I4I4 I5I5 c ( ( c c ( I6I6 + * Pilha : 0 E 1 + 6 c 5 Entrada: c + c #

60 I 0 S.E# E.E + T E.T T.T * F T.F F.(E) F.c I 1 Desvio(0,E) S E.# E E. + T I 2 Desvio(0, T) E T. T T.* F I 3 Desvio(0,F) T F. I 4 Desvio(0,() F (.E) E.E + T E.T T.T * F T.F F.(E) F.c I 5 Desvio(0,c) F c. I 6 Desvio(1,+) E E +.T T.T * F T.F F.(E) F.c I 7 Desvio(2,*) T T *.F F.(E) F.c I 8 Desvio(4,E) F (E.) E E.+ T I 9 Desvio(6,T) E E +T. T T. * F I 10 Desvio(7,F) T T * F. I 11 Desvio(8, )) F (E). E T F ( c + * E T F ) F I3I3 I4I4 I5I5 c ( ( c c ( I6I6 + * Pilha : 0 E 1 + 6 F 3 Entrada: c + c #

61 I 0 S.E# E.E + T E.T T.T * F T.F F.(E) F.c I 1 Desvio(0,E) S E.# E E. + T I 2 Desvio(0, T) E T. T T.* F I 3 Desvio(0,F) T F. I 4 Desvio(0,() F (.E) E.E + T E.T T.T * F T.F F.(E) F.c I 5 Desvio(0,c) F c. I 6 Desvio(1,+) E E +.T T.T * F T.F F.(E) F.c I 7 Desvio(2,*) T T *.F F.(E) F.c I 8 Desvio(4,E) F (E.) E E.+ T I 9 Desvio(6,T) E E +T. T T. * F I 10 Desvio(7,F) T T * F. I 11 Desvio(8, )) F (E). E T F ( c + * E T F ) F I3I3 I4I4 I5I5 c ( ( c c ( I6I6 + * Pilha : 0 E 1 + 6 T 9 Entrada: c + c #

62 I 0 S.E# E.E + T E.T T.T * F T.F F.(E) F.c I 1 Desvio(0,E) S E.# E E. + T I 2 Desvio(0, T) E T. T T.* F I 3 Desvio(0,F) T F. I 4 Desvio(0,() F (.E) E.E + T E.T T.T * F T.F F.(E) F.c I 5 Desvio(0,c) F c. I 6 Desvio(1,+) E E +.T T.T * F T.F F.(E) F.c I 7 Desvio(2,*) T T *.F F.(E) F.c I 8 Desvio(4,E) F (E.) E E.+ T I 9 Desvio(6,T) E E +T. T T. * F I 10 Desvio(7,F) T T * F. I 11 Desvio(8, )) F (E). E T F ( c + * E T F ) F I3I3 I4I4 I5I5 c ( ( c c ( I6I6 + * Pilha : 0 E 1 Entrada: c + c #

63 Tabelas SLR(1) Um item LR(0), para uma gramática G, é uma produção de G com um ponto em alguma das posições do seu lado direito. Exemplo: A produção E E + T produz 4 itens: [E.E + T] [E E.+ T] [E E +.T] [E E + T.] Intuitivamente o. indica até que parte da produção foi analisada em um determinado estado do analisador sintático.

64 Construção da Tabela Sintática SLR(1) A construção da tabela sintática é auxiliada por duas operações: Fechamento: Sendo I um conjunto de itens da gramática, o fechamento de I é definido por duas regras: 1.Inicialmente cada item de I é adicionado em FECHAMENTO(I). 2.Se [A.A ] estiver em FECHAMENTO(I) e B for uma produção, adicionar o item [B. ] a FECHAMENTO(I). Essa regra é aplicada até que nenhum novo item possa ser adicionado. Desvio: A operação DESVIO(I, X) é definida como o fechamento do conjunto de todos os itens [A X. ] tais que [A.X ] esteja em I.

65 Construção da Tabela Sintática SLR(1) Construção de um conjunto de itens LR(0): C = FECHAMENTO(S.S#) /* Onde S é o símbolo inicial da linguagem */ Repetir Para cada conjunto de itens I em C e cada símbolo gramatical X tal que DESVIO(I,X) não seja vazio e não esteja em C Incluir Desvio(I,X) em C Até que não haja mais conjunto de itens a serem incluídos em C

66 Construção da Tabela Sintática SLR(1) Construção da tabela sintática SLR(1): 1.Construir o conjunto de itens C = {I 0, I 1,..., I n } 2.Cada estado i é construído a partir de I i. As ações sintáticas são determinadas como: Se [A.a ] estiver em I i e DESVIO(I i, a) = I j então ação[i, a] = Empilhar j (se a for um terminal) ou desvio[i, a] = Empilhar j (se a for um não terminal) Se [A.] estiver em I i então ação(i, a) = reduzir através de A, para todo a em SEGUINTE(A). Se [S S.#] estiver em I i então ação(i, #) = aceitar

67 Construção da Tabela Sintática SLR(1) I 0 S.E# E.E + T E.T T.T * F T.F F.(E) F.c I 1 Desvio(0,E) S E.# E E. + T I 2 Desvio(0, T) E T. T T.* F I 3 Desvio(0,F) T F. I 4 Desvio(0,() F (.E) E.E + T E.T T.T * F T.F F.(E) F.c I 5 Desvio(0,c) F c. I 6 Desvio(1,+) E E +.T T.T * F T.F F.(E) F.c I 7 Desvio(2,*) T T *.F F.(E) F.c I 8 Desvio(4,E) F (E.) E E.+ T I 9 Desvio(6,T) E E +T. T T. * F I 10 Desvio(7,F) T T * F. I 11 Desvio(8, )) F (E). E T F ( c + * E T F ) F I3I3 I4I4 I5I5 c ( ( c c ( I6I6 + *

68 Construção da Tabela Sintática SLR(1) I 5 Desvio(0,c) F c. I 2 Desvio(0, T) E T. T T.* F I 3 Desvio(0,F) T F. I 9 Desvio(6,T) E E +T. T T. * F I 10 Desvio(7,F) T T * F. I 11 Desvio(8, )) F (E). SEGUINTE(F) = { +, *, ), # } SEGUINTE(E) = { +, ), # } SEGUINTE(T) = { +, *, ), # } SEGUINTE(E) = { +, ), # } SEGUINTE(F) = { +, *, ), # } Se [A.] estiver em I i então ação(i, a) = redução através de A, para todo a em SEGUINTE(A).

69 Construção da Tabela Sintática SLR(1) No método SLR(1), como a decisão de reduzir, aplicando uma produção A, é tomada usando o conjunto SEGUINTE(A) e não o contexto onde ocorreu algumas gramáticas LR(1) podem apresentar conflitos empilhar/reduzir se tentamos construir tabelas usando o método SLR(1). Por o exemplo: S L = R S R L *R L id R L Podemos pensar em L e R como o l-value e o r-value, respectivamente.

70 Construção da Tabela Sintática SLR(1) I 0 S.S# S.L = R S.R L.*R L.id R.L I 1 Desvio (0,S) S S.# I 2 Desvio (0,L) S L. = R R L. I 3 Desvio (0,R) S R. I 4 Desvio (0,*) L *.R R.L L.*R L.id I 5 Desvio (0,id) L id. I 6 Desvio (2,=) S L=.R R.L L.*R L.id I 7 Desvio (4,R) L *R. I 8 Desvio (4,L) R L. I 9 Desvio (6,L) S L=R. S L R * id = R L R * * L

71 Construção da Tabela Sintática SLR(1) SEGUINTE(R) = {=, # } I 2 Desvio (0,L) S L. = R R L. No estado 2, a ação reduzir R L deve ser executada para todos os seguintes de R, o que nesse caso ocasiona um conflito empilhar/reduzir. Entretanto não existe forma sentencial da gramática que inicie com R =. Para tratar essa gramática é necessário um método que carregue mais informação sobre o contexto para o estado.

72 Construção da Tabela Sintática LR(1) Fechamento(I): Repetir Para cada item [A.B, a] em I, cada produção B na Gramática e cada termina b em PRIMEIRO( a) tal que [B., b] não esta em I Faça Incluir [B., b] em I até que não seja mais possível adicionar itens a I. Desvio(I, X): é fechamento do conjunto de itens [A X., a] tais que [A.X, a] esta em I. Itens(G): C = {FECHAMENTO({[S.S#, ]})} (Onde S é o símbolo inicial da gramática) Repetir Para cada conjunto de itens I em C e cada símbolo gramatical X tal que Desvio(I, X) e Desvio(I, X) C Faça Incluir Desvio(I, X) em C até que nenhum novo item possa ser adicionado a C

73 Construção da Tabela Sintática LR(1) I 0 [S.S#, ] [S.L = R,#] [S.R,#] [L.*R,=,#] [L.id,=,#] [R.L,#] I 1 Desvio (0,S) S S.# I 2 Desvio (0,L) [S L. = R,#] [R L.,#] I 3 Desvio (0,R) [S R.,#] I 4 Desvio (0,*) [L *.R,=,#] [R.L,=,#] [L.*R,=,#] [L.id,=,#] I 5 Desvio (0,id) [L id.,=,#] I 6 Desvio (2,=) [S L=.R,#] [R.L,#] [L.*R,#] [L.id,#] I 7 Desvio (4,R) [L *R.,=,#] I 8 Desvio (4,L) [R L.,=,#] I 9 Desvio (6,L) [S L=R.,#] S L R * id = R L R * * L I 12 Desvio (6,id) [L id.,#] I 11 Desvio (6,*) [L *.R,#] [R.L,#] [L.*R,#] [L.id,#] I 10 Desvio (6,L) [R L.,#] * I 7 Desvio (11,R) [L *R.,#] R

74 LALR – lookahead LR A idéia geral é construir o conjunto de itens os conjuntos de itens LR(1) e, se nenhum conflito aparecer, combinar os itens com núcleo comum. Algoritmos eficientes para a geração de tabelas LALR constroem o conjunto de itens LR(0) e numa segunda etapa determina os lookahead correspondentes a cada item. O método LALR: Trata a maioria dos casos presentes em linguagens de programação; Na grande maioria dos casos o número de estados é muito inferior ao número de estado gerados pelo método LR(1). Comparando com o método LR(1), em algumas situações a detecção de erro e postergada, reduções desnecessárias são aplicadas antes que o erro detectado.

75 Construção da Tabela Sintática LALR(1) I 0 [S.S#, ] [S.L = R,#] [S.R,#] [L.*R,=,#] [L.id,=,#] [R.L,#] I 1 Desvio (0,S) S S.# I 2 Desvio (0,L) [S L. = R,#] [R L.,#] I 3 Desvio (0,R) [S R.,#] I 4 Desvio (0,*) [L *.R,=,#] [R.L,=,#] [L.*R,=,#] [L.id,=,#] I 5 Desvio (0,id) [L id.,=,#] I 6 Desvio (2,=) [S L=.R,#] [R.L,#] [L.*R,#] [L.id,#] I 7 Desvio (4,R) [L *R.,=,#] I 8 Desvio (4,L) [R L.,=,#] I 9 Desvio (6,L) [S L=R.,#] S L R * id = R L R * * L

76 Hierarquia de Gramáticas Livres de Contexto Gramáticas Ambíguas Gramáticas não ambíguas LR(k) LR(1) LALR(1) SLR LL(k) LL(1)

77 Uso de Gramáticas Ambíguas if ( ) else | if ( )... | |... if ( ) if ( ) else if (a > 0) if (a > b) m = a else m = b if (a b) m = a else m = b if ( ) else if ( ) A gramática é ambígua, no estado onde existe a transição para o token else ocorre um conflito empilhar/reduzir. A maioria dos geradores nesses casos opta por empilhar (que corresponde a primeira árvore).

78 Gramática de Atributos Gramática livre de contexto na qual cada símbolo possui um conjunto associado de atributos. A cada produção pode estar associada um conjunto de regras semânticas, que podem alterar valores de atributos, emitir código, atualizar a tabela de símbolos, emitir mensagens de erro ou realizar quaisquer outras atividades. Em geradores de analisadores sintáticos estas regras são geralmente descritas em linguagem de programação. Os atributos são classificados como: Atributos Sintetizados: O valor do atributo de um nó é computado a partir dos atributos de seus filhos. Atributos Herdados: O valor do atributo de um nó é computado a partir dos atributos dos irmãos e pais do nó.

79 Gramática de Atributos ProduçãoRegra Semântica S E E E 1 + T E T T T 1 * F T F F (E) F const {Imprimir (E.val)} {E.val = E 1.val + T.val} {E.val = T.val} {T.val = T 1.val * F.val} {T.val = F.val} {F.val = E.val} {F.val = const.lexval} 1 + 2 * 3 S E.val = 1 + T.val = 6 T.val = 1 T.val = 2 * F.val = 3 F.val = 1 F.val = 2 const. lexval const. lexval const. lexval E.val = 7