©universidade do algarve 1 introdução da disciplina compiladores joão m. p. cardoso universidade...

©Universidade do Algarve1

Introdução da Disciplina

Compiladores

João M. P. Cardoso

Universidade do Algarve

8000-117 Faro, Portugal


O que é um compilador?

Software que traduz o texto que representa um programa para código máquina capaz de ser executado pelo computador

Contudo, um compilador pode ser muito mais do que isso...


Importância

Papel importante no desenvolvimento de aplicações complexas em tempo útil

Muitas das matérias abordadas são utilizadas por outras ferramentas: Tradução de linguagens Interpretação de descrições (ex.: html,

postscript, latex, ficheiros word) Procura de palavras ou frases por motores

de busca


Dilema da Programação

Assembly é fastidioso, erróneo, pouco produtivo, etc.Embora possa permitir melhor

desempenho Desenho de linguagens de alto-nível Como implementar a linguagem?

InterpretadorCompilador


Compilador

Programa em Linguagem

Máquina

Código fonte descrito numa linguagem de

alto-nível (ex.: C, C++, Pascal, etc.)

Compilador

Ponto de Origem

Ponto de Destino


Ponto de Origem

Linguagem imperativa (e.g., C/C++, Java, Pascal, etc.) Estado

• Variáveis escalares• Variáveis do tipo array• Registos• Atributos de objectos (linguagens orientadas por

objectos) Computação

• Expressões (aritméticas, lógicas, etc.)• Enunciados de atribuição• Fluxo de controlo (if, switch, etc.)• Procedimentos (métodos nas linguagens

orientadas por objectos)

Int sum(int A[], int N) { Int i, sum = 0; For(i=0; i<N; i++) { sum = sum + A[i]; } return sum;}


Ponto de Destino

Linguagem máquina que descreve o programa com base no ISA (Instruction-Set Architecture) do processador Estado

• Memória• Registos (de estado, de propósito geral, etc.)

Computação• Instruções do ISA (MIPS):

• Lw $3, 100($2)• Add $3, $2, $1• Bne $2, $3, label• …

Sum: Addi $t0, $0, 0 Addi $v0, $0, 0Loop: beq $t0, $a1, End Add $t1, $t0, $t0 Add $t1, $t1, $t1 Add $t1, $t1, $a0 Lw $t2, 0($t1) Add $v0, $v0, $t2 Addi $t0, $t0, 1 J LoopEnd: jr $ra


Tópicos

Estudo das etapas de um compilador Implementação de algumas dessas

etapas Aulas práticas serão vocacionadas

para implementação e realização de alguns exercícios

Construção de um compilador/interpretador simples


Docentes

João M. P. [email protected]. 2.65


Conteúdo Programático

Aulas Teóricas Introdução Análise lexical Análise Sintáctica Análise Semântica Tradução para código intermédio Geração de código final Optimização de código Tópicos avançados


Conteúdo Programático

Aulas Teórico-Práticas Programação de várias etapas de um

compilador (vamos utilizar Java) Exercícios de papel e lápis sobre

determinados aspectos Trabalhos para Casa

Exercícios levantados nas aulas teóricas Realização dos trabalhos para avaliação


Avaliação

Exame (40 %) + Trabalhos (60%) (1) Exame

de Época Normal de Recurso

Para obter aprovação: Nota da equação (1) >= 9,5 valores, mas Nota do exame >= 6,5 e Nota dos trabalhos >= 10


Bibliografia

Andrew W. Appel. Modern Compiler Implementation in Java, Cambridge University Press, 1998.

Alfred V. Aho, Ravi Sethi, Jeffery D. Ullman. Compiler - Principles, Techniques, and Tools, Addison-Wesley, 1986. [existe uma tradução brasileira]

Dick Grune, Henri E. Bal, Ceriel J. H. Jacobs, and Koen G. Langendoen, “Modern Compiler Design,” John Wiley & Sons, Ltd, 2000. [existe uma tradução brasileira]

Rui Gustavo Crespo. Processadores de Linguagens. IST Press. 2001. http://istpress.ist.utl.pt/lprocess.html

Com tópicos mais avançados: Steven S. Muchnick. Advanced Compiler Design and

Implementation, Morgan Kaufmann Publishers, 1997.


Boa sorte!

POR EXEMPLO, TENHO QUE SABER COMO

FUNCIONA UM COMPILADOR.

E DEPOIS?

DEPOIS? DEPOIS ESTAMOS

PRONTOS PARA CONSTRUIR UM COMPILADOR!

Página Web da disciplina:http://w3.ualg.pt/~jmcardo/ensino/compiladores

Lista de correio electrónicohttps://imap.ualg.pt/wws/info/fct-compiladores

Para subscrever: [email protected]


Do alto-nível ao assembly

Compiladores

João M. P. Cardoso


Viagem

Como são implementadas as estruturas computacionais em assembly? Revisão dos conceitos relacionados com a

programação em assembly para o MIPS R3000 (ver disciplina de Arquitectura de Computadores)

Fizemos o papel de um compilador. Agora vamos aprender, entre outras coisas, a fazer um compilador.


Do alto-nível ao assembly Alvo: MIPS R3000


# $a0 armazena o endereço de A[0]# $a1 armazena o valor de NSum: Addi $t0, $0, 0 # i = 0

Addi $v0, $0, 0 # sum = 0Loop: beq $t0, $a1, End # if(i == N) goto End;

Add $t1, $t0, $t0 # 2*iAdd $t1, $t1, $t1 # 2*(2*i) = 4*iAdd $t1, $t1, $a0 # 4*i + base(A)Lw $t2, 0($t1) # load A[i]Add $v0, $v0, $t2 # sum = sum + A[i]Addi $t0, $t0, 1 # i++J Loop # goto Loop;

End: jr $ra # return



Variáveis globais:Armazenadas na memóriaPara cada uso de uma variável global

o compilador tem de gerar instruções load/store

int a, b, c;

... fun(...) { ...}

Memória

abc


Variáveis Globais

Int a, b, c;

void fun() { c = a + b;}

.data 0x10000000a: .space 4b: .space 4c: .space 4

.textfun: …

la $t1, alw $t1, 0($t1)la $t2, blw $t2, 0($t2)add $t3, $t2, $t1la $t4, csw $t3, 0($t4)…

0x10000008

0x100000040x10000000

Alocação de

memória

Memória

abc


Do alto-nível ao assembly Conceito de chamada a procedimentos

Cada procedimento tem estados• Variáveis locais• Endereço de retorno

Estado é guardado na área de memória designada por pilha de chamadas (é utilizado um registo para apontar para a posição actual da pilha)

Pilha de chamadas A pilha de chamadas encontra-se no topo da memória A pilha cresce para baixo

void fun() { int a, b, c; ... c = a + b; ...}

Memória

cba

Registos

$sp


Variáveis Locais

Exemplo:


fun: addi $sp, $sp, -12…lw $t1, 0($sp)lw $t2, 4($sp)add $t3, $t2, $t1sw $t3, 8($sp)…addi $sp, $sp, 12jr $raMemória

cba $sp

Reserva espaço na pilha

liberta espaço na pilha

Load aLoad b

store ca + b


Variáveis Locais

Acesso aos registos internos do processador é muito mais rápido Mas os registos internos são em número limitado E por isso nem todas as variáveis locais podem ser

armazenadas nesses registos No passado a atribuição de registos internos do

processador a variáveis locais era feita pelo programador: A linguagem C tem uma palavra reservada para

orientar o compilador: register (e.g., register int c;) Hoje os compiladores são muito mais eficientes

Essa atribuição é lhe inteiramente delegada


Variáveis Locais

Utilização de registos internos


fun: …add $t3, $t2, $t1…jr $ra

Ficheiro de

Registos$t1$t2$t3

abc



Implementar RegistosRegistos contêm

vários campos Cada estrutura é

armazenada em posições contíguas de memória

typedef struct { int x, y, z;} foo;

foo *p;

Memória

zyx

p



Exemplo com estrutura local:


fun() { foo *p; p->x = p->y + p->z;}

fun: addi $sp, $sp, -16…

lw $t1, 0($sp)addi $t1, $t1, 8lw $t2, 0($t1)lw $t1, 0($sp)addi $t1, $t1, 12lw $t3, 0($t1)add $t3, $t2, $t3lw $t1, 0($sp)addi $t1, $t1, 4sw $t3, 0($t1)…addi $sp, $sp, 16jr $ra



Endereço de p

Load p->y

Load p->zp->y + p->z

store em p->x

Memória

zyxp

address p->y

address p->z

address p->x

Endereço de p

Endereço de p



Exemplo com estrutura local (optimizado):


fun() { foo *p; p->x = p->y + p->z;}

fun: addi $sp, $sp, -16…lw $t2, 8($sp)lw $t3, 12($sp)add $t3, $t2, $t3sw $t3, 4($sp)…addi $sp, $sp, 16…



Load p->yLoad p->zp->y + p->zstore em p->x

Memória

zyxp



Compiladores

João M. P. Cardoso


Alinhamento, empacotamento e enchimento

Requisitos de alinhamento: Inteiros tipo int (4 bytes) a começar em

endereços com os 2 LSBs == “00” Inteiros tipo short (2 bytes) a começar em

endereços com o LSB == ‘0’ Alinhamento requer:

Enchimento entre campos para assegurar o alinhamento

Empacotamento de campos para assegurar a utilização de memória


Alinhamento

typedef struct {

int w; char x; int y; char z;} foo;

foo *p;

Memória

zyx

p

w

Memória

yx, z

p

w

Organização “ingénua”

OrganizaçãoEmpacotada

(poupa 4 bytes)

livre

ocupado 32 bits32 bits


Arrays

Afectação de posições de memória para os elementos do array

Elementos são armazenados contiguamente

Memória

a[0]

int a[4];

a[1]a[2]a[3]

Memória

a[1]

short a[4];

a[0]a[3]a[2]

32 bits 32 bits


Arrays

Utilizando registos do processador para armazenar as variáveis i e j:

.dataA: .space 16

.textProc:

…la $t0, Aaddi $t2, $0,

4mult $t1, $t2mflo $t2add $t3, $t2,

$t0lw $t4,

0($t3)…

int a[4];proc() { int i, j; … i = a[j]; …}

Endereço de a[j] = endereço de a[0] + (4 × j) = a + (4 × j)


Expressões

a = b * c + d – e; a em $t4; b em $t0; c em $t1; d em

$t2; e em $t3

…mult $t0, $t1mflo $t4sub $t5, $t2,

$t3add $t4, $t4,

$t5…

…mult $t0, $t1mflo $t4add $t4, $t4,

$t2sub $t4, $t4,

$t3…


Estruturas condicionais

If(a == 1) b = 2; a em $t0; b em $t1

If(a == 1) b = 2;

else b = 1; a em $t0; b em $t1

…addi $t2, $0, 1bne $t2, $t0,

skip_ifaddi $t1, $0, 2

Skip_if: …

…addi $t2, $0, 1bne $t2, $t0,

elseaddi $t1, $0, 2 j skip_if

Else: addi $t1, $0, 1Skip_if: …


Estruturas condicionais

Branch-delay O processador executa

sempre a instrução a seguir a uma instrução de salto (quer o salto seja realizado ou não)

Quando não é possível deslocar uma instrução para depois da instrução de salto, tem de se introduzir uma instrução nop

If(a == 1) b = 2;

C = a+1; a em $t0; b em $t1

…addi $t2, $0, 1bne $t2, $t0,

skip_ifaddi $t3, $t0, 1addi $t1, $0, 2

Skip_if: …


Ciclos

Transformar o fluxo de controlo (while, for, do while, etc.) em saltos



Addi $v0, $0, 0 # sum = 0Loop: beq $t0, $a1, End # if(i == N) goto End;

Add $t1, $t0, $t0 # 2*iAdd $t1, $t1, $t1 # 2*(2*i) = 4*iAdd $t1, $t1, $a0 # 4*i + base(A)Lw $t2, 0($t1) # load A[i]Add $v0, $v0, $t2 # sum = sum + A[i]Addi $t0, $t0, 1 # i++J Loop # goto Loop;



Ciclos

Optimizações Manter i e endereço de a[i] em registos Determinar endereço de a[0] antes do corpo

do ciclo, e incrementar de 4 (no caso de serem acessos a palavras de 32 bits) no corpo do ciclo

Caso o ciclo execute pelo menos uma iteração (N > 0) passar salto do ciclo para o fim do corpo


Ciclos

Código após as optimizações



Addi $v0, $0, 0 # sum = 0Loop: Lw $t2, 0($a0) # load A[i]

Add $v0, $v0, $t2 # sum = sum + A[i]addi $a0, $a0, 4 # add 4 to addressAddi $t0, $t0, 1 # i++bne $t0, $a1, Loop # if(i != N) goto Loop;



Procedimentos

Protocolo entre os procedimentos que invocam e os procedimentos invocados Dependente do processador No MIPS:

• Procedimento espera argumentos nos registos $a0-$a3

• Coloca valores a retornar nos registos $v0-$v1• Outras formas de passagem de parâmetros

utilizam a pilha de chamadas (por exemplo, sempre que o número de argumentos ultrapassa o número de registos para utilizar como argumentos)


Sumário

Quais as responsabilidades do compilador? Esconder do programador conceitos baixo-nível da

máquina Produzir rapidamente código eficiente Afectar variáveis a registos locais ou posições de

memória Cálculo de expressões com constantes Manter funcionalidade inicial Geração de instruções de forma a suportar as

chamadas aos procedimentos utilizadas no programa Optimizações


Anatomia de um Compilador

Compiladores

João M. P. Cardoso


Viagem

Do texto que representa o programa até ao código máquina

Duas fases:Análise

• Reconhecimento dos enunciados no código fonte e armazenamento em estruturas internas

Síntese• Geração do código assembly a partir das

estruturas internas


Análise Lexical

Lexical Analyzer (Scanner)

Cadeia de Tokens

Programa (cadeia de caracteres)


Análise Lexical/* uma expressão simples */y = b*x +c; // atribui a y

ID(y) EQ ID(b) TIMES ID(x) PLUS ID(c) SEMICOLON EOF



Análise Lexical

/* exemploInt sum(int A[], int N) { Int i, 5sum = 0; For(i=0; i<N; i++) { sum = sum + A[i]; } return sum;}

Tratamento de erros

Não é uma palavra reservada nem um identificador

Falta terminar comentário */


Análise Sintáctica

Syntax Analyzer (Parser)

Árvore sintáctica



Cadeia de Tokens


b x

y

=

+

* c

b x

y

=

+

* c



b x*

=

y

<stmt>

<expr><ident>

<ident>

<expr>

<ident><op>

y = b*x + c

+

<op>

c

<ident>

Árvore Sintáctica (concreta)



b x

y

=

+

* c

Árvore Sintáctica (abstracta): AST

y = b*x + c



Tratamento de erros

Int sum(int A[], int N)) { Int i, sum = 0; For(i=0; i<N; i++) { sum = sum + A[i] } retur sum;}}

Falta ‘;’

“retur” não é palavra reservada: dois identificadores seguidos?

Chaveta a mais

Parêntesis a mais


Análise Semântica

Semantic AnalyzerSemantic Analyzer


Árvore sintáctica



Cadeia de Tokens


Representação intermédia

tmp1 = b*x;tmp2 = tmp1 + c;


Análise Semântica

Tratamento de erros

boolean sum(int A[], int N) { Int i, sum; For(i=0; i<N; i++) { sum1 = sum + A[i]; } return sum;}

Não foi atribuído valor inicial a sum

Tipo da variável retornada não confere com a declaração do cabeçalho da função

Variável não declarada


Optimização de código

