compiladores - w3.ualg.ptw3.ualg.pt/~jmcardo/ensino/comp04/guiacompiladores.pdf · caderno de...

Caderno de exercícios e trabalhos práticos para a disciplina de:

COMPILADORES

Julho de 2003 - Julho de 2004

João M. P. Cardoso Universidade do Algarve Faculdade de Ciências e Tecnologia Campus de Gambelas 8000-117 Faro Email: [email protected] URL: http://w3.ualg.pt/~jmcardo Curso de Licenciatura em Engenharia de Sistemas e Informática Curso de Licenciatura em Ensino de Informática Curso de Licenciatura em Informática (ramo tecnológico e ramo de gestão)

CADERNO DE EXERCÍCIOS E TRABALHOS PRÁTICOS PARA A DISCIPLINA DE COMPILADORES

©João M. P. Cardoso 2

Índice

FICHA 1. Utilização da ferramenta make ..............................................................5

1.1 Verificar a diferença entre os tempos de execução de uma aplicação na

presença ou ausência de opções de optimização de compilação. ..............................5

1.2 Criação de uma makefile ...............................................................................6

FICHA 2. Optimizações de código.........................................................................8

2.1 Verificar a diferença entre o tempo de execução utilizando o interpretador e

utilizando o compilador JIT .......................................................................................8

2.2 Optimizações..................................................................................................9

2.3 Propagação de constantes (Constant Propagation) ......................................10

2.4 Constant folding (Constant-Expression Evaluation) ...................................11

2.5 Desenrolamento de ciclos (Loop Unrolling)................................................12

2.6 Simplificação algébrica (Algebraic simplification) .....................................12

2.7 Desenrolamento de ciclos (Loop Unrolling)................................................13

2.8 Simplificações algébricas + constant folding ..............................................14

2.9 Scalar replacement .......................................................................................14

2.10 Simplificação algébrica................................................................................15

2.11 Eliminação de código ou de declarações não utilizadas ..............................16

2.12 Strength reduction........................................................................................16

2.13 Depois de simplificações algébricas e reassociação ....................................17

2.14 Depois de CSE (eliminação de sub-expressões comuns): ...........................17

2.15 Sumário ........................................................................................................18



FICHA 3. Introdução ao Processamento de Linguagens ......................................19

3.1 Exercícios.....................................................................................................19

FICHA 4. Introdução aos Algoritmos Iterativos...................................................21

4.1 Algoritmo Iterativo para Determinar Funções Recursivas ..........................21

4.2 Transitive Closure........................................................................................22

4.3 Algoritmo Iterativo para Transitive Closure................................................22

4.4 Exercício 1 ...................................................................................................23

4.5 Código Java..................................................................................................23

4.6 Classe Graph.java ........................................................................................23

4.7 Classe TransitiveClosure.java......................................................................25

4.8 Trabalho para Casa ......................................................................................26

4.9 Créditos ........................................................................................................26

FICHA 5. Exercícios sobre Expressões Regulares e Autómatos Finitos..............27

5.1 Exercícios com Expressões Regulares.........................................................27

5.2 Exercícios com Autómatos Finitos ..............................................................27

FICHA 6. Implementação manual de um analisador lexical ................................30

6.1 Exercícios.....................................................................................................30

6.2 Notas ............................................................................................................31

FICHA 7. Exercícios sobre Gramáticas................................................................32

FICHA 8. Implementação manual de um analisador sintáctico descendente .......35

FICHA 9. Implementação de Analisadores Gramaticais Utilizando o JavaCC (1ª

parte) 36



9.1 Exemplo .......................................................................................................36

9.2 Exercícios.....................................................................................................39

9.3 Referências de Apoio...................................................................................39


parte) 40

10.1 Exercício ......................................................................................................40


parte) 41

11.1 Exemplo .......................................................................................................41

11.2 Referências de Apoio...................................................................................52

FICHA 12. Trabalho Final ......................................................................................53

12.1 Exercício ......................................................................................................53

12.2 Gramática Inicial da Linguagem..................................................................56

12.3 Algumas Dicas .............................................................................................57

12.4 Documentação e Ferramentas de Suporte....................................................57

Anexo B: Enunciado de um Exame .............................................................................59



FICHA 1. Utilização da ferramenta make1

Duração: 3 horas

Esta aula tem como objectivo a utilização de makefiles. Será demonstrada a sua

utilidade na compilação de uma aplicação, fazendo variar algumas opções de

compilação. A criação de uma makefile será estudada para um programa exemplo.

1.1 Verificar a diferença entre os tempos de execução

de uma aplicação na presença ou ausência de

opções de optimização de compilação. Procedimentos:

Após copiar o ficheiro JASPA_1.0.tar.gz para a área de trabalho deve descompactá-lo

(sugestão: tar xvfz ficheiro).

Mudando para o directório JASPA, com um editor à escolha, comente a 4ª linha do

ficheiro MakeFile que determina a compilação usando F90. Edite o ficheiro

common.make e remova a secção respeitante ao F90.

Para verificar a correcta instalação da aplicação, emita os seguintes comandos:

$ make

$ cd matrices

$ java jaspa memplus.mtx

$ jaspa_c memplus.mtx

Copie para o directório matrices, o ficheiro m48.mtx.

1 Exercício concebido pela Eng.ª Margarida Moura (assistente da disciplina no ano

lectivo de 2002/2003)



Voltando para o directório JASPA, edite o ficheiro common.make e comente as linhas

de CFLAGS e JAVAFLAGS.

Emita os comandos:

$ make

$ cd matrices

$ java jaspa m48.mtx



Anote os resultados obtidos.

$ jaspa_c m48.mtx

$ jaspa_c m48.mtx

$ jaspa_c m48.mtx

Anote os resultados obtidos.

Voltando para o directório JASPA, edite o ficheiro common.make e retire a marca de

comentário das linhas de CFLAGS e JAVAFLAGS. Repita os comandos anteriores e

anote os resultados obtidos.

1.2 Criação de uma makefile Esta secção tem como objectivo relembrar a utilização de makefiles.

Sugere-se a leitura inicial de Criando Makefiles: Um Mini Tutorial

(http://www.gazetadolinux.com/pr/lg/issue83/heriyanto.html).

Para uma descrição detalhada, recomenda-se a leitura no manual do GNU make que

pode ser encontrado em http://www.gnu.org/software/make/manual/make.html

Procedimentos iniciais:



Transfira para a sua área o ficheiro exer2.zip, e descompacte-o. Compile os

programas executando o comando $ make

Execute os programas com os comandos: $ prog0 dados_bbig.dat 370000 result.dat

$ prog1 dados_bbig.dat 370000 result.dat

Crie, na sua área, a estrutura de directórios da figura abaixo.

Figura 1. Árvore de directórios

Organize os programas por directórios de forma que:

file_func.c fique em gerais

exemplo1.c, exemplo2.c e exemplo3.c fiquem em func

prog0.c e prog1.c fiquem em src

a) Elabore uma makefile em Corrente que proceda à compilação dos programas,

guardando os executáveis em bin.

b) Modifique a makefile de forma que esta provoque a execução sucessiva dos dois

programas.

c) Modifique novamente a makefile de forma a que a linha emitida por um programa

seja enviada para um ficheiro com o nome do programa e a extensão log. Acrescente

uma regra que, usando o diff permita comparar os dois ficheiros.



FICHA 2. Optimizações de código

Duração: 3 horas

Esta aula tem como objectivo a utilização de algumas das optimizações de código

realizadas pelos compiladores. Algumas dessas optimizações não dependem do

processador alvo para garantirem sempre bons resultados. As optimizações do tipo

anterior e cujo impacto será avaliado são:

• Propagação de constantes (Constant propagation);

• Avaliação de expressões com constantes (Constant folding ou Constant-

Expression evaluation);

• Simplificações algébricas (Algebraic Simplifications)

• Substituição por escalares (Scalar replacement)

• Redução do custo (Strength reduction)

• Eliminação de sub-expressões comuns (Common-Subexpression elimination -

CSE)

• Eliminação de código e de declarações não utilizadas

• Desenrolamento de ciclos (Loop unrolling)

Após leitura desta ficha e verificação das melhorias no tempo de execução, descreva

cada uma das optimizações anteriores.

2.1 Verificar a diferença entre o tempo de execução

utilizando o interpretador e utilizando o

compilador JIT O programa exemplo que vamos utilizar é formado pelas classes em bytecodes e por

uma classe para a qual é dada o ficheiro Java original. Para executar o programa deve

