1 Linguagens Formais, Lex & Yacc Vladimir Oliveira Di Iorio Linguagens Formais, Lex & Yacc Vladimir...

1

Linguagens Formais,Linguagens Formais,

Lex & YaccLex & Yacc

Vladimir Oliveira Di IorioVladimir Oliveira Di Iorio

Linguagens Formais,Linguagens Formais,

Lex & YaccLex & Yacc

Vladimir Oliveira Di IorioVladimir Oliveira Di Iorio

2

IntroduçãoIntrodução

3

• Linguagens formais são linguagens cuja sintaxe (e geralmente semântica) é precisamente definida, sem ambigüidades.

• São diferentes de linguagens naturais, recheadas de imprecisões e ambigüidades.

• Exemplos de linguagens formais: linguagens de programação como C, C++, Pascal, Java, linguagens de consulta como SQL.

Linguagens FormaisLinguagens Formais

4

• Uma definição para o comando UPDATE da linguagem SQL, usando estilo BNF:

UPDATE [TRANSACTION transaction] {table | view}SET col = <val> [, col = <val> …][WHERE <search_condition> | WHERE CURRENT OF cursor];

• Exemplo de um comando válido:

UPDATE CLIENTE SET DATA_INCLUSAO = CURRENT DATE;

ExemploExemplo

5

• Estudar fundamentos teóricos de linguagens formais:– alfabetos, palavras e linguagens;– expressões regulares;– gramáticas regulares e livres de contexto.

• Apresentar ferramentas no estilo Lex, para processamento de entradas usando linguagens regulares.

• Apresentar ferramentas no estilo Yacc, para processamento de entradas usando linguagens livres de contexo.

• Dar exemplos de utilização de ferramentas Lex e Yacc, na construção de filtros, pequenos interpretadores e compiladores.

Objetivos do CursoObjetivos do Curso

6

• Expressões regulares são um formalismo usado para definir o formato correto de uma cadeia de caracteres.

• São usados símbolos de um alfabeto qualquer, juntamente com operadores especiais, como '*' e '+'.

• Um exemplo: a+ b c*

Essa expressão define que as cadeias válidas são aquelas que iniciam com uma seqüência não vazia de símbolos 'a', seguidos de exatamente um símbolo 'b', seguido de uma seqüência possivelmente vazia de símbolos 'c'.

Visão Geral - Expressões RegularesVisão Geral - Expressões Regulares

7

• Autômatos finitos são um formalismo equivalente às expressões regulares, que usa representação em forma de grafo.• Autômato finito equivalente à expressão a+ b c* :

Visão Geral - AutômatosVisão Geral - Autômatos

a

a

b

c

Estado inicialEstado inicial Estado finalEstado final

8

• Gramáticas são mais um formalismo usado para definir o formato correto de uma cadeia de caracteres.

• Os símbolos são classificados como terminais e não terminais, e são usadas regras de reescrita para os símbolos não terminais.

• Gramática equivalente à expressão a+ b c* :

<S> -> a<A><A> -> a<A> | b | b -> c | c

Visão Geral - GramáticasVisão Geral - Gramáticas

9

• Ferramentas no estilo Lex utilizam uma especificação baseada em expressões regulares.

• A partir dessa definição, Lex gera automaticamente um programa que simula o comportamento de autômatos equivalentes às expressões fornecidas.

• O programa lê uma entrada e verifica se essa entrada está no formato especificado.

• Enquanto verifica a entrada, pode executar algumas ações (trechos de programa) desejadas.

Visão Geral - LexVisão Geral - Lex

10

• Ferramentas no estilo Yacc funcionam de maneira parecida com Lex - mas utilizam uma especificação baseada em gramáticas.

• O formalismo de gramáticas é mais poderoso que o de expressões regulares e autômatos, assim é possível gerar programas que processam entradas mais complexas.

• Da mesma forma que Lex, Yacc pode associar ações (trechos de programa) a cada regra da gramática. À medida que a entrada é processada, ações adequadas são executadas. Essas ações podem ser, por exemplo, a interpretação ou compilação da entrada.

Visão Geral - YaccVisão Geral - Yacc

11

• Um compilador ou interpretador pode ser gerado rapidamente usando Lex e Yacc em conjunto.

• Lex é geralmente usado para separar uma entrada em unidades léxicas. No caso de uma linguagem de programação, por exemplo, pode identificar um número real como "1.23" ou uma palavra-chave como "begin".

• Yacc pode usar as unidades léxicas produzidas por Lex e verificar se essas unidades formam uma entrada válida. Enquanto isso pode, por exemplo, compilar a entrada.

Visão Geral - Lex & YaccVisão Geral - Lex & Yacc

12

Visão Geral - Lex & YaccVisão Geral - Lex & Yacc

Lex

AnalisadorLéxico

regrasléxicas

entrada Yacc

AnalisadorSintático

regrassintáticas

saída

13

• O primeiro compilador para uma linguagem de programação de alto nível foi desenvolvido para a linguagem FORTRAN, na década de 50.

• Na época, a teoria de linguagens formais ainda não estava estabelecida (Chomsky, 1959).

• Foi necessário um esforço gigantesco, e a utilização de um grande número de programadores.

HistóriaHistória

14

• Atualmente, com a utilização de ferramentas como Lex e Yacc, é possível construir rapidamente um compilador.

• O processo de geração automática utilizado por essas ferramentas, em geral, produz analisadores quase tão rápidos quanto os escritos totalmente à mão.

HistóriaHistória

15

Linguagens FormaisLinguagens Formais

16

• Um alfabeto é um conjunto finito de símbolos distintos.

• Exemplo: Σ = {a,b,c} é um alfabeto formado pelos símbolos a, b e c.

• Uma palavra sobre um alfabeto Σ é uma seqüência de comprimento finito formada com símbolos desse alfabeto.

• Algumas palavras sobre o alfabeto Σ = {a,b,c} :abc , bcaabbac , b

• A palavra de comprimento zero é representada por λ .