Code OptimizerCode Optimizer

Representação intermédia optimizada




Árvore sintáctica



Cadeia de Tokens



Geração de código assembly

Code Generator

Código Assembly

Code Generator

Code OptimizerCode Optimizer





Árvore sintáctica



Cadeia de Tokens


mult $t4, $t1,$t2;Add $t4, $t4, $t3;


TPC

Apresente os resultados de cada etapa de compilação para a expressão:y = a*x*x+b*x+c;


Análise Lexical

Compiladores

João M. P. Cardoso


Linguagens Formais

Linguagem natural Ambígua

• problema no processamento das linguagens• dependência do contexto permite mensagens

mais curtas Linguagem (artificial) formal

Obedece a regras apresentadas rigorosamente através do recurso a formalismos apropriados

Regras garantem a não ambiguidade da linguagem


Linguagens formais e definição da linguagem

Necessidade de definir precisamente uma linguagem

Estrutura por camadas na definição da linguagem Começar por um conjunto de símbolos da linguagem Estrutura lexical - identifica “palavras” na

linguagem (cada palavra é uma sequência de símbolos)

Estrutura Sintáctica - identifica “frases” na linguagem (cada frase é uma sequência de palavras)

Semântica – significado do programa (especifica que resultados deverão ser obtidos para as entradas)


Especificação Formal de Linguagens

Expressões regulares (método generativo)Existem casos que não se podem descrever

por expressões regulares Autómatos finitos (método por reconhecimento)

Não deterministas (NFAs)Deterministas (DFAs) Implementam qualquer expressão regular


Especificação de Estruturas Lexicais utilizando Expressões regulares Dado um vocabulário/alfabeto = conjunto

de símbolos Expressões regulares são construídas com:

- string vazia Qualquer símbolo do alfabeto r1r2 – expressão regular r1 seguida de r2

(sequência): concatenação (às vezes utiliza-se o .)

r1| r2 – expressão regular r1 ou r2 (selecção) r* - sequência iterativa ou selecção | r | rr |

… Parêntesis para indicar precedências

• Prioridade: *, ., |


Expressões regulares

Reescrever a expressão regular até se obter apenas uma sequência de letras (string) Exemplo

(0 | 1)*”.”(0 | 1)*(0 | 1)(0 | 1)*”.”(0 | 1)*1(0 | 1)*”.”(0 | 1)*1”.”(0 | 1)*1”.”(0 | 1)(0 | 1)*1”.”(0 | 1)1”.”0

Regras gerais

1) r1| r2 r1

2) r1| r2 r2

3) r* rr*

4) r*


Não determinismo na geração

Diferente aplicação de regras pode conduzir a resultados finais diferentes

Exemplo 1(0 | 1)*”.”(0 | 1)*(0 | 1)(0 | 1)*”.”(0 | 1)*1(0 | 1)*”.”(0 | 1)*1”.”(0 | 1)*1”.”(0 | 1)(0 | 1)*1”.”(0 | 1)1”.”0

Exemplo 2(0 | 1)*”.”(0 | 1)*(0 | 1)(0 | 1)*”.”(0 | 1)*0(0 | 1)*”.”(0 | 1)*0”.”(0 | 1)*0”.”(0 | 1)(0 | 1)*0”.”(0 | 1)0”.”1


Linguagem gerada por expressões regulares

Conjunto de todas as strings geradas pela expressão regular é uma linguagem de expressões regulares

Em geral, uma linguagem pode ser infinita

String na linguagem é chamada de token


Linguagens e Expressões Regulares

Exemplos: = {0, 1, “.” }

(0 | 1)*”.”(0 | 1)* - números binários de vírgula flutuante

(00)* - strings de zeros com comprimento par

(1*01*01*)* - strings com um número par de zeros

= {a, b, c, 0, 1, 2 } (a | b | c)(a | b | c | 0 | 1 | 2)* - identificadores

alfanuméricos (0|1|2)* - números ternários


Expressões Regulares

Outras construções:r+ - uma ou mais ocorrências de r: r |

rr | rrr ...• Equivalente a: r.r*

r? – zero ou uma ocorrência de r: (r | )[ ] – classes de símbolos:

• [ac] o mesmo que: (a | c)• [a-c] o mesmo que: (a | b | c)


Expressões Regulares

Especifique a linguagem de Inteiros Especifique a linguagem de

identificadores (uma letra seguida de sequências de letras e algarismos)

Enumere propriedades algébricas das expressões regulares

Dê exemplos de linguagens que não podem ser especificadas por expressões regulares


Análise Lexical

Compiladores

João M. P. Cardoso


Especificação Formal de Linguagens

Expressões regulares (método generativo)Existem casos que não se podem

descrever por expressões regulares Autómatos finitos (método por

reconhecimento)Não deterministas (NFAs)Deterministas (DFAs)Implementam qualquer expressão regular


Autómatos Finitos

Conjunto de estados 1 estado de Entrada 1 ou mais estados terminais (ou estados de

aceitação) Alfabeto de símbolos: (inclui o símbolo de

string de tamanho zero: ) Transições entre estados despoletadas pela

ocorrência de um determinado símbolo do alfabeto

Transições rotuladas com símbolos


Autómatos Finitos

Exemplo

Estado de início

Estado de aceitação

1

0

1

0

(0 | 1)*”.”(0 | 1)*


Aceitação de string pelo autómato Reconhecimento através da execução do autómato

Começar com o estado de início e com o primeiro símbolo da string

Guardar estado corrente e o símbolo corrente da string

Em cada passo, fazer corresponder símbolo corrente com a transição rotulada com esse símbolo

Continuar até ao fim da string ou até que a correspondência falhe

Se o estado final é estado de aceitação, então o autómato aceita a string

Linguagem do autómato é constituída pelo conjunto de strings que ele aceita


Exemplo

11.0

Símbolo corrente

Estado de início


1

0

1

0


Exemplo

11.0

Símbolo corrente String aceite!

Estado de início


1

0

1

0


Autómatos Finitos

NFA: Autómato Finito não Determinista De um determinado estado, a mesma

ocorrência pode conduzir a estados distintos DFA

O mesmo que NFA com a seguinte ressalva:• De um determinado estado, a ocorrência de um

símbolo não pode ter mais do que um laço, e por isso não pode levar a estados diferentes.


NFA vs DFA

DFA Sem transições No máximo uma transição de cada estado

para cada símbolo

NFA – nenhuma destas restrições

a

a

a

b

OKNOTOK


Autómatos Finitos

Autómatos Finitos Deterministas (DFAs)Implementações mais rápidas do que

para os NFAs, masMaior complexidade do autómato


Generativo vs Reconhecimento

Expressões regulares são um mecanismo para gerar as Strings da linguagem

Autómatos são um mecanismo para reconhecer se uma String específica pertence à linguagem

Abordagem standard Usar expressões regulares aquando da definição da

linguagem Tradução automática para autómatos para a

implementação da analisador lexical


Análise Lexical

Compiladores

João M. P. Cardoso


Da Expressão Regular ao Autómato

Tradução da Expressão Regular para um Autómato

Implementação do Autómato


Da Expressão Regular ao Autómato

Construção por indução estrutural Dada uma expressão regular r arbitrária, Assumir que podemos convertê-la para um

autómato com Um estado início Um estado de aceitação

Mostrar como converter todas as construções de expressões regulares para produzir um autómato com Um estado de início Um estado de aceitação


Construtores Básicos

aa


Sequência

r1.r2

r1 r2


Selecção

r1 | r2

r1

r2


Asterisco de Kleene

r*

r


Regras de Conversão

r1 r2

r1.r2

r1

r2

r1 | r2

r

r*a a


Conversão

A conversão de uma expressão regular para um autómato baseada nas regras apresentadas produz um NFA

Nós queremos ter um DFA para facilitar o algoritmo de reconhecimento

Pode-se converter do NFA para o DFA o DFA pode ser exponencialmente maior do

que o NFA• Teoricamente um NFA com N estados pode

originar um DFA com 2N-1 estados A optimização do DFA resultante envolveria

eliminação de estados equivalentes


Conversão NFA para DFA

O DFA tem um estado para cada subconjunto de estados no NFA O estado início do DFA corresponde ao conjunto de estados

alcançáveis seguindo as transições do estado início no NFA Um estado do DFA é de aceitação se um estado de aceitação do

NFA está no conjunto de estados agrupados Para determinar a transição despoletada pelo símbolo “a” de um dado

estado D do DFA Colocar S como conjunto vazio Encontrar o conjunto N de estados D no NFA

• Para todos os estados do NFA em N• Determinar o conjunto de estados N’ em que o NFA pode

estar depois de reconhecer “a”• Actualizar S com a união de S com N’

Se S não é vazio, há uma transição para “a” de D para o estado no DFA que tem o conjunto de estados S do NFA

Caso contrário, não há nenhuma transição “a” de D


NFA para DFA Exemplo: (0 | 1)*.(0|1)*

1 2

3

4

5

6

1

0

7

8

9 10

11

12

13

14

1

0

15

16

.

1,2,3,4,8

5,7,2,3,4,8

6,7,2,3,4,8

9,10,11,12,16

13,15,10,11,12,16

14,15,10,11,12,16

1

0

1

0

10

10

00

1 1


Estrutura Lexical nas Linguagens

Cada linguagem tem várias categorias de palavras. Numa linguagem de programação: Palavras chave (if, while) Operações aritméticas (+, -, *, /) Números inteiros (1, 2, 45, 67) Números em vírgula flutuante (1.0, .2, 3.337) Identificadores (abc, i, j, ab345)

Tipicamente tem-se uma categoria lexical para cada palavra chave e/ou categoria

Cada categoria lexical é definida por expressões regulares


Exemplo de Categorias Lexicais (exemplo)

Palavra_chave_if = if Palavra_chave_while = while Operador = +|-|*|/ Inteiro = [0-9] [0-9]* Float = [0-9]*. [0-9]* Identificador = [a-z]([a-z]|[0-9])* Na análise sintáctica vamos utilizar

estas categorias


Análise Lexical

Compiladores

João M. P. Cardoso


Da Expressão Regular ao Analisador Lexical

Tradução da Expressão Regular para um NFA

Do NFA para o DFA Implementação em software do

DFA


Interpretador do DFA

State = DFA initial state;inputChar = getchar();While(inputChar) {

State = trans(State, inputChar]);inputChar = getchar();

}If(State é um estado de aceitação) realizar acção relativa ao estado State (reconheceu

String)Else realizar outra acção

Algoritmo do Interpretador


NFA para DFA Exemplo: (0 | 1)*.(0|1)*

1 2

3

4

5

6

1

0

7

8

9 10

11

12

13

14

1

0

15

16

.

1,2,3,4,8

5,7,2,3,4,8

6,7,2,3,4,8

9,10,11,12,16

13,15,10,11,12,16

14,15,10,11,12,16

1

0

1

0

10

10

00

1 1


DFA

Tabela de transição de estados (adicionamos o estado 0 – estado morto - para as transições não apresentadas)

1

2

3

4

5

6

1

0

1

0

10

10

00

1 1

Estado

Actual

Próximo Estado

“0” “1” “.”

0 0 0 0

1 3 2 4

2 3 2 4

3 3 2 4

4 6 5 0

5 6 5 0

6 6 5 0


Implementação do DFA

Implementar a tabela de transições de estados com um array bidimensional

1

2

3

4

5

6

1

0

1

0

10

10

00

1 1

Estado

Actual

Próximo Estado

“0” “1” “.”

0 0 0 0

1 3 2 4

2 3 2 4

3 3 2 4

4 6 5 0

5 6 5 0

6 6 5 0



O array fornecerá uma indexação por número de estado e símbolo

Supondo a possibilidade de 256 símbolos: int Edge[NumStates][256] (NumStates = 7)

1

2

3

4

5

6

1

0

1

0

10

10

00

1 1

Estado

Actual

Próximo Estado

“0” “1” “.”

0 0 0 0

1 3 2 4

2 3 2 4

3 3 2 4

4 6 5 0

5 6 5 0

6 6 5 0



int Edge[NumStates][256] ={ /*... 0 1 2 ... 9 ...

“.” ... *//* estado 0 */ {..., 0, 0, 0, ..., 0, ..., 0, ...},/* estado 1 */ {..., 3, 2, 0, ..., 0, ..., 4, ...},/* estado 2 */ {..., 3, 2, 0, ..., 0, ..., 4, ...}, /* estado 3 */ {..., 3, 2, 0, ..., 0, ..., 4, ...}, /* estado 4 */ {..., 6, 5, 0, ..., 0, ..., 0, ...}, /* estado 5 */ {..., 6, 5, 0, ..., 0, ..., 0, ...}, /* estado 6 */ {..., 6, 5, 0, ..., 0, ..., 0, ...}}

Exemplo:Edge[3][(int) ‘.’] 4

Estado

Actual

Próximo Estado

“0” “1” “.”

0 0 0 0

1 3 2 4

2 3 2 4

3 3 2 4

4 6 5 0

5 6 5 0

6 6 5 0



Um array unidimensional traduz o número de estado no número da acção a realizar:

// estado 0 1 2 3 4 5 6int final[NumStates] = {0, 0, 0, 0, 1, 1, 1}

Exemplo:

final[3] 3 (logo deve ser realizada a acção 3)

Estado

Actual

Próximo Estado

“0” “1” “.”

0 0 0 0

1 3 2 4

2 3 2 4

3 3 2 4

4 6 5 0

5 6 5 0

6 6 5 0



State = 1; // estado inicial do DFAinputChar = input.read();While(inputChar) {

State = edge[State][inputChar];inputChar = input.read();

}If(final[State] == 1) realizar acção (reconheceu String)Else realizar outra acção

Programação do Interpretador


Optimizações na implementação do DFA

Representação da tabela de transições por um array bidimensional pode não ser eficiente em termos de espaço de memória

Mapeamento indirecto:int Edge[NumStates][4] = { /* estado 0 */ {0, 0, 0, 0},/* estado 1 */ {3, 2, 4, 0},/* estado 2 */ {3, 2, 4, 0}, /* estado 3 */ {3, 2, 4, 0}, /* estado 4 */ {6, 5, 0, 0}, /* estado 5 */ {6, 5, 0, 0}, /* estado 6 */ {6, 5, 0, 0}}

/*... “0” “1” “2” “3” ... 9 ... “.” ... */Int map[256] = { ..., 0, 1, 3, 3,... 3, ... 2, ...}Exemplo:

Edge[3][(int) ‘.’] é feito assim:Edge[3][map[(int) ‘.’]]


Optimizações na implementação do DFA

Para o exemplo apresentado:Permitiu passar de um array com 256

7 (1792) elementos para um array com 256 e outro array com 7 4 (28) elementos

De 1792 para 284 elementos Existem outras formas de

optimização...



Compiladores

João M. P. Cardoso


Sintaxe em Linguagens de Programação

Linguagens regulares deficientes para especificar a sintaxe das linguagens de programação

Porquê? Construções com sintaxe encadeada (a+(b-c))*(d-(x-(y-z))) if (x < y) if (y < z) a = 5 else a = 6 else a = 7

Linguagens regulares não têm o estado requerido para modelar encadeamento

Nenhuma expressão regular para especificar linguagens com expressões com parêntesis


Solução

Gramáticas independentes do contextoReconhecimento realizado por

autómatos finitos equipados com uma pilha


Gramáticas Notação de Backus Naur Form (BNF) para especificar a

gramática Símbolos terminais: letras maiúsculas (por vezes a

negrito) e Símbolos não-terminais: iniciados por uma letra maiúscula

Ou, símbolos não-terminais delimitados por < e > Numa produção (derivação) os lados esquerdo e direito