primeiro compilar o ficheiro Filter.java e depois executar um dos comandos seguintes:

Utilizando o interpretador: Java –Xint DrawImage

Utilizando o compilador JIT (por omissão): Java DrawImage



Verifique os tempos de execução de cada um dos algoritmos apresentados.

A Figura 2 apresenta o resultado da execução do referido programa.

Figura 2. Appet Java utilizada para que os alunos possam verificar o impacto no

desempenho da utilização de determinadas transformações (optimizações) ao

nível do código da aplicação.

2.2 Optimizações Vamos considerar a função doFIR apresentada em baixo e que é um método da classe

Filter.java. Este método, como pôde constatar anteriormente implementa um

algoritmo de processamento de imagem que reduz o ruído de uma imagem. De

seguida vamos realizar manualmente um conjunto de optimizações, que integram ou

constam como opções de alguns compiladores e que permitem melhorar o

desempenho.

final public static short[] doFIR(short[] IN) {

short[] K = {1, 2, 1,

2, 4, 2,

1, 2, 1};

int DIM = 350;

short[] OUT = new short[DIM*DIM];



for (int row=0; row < DIM-3+1; row++) {

for (int col = 0; col< DIM-3+1; col++) {

int sumval = 0;

for (int wrow=0; wrow < 3; wrow++) {

for (int wcol = 0; wcol<3; wcol++) {

sumval += IN[(row +wrow)*DIM+(col+wcol)]*K[wrow*3+wcol];

}

}

sumval = sumval / 16;

OUT[row * DIM + col] = (short) sumval;

}

}

return OUT;

}

2.3 Propagação de constantes (Constant Propagation) final public static short[] doFIR(short[] IN) {

short[] K = {1, 2, 1,

2, 4, 2,

1, 2, 1};

short[] OUT = new short[350*350];

for (int row=0; row < 350-3+1; row++) {

for (int col = 0; col< 350-3+1; col++) {

int sumval = 0;



sumval += IN[(row +wrow)*350+(col+wcol)]*K[wrow*3+wcol];

}

}


OUT[row * 350 + col] = (short) sumval;

}

}

return OUT;

}



2.4 Constant folding (Constant-Expression

Evaluation) final public static short[] doFIR(short[] IN) {

short[] K = {1, 2, 1,

2, 4, 2,

1, 2, 1};

short[] OUT = new short[350*350];

for (int row=0; row < 350-3+1; row++) {

for (int col = 0; col< 350-3+1; col++) {

int sumval = 0;



sumval+= IN[(row +wrow)*350+(col+wcol)]*K[wrow*3+wcol];

}

}



}

}

return OUT;

}

Depois de aplicar constant folding:


short[] K = {1, 2, 1,

2, 4, 2,

1, 2, 1};

short[] OUT = new short[122500];

for (int row=0; row < 348; row++) {

for (int col = 0; col< 348; col++) {

int sumval = 0;




}

}



122500

348



}

}

return OUT;

}

2.5 Desenrolamento de ciclos (Loop Unrolling) for (int wcol = 0; wcol<3; wcol++) {


}

Obtém-se:


short[] K = {1, 2, 1,

2, 4, 2,

1, 2, 1};




int sumval = 0;


sumval+= IN[(row +wrow)*350+(col+0)]*K[wrow*3+0];



}



}

}

return OUT;

}

2.6 Simplificação algébrica (Algebraic simplification) final public static short[] doFIR(short[] IN) {

short[] K = {1, 2, 1,

2, 4, 2,

1, 2, 1};






int sumval = 0;


sumval+= IN[(row +wrow)*350+col])*K[wrow*3];

sumval+= IN[(row +wrow)*350+(col+1)])*K[wrow*3+1];

sumval+= IN[(row +wrow)*350+(col+2)])*K[wrow*3+2];

}



}

}

return OUT;

}

2.7 Desenrolamento de ciclos (Loop Unrolling) for (int wrow=0; wrow < 3; wrow++) {

sumval+= IN[(row +wrow)*350+col]*K[wrow*3];



}

Obtém-se:


short[] K = {1, 2, 1,

2, 4, 2,

1, 2, 1};




int sumval = 0;

sumval+= IN[(row +0)*350+col]*K[0*3];

sumval+= IN[(row +0)*350+(col+1)]*K[0*3+1];












}

}

return OUT;

}

2.8 Simplificações algébricas + constant folding final public static short[] doFIR(short[] IN) {

short[] K = {1, 2, 1,

2, 4, 2,

1, 2, 1};




int sumval= IN[row*350+col]*K[0];

sumval+= IN[row*350+(col+1)]*K[1];

sumval+= IN[row*350+(col+2)]*K[2];

sumval+= IN[(row +1)*350+col]*K[3];

sumval+= IN[(row +1)*350+(col+1)]*K[4];


sumval+= IN[(row +2)*350+col]*K[6];





}

}

return OUT;

}

2.9 Scalar replacement final public static short[] doFIR(short[] IN) {

short[] K = {1, 2, 1,

2, 4, 2,

1, 2, 1};






int sumval= IN[row*350+col]*1;

sumval+= IN[row*350+(col+1)]*2;

sumval+= IN[row*350+(col+2)]*1;

sumval+= IN[(row +1)*350+col]*2;

sumval+= IN[(row +1)*350+(col+1)]*4;

sumval+= IN[(row +1)*350+(col+2)]*2;


sumval+= IN[(row +2)*350+(col+1)]*2;

sumval+= IN[(row +2)*350+(col+2)]*1;



}

}

return OUT;

}

2.10 Simplificação algébrica final public static short[] doFIR(short[] IN) {

short[] K = {1, 2, 1,

2, 4, 2,

1, 2, 1};




int sumval= IN[row*350+col];

sumval+= IN[row*350+col+1]*2;

sumval+= IN[row*350+col+2];


sumval+= IN[(row +1)*350+col+1]*4;


sumval+= IN[(row +2)*350+col];


sumval+= IN[(row +2)*350+col+2];



}

}

return OUT;

}



2.11 Eliminação de código ou de declarações não

utilizadas final public static short[] doFIR(short[] IN) {





sumval+= IN[row*350+col+1]*2;










}

}

return OUT;

}

2.12 Strength reduction final public static short[] doFIR(short[] IN) {





sumval+= IN[row*350+col+1]<<1;


sumval+= IN[(row +1)*350+col]<<1;

sumval+= IN[(row +1)*350+col+1]<<2;





sumval = sumval >> 4;




}

}

return OUT;

}

2.13 Depois de simplificações algébricas e reassociação





int sumval=IN[row*350+col];

sumval+=IN[row*350+col+1]<<1;

sumval+=IN[row*350+col+2];

sumval+=IN[350*row +350+col]<<1;



sumval+=IN[350*row +700+col];


sumval+=IN[350*row +702+col];



}

}

return OUT;

}

2.14 Depois de CSE (eliminação de sub-expressões

comuns): final public static short[] doFIR(short[] IN) {




int row_350_col = row*350 + col;

int sumval= IN[row_350_col];

sumval+= IN[row_350_col + 1]<<1;

sumval+= IN[row_350_col + 2];










OUT[row_350_col] = (short) sumval;

}

}

return OUT;

}

2.15 Sumário As optimizações ilustradas nesta ficha permitem, sempre que haja potencial para a sua

aplicação, melhorar o desempenho do código. No exemplo ilustrado foi necessário

aplicar algumas das optimizações mais do que uma vez, em virtude da aplicação de

certas optimizações potenciar a aplicação de outras (ver por exemplo a aplicação do

desenrolamento de ciclos).



FICHA 3. Introdução ao Processamento de Linguagens

Duração: 3 horas

Exercício iniciais com programação em Java. Esta aula serve para adquirir alguns

conhecimentos em programação em Java com dois exemplos que envolvem o

tratamento de texto.

3.1 Exercícios 1. Escreva um programa em Java que leia um ficheiro de texto e apresente no

ecrã o número de ocorrências de cada caracter (letra, número, ou símbolo). O

programa deverá ser invocado na linha de comandos como:

Java ContaSimbolos <nome do ficheiro>

2. Escreva um programa que leia um ficheiro com um texto e escreva num

ficheiro especificado pelo utilizador o texto transformado pelas regras da

paródia: “The Official Language of Europe”2 identificadas a negrito na caixa

de texto abaixo (considere a precedência na aplicação das regras pela ordem

com que são descritas no texto). O programa deverá ser invocado na linha de

comandos como:

Java Parodia <nome do ficheiro de entrada> <nome do ficheiro de saída>

The Official Language of Europe