Alfabetos e PalavrasAlfabetos e Palavras

17

• Seja Σ um alfabeto qualquer. O conjunto de todas as palavras sobre Σ é denotado por Σ* .

• Por exemplo, se Σ = {a,b,c} , então

Σ* = {λ, a, b, c, aa, ab, ac, ba, bb, bc, ca, cb, cc, aaa, ...}• Uma linguagem sobre um alfabeto Σ é qualquer

subconjunto de Σ* .• Linguagens sobre Σ = {a,b,c} :

{a, ab, bbc}

{aa, ab, ac, ba, bb, bc, ca, cb, cc}

todas as palavras que começam com a

LinguagensLinguagens

18

• Outras linguagens sobre Σ = {a,b,c} :

todas as palavras de comprimento par

{λ, a, b, c} {λ}

{ } Σ* • A concatenação de 2 palavras será representada por

sua justaposição. Por exemplo, sejam uma palavra x = abc e uma palavra y = bb .

A concatenação de x com y é representada por

xy = abcbb .

LinguagensLinguagens

19

• Se X e Y são duas linguagens,a concatenação de X com Y, denotada por XY,é a seguinte linguagem:

XY = { palavras xy tais que x X e y

Y }

Ou seja, são as palavras formadas pela concatenação de uma palavra qualquer de Xcom uma palavra qualquer de Y

(prefixo pertence a X, sufixo pertence a Y).

Concatenação de linguagensConcatenação de linguagens

20

• Por exemplo, sejam

X = {a,b,c} e Y = {abb,ba} .

Então

XY = {aabb,aba,babb,bba,cabb,cba}

• A concatenação de X consigo mesma n vezes é Xn :Xn = X X X ... X X (n vezes)

• Por definição, X0 é o conjunto {λ}:

X0 = {λ}


21

• Outros exemplos, com X = {a,b,c} e Y = {abb,ba} :

X0 = {λ}

X1 = X = {a,b,c}

X2 = XX = {aa,ab,ac,ba,bb,bc,ca,cb,cc}

X3 = X2X = {aaa,aab,aac,aba,abb,abc,aca,acb,acc,baa,bab,bac,bba,bbb,bbc,bca,bcb,bcc,caa,cab,cac,cba,cbb,cbc,cca,ccb,ccc}

Y2 = YY = {abbabb,abbba,baabb,baba}


22

Considere o alfabeto Σ = {a,b,c}. Seja L1 a linguagem das

palavras que começam com o símbolo 'a', e L2 a linguagemdas palavras que terminam com o símbolo 'b'.

1. O conjunto {a,b,c} é uma linguagem sobre Σ ?

2. Qual a menor linguagem que pode ser criada com esse alfabeto (menor número de palavras) ?

3. Qual é o resultado da concatenação de L1 com L2 ?

4. Qual é o resultado da união de L1 com L2 ?

5. A união de 2 linguagens pode resultar em uma linguagem menor que as outras duas?

6. A concatenção de 2 linguagens pode resultar em uma linguagem menor que as outras duas?

ExercíciosExercícios

23

• A operação X*, denominada Fecho de Kleene de X,é definida como a união de Xi ,com i variando de 0 a infinito:

X* = X0 X1 X2 X3 ...

Ou seja, X* consiste de todas as palavras que se pode construir a partir dos elementos de X .

• Por exemplo, se X = {a,b,c} e Y = {abb,ba} :

X* = {λ,a,b,c,aa,ab,ac,ba,bb,bc,ca,cb,cc,aaa,...}

Y* = {λ,abb,ba,abbabb,abbba,baabb,baba,abbabbabb,...}

Fecho de KleeneFecho de Kleene

24

Expressões RegularesExpressões Regulares

25

• Para definir expressões regulares, vamos usar as seguintes abreviações:– o conjunto {a} será representado simplesmente por a ;– {a,b,c,...} será representado por a b c ...

• O conjunto de expressões regulares sobre um alfabeto Σ qualquer é definido como:

1. os conjuntos { } e λ são expressões regulares;

2. para todo símbolo a de Σ, a é uma expressão regular;

3. se x e y são expressões regulares sobre Σ, então também são expressões regulares: x y , xy e x* .

Expressões Regulares - DefiniçãoExpressões Regulares - Definição

26

• a b linguagem formada apenas pelas palavras a e b

• abb aa ac linguagem formada exatamente pelas palavras abb, aa e ac, ou seja, {abb,aa,ac}

• a* linguagem (infinita) de todas as palavras formadas apenas com o símbolo a

Expressões Regulares - exemplosExpressões Regulares - exemplos

27

• (a b) (ab bb) denota a linguagem {aab,abb,bab,bbb}

• (a b)*

a linguagem {λ,a,b,aa,ab,ba,bb,aaa,...} :

• (aa)*

palavras só com a, e com comprimento par (inclui a palavra nula)


28

• (a2)+

palavras só com a, e com comprimento par maior que zero (não inclui a palavra nula)

• a (a b c)*

Linguagem sobre {a,b,c} das palavras que começam com o símbolo a

• Outras abreviações:– x+ é usado para abreviar xx* ;– x2 é usado para abreviar xx ; – x3 para abreviar x2x etc.


29

• a (a b c)* b

Linguagem sobre {a,b,c} das palavras que começam com o símbolo a e terminam com b

• (b c) (a b c)* λ

Linguagem das palavras sobre {a,b,c} que não começam com o símbolo a


30

• Que linguagens são essas?

1. (a b)* b (a b)*

2. (a b)* a (a b)* a (a b)*

3. (a b c) (a b c) (a b c)

4. (b* a b* a b*) *

Expressões Regulares - exercíciosExpressões Regulares - exercícios

31

• Construa expressões regulares para:

1. Linguagem das palavras de comprimento par

sobre o alfabeto {a,b,c}.2. Linguagem das palavras sobre o alfabeto {a,b,c}

que contenham exatamente um símbolo c .

Expressões Regulares - exercíciosExpressões Regulares - exercícios