são separados pelo símbolo ou ::=• Ex.: Expr Term OP Term

Produções alternativas (p1, p2, p3, ..., pn) são representadas por p1 | p2 | p3 |...| pn

• Ex.: Literal BINARIO | OCTAL | INT | FLOAT Se o lado direito de uma produção não contém nenhum

símbolo, então escreve-se • Ex.: Palavra


Gramáticas

EBNF, ou BNF estendidoInclui { } para representar 0 ou mais

repetições de símbolose [ ] para representar elementos

opcionais


Gramáticas (independentes do contexto)

Conjunto de símbolos terminais{ OP, INT, OPEN, CLOSE }Cada símbolo terminal definido por

expressões regulares Conjunto de símbolos não-terminais

{ Start, Expr } Conjunto de produções

Um único símbolo não-terminal no lado esquerdo da produção (LHS)

Sequência de símbolos terminais e não-terminais no lado direito da produção (RHS)

OP = + | - | * | /

INT = [0-9] [0-9]*

OPEN = (

CLOSE = )

Start Expr

Expr Expr OP Expr

Expr INT

Expr OPEN Expr CLOSE


Jogo da produção/derivação

Dada a frase correnteComeçar pelo símbolo não-terminal StartRepetir até não haver símbolos não-terminais

Seleccionar um símbolo não-terminalSeleccionar uma produção com símbolos não-terminais em LHSSubstituir símbolo não-terminal com o RHS da produção

Substituir a expressão regular com as Strings correspondentesString gerada está na linguagem

Nota: selecções diferentes produzem Strings diferentes


Produção/Derivação

Start

Expr

Expr OP Expr

OPEN Expr CLOSE OP Expr

OPEN Expr OP Expr CLOSE OP Expr

OPEN INT OP Expr CLOSE OP Expr

OPEN INT OP Expr CLOSE OP INT

OPEN INT OP INT CLOSE OP INT

( 2 - 1 ) + 1

OP = +|-|*|/

INT = [0-9] [0-9]*

OPEN = (

CLOSE = )

1) Start Expr

2) Expr Expr OP Expr

3) Expr INT

4) Expr OPEN Expr CLOSE



Compiladores

João M. P. Cardoso


Árvore Sintáctica

Nós internos: símbolos não-terminais Folhas: símbolos terminais Laços:

De símbolos não-terminais do LHS da produção

A nós do RHS da produção Captura a derivação da frase (String)


Árvore Sintáctica para (2-1)+1

Start

Expr

ExprExprOP

+OPEN(

CLOSE)

ExprINT1

OP -

Expr

INT2

Expr

INT1


Ambiguidade numa Gramática

Múltiplas derivações (como consequência: múltiplas árvores sintácticas) para a mesma String

Derivação e árvore sintáctica reflecte usualmente a semântica do programa

Ambiguidade na gramática reflecte muitas das vezes ambiguidades na semântica da linguagem (considerada indesejável)


Exemplo de ambiguidade

Duas árvores sintácticas para 2-1+1

Start

Expr

Expr ExprOP+

Expr ExprOP-

INT2

INT1

INT1

Start

Expr

ExprExpr OP-

Expr ExprOP+

INT1

INT1

INT2

Árvore correspondente a (2-1)+1

Árvore correspondente a 2-(1+1)


Eliminação de ambiguidade

Solução: modificar gramática Faz todos os operadores com

associação à esquerda

Gramática Original

Start Expr

Expr Expr OP Expr

Expr INT


Gramática Modificada

Start Expr

Expr Expr OP INT

Expr INT



Árvore sintáctica para a gramática

Apenas uma árvore sintáctica para: 2-1+1

Start

Expr

Expr OP+

Expr OP-

INT2

INT1

INT1

Start

Expr

ExprExpr OP-

Expr ExprOP+

INT1

INT1

INT2

Árvore sintáctica válidaÁrvore sintáctica inválida


Violação de prioridade

Todos os operadores associam à esquerda

Viola prioridade de * sobre +2-3*4 associa como (2-

3)*4

Start

Expr

Expr OP*

Expr OP-

INT2

INT3

INT4

Árvore sintáctica para2-3*4


Resolver prioridade

Gramática Original

OP = + | - | * | /

INT = [0-9] [0-9]*

OPEN = (

CLOSE = )

Start Expr

Expr Expr OP INT

Expr INT


Gramática ModificadaOP1 = + | -

OP2 = * | /

INT = [0-9] [0-9]*

OPEN = (

CLOSE = )

Start Expr

Expr Expr OP1 Term

Expr Term


Term Term OP2 INT

Term INT


Modificação nas Árvores Sintácticas

Start

Expr

Expr OP*

Expr OP-

INT2

INT3

INT4

Velha Árvore sintáctica para 2-3*4

Start

Expr

Expr OP1-

Term

INT2

Nova Árvore sintáctica para 2-3*4

Term

Term OP2*

INT3

INT4


Ideia Geral

Agrupar operadores por níveis de prioridade * e / estão no nível de topo + e – estão no nível a seguir

Símbolo não-terminal para cada nível de prioridade Term é não-terminal para * e / Expr é não-terminal para + e -

Pode-se fazer associatividade dos operadores à esquerda ou à direita em cada nível

Generalizar para níveis arbitrários de prioridades


Exercícios (TPC) Especificar utilizando a representação BNF

gramáticas correspondentes às expressões regulares: [0-9]+ e [0-9]*

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:

• 5-2*3• y^3



Compiladores

João M. P. Cardoso


Manuseando estruturas if-then-else

Start Stat

Stat IF Expr THEN Stat ELSE Stat

Stat IF Expr THEN Stat

Stat ...


Árvore Sintáctica

Considere o enunciado: if e1 then if e2 then s1 else s2


Árvore Sintáctica Duas Árvores

Sintácticas

Stat

IF Expr Stat

IF Expr Stat ELSEe1

e2

Stat

s1 s2

IF Expr

Stat

IF Expr Stat ELSE

e2

e1

Stat

s1s2

Qual é a correcta?

THEN

THEN

THEN


Leituras alternativas

Gramática ambígua Árvore sintáctica 1

if e1

if e2 s1

else s2

Árvore sintáctica 2

if e1

if e2 s1

else s2


Gramática modificada

Goal Stat

Stat WithElse

Stat LastElse

WithElse IF Expr THEN WithElse ELSE WithElse

WithElse ...

LastElse IF Expr THEN Stat

LastElse IF Expr THEN WithElse ELSE LastElse


Gramática modificada

Ideia básica: controlar quando um IF sem ELSE pode ocorrerNo nível de topo do enunciadoOu como último numa sequência de

enunciados if then else if then ...


Analisador Sintáctico

Converte programas numa árvore sintáctica Pode ser programado do zero! Ou construído automaticamente por um gerador de

“parsers” Aceitam uma gramática como entrada Produzem um analisador sintáctico como resultado

Problema prático A Árvore Sintáctica para a gramática modificada é

complicada Gostaríamos de começar com uma árvore sintáctica

mais intuitiva


Solução

Sintaxe Abstracta versus Concreta Sintaxe abstracta corresponde ao meio

intuitivo de pensar a estrutura do programa• Omite detalhes como palavras-chave supérfluas

que estão lá para tornar a linguagem ambígua• Sintaxe abstracta pode ser ambígua

Sintaxe Concreta corresponde à gramática completa para utilizada para analisar sintacticamente a linguagem

Os analisadores sintácticos são muitas das vezes escritos para produzirem Árvores Sintácticas Abstractas (ASTs)


ASTs (Árvores Sintácticas Abstractas)

Começar com uma gramática intuitiva mas ambígua

Modificar a gramática para a tornar não- ambígua Árvores sintácticas concretas Menos intuitivas

Converter as árvores sintácticas concretas em ASTs Correspondem à gramática intuitiva para a

linguagem Mais simples de manipular pelo programa


Exemplo

Gramática intuitiva mas ambígua

OP = * | / | + | -

INT = [0-9] [0-9]*

Start Expr

Expr Expr OP Expr

Expr INT

Gramática não-ambíguaOP1 = + | -

OP2 = * | /

INT = [0-9] [0-9]*

OPEN = (

CLOSE = )

Start Expr

Expr Expr OP1 Term

Expr Term

Term OPEN Expr CLOSE

Term Term OP2 INT

Term INT


ExemploStart

Expr

Expr

Expr OP2-

INT3

Árvore sintáctica concreta para

(2-3)*4 Term

OP1*

INT4

Term

OPEN CLOSE

Term

INT2

Term

Start

Expr

Expr OP*

ExprOP

-INT2

Expr

INT4

Expr

INT3

Árvore sintáctica abstracta para

(2-3)*4

• Utiliza gramática intuitiva• Elimina terminais supérfluos

• OPEN, CLOSE, etc.


Exemplo

Start

Expr

Expr OP*

OP-

INT2

INT4

INT3

AST para (2-3)*4

Ainda mais

simplificada

Árvore sintáctica abstracta para

(2-3)*4 Start

Expr

Expr OP*

ExprOP

-INT2

Expr

INT4

Expr

INT3


Sumário

Níveis da estrutura lexicais e sintácticos Lexicais – expressões regulares e

autómatos Sintácticos – gramáticas

Ambiguidades na gramática Gramáticas modificadas Árvores Sintácticas Abstractas (ASTs)

Papel generativo versus papel reconhecedor Generativo mais conveniente para

especificação Reconhecedor requerido na implementação



Compiladores

João M. P. Cardoso


Vocabulário gramatical

Derivação à esquerda (Leftmost) Expandir sempre o símbolo não terminal

mais à esquerda que resta

Derivação à direita (Rightmost) Expandir sempre o símbolo não terminal

mais à direita que resta

Aplicar primeiro a produção aqui

NT1 T1 T2 T3 NT2 NT3

E só depois aos outros símbolos não-terminais


Ponto Inicial

Assumir que a análise lexical produziu uma sequência de tokens (símbolos terminais) Cada token tem um tipo e um valor Tipos correspondem a símbolos terminais Valores correspondem ao conteúdo do token

lido Exemplo

INT(549) – token que identifica um inteiro de valor lido 549

IF – palavra chave “if” sem necessidade de valor

OP(+) – operador com valor +


Abordagem Básica

Começar pelo símbolo Start ou pela primeira produção

Construir uma derivação leftmost Se o símbolo leftmost é não-terminal,

seleccionar uma produção e aplicá-la Se o símbolo leftmost é terminal, fazer

corresponder com a entrada Se todos os terminais foram correspondidos,

foi encontrada uma derivação que aceita a String!

Chave: encontrar as produções correctas para os símbolos não-terminais


Gramática do Exemplo

INT = [0-9]+

Start Expr

Expr Expr “+” Term

Expr Expr “-” Term

Expr Term

Term Term “*” INT

Term Term “/” INT

Term INT

Conjunto de tokens (símbolos terminais):

{ +, -, *, /, INT }


Analisador Sintáctico para a gramática exemplo

StartÁrvore Sintáctica

Posição corrente na árvore sintáctica

Forma sentencial

Entrada que falta2-2*2

Start




Forma sentencial


Expr

Posição corrente na árvore sintáctica

Expr

Produção AplicadaStart Expr




Forma sentencial

Entrada a faltar2-2*2

Expr - TermExpr

Produção AplicadaExpr Expr - Term

TermExpr -




Forma sentencial


Term - TermExpr

Produção AplicadaExpr Term

TermExpr -

Term




Forma sentencial


INT - TermExpr

Produção AplicadaTerm INT

TermExpr -

INT

Term




Forma sentencial


2 - TermExpr

TermExpr -

INT 2

Term

Token corresponde!




Forma sentencial

Entrada que falta-2*2

2 - TermExpr

TermExpr -

INT 2

Term

Token corresponde!




Forma sentencial

Entrada que falta2*2

2 - TermExpr

TermExpr -

INT 2

Term




Forma sentencial


2 – Term*INTExpr

TermExpr -

INT 2

Term Term INT*

Produção AplicadaTerm Term * INT




Forma sentencial


2 – INT*INTExpr

TermExpr -

INT 2

Term Term INT*

Produção AplicadaTerm INT

INT




Forma sentencial


2 – 2*INTExpr

TermExpr -

INT 2

Term Term INT*

INT 2

Token corresponde!




Forma sentencial

Entrada que falta*2

2 – 2*INTExpr

TermExpr -

INT 2

Term Term INT*

INT 2

Token corresponde!




Forma sentencial

Entrada que falta2

2 – 2*INTExpr

TermExpr -

INT 2

Term Term INT*

INT 2




Forma sentencial

Entrada que falta2

2 – 2*2Expr

TermExpr -

INT 2

Term Term INT 2*

INT 2

Token corresponde!




Forma sentencial

Entrada que falta

2 – 2*2Expr

TermExpr -

INT 2

Term Term INT 2*

INT 2

Análise sintáctica terminou


Sumário

Três acções (mecanismos) Aplicar produção para expandir o símbolo

não-terminal corrente na árvore sintáctica Casar o símbolo terminal corrente Aceitar a análise sintáctica como correcta

Qual a produção a utilizar por cada símbolo não-terminal?

Uma abordagem: Backtracking Tenta uma alternativa Quando for claro que a alternativa falhou

tentar outra alternativa


Analisador Sintáctico Preditivo

Alternativa ao backtracking Muito útil para linguagens de programação,

que podem ser desenhadas para facilitar a análise

Ideia básica Ver à frente na sequência de tokens Decisão de qual a produção a aplicar

baseada nos tokens seguintes Utilizaremos a profundidade de um token no

mecanismo de ver à frente


Gramática Exemplo

Start Expr

Expr Term Expr’

Expr’ “+” Term Expr’

Expr’ “-” Term Expr’

Expr’ Term INT Term’

Term’ “*” INT Term’

Term’ “/” INT Term’

Term’

INT = [0-9]+


{ +, -, *, /, INT }


Pontos de Escolha

Assumir que Term’ é a posição corrente na árvore sintáctica

3 produções diferentes a aplicar



Term’ Utilizar o próximo token para decidir

Se o próximo token for *, aplicar Term’ * Int Term’ Se o próximo token for /, aplicar Term’ / Int Term’ De outro modo, aplicar Term’


Múltiplas Produções com o mesmo prefixo no RHS

Gramática Exemplo

Nt IF THEN

Nt IF THEN ELSE Assumir que Nt é a posição corrente

na árvore sintáctica e IF é o próximo token

Qual a produção a aplicar?


Solução: factorizar a gramática à esquerda

Nova gramática factoriza o prefixo comum numa única produçãoNt IF THEN Nt’Nt’ ELSENt’

Nenhuma escolha quando o próximo token é um IF

Todas as alternativas foram unificadas numa única produção


Símbolos não-terminais

E as produções com símbolos não-terminais?

Nt Nt1 1

Nt Nt2 2

Tem de se escolher com base nos primeiros terminais possíveis que Nt1 e Nt2

podem gerar E se Nt1 ou Nt2 podem gerar ?

Tem de se escolher com base em 1 e 2



Compiladores

João M. P. Cardoso


Analisador sintáctico descendente

A recursividade à esquerda pode levar a ciclos infinitos!

Exemplo de produção: Term Term*Num

Passos potenciais na análise:

Term

Num*Term

Term

Term

Num*Term

Term

Num*


Analisador sintáctico descendente

A recursividade à esquerda pode levar a ciclos infinitos!

Solução: modificar gramática de modo a eliminar recursividade à esquerda


Eliminar recursividade à esquerda

Começar com produções da forma A A A Sequências , de símbolos

terminais e não-terminais que não começam com A

Repetição da aplicação: A A

forma a árvore sintáctica seguinte:

A

A

A