The European Commission has just announced an agreement whereby English will be the

official language of the EU rather than German which heavily lobbied to be the official

language and was the other possibility. As part of the negotiations, Her Majesty's

Government conceded that English spelling had some room for improvement and has

accepted a 5-year phase-in plan that would be known as "EuroEnglish."

2 Paródia divulgada na Internet de fonte desconhecida.



In the first year, "s" will replace the soft "c" . . . Sertainly, this will make the sivil

servants jump with joy. The hard "c" will be dropped in favor of the "k." This should

klear up konfusion and keyboards kan have 1 less letter.

There will be growing publik enthusiasm in the sekond year, when the troublesome "ph"

will be replased with the "f." This will make words like "fotograf" 20% shorter.

In the 3rd year, publik akseptanse of the new spelling kan be expekted to reach the

stage where more komplikated changes are possible. Governments will enkourage the

removal of double letters, which have always ben a deterent to akurate speling. Also, al

wil agre that the horible mess of the silent "e's" in the language is disgraseful, and they

should go away.

By the 4th yar, peopl wil be reseptiv to steps such as replasing "th" with "z" and the "w"

with "v."

During the fifz yar, ze unesesary "o" kan be dropd from vords kontaining "ou" and

similar changes vud of kors be aplid to ozer kombinations of leters. After ze fifz yar, ve

vil hav a realy sensibl vriten styl. Zer vil be no mor trubls or difikultis and evryvun vil

find it easy tu understand each ozer.

ZE DREM VIL FINALI KUM TRU!



FICHA 4. Introdução aos Algoritmos Iterativos

Duração: 3 horas

4.1 Algoritmo Iterativo para Determinar Funções Recursivas

Esta aula pretende representar uma classe de algoritmos muito utilizada em algumas

fases de um compilador. Estes algoritmos designam-se por iterativos, pois vão

alcançando a solução final por iterações.

Pretende-se determinar se um conjunto de chamadas a funções existente num dado

programa origina recursividade. Para tal é normalmente criado um grafo chamado de

Call Graph3 (grafo de chamadas a funções) que representa a estrutura de chamadas a

funções de um programa. Considere os pedaços de código seguintes (as reticências

indicam enunciados no programa que não contêm chamadas a instruções): Void P() {... Q(); … S(); …}

Void Q() {...R(); … T(); …}

Void R() {…P(); …}

Void S() {…}

Void T() {...}

Cada nó do Call Graph representa a chamada a uma função ou procedimento, e cada

laço entre dois nós representa que a função de onde sai a seta chama a função para

onde a seta aponta. O Call Graph que representa o programa é (poderia ser construído

com base na análise do código do programa):

P

Q

R T

S

3 O Call Graph é utilizado na compilação em outros contextos que não apenas o de recursividade.



Vamos supor que um compilador pretendia determinar quais são as funções

recursivas.

4.2 Transitive Closure Uma das propriedades que se pode aplicar ao grafo é a propriedade transitiva:

● Se existe uma seta do nó A para o nó B e do nó B para o nó C então vamos fazer

com que exista também uma seta entre o nó A e o nó C.

Como os enunciados ‘A chama A directa ou indirectamente e ‘A é recursiva’ são

equivalentes a aplicação da regra anterior permite determinar automaticamente as

funções recursivas num determinado programa.

Após aplicação da propriedade transitiva teríamos o grafo seguinte:

P

Q

R T

S

Que mostra claramente que as funções P, Q, e R são funções recursivas.

4.3 Algoritmo Iterativo para Transitive Closure O seguinte algoritmo iterativo pode ser utilizado para aplicar a propriedade transitiva

a um Call Graph:

SET flag of Something changed TO TRUE;

WHILE something changed {

SET flag of Something changed TO FALSE;

FOR EACH node A IN Graph {

FOR EACH node B IN Descendants of Node A {

FOR EACH node C IN Descendants of Node B {

IF there is no arrow from Node A to Node C {

Add an arrow from Node A to Node C;

SET flag Something changed TO TRUE;

}

}



}

}

}

4.4 Exercício 1 Com base no código Java (ver a secção seguinte) formado pelas classes Graph e

TransitiveClosure, escreva o método da classe Graph, designado por

transitiveClosure, que deve implementar o algoritmo apresentado anteriormente. De

seguida realize os passos seguintes:

a) Compile as classes java fazendo: javac *.java

b) Execute o programa fazendo: java TransitiveClosure

4.5 Código Java No código Java, o Call Graph original é representado por um array bidimensional,

designado por Edges, de 5×5 elementos booleanos. O grafo original poderá ser

representado pela seguinte matriz, em que os nós 0, 1, 2, 3, e 4 representam as funções

P, Q, R, S, e T, respectivamente:

J Edges[i][j]

0 1 2 3 4

0 False true false true false

1 False False true False true

2 true False False False False

3 False False False False False

I

4 False False False False False

Por exemplo, o valor true no elemento edges[0][1] indica que existe um laço entre o

nó 0 e o nó 1 com sentido de 0 para 1.

4.6 Classe Graph.java /**

This is the class of the calling graph structure.

It includes the transitive closure algorithm.



the lines below tells the javadoc tool who is the author of this class and which is the

version (try: javadoc graph.java and then view the generated html files)

@author João M. P. Cardoso

@version v0.1

*/

// import from the API the class to use System.out.println

import java.io.*;

public class Graph {

// array which represents the edges between nodes

boolean[][] edges;

/**

add an edge between two nodes

@param source represents the source of the directed edge

@param sink represents the destination node of the directed edges

*/

public void addEdge(int source, int sink) {

edges[source][sink] = true;

}

/**

Print the edges between nodes.

*/

public void print() {

System.out.println("Graph edges: ");

int N = edges.length;

for(int i=0; i<N; i++)

for(int j=0; j<N; j++)

if(edges[i][j])

System.out.println(i+" -> "+j);

}

/**

Constructor of the graph.

The line below defines the argument numNodes to be used by the javadoc tool

@param numNodes the number of nodes in the graph

*/

public Graph(int numNodes) {



// create the array with size = numNodes x numNodes

edges = new boolean[numNodes][numNodes];

// initiate all the elements equal to false: none edges

for(int i=0; i<numNodes; i++)

for(int j=0; j<numNodes; j++)

edges[i][j] = false;

}

/**

Show the functions of the calling graph which are recursive.

*/

public void printRecursiveFunctions() {

int numNodes = this.edges.length;

System.out.print("Recursive Functions in nodes: {");

for(int k=0; k<numNodes; k++)

// if there is an edge with source=sink then

// the node represents a recursive function

if(edges[k][k])

System.out.print(" "+k);

System.out.println(" }");

}

/**

Algorithm to perform the transitive closure on the original graph.

*/

public void transitiveClosure() {

// your code must be here!!!

}

}

4.7 Classe TransitiveClosure.java /**

Class where the calling graph is created and the transitive closure is applied.

*/

public class TransitiveClosure {

public static void main(String args[]) {

// create a calling graph with 5 nodes



Graph callGraph = new Graph(5);

// add the 5 edges

callGraph.addEdge(0, 1);





// print the original graph

callGraph.print();

// call the transitive closure algorithm over the callGraph

callGraph.transitiveClosure();

// print the graph after applying the transitive closure algorithm

callGraph.print();

// show the nodes which represent recursive functions

callGraph.printRecursiveFunctions();

}

}

4.8 Trabalho para Casa Modifique o método main da classe TransitiveClosure de modo a determinar as

funções recursivas do seguinte Call Graph:

P

Q

R T

S

U

4.9 Créditos A aula é baseada no exemplo apresentado no livro:

Dick Grune, Henri E. Bal, Ceriel J. H. Jacobs, and Koen G. Langendoen, Modern

Compiler Design, John Wiley & Sons, Ltd, 2000.



FICHA 5. Exercícios sobre Expressões Regulares e Autómatos Finitos

Duração: 3 horas

5.1 Exercícios com Expressões Regulares 1.1 Escreva expressões regulares para os seguintes exemplos:

(a) números binários representando números inteiros;

(b) [TPC] URLs da forma: http://www.ualg.pt (em que o campo intermédio

“ualg” é o único campo variável).

(c) [TPC] IPs da forma: 140.192.33.37 (considere que todos os IPs têm o mesmo

número de dígitos por cada campo).

(d) Representação binária de números inteiros sem utilizarem zeros supérfluos;

(e) Strings sobre o alfabeto {a, b, c} com número ímpar de a’s;

(f) [TPC] Strings sobre o alfabeto {a, b, c} em que o primeiro “a” precede o