32

• As linguagens que podem ser especificadas por expressões regulares são chamadas de

linguagens regulares.

• Mas expressões regulares não podem ser usadaspara especificar qualquer linguagem desejada.

• Muitas linguagens não conseguem ser especificadas com expressões regulares, necessitando de formalismos mais poderosos.

Expressões Regulares - restriçõesExpressões Regulares - restrições

33

• Exemplos de linguagens que não são regulares:

– Linguagem cujas palavras têm o formato anbn,para qualquer n. Ou seja:

{ λ, ab, aabb, aaabbb, ... }

– Linguagem sobre alfabeto { a, b, (, ) } com

aninhamento correto de parêntesis abrindo e fechando.

Expressões Regulares - restriçõesExpressões Regulares - restrições

34

Lex - Gerador deLex - Gerador deAnalisadores LéxicosAnalisadores Léxicos

35

• Ajuda a escrever programas cuja entrada pode ser descrita por meio de expressões regulares.

• Principais utilizações:– transformações simples e extração de padrões em

textos;– separação da entrada em unidades léxicas, como

preparação para um analisador sintático.• Os exemplos utilizados nesta apresentação seguirão

o formato do programa JFlex, um clone de Lex que gera código em Java.

Lex - Gerador deLex - Gerador deAnalisadores LéxicosAnalisadores Léxicos

36

• Um texto fonte para LEX é composto de:– lista de expressões regulares;– fragmentos de programa associados a cada

expressão.• Quando o fonte é submetido ao LEX, um programa é

automaticamente gerado. Esse programa:– lê um arquivo de entrada;– particiona a entrada em cadeias que "casam" com

as expressões regulares definidas;– executa os fragmentos de programa associados às

expressões "casadas";– escreve no arquivo de saída.

Lex Lex - fonte- fonte

37

Lex Lex - esquema de funcionamento- esquema de funcionamento

Lex

Yylex

fonteYylex

(programagerado)

entrada saída

38

• Um exemplo, usando o gerador JFlex:

1 .2 .3 .4 .

1 .2 .3 .4 .

%%%standalone%%\t { System.out.print("TAB"); }

Lex Lex - exemplo com JFlex- exemplo com JFlex

• Como na maioria dos clones de Lex, o fonte é dividido em 3 seções, separadas por "%%".• No JFlex, as seções são:

1. código do usuário a ser incluído;

2. opções e declarações;

3. regras e ações associadas.

39

1 .2 .3 .4 .

1 .2 .3 .4 .


Essa opção indica que o programa gerado poderá serexecutado diretamente (não será usado dentro de um analisador sintático).

Essa opção indica que o programa gerado poderá serexecutado diretamente (não será usado dentro de um analisador sintático).


Expressão regularExpressão regular

Ação (fragmento de programa)associada à expressão

Ação (fragmento de programa)associada à expressão

Uma regraUma regra

40

1 .2 .3 .4 .

1 .2 .3 .4 .



• Essa regra "casa" com um caractere "\t" (tabulação) da entrada. Se isso acontecer, o código entre chaves é executado.• Se a entrada não casa com nenhuma regra, a ação default é executada: escrever o caractere diretamente na saída.• Ou seja, esse "programa" Lex serve para ler uma entrada e trocar as tabulações por "TAB".

41

• Supondo que o fonte abaixo esteja no arquivo ex1.flex:

1 .2 .3 .4 .

1 .2 .3 .4 .


> jflex ex1.flexReading "ex1.flex"Constructing NFA : 6 states in NFAConverting NFA to DFA : ..4 states before minimization, 3 states in minimized DFAWriting code to "Yylex.java"

> javac Yylex.java

> jflex ex1.flexReading "ex1.flex"Constructing NFA : 6 states in NFAConverting NFA to DFA : ..4 states before minimization, 3 states in minimized DFAWriting code to "Yylex.java"

> javac Yylex.java

Executa jflex,gerando Yylex.java

Executa jflex,gerando Yylex.java

gera Yylex.classgera Yylex.class

Lex Lex - usando o JFlex- usando o JFlex

42

• Supondo que o texto abaixo esteja no arquivo teste.txt:

> java Yylex teste.txtteste...TABEsta linha comeca com tabTABTABEsta com 2 tabs

> java Yylex teste.txtteste...TABEsta linha comeca com tabTABTABEsta com 2 tabs

teste...Esta linha comeca com tab

Esta com 2 tabsfim.

teste...Esta linha comeca com tab

Esta com 2 tabsfim.

• Para gerar a saída no arquivo saida.txt:

> java Yylex teste.txt > saida.txt> java Yylex teste.txt > saida.txt

Lex Lex - executando analisador gerado- executando analisador gerado

43

• Expressões regulares usadas em regras:– caracteres de texto: letras, dígitos, caracteres

especiais como '\t', '\n' etc.– operadores: usados como funções especiais das

expressões regulares.• Na maioria das versões de Lex, os operadores são:

" \ [ ] ˆ - ? . * + | ( ) $ / { } % < >• Os operadores podem ser utilizados como caracteres