Eliminar recursividade à esquerda

Produções de substituição A A A R R é um novo símbolo não-terminal A R R R

A

A

A

R

R

R

Árvore inicial

Nova Árvore


Gramática do Exemplo

INT = [0-9]+

Start Expr



Expr Term



Term INT


{ +, -, *, /, INT }



Pedaço da gramática original



Term INT

Pedaço da gramática modificada

Term INT Term’



Term’



Start Expr

Expr Term Expr’

Expr’ “+” Term Expr’

Expr’ “-” Term Expr’

Expr’ Term INT Term’



Term’

INT = [0-9]+

INT = [0-9]+

Start Expr



Expr Term



Term INT


Comparando as Árvores Sintácticas

Term

INT*

Term

INT*

INT

Term

INT Term’

INT* Term’

INT* Term’

Gramática original Gramática modificada


Eliminar Recursividade à esquerda

Necessária na análise sintáctica preditiva

Modifica o algoritmo de procura no espaço de produçõesElimina recursividade directa infinita Contudo: gramática modificada é

menos intuitiva Requer mais transformações para se

atingir AST desejada


Requer +transformações para se alcançar AST desejada

Árvore Sintáctica para: 2*3*4

Construir AST durante a derivação!

Term

INT2

Term’

INT3

* Term’

INT4

* Term’

Term

INT3

*

Term

INT4

*

INT2

Árvore Sintáctica ConcretaAST desejada


Sumário

Analisador sintáctico descendente Utilizar Lookahead para evitar Backtracking Modificar gramática para evitar

necessidade de inspecção de tokens muito à frente (lookahead): factorização

Modificar gramática para evitar ciclos infinitos

Como implementar o analisador sintáctico descendente?



Compiladores

João M. P. Cardoso



Pedaço da gramática original



Term INT

Pedaço da gramática modificada

Term INT Term’



Term’


Analisador Sintáctico Construído Manualmente Um procedimento por símbolo não-terminal Esse procedimento examina o símbolo

corrente de entrada Chama recursivamente procedimentos para

RHS da produção escolhida Os procedimentos retornam verdadeiro se a

análise sintáctica foi bem sucedida e retornam falso em caso contrário


Exemplo

Procedimento para o símbolo não-terminal Term:

Term() {if (token == INT) {

token = NextToken(); return TermPrime();

} else return false;}

Produções para o símbolo não-terminal Term:

Term INT Term’

A função NextToken() avança um token na sequência de tokens gerada pela análise lexical e retorna o token nessa posição.


Exemplo

Procedimento para o símbolo não-terminal Term’:

TermPrime() {if((token == ‘*’) || (token == ‘/’)) {

token = NextToken();if (token == INT) {

token = NextToken(); return TermPrime();

} else return false;} else return true;

}


Exemplo

Pseudo-código para a parte do programa responsável pela análise sintáctica:

...

token = NextToken();

Term();

...


Construção da Árvore Sintáctica

Cada procedimento retorna a secção da árvore sintáctica para a parte da String que analisou

Utilizar excepções para tornar clara a estrutura do código (outra forma será utilizar uma função de erro)

Em geral, podemos ajustar o algoritmo de análise sintáctica para satisfazer objectivos diferentes Tipicamente, produz AST em vez de árvore

sintáctica concreta


Construção da Árvore Sintáctica para o exemplo

Com geração de excepções:Term() {

if (token == INT) {oldToken = token; token = NextToken();node = TermPrime();if (node == NULL) return oldToken; else return new TermNode(oldToken, node);

} else throw SyntaxError;}



Com geração de excepções:

TermPrime() {if ((token == ‘*’) || (token == ‘/’)) {

first = token; next = NextToken();if (next == INT) {

token = NextToken(); return new TermPrimeNode(first, next, TermPrime());

} else throw SyntaxError;} else return NULL;

}



Sem geração de excepçõesTerm() {

if (token == INT) {oldToken = token; token = NextToken();node = TermPrime();if (node == NULL) return oldToken; else return new TermNode(oldToken, node);

} else error();}TermPrime() {

if ((token == ‘*’) || (token == ‘/’)) {first = token; next = NextToken();if (next == INT) {

token = NextToken(); return new TermPrimeNode(first, next, TermPrime());

} else error();} else return NULL;

}


Árvore Sintáctica para 2*3*4

Term

INT2

Term’

INT3

* Term’

INT4

* Term’

Term

INT3

*

Term

INT4

*

INT2

Árvore Sintáctica Concreta

AST desejada



Compiladores

João M. P. Cardoso


Geração Directa da AST

TermPrime constrói uma árvore incompletaFalta leftmost childRetorna a raiz e o nó

incompleto (root, incomplete) =

TermPrime()Chamada com token: *Tokens que faltam: 3 * 4

Term

INT3

*

Term

INT4

*

root

incomplete

Falta parte esquerda que será construída pelo

procedimento de chamada


Código para Term

Term() {

if (token == INT) {

leftmostInt = token;


(root, incomplete) = TermPrime();

if (root == NULL) return leftmostInt;

incomplete.leftChild = leftmostInt;

return root;

} else throw SyntaxError;

}

INT2

token

2*3*4

Entrada


Código para Term

INT2

token

2*3*4