primeiro “b”;

(g) Números binários cuja divisão por 4 dá resto zero;

(h) [TPC] Números binários maiores do que 101001;

(i) [TPC] A linguagem das constantes em vírgula flutuante (notação utilizada em

Java).

1.2 Acha que é possível escrever expressões regulares para os seguintes exemplos?

No caso de ser possível apresente uma solução:

(j) números binários que começam e acabam com o mesmo digito;

(k) [TPC] sequências de algarismos que formam capicuas;

5.2 Exercícios com Autómatos Finitos 2.1 Considere o autómato finito seguinte:



0 1

0

0

2

0

3

1

1

1

(a) O autómato é determinista ou não determinista?

(b) Qual é o seu estado de início? Quais são os estados de aceitação (finais)?

(c) Este autómato aceita a sequência 110100? Qual a sequência de estados

visitados no reconhecimento desta String?

(d) Qual é a String mais pequena que o autómato aceita?

(e) Pode indicar a String maior que o autómato aceita?

(f) Por palavras, qual é a linguagem que o autómato aceita?

2.2 Desenhe os NFAs para as expressões regulares seguintes. Depois converta cada

um deles para DFA.

(a) [01]

(b) 1+

(c) (0 | 1) [0 | 1]+

2.3 Converta os NFAs seguintes para DFAs:

(a) 0, 1

x y z0 1

(b)

(c)



2.4 Um analisador lexical baseado num interpretador de um DFA utiliza duas tabelas:

● edges: indexada pelo número do estado e símbolo de entrada, retorna o número do

estado, e

● final: indexada pelo número do estado, retorna 0 ou um número representativo da

acção a realizar.

Considerando a seguinte especificação:

(aba)+ ⇒ acção número 1

(a(b*)a) ⇒ acção número 2

(a | b) ⇒ acção número 3

Apresente as tabelas edges e final para o analisador lexical.



FICHA 6. Implementação manual de um analisador lexical

Duração: 3 horas

Exercício sobre expressões regulares, NFAs, DFAs, e implementação manual de

analisadores lexicais baseados em DFAs.

6.1 Exercícios Pretende-se implementar um programa capaz de reconhecer números inteiros e

números reais introduzidos via teclado.

As expressões regulares que definem os números são:

Inteiro → [0-9]+

Real → [0-9]*.[0-9]+

(a) Desenhe o NFA que integre as duas expressões regulares anteriores;

(b) Transforme o NFA num DFA equivalente;

(c) Desenvolva um programa em Java que leia via teclado um conjunto de caracteres

e reconheça os dois tipos de números. Considere uma implementação do DFA

baseada na construção Java switch.

Pode utilizar o algoritmo seguinte, com a ressalva de que os caracteres não são lidos

de um ficheiro mas sim via teclado:

State = state_begin;

Char c = read char;

While c ≠ EOF do {

State = trans(State, c);

c = read next char;

}

if State in Set_of_final_states then

return “yes”;

else

return “no”;



(d) O que teria de mudar nas expressões regulares para que todos os números com

algarismos à esquerda do ponto e sem algarismos à direita do ponto fossem

considerados números reais? Apresente os novos NFA e DFA.

(e) Elabore um programa Java que implemente o reconhecedor da alínea anterior,

utilizando uma ou mais tabelas para determinar as transições de estados.

(f) TPC (depois de ser utilizado o JavaCC): Implemente o supracitado programa

utilizando o gerador de analisadores léxicos e sintácticos JavaCC.

6.2 Notas O programa é constituído pela classe RecNumber e deve responder da seguinte forma

para os casos apresentados (o símbolo ↵ representa a tecla ENTER):

C:\java_code>java RecNumber↵

123↵

Integer number


12.3↵

Real number


.34↵

Real number


1. ↵

Unrecognized input

C:\java_code>java RecNumber

12a↵

Unrecognized input



FICHA 7. Exercícios sobre Gramáticas

Duração: 3 horas

1. Especificar utilizando a representação BNF gramáticas correspondentes às

expressões regulares:

(a) [0-9]+

(b) [0-9]*

2. A gramática seguinte produz expressões constituídas de dígitos 0...9 separados

pelos sinais + ou -: Expr → Expr “+” Expr | Expr “-“ Expr | Digit

Digit → 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9

(a) Considere as expressões 9-5+2 e 3+7-4-2. Desenhe árvores sintácticas

concretas que derivem cada uma destas expressões;

(b) Pode derivar -5+2 da gramática especificada? Se achar que sim desenhe a

árvore sintáctica, caso contrário diga porque não.

(c) É a gramática ambígua? No caso de ser, tente encontrar uma gramática que

possa produzir a mesma linguagem (i.e., o mesmo conjunto de expressões) mas

que não seja ambígua.

(d) Diga se cada uma das gramáticas seguintes é equivalente (i.e., produz a mesma

linguagem) à gramática anterior? (i) Expr → Expr “+” Expr

Expr → Expr “-“ Expr

Expr → Digit

Digit → 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9

(ii) DIGIT = [0-9]

Expr → Expr “+” Expr

Expr → Expr “-“ Expr

Expr → DIGIT

(iii) Expr → (Expr “+” Expr) | (Expr “-“ Expr) | Digit

Digit → 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9

(iv) OP = “+“ | “-“

Expr → (Expr OP Expr) | Digit

Digit → 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9

3. Considere as gramáticas seguintes:



DIGIT = [0-9]

(i) Aexpr → “-“ | DIGIT | Aexpr DIGIT

(ii) Bexpr → DIGIT Bexpr | Bexpr DIGIT | “.”

(a) Descreva as linguagens produzidas por cada uma das gramáticas.

(b) Ambas as gramáticas são recursivas. Apresente gramáticas equivalentes não-

recursivas utilizando a notação EBNF;

4. Considere a gramática seguinte: NUMLIT = [0-9]+

IDENT = [a-zA-Z][a-zA-Z0-9]*

BOOLLIT = “true” | “false”

Seq → Comando { “;” Seq }

Comando → “if” Expr “then” Comando [“else” Comando]

| IDENT “:=” Expr

| “{“ Seq “}”

Expr → NUMLINT | BOOLLIT | IDENT

(a) Desenhe a árvore sintáctica concreta para a sequência de código: y := 0;

if x then y := 1

else {y := 0}

(b) Desenhe uma possível AST para a árvore sintáctica concreta anterior.

5. Dada a gramática: NUM = [0-9]+

ID = [A-Za-Z][0-9A-Za-z]*

Expr → Expr “+” Term | Expr “–” Term | Term

Term → Term “*” Factor | Term “/” Factor | Factor

Factor → Primary “^” Factor | Primary

Primary → “-” Primary | Element

Element → “(“ Expr “)” | NUM | ID

Quais as árvores sintácticas para:

(a) 5-2*3

(b) y^3

6. Pretende-se especificar uma gramática que permita produzir expressões aritméticas

com inteiros atendendo a que:



(i) as operações aritméticas que podem ser utilizadas são (por ordem de

precedência):

• ^

• /, *

• +, -

(ii) a gramática deve ser não-ambígua e deve respeitar a prioridade das

operações aritméticas;

(iii) deve poder produzir expressões aritméticas com parêntesis;

Especifique a gramática utilizando a notação EBNF.



FICHA 8. Implementação manual de um analisador sintáctico descendente

Duração: 3 horas mais trabalho extraordinário

Trabalho de avaliação referente à implementação manual em Java de um analisador

sintáctico descendente.

Dada a gramática seguinte: S → E

E → T “+” E

E → T

T → “x”

(a) Implemente o analisador sintáctico descendente que implemente a gramática

considerada. Suponha que o analisador recebe via teclado a sequência de símbolos

terminais identificados por códigos. O analisador deve imprimir uma mensagem

dizendo se a sequência de símbolos terminais pertence ou não à gramática.

Nota: os códigos atribuídos a cada símbolo terminal são: “x” (código 1), “+”

(código 2). Assim, a expressão: x + x é introduzida no analisador como: 1 2 1.

(b) Implemente outra versão do analisador de modo a que este construa a árvore

sintáctica concreta. No final da construção da árvore sintáctica o analisador deve

imprimir a estrutura da árvore.



FICHA 9. Implementação de Analisadores Gramaticais Utilizando o JavaCC (1ª parte)

Duração: 3 horas

Utilização do JavaCC [3] para gerar parsers. Esta aula tem como objectivo o início da

aprendizagem do gerador de analisadores sintácticos JavaCC. Esta tarefa requer a

aplicação dos conhecimentos até agora adquiridos na disciplina, principalmente no