de texto, se vierem precedidos de um caractere de escape ('\') ou se estiverem entre aspas duplas.

• Nas slides seguintes, veremos o funcionamento de alguns operadores.

Lex Lex - expressões regulares- expressões regulares

44

• Classes de caracteres:

[abc] casa com um dos caracteres a, b ou c

[a-zA-Z] casa com uma letra minúscula ou maiúscula

[^a-zA-Z] casa com qualquer coisa, exceto letras

• Caractere arbitrário:

. casa com qualquer caractere, exceto newline

• Exclusivos de JFlex:

[:letter:] isLetter( )

[:digit:] isDigit( )

[: lowercase:] isLowerCase( )

[:uppercase:] isUpperCase( )


45

• Expressões repetidas (* e +):

a* casa com qualquer número consecutivo de a's (incluindo zero repetições)

a+ casa com uma ou mais ocorrências de a

[A-Za-z][A-Za-z0-9]*

definição usual de "identificador"

• Alternação e agrupamento ( | ):

(ab|cd) casa com ab ou cd


46

• Expressão opcional (?):

ab?c casa com ac ou abc;

(ab|cd+)?(ef)*

casa com abefef , efefef , cdef, ou cddd mas não com abc , abcd , ou abcdef

• Macros e repetições:

{digit} casa com a definição da expressão regular

digit (seção de definições)

a{n} casa com n vezes a concatenação de a


47

• Como ocorre a escolha das regras para casamento?

1. À medida que a entrada é lida, o analisador procura a regra que possibilita o casamento com a mais longa possível seqüência de caracteres da entrada.

2. Se mais de uma regra possibilita o casamento com a seqüência mais longa, a escolha é feita pela ordem em que as regras aparecem na fonte.

Lex Lex - escolha de regras- escolha de regras

48

• Supondo que o fonte abaixo esteja no arquivo ex2.flex:

1 .2 .3 .4 .5 .6 .

1 .2 .3 .4 .5 .6 .

%%%standaloneIdentifier = [a-zA-Z][a-zA-Z0-9]*%%abc { System.out.println("-----\"abc\""); }{Identifier} { System.out.println("-----id"); }

> jflex ex2.flexReading "ex2.flex"Constructing NFA : 16 states in NFAConverting NFA to DFA : ......8 states before minimization, 6 states in minimized DFAWriting code to "Yylex.java"

> javac yylex.java

> jflex ex2.flexReading "ex2.flex"Constructing NFA : 16 states in NFAConverting NFA to DFA : ......8 states before minimization, 6 states in minimized DFAWriting code to "Yylex.java"

> javac yylex.java


49

• Supondo que o texto abaixo esteja no arquivo teste.txt:

> java Yylex teste.txt> java Yylex teste.txt

abcdeabcabc123123abcd123abc


• O que será impresso???


50



1 .2 .3 .4 .5 .6 .

1 .2 .3 .4 .5 .6 .

%%%standaloneIdentifier = [a-zA-Z][a-zA-Z0-9]*%%abc { System.out.println("-----abc"); }{Identifier} { System.out.println("-----id"); }

-----id

-----abc

-----id

123-----id

123-----abc

-----id

-----abc

-----id

123-----id

123-----abc

Entrada:

Saída:


51

• Dentro das ações associadas às regras, alguns objetos e métodos podem ser acessados pelos trechos de programa.

• Esses objetos e métodos, gerados automaticamente pelo analisador, possuem nomes que iniciam com "yy", para evitar conflito com objetos do código inserido pelo usuário.

• Exemplos: o texto que foi "casado" com a regra, a linha e coluna atuais etc.

• Nos próximos slides, veremos esses e outros exemplos de objetos e métodos acessíveis dentro das ações associadas às regras.

Lex Lex - objetos acessados nas ações- objetos acessados nas ações

52

• String yytext() : retorna a seqüência de caracteres que foi casada com a regra.

• int yylength() : retorna o comprimento da seqüência casada.

• int yyline : contém o número da linha atual.• int yycolumn : contém o número da coluna atual,

na linha atual.

Lex Lex - objetos acessados nas ações- objetos acessados nas ações

53

1 .2 .3 .4 .5 .6 .7 .8 .9 .10 .11 .12 .13 .14 .15 .16 .17 .18 .

1 .2 .3 .4 .5 .6 .7 .8 .9 .10 .11 .12 .13 .14 .15 .16 .17 .18 .

%%

%standalone%class Ex3 /* define nome da classe gerada */%unicode /* permite usar caracteres unicode */%line /* permite usar yyline */%column /* permite usar yycolumn */

FimdeLinha = \r|\n|\r\nCharTexto = [^\r\n]Espaco = {FimdeLinha} | [ \t]

ComentLinha = "//" {CharTexto}* {FimdeLinha}

Ident = [a-zA-Z][a-zA-Z0-9]*Inteiro = 0 | [1-9][0-9]*

54

19 .20 .21 .22 .23 .24 .25 .26 .27 .28 .

19 .20 .21 .22 .23 .24 .25 .26 .27 .28 .

%%

{ComentLinha} { /* despreza */ }{Espaco} { /* despreza */ }{Ident} { System.out.println ("id=" + yytext() +" linha= "+ yyline +" coluna = "+ yycolumn); }{Inteiro} { System.out.println ("int=" + yytext()); }

.|\n { throw new Error("Caractere Ilegal <" +yytext()+">"); }

abcde// linha comentadaabcabc123123abcd

123abc

abcde// linha comentadaabcabc123123abcd

123abc

id=abcde linha= 0 coluna = 0id=abc linha= 2 coluna = 0id=abc123 linha= 3 coluna = 0int=123id=abcd linha= 4 coluna = 3int=123id=abc linha= 8 coluna = 3

id=abcde linha= 0 coluna = 0id=abc linha= 2 coluna = 0id=abc123 linha= 3 coluna = 0int=123id=abcd linha= 4 coluna = 3int=123id=abc linha= 8 coluna = 3

Entrada: Saída:

55

• Inserir um caractere inválido (ex: "@") no arquivo de entrada e executar a especificação anterior.

• Responder: é possível construir uma especificaçãoLex que reconheça fórmulas matemáticas sintaticamentecorretas, com operandos, operadores e parêntesisaninhados?

Exemplo:

12*((5 + 2) / (3 - 1))

Lex Lex - exercícios- exercícios

56

• No exemplos exibidos até agora, Lex é usado para gerar um programa que processa toda a entrada de uma vez.

• Como explicado anteriormente, outra importante utilização de Lex é na separação da entrada em unidades léxicas, para ser usado em conjunto com um analisador sintático.

Lex Lex - uso com analisador sintático- uso com analisador sintático

57

Lex

Yylex

regrasléxicas

entradaYacc

Yyparse

regrassintáticas

saída


58

• Quando Lex é usado em conjunto com um analisador sintático, uma classe Main não é gerada.

• Lex gera um método yylex que retorna a unidade léxica que foi extraída do texto de entrada.

• O método yylex deve ser seguidamente executado pelo analisador sintático, para obter essas unidades sintáticas, chamadas tokens.

• Algumas ações devem conter comandos return, que retornam o token que foi extraído, para o analisador sintático.


59

1 .2 .3 .4 .5 .6 .7 .8 .9 .

1 .2 .3 .4 .5 .6 .7 .8 .9 .

import java_cup.runtime.Symbol;

%%

%cup%debug...

%%

...{Ident} { return new Symbol(sym.IDENT, yytext());}...

Usa classe Symboldefinida em java_cup

Usa classe Symboldefinida em java_cup

Usa java_cupUsa java_cup

Diretiva para teste: criauma função Main artificial

Diretiva para teste: criauma função Main artificial

Retorna um token.O código do token é definidono analisador sintático.

Retorna um token.O código do token é definidono analisador sintático.

60

GramáticasGramáticas

61

• Gramáticas são um formalismo utilizado para especificação de linguagens.

• Em uma gramática, os símbolos são classificados como terminais (símbolos que formam as palavras da linguagem) e não terminais.

• Os símbolos não terminais são também chamados de variáveis.

• O processo de geração de palavras é denominado derivação, e consiste em regras de reescrita dos símbolos não terminais.

Gramáticas - DefiniçãoGramáticas - Definição

62

• Exemplo:<S> -> a<A><A> -> a<A> | b | b -> c | c

• No exemplo acima, símbolos entre < > são considerados como não terminais ( <S>, <A>, ). Os demais são os símbolos terminais ( a, b, c ).

• Cada regra é composta de um lado esquerdo e um lado direito, separados por -> .

• O único tipo de gramática que vamos estudar são as gramáticas livres de contexto, em que o lado esquerdo é apenas uma variável (não terminal).

Gramáticas - ExemploGramáticas - Exemplo

63

• Exemplo:<S> -> a<A>

<A> -> a<A> | b | b

 -> c | c

• As regras -> c | c são uma abreviação para as regras -> c e -> c .

• Uma das variáveis é denominada símbolo inicial. Para simplificar, vamos supor que seja o símbolo do lado esquerdo da primeira regra (neste caso, <S> ).

• Outra simplificação: geralmente, usa-se maiúsculas para variáveis e minúsculas para terminais, dispensando <> .

Gramáticas - ExemploGramáticas - Exemplo

64

• Exemplo:S -> aA

A -> aA | bB | b

B -> cB | c

• Uma derivação é uma seqüência de palavras formadas por símbolos terminais e variáveis, onde cada palavra é derivada da anterior.

• Uma palavra y é derivada de x (escrevemos x => y) se y pode ser obtida substituindo uma variável v de x por algum lado direito das regras de v.

• Por exemplo, são válidas as seguintes relações :

aabB => aabc , aaA => aaaA , ABAB => AcAB

Gramáticas - DerivaçãoGramáticas - Derivação

65

• Exemplo:S -> aA

A -> aA | bB | b

B -> cB | c

• Exemplo de derivação :

aaA => aaaA => aaaaA => aaaabB => aaaabcB• Usa-se a abreviação =>* para indicar derivação em 0

ou mais passos: aaA =>* aaaabcB• Derivações de interesse, para uma gramática, são

aquelas cuja primeira palavra é o símbolo inicial, e a última palavra contém apenas símbolos terminais.

Gramáticas - DerivaçãoGramáticas - Derivação

66

• Exemplo:S -> aA

A -> aA | bB | b

B -> cB | c

• Derivações de palavras com terminais a partir de S :

S => aA => aaA => aab

S => aA => abB => abcB => abccB => abccc

S =>* aaabcc• A linguagem gerada por uma gramática é o

conjunto de palavras apenas com símbolos terminais, derivadas a partir do símbolo inicial.

Linguagem de uma gramáticaLinguagem de uma gramática

67

1. Usando a gramática abaixo:S -> aA

A -> aA | bB | b

B -> cB | c

mostre todos os passos das seguintes derivações:

S =>* ab

S =>* aaabcc

2. Qual é a palavra de menor comprimento, apenas com símbolos terminais, que pode ser derivada a partir do símbolo inicial da gramática acima?

3. Qual é a linguagem gerada pela gramática acima?

ExercíciosExercícios

68

• Exemplo:S -> aA

A -> aA | bB | b

B -> cB | c

• A linguagem gerada pela gramática acima é o conjunto de palavras sobre {a,b,c} que começam com a (uma ou mais ocorrências), seguido de exatamente um b, seguido de qualquer número de c.

• Ou seja, a linguagem gerada por essa gramática é: a+bc*

• MAS: gramáticas podem gerar linguagens bem mais complexas que as expressas por expressões regulares!

Linguagem de uma gramáticaLinguagem de uma gramática

69

• Gramáticas com regras cujo lado esquerdo é apenas uma variável são chamadas gramáticas livres de contexto.

• As linguagens geradas por gramáticas livres de contextro são chamadas linguagens livres de contexto.

• As gramáticas regulares são um subconjunto das gramáticas livres de contexto. São aquelas com regras cujo lado direito é λ, ou é composto apenas de um terminal, ou então um terminal seguido de uma variável.

• A gramática usada nos exemplos anteriores é regular.• As linguagens geradas por gramáticas regulares são

chamadas de linguagens regulares.

Regulares X Livres de ContextoRegulares X Livres de Contexto

70

• Exemplo:S -> aSb | λ

• Algumas palavras geradas pela gramática acima:

Gramáticas Livres de ContextoGramáticas Livres de Contexto

S => λ

S => aSb => ab

S => aSb => aaSbb => aabb

S => aSb => aaSbb => aaaSbbb => aaabbb

• Qual é a linguagem gerada pela gramática acima?

Resposta: o conjunto de palavras sobre {a,b} com o formato anbn , n ≥ 0.

71

• Exemplo:S -> aSB | λ

B -> bb



S => λ

S => aSB => aB => abb

S => aSB => aaSBB => aaBB => aabbB => aabbbb

S => aSB => aaSBB => aaaSBBB => aaaBBB => aaabbBB =>

=> aaabbbbB => aaabbbbbb


É o conjunto de palavras sobre {a,b} com o formato anb2n , n ≥ 0.

72

• Exemplo:S -> aSbb | A

A -> Ac | λ



S => A => λ

S => aSbb => aAbb => abb

S => aSbb => aaSbbbb => aaAbbbb => aacbbbb

S => aSbb => aAbb => aAcbb => aAccbb => aAcccbb =>

=> aAcccbb => acccbb


É o conjunto de palavras sobre {a,b,c} com o formato ancmb2n , m,n ≥ 0.

73

• Construir uma gramática sobre o alfabeto

{ a, b, c, +, -, (, ) }

para gerar fórmulas matemáticas sintaticamente corretas em que a, b e c são operandos, + e - são operadores, e os parêntesis são corretamente aninhados.

ExercícioExercício

74


B -> bb

• Árvore de derivação para a palavra aaabbbbbb:

Árvores de DerivaçãoÁrvores de Derivação

S

a S B

a S B

a S B

λ

bb

bb

bb

75


B -> bb



S

a S B

a S B

a S B

λ

bb

bb

bb

76


B -> bb



S

a S B

a S B

a S B

λ

bb

bb

bb

77


B -> bb



S

a S B

a S B

a S B

λ

bb

bb

bb

78


B -> bb



S

a S B

a S B

a S B

λ

bb

bb

bb

79


B -> bb



S

a S B

a S B

a S B

λ

bb

bb

bb

80


B -> bb



S

a S B

a S B

a S B

λ

bb

bb

bb

81


B -> bb



S

a S B

a S B

a S B

λ

bb

bb

bb

83

• Algumas gramáticas são ambíguas. Isso significa que uma mesma palavra (só com terminais) pode ser derivada de duas formas diferentes, mesmo que seja sempre escolhida uma mesma ordem para substituição das variáveis.

• Duas gramáticas diferentes podem gerar a mesma linguagem, sendo uma das gramáticas ambígua e a outra não ambígua.

• Gramáticas ambíguas não são muito adequadas para a construção automática de analisadores sintáticos.

• Algumas linguagens são inerentemente ambíguas. Isso quer dizer que é impossível construir uma gramática não ambígua que gere essas linguagens.

AmbigüidadeAmbigüidade

84

Yacc - Gerador deYacc - Gerador deAnalisadores SintáticosAnalisadores Sintáticos

(Yacc =Yet Another Compiler-Compiler)(Yacc =Yet Another Compiler-Compiler)

85

• Auxilia no processo de definição do formato da entrada para um programa.

• Uma especificação Yacc:– regras que descrevem a estrutura da entrada;– ações que devem ser executadas quando cada

regra é utilizada;• Os exemplos utilizados nesta apresentação seguirão

o formato do programa Javacup, um clone de Yacc que gera código em Java.

Yacc - Gerador deYacc - Gerador deAnalisadores SintáticosAnalisadores Sintáticos

86

Yacc Yacc - exemplo usando Javacup- exemplo usando Javacup

1 .2 .3 .4 .5 .6 .7 .8 .9 .10 .11 .12 .13 .14 .

1 .2 .3 .4 .5 .6 .7 .8 .9 .10 .11 .12 .13 .14 .

import java_cup.runtime.*;

terminal PTVIRG, MAIS, MENOS, INTEIRO;non terminal expr_list, expr_ptv, expr;

expr_list ::= expr_list expr_ptv | expr_ptv;expr_ptv ::= expr PTVIRG;expr ::= expr MAIS expr | expr MENOS expr | INTEIRO;

Declaração de símbolosterminais e não terminais

Declaração de símbolosterminais e não terminais

Gramática: lista de regrasseparadas por ";" .

Gramática: lista de regrasseparadas por ";" .

87

• A especificação apresentada tem como símbolos terminais: PTVIRG, MAIS, MENOS e INTEIRO.

• Se esse símbolos corresponderem a ';', '+', '-' e números inteiros, respectivamente, então a linguagem reconhecida é uma lista de expressões separadas por ';'. O operadores são '+' e '-' .

• Para gerar um analisador sintático, vamos usar o Javacup (supondo especificação em um arquivo ex1.cup) :

Yacc Yacc - geração de um analisador- geração de um analisador

> java java_cup.Main ex1.cup> java java_cup.Main ex1.cup

java_cup é um programaescrito em Java!

java_cup é um programaescrito em Java!

88

• A gramática utilizada possui várias ambigüidades, que causam conflitos no analisador sintático.

Yacc Yacc - conflitos na gramática- conflitos na gramática

> java java_cup.Main ex1.cupOpening files...Parsing specification from standard input......*** Shift/Reduce conflict found in state #9...*** More conflicts encountered than expected -- parser generation aborted...

> java java_cup.Main ex1.cupOpening files...Parsing specification from standard input......*** Shift/Reduce conflict found in state #9...*** More conflicts encountered than expected -- parser generation aborted...

89

• Por exemplo, considere a entrada: 1 - 2 + 3;

Yacc Yacc - conflitos na gramática- conflitos na gramática

expr_list

expr_ptv

expr ;

expr - expr

expr + exprINTEIRO

2 3

expr_list

expr_ptv

expr ;

expr + expr

expr - expr

3

1 2

OU

1INTEIRO INTEIRO INTEIRO INTEIRO

INTEIRO

90

Yacc Yacc - reescrevendo especificação- reescrevendo especificação

1 .2 .3 .4 .5 .6 .7 .8 .9 .10 .11 .12 .13 .14 .

1 .2 .3 .4 .5 .6 .7 .8 .9 .10 .11 .12 .13 .14 .

import java_cup.runtime.*;

terminal PTVIRG, MAIS, MENOS, INTEIRO;non terminal expr_list, expr_ptv, expr;

expr_list ::= expr_list expr_ptv | expr_ptv;expr_ptv ::= expr PTVIRG;expr ::= INTEIRO MAIS expr | INTEIRO MENOS expr | INTEIRO;

Ambigüidades eliminadasAmbigüidades eliminadas

91

Yacc Yacc - reescrevendo especificação- reescrevendo especificação

> java java_cup.Main ex2.cupOpening files...Parsing specification from standard input...Checking specification......Writing parser...Closing files...------- CUP v0.10k Parser Generation Summary ------- 0 errors and 0 warnings... 0 productions never reduced. 0 conflicts detected (0 expected). Code written to "parser.java", and "sym.java".----------------------------------------------------

> java java_cup.Main ex2.cupOpening files...Parsing specification from standard input...Checking specification......Writing parser...Closing files...------- CUP v0.10k Parser Generation Summary ------- 0 errors and 0 warnings... 0 productions never reduced. 0 conflicts detected (0 expected). Code written to "parser.java", and "sym.java".----------------------------------------------------

• Supondo nova especificação em um arquivo ex2.cup :

92

• Os arquivos gerados pelo Javacup foram parser.java e sym.java. O primeiro contém o analisador sintático (parser). O segundo contém uma definição para símbolos terminais.

• Conteúdo do arquivo sym.java:

Yacc Yacc - arquivos gerados- arquivos gerados

1 .2 .3 .4 .5 .6 .7 .8 .

1 .2 .3 .4 .5 .6 .7 .8 .

public class sym { public static final int MAIS = 3; public static final int PTVIRG = 2; public static final int error = 1; public static final int MENOS = 4; public static final int EOF = 0; public static final int INTEIRO = 5;}

93

• Falta especificar um procedimento que extrai os tokens do arquivo de entrada, classificando-os como PTVIRG, MAIS, MENOS ou INTEIRO.

• Esse procedimento é geralmente chamado de scanner.

• Isso será feito usando um analisador léxico automaticamente gerado com JFlex.

Yacc Yacc - especificando "scanner"- especificando "scanner"

94

Yacc Yacc - especificando "scanner"- especificando "scanner"

1 .2 .3 .4 .5 .6 .7 .8 .9 .10 .11 .12 .13 .14 .15 .16 .17 .

1 .2 .3 .4 .5 .6 .7 .8 .9 .10 .11 .12 .13 .14 .15 .16 .17 .

import java_cup.runtime.*;%%

%cupFimdeLinha = \r|\n|\r\nEspaco = {FimdeLinha} | [ \t]Inteiro = 0 | [1-9][0-9]*

%%{Espaco} { /* despreza */ }{Inteiro} { return new Symbol (sym.INTEIRO); }"+" { return new Symbol (sym.MAIS); }"-" { return new Symbol (sym.MENOS); }";" { return new Symbol (sym.PTVIRG); }

.|\n { throw new Error("Caractere Ilegal <"+ yytext()+">"); }

Usa classe Symbol, definidaem java_cup.runtime,e os códigos de sym.java.

Usa classe Symbol, definidaem java_cup.runtime,e os códigos de sym.java.

95

• Finalmente, falta especificar uma função Main, que irá fazer as inicializações necessárias e chamar o analisador sintático.

• O analisador sintático, por sua vez, irá chamar o analisador léxico para extrair os tokens do arquivo de entrada.

Yacc Yacc - especificando "Main"- especificando "Main"

96

Yacc Yacc - especificando "Main"- especificando "Main"

1 .2 .3 .4 .5 .6 .7 .8 .9 .10 .11 .12 .13 .

1 .2 .3 .4 .5 .6 .7 .8 .9 .10 .11 .12 .13 .

import java.io.*; class Main { static public void main(String argv[]) { /* Inicia o parser */ try { parser p = new parser(new Yylex(System.in)); Object result = p.parse().value; } catch (Exception e) { e.printStackTrace(); } }}

97

• Suponha que tenhamos então os seguintes arquivos:– ex2.cup : especificação que será submetida ao Javacup;– ex2.flex : especificação que será submetida ao JFlex;– Main.java : contém a função Main.

• O procedimento completo para gerar um analisador sintático será:

Yacc Yacc - procedimento completo- procedimento completo

> java java_cup.Main ex2.cup...> jflex ex2.flex...> javac Main.java

> java java_cup.Main ex2.cup...> jflex ex2.flex...> javac Main.java

98

Yacc Yacc - usando o analisador gerado- usando o analisador gerado

> java Main1+2;1-2+3;^Z

> java Main1+2;1-2+3;1 1;Syntax errorCouldn't repair and continue parse...

> java Main1+2;1-2+3;^Z

> java Main1+2;1-2+3;1 1;Syntax errorCouldn't repair and continue parse...

99

• Um analisador que só verifica a sintaxe de uma entrada tem pouca utilidade.

• Ferramentas como Javacup permitem associar valores aos símbolos e ações às regras.

• Uma ação é um trecho de programa que é associado a uma regra. Pode ser executado em qualquer ponto da derivação, quando a regra é utilizada.

• Um valor pode ser associado a um símbolo terminal no analisador léxico. No analisador sintático, um valor pode ser associado a um símbolo não terminal, recursivamente.

Yacc Yacc - valores e ações- valores e ações

100

Yacc Yacc - valores no JFlex- valores no JFlex

1 .2 .3 .4 .5 .6 .7 .8 .9 .10 .

1 .2 .3 .4 .5 .6 .7 .8 .9 .10 .

{Espaco} { /* despreza */ }

{Inteiro} { int aux = Integer.parseInt (yytext()); return new Symbol (sym.INTEIRO, new Integer(aux));}

"+" { return new Symbol (sym.MAIS); }"-" { return new Symbol (sym.MENOS); }";" { return new Symbol (sym.PTVIRG); }

• A classe Symbol possui construtores que permitem a especificação de um valor (Object) associado ao token.

• Trecho da nova especificação para o JFlex:

Valor associadoao token.

Valor associadoao token.

101

Yacc Yacc - valores no Javacup- valores no Javacup• No Javacup, na declaração de símbolos terminais e não

terminais, pode-se especificar um TIPO associado.• Trecho da nova especificação para o Javacup:

Tipo associadoao símbolo.

Tipo associadoao símbolo.

1 .2 .3 .4 .5 .6 .7 .

1 .2 .3 .4 .5 .6 .7 .

terminal PTVIRG, MAIS, MENOS;

terminal Integer INTEIRO;

non terminal Object expr_list, expr_ptv;

non terminal Integer expr;

102

Yacc Yacc - valores no Javacup- valores no Javacup

1 .2 .

1 .2 .

expr_ptv ::= expr:e {: System.out.println("= " + e); :} PTVIRG;

• As ações são trechos de programa delimitados por {: ... :}.• A cada token, é possível associar um identificador, para

que o seu valor possa ser acessado dentro da ação.• Trecho da nova especificação para o Javacup:

Usa o valor de edentro da ação.

Usa o valor de edentro da ação.

Delimitadoresde ação.

Delimitadoresde ação.

Imprime valor da expressão,imediatamente antes dereconhecer ';' .

Imprime valor da expressão,imediatamente antes dereconhecer ';' .

103

Yacc Yacc - valores no Javacup- valores no Javacup

• A palavra-chave RESULT indica o valor do símbolo da esquerda da regra sendo utilizada.

• Trecho da nova especificação para o Javacup:

1 .2 .3 .4 .5 .6 .7 .8 .

1 .2 .3 .4 .5 .6 .7 .8 .

expr ::= INTEIRO:n MAIS expr:e {: RESULT = new Integer(n.intValue() + e.intValue()); :} | INTEIRO:n MENOS expr:e {: RESULT = new Integer(n.intValue() - e.intValue()); :} | INTEIRO:n {: RESULT = n; :} ;

104

• Suponha especificações em ex3.cup e ex3.flex:


> java java_cup.Main ex3.cup...> jflex ex3.flex...> javac Main.java> java Main1;= 11+1;= 21-1;= 01-2-3;= 2^Z

> java java_cup.Main ex3.cup...> jflex ex3.flex...> javac Main.java> java Main1;= 11+1;= 21-1;= 01-2-3;= 2^Z

???O problema é a incorreta

associatividade!

???O problema é a incorreta

associatividade!

105

• Usando a gramática abaixo:

expr_list ->

expr_list expr_ptv

| expr_ptv

expr_ptv -> expr PTVIRG

expr ->

INTEIRO MAIS expr

| INTEIRO MENOS expr

| INTEIRO

construir a árvore de derivação de : 1 - 2 - 3;

ExercícioExercício

106

• Derivação de: 1 - 2 - 3;

Yacc Yacc - associatividade- associatividade

expr_ptv

expr ;

INTEIRO - expr

INTEIRO - expr1

2

3

INTEIRO

Associatividadeà direita!

Associatividadeà direita!

107

Yacc Yacc - alterando associatividade- alterando associatividade

• Trecho da nova especificação para o Javacup, implementando associatividade à esquerda para os operadores '+' e '-' :

1 .2 .3 .4 .5 .6 .7 .8 .

1 .2 .3 .4 .5 .6 .7 .8 .

expr ::= expr:e MAIS INTEIRO:n {: RESULT = new Integer(e.intValue() + n.intValue()); :} | expr:e MENOS INTEIRO:n {: RESULT = new Integer(e.intValue() - n.intValue()); :} | INTEIRO:n {: RESULT = n; :}; ;

108

• Derivação de: 1 - 2 - 3;

Yacc Yacc - associatividade à esquerda- associatividade à esquerda

expr_ptv

expr ;

expr - INTEIRO

expr - INTEIRO 3

2

1

INTEIRO

Associatividadeà esquerda!

Associatividadeà esquerda!

109

• Suponha especificações em ex4.cup e ex4.flex:


> java java_cup.Main ex4.cup...> jflex ex4.flex...> javac Main.java> java Main1;= 11+1;= 21-1;= 01-2-3;= -4^Z

> java java_cup.Main ex4.cup...> jflex ex4.flex...> javac Main.java> java Main1;= 11+1;= 21-1;= 01-2-3;= -4^Z

OK!OK!

110

Yacc Yacc - associatividade e precedência- associatividade e precedência

• A associatividade de operadores é uma característica tão importante em gramáticas que a maioria dos clones de Yacc possuem diretivas para simplificar sua especificação.

• Suponha que, além dos operadores representados por MAIS e MENOS, a gramática possua VEZES e DIVISAO.

• As diretivas abaixo determinam a precedência e a associatividade desses operadores:

1 .2 .

1 .2 .

precedence left MAIS, MENOS;precedence left VEZES, DIVISAO;

111

Yacc Yacc - associatividade e precedência- associatividade e precedência

• Usando as diretivas apresentadas, não é mais necessário construir as regras de modo que a derivação defina a associatividade e precedência.

• Trecho da nova especificação:

1 .2 .3 .4 .5 .6 .7 .8 .9 .10 .

1 .2 .3 .4 .5 .6 .7 .8 .9 .10 .

expr ::= expr:e1 MAIS expr:e2 {: RESULT = new Integer(e1.intValue()+e2.intValue()); :} | expr:e1 MENOS expr:e2 {: RESULT = new Integer(e1.intValue()-e2.intValue()); :} | expr:e1 VEZES expr:e2 {: RESULT = new Integer(e1.intValue()*e2.intValue()); :} | expr:e1 DIVISAO expr:e2 {: RESULT = new Integer(e1.intValue()/e2.intValue()); :} ...

1 Linguagens Formais, Lex & Yacc Vladimir Oliveira Di Iorio Linguagens Formais, Lex & Yacc Vladimir...

Documents

Transcript of 1 Linguagens Formais, Lex & Yacc Vladimir Oliveira Di Iorio Linguagens Formais, Lex & Yacc Vladimir...