EntradaTerm() {

if (token == INT) {






return root;


}


Código para Term

INT2

leftmostInt

2*3*4

EntradaTerm() {

if (token == INT) {






return root;


}


Código para Term

Term

INT3

*

Term

INT4

*

INT2

root

incomplete

leftmostInt

2*3*4

EntradaTerm() {

if (token == INT) {






return root;


}


Código para TermPrime

TermPrime() {if((token == ‘*’) || (token == ‘/’)) {

op = token; next = NextToken();if (next == INT) {

token = NextToken();(root, incomplete) = TermPrime();if (root == NULL) {

root = new ExprNode(NULL, op, next);return(root, root);

} else { newChild = new ExprNode(NULL, op, next);incomplete.leftChild = newChild;return(root, newChild);

}} else throw SyntaxError;

} else return(NULL,NULL);}

Filho da esquerda a ser colocado pelo procedimento de

chamada


Sumário

Analisador sintáctico descendente (Top-Down Parser)

Utilizar Lookahead para evitar Backtracking

O parser é um conjunto de procedimentos mutuamente recursivos


Terminologia Muitas técnicas de análise sintáctica

diferentesCada uma pode manusear algum

conjunto de CFGs (gramáticas independentes do contexto)

Categorização das técnicas

( )


Terminologia

Muitas técnicas de análise sintáctica diferentesCada uma pode manusear algum conjunto de

CFGs (gramáticas independentes do contexto)Categorização das técnicas

L – análise da esq. para a drt.R - análise da drt. para a esq.

( )


Terminologia

Muitas técnicas de análise sintáctica diferentesCada uma pode manusear algum conjunto

de CFGs (gramáticas independentes do contexto)


L – derivação pela esquerdaR – derivação pela direita

( )


Terminologia

Muitas técnicas de análise sintáctica diferentesCada uma pode manusear algum conjunto

de CFGs (gramáticas independentes do contexto)


Número de lookahead

( )


Terminologia

Muitas técnicas de análise sintáctica diferentesCada uma pode manusear algum conjunto de

CFGs (gramáticas independentes do contexto)Categorização das técnicas

Exemplos: LL(0), LR(1)Até agora: LL(1)Nas próximas aulas

• Análises LR(k)

( )L L k


Terminologia

LL(k)Descendente (top-down), preditivaConstrói derivação pela esquerda (leftmost) de

cima para baixo LR(k)

Ascendente (bottom-up), shift-reduceConstrói derivação pela direita (rightmost) de

baixo para cima



Compiladores

João M. P. Cardoso


Analisador Sintáctico Ascendente

Mecanismo CentralAutómato Pushdown, que implementaParser Shift-reduce


Autómato Push-Down

Constituído por Pilha Pushdown (pode conter terminais e não-

terminais) Controlo por um autómato de estados finitos

Pode realizar uma de três acções: Shift:

• Desloca símbolo corrente da entrada para a pilha Reduce:

• Se o(s) símbolo(s) no topo da pilha “casa(m)” RHS de alguma das produções da gramática

• Pop (retirar) esses símbolos da pilha• Push não-terminal do LHS para a pilha

Aceita a entrada como pertencendo à linguagem


* ( + num )numnum

Expr Expr Op Expr

Expr (Expr)

Expr - Expr

Expr num

Op +

Op -

Op *

Pilha

String de entrada

Exemplo: Parser Shift-Reduce


* ( + num )numnum

Expr Expr Op Expr

Expr (Expr)

Expr - Expr

Expr num

Op +

Op -

Op *



SH

IFT

* ( + num )numnum

Expr Expr Op Expr

Expr (Expr)

Expr - Expr

Expr num

Op +

Op -

Op *



SH

IFT

* ( + num )num

num

Expr Expr Op Expr

Expr (Expr)

Expr - Expr

Expr num

Op +

Op -

Op *



* ( + num )num

num

Expr Expr Op Expr

Expr (Expr)

Expr - Expr

Expr num

Op +

Op -

Op *

RE

DU

CE



* ( + num )num

num

Expr Expr Op Expr

Expr (Expr)

Expr - Expr

Expr num

Op +

Op -

Op *

RE

DU

CE

Expr



* ( + num )num

num

Expr Expr Op Expr

Expr (Expr)

Expr - Expr

Expr num

Op +

Op -

Op *Expr

SH

IFT



( + num )num

num

Expr Expr Op Expr

Expr (Expr)

Expr - Expr

Expr num

Op +

Op -

Op *Expr

SH

IFT

*



( + num )num

num

Expr Expr Op Expr

Expr (Expr)

Expr - Expr

Expr num

Op +

Op -

Op *Expr

Op

RE

DU

CE

*



( + num )num

num

Expr Expr Op Expr

Expr (Expr)

Expr - Expr

Expr num

Op +

Op -

Op *Expr

Op

*SH

IFT



+ num )num

num

Expr Expr Op Expr

Expr (Expr)

Expr - Expr

Expr num

Op +

Op -

Op *Expr

Op

*SH

IFT

(



+ num )

num

Expr Expr Op Expr

Expr (Expr)

Expr - Expr

Expr num

Op +

Op -

Op *Expr

Op

*SH

IFT

(

num



+ num )

num

Expr Expr Op Expr

Expr (Expr)

Expr - Expr

Expr num

Op +

Op -

Op *Expr

Op

*SH

IFT

(

num

RE

DU

CE

Expr



+ num )

num

Expr Expr Op Expr

Expr (Expr)

Expr - Expr

Expr num

Op +

Op -

Op *Expr

Op

*SH

IFT

(

num

Expr



num )

num

Expr Expr Op Expr

Expr (Expr)

Expr - Expr

Expr num

Op +

Op -

Op *Expr

Op

*SH

IFT

(

num

Expr

+



num )

num

Expr Expr Op Expr

Expr (Expr)

Expr - Expr

Expr num

Op +

Op -

Op *Expr

Op

*SH

IFT

(

num

Expr

Op

RE

DU

CE

+



num )

num

Expr Expr Op Expr

Expr (Expr)

Expr - Expr

Expr num

Op +

Op -

Op *Expr

Op

*SH

IFT

(

num

Expr

Op

+



)

num

Expr Expr Op Expr

Expr (Expr)

Expr - Expr

Expr num

Op +

Op -

Op *Expr

Op

*SH

IFT

(

num

Expr

num

Op

+



)

num

Expr Expr Op Expr

Expr (Expr)

Expr - Expr

Expr num

Op +

Op -

Op *Expr

Op

*SH

IFT

(

num

Expr

Op

+

Expr

RE

DU

CE

num



)

num

Expr Expr Op Expr

Expr (Expr)

Expr - Expr

Expr num

Op +

Op -

Op *Expr

Op

*SH

IFT

(

num +

RE

DU

CE

num

Expr

Expr

Op

ExprExpr



)

num

Expr Expr Op Expr

Expr (Expr)

Expr - Expr

Expr num

Op +

Op -

Op *Expr

Op

*SH

IFT

(

num

Expr

Op

+

Expr

num

Expr



num

Expr Expr Op Expr

Expr (Expr)

Expr - Expr

Expr num

Op +

Op -

Op *Expr

Op

*SH

IFT

(

num

Expr

Op

+

Expr

num

Expr

)



RE

DU

CE

num

Expr Expr Op Expr

Expr (Expr)

Expr - Expr

Expr num

Op +

Op -

Op *Expr

Op

*

(

num

Expr

Op

+

Expr

num

Expr

)Expr



RE

DU

CE

num

Expr Expr Op Expr

Expr (Expr)

Expr - Expr

Expr num

Op +

Op -

Op *Expr

Op

*

(

num

Expr

Op

+

Expr

num

Expr

)Expr

Expr



AC

CE

PT

!

num

Expr Expr Op Expr

Expr (Expr)

Expr - Expr

Expr num

Op +

Op -

Op *Expr

Op

*

(

num

Expr

Op

+

Expr

num

Expr

)Expr

Expr



Conflitos que podem Ocorrer

Conflito Reduce/Reduce O topo da pilha pode “casar” com RHS de

produções múltiplas Qual a produção a utilizar na redução?

Conflito Shift/Reduce Pilha pode “casar” com RHS da produção Mas esse pode não ser o “casamento”

correcto Pode ser necessário deslocar a entrada e

encontrar mais tarde uma redução diferente


Expr Expr Op Expr

Expr (Expr)

Expr - Expr

Expr num

Op +

Op -

Op *

Conflitos

Gramática Original Nova Gramática

Expr Expr Op Expr

Expr Expr - Expr

Expr (Expr)

Expr Expr - Expr num

Op +

Op -

Op *


- numnum

ConflitosExpr Expr Op Expr

Expr Expr - Expr

Expr (Expr)

Expr Expr -

Expr num

Op +

Op -

Op *


- numnum

SH

IFT


Expr Expr - Expr

Expr (Expr)

Expr Expr -

Expr num

Op +

Op -

Op *


- num

SH

IFT

num


Expr Expr - Expr

Expr (Expr)

Expr Expr -

Expr num

Op +

Op -

Op *


- num

SH

IFT

Expr

RE

DU

CE

num


Expr Expr - Expr

Expr (Expr)

Expr Expr -

Expr num

Op +

Op -

Op *


- num

SH

IFT

Expr

num


Expr Expr - Expr

Expr (Expr)

Expr Expr -

Expr num

Op +

Op -

Op *


num

SH

IFT

Expr

num

-


Expr Expr - Expr

Expr (Expr)

Expr Expr -

Expr num

Op +

Op -

Op *


num

Expr

num

-

Opções:Reduce

Reduce

Shift

Conflito shift/reduce/reduceExpr Expr Op Expr

Expr Expr - Expr

Expr (Expr)

Expr Expr -

Expr num

Op +

Op -

Op *


num

Expr

num

-

RE

DU

CE


Expr Expr - Expr

Expr (Expr)

Expr Expr -

Expr num

Op +

Op -

Op *

O que acontece ao escolher-se: Reduce


num

Expr

num -

SH

IFT

Expr


Expr Expr - Expr

Expr (Expr)

Expr Expr -

Expr num

Op +

Op -

Op *



Expr

num -

SH

IFT

Expr

num


Expr Expr - Expr

Expr (Expr)

Expr Expr -

Expr num

Op +

Op -

Op *



Expr

num -

Expr Expr Op Expr

Expr Expr - Expr

Expr (Expr)

Expr Expr -

Expr num

Op +

Op -

Op *


RE

DU

CE

Expr

Expr

num

Conflito shift/reduce/reduce


Expr

num -

FA

ILS

!

Expr

Expr

num

Expr Expr Op Expr

Expr Expr - Expr

Expr (Expr)

Expr Expr -

Expr num

Op +

Op -

Op *




num

Expr

num

-

Qualquer uma destas opções resulta:Reduce

Shift


Expr Expr - Expr

Expr (Expr)

Expr Expr -

Expr num

Op +

Op -

Op *


num

Expr

num

-

O que acontece ao escolher-se:Reduce


Expr Expr - Expr

Expr (Expr)

Expr Expr -

Expr num

Op +

Op -

Op *


num

Expr

num

Op

-

RE

DU

CE



Expr Expr Op Expr

Expr Expr - Expr

Expr (Expr)

Expr Expr -

Expr num

Op +

Op -

Op *


Expr

num

Op

-

SH

IFT

num


Expr Expr Op Expr

Expr Expr - Expr

Expr (Expr)

Expr Expr -

Expr num

Op +

Op -

Op *



Expr

num

Op

-

RE

DU

CE

Expr

num


Expr Expr Op Expr

Expr Expr - Expr

Expr (Expr)

Expr Expr -

Expr num

Op +

Op -

Op *



Expr

num

Op

-

RE

DU

CE

Expr

num

Expr



Expr Expr Op Expr

Expr Expr - Expr

Expr (Expr)

Expr Expr -

Expr num

Op +

Op -

Op *


Expr

num

Op

-

AC

CE

PT

Expr

num

Expr



Expr Expr Op Expr

Expr Expr - Expr

Expr (Expr)

Expr Expr -

Expr num

Op +

Op -

Op *


num

Expr

num

-

SH

IFT

Conflitos

O que acontece ao escolher-se:Shift

Expr Expr Op Expr

Expr Expr - Expr

Expr (Expr)

Expr Expr -

Expr num

Op +

Op -

Op *


Expr

num

-

SH

IFT

num


Expr Expr Op Expr

Expr Expr - Expr

Expr (Expr)

Expr Expr -

Expr num

Op +

Op -

Op *

Conflitos


Expr

num

-

RE

DU

CE

Expr

num

Conflitos


Expr Expr Op Expr

Expr Expr - Expr

Expr (Expr)

Expr Expr -

Expr num

Op +

Op -

Op *


Expr

num -

RE

DU

CE

Expr

num

Expr

Conflitos


Expr Expr Op Expr

Expr Expr - Expr

Expr (Expr)

Expr Expr -

Expr num

Op +

Op -

Op *


Expr

num -

AC

CE

PT

Expr

num

Expr

Conflitos


Expr Expr Op Expr

Expr Expr - Expr

Expr (Expr)

Expr Expr -

Expr num

Op +

Op -

Op *


num

Expr

num

-

Este conflito Shift/Reduce reflecte ambiguidade na gramática

Conflito Shift/Reduce/Reduce

Expr Expr Op Expr

Expr Expr - Expr

Expr (Expr)

Expr Expr -

Expr num

Op +

Op -

Op *


num

Expr

num

-

Eliminar alterando a gramática


Este conflito Shift/Reduce reflecte ambiguidade na gramática

Expr Expr Op Expr

Expr Expr - Expr

Expr (Expr)

Expr Expr -

Expr num

Op +

Op -

Op *



num

Expr

num

-

Expr Expr Op Expr

Expr Expr - Expr

Expr (Expr)

Expr Expr -

Expr num

Op +

Op -

Op *

Este conflito Shift/Reduce pode ser eliminado com Lookahead de um símbolo



Compiladores

João M. P. Cardoso


Construção de um Parser

Vamos construir sem lookahead Decisões chave

Shift ou Reduce Qual a produção a reduzir?

Ideia básica Construir um DFA para controlar acções de shift

e de reduce O mesmo que, converter gramática por

autómato de pilha (pushdown automaton) Codificar controlo de estados finitos numa

tabela de parse


Estados do Parser

Sequência de Tokens na entrada ($ para sinalizar o fim da entrada)

Estado corrente do autómato de estados finitos

Duas PilhasPilha de Estados (implementa autómato

de estados finitos)Pilha de Símbolos (terminais da entrada

e não-terminais das reduções)


Integração de controlo dos estados finitos

Acções Coloca símbolos e estados na pilha Reduzir de acordo com uma dada produção Aceitar Erro

Acção seleccionada é uma função de Símbolo corrente na entrada Estado corrente do controlo de estados finitos

Cada acção especifica o próximo estado Implementar o controlo utilizando a

tabela do parser


Implementa controlo dos estados finitos Em cada estado, ver

Tabela[topo da pilha de estados][símbolo na entrada] Em seguida, realizar acção

Tabela do Parser

ACTION GotoState ( ) $ Xs0 shift to s2 error error goto s1s1 error error accept s2 shift to s2 shift to s5 error goto s3s3 error shift to s4 error s4 reduce (2) reduce (2) reduce (2) s5 reduce (3) reduce (3) reduce (3)


Exemplo de Tabela do Parser

S X $ (1)

X (X) (2)

X ( ) (3)

GramáticaEntradaPilha de Estados

Pilha de Símbolos

(())

Xs0



Shift para sn Coloca o token na entrada na pilha de

símbolos Coloca sn na pilha de estados Avança para o próximo símbolo na entrada

Tabela do Parser



Reduce (n) Retira itens das duas pilhas quantas vezes quantos os símbolos no RHS da

regra n Coloca LHS da regra n na pilha de símbolos Ver

• Tabela[topo da pilha de estados][topo da pilha de símbolos] Coloca esse estado (na parte goto da tabela) na pilha de estados

Tabela do Parser



Aceitar Parar a análise e reportar sucesso

Erro Parar a análise e reportar erro

Tabela do Parser



S X $(1)

X (X) (2)

X ( ) (3)

(())$

s0

Tabela do Parser em acção


Pilha de Símbolos



S X $(1)

X (X) (2)

X ( ) (3)

(())$

s0



Pilha de Símbolos



S X $(1)

X (X) (2)

X ( ) (3)

())$

s0 (s2



Pilha de Símbolos



S X $(1)

X (X) (2)

X ( ) (3)

))$

s0 (s2 (s2



Pilha de Símbolos



S X $(1)

X (X) (2)

X ( ) (3)

)$

s0 (s2 (s2

s5

)



Pilha de Símbolos



)$

s0 (s2 (s2

s5

)

S X $(1)

X (X) (2)

X ( ) (3)



Pilha de Símbolos



)$

s0 (s2 (s2

s5

)

S X $(1)

X (X) (2)

X ( ) (3)

Passo 1: pop das pilhas


Pilha de Símbolos



S X $(1)

X (X) (2)

X ( ) (3)

)$

s0 (s2

Passo 1: pop das pilhas


Pilha de Símbolos



S X $(1)

X (X) (2)

X ( ) (3)

)$

s0 (s2

Passo 2: push não-terminal


Pilha de Símbolos



S X $(1)

X (X) (2)

X ( ) (3)

)$

s0 (s2 X



Pilha de Símbolos



S X $(1)

X (X) (2)

X ( ) (3)

)$

s0 (s2 X

Passo 3: usar Goto, push novo estado


Pilha de Símbolos



S X $(1)

X (X) (2)

X ( ) (3)

)$

s0 (s2 Xs3



Pilha de Símbolos



S X $(1)

X (X) (2)

X ( ) (3)s0 (s2 Xs3

s4

)



Pilha de Símbolos

$



S X $(1)

X (X) (2)

X ( ) (3)

$

s0 (s2 Xs3

s4

)



Pilha de Símbolos



S X $(1)

X (X) (2)

X ( ) (3)s0 (s2 Xs3

s4

)

Passo 1: pop pilhas


Pilha de Símbolos

$



S X $(1)

X (X) (2)

X ( ) (3)s0

Passo 1: pop pilhas


Pilha de Símbolos

$



S X $(1)

X (X) (2)

X ( ) (3)s0



Pilha de Símbolos

$



S X $(1)

X (X) (2)

X ( ) (3)s0 X



Pilha de Símbolos

$



S X $(1)

X (X) (2)

X ( ) (3)s0 Xs1



Pilha de Símbolos

$



S X $(1)

X (X) (2)

X ( ) (3)s0 Ss1

Aceitar a String!


Pilha de Símbolos

$




Compiladores

João M. P. Cardoso


Construção do Parser

Sintetizar um DFA Captura todos os estados possíveis em que o

parser pode estar Transições de estados para terminais e não-

terminais Utilizar o DFA para criar a tabela sintáctica


Exemplo

Gramática

S X $ (1)

X (X) (2)

X ( ) (3)

X ( X )

Aqui? Ou aqui?Ou aqui?

Ou aqui?

Estados do DFA baseados nos itens Temos de capturar o que foi já percorrido numa

produção


Exemplo

Gramática

S X $ (1)

X (X) (2)

X ( ) (3)

X ( X )


produção

Produção X (X) gera 4 itens:X • (X )X ( • X ) X (X • )X (X ) •


Exemplo

Gramática

S X $ (1)

X (X) (2)

X ( ) (3)


produção

Itens para todas as produções da Gramática:S • X $

S X • $

X • (X)

X ( • X )

X (X • )

X (X) •

X • ( )

X ( • )

X ( ) •


Ideia por trás dos itens

Estados correspondem a conjuntos de itens Se um estado contém um item: A • c

O parser espera uma eventual redução utilizando a produção: A c

O parser já analisou Espera que a entrada possa conter c, seguido de

Se um estado contém um item: A • O parser já analisou Reduzirá utilizando: A

Se um estado contém um item: S • $ e a entrada está vazia O parser aceita a entrada


Relação entre itens e acções

Se o estado corrente contém o item: A • c e o símbolo corrente na entrada é c O parser desloca c para a pilha de símbolos O próximo estado conterá A c •

Se o estado corrente contém o item: A • Reduzirá utilizando: A

Se o estado corrente contém o item: S • $ e a entrada está vazia O parser aceita a entrada


Closure() de um conjunto de itens

Closure (fechamento) encontra todos os itens no mesmo estado

Algoritmo de ponto-fixo para Closure(I) Cada item em I é também um item em

Closure(I) Se A • B está em Closure(I) e B •

é um item, então adicionar B • a Closure(I)

Repetir até que não haja adição de novos itens a Closure(I)


Closure({X ( • X )}) Itens

S • X $

S X • $

X • (X)

X ( • X )

X (X • )

X (X) •

X • ( )

X ( • )

X ( ) •

X ( • X) X • (X)X • ( )

Exemplos de Closure()

S • X $

X • (X)

X • ( )

Closure({S • X $})


Goto() de um conjunto de itens

Goto encontra o novo estado depois de ter consumido um símbolo da gramática no presente estado

Algoritmo para Goto(I, X) em que I é um conjunto de itens e X um símbolo terminal ou não-terminal da gramática

Goto(I, X) = Closure({ A X • | A • X em I })

dá-nos o novo conjunto obtido pelo movimento do ponto sobre X


Goto({X ( • X)}, X)

X (X • )

ItensS • X $

S X • $

X • (X)

X ( • X )

X (X • )

X (X) •

X • ( )

X ( • )

X ( ) •

Exemplos de Goto()

Goto ({X •(X)}, ()

X ( • X) X • (X)X • ( )


Começar com o item: S • $ Caso não exista adicionar a primeira produção com término

$ Criar o primeiro estado como sendo Closure({ Goal • S

$}) Escolher um estado I

Para cada item A • X em I• determinar Goto(I, X)• se Goto(I, X) não está no estado, criar um

novo estado• Adicionar um laço X do estado I ao estado

Goto(I, X) Repetir até que não haja mais modificações

possíveis

Construir os estados do DFA


Construir o Parser Construir o DFA

DFA para a gramática:

Construir a tabela do parser utilizando o DFA

S • X$X • (X)X • ( )

s0S X • $

s1X

X ( • X)X ( • )X • (X)X • ( )

s2

(X (X • )

X

s3

(

X ( ) •

)s5

X (X) •

)s4


Criação da tabela sintáctica

Para cada estado Transição para outro estado utilizando um

símbolo terminal é um deslocamento para esse estado (shift to sn)

Transição para outro estado utilizando um símbolo não-terminal é um goto para esse estado (goto sn)

Se existir um item A • no estado fazer uma redução com essa produção para todos os terminais (reduce k)

Se existir um item S X • $ no estado então colocar acção de aceitação para o terminal $



S • X$X • (X)X • ( )

s0S X • $

s1X

X ( • X)X ( • )X • (X)X • ( )

s2

(X (X • )

X

s3

(

X ( ) •

)s5

X (X) •

)s4

Criação da tabela sintáctica


Problemas que podem ocorrer

Nenhum lookahead Vulnerável a conflitos desnecessários

• Conflitos Shift/Reduce (pode reduzir demasiado cedo em alguns casos)

• Conflitos Reduce/Reduce Solução: Lookahead

Apenas para reduções – reduzir apenas quando o próximo símbolo pode ocorrer depois de não-terminal da produção

Lookahead sistemático, divisão de estados baseada no próximo símbolo, acção é sempre uma função do próximo símbolo

Pode ser generalizado para ver à frente múltiplos símbolos



Compiladores

João M. P. Cardoso


Definições: Conjuntos First() e Follow()

Conjunto First() Conjunto de símbolos terminais situados mais

à esquerda em todas as possíveis árvores de derivação de

T First( ) se T pode aparecer como primeiro símbolo numa derivação começando em

Começar pelo conceito de NT derivando :• NT implica que NT deriva • NT NT1 ... NTn e se todos os NTi (1i

n) derivam implica que NT deriva

Notação

T é terminal,

NT é não-terminal,

S é terminal ou não-terminal,

e α e representam sequências de terminais e/ou não terminais


Definições: Regras para First()

1) TFirst(T)

2) First(S) First(S )

3) NT deriva implica:

First() First(NT )

4) NT S implica:

First(S ) First(NT)

Notação

T é terminal,

NT é não-terminal,

S é terminal ou não-terminal,

e α e representam sequências de terminais e/ou não terminais


Definições: Exemplo First()

First(Term’)?

Gramática

Term’ * INT Term’

Term’ / INT Term’

Term’

Solução

First(Term’) = {*,/}

First(* INT Term’) = {*}

First(/ INT Term’) = {/}

First(*) = {*}

First(/) = {/}


Definições: Conjunto First()

Se duas ou mais produções diferentes para o mesmo símbolo não-terminal têm conjuntos First com símbolos terminais comuns então: A gramática não pode ser analisada com um

parser preditivo LL(1) sem retrocesso• Exemplo:• S X $• X a• X a b

• First(X a) = { a }• First(X a b) = { a }• Qual a produção a escolher quando perante o

símbolo terminal a?


Definições: Conjunto Follow()

Para o símbolo não-terminal A, Follow(A) é o conjunto dos primeiros terminais que podem vir depois de A em alguma derivação

Regras para Follow() $ Follow(S), em que S é o símbolo início Se A B é uma produção então

First() Follow(B) Se A B é uma produção então

Follow(A) Follow(B) Se A B é uma produção e deriva então

Follow(A) Follow(B)


Definições: Algoritmo para Follow()

for all nonterminals NT

Follow(NT) = {}

Follow(S) = {$}

while Follow sets keep changing

for all productions A BFollow(B) = Follow(B) First()

if ( derives ) Follow(B) = Follow(B)Follow(A)

for all productions A B

Follow(B) = Follow(B)Follow(A)


Definições: Exemplo Follow()

Gramáticas exemplo: S X $

X aX a b

• Follow(S) = { $ }• Follow(X) = { $ }

S X $X “(“ X “)”X

• Follow(S) = { $ }• Follow(X) = { “)”, $ }


Parser com Lookahead apenas nas reduções