que respeita aos conceitos sobre análise sintáctica e sobre analisadores sintácticos

descendentes.

O JavaCC utiliza um ficheiro com extensão .jj onde se encontra descrita a gramática

para o parser e gera uma classe Java com o nome do parser e outras classes Java de

suporte4.

nome.jj Parser.java ParserTojenManager.java ParserConstants.java Token.java ParseError.java …

JavaCC

Figura 3. Entradas e saídas do JavaCC supondo que foi especificado “Parser”

como nome do parser no ficheiro nome.jj.

9.1 Exemplo Suponhamos que desejamos implementar um analisador sintáctico que reconheça

expressões aritméticas com apenas um número inteiro positivo ou com uma adição ou

uma subtracção de dois números inteiros positivos (por exemplo: 2+3, 1-4, 5, etc.). De

seguida apresenta-se uma gramática em EBNF com a especificação do símbolo

terminal utilizando uma expressão regular:

4 À medida que forem percebendo o JavaCC vão também tomando conhecimento do significado das

classes de suporte.



INTEGER = [0-9]+

Aritm → Integer [(“+” | “-“) Integer]

Para implementar um parser que implemente esta gramática utilizando o JavaCC

temos de criar um ficheiro com extensão .jj (vamos chamar-lhe: Exemplo.jj).

O ficheiro é constituído por:

1. Lista de opções (opcional): é onde pode ser definido o nível de lookahead, por

exemplo.

2. Unidade de compilação Java (PARSER_BEGIN(nome) ...

PARSER_END(nome))

3. Lista de produções da gramática (as produções aceitam os símbolos +, *, e ?

com o mesmo significado, aquando da utilização em expressões regulares)

Por exemplo para a gramática anterior, poderemos criar o ficheiro Exemplo.jj

seguinte:

PARSER_BEGIN(Exemplo)

// código Java que invoca o parser

public class Exemplo {

public static void main(String args[]) throws ParseException {

// criação do objecto utilizando o constructor com argumento para

// ler do standard input (teclado)

Exemplo parser = new Exemplo(System.in);

Exemplo.Aritm();

}

}

PARSER_END(Exemplo)

// símbolos que não devem ser considerados na análise

SKIP :

{

“ “ | “\t” | “\r”

}

// definição dos tokens (símbolos terminais)

TOKEN :

{

< INTEGER : ([“0” – “9”])+ >

| < EOL : “\n” >



}

// definição da produção

void Aritm() : {}

{

<INTEGER> ( (“+” | “-“) <INTEGER> )? (<EOF> | <EOL>)

}

Em seguida deve fazer-se: Javacc Exemplo.jj

Compilar o código Java gerado: Javac *.java

Executar o analisador sintáctico: Java Exemplo

Poderemos associar às funções referentes aos símbolos não-terminais pedaços de

código Java. Por exemplo, as modificações apresentadas em seguida permitem

escrever no ecrã mensagens a indicar os números que são lidos pelo parser:

void Aritm : {Token t1, t2;}

{

t1=<INTEGER> {

System.out.println(“Integer = “+t1.image);

}

( (“+” | “-“) t2=<INTEGER> {

System.out.println(“Integer = “+t2.image);

}

)? (<EOF> | <EOL>)

}

Por cada símbolo terminal INTEGER, foi inserida uma linha de código Java que

imprime no ecrã o valor do token lido (o método image da classe Token retorna uma

String representativa do valor do token5)

Insira estas modificações no ficheiro Exemplo.jj e volte a repetir o processo até à

execução do parser. Verifique o que acontece.

5 Outros métodos serão apresentados posteriormente.



Como poderíamos adicionar também a escrita do sinal (+ ou -) lido?

9.2 Exercícios 1. Considere a ficha Nº 5. No exercício pretendia-se implementar um programa para

reconhecer números inteiros e números reais introduzidos via teclado. As expressões

regulares que definem os números são: Inteiro → [0-9]+

Real → [0-9]*.[0-9]+

Agora, pretende-se implementar o programa utilizando o gerador de analisadores

léxicos e sintácticos: JavaCC.

Antes de iniciar as implementações referentes aos exercícios apresentados de seguida,

deve ler com atenção o tutorial [3]. Tenha atenção aos símbolos que devem ser

utilizados nas produções da gramática no JavaCC. Note que o JavaCC requer a

definição de gramáticas não-ambíguas de modo a poder fornecer apenas uma árvore

sintáctica concreta para uma dada frase.

2. Implemente utilizando o JavaCC um analisador sintáctico que permita reconhecer

expressões aritméticas com as operações *, +, e -. O analisador deve também aceitar a

utilização de parêntesis;

3. Com base no analisador anterior, adicione o código Java necessário para

implementar uma calculadora de expressões aceites pela gramática.

9.3 Referências de Apoio 3. JavaCC: https://javacc.dev.java.net/

4. Oliver Enseling, “Build your own languages with JavaCC”, Copyright © 2003

JavaWorld.com, an IDG company, http://www.javaworld.com/javaworld/jw-

12-2000/jw-1229-cooltools_p.html (cópia local em pdf:

http://w3.ualg.pt/~jmcardo/ensino/PS2003/AulaTP7/jw-1229-cooltools.pdf)




Duração: 3 horas

Implementação de uma calculadora utilizando o JavaCC sem a criação da árvore

sintáctica.

10.1 Exercício Considere a gramática seguinte:

EOL=”\n”

INTEGER=[0-9]+

Start → Expr EOL

Expr → Term {(“+” Expr) | (“-“ Expr)}

Expr → “(“ Expr “)”

Term → Unary {(“*” Term) | (“/” Term)}

Term → “(“ Expr “)”

Unary → “-“ INTEGER

Unary → INTEGER

a) É a gramática ambígua?

b) A gramática respeita as precedências (prioridades) das operações aritméticas?

c) Acha que a gramática tem recursividade à esquerda?

d) Para que não seja necessário backtracking qual o nível mínimo de lookahead

necessário?

e) Implemente esta gramática utilizando o JavaCC. Utilize o nível de lookahead que

achar necessário.

f) Modifique o ficheiro do JavaCC da gramática de modo a calcular o valor das

expressões (funcionamento como calculadora).




Duração: 3 horas

Esta ficha pretende que aprendam a utilizar o JJTree em conjunto com o JavaCC [3]

para gerar parsers e árvores sintácticas.

Após a utilização do JavaCC nas duas últimas aulas, é agora tempo de aprenderem

como se pode gerar automaticamente a árvore sintáctica. Para tal utilizaremos o

JJTree (é uma ferramenta integrada no pacote de software JavaCC). O JJTree é uma

ferramenta de pré-processamento que permite gerar um ficheiro para o JavaCC que,

para além da descrição da gramática, integra código Java para a geração da árvore

sintáctica. O ficheiro de entrada do JJTree é um ficheiro que especifica a gramática do

mesmo modo que para o JavaCC e que adicionalmente inclui directivas para a geração

dos nós da árvore (é utilizado jjt como extensão do ficheiro origem).

nome.jjt JJTree

nome.jj Node.java …

Figura 4. Entradas e saídas do JJTree.

11.1 Exemplo Vamos considerar a gramática da FICHA 8 e vamos supor que pretendemos realizar

um programa que calcule as mesmas expressões, desta vez gerando a árvore sintáctica

e efectuando os cálculos sobre a árvore.

Para gerar a árvore sintáctica vamos alterar a extensão do ficheiro da gramática

original para jjt e vamos adicionar as directivas que indicam ao JJTree para criar a

árvore. O ficheiro apresentado de seguida contém as modificações introduzidas (é

utilizado o método dump() para imprimir no ecrã a árvore gerada por cada expressão

introduzida).



Ficheiro Calculator.jjt:

options

{

LOOKAHEAD=2;

}

PARSER_BEGIN(Calculator)

public class Calculator

{


Calculator parser = new Calculator(System.in);

int i=0;

while (true) {

// the function will return the root node of the Syntax Tree

SimpleNode rootNode = parser.parseOneLine();

//print the Syntax Tree

rootNode.dump("Syntax Tree "+(i++)+": ");

}

}

}

PARSER_END(Calculator)

SKIP :

{

" "

| "\r"

| "\t"

}

TOKEN:

{

< INTEGER: (["0"-"9"])+ >

| < EOL: "\n" >

}

SimpleNode parseOneLine() #Root : {} // diz ao JJTree para criar o nó Root

{

expr() <EOL> {return jjtThis;} // retorna o nó da árvore construído neste

procedimento

| <EOL>



| <EOF> { System.exit(-1); }

}

