aulas terico-prticas de compiladores -...

Caderno de exercícios para a disciplina de:

COMPILADORES

Janeiro de 2005

João M. P. Cardoso Departamento de Engenharia Electrónica e Informática (DEEI) Faculdade de Ciências e Tecnologia (FCT) Universidade do Algarve Campus de Gambelas 8000-117 Faro Email: [email protected]: 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

mailto:[email protected]

http://w3.ualg.pt/~jmcardo

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

Índice

FICHA Nº 1 Optimizações de código.....................................................................5

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

utilizando o compilador JIT .......................................................................................5

1.2 Optimizações..................................................................................................6

1.3 Propagação de constantes (Constant Propagation) ........................................7

1.4 Constant folding (Constant-Expression Evaluation) .....................................8

1.5 Desenrolamento de ciclos (Loop Unrolling)..................................................9

1.6 Simplificação algébrica (Algebraic simplification) .......................................9

1.7 Desenrolamento de ciclos (Loop Unrolling)................................................10

1.8 Simplificações algébricas + constant folding ..............................................11

1.9 Scalar replacement .......................................................................................11

1.10 Simplificação algébrica................................................................................12

1.11 Eliminação de código ou de declarações não utilizadas ..............................13

1.12 Strength reduction........................................................................................13

1.13 Depois de simplificações algébricas e reassociação ....................................14

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

1.15 Sumário ........................................................................................................15

FICHA Nº 2 Introdução aos Algoritmos Iterativos...............................................16

1.16 Algoritmo Iterativo para Determinar Funções Recursivas ..........................16

1.17 Transitive Closure........................................................................................17

1.18 Algoritmo Iterativo para Transitive Closure................................................17 ©João M. P. Cardoso 2


1.19 Exercício 1 ...................................................................................................18

1.20 Código Java..................................................................................................18

1.21 Classe Graph.java ........................................................................................19

1.22 Classe TransitiveClosure.java......................................................................21

1.23 Trabalho para Casa ......................................................................................21

1.24 Créditos ........................................................................................................22

FICHA Nº 3 Exercícios sobre Expressões Regulares e Autómatos Finitos..........23

1.25 Exercícios com Expressões Regulares.........................................................23

1.26 Exercícios com Autómatos Finitos ..............................................................23

FICHA Nº 4 Exercícios sobre Gramáticas............................................................26

FICHA Nº 5 Implementação de Analisadores Gramaticais Utilizando o JavaCC

(1ª parte) 29

1.27 Exemplo .......................................................................................................29

1.28 Exercícios.....................................................................................................32

1.29 Referências de Apoio...................................................................................32


(2ª parte) 33

1.30 Exercício ......................................................................................................33


(3ª parte) 34

1.31 Exemplo .......................................................................................................34

1.32 Referências de Apoio...................................................................................45

©João M. P. Cardoso 3


FICHA Nº 8 : Exercício sobre analisadores sintácticos........................................46

FICHA Nº 9 : Exercícios de Revisão....................................................................50

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



FICHA Nº 1 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.

1.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 1 apresenta o resultado da execução do referido programa.

Figura 1. 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.

1.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;

}

1.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;

}



1.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]; 122500

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

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;




}

}





}

}

return OUT;

}

1.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;

}

1.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;

}

1.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;

}

1.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;

}

1.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;

}

1.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;

}



1.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;

}

1.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;

}

1.13 Depois de simplificações algébricas e

reassociação final public static short[] doFIR(short[] IN) {




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;

}

1.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;

}

1.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 Nº 2 Introdução aos Algoritmos Iterativos

Duração: 3 horas

1.16 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 Graph1 (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):

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



P

Q

R T

S

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

recursivas.

1.17 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.

1.18 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;

}

}

}

}

}

1.19 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

1.20 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.

1.21 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!!!

}

}



1.22 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();

}

}

1.23 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

1.24 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 Nº 3 Exercícios sobre Expressões Regulares e Autómatos Finitos

Duração: 3 horas

1.25 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;

1.26 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 Nº 4 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 Nº 5 Implementação de Analisadores Gramaticais Utilizando o JavaCC (1ª parte)

Duração: 3 horas

Utilização do JavaCC [1] 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

suporte2.

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

JavaCC

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

como nome do parser no ficheiro nome.jj.

1.27 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:

2 À 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 token3)

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

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

3 Outros métodos serão apresentados posteriormente.



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

1.28 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 [1]. 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.

1.29 Referências de Apoio 1. 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 (cópia local em pdf:

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


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

http://www.javaworld.com/javaworld/jw-12-2000/jw-1229-cooltools_p.html

http://www.javaworld.com/javaworld/jw-12-2000/jw-1229-cooltools_p.html

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.

1.30 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 [1]

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 3. Entradas e saídas do JJTree.

1.31 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)4); })

| (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

4 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));

})

}

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

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

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


http://www.experimentalstuff.com/Technologies/JavaCC/index.html

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


FICHA Nº 8 : Exercício sobre analisadores sintácticos

Tradução da notação EBNF para BNF:

1. Para determinar os conjuntos First e Follow é necessário representar em BNF as seguintes gramáticas apresentadas na notação EBNF. Apresente as gramáticas em BNF.

(a)

A → “a” { “b” } (“a” | A)

(b)

A → { “(“ [B | D] “)” }

D → { “[“ [B | D] “]” }

(c)

C → { ( “a” | [ “b” ] ) (“c” | “d” )}

Conjuntos First e Follow:

2. Considere a seguinte gramática representada em BNF:

A → “a” A | “a” B “b”

B → “b” B | C

C → ε | B

(a) Quais dos símbolos não-terminais podem derivar ε?