Designa-se por parser Simple LR: SLR(1) ou simplesmente SLR

Se um estado contiver: A • Reduzir de A apenas se o próximo

símbolo na entrada pode seguir (follow) A em alguma derivação

Gramática exemplo:S X $ (1)X a (2)X a b (3)


Parser sem Lookahead: LR(0)

S • X $X • aX • a b

S X • $

X a • X a • b

X a b •

ACTION GotoState a b $ Xs0 shift to s1 error error goto s3s1 reduce(2) S/R Conflict reduce(2) s2 reduce(3) reduce(3) reduce(3)s3 error error accept

s0s3

s1

s2X

ab

reduce(2)

ou

shift to s2


Tabela sintáctica com apenas lookahead nas reduções

Para cada estado Transição para outro estado utilizando um símbolo

terminal é um deslocamento para esse estado (shift to sn) (como anteriormente)

Transição para outro estado utilizando um símbolo não-terminal é um goto para esse estado (goto sn) (como anteriormente)

Se existir um item: X • no estado, fazer uma redução com essa produção sempre que o símbolo corrente (T) na entrada possa seguir (follow) X em alguma derivação

Elimina acções de redução inúteis


ACTION GotoState a b $ Xs0 shift to s1 error error goto s3s1 reduce(2) shift s2/r(2) reduce(2) s2 reduce(3)s3 error error accept

Nova tabela sintáctica

•Reduce(2) implica redução com a regra: X a •Como Follow(X) = {$}

b nunca segue X nas derivações: resolver conflito shift/reduce com shift


S • X $X • aX • a b

S X • $

X a • X a • b

X a b •

ACTION GotoState a b $ Xs0 shift to s1 error error goto s3s1 shift to s2 reduce(2) s2 reduce(3)s3 error error accept

s0

s3

s1

s2X

ab

b nunca segue X nas derivações: resolver conflito shift/reduce com shift

Nova tabela sintáctica

bFollow(X)aFollow(X)


Lookahead mais genérico

Itens contêm informação lookahead potencial, resultando em mais estados no controlo de estados finitos Item da forma: [A • X c] diz

• Próximo símbolo na entrada é c• Parser já consumiu , espera analisar X , e

depois reduzir utilizando: A • X Em adição ao estado corrente na tabela sintáctica,

todas as acções do parser são função dos símbolos de lookahead


Sumário

Geradores de Parsers – dada uma gramática, produz um parser

Técnica de análise sintáctica ascendente Construir automaticamente um autómato de

pilha (pushdown automata) Obter um parser shift-reduce

• Controlo de estados finitos + pilha• Implementação baseada em tabela

Conflitos: Shift/Reduce, Reduce/Reduce Uso de lookahead para eliminar conflitos

Parser SLR(1) (elimina acções de redução inúteis)

Parser LR(k) (uso de lookahead genérico)


Ideia básica para LR(1)

Dividir estados em LR(0) DFA baseado em lookahead

Acção de reduzir é baseada no item e no lookahead


Itens LR(1)

Itens mantêm informação em relação a: Produção Posição right-hand-side (o ponto) Símbolo lookahead

Item LR(1) é da forma [A • T] A é uma produção O ponto em A • denota a posição T é um símbolo terminal ou o marcador de término

($) Item [A • T] significa

O parser já analisou Se analisa e o próximo símbolo é T então o parser

deve reduzir com A


GramáticaS X $X (X)X

Símbolos terminais ‘(‘ ‘)’

Marcador de término ‘$’

Itens LR(1)[S • X $ ) ][S • X $ ( ][S • X $ $ ][S X • $ ) ][S X • $ ( ][S X • $ $][X • (X) ) ][X • (X) ( ][X • (X) $ ][X ( • X) ) ][X ( • X) ( ]

[X ( • X) $ ][X (X • ) ][X (X • ) ( ][X (X • ) $ ][X (X) • ) ][X (X) • ( ][X (X) • $ ][X • ) ][X • ( ][X • $ ]

Itens LR(1): exemplo


Criação do parser LR(1)

É necessário definir funções Closure() e Goto() para itens LR(1)

Necessário algoritmo para criar DFA Necessário algoritmo para criar a tabela

do parser


Closure para LR(1)

Closure(I)repeat

for all items [A • X c] in Ifor any production X

for any d First( c)

I = I { [X • d] }until I does not changereturn I


Goto para LR(1)

Goto(I, X)

J = { }

for any item [A • X c] in I

J = J {[A X • c]}

return Closure(J)


Construção do DFA LR(1)

Começar com o item: [Start • S $ ?] ? É irrelevante porque nunca deslocaremos $

Determinar o fechamento (closure) do item e formar o estado

Seleccionar um estado I for each item [A • X c] in I

• find Goto(I, X)• if Goto(I, X) is not already a state, make one• Add an edge X from state I to Goto(I, X)

state Repetir até que não haja mais adições


Criação da tabela do parser

Para cada estado no DFA LR(1) Transição para outro estado usando um símbolo

terminal é um deslocamento para esse estado (shift to sn)

Transição para outro estado usando um símbolo não-terminal é um goto para esse estado (goto sn)

Se existir um item [A • a] num estado,reduzir para o símbolo de entrada a com a produção A (reduce k)


Parser Look-Ahead LR(1) ou LALR(1)

Motivação Parser LR(1) tem um número elevado de

estados Método simples para eliminar estados

Se dois estados LR(1) são idênticos excepto no símbolo lookahead dos itens então juntar estados

Resultado é um DFA LALR(1) Tipicamente tem muito menos estados do que

LR(1) Pode ter mais conflitos reduce/reduce


Classificação de Gramáticas

Dada uma determinada gramática, determinar se pode ter como analisador:LL(0), LL(1), LL(2), ..., LL(k)?LR(0), LR(1), LR(2), ..., LR(k)?SLR(1)?


Classificar uma gramática como LL(1)

Como verificar se uma gramática é LL(1)? Se a tabela sintáctica não tiver mais do que uma

produção em cada célula Tabela sintáctica do analisador preditivo

Uma linha por cada não-terminal Uma coluna por cada Terminal Colocar produção X na linha X, coluna T, para

cada T First() Se pode derivar então colocar produção X

na linha X, coluna T, para cada T Follow(X)



Colocar produção X na linha X, coluna T, para cada T First()

Se pode derivar então colocar produção X na linha X, coluna T, para cada T Follow(X)

Gramática:

Z “d”

Z X Y Z

Y Y “c”

X Y

X “a” Não-terminais

Terminais“d” “c” “a”

Z

Y

X



Gramática:

Z “d”

Z X Y Z

Y Y “c”

X Y

X “a”Não-

terminaisTerminais

“d” “c” “a”

Z Z X Y ZZ “d”

Z X Y Z Z X Y Z

Y Y Y Y “c”

Y

X X Y X Y X YX “a”

Como verificar se uma gramática é LL(1)? Se a tabela sintáctica não tiver mais do

que uma produção em cada célula A gramática não é LL(1)



Uma gramática diz-se: LR(0) se existir uma tabela sintáctica LR(0)

sem conflitos (reduce/reduce, ou shift/reduce)

SLR(1) se existir uma tabela sintáctica SLR(1) sem conflitos (reduce/reduce, ou shift/reduce)

LR(k) se existir uma tabela sintáctica LR(k) sem conflitos (reduce/reduce, ou shift/reduce)

LL(k) se puder ser analisada por um analisador sintáctico preditivo com lookahead=k

…



G0regular

LR(0)SLR(1)

LALR(1)LR(1)LR(k)

unambiguousContext free

G1 G2 G3 G4 G5 G6 G7

LL(0)

LL(1)

LL(k)


Geradores de Parsers

Geram C, http://dinosaur.compilertools.net/ Lex & Yacc flex e bison

Geram Java: JLex e CUPhttp://www.cs.princeton.edu/~appel/modern/java/JLex/http://www.cs.princeton.edu/~appel/modern/java/CUP/ JavaCC: http://www.experimentalstuff.com/Technologies/JavaCC/

index.html Lista com mais geradores de parsers

http://catalog.compilertools.net/lexparse.html http://catalog.compilertools.net/java.html


Análise Semântica e Representação Intermédia

Compiladores

João M. P. Cardoso


Localização actual nas etapas de compilação



Token Stream

Parse Tree

Program (character stream)

Semantic AnalyzerIntermediate Code Generator

Intermediate Representation + Symbol Table


O que é a semântica de um programa?

Sintaxe Como o programa é constituídoRepresentação textual ou estrutura

SemânticaQual é o significado do programa?


Qual o motivo da análise semântica?

Certifica-se de que o programa está de acordo com as definições da linguagem de programação

Reportar, sempre que haja erros semânticos, mensagens de erro que sejam úteis para o utilizador

Não é preciso muito trabalho adicional se for incorporada durante a criação da representação intermédia


Erros na Análise Semântica

boolean sum(int A[], int N) { Int i, sum; For(i=0; i<N; i++) { sum1 = sum + A[i]; } return sum;}...Int s = sum(A);

Falta um argumento

Não foi atribuído valor inicial a sum

Tipo da variável devolvida não confere com a declaração do cabeçalho da função

Variável não declarada

Inconsistência entre tipos no RHS e LHS


Objectivo das representações intermédias do programa

Permitir análises e transformaçõesOptimizações

Estruturar tradução para código máquinaSequência de passos

Árvore Sintáctica

RepresentaçãoIntermédiade nível alto

RepresentaçãoIntermédia denível baixo

CódigoMáquina

Análise Semântica

Intermediate Representation (IR)


Representação Intermédia de Nível Alto

Preserva o fluxo de controlo estruturado Útil para optimizações ao nível do ciclo

Desenrolamento de ciclos, Fusão de ciclos, etc.

Preserva estrutura ao nível dos objectos Útil para optimizações em programas

orientados por objectos


Representação Intermédia de Nível Baixo

Passa do modelo de dados abstracto para o espaço planar de endereçamento

Elimina o fluxo de controlo estruturado

Útil para tarefas de compilação de nível baixoAfectação de registosSelecção de instruções


Alternativas

Há muitas alternativas possíveis Árvores de instruções e de expressões Grafos direccionados acíclicos (DAGs) Código de 3 endereços (C3E) E muitas outras...

Mais ou menos especificas à própria linguagem

Estas lições apresentam uma possibilidade de árvores de instruções e de expressões (mais tarde falaremos também de código de 3 endereços)


Tarefas de Compilação

Determina formato das estruturas na memória Determinar formato de arrays e de objectos na memória Determinar formato da pilha de chamadas na memória

Gerar código para ler valores

• parâmetros, elementos de arrays, campos de objectos para avaliar expressões e computar valores novos para escrever valores para estruturas de controlo

Enumera funções e cria a tabela de funções Invocação de funções acede à entrada correspondente

na tabela de funções Gera código para funções

variáveis locais, e acesso a parâmetros Invocações de funções


Tabelas de símbolos (symbol tables)

Conceito chave na compilação enquanto a declaração de tipos, variáveis e

funções são processadas vamos atribuir significados a esses identificadores utilizando tabelas de símbolos

Compiladores utilizam tabelas de símbolos para produzirem Layout das estruturas na memória Tabelas de funções Código para aceder a campos, variáveis

locais, parâmetros, etc.


Tabelas de Símbolos

Durante a tradução de árvores sintácticas para representação intermédia Tabelas de símbolos mapeiam identificadores

(strings) em descritores (informação acerca dos identificadores)

Operação básica: Lookup• Dada uma string, encontrar o seu descritor• Implementação típica: Hash Table (contentor

associativo) Exemplo

Dado o nome de uma variável, encontrar descritor• Descritor local, descritor de parâmetro, descritor

global


Exemplo

void add(int x, int[] v, int N) {

int i;

i = 0;

while (i < N) {

v[i] = v[i]+x;

i = i+1;

}

}

x

i

Função add

vN

descritor para parâmetro xdescritor para parâmetro vdescritor para parâmetro N

descritor para variável local i


Exemplo


int i;

i = 0;

while (i < N) {

v[i] = v[i]+x;

i = i+1;

}

}

x

i

Função add

Código da função

vN



descritor para retorno


Exemplo


int i;

i = 0;

while (i < N) {

v[i] = v[i]+x;

i = i+1;

}

}

x

i

add

Código da função v

N



descritor para retorno


Hierarquia em tabelas de símbolos

Alcance/Escopo (scope) O mesmo nome para uma variável pode ter

significados diferentes em locais diferentes É necessária uma tabela de símbolos por

cada escopo A hierarquia deriva de

Encadeamento de escopos Hierarquia na tabela de símbolos reflecte esta

hierarquia Lookup atravessa de modo ascendente a

hierarquia até que o descritor seja encontrado


Lookup i num exemplo

i descritor para a variável local i

x descritor para parâmetro x

v descritor para a variável global v

TS para as variáveis globais

TS para os parâmetros da função

TS para as variáveis locais da função


Lookup I num exemplo

v[i] = v[i]+x;

1º vai procurar na TS das variáveis locais e só se não encontrar é que sobe na hierarquia das TS i descritor para a variável local i

x descritor para parâmetro x

v descritor para a variável global v



Compiladores

João M. P. Cardoso


Descritores

O que contêm? Informação utilizada para geração de

código e análise semânticaDescritores locais - nome, tipo, offset

na pilhaDescritores de funções

• assinatura (tipo do valor retornado, e parâmetros)

• Referência à tabela de símbolos local• Referência ao código para a função


Parâmetros, Local, e Descritores de Tipos

Parâmetros, Local referem a descritores de tipoDescritor de tipo base: int, boolean,

etc.Descritor de tipo de array, que contém

referência ao descritor de tipo para os elementos do array

Descritor de estrutura, etc.


Exemplo: Tabela de Símbolos para Tipos

boolean Descritor de boolean

int Descritor de intint [] Descritor de array

boolean [] Descritor de arrayvector [] Descritor de array Descritor de

estrutura para vector


Descritores de funções

Contêm referência para o código da função

Contêm referência para a tabela de símbolos local (para as variáveis locais da função)

Na hierarquia de tabelas de símbolos, a TS para os parâmetros é mãe da TS para as variáveis locais


Descritor de função para add

v

iDescritor de variável local

TS de variáveis locais

x

TS para parâmetros

Descritor de parâmetro

Código para a função add

Descritor de função para add

N Descritor de parâmetro

Descritor de parâmetro


O que é uma árvore sintáctica?

Árvore sintáctica guarda resultados da análise sintáctica

Nós externos são terminais/tokens Nós internos são não-terminais


Árvores abstractas versus concretas

Relembrar modificações à gramática Factorização à esquerda, eliminação de

ambiguidade, precedências dos operadores Modificações levam a uma árvore que não

reflecte uma interpretação do programa intuitiva e clara

Pode ser mais conveniente trabalhar com a AST (pode ser vista como a árvore sintáctica representativa da gramática sem as modificações modificações)


Construções alternativas para Representações Intermédias

Construir a árvore sintáctica concreta, traduzir para AST, traduzir para representação intermédia

Construir a árvore sintáctica abstracta, traduzir para representação intermédia

Incluir a construção da representação intermédia durante a análise sintáctica Elimina a construção intermédia da árvore

sintáctica – melhora performance do compilador

Menos código a escrever


Tabela de Símbolos

Dada uma árvore sintáctica (abstracta ou concreta)Atravessar recursivamente a árvoreConstruir a tabela de símbolos

enquanto a travessia da árvore decorre


Escopos aninhados

Várias formas de aninhamento TS das funções aninhadas na TS dos

globais TS de locais aninhada dentro da TS da

função Aninhamento resolve ambiguidade em

possíveis conflitos Mesmo nome utilizado para uma variável

global e uma variável local Nome refere uma variável local dentro da

função


Escopos aninhados de código

TS podem ter profundidade arbitrária com base no aninhamento do código:boolean x; int foo(int x) {

double x = 5.0;{ float x = 10.0;

{ int x = 1; ... x ...} ... x ...

}... x ...

}

Nota: Conflitos de nomes com aninhamento podem reflectir erros no programa. Os compiladores geram mensagens de aviso em presença de conflitos deste tipo.


Representação de código em nível alto

Ideia básica Movimento em direcção à linguagem

assembly Preservar a estrutura de nível alto

• Formato de objectos• Fluxo de controlo estruturado• Distinção entre parâmetros, variáveis locais, e

campos Abstracção de nível alto da linguagem

assembly• Nós load e store• Acesso a armazenamento local abstracto,

parâmetros e campos, e não posições de memória directamente


Representação de expressões

Árvores de expressões representam as expressões Nós internos – operações como: +, -, etc. Folhas – Nós Load representam acesso a variáveis

Nós Load ldl para acesso a variáveis locais – descritor de

locais ldp para acessos a parâmetros – descritor de

parâmetros lda para acesso a arrays

• Árvore da expressão para o valor• Árvore de expressão para o índice

Para acesso a atributos de uma classe ou campos de estruturas...


Exemplo

x e y são variáveis locais

x*x + y*y +

ldl

Descritor de local para xNa tabela de símbolos locais

*

ldl ldl

*

ldl

Descritor de local para xNa tabela de símbolos locais


Exemplov é uma array passado como argumento da

função add

i é uma variável local

x é um argumento da função

v[i]+x lda

+

ldp

Descritor local para I na tabela de símbolos locais da função add

ldlldp

Descritor de parâmetro para v na tabela de símbolos de parâmetros da função add

Descritor de parâmetro para x na tabela de símbolos de parâmetros da função add


Representação de enunciados de atribuição

Nós Storestl para stores em variáveis locais

• Descritor local• Árvore da expressão para o valor a guardar

sta para stores em elementos de arrays• Árvore da expressão para o array• Árvore da expressão para o índice• Árvore da expressão para o valor a guardar

Para stores em atributos de classes ou campos de estruturas...


v[i]=v[i]+x;

lda

+

ldp

Descritor do parâmetro para v na tabela de símbolos dos parâmetros da função add

Descritor local para I na tabela de símbolos locais da função add

Descritor do parâmetro para x na tabela de símbolos dos parâmetros da função add

ldl

sta

ldlldp

ldp

Exemplo


Orientação

Representações intermédias Movimento em direcção à linguagem

máquina Suporte para análises do programa e acções

de transformação IR (intermediate representation) de nível

alto Preserva estruturas de objectos e de arrays Tabelas de símbolos Descritores



Compiladores

João M. P. Cardoso


Representação do fluxo de controlo

Nós de enunciadosNó if

• Árvore de expressão para a condição• Nó para o corpo do then e nó para o corpo

do elseNó while

• Árvore de expressão para a condição• Nó para o corpo

Nó return • Árvore de expressão para o

valor/expressão de retorno


Exemplo

while (i < N)

v[i] = v[i]+x;

Descritor de locais para i

ldl

Descritor de parâmetros para v

Descritor de parâmetros para x

while

<

ldp lda

+

ldp

ldl

sta

ldl

ldp

ldp


Exemplo

while (i < N)

v[i] = v[i]+x;

Ldl i

while

<

Ldp v lda

+

Ldp x

Ldl i

sta

Ldl i

Ldp v

Ldp v

Notação abreviada


Das árvores sintácticas até à IR

Atravessar recursivamente a árvore sintáctica

Construir representação de modo ascendente (Bottom-Up) Ver identificador da variável na tabela de

símbolos Construir nós Load para aceder a variáveis Construir expressões a partir dos nós de

Load e dos nós de operações Construir nós Store para enunciados de

atribuição Colocar nós while, if, return para as

construções de controlo


Sumário

Representação Intermédia de alto nível Objectivo: representar o programa de um

modo intuitivo para suporte de futuras tarefas de compilação

Representação dos dados do programa Tabelas de Símbolos Organização hierárquica

Representação da computação Árvores de expressões Vários tipos de nós store e load Fluxo de controlo estruturado


Análise semântica: Erros

Assumimos a inexistência de problemas durante a construção da IR

Contudo, é necessário fazer muitas verificações durante a tradução

Chamadas de Análise Semântica Realização da análise semântica ao nível

da árvore sintáctica Para que os erros sejam informativos/claros

é necessário que os nós da árvore sejam anotados com as posições no programa


Objectivo da análise semântica

Assegurar que o programa obedece a um conjunto de verificações de sanidade Todas as variáveis usadas foram definidas Tipos são usados correctamente Chamadas a funções têm o número correcto

e tipos de parâmetros e do valor retornado Verificação aquando da construção da IR


Descritores para identificadores

Quando se constrói o descritor de uma variável local, parâmetro, etc. temos Nome do tipo Nome da variável

O que é a verificação? Verificar se o nome do tipo identifica um tipo válido lookup nome na tabela de símbolos dos

tipos Se não estiver lá, falha na análise semântica


Tabela de símbolos local

Quando se constrói a tabela de símbolos local temos uma lista de descritores locais

Fazer a verificação a quê? Nomes de variáveis em duplicado

Quando se faz a verificação? Quando se insere o descritor na tabela de

símbolos local Similar para os parâmetros, para a TS

global, etc.


Verificação para loads, stores, etc.

O que tem o compilador? Nome da variável. O que faz? Lookup nome da variável:

Se estiver na tabela de símbolos local, referencia descritor local

Se estiver na tabela de símbolos dos parâmetros, referencia descritor do parâmetro

Se estiver na tabela de símbolos global, referencia descritor global

Se não for encontrado um descritor: erro semântico (a variável não foi declarada...)


Verificação para a Instrução de Load para arrays

O que tem o compilador?Nome da variávelExpressão de indexação no array

O que faz?Lookup nome da variável (se não

estiver: erro semântico)Verifica tipo da expressão (se não for

inteiro: erro semântico)


Operação de adição

O que tem o compilador? 2 expressões

O que pode estar errado? Expressões têm o tipo errado Têm de ser os dois inteiros (por exemplo)

Por isso o compilador faz a verificação do tipo das expressões Instruções load guardam o tipo da variável acedida Operações guardam o tipo da expressão produzida Assim, é apenas necessário verificar tipos, e caso

falhe dá erro semântico


Inferência de tipos para operações de adição

Algumas linguagens deixam adicionar floats, ints, doubles

Quais são os problemas? Tipo do resultado da operação Conversão dos operandos da operação

Regras standard podem ser usualmente aplicadas Se adição de um int e de um float

• converter o int para float, adicionar os floats, e o resultado é um float.

Se adição de um float e de um double• converter o float para double, adicionar os

doubles, e o resultado é um double.


Regras para a adição

Princípio básico: Hierarquia de tipos de números (int, depois float, depois double)

Todas as conversões forçadas são feitas de modo ascendente na hierarquia Ex: int para float; float para double;

Resultado tem o tipo do operando no nível mais elevado da hierarquia int + float é float, int + double é double, float + double é double


Inferência de tipos

Inferir tipos sem declaração explicita de tipos

A adição é um caso muito restrito de inferência de tipos

Tópico importante em investigação recente de linguagens de programação Quantas declarações de tipos se podem

omitir? Ligado ao polimorfismo


Instrução Store

O que tem o compilador? Nome da variávelexpressão

O que faz? Lookup nome da variável (se não

estiver: erro semântico)Verifica tipo da variável com o tipo da

expressão• Se o tipo da variável não for compatível

com o tipo da expressão, erro semântico


Instrução Store para arrays O que tem o compilador?

Nome da variável, expressão de indexação expressão

O que faz? Lookup nome da variável (se não estiver:

erro semântico) Verifica se o tipo da expressão de indexação

é inteiro Verifica tipo da variável em relação ao tipo

da expressão• Se o tipo da variável não for compatível com o

tipo da expressão: erro semântico


Invocação de funções

O que tem o compilador?Nome da função, parâmetros

Verificações:Nome da função é identificado na tabela

de funções do programaTipos dos parâmetros “casam” com tipos

dos parâmetros da declaração da função


Sumário de verificações semânticas

Realizar a verificação semântica durante a construção do IR

Muitas verificações são para certificar que se constrói uma IR correcta

Outras verificações correspondem a verificações simples de sanidade

Cada linguagem de programação tem uma lista que deve ser verificada

Pode reportar muitos erros potenciais durante a compilação



Compiladores

João M. P. Cardoso


Conversão para a IR de nível baixo

Converte fluxo de controlo estruturado em fluxo de controlo baseado em saltos (não estruturado) Saltos condicionais e incondicionais

Converte modelo de memória estruturado em modelo de memória planar Endereçamento planar para variáveis Endereçamento planar para Arrays

Continua independente da linguagem máquina, mas: Movimento para muito próximo da máquina; para um

modelo standard da máquina (espaço de endereçamento planar, saltos)


Representação do Programa

Control Flow Graph (CFG): grafo de fluxo de controlo Nós do CFG são nós de instruções

• stl, sta, cbr, ldl, lda, ldp são nós de instruções• +, <, ... são nós de expressões

Laços no CFG representam o fluxo de controlo

Forks em instruções de salto condicional• Representam dois ou mais caminhos possíveis

Merges quando o controlo pode alcançar um ponto por caminhos múltiplos

Um nó de entrada (entry) e um nó de saída (exit)


ldl i

<

lda

+

ldp x

ldl i

sta

ldl i

ldp v

ldp v

ldp N

cbr

entry

exit

while (i < N) v[i] = v[i]+x;

Laços de fluxo de controlo

Laços entre Instruções e expressões

Exemplo: CFG


if (x < y) { a = 0;} else { a = 1;}

entry

ldl x ldl y

<

cbr

stl a 0 stl a 1

exit

Exemplo: CFG


Modelo de Memória da Máquina Alvo

Uma memória planar Composta por palavras Endereçável ao byte

Nós modelam instruções Load e Store ld addr,offset – resultado é

o conteúdo de memória no local: addr+offset

st addr, offset, valor – escreve valor no local: addr+offset

Substituir nós: lda e ldl por nós ld

Substituir nós: sta e stl por nós st

Stack

Código

Heap Arrays

locais(alguns parâmetros)


ld 4 ld 8 ld 8ld 4

* *

++

ldl

Descritor local para x (4)

*

ldl ldl

*

ldl

Descritor local para y (8)

Exemplo:

spsp spsp

ld address offset MEM[address+offset] No caso de offset=4 relativo ao sp

(MEM[$sp+offset]):

x*x+y*y

ld 4

sp


Parâmetros

Muitas máquinas têm convenções nas chamadas Primeiro parâmetro no registo 5, segundo

parâmetro no registo 6, ... ver $a0, $a1, … do MIPS

As convenções variam com a máquina Vamos assumir que cada parâmetro é uma

palavra Vamos endereçar os parâmetros pelo

número ldp <número do parâmetro>


Acesso a elementos de um Array

Assumir que a variável aponta para o primeiro elemento do array

Elementos do array em posições contíguas Qual é o endereço: v[5]?

v é um array de inteiros: assumir inteiros de 4 bytes

(endereço em v) + (5*4) Determinar endereço

Base do Array + (index * element size)


Exemplo: v[5]+x

lda

+

ldp

Descritor de parâmetro v (2)

Descritor de parâmetro de x (1)

5ldp ldp 2 *

5 4

+

ld 0

+

ldp 1

Conversão de nós lda para nós ld Determinar endereço

Base + (index * element size) ld do endereço Offset de ld é 0


Variáveis Locais

Assumir que são alocadas na pilha de chamadasEndereçamento realizado usando

offsets a partir do apontador da pilha Relembrar:

pilha cresce para baixo e por isso os offsets são positivos

Símbolo especial sp contém apontador para a pilha


Acções na invocação de funções (relembrar)

Invocadora Definir parâmetros de acordo com a convenção de

invocações Definir endereço de retorno utilizando a convenção de

invocações Saltar para a função invocada

Invocada Alocar stack frame = deslocar para baixo o apontador

da pilha (sp) computar Definir o valor de retorno de acordo com a convenção

de invocações Libertar stack frame = deslocar para cima o apontador

da pilha (sp) Retornar para a função invocadora


Gestão da Pilha (relembrar)

Determinar tamanho da stack frame Alocar quando se entra na função Libertar imediatamente antes do retorno da função Guarda todas as variáveis locais Mais espaço para parâmetros (quando estes ultrapassam

em número o número de registos convencionados como argumentos de funções)

Assume que todas as variáveis locais e os parâmetros têm o comprimento de uma palavra

Determinar offsets das variáveis locais e dos parâmetros Computar offsets das variáveis locais e dos parâmetros

Guardados nas tabelas de símbolos de locais e de parâmetros

Continua a usar nós ldp para aceder aos parâmetros


Eliminação de nós ldl

Uso de offsets na tabela de símbolos locais e sp Substituir nós ldl por nós ld Exemplo de offsets para locais e parâmetros

i descritor da variável local i (0)

Outras TS (variáveis globais, por exemplo)

TS de variáveis locais

x

TS de parâmetros

Descritor do parâmetro x (0)

Código para a função add

Descritor da função add

v Descritor do parâmetro v (1)

N Descritor do parâmetro N (2)


Exemplo: v[i]+x

lda

+

ldp

Descritor de parâmetro para v (1)

Descritor de parâmetro para x (0)

ldpldp 1 *

4

+

ld 0

+

ldp 0

Descritor de local para i (0)

ldl

sp

ld 0


Nós Enter e Exit para a função add

void add(int x, int[] v, int N) {int i; ...

} Qual o espaço na pilha para a função add?

4 bytes (espaço para i)• Assumindo palavras de 4 bytes• Assumindo parâmetros da função em registos

usados para passar argumentos Nós enter e exit são anotados com o valor

do espaço na pilha necessário para a função

enter 4

exit 4

....


ldp 1 *

4

+

ld 0

+

ldp 0

sp

ld 0

ldp 1 *

4

+

sp

ld 0

st 0

sp

ld 0

<

Exemplo

cbr

st 0

sp

ld 0+

1sp

st 0

sp 0

enter 4

exit 4

ldp 2


Sumário da IR de nível baixo

Acessos a arrays traduzidos para nós ld ou st Endereço é o endereço base do array

(apontador) + (index * element size) Acessos locais traduzidos para nós ld ou st

Endereço em sp, offset é o offset local Acesso a parâmetros traduzidos para:

Instruções lpd – especificar número de parâmetro

Nós Enter e Exit de uma função identificam tamanho da pilha utilizado


Sumário

Tradução de árvores sintácticas para IR de nível alto Preserva o fluxo de controlo estruturado Representação eficiente para análise de

nível alto e optimizações Tradução de IR de nível alto para IR de nível

baixo Espaço de endereçamento planar Remoção da estrutura do fluxo de controlo,

substituição por saltos condicionais Movimento em direcção à máquina alvo


Geração de Código Final

Compiladores

João M. P. Cardoso


Problema

Dada a representação intermédia de baixo nível como gerar o código assembly?

Não optimizado: Variáveis locais e parâmetros todos afectados a

posições relativas e distintas na pilha Optimizado:

Partilha de posições relativas da pilha por uma ou mais variáveis

Utilização de registos do banco de registos do uP para armazenar variáveis

...


Geração de código final

Code Generator

Código Assembly

Code Generator

Code Optimizer





Árvore sintáctica



Cadeia de Tokens




Y2=a*x*x+b*x+c;

Ldl x