void expr():

{

}

{

term()

(

"+" expr() #Add(2) // diz ao JJTree para criar um nó Add que tem dois filhos

| "-" expr() #Sub(2) // diz ao JJTree para criar um nó Sub que tem dois filhos

)*

| "(" expr() ")"

}

void term(): {}

{

unary()

(

"*" term() #Mult(2) // diz ao JJTree para criar um nó Mult que tem dois filhos

| "/" term() #Div(2) // diz ao JJTree para criar um nó Div que tem dois filhos

)*

| "(" expr() ")"

}

void unary(): {}

{

"-" <INTEGER>

| <INTEGER>

}

Em seguida deve fazer-se: jjtree Calculator.jjt

Gerar o código Java com o JavaCC: javacc Calculator.jj

Compilar o código Java gerado: Javac *.java

Executar o analisador sintáctico: Java Calculator



Verifique de seguida as árvores geradas para um conjunto de expressões introduzidas.

Contudo, a criação da árvore sintáctica não é suficiente para nós. Primeiro, a árvore

gerada não armazena os valores dos números inteiros lidos. Segundo, é necessário

programar o procedimento que atravessa a árvore e calcula o valor da expressão

aritmética definida pela árvore.

Para resolvermos o primeiro obstáculo teremos que fazer algumas alterações. O

JJTree vai gerar uma classe Java para o SimpleNode (nome da classe definido como

retorno do procedimento: parseOneLine()). Esta classe, é utilizada para representar os

nós da árvore sintáctica, e pode ser personalizada para implementar as

funcionalidades necessárias. A classe inclui os seguintes métodos:

Alguns métodos da classe representativa dos nós da árvore sintáctica:

Descrição:

public Node jjtGetParent() Retorna o nó pai do nó actual public Node jjtGetChild(int i) Retorna o nó filho nº i public int jjtGetNumChildren() Retorna o número de filhos do nó Public void dump() Escreve no ecrã a árvore sintáctica

a partir do nó

Depois da classe SimpleNode ser gerada pela primeira vez pelo JJTree podemos

adicionar-lhe métodos ou campos. Neste momento interessa-nos acrescentar à classe

um campo que permita armazenar o valor do inteiro (no caso das folhas da árvore).

Foram ainda adicionados dois métodos que permitem aceder ao campo (atribuir e

retornar o seu valor). A classe é apresentada de seguida com as alterações efectuadas

(a negrito).

/* Generated By:JJTree: Do not edit this line. SimpleNode.java */

public class SimpleNode implements Node {

protected Node parent;

protected Node[] children;

protected int id;

protected Calculator parser;

int value;

public void setValue(int a) {

this.value = a;

}



public int getValue() {

return this.value;

}

public SimpleNode(int i) {

id = i;

}

public SimpleNode(Calculator p, int i) {

this(i);

parser = p;

}

public void jjtOpen() {

}

public void jjtClose() {

}

public void jjtSetParent(Node n) { parent = n; }

public Node jjtGetParent() { return parent; }

public void jjtAddChild(Node n, int i) {

if (children == null) {

children = new Node[i + 1];

} else if (i >= children.length) {

Node c[] = new Node[i + 1];

System.arraycopy(children, 0, c, 0, children.length);

children = c;

}

children[i] = n;

}

public Node jjtGetChild(int i) {

return children[i];

}

public int jjtGetNumChildren() {

return (children == null) ? 0 : children.length;

}

/* You can override these two methods in subclasses of SimpleNode to

customize the way the node appears when the tree is dumped. If

your output uses more than one line you should override

toString(String), otherwise overriding toString() is probably all

you need to do. */

public String toString() { return CalculatorTreeConstants.jjtNodeName[id]; }

public String toString(String prefix) { return prefix + toString(); }



/* Override this method if you want to customize how the node dumps

out its children. */

public void dump(String prefix) {

System.out.print(toString(prefix));

if (children != null) {

for (int i = 0; i < children.length; ++i) {

SimpleNode n = (SimpleNode)children[i];

if (n != null) {

System.out.println();

n.dump(prefix + " ");

if(n.id == CalculatorTreeConstants.JJTUNARY)

System.out.println(" ["+n.getValue()+"]");

}

}

}

}

}

O novo ficheiro que descreve a gramática, que indica ao JJTree para gerar a árvore

sintáctica e que calcula o valor das expressões aritméticas introduzidas é apresentado

de seguida. Durante o atravessamento da árvore é importante que se possa verificar de

que tipo é um determinado nó. Tal pode ser feito utilizando o campo id de cada nó da

árvore (ver nos exemplos node.id). Para cada tido de nó da árvore o JJTree gera um

ficheiro em que são especificados os identificadores atribuídos (ver ficheiro

CalculatorTreeConstants.java). O tipo de nós corresponde aos procedimentos da

gramática e/ou aos nós especificados nas directivas para o JJTree.

Novo ficheiro Calculator.jjt:

options

{

LOOKAHEAD=2;

}


public class Calculator {



int i=0;

while (true) {







// call the evaluation method with the ROOT node

System.out.println("Result: "+parser.eval(rootNode));

}

}

/*

Método recursivo que realiza o cálculo da expressão percorrendo a árvore sintáctica.

*/

int eval(SimpleNode node) {

// each node contains an id field identifying its type.

int id = node.id;

//System.out.println("VALUE "+node.getValue()+" "+id);

if(id == CalculatorTreeConstants.JJTUNARY) // node with integer value

return node.getValue();

else if(node.jjtGetNumChildren() == 1) // only one child

return this.eval((SimpleNode) node.jjtGetChild(0));

// nodes with two childs

SimpleNode lhs = (SimpleNode) node.jjtGetChild(0); //left child

SimpleNode rhs = (SimpleNode) node.jjtGetChild(1); // right child

switch(id) {

case CalculatorTreeConstants.JJTADD : return eval( lhs ) + eval( rhs );

case CalculatorTreeConstants.JJTSUB : return eval( lhs ) - eval( rhs );

case CalculatorTreeConstants.JJTMULT : return eval( lhs ) * eval( rhs );

case CalculatorTreeConstants.JJTDIV : return eval( lhs ) / eval( rhs );

default : // abort

System.out.println("Operador ilegal!");

System.exit(1);

}

return 0;

}

}




SKIP :

{

" "

| "\r"

| "\t"

}

TOKEN:

{

< INTEGER: (["0"-"9"])+ >

| < EOL: "\n" >

}

SimpleNode parseOneLine() #Root : {} // diz ao JJTree para criar o nó Root

{

expr() <EOL> {return jjtThis;} // retorna o nó da árvore construído neste

procedimento

| <EOL>


}

void expr(): {}

{

term()

(

"+" expr() #Add(2) // diz ao JJTree para criar um nó Add que tem dois filhos

| "-" expr() #Sub(2) // diz ao JJTree para criar um nó Sub que tem dois filhos

)*

| "(" expr() ")"

}

void term(): {}

{

unary()

(

"*" term() #Mult(2) // diz ao JJTree para criar um nó Mult que tem dois filhos

| "/" term() #Div(2) // diz ao JJTree para criar um nó Div que tem dois filhos

)*

| "(" expr() ")"

}

void unary(): {Token t;}



{

"-" (t=<INTEGER> {

// diz ao JJTree para colocar o valor do inteiro num dos campos deste nó

// (para tal é necessário adicionar à classe Java SimpleNode o método setValue() e

// o campo que armazena o valor inteiro

jjtThis.setValue(-Integer.parseInt(t.image)6); })

| (t=<INTEGER> {

// diz ao JJTree para colocar o valor do inteiro num dos campos deste nó

// (para tal é necessário adicionar à classe Java SimpleNode o método setValue() e

// o campo que armazena o valor inteiro

jjtThis.setValue(Integer.parseInt(t.image));

})

}

Acha que a árvore sintáctica gerada pelos ficheiros jjt apresentados é uma árvore

sintáctica concreta ou uma AST (árvore sintáctica abstracta)?

Para que não seja gerado um nó por cada procedimento na gramática utiliza-se a

directiva #void a seguir ao nome do procedimento para o qual não se quer nó na

árvore. Este método permite gerar as ASTs automaticamente sem por isso ser

necessário transformar a árvore concreta numa AST. O ficheiro seguinte apresenta

uma versão da calculadora em que são geradas ASTs. Verifique a colocação da

directiva a indicar os símbolos não-terminais para os quais não será representado

qualquer nó na árvore.

Novo ficheiro Calculator.jjt:

options

{

LOOKAHEAD=2;

}


public class Calculator

6 Como o valor de um Token é guardado como String, é necessário converter a representação em String

para inteiro. Tal pode ser conseguido utilizando métodos existentes nos API do Java. Por exemplo,

Integer.parseInt(t.image) retorna o inteiro representado pela String t.image.



{



int i=0;

while (true) {





// call the evaluation method with the ROOT node

System.out.println("Result: "+parser.eval(rootNode));

}

}

int eval(SimpleNode node) {

// each node contains an id field identifying its type.

// we switch on these.

// enum values such as JJTUNARY come from the interface file

// SimpleParserTreeConstants, which SimpleParser implements.

// This interface file is one of several auxilliary Java sources

// generated by JJTree. JavaCC contributes several others.

int id = node.id;

//System.out.println("VALUE "+node.getValue()+" "+id);

if(id == CalculatorTreeConstants.JJTUNARY) // node with integer value

return node.getValue();

else if(node.jjtGetNumChildren() == 1) // only one child

return this.eval((SimpleNode) node.jjtGetChild(0));

SimpleNode lhs = (SimpleNode) node.jjtGetChild(0); //left child

SimpleNode rhs = (SimpleNode) node.jjtGetChild(1); // right child

switch(id) {

case CalculatorTreeConstants.JJTADD : return eval( lhs ) + eval( rhs );

case CalculatorTreeConstants.JJTSUB : return eval( lhs ) - eval( rhs );

case CalculatorTreeConstants.JJTMULT : return eval( lhs ) * eval( rhs );

case CalculatorTreeConstants.JJTDIV : return eval( lhs ) / eval( rhs );

default : // abort

System.out.println("Operador ilegal!");



System.exit(1);

}

return 0;

}

}


SKIP :

{

" "

| "\r"

| "\t"

}

TOKEN:

{

< INTEGER: (["0"-"9"])+ >

| < EOL: "\n" >

}

SimpleNode parseOneLine() #Root : {}

{

expr() <EOL> {return jjtThis;}

| <EOL>


}

void expr() #void : {}

{

term()

(

"+" expr() #Add(2)

| "-" expr() #Sub(2)

)*

| "(" expr() ")"

}

void term() #void : {}

{

unary()

(

"*" term() #Mult(2)



| "/" term() #Div(2)

)*

| "(" expr() ")"

}

void unary() : {Token t;}

{

"-" (t=<INTEGER> {

jjtThis.setValue(-Integer.parseInt(t.image));

})

| (t=<INTEGER> {

jjtThis.setValue(Integer.parseInt(t.image));

})

}

11.2 Referências de Apoio 5. JavaCC: http://www.experimentalstuff.com/Technologies/JavaCC/index.html

6. Documento de introdução ao JJTree incluído na distribuição da ferramenta:

http://w3.ualg.pt/~jmcardo/ensino/PS2003/jjtree.intro



FICHA 12. Trabalho Final

Duração: 3 aulas de 3 horas mais trabalho extraordinário

Esta ficha apresenta o enunciado do último trabalho prático que será realizado com o

acompanhamento proporcionado por 3 aulas práticas e com esforços extra aulas.

12.1 Exercício Pretende-se implementar um interpretador ou um compilador para uma linguagem de

programação muito simples, designada por ualg. Nesta linguagem todas as variáveis e

constantes são do tipo inteiro com sinal (representado em 32 bits). A linguagem aceita

expressões aritméticas e operações relacionais, construções condicionais do tipo if e

if-else, e construções while. Os programas na linguagem ualg são constituídos por

uma única função (a função tem de retornar sempre uma variável e pode ter ou não

argumentos), não existem chamadas a funções, e os argumentos são sempre passados

por valor. A linguagem ualg não deve diferenciar minúsculas de maiúsculas.

São apresentados na Figura 5 exemplos e algumas restrições da linguagem. A

gramática de uma linguagem similar encontra-se representada em EBNF na secção 2.

Tenha contudo em atenção que a gramática apresentada só permite o encadeamento

de construções condicionais e cíclicas do tipo de if-while ou while-if. Deve por isso

proceder às alteraçoes necessárias que permitam ao compilador/interpretador não ter

restrições no encademaneto deste tipo de construtores. A Figura 6 apresenta exemplos

de programas em ualg.

Tipo Instruções e operações

Exemplo

Operações aritméticas e lógicas *, /, +, -, <<, >>, &, |, ^

a=2*b; /* RHS com apenas uma operação */

Relacionais (Apenas utilizados como teste nas construções if, if-else, while)

==, !=, >, <, >=, <=

If(a >= b) { ... } /* Apenas utilizados no teste da condição pelas construções if, if-else, e while */

Construções condicionais If, if-else If(a == b) { c=2; }

Construções cíclicas while While(a != 2) { a = a-1; }

Atribuição = A=2; A=b;



Imprimir a string e o valor da variável no ecrã (com mudança de linha)

print Print(“a: ”, a);

Ler inteiro do ecrã read A=read;

Figura 5. Operações e construções suportadas pela linguagem.

Pretende-se que implemente um dos seguintes programas:

1. Interpretador para esta linguagem;

2. Compilador para esta linguagem que gere uma rotina em código MIPS

(utilização do simulador spim [4] para validar os resultados) [5];

Count(word) { cont=0; n = 0; While(n < 32) { teste = word & 1; If(teste == 1) { cont = cont +1; } word = word >> 1; n = n + 1; } return cont; }

sqrt(vsqn) { vsq=vsqn; asq=0; a=0; tvsq=0; I=0; While(I < 6) { nasq1 = asq + a; nasq2 = nasq1 << 2; nasq = nasq2 | 1; sa = a << 1; tvsq1 = tvsq << 2; Vsq1 = vsq >> 10; Vsq2 = vsq1 & 3; tvsq = tvsq1 | vsq2; vsq = vsq << 2; if(nasq <= tvsq) { a = sa | 1; asq = nasq; } else { a = sa ; asq = asq << 2 ; } I = i+1; } return a; }

Max() { A=Read; B=Read; Max=a; If(max < b) { Max = b; } Print(“max: “, max); Return max; } (a) Max(a, b) { Max=a; If(max < b) { Max = b; } Return max; } (b)

Conta nº de bits com valor “1” no conteúdo da variável passada como argumento.

Calcula a raiz quadrada de um número inteiro sem sinal representado por 12 bits. Retorna o valor inteiro da raiz quadrada representado por 6 bits.

Dois programas para determinar o valor máximo de duas variáveis: (a) versão com leitura/escrita de dados; (b) versão sem leitura/escrita de dados.

Figura 6.Exemplo de programas na linguagem ualg.

Compilador: Para executar o compilador deve ser introduzido o comando: java ualg

[-o] programa.ualg. A opção –o deve ser considerada pelos alunos que consigam

optimizar a geração do código:



● Utilização do menor número possível de espaço em memória para armazenar

variáveis (atribuir o maior número possível de variáveis a registos do

microprocessador);

Interpretador: Para executar o interpretador deve introduzido o comando: java ualg

[-p|-b] programa.ualg. As opções –p e –b devem ser incorporadas para permitir a

interpretação linha-a-linha (opção: –p) e a interpretação até encontrar uma instrução

write (opção: –b). As funções com argumentos devem originar que o interpretador

solicite ao utilizador a inserção via teclado do valor para cada um dos argumentos. O

interpretador deve escrever no ecrã o valor retornado pela função.

A nota final terá em conta os pesos dados a cada uma das tarefas a realizar. A

contribuição de cada tarefa na nota global é apresentada na Figura 7.

Cada grupo deve realizar uma apresentação do trabalho. No inicio da apresentação

deverá ser entregue um pequeno relatório a descrever as opções tidas durante o

desenvolvimento e as restrições do compilador. O relatório deve incluir em anexo o

ficheiro de entrada do JavaCC e do JJTree e a documentação do programa que deve

ser gerada automaticamente pelo javadoc.

Tarefa Percentagem na nota

Analisador sintáctico sem geração da árvore sintáctica (inclui especificação da gramática no JavaCC)

20%

Criação da árvore sintáctica anotada utilizando o JJTree (para validação o compilador/interpretador deve imprimir no ecrã a árvore sintáctica e as anotações)

20%

Geração de código/interpretação para/de sequências de instruções com expressões aritméticas. Incluir, no caso do interpretador, a leitura de valores pelo teclado dos argumentos da função e, a escrita do valor retornado pela função e a implementação das instruções read e print.

10%

Geração de código/interpretação para/de estruturas condicionais (if, if-else)