(b) Determine os conjuntos First e Follow para os símbolos não-terminais A e B.

Análise Sintáctica Descendente:

3. Considere a gramática seguinte, em que PRINT, ID e NUM representam símbolos terminais:

Start → S

S → S “;“ S

S → ID “:=” E

S → PRINT “(“ L “)”



E → ID

E → NUM

E → E “+” E

E → “(“ S “,” E “)”

L → E

L → L “,” E

(a) Acha que esta gramática é ambígua ou não-ambígua? Justifique a resposta.

(b) Determine os conjuntos: First(S), First(E), First(L), Follow(S), Follow(E), e

Follow(L).

(c) Pretende-se implementar um analisador sintáctico descendente LL(1). Para tal

deve-se, e apenas caso seja necessário, transformar a gramática de forma a eliminar

ambiguidades e recursividades à esquerda. Caso seja necessário, deve-se também

factorizar à esquerda. Tendo em atenção os pontos anteriores, verifique se é

necessário modificar a gramática e caso seja necessário apresente a gramática

modificada.

Análise Sintáctica Ascendente:

4. Considere a gramática seguinte em que B é o símbolo inicial (os números entre parêntesis identificam cada termo de uma produção):

B → P “&” B | P (1, 2)

P → “x” | “y” (3, 4)

(c) Como pode a gramática produzir x&y&x? Pode a gramática produzir x&y&?

(d) A partir das regras da gramática construa o DFA (autómato finito determinista) que implemente o controlo das acções num parser ascendente LR(0) ou SLR.

(e) A partir do DFA obtido na alínea anterior construa as tabelas sintácticas supondo uma gramática LR(0) e uma gramática SLR.

(f) Considerando a tabela sintáctica seguinte mostre como o parser aceita a entrada x&y&x completando a tabela apresentada a seguir à tabela sintáctica.

Acção Goto Estado

x y & $ B P

S1 Shift s5 Shift s5 erro Erro Goto s2 Goto s3

S2 erro erro erro Aceita

S3 erro erro Shift s4 Reduce (2)



S4 Shift s5 Shift s6 erro Erro Goto 7 Goto 3

S5 Reduce (3) Reduce (3) Reduce (3) Reduce (3)

S6 Reduce (4) Reduce (4) Reduce (4) Reduce (4)

S7 erro erro erro Reduce (1)

Pilha de

Símbolos

Pilha de Estados String na

Entrada

Acção

S1 x&y&x$ Shift s5

x s1 s5 &y&x$ Reduce (3)

P S1 &y&x$ Goto s3

P s1 s3 &y&x$ Shift s4

P & s1 s3 s4 y&x$

(g) Repita as acções efectuadas na tabela seguinte quando a String de entrada é x&y&:

Pilha de

Símbolos

Pilha de Estados String na

Entrada

Acção

x&y&$

5. Considere cada uma das gramáticas seguintes. Diga se cada uma das gramáticas é uma gramática LR(0) e/ou SLR(1). Para tal, construa as tabelas sintácticas LR(0) e SLR(1). Nota: uma gramática designa-se, por exemplo, por gramática LR(0) se a tabela sintáctica LR(0) não apresenta conflitos (shift/reduce ou reduce/reduce).

a)

S → X $ (1)



X → “(“ X “)” | “(“ “)” (2, 3)

b)

S → X $ (1)

X → “(“ X “)” | ε (2, 3)

c)

S → X $ (1)

X → “(“ | Y (2, 3)

Y → “(“ Y “)” | ε (4, 5)



FICHA Nº 9 : Exercícios de Revisão

1. 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

x

4 3

x

y

x

y

2 y

x x

5 a

6

x

x

a

a

2. 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.

Apresente as tabelas edge e final para o analisador lexical do exercício anterior.

3. 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 Term (2)

Expr → LIT (3)

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

Term → LIT (5)

(a) Desenhe as árvores sintácticas concretas que conseguir derivar para as entradas: (3/2)+4$ e 3/2+4$;

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



(c) Caso pretendesse que a gramática aceitasse nomes de variáveis – começados com uma letra e seguidos de sequências com zero ou mais dígitos ou letras – e não apenas literais como símbolos terminais, quais 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. No caso de ter de ser modificada, apresente a nova gramática;

(e) Determine os conjuntos First e Follow para cada um dos símbolos não terminais da gramática anterior;

(f) Considerando a gramática original desenhe o DFA para o analisador sintáctico LR(0);

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

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

4. Na figura a seguir é apresentado um pedaço de código (os números entre parêntesis identificam cada linha de código).

(1) int SumArray(int[] A, int N) {

(2) int i, sum;

(3) i = 0;

(4) sum = 0;

(5) while(i < N) {

(6) sum = sum + A[i];

(7) i = i+1;

(8) }

(9) return sum;

(10) }

(i) Diga os elementos presentes no código que deverão ser armazenados na tabela de símbolos para as variáveis locais e na tabela de símbolos para os parâmetros da função;

(j) Supondo que na geração de código assembly se pretendia utilizar a pilha de chamadas para armazenar todas as variáveis na função, quais os atributos que deverá ter o descritor associado a cada variável;

(k) Qual a estrutura de dados que escolheria para implementar a(s) tabela(s) de símbolos?

(l) Considerando as linhas de código (6) e (9), diga que verificações devem ser feitas pelo analisador semântico;

(m) Desenhe a árvore de instruções e expressões de nível alto para a sequência de instruções de (3) a (8), considerando as instruções: lda, sta, ldl, stl, e ldp;



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): ©João M. P. Cardoso 52


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) }

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

feitas pelo analisador semântico;

(b) 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);

(c) 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;

(d) 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.]


aulas terico-prticas de compiladores -...

Documents