*

+

+

ldl c

stl y2

Ldl x

*

Ldl a

Ldl x

*

Ldl b

IR de alto nível



Y2=a*x*x+b*x+c;

Variáveis: A B X C y2 Ldl x

*

+

+

ldl c

stl y2

Ldl x

*

Ldl a

Ldl x

*

Ldl b

IR de alto nível



Y2=a*x*x+b*x+c;

Variáveis (posição relativa a $sp)

A: 0 B: 4 X: 8 C: 12 Y2: 16 Ld 8

*

+

+

ld 12

st 16

Ld 8

*

Ld 0

Ld 8

*

Ld 4

IR de baixo nível

sp

sp

spsp

sp

sp sp



Y2=a*x*x+b*x+c;

Começar nas folhas:

lw $t0, 4($sp)

Ld 8

*

+

+

ld 12

st 16

Ld 8

*

Ld 0

Ld 8

*

Ld 4

IR de baixo nível

sp

sp

spsp

sp

sp sp

<$t0>



Y2=a*x*x+b*x+c;

lw $t0, 4($sp)

lw $t1, 8($sp)

Ld 8

*

+

+

ld 12

st 16

Ld 8

*

Ld 0

Ld 8

*

Ld 4

IR de baixo nível

sp

sp

spsp

sp

sp sp

<$t0><$t1>



Y2=a*x*x+b*x+c;

lw $t0, 4($sp)

lw $t1, 8($sp)

mult $t2, $t1, $t0

Ld 8

*

+

+

ld 12

st 16

Ld 8

*

Ld 0

Ld 8

*

Ld 4

IR de baixo nível

sp

sp

spsp

sp

sp sp

<$t2>

<$t0><$t1>



Y2=a*x*x+b*x+c;

lw $t0, 4($sp)

lw $t1, 8($sp)

mult $t2, $t1, $t0

lw $t3, 8($sp)

Ld 8

*

+

+

ld 12

st 16

Ld 8

*

Ld 0

Ld 8

*

Ld 4

IR de baixo nível

sp

sp

spsp

sp

sp sp

<$t2>

<$t3>



Y2=a*x*x+b*x+c;

lw $t0, 4($sp)

lw $t1, 8($sp)

mult $t2, $t1, $t0

lw $t3, 8($sp)

lw $t4, 8($sp)

Ld 8

*

+

+

ld 12

st 16

Ld 8

*

Ld 0

Ld 8

*

Ld 4

IR de baixo nível

sp

sp

spsp

sp

sp sp

<$t2>

<$t3> <$t4>



Y2=a*x*x+b*x+c;

lw $t0, 4($sp)

lw $t1, 8($sp)

mult $t2, $t1, $t0

lw $t3, 8($sp)

lw $t4, 8($sp)

mult $t5, $t3, $t4 Ld 8

*

+

+

ld 12

st 16

Ld 8

*

Ld 0

Ld 8

*

Ld 4

IR de baixo nível

sp

sp

spsp

sp

sp sp

<$t2>

<$t3> <$t4>

<$t5>



Y2=a*x*x+b*x+c;

lw $t0, 4($sp)lw $t1, 8($sp)mult $t2, $t1, $t0lw $t3, 8($sp)lw $t4, 8($sp)mult $t5, $t3, $t4lw $t6, 0($sp) Ld 8

*

+

+

ld 12

st 16

Ld 8

*

Ld 0

Ld 8

*

Ld 4

IR de baixo nível

sp

sp

spsp

sp

sp sp

<$t2><$t5>

<$t6>



Y2=a*x*x+b*x+c;

lw $t0, 4($sp)

lw $t1, 8($sp)

mult $t2, $t1, $t0

lw $t3, 8($sp)

lw $t4, 8($sp)

mult $t5, $t3, $t4

lw $t6, 0($sp)

mult $t7, $t5, $t6 Ld 8

*

+

+

ld 12

st 16

Ld 8

*

Ld 0

Ld 8

*

Ld 4

IR de baixo nível

sp

sp

spsp

sp

sp sp

<$t2><$t5>

<$t6>

<$t7>



Y2=a*x*x+b*x+c;

lw $t0, 4($sp)lw $t1, 8($sp)mult $t2, $t1, $t0lw $t3, 8($sp)lw $t4, 8($sp)mult $t5, $t3, $t4lw $t6, 0($sp)mult $t7, $t5, $t6Add $t8, $t7, $t2 Ld 8

*

+

+

ld 12

st 16

Ld 8

*

Ld 0

Ld 8

*

Ld 4

IR de baixo nível

sp

sp

spsp

sp

sp sp

<$t2>

<$t7>

<$t8>



Y2=a*x*x+b*x+c;

lw $t0, 4($sp)lw $t1, 8($sp)mult $t2, $t1, $t0lw $t3, 8($sp)lw $t4, 8($sp)mult $t5, $t3, $t4lw $t6, 0($sp)mult $t7, $t5, $t6Add $t8, $t7, $t2lw $t9, 12($sp) Ld 8

*

+

+

ld 12

st 16

Ld 8

*

Ld 0

Ld 8

*

Ld 4

IR de baixo nível

sp

sp

spsp

sp

sp sp

<$t8><$t9>



Y2=a*x*x+b*x+c;

lw $t0, 4($sp)lw $t1, 8($sp)mult $t2, $t1, $t0lw $t3, 8($sp)lw $t4, 8($sp)mult $t5, $t3, $t4lw $t6, 0($sp)mult $t7, $t5, $t6Add $t8, $t7, $t2lw $t9, 12($sp)Add $t10, $t8, $t9 Ld 8

*

+

+

ld 12

st 16

Ld 8

*

Ld 0

Ld 8

*

Ld 4

IR de baixo nível

sp

sp

spsp

sp

sp sp

<$t8><$t9>

<$t10>



Y2=a*x*x+b*x+c;

lw $t0, 4($sp)lw $t1, 8($sp)mult $t2, $t1, $t0lw $t3, 8($sp)lw $t4, 8($sp)mult $t5, $t3, $t4lw $t6, 0($sp)mult $t7, $t5, $t6Add $t8, $t7, $t2lw $t9, 12($sp)Add $t10, $t8, $t9Sw $t10, 16($sp)

Ld 8

*

+

+

ld 12

st 16

Ld 8

*

Ld 0

Ld 8

*

Ld 4

IR de baixo nível

sp

sp

spsp

sp

sp sp

<$t10>



Y2=a*x*x+b*x+c;

lw $t0, 4($sp)lw $t1, 8($sp)mult $t2, $t1, $t0lw $t3, 8($sp)lw $t4, 8($sp)mult $t5, $t3, $t4lw $t6, 0($sp)mult $t7, $t5, $t6add $t8, $t7, $t2lw $t9, 12($sp)add $t10, $t8, $t9sw $t10, 16($sp)

Ld 8

*

+

+

ld 12

st 16

Ld 8

*

Ld 0

Ld 8

*

Ld 4

IR de baixo nível

sp

sp

spsp

sp

sp sp

11 registos $t para armazenar valores intermédios!(MIPS tem 10 registos $t)



Y2=a*x*x+b*x+c;

Solução utilizando menos registos para armazenar resultados intermédios?

Ld 8

*

+

+

ld 12

st 16

Ld 8

*

Ld 0

Ld 8

*

Ld 4

IR de baixo nível

sp

sp

spsp

sp

sp sp



Y2=a*x*x+b*x+c;

lw $t0, 4($sp) lw $t1, 8($sp) mult $t?, $t1, $t0

Resultado pode ser armazenado em $t1 ou em $t0

Ld 8

*

+

+

ld 12

st 16

Ld 8

*

Ld 0

Ld 8

*

Ld 4

IR de baixo nível

sp

sp

spsp

sp

sp sp

<$t?>

<$t0><$t1>



Y2=a*x*x+b*x+c;

lw $t0, 4($sp) lw $t1, 8($sp) mult $t0, $t1, $t0 …

Ld 8

*

+

+

ld 12

st 16

Ld 8

*

Ld 0

Ld 8

*

Ld 4

IR de baixo nível

sp

sp

spsp

sp

sp sp

<$t0>

<$t0><$t1>



Y2=a*x*x+b*x+c;


Ld 8

*

+

+

ld 12

st 16

Ld 8

*

Ld 0

Ld 8

*

Ld 4

IR de baixo nível

sp

sp

spsp

sp

sp sp

<$t0><$t1>

<$t0>

<$t2><$t1>

<$t1><$t2>

<$t1>

<$t0><$t1>

<$t0>3 registos $t para armazenar valores intermédios


Não optimizado

Acessos à pilha requerem mais ciclos do que acessos a registos internos

Utilização da pilha para todas as variáveis requer mais instruções


Geração de código

Utilização de esqueletos (templates) para geração de código assembly paraEstruturas If-then ou if-then-else Loops



if (test)

true_body

else

false_body

<do the test>

boper …, lab_true

<false_body>

j lab_end

lab_true:

<true_body>

lab_end:



while (test)

body

lab_cont:<do the test>boper …, lab_bodyj lab_end

lab_body:<body>j lab_cont

lab_end:

• Esqueleto optimizado: lab_cont:<do the test>boper …, lab_end<body>j lab_cont

lab_end:


Linhas mestras para o gerador de código Descer o nível de abstracção devagar: Utilizar várias

etapas Mesmo que apenas se faça uma coisa por cada

etapa Mais fácil de depurar, mais fácil de lidar com o

problema Manter o nível de abstracção consistente

IR deve manter a semântica correcta sempre! Pode ser necessário realizar optimizações entre

etapas Utilizar assertions (assertividades) deliberadamente

Utilizar uma assertion para verificar um pressuposto Ajudam a encontrar bugs!


Linhas mestras para o gerador de código

Começar com geração simples, mesmo que naïfOk gerar: 0 + 1*x + 0*y

A biblioteca de runtime é nossa amiga!Não tentes gerar código assembly

quando existem rotinas na biblioteca com a mesma funcionalidade

Exemplo: malloc


Linhas mestras para o gerador de código Lembrar que as optimizações vêm depois

O optimizador realiza as optimizações Pensar o que o optimizador necessita e estruturar o

código de acordo com isso Exemplo: alocação de registos, simplificações

algébricas, propagação de constantes Utilizar uma boa infra-estrutura de teste

Teste regressivo• Se um programa cria um bug adicioná-lo ao teste suite

Utilizar makefiles: para executar o compilador sobre o teste suite e verificar automaticamente se os resultados estão correctos (pode implicar a utilização de um simulador da arquitectura)

Ver teste na Engenharia de Software


Optimizações

Compiladores

João M. P. Cardoso


Alocação de registos

Atribuir o maior número de variáveis a registos

Utilizar cada registo para armazenar o maior número possível de variáveis (registos são poucos...)Tempo de vida de variáveis

Uma das optimizações com maior impacto (tamanho do código e desempenho)


Tempo de Vida de Variáveis

Duração numa sequência de instruções entre a definição de uma variável e o seu uso

A = b*c;

D=b*b+e;

E=A+D;

Tempo de vida de A



Y2=a*x*x+b*x+c


$t0 $t1 $t2 $t3 $t4 $t5 $t6 $t7 $t8 $t9 $t10



Y2=a*x*x+b*x+c


$t0 $t1 $t2 $t3 $t4 $t5 $t6 $t7 $t8 $t9 $t10

3 registos


Y2=a*x*x+b*x+c

lw $t0, 4($sp) lw $t1, 8($sp) mult $t2, $t1, $t0 lw $t3, 8($sp) lw $t4, 8($sp) mult $t5, $t3, $t4 lw $t6, 0($sp) mult $t7, $t5, $t6 add $t8, $t7, $t2 lw $t9, 12($sp) add $t10, $t8, $t9 sw $t10, 16($sp)

Afectação de registos a variáveis

$t0$t1 $t2$t3 $t4$t5 $t6$t7 $t8$t9$t10


Y2=a*x*x+b*x+c

lw $t0, 4($sp) lw $t1, 8($sp) mult $t2, $t1, $t0 lw $t3, 8($sp) lw $t4, 8($sp) mult $t5, $t3, $t4 lw $t6, 0($sp) mult $t7, $t5, $t6 add $t8, $t7, $t2 lw $t9, 12($sp) add $t10, $t8, $t9 sw $t10, 16($sp)


$t0$t1 $t2$t3 $t4$t5 $t6$t7 $t8$t9$t10

4 registos



Determinar tempo de vida das variáveis

Afectar um registo a uma ou mais variáveis

Como?Por exemplo: Coloração de grafos

(problema NP-complexo)• Heurísticas: Algoritmo left-edge


Afectação de registos a variáveis Algoritmo Left-edge (utilizado no exemplo

em que se obteve 3 registos) Ordenar segmentos (intervalos) pelo valor

do tempo de início Começar pelo primeiro segmento e tentar

adicionar segmentos pela ordem sempre que não haja sobreposição

Quando não for possível adicionar mais segmentos, voltar ao passo anterior considerando o segmento seguinte

Número de registos = número de colunas com segmentos


Afectação de registos a variáveis Algoritmo Left-edge

LEFT_EDGE(I) {Sort elements of I in a list L in ascending order of li ;c = 0;while (some interval has not been colored ) do {

S = ;r = 0;while ( s L such that ls > r) do {∃ ∈

s = First element in the list L with ls > r ;S = S { s } ;∪r = rs ;Delete s from L;

}c = c +1;Label elements of S with color c;

}}


Afectação de registos a variáveis Coloração de grafos

Determinar tempo de vida das variáveis Construir grafo de interferências* (existe interferência

quando duas variáveis têm tempos de vida com sobreposição)

• Laços representam interferência• Nós representam variáveis

Determinar o número mínimo de cores do grafo (pode ser utilizado o algoritmo left-edge)

Cada cor corresponde a um registo (número de registos = número de cores)

* Também chamado de grafo de conflitos



Tempo de vida das variáveis


$t0 $t1 $t2 $t3 $t4 $t5 $t6 $t7 $t8 $t9 $t10



Grafo de interferências


$t0 $t1 $t2 $t3 $t4 $t5 $t6 $t7 $t8 $t9 $t10

$t0 $t1

$t2 $t3

$t4

$t5

$t6

$t7

$t8

$t9

$t10



Grafo de interferênciasInterferência

(laço) entre duas variáveis (nós) indica que não podem ser armazenadas no mesmo registo

v0 v1

v2 v3

v4

v5

v6

v7

v8

v9 v10



Grafo de interferências

Depois de colorido:Número de cores

indica o número de registos necessário

v0 v1

v2 v3

v4

v5

v6

v7

v8

v9 v10


Afectação de registos a variáveis: exercício

Considerando o código ao lado, determine o número de registos necessário para armazenar as variáveis utilizando o algoritmo left_edge (y2 é a única variável utilizada posteriormente)

T1=x*x;T2=a*t1;T3=b*x;T4=t3+c;T5=t4+t2;Y2=t5;



Na presença de estruturas condicionais Problema mais complicado Resolução similar


Optimizações

Existem muitas outras optimizações Loop unrolling (existe uma série de optimizações ao

nível de loops) propagação de constantes redução de força (strength reduction) avaliação de expressões com constantes eliminação de sub-expressões comuns, substituição por escalares (scalar replacement) eliminação de acessos a memória redundantes eliminação de código morto movimento de código


Fim!

Disponível para orientar alunos interessados em realizar projectos sobre estes temasNo ensino de certos tópicos:

utilizando, por exemplo, Java AppletsNa criação de infra-estruturas para

apoio à leccionaçãoEm tópicos avançados relacionados

com investigação

©universidade do algarve 1 introdução da disciplina compiladores joão m. p. cardoso universidade...

Documents