10%

Geração de código/interpretação para/de estruturas cíclicas (while) 10%Optimizações ao nível do código assembly gerado (opção do compilador –o) ou tipos de interpretação (opções –b e –p)

10%

Legibilidade e estrutura do código, apresentação do trabalho, etc. 20%Melhor compilador e melhor interpretador (o melhor compilador poderá vir a ser utilizado na disciplina de Arquitectura de Computadores)

Bónus: 10%

Figura 7. Percentagem na nota final no trabalho de cada tarefa.



12.2 Gramática Inicial da Linguagem De seguida é apresentada a gramática inicial da linguagem (esta gramática foi escrita

de forma a ser o mais intuitiva possível e o mais próximo possível da gramática que

deverá ser especificada no JavaCC):

IDENTIFIER = [a-z][a-z0-9]*

LITERAL = [0-9]+

STRING = “\““ [a-zA-Z0-9”:”” “]+ “\““

// os operadores têm o mesmo significado e precedência do que na

linguagem Java

RELA_OP = “>“ | “<“ | “==“ | “!=“ | “>=” | “<=”

OTHER_OP = “*“ | “/“ | “&“ | “|“ | “<<” | “>>” | “^”

ADD_SUB = “+“ | “-“

LPAR = “(“

RPAR = “)”

VIRG = “,”

PVIRG = “;”

LCHAVETA = “{“

RCHAVETA = “}“

ASSIGN = “=“

WHILE = “while”

IF = “if”

ELSE = “else”

RETURN = “return”

PRINT= ”print”

READ= ”read”

Start → IDENTIFIER LPAR [Varlist] RPAR LCHAVETA Stmtlst RETURN IDENTIFIER

PVIRG RCHAVETA

Varlist → IDENTIFIER {VIRG IDENTIFIER}

Stmtlst → {Stmt}

Stmt → Expr1 | Expr3 | Expr4 | Print

Expr1 → IDENTIFIER ASSIGN Rhs PVIRG

Rhs → Term [(ADD_SUB | OTHER_OP) Term]

Term → IDENTIFIER | ([ADD_SUB] LITERAL) | READ

Expr3 → WHILE Exprtest LCHAVETA Stmtsimple RCHAVETA

Expr4 → IF Exprtest LCHAVETA Stmtsimple RCHAVETA



Expr4 → IF Exprtest LCHAVETA Stmtsimple RCHAVETA ELSE LCHAVETA

Stmtsimple RCHAVETA

Print → PRINT LPAR STRING VIRG IDENTIFIER RPAR PVIRG

Exprtest → LPAR IDENTIFIER RELA_OP (IDENTIFIER | ([ADD_SUB] LITERAL)) RPAR

Stmtsimple → {Expr1 | Expr4 | Expr3 | Print}

12.3 Algumas Dicas Antes de começarem a especificar a gramática no JavaCC devem verificar se a

gramática é não-ambígua e não tem recursividade à esquerda. No caso de não se

verificar alguma destas propriedades, a gramática deve ser modificada e só depois é

que deve ser especificada no JavaCC.

A linguagem ualg não deve diferenciar minúsculas de maiúsculas. Para isso devem

atribuir o valor verdadeiro à opção IGNORE_CASE do JavaCC:

options {

IGNORE_CASE=true;

}

Lembrem-se que cada símbolo não-terminal da gramática pode ser um procedimento

no ficheiro descritivo da gramática.

Durante a fase de validação do analisador gramatical podem utilizar uma makefile

que execute o compilador com vários programas teste (programas em ualg que

permitam verificar se determinadas construções da linguagem estão a ser aceites pelo

analisador gramatical). Esta abordagem permite automatizar o teste da gramática e é

por isso útil para testar o analisador sempre que forem feitas alterações na descrição

JavaCC da gramática.

12.4 Documentação e Ferramentas de Suporte 1. JavaCC: Java Compiler Compiler™ (JavaCC) - The Java Parser Generator

JavaCC: https://javacc.dev.java.net/

2. Oliver Enseling, “Build your own languages with JavaCC”, Copyright © 2003

JavaWorld.com, an IDG company, http://www.javaworld.com/javaworld/jw-12-

2000/jw-1229-cooltools_p.html

3. Documento de introdução ao JJTree incluído na distribuição da ferramenta

[FICHA Nº 9].



4. Spim: http://www.cs.wisc.edu/~larus/spim.html

5. Rever as primeiras 3 aulas teóricas (“Da linguagem alto-nível ao código

assembly”).



Anexo B: Enunciado de um Exame

Exame de época de recurso da disciplina de Programação de

Sistemas

Ano lectivo de 2002/2003

2º Semestre

Licenciatura em Engenharia de Sistemas e Computação

Licenciatura em Ensino de Informática

Licenciatura em Informática, ramo de Gestão

Duração: 2 horas + meia hora de tolerância (total: 2H30)

1. [2 valores] Converta o NFA (autómato finito não-determinista) seguinte num

DFA (autómato finito determinista) utilizando o algoritmo de conversão que

aprendeu.

0 1

ε

4 3z

y

2 x

z x

5 a

6

a

a

ε

a

y

2. [1,5 valores] Escreva para cada estado de aceitação do autómato da figura anterior

a expressão regular que represente as palavras da linguagem aceites pelo mesmo.

3. [1,5 valores] Desenhe um autómato finito (determinista ou não-determinista) que

permita reconhecer palavras representadas por cada uma das expressões regulares



seguintes (o autómato deve diferenciar o reconhecimento por cada uma das

expressões):

d+e?

[a-c]*[1-3]+

4. [10 valores] Considere a gramática seguinte (o número entre parêntesis identifica

o número de cada produção):

LIT = [0-9]+

OP = “+” | “-“ | “*” | “/”

Start → Expr $ (1)

Expr → Expr OP Expr (2)

Expr → LIT (3)

Expr → “(“ Expr “)” (4)

(a) Desenhe as árvores sintácticas concretas que conseguir derivar para as entradas:

(32*2)+1$ e 32*2+1$;

(b) Acha que a gramática apresentada é ambígua ou não-ambígua? Justifique a

resposta;

(c) Supondo que os tokens definidos pelo símbolo terminal OP correspondem a

operadores aritméticos, diga se a prioridade destes operadores é respeitada pela

gramática. Justifique a resposta com um exemplo. Caso não seja, indique as

modificações que teria de introduzir na gramática.

(d) Suponha que se pretende implementar um analisador sintáctico descendente sem

retrocesso (backtracking). Diga se terá de modificar a gramática para a

implementação ser possível. Justifique a resposta. No caso de ter de ser

modificada, apresente a nova gramática;

[Nota: Apresente a resolução das duas alíneas seguintes na mesma página do

teste]

(e) Considerando a gramática original desenhe o DFA para o analisador sintáctico

LR(0);

(f) Desenhe a tabela sintáctica correspondente ao DFA da alínea anterior;



(g) Determine os conjuntos First e Follow para cada um dos símbolos não terminais

da gramática anterior;

(h) Diga se a gramática original é LR(0). Caso não seja indique se é SLR(1).

Justifique;

(i) Desenhe uma tabela (de acordo com a tabela exemplificativa indicada em baixo)

com as etapas do analisador sintáctico shift/reduce para a entrada: 3*2+4$.

Pilha de estados Pilha de símbolos Entrada Acção

3*2+4$

5. [5 valores] Na figura a seguir é apresentado um pedaço de código (os números

entre parêntesis identificam cada linha de código).

(1) void AddToArray(int[] A, int N, int C) {

(2) int i;

(3) i = 1;

(4) while(i <= N) {

(5) A[i] = C + A[i];

(6) i = i+1;

(7) }

(8) }

(j) Considerando as linhas de código (5) e (6), diga que verificações devem ser feitas

pelo analisador semântico;

(k) No caso da variável i ter sido declarada como float que conversões teriam de ser

introduzidas durante a análise semântica da linha (6);

(l) Desenhe a árvore de instruções e expressões de nível alto para a sequência de

instruções de (3) a (7), considerando as instruções: lda, sta, ldl, stl, ldp;

(m) Desenhe a representação intermédia de nível baixo para a sequência de instruções

de (3) a (7), considerando que todas as variáveis escalares locais são guardadas

em posições da pilha. Considere para a representação as instruções: cbr, lda, sta,

ld, st, ldp;



[Nota: Considere uma memória de sistema endereçável ao byte.]

compiladores - w3.ualg.ptw3.ualg.pt/~jmcardo/ensino/comp04/guiacompiladores.pdf · caderno de...

Documents