Paradigmas de Linguagem de Programação

Transcrição

1 Paradigmas de Linguagem de Programação Sintaxe Introdução Sintaxe: conjunto de regras que definem a forma da linguagem; Como as sentenças podem ser formadas como sequências de componentes básicos palavras; A sintaxe não revela nada sobre o significado dasentença; Exemplo: Em C, palavras chaves como while, do, for, if, são palavras da linguagem; Palavras não são elementares, elas são construídas com caracteres que pertencem a um alfabeto; Assim, a sintaxe de uma linguagem é definida por dois conjuntos de regras: regras léxicas e regras sintáticas. 1

2 Introdução Será apresentado nos próximos slides a definição de compilador e suas fases de análise léxica, sintática e semântica Compreender a sintaxe e o comportamento de um compilador é essencial para o bom programador Contexto de um compilador Aquilo que é usualmente designado por um compilador é de fato um conjunto de programas que no seu conjunto formam o compilador; 2

3 Implementação Abstração Contexto de um compilador Componentes Pré-Processador: processa diretivas; retira os comentários; entre outras tarefas. Compilador: faz a análise do texto escrito na linguagem fonte e faz a sua transcrição para a linguagem destino; Assembler: faz a transcrição da linguagem intermediária para a linguagem final (máquina); Loder/Linker: no caso de que se querer um programa executável os loader/linker fazem a junção do código máquina produzido pelas anteriores fases a um conjunto de serviços ( run-time routines ) que permitem a criação de um programa independente Contexto de um compilador Código Fonte Tokens e Lexemas Árvore Sintática Abstrata AST Decorada Código de Máquina 3

4 Processo de compilação 1) Análise 1.1) Análise léxica Organiza caracteres de entrada em grupos, chamados tokens Erros: tamanho máximo da variável excedido, caracteres inválidos. Processo de compilação 1) Análise 1.2) Análise sintática Organiza tokens em uma estrutura hierárquica Erros: falta de (, ), =, identificador inválido... 4

5 Processo de compilação 1) Análise 1.3) Análise semântica Checa se o programa respeita regras básicas de consistência Erro: tipos inconsistentes atribuir uma string em uma variável inteira Processo de compilação Vejamos um exemplo, seja a seguinte instrução de atribuição: posicao = inicial + incremento * 60 Na análise léxica é separada em uma lista de palavras: (posicao,=,inicial,+,incremento,*,60) 5

6 Processo de compilação Vejamos um exemplo, seja a seguinte instrução de atribuição: posicao = inicial + incremento * 60 Na análise sintática tenta-se construir uma frase correta com a lista de palavras produzidas pela fase anterior. É usual construir uma estrutura em árvore para representar a frase obtida. Processo de compilação Vejamos um exemplo, seja a seguinte instrução de atribuição: posicao = inicial + incremento * 60 Na análise semântica verifica a validade da frase no que diz respeito aos tipos das entidades utilizadas. Por exemplo, se um dos identificadores presentes na expressão é do tipo real, então é necessário converter 60 para a sua representação real: 6

7 Tabela de símbolos A informação acerca das palavras que o programa contém tem de fluir entre as várias fases do compilador; A tabela de símbolos vai conter uma entrada para cada uma das palavras que foram identificadas pelo analisador léxico; Gestão de erros Trata-se de detectar os erros enviando uma mensagem apropriada para o utilizador: local do erro; tipo do erro; causa provável; É importante tentar recuperar do erro automaticamente de forma a poder continuar a tarefa de compilação até ao máximo possível; 7

8 Descrição gráfica das fases Definição de linguagem Linguagens Formais Alfabeto: Um conjunto finito e não vazio de símbolos arbitrários é designado por um alfabeto, e é denotado por Σ; Um símbolo de um alfabeto é uma entidade abstrata básica, podendo representar números, letras, desenhos, etc, por exemplo: 1,2,a,b,c. Um alfabeto é representado por: Σ (sigma) Σ = {0,1} Σ = {a,b} 8

9 Definição de linguagem Linguagens Formais Palavra (ou cadeia de caracteres): As sequências finitas de símbolos (do alfabeto) justapostos; O conjunto de todas as palavras sobre Σ é denotado por Σ ; A palavra vazia, não contém nenhuma letra, e é denotada por ɛ; Seja Σ = {a,b} Então as cadeias possíveis são: w = ɛ w = a w = b w = ab Definição de linguagem Linguagens Formais Linguagem: Um conjunto arbitrário de palavras de Σ é designado por uma linguagem e é usualmente denotado por L; Se Σ representa um alfabeto, Então Σ* representa o conjunto de todas as palavras possíveis sobre Σ; Σ+ representa o conjunto de todas as palavras excetuando a palavra vazia. 9

10 Definição de linguagem Linguagens Formais Linguagem Assim podemos dizer que: Σ* = {ɛ, a, b, ab, ba, aab, abb, aaaa,...} Σ+ = Σ* - ɛ = {a, b, ab, ba, aab, abb, aaaa,...} Uma linguagem L é geralmente definida como um subconjunto de Σ*; Uma sentença é geralmente definida como uma cadeia pertencente à linguagem L. Definição de linguagem Linguagens Formais Tamanho ou Comprimento O tamanho ou comprimento de uma cadeia w, representado por w, é o número de símbolos que compõem a cadeia; w = ɛ w = 0 w = a w = 1 w = ab w = 2 w = abb w = 3 10

11 Definição de linguagem Linguagens Formais Concatenação de Palavras: a concatenação de w e v é a cadeia obtida pela adição dos símbolos de v no final de w. Nenhum símbolo pode ser mudado de lugar; Se w = a1, a2,...,an e v = b1, b2,...,bn Então a concatenação, w o v = a1a2...anb1b2...bn Por exemplo: seja w = ababa e v = cdcdcd Então w o v = ababacdcdcd Definição de linguagem Linguagens Formais Concatenação de Palavras A operação de concatenação satisfaz as seguintes propriedades: a) associatividade b) elemento neutro a direita e a esquerda 11

12 Definição de linguagem Linguagens Formais Concatenação de Palavras A operação de concatenação também vale para as linguagens L1 o L2 = {x o y x Є L1 e y Є L2} Exemplo: L1 = {a, bc} e L2 = {aa, cb, bb} L1 o L2 = {x o y x Є L1 e y Є L2} = { L1 o L2 = { Definição de linguagem Linguagens Formais Sufixo, prefixo e subcadeia 12

13 Definição de linguagem Linguagens Formais União, Intersecção e Diferença União: L1 U L2 = {w: w Є L1 ou w Є L2} Intersecção: L1 L2 = {w: w Є L1 e w Є L2} Diferença: L1 - L2 = {w: w Є L1 e w Ɇ L2} Exemplo: L1={a, b, aa, ab, abb, aab, aaa} e L2={a, aa, aaa, aaaa} União: L1 U L2 = Intersecção: L1 L2 = Diferença: L1 - L2 = Definição de linguagem Linguagens Formais A imagem inversa de P, denotada por P 1 é a palavra que se obtém de P por inversão da ordem das letras. Por exemplo: se P = abcd, então P 1 = dcba; 13

14 Análise léxica Regras Léxicas Especificam o conjunto de caracteres que constituem o alfabeto da linguagem, bem como a maneira que eles podem ser combinados; Exemplo Pascal: letras maiúsculas e minúsculas são idênticas; C e ADA: letras maiúsculas e minúsculas são diferenciadas; Pascal: sinal de diferente <> C: sinal de diferente!= ADA: sinal de diferente /=: Análise léxica Seu objetivo é analisar a entrada dada (programa fonte) e dividi-la em sequências considerando os tokens da linguagem, definidos por expressões regulares; Cada token é normalmente formado por seu tipo (se é um operador lógico, um identificador, um número inteiro, etc.) e pelo seu valor e outros atributos. 14

15 Análise léxica Este valor vai depender do tipo do token e normalmente corresponde à sequência de caracteres realmente lida da entrada. Análise léxica Tarefa principal Ler o arquivo onde se encontra o programa-fonte Produzir como saída uma sequência de tokens com seus respectivos códigos que o Analisador Sintático usará para validar regras da gramática; 15

16 Análise léxica Primeira fase do compilador; Lê a sequência de caracteres do canal de entrada e produz uma sequência de palavras (lexemas); Expressões regulares e as gramáticas regulares Descrevem a sintaxe das linguagens de programação Dado uma palavra Trata-se agora de, dado uma linguagem, ser capaz de reconhecer de forma automática se uma dada frase pertence a essa linguagem. Análise léxica Lê os caracteres de entrada (scanner) e os agrupa em sequências chamadas lexemas (tokens); Os tokens são consumidos na fase seguinte (análise sintática); Programa Fonte Analisador Léxico (scanner) GetToken() token Tabela de Símbolos (identificadores e constantes) Analisador sintático (parser) Para Análise semântica 16

17 Análise léxica A tabela de símbolos é utilizada para diferenciar palavras e símbolos reservados da linguagem (while, for, =, >, <) de identificadores definidos pelo usuário Lexema (lido) Token (Tipo) ; <PONTO_VIRGULA> aux <IDENTIFICADOR> while <PALAVRA_RESERVADA> Análise léxica A tabela de símbolos também é utilizada para armazenar o tipo e o valor das variáveis e o seu escopo Lexema (lido) Token (Tipo) Valor ; <PONTO_VIRGULA> - aux <IDENTIFICADOR> 10 while <PALAVRA_RESERVADA> - 17

18 Análise léxica Classes de tokens mais comuns: identificadores; palavras reservadas; números inteiros sem sinal; números reais; cadeias de caracteres; sinais de pontuação e de operação; caracteres especiais; símbolos compostos de dois ou mais caracteres especiais; comentários; etc. Análise léxica Exemplos de tokens que podem ser reconhecidos em uma linguagem de programação como C: 18

19 Análise léxica O analisador léxico desconsidera o trecho do código fonte que encontra-se entre delimitadores de comentários. Além disso, ele desconsidera espaços em branco colocados pelos programadores a fim de melhorar a legibilidade do código fonte (endentação). Análise léxica EXEMPLO: seja a cadeia (2 * 12.01), o analisador léxico teria: 19

20 Análise léxica a abc [abc] [a-f] Expressão Regular X+ corresponde a um ou mais elemento de X a abc a, b ou c a,b,c,d,e ou f [0-9] qualquer digito de 0 a 9 X* zero ou mais elemento de X [0-9]+ qualquer inteiro (...) agrupamento de expressão alternância OU (a b c)* equivale a [a-c]* Análise léxica Exemplo: Expressão para reconhecer números reais (0, 27,.12, 2.19) [0-9]+ [0-9]+\.[0-9]+ \.[0-9]+ [0-9]+(\.[0-9]+)? \.[0-9]+ [0-9]*(\.)?[0-9]+ 20

21 Análise sintática Regras Sintáticas Especificam as sequências de símbolos que constituem estruturas sintáticas válidas; Estas regras permitem o reconhecimento de expressões e comandos; Exemplo: Pascal: atribuição a:=b; C: atribuição a=b; Análise sintática As linguagens de programação possuem regras precisas para descrever a estrutura sintática de programas bem formados; Exemplo: Linguagem C Funções declaração e comando Comando expressões A estrutura sintática das construções de uma linguagem de programação é especificada pelas regras gramaticais de uma gramática livre de contexto 21

22 Análise sintática Benefícios para projetistas de linguagens: Uma gramática provê uma especificação sintática precisa e fácil de entender para as linguagens de programação; A partir de determinadas classes gramaticais, podemos construir automaticamente um analisador sintático eficiente; Durante o processo de construção do analisador, podem ser detectadas ambiguidades sintáticas; Uma gramática permite o desenvolvimento de uma linguagem iterativamente, possibilitando lhe acrescentar novas construções para realizar novas tarefas; Análise sintática Utiliza os tokens produzidos pela análise léxica e verifica a formação do programa com o uso de GLC (Gramáticas Livres de Contexto) A partir dos tokens é criada uma representação intermediária da árvore sintática mostra a estrutura gramatical da sequência de tokens; 22

23 Análise sintática expr = a + b * 60 <identificador, 1>, < = >, <identificador, 2>, <+>, <identificador, 3>, < * >, <numero, 60> Percorrendo a árvore e consultando a GLC é possível verificar se a expressão pertence à linguagem. = <id,1> + <id,2> * <id,3> 60 Análise sintática O analisador sintático recebe do analisador léxico uma cadeia de tokens representando o programa fonte e verifica se essa cadeia de tokens pertence à linguagem gerada pela gramática. 23

24 Análise sintática O analisador sintático constrói uma árvore de derivação e a passa ao restante do front-end do compilador para processamento. Obs: na prática não é necessário construir a árvore de derivação explicitamente, pois a ações de verificação e tradução podem ser implementados em um único módulo. Análise sintática Existem 3 estratégias gerais de análise sintática para o processamento de gramáticas: Universal, Descendente (Top Down) e Ascendente (Bottom Up). Em ambas as estratégias a entrada do analisador sintático é consumida da esquerda para a direita, um símbolo de cada vez Os analisadores criados à mão normalmente utilizam gramáticas LL Os analisadores sintáticos para a maioria de gramáticas LR geralmente são construídos utilizando ferramentas automatizadas 24

25 Análise sintática Para descrever uma linguagem é necessário uma série de regras gramaticais; As regras são formadas por uma única estrutura do lado esquerdo seguida do metasímbolo ::= e por uma sequência de itens do lado direito (símbolos ou estruturas); Estruturas entre <> são chamadas de não terminais; Símbolos como garota e cachorro são chamadas de terminais; As regras gramaticais são as produções. Análise sintática Exemplo de uma gramática para expressões aritméticas de adição e multiplicação: <exp>::= <exp>+<exp> <exp>*<exp> (exp) <num> <num> ::= <num><digito> <digito> <digito> ::=

26 Análise sintática BNF Sentenças simples consistem de uma frase nominal e de uma frase verbal seguida de um ponto, da seguinte maneira: <sentence> ::= <frase_nominal><frase_verbal>. Deve-se saber descrever a estrutura de uma frase nominal e de uma frase verbal: <frase_nominal> ::= <artigo><substantivo> <artigo> ::= um a <substantivo> ::= garota cachorro <frase_verbal> ::= <verbo> <frase_nominal> <verbo> ::= viu abraça Análise sintática Cada regra gramatical apresentada consiste de uma string colocada entre < e >, esta string é o nome da estrutura que está sendo descrita; O símbolo ::= pode ser lido como consiste de ou é o mesmo que ; Após o símbolo ::=, temos uma sequência de outros nomes e símbolos; 26

27 Análise sintática Construção de uma sentença legal: Inicia-se com o símbolo <sentença> e prossegue-se trocando o lado esquerdo por alternativas do lado direito nas regras; Este processo criará uma derivação na linguagem; Desta forma, podemos construir a sentença: A garota viu um cachorro ; Análise sintática Montando a derivação da sentença: a garota viu um cachorro <sentença> <frase_nominal><frase_verbal>. <artigo><substantivo><frase_verbal>. a <substantivo><frase_verbal>. a garota <frase_verbal>. a garota <verbo><frase_nominal>. a garota viu <frase_nominal>. a garota viu <artigo><substantivo>. a garota viu um <substantivo>. a garota viu um cachorro. Pode-se começar com a sentença a garota viu um cachorro, e voltar até <sentença> para provar que é uma sentença válida da linguagem. 27

28 Análise sintática - Extensão da BNF EBNF (Extend BNF) Definição EBNF para uma calculadora Definição de sintaxe para uma linguagem Definição EBNF para uma linguagem de programação simples Análise sintática Recursão a Esquerda Na gramática a seguir, o não-terminal E representa expressões consistindo em termos separados pelo operador +; T representa termos consistindo em fatores separados pelo operador *; e F representa fatores que podem ser expressos entre parênteses ou identificadores. Essa gramática não pode ser usada com o método de análise descendente pois é recursiva a esquerda. 28

29 Análise sintática Recursão a Esquerda Gramáticas são recursivas à esquerda se possui um não-terminal A para o qual existam derivações do tipo A Aα para uma cadeia α. Para o par de produções recursivas à esquerda A Aα β A substituição abaixo elimina a recursão imediata à esquerda: A βa A αa ε Nenhuma outra modificação é requerida a partir de A. Análise sintática Recursão a Esquerda Gramática para expressões simples: E E + T T T T * F F F ( E ) id Aplicando transformação na Primeira Regra E E + T T é do tipo A Aα β Obtemos: A βa E TE A αa ε E +TE ε 29

30 Análise sintática Recursão a Esquerda Gramática para expressões simples: E E + T T T T * F F F ( E ) id Aplicando transformação na Segunda Regra E T * F F é do tipo A Aα β Obtemos: A βa T FT A αa ε E *FT ε Análise sintática Recursão a Esquerda Assim, obtemos a partir de: E E + T T T T * F F F ( E ) id A gramática equivalente sem recursão à esquerda: E TE E +TE T FT T *FT ε F (E) id 30

31 Análise sintática Recursão a Esquerda Exemplo 2: A Aa b Para o par de produções recursivas à esquerda A Aα β Exemplo 3: S SS+ SS* a Exemplo 4: S Sa B B Bb c Considere para eliminar a recursão A βa A αa ε Análise sintática Recuperação de erro O recuperador de erros em um analisador sintático possui objetivos simples, mas desafiadores: Informar a presença de erros de forma clara e precisa; Recuperar-se de cada erro com rapidez suficiente para detectar erros subsequentes; Acrescentar um custo mínimo no processamento de programas corretos. Como um recuperador de erro deve informar a presença de um erro? No mínimo ele precisa informar o local no programa fonte onde o erro foi detectado, pois existe uma boa chance de que o local exato do erro seja em um dos tokens anteriores. 31

32 Análise sintática Recuperação de erro Recuperação em nível de frase Ao detectar um erro, o analisador sintático pode realizar a correção local sobre o restante da entrada. Uma correção local típica compreende a substituição de uma vírgula por um ponto-e-vírgula, exclusão de um ponto-e-vírgula desnecessário. A escolha da correção local fica a critério do projetista do compilador. Análise sintática Recuperação de erro Produções de Erro Nesta estratégia de recuperação de erro podemos estender a gramática da linguagem em mãos com produções que geram construções erradas, antecipando assim os erros mais comuns. 32

33 Análise sintática Não é possível enumerar a sintaxe de todos os programas das mais diferentes linguagens; É necessário uma maneira de definir um conjunto infinito usando uma descrição finita: A sintaxe de uma linguagem é definida através de uma gramática; Gramática: conjunto de regras que definem todos os construtores que podem ser aceitos na linguagem. Análise sintática Fortran foi definido através da especificação de algumas regras em inglês; Algol 60 foi definido através de uma gramática livre de contexto desenvolvida por Jonh Backus; Essa gramática ficou conhecida como BNF (Backus-Naur Form); BNF foi utilizada posteriormente na definição de várias linguagens como C, Pascal e Ada; BNF é uma metalinguagem pois consiste numa linguagem para descrição de outras linguagens. 33

34 Análise sintática Observe os dois trechos de código a seguir, sendo o código a. em C e o código b. em Pascal a. b. while(x!=y) while x<>y do { begin } end Ambas possuem a mesma estrutura conceitual, porém, diferem na aparência léxica; Quando duas construções diferem apenas no nível léxico, se diz que elas seguem a mesma sintaxe abstrata e diferem na sintaxe contreta. Análise sintática Com tudo isso, é possível concluir que a descrição sintática de uma linguagem: Ajuda o programador a saber como escrever um programa sintaticamente correto; Pode ser usada para determinar se um programa está sintaticamente correto este é exatamente o trabalho do compilador! 34

35 Análise sintática - Análise Top-Down Como reconhecer se uma sentença está de acordo com uma gramática? Pode-se implementar reconhecedores de sentença Recursivamente, com retrocesso Com mecanismo preditivo First e Follow Para usar os reconhecedores, primeiramente deve-se transformar a Gramática Livre de Contexto Eliminação de produções vazias Eliminação de recursividade a esquerda Fatoração de uma gramática Análise sintática Conjuntos First First(α) Definição informal: conjunto de todos os terminais que começam com qualquer sequência derivável de α Definição formal Se existe um t T e um β V* tal que α * t β então t First(α) Se α * ε então ε First(α) A B C D first(a) = {b, c, d} B b first(b)= {b} C c first(c)= {c} D d first(d)= {d} 35

36 Análise sintática Conjuntos First Para determinar o FIRST(A): Se a é terminal, então o first(a) = a; Se A é não terminal e A aα é uma produção, então se acrescenta a ao conjunto de first de A, logo: first(a)=a; Se A ε é uma produção ε, logo first(a)=ε; Se A Y1Y2...Yk é uma produção, então todo i tal que todos Y1...Yi-1 são não terminais e FIRST(Yj) contém ε, onde j=1,2...i-1. acrescente todo símbolo diferente de ε de FIRST(Yj) a FIRST(A). Se ε FIRST(A), para todo i=1,2..k. então acrescente ε a FIRST(A). Análise sintática Conjuntos First E TE E +TE ε T FT T *FT ε F (E) id First(E) = {? } First(E ) = {? } First(T) = {? } First(T ) = {? } First(F) = {? } 36

37 Análise sintática Conjuntos First E TE E +TE ε T FT T *FT ε F (E) id First(E) = First(T) = First(F) ={ (,id } First(E ) = { +, ε} First(T) = First(F) = { (, id } First(T ) = { *, ε } First(F) = { (, id } Análise sintática Conjuntos First E TE E +TE ε T FT T *FT ε F (E) id First(E) = First(T) = First(F) ={ (,id } First(E ) = { +, ε} First(T) = First(F) = { (, id } First(T ) = { *, ε } First(F) = { (, id } Se F derivasse em ε seria preciso incluir o first(t ) em first(t) 37

38 Análise sintática Conjuntos First E TE E +TE ε T FT H E T T *FT ε F (E) id First(E) = First(T) = First(F) ={ (,id } First(E ) = { +, ε} First(T) = First(F) = { (, id } First(H) = {? } First(T ) = { *, ε } First(F) = { (, id } Análise sintática Conjuntos First E TE E +TE ε T FT H E T T *FT ε F (E) id First(E) = First(T) = First(F) ={ (,id } First(E ) = { +, ε} First(T) = First(F) = { (, id } First(H) = { First(E ) U First(T) } First(T ) = { *, ε } First(F) = { (, id } 38

39 Análise sintática Conjuntos First E TE E +TE ε T FT H E T T *FT ε F (E) id First(E) = First(T) = First(F) ={ (,id } First(E ) = { +, ε} First(T) = First(F) = { (, id } First(H) = { +, (, id } First(T ) = { *, ε } First(F) = { (, id } Análise sintática Conjuntos Follow Se A é um não-terminal, o follow(a) é o conjunto de terminais imediatamente seguintes (à direita) de A 39

40 Análise sintática Conjuntos Follow Para determinar follow(a) 1. Colocar $ em follow(s) se S é o símbolo de partida. $ é o marcador de fim de entrada durante análise 2. Se existe uma produção A αbβ e β ε então tudo que estiver em first(β), exceto ε, deve ser adicionado em follow(b) 3. Se existe uma produção A αb ou A αbβ onde first(β) contem ε (β ε), então tudo que está em follow(a) está em follow(b) Análise sintática Conjuntos Follow E TE E +TE ε T FT T *FT ε F (E) id First(E) = First(T) = First(F) ={ (,id } First(E ) = { +, ε} First(T) = First(F) = { (, id } First(T ) = { *, ε } First(F) = { (, id } Follow(E) = { ), $ } Follow(E ) = Follow(E) = { ), $ } Follow(T) = First(E ) U Follow(E) U Follow(E ) = { +, ), $} Follow(T ) = Follow(T) = {+, ), $} Follow(F) = First(T ) U Follow(T) U Follow(T ) = { *, +, ), $} 40

41 Análise sintática Conjuntos Follow Regra 2 e regra 1 E TE E +TE ε T FT T *FT ε F (E) id First(E) = First(T) = First(F) ={ (,id } First(E ) = { +, ε} First(T) = First(F) = { (, id } First(T ) = { *, ε } First(F) = { (, id } Follow(E) = { ), $ } Follow(E ) = Follow(E) = { ), $ } Follow(T) = First(E ) U Follow(E) U Follow(E ) = { +, ), $} Follow(T ) = Follow(T) = {+, ), $} Follow(F) = First(T ) U Follow(T) U Follow(T ) = { *, +, ), $} Análise sintática Conjuntos Follow Regra 3 E TE E +TE ε T FT T *FT ε F (E) id First(E) = First(T) = First(F) ={ (,id } First(E ) = { +, ε} First(T) = First(F) = { (, id } First(T ) = { *, ε } First(F) = { (, id } Follow(E) = { ), $ } Follow(E ) = Follow(E) = { ), $ } Follow(T) = First(E ) U Follow(E) U Follow(E ) = { +, ), $} Follow(T ) = Follow(T) = {+, ), $} Follow(F) = First(T ) U Follow(T) U Follow(T ) = { *, +, ), $} 41

42 Análise sintática Conjuntos Follow Regra 2 e Regra 3 E TE E +TE ε T FT T *FT ε F (E) id First(E) = First(T) = First(F) ={ (,id } First(E ) = { +, ε} First(T) = First(F) = { (, id } First(T ) = { *, ε } First(F) = { (, id } Follow(E) = { ), $ } Follow(E ) = Follow(E) = { ), $ } Follow(T) = First(E ) U Follow(E) U Follow(E ) = { +, ), $} Follow(T ) = Follow(T) = {+, ), $} Follow(F) = First(T ) U Follow(T) U Follow(T ) = { *, +, ), $} Análise sintática Conjuntos Follow Regra 3 E TE E +TE ε T FT T *FT ε F (E) id First(E) = First(T) = First(F) ={ (,id } First(E ) = { +, ε} First(T) = First(F) = { (, id } First(T ) = { *, ε } First(F) = { (, id } Follow(E) = { ), $ } Follow(E ) = Follow(E) = { ), $ } Follow(T) = First(E ) U Follow(E) U Follow(E ) = { +, ), $} Follow(T ) = Follow(T) = {+, ), $} Follow(F) = First(T ) U Follow(T) U Follow(T ) = { *, +, ), $} 42

43 Análise sintática Conjuntos Follow Regra 2 e Regra 3 E TE E +TE ε T FT T *FT ε F (E) id First(E) = First(T) = First(F) ={ (,id } First(E ) = { +, ε} First(T) = First(F) = { (, id } First(T ) = { *, ε } First(F) = { (, id } Follow(E) = { ), $ } Follow(E ) = Follow(E) = { ), $ } Follow(T) = First(E ) U Follow(E) U Follow(E ) = { +, ), $} Follow(T ) = Follow(T) = {+, ), $} Follow(F) = First(T ) U Follow(T) U Follow(T ) = { *, +, ), $} Análise sintática First Follow S AB first(s)={c} follow(s)={ $ } A c ε first(a)={c, ε} follow(a)={ c } B cbb ca first(b)={c} follow(b)={ $ } 43

44 Análise sintática Analisador Top-Down A análise top-down é realizada da raiz para as folhas Parte-se de um não-terminal que é o símbolo inicial da gramática em direção aos terminais Análise sintática preditiva não-recursiva O símbolo da cadeia de entrada, em análise, é suficiente para determinar qual regra de produção deve ser escolhida São construídos utilizando gramáticas LL ( 1 ) Cadeia de entrada é analisada da esquerda para a direita ( Left-toright) A derivação das produções é feita mais a esquerda ( Leftmost) A cada passo é observado um ( 1) símbolo a frente para determinar que ação deve ser tomada 44

45 Análise sintática preditiva não-recursiva Condições Eliminar a recursividade a esquerda Fatorar a gramática Construir o conjunto first e follow Análise sintática preditiva não-recursiva Construção da tabela preditiva Dimensão1: não terminal X Dimensão2: símbolo de entrada (terminal) t A entrada (X, t) contém a regra da produção a aplicar obtida a partir dos conjuntos first e follow S caa first(s)={c} follow(s)={ $ } A cb B first(a)={b, c, ε} follow(a)={ a } B bcb ε first(b)={b, ε} follow(b)={ a } Não Terminal Símbolo de Entrada a b c S erro erro S caa A A B A B A cb B B ε B bcb erro 45

46 Análise Sintática Tabela Preditiva Topo da pilha S S deriva em c? Sim: S caa Não Terminal Símbolo de Entrada a b c S erro erro S caa A A B A B A cb B B ε B bcb erro Entrada: cbca Pilha Entrada Ação S$ cbca$ Análise Sintática Tabela Preditiva S caa substitui na pilha o S por caa Não Terminal Símbolo de Entrada a b c S erro erro S caa A A B A B A cb B B ε B bcb erro Entrada: cbca Pilha Entrada Ação S$ cbca$ S caa caa$ cbca$ 46

47 Análise Sintática Tabela Preditiva O topo da pilha é igual ao valor do topo de entrada Não Terminal Símbolo de Entrada a b c S erro erro S caa A A B A B A cb B B ε B bcb erro Entrada: cbca Pilha Entrada Ação S$ cbca$ S caa caa$ cbca$ casar(c) Análise Sintática Tabela Preditiva A deriva em b? Sim: A B Não Terminal Símbolo de Entrada a b c S erro erro S caa A A B A B A cb B B ε B bcb erro Entrada: cbca Pilha Entrada Ação S$ cbca$ S caa caa$ cbca$ casar(c) Aa$ bca$ 47

48 Análise Sintática Tabela Preditiva Substitui o A na pilha por B Não Terminal Símbolo de Entrada a b c S erro erro S caa A A B A B A cb B B ε B bcb erro Entrada: cbca Pilha Entrada Ação S$ cbca$ S caa caa$ cbca$ casar(c) Aa$ bca$ A B Ba$ bca$ Análise Sintática Tabela Preditiva B deriva em b? Sim: B bcb Não Terminal Símbolo de Entrada a b c S erro erro S caa A A B A B A cb B B ε B bcb erro Entrada: cbca Pilha Entrada Ação S$ cbca$ S caa caa$ cbca$ casar(c) Aa$ bca$ A B Ba$ bca$ 48

49 Análise Sintática Tabela Preditiva B deriva em b? Sim: B bcb Não Terminal Símbolo de Entrada a b c S erro erro S caa A A B A B A cb B B ε B bcb erro Entrada: cbca Pilha Entrada Ação S$ cbca$ S caa caa$ cbca$ casar(c) Aa$ bca$ A B Ba$ bca$ B bcb O topo da pilha é igual ao valor do topo de entrada Não Terminal Símbolo de Entrada a b c S erro erro S caa A A B A B A cb B B ε B bcb erro Entrada: cbca Pilha Entrada Ação S$ cbca$ S caa caa$ cbca$ casar(c) Aa$ bca$ A B Ba$ bca$ B bcb bcba$ bca$ casar(b) 49

50 Análise Sintática Tabela Preditiva O topo da pilha é igual ao valor do topo de entrada Não Terminal Símbolo de Entrada a b c S erro erro S caa A A B A B A cb B B ε B bcb erro Entrada: cbca Pilha Entrada Ação S$ cbca$ S caa caa$ cbca$ casar(c) Aa$ bca$ A B Ba$ bca$ B bcb bcba$ bca$ casar(b) cba$ ca$ casar(c) Análise Sintática Tabela Preditiva B deriva em a? SIM: quando B ε Não Terminal Símbolo de Entrada a b c S erro erro S caa A A B A B A cb B B ε B bcb erro Entrada: cbca Pilha Entrada Ação S$ cbca$ S caa caa$ cbca$ casar(c) Aa$ bca$ A B Ba$ bca$ B bcb bcba$ bca$ casar(b) cba$ ca$ casar(c) Ba$ a$ B ε 50

51 Análise Sintática Tabela Preditiva O topo da pilha é igual ao valor do topo de entrada Não Terminal Símbolo de Entrada a b c S erro erro S caa A A B A B A cb B B ε B bcb erro Entrada: cbca Pilha Entrada Ação S$ cbca$ S caa caa$ cbca$ casar(c) Aa$ bca$ A B Ba$ bca$ B bcb bcba$ bca$ casar(b) cba$ ca$ casar(c) Ba$ a$ B ε a$ a$ casar(a) Análise Sintática Tabela Preditiva O topo da pilha é igual ao valor do topo de entrada Não Terminal Símbolo de Entrada a b c S erro erro S caa A A B A B A cb B B ε B bcb erro Entrada: cbca Pilha Entrada Ação S$ cbca$ S caa caa$ cbca$ casar(c) Aa$ bca$ A B Ba$ bca$ B bcb bcba$ bca$ casar(b) cba$ ca$ casar(c) Ba$ a$ B ε a$ a$ casar(a) $ $ aceita 51

52 Análise sintática Analisador Bottom-up A análise top-down é realizada das folhas para a raiz Parte-se dos símbolos terminais em direção ao símbolo inicial da gramática Análise sintática Analisador Bottom-up id * id F * id T * id T * F T E E E + T T T T * F F F (E) id id F id F id id T * F F id id T T * F F id Entrada: id*id id 52

53 Análise sintática Analisador Bottom-up O processo de análise sintática ascendente pode ser encarado como um processo de reduzir uma cadeia w para o símbolo inicial da gramática Redução : operação de substituição do lado direito de uma produção pelo nãoterminal correspondente do lado esquerdo Para a regra A α, α pode ser reduzido em A Análise sintática Analisador Bottom-up Analisadores sintáticos Bottom-up Analisadores conhecidos como empilha-reduz (shift-reduce) Etapas do reconhecimento: determinar quando reduzir e determinar a produção a ser utilizada para que a análise prossiga 53

54 Análise sintática Analisador Bottom-up Componentes do analisador bottom-up Pilha, onde os símbolos a serem reduzidos são empilhados Tabela sintática, que guia o processo de shift e reduce Processo de reconhecimento de uma sentença 1. Empilhar símbolos da cadeia de entrada 2. Quando um lado direito apropriado de uma produção aparece, ele é reduzido (substituído) pelo lado esquerdo da produção 3. Se a análise tiver sucesso, esse processo ocorre até que os símbolos da cadeia de entrada sejam todos consumidos e a pilha fique apenas com o símbolo inicial da gramática Análise sintática Analisador Bottom-up Gramática: S (L) a L L+S S Entrada: a+a Pilha Cadeia Regra $ (a+a)$ $ (a+a)$ shift ( $( a+a)$ shift a $(a +a)$ reduce S a $(S +a)$ reduce L S $(L +a)$ shift + $(L+ a)$ shift a $(L+a )$ reduce S a $(L+S )$ reduce L L+S $(L )$ shift ) $(L) $ reduce S (L) $S $ aceita 54

55 Análise sintática Analisador Bottom-up Operações durante a análise: Shift: coloca-se no topo da pilha o primeiro símbolo da cadeia de entrada Reduce: substitui-se o lado direito do handle pelo seu lado esquerdo Aceita: a cadeia de entrada é reconhecida Erro: a cadeia de entrada não é reconhecida Análise semântica A semântica define o significado dos programas sintaticamente corretos; Por exemplo, em C, a instrução if(a>b) max = a; else max = b; Diz que a expressão a>b deve ser avaliada e, dependendo do retorno (true ou false), um dos dois comandos de atribuição será executado. 55

56 Análise semântica Regras sintáticas: mostram como formar o comando; Regras semânticas: mostram qual é o efeito do comando; Erros semânticos tipos inválidos - o programa dá um resultado, mas não é correto! o computador não advinha o que eu quero logo: o programa que escrevi não resolve o problema pretendido os erros semânticos são os mais difíceis de corrigir Análise semântica Conceitos semânticos básicos de uma LP Variáveis: questões semânticas associadas a declaração (escopo, tipo e tempo de vida); Valores e Referência: se o valor associado a variável denota localização na memória ou conteúdo localizado na memória; Expressões: possuem regras para serem escritas envolvendo os tipos de expressões permitidas; 56

57 Análise semântica Abstração Processo de identificar apenas as qualidades ou propriedades relevantes do fenômeno que se quer modelar; As LP são as ferramentas com as quais os programadores podem implementar os modelos abstratos; Por outro lado, as próprias LP são abstrações do processador subjacente; Análise semântica Abstração Sugere a distinção que deve ser feita entre o que o programa faz e como ele é implementado ; Quando um procedimento é chamado, pode-se concentrar apenas no que ele faz; Quando se está escrevendo o procedimento deve-se concentrar em como implementálo; As primeiras abstrações foram o uso de mnemônicos em assembly; 57

58 Análise semântica Programas trabalham com entidades Entidades: Variáveis, rotinas e comandos; As entidades dos programas possuem propriedades chamadas atributos; Os valores dos atributos devem ser definidos antes de sua utilização. Análise semântica A definição do valor de um atributo é conhecida como amarração ou binding; 58

59 Análise semântica Amarração estática: A amarração é estabelecida antes do tempo de execução e não pode ser alterada depois; Exemplo: um conjunto de valores é amarrado ao tipo inteiro no tempo de implementação da linguagem, assim, a definição da linguagem específica que o tipo inteiro deve ser suportado e a implementação da linguagem amarra-o à representação da memória. Análise semântica Amarração dinâmica: A amarração é estabelecida em tempo de execução. Exemplo: as variáveis são amarradas a um valor em tempo de execução; 59

60 Exemplo Analise os códigos abaixo e identifique os erros em léxico, sintático e semântico: int I2, A@; I2 = 0; while(i2 <= 0); I = I+1; I2 = a ; int a, b c; a = 2; b := 3; c = 4; media = (a+b+c)/3; total = num1 + num2 * 50 Analisador Léxico Fases da compilação 60

61 Fases da compilação total = num1 + num2 * 50 Analisador Léxico (id,1)(=>(id,2)(+>(id,3)(*>(50> Fases da compilação total = num1 + num2 * 50 Analisador Léxico (id,1)(=>(id,2)(+>(id,3)(*>(50> Analisador Sintático = (id,1) + (id,2) * (id,3) 50 61

62 Fases da compilação total = num1 + num2 * 50 Analisador Léxico (id,1)(=>(id,2)(+>(id,3)(*>(50> Analisador Sintático = (id,1) + (id,2) * (id,3) 50 Analisador Semântico = (id,1) + (id,2) * (id,3) atof(50) Fases da compilação total = num1 + num2 * 50 Analisador Léxico (id,1)(=>(id,2)(+>(id,3)(*>(50> Analisador Sintático = (id,1) + (id,2) * (id,3) 50 Analisador Semântico = (id,1) + (id,2) * (id,3) atof(50) Gerador de Código Intermediário t1 = atof(50) t2 = id3 * t1 t3 = id2 + t2 id1 = t3 62

63 Fases da compilação total = num1 + num2 * 50 Analisador Léxico (id,1)(=>(id,2)(+>(id,3)(*>(50> Analisador Sintático = (id,1) + (id,2) * (id,3) 50 Analisador Semântico = (id,1) + (id,2) * (id,3) atof(50) Gerador de Código Intermediário t1 = atof(50) t2 = id3 * t1 t3 = id2 + t2 id1 = t3 Otimizador de Código t1 = id3 * 50.0 id1 = id2 + t1 Fases da compilação total = num1 + num2 * 50 Analisador Léxico (id,1)(=>(id,2)(+>(id,3)(*>(50> Analisador Sintático = (id,1) + (id,2) * (id,3) 50 Analisador Semântico = (id,1) + (id,2) * (id,3) atof(50) Gerador de Código Intermediário t1 = atof(50) t2 = id3 * t1 t3 = id2 + t2 id1 = t3 Otimizador de Código t1 = id3 * 50.0 id1 = id2 + t1 Gerador de Código LDF R2,id3 MULF R2, R2, #50.0 LDF R1, id2 ADDF R1, R1, R2 STF id1, R1 63

64 Referências SEBESTA, Robert W. Conceitos de linguagens de programação. 9ª ed. Porto Alegre: Bookman, p. ISBN Notas de aula Professora Isabel Harb Manssour 64