COMPORT – Compilador Portugol - Nilo Menezes

UNIVERSIDADE DO AMAZONAS
Instituto de Ciências Exatas
Departamento de Ciência da Computação
COMPORT – Compilador Portugol
Nilo Ney Coutinho Menezes
MANAUS – AM
SETEMBRO 2003
Comport – Compilador Portugol
I

Nilo Ney Coutinho Menezes
COMPORT – Compilador Portugol
Monografia apresentada à banca
examinadora da Universidade do
Amazonas, como exigência parcial para
obtenção do grau de Bacharel em
Processamento de Dados sob a orientação
do Professor Doutor Alberto Nogueira de
Castro Júnior.
MANAUS – AM
SETEMBRO 2003
II

Menezes, Nilo
Comport – Compilador Portugol
Acadêmico [Manaus] 2003.
125p, 29,7cm
Monografia de conclusão de curso – Universidade do Amazonas
Área de concentração: Compiladores
Orientador(a): Prof(a). Alberto Nogueira de Castro Júnior, PhD
1. Compiladores
2. Portugol
3. Linguagens de programação
III

À memória de José Ney Farias de Menezes, meu avô,
responsável pela minha introdução à computação.
IV

Aos meus pais pelo incentivo e suporte.
A minha esposa e filhos pela paciência e finais de semana perdidos.
V

“Quem quer fazer alguma coisa encontra um meio.
Quem não quer fazer nada encontra uma desculpa”
(provérbio árabe)
“Quando se busca o cume da montanha,
não se dá importância às pedras no caminho”
(provérbio oriental)
“As maiores distâncias que devemos percorrer estão dentro de nós mesmos”
(Charles de Gaulle)
VI

Comport – Compilador Portugol
Nilo Ney Coutinho Menezes
ESTA MONOGRAFIA FOI SUBMETIDA À COORDENAÇÃO DO CURSO DE
PROCESSAMENTO DE DADOS, COMO PARTE DOS REQUISITOS NECESSÁRIOS À OBTENÇÃO DO
TÍTULO DE BACHAREL EM PROCESSAMENTO DE DADOS, OUTORGADO PELA UNIVERSIDADE DO
AMAZONAS - UA E ENCONTRA-SE À DISPOSIÇÃO DOS INTERESSADOS NA BIBLIOTECA DA REFERIDA
UNIVERSIDADE.
A CITAÇÃO DE QUALQUER TRECHO DESTA MONOGRAFIA É PERMITIDA, DESDE
QUE FEITA DE ACORDO COM AS NORMAS DE ÉTICA CIENTÍFICA.
Banca Examinadora:
_______________________________
Prof. Alberto Nogueira de Castro Júnior, PhD
Universidade do Amazonas
_______________________________
Prof. Edjar de Souza Mota, PhD
Universidade do Amazonas
_______________________________
Prof. Ruiter Braga, MsC
Universidade do Amazonas
Julgado em: ____ / ____ / _______
MANAUS – AM
SETEMBRO 2003
VII

DECLARAÇÃO
Declaro que esta monografia foi desenvolvida por mim e, através deste instrumento,
concedo ao Departamento de Ciência da Computação da Universidade do Amazonas
(DCC/UA) o direito de utilizá-la, bem como aos produtos resultantes do trabalho nela
descrito (software, hardware, modelos, algoritmos, etc) nas suas atividades de ensino,
pesquisa e extensão.
_________________________________
Nilo Ney Coutinho Menezes
VIII

RESUMO
Comport – Compilador Portugol
Nilo Ney Coutinho Menezes
Setembro 2003
Comport – Compilador Portugol
Orientador: Prof. Alberto Nogueira de Castro Júnior, PhD
Este trabalho visa reunir informações sobre a construção de um compilador
da linguagem Portugol, com objetivo de servir como um estudo de caso para a disciplina de
Construção de Compiladores do curso de Ciência da Computação da Universidade do
Amazonas. A disponibilização de uma ferramenta para estudo e ensino de programação em
português pretende quebrar a barreira da língua inglesa, presente em praticamente todas
as linguagens de programação conhecidas. O trabalho inclui um estudo e especificação de
uma máquina RISC virtual que pode ser analisada e estendida durante cursos de
Organização de Computadores. Foi incluída uma pequena referência bibliográfica que pode
servir como base para o estudo das técnicas de compilação e geração de código.
9

ABSTRACT
Comport – Compilador Portugol
Nilo Ney Coutinho Menezes
Setembro 2001
ComPort – Compilador Portugol
Supervisor: Prof. Alberto Nogueira de Castro Júnior, PhD
The purpose of this paper is to collect information about the Portugol language
compiler construction and specification. The learning of the English language is a
very difficult problem to Brazilian students who want to learn their first programming
language as they are always written in English. This paper can be used in Compiler
Construction courses. The virtual RISC machine specification included can be used
in the Computers Organization course. It includes a little reference about compiling
and code generation.
10

SUMÁRIO
ComPort – Compilador Portugol
DECLARAÇÃO......................................................................................................... VIII
RESUMO.......................................................................................................................9
ABSTRACT.................................................................................................................10
SUMÁRIO....................................................................................................................11
LISTA DE TABELAS ..................................................................................................15
LISTA DE FIGURAS...................................................................................................16
INTRODUÇÃO ............................................................................................................17
1. A COMPILAÇÃO.................................................................................................18
1.1. Linguagem e Sintaxe ..................................................................................................18
1.1.1. Símbolos ...............................................................................................................19
1.1.2. Alfabeto, palavra e comprimento .........................................................................19
1.1.3. Gramática .............................................................................................................20
1.1.4. Autômatos Finitos ................................................................................................21
1.2. Compilador .................................................................................................................24
1.3. Análise Léxica e Analisador Léxico ..........................................................................25
1.3.1. Tokens, Padrões e Lexemas .................................................................................26
1.3.2. Expressões regulares.............................................................................................26
1.3.3. Tabela de Símbolos ..............................................................................................28
1.4. Análise Sintática .........................................................................................................28
11

ComPort – Compilador Portugol
1.4.1. Gramáticas livres de contexto...............................................................................28
1.5. Análise Semântica.......................................................................................................29
1.6. Geração de Código .....................................................................................................29
1.7. Otimização de Código ................................................................................................30
2. PORTUGOL.........................................................................................................31
2.1. Comentários ................................................................................................................31
2.2. Tipos básicos ...............................................................................................................31
2.2.1. Numérico ..............................................................................................................31
2.2.2. Literal ...................................................................................................................32
2.2.3. Lógico...................................................................................................................32
2.2.4. Vetores e matrizes ................................................................................................32
2.2.5. Registros ...............................................................................................................32
2.3. Variáveis e identificadores.........................................................................................33
2.4. Declaração de variáveis..............................................................................................33
2.5. Atribuição....................................................................................................................34
2.6. Operadores..................................................................................................................34
2.6.1. Operadores Aritméticos........................................................................................34
2.6.2. Operadores Lógicos..............................................................................................35
2.6.3. Operadores Relacionais ........................................................................................35
2.6.4. Operadores Literais ..............................................................................................35
2.7. Estrutura seqüencial ..................................................................................................36
2.8. Estruturas condicionais..............................................................................................36
2.9. Estruturas de repetição..............................................................................................37
2.10. Procedimentos e Funções .......................................................................................38
12

ComPort – Compilador Portugol
2.11. Módulos ...................................................................................................................39
2.12. Funções pré-definidas ............................................................................................39
2.13. Especificação BNF ..................................................................................................40
3. O COMPILADOR PORTUGOL ...........................................................................43
3.1. Analisador Léxico.......................................................................................................43
3.2. Analisador Sintático ...................................................................................................43
3.3. Gerador de Código .....................................................................................................43
3.4. Funções Adicionais .....................................................................................................43
4. A MÁQUINA VIRTUAL........................................................................................44
4.1. Registradores ..............................................................................................................44
4.2. Formato de Instruções ...............................................................................................45
4.3. Instruções ....................................................................................................................46
4.4. Limitações ...................................................................................................................48
4.5. Implementação............................................................................................................48
CONCLUSÃO .............................................................................................................49
REFERÊNCIA BIBLIOGRÁFICA ...............................................................................50
APÊNDICE A – CÓDIGO FONTE ..............................................................................51
SCANNER.H...........................................................................................................................51
SCANNER.CPP ......................................................................................................................55
PARSER.H ..............................................................................................................................65
13

ComPort – Compilador Portugol
PARSER.CPP .........................................................................................................................67
CODEGENERATOR.H.........................................................................................................84
CODEGENERATOR.CPP ....................................................................................................87
FUNCOES.H.........................................................................................................................100
FUNCOES.CPP ....................................................................................................................101
RISC.H ..................................................................................................................................103
RISC.CPP..............................................................................................................................104
INSTRUCOES.H ..................................................................................................................108
PRINCIPAL.CPP .................................................................................................................109
MAKEFILE ..........................................................................................................................110
APENDICE B – TABELA ASCII...............................................................................114
APENDICE C – OPCODES DA MÁQUINA VIRTUAL.............................................115
APENDICE D – EMENTAS DE CURSOS DE COMPILAÇÃO DE OUTRAS
UNIVERSIDADES.....................................................................................................118
ÍNDICE REMISSIVO .................................................................................................124
14

LISTA DE TABELAS
ComPort – Compilador Portugol
Tabela 1 - Função programa _________________________________________________ 22
Tabela 2 - Token x Lexema x Padrão___________________________________________ 26
Tabela 3 - Notação para as expressões regulares _________________________________ 27
Tabela 4 - Operadores aritméticos_____________________________________________ 34
Tabela 5 - Operadores lógicos ________________________________________________ 35
Tabela 6 - Operadores Relacionais ____________________________________________ 35
Tabela 7 - Operadores literais ________________________________________________ 35
Tabela 8 - Funções pré-definidas______________________________________________ 39
Tabela 9 – Instruções da Máquina Virtual_______________________________________ 47
15

LISTA DE FIGURAS
ComPort – Compilador Portugol
Figura 1 - Fita e unidade de controle ......................................................................................21
Figura 2 - Representação gráfica de um autômato..................................................................22
Figura 3 - Exemplo de autômato finito ....................................................................................23
Figura 4 - Diagrama de tradução ............................................................................................24
Figura 5 - Fases de um compilador .........................................................................................25
Figura 6 - O papel do analisador léxico ..................................................................................25
16

INTRODUÇÃO
ComPort – Compilador Portugol
A aprendizagem de uma linguagem de programação, normalmente
com símbolos e palavras-chave em inglês, por estudantes brasileiros que não
dominam o idioma é um obstáculo a mais no estudo da computação. Para resolver
este tipo de problema e garantir independência de conteúdo em relação à
linguagens comerciais ou não padronizadas, muitos autores criaram uma linguagem
aportuguesada, normalmente utilizada para descrever algoritmos, geralmente
chamada de Portugol.
No entanto, vários autores definiram o Portugol como uma forma
traduzida de Pascal ou de “Pascal sem ponto-e-vírgula em português”. Além disso,
a escassez ou inexistência de compiladores de Portugol faz com que a tradução
para uma outra linguagem de programação seja etapa necessária e obrigatória para
o teste da lógica num computador.
O objetivo deste trabalho é construir um compilador Portugol,
detalhando as fases de construção, mostrando opções e justificando escolhas. Não
só criando uma ferramenta de testes, mas também, material para estudo nas
disciplinas de Construção de Compiladores e Linguagens de Programação; e talvez
Sistemas Operacionais e Organização de Computadores.
O texto foi dividido em quatro capítulos. O primeiro capítulo trata da
definição dos termos básicos para o entendimento de todo o texto, desde a
definição de linguagem até as partes e fases de um compilador. O segundo capítulo
cobre a modelagem do Portugol, desta vez uma linguagem em português com
características próprias. O terceiro capítulo é a aplicação dos conceitos dos dois
primeiros, nele constrói-se o compilador Portugol propriamente dito. No quarto e
último capítulo define-se a máquina virtual, uma vez que o compilador gera
pseudocódigo, com objetivo de garantir portabilidade e transparência entre
plataformas e sistemas operacionais. O código fonte de todos os programas
desenvolvidos se encontram nos apêndices e tabelas importantes nos anexos.
Nilo Ney Coutinho Menezes
17

1. A COMPILAÇÃO
ComPort – Compilador Portugol
O entendimento do processo de compilação exige o conhecimento de
uma série de termos como linguagem, sintaxe, tokens e lexemas entre outros. O
objetivo deste capítulo é explicar estes termos, dando uma noção geral do que está
por vir, formando uma base comum de conhecimento.
1.1. LINGUAGEM E SINTAXE
Em WIRTH (1996), cada linguagem mostra uma estrutura chamada
gramática ou sintaxe. Por exemplo, uma sentença correta consiste de um sujeito
seguido por um predicado, onde correto significa bem formada. Este fato pode ser
descrito pela seguinte fórmula:
sentença = sujeito predicado.
Se adicionarmos a esta fórmula outras duas:
sujeito = “João” | “Maria”
predicado = “come” | “fala”
Então definiríamos conseqüentemente quatro possíveis sentenças:
João come
João fala
Maria come
Maria fala
Onde o símbolo “|” é pronunciado como “ou”. Estas fórmulas são
chamadas regras sintáticas, produções ou simplesmente equações sintáticas.
Sujeito e predicado são classes sintáticas. Uma notação simplificada omite
identificadores significativos:
S = AB.
A=”a”|”b”.
B=”c”|”d”.
L={ac,ad,bc,bd}
18

ComPort – Compilador Portugol
Ao conjunto L de sentenças que são geradas desta forma, ou seja, pela
substituição repetida de sentenças do lado esquerdo pelas do lado direito da
equação; é chamado linguagem.
Formulando os conceitos apresentados mais rigorosamente, uma
linguagem é definida pelo seguinte:
1. Um conjunto de símbolos terminais. São símbolos que ocorrem
em suas sentenças. São chamados terminais por não poderem
ser substituídos por nenhum outro símbolo. O processo de
substituição termina com símbolos terminais. No exemplo, este
conjunto consiste dos elementos a,b,c e d. Este conjunto
também é chamado de vocabulário.
2. Um conjunto de símbolos não-terminais. Estes denotam classes
sintáticas e podem ser substituídos. No exemplo, são os
elementos S, A e B.
3. Um conjunto de equações sintáticas. Estas definem as possíveis
substituições de símbolos não terminais. Uma equação é
especificada para cada símbolo não terminal.
4. Um símbolo inicial. É um símbolo não-terminal. No exemplo S.
Uma linguagem é um conjunto de seqüências de símbolos
terminais que, começando pelo símbolo inicial, podem ser gerados pela
aplicação repetitiva de equações sintáticas, ou seja, substituições.
1.1.1. Símbolos
Símbolos não possuem uma definição formal, são entidades abstratas
básicas, um conceito primitivo, como o ponto na Geometria.
Exemplos de símbolos são as letras do nosso alfabeto ou dígitos de um
número.
1.1.2. Alfabeto, palavra e comprimento
Um alfabeto é um conjunto finito de símbolos. Por exemplo, o alfabeto
da língua portuguesa é composto de letras de “A” até “Z”. No estudo de
19

ComPort – Compilador Portugol
compiladores podemos definir outros alfabetos para fins específicos. Por exemplo:
Σ={a,b} indica um alfabeto chamado Σ, com dois elementos (a e b). Utilizaremos o
símbolo Σ* para denotar todas as palavras que podem ser formadas por um alfabeto
Σ.
Entende-se por palavra uma seqüência ou cadeia de símbolos de um
alfabeto. A palavra vazia será representada por ε e utilizaremos Σ+ para denotar
todas as palavras de um alfabeto Σ, com exceção da palavra vazia. Logo, podemos
concluir que Σ+ = Σ* - { ε }. É bom lembrar que Σ = { } é um alfabeto válido, mesmo
sem possuir símbolos.
Exemplo:
Utilizando a nossa definição anterior de Σ={a,b}, teríamos Σ*={ε, a, b,
aa, bb, aaa, bbb, ...} e Σ+={a, b, aa, bb, aaa, bbb, ...}.
O comprimento de uma palavra é igual ao número de símbolos que ela
possui. Exemplo:
| a | = 1 lê-se o comprimento de “a” é 1.
| aaa | = 3 lê-se o comprimento de “aaa” é 3.
1.1.3. Gramática
Em MENEZES (2001), obtemos a definição formal de gramática:
“Uma gramática é uma quádrupla ordenada G = (V, T, P, S) onde:
V conjunto de símbolos variáveis ou não terminais;
T conjunto de símbolos terminais, disjunto de V;
P conjunto finitos de pares, denominados regras de produção;
S elemento de V denominado variável inicial.”
Na notação acima, a linguagem anterior poderia ser representada por:
G = ( { A, B, S}, { a, b, c, d }, P, S )
Onde P = { S � AB, A � a | b, B � c | d }
Desta forma podemos dizer que L é a linguagem gerada por G, ou seja,
L(G) ou simplesmente GERA(G).
Dizemos que duas gramáticas são equivalentes se e somente se as
linguagens por ela geradas forem iguais, ou seja, supondo G1 e G2 gramáticas, G1
e G2 são equivalentes se e somente se GERA(G1)=GERA(G2).
20

1.1.4. Autômatos Finitos
ComPort – Compilador Portugol
Segundo AHO (1995), um reconhecedor para uma linguagem é um
programa que toma como entrada uma cadeia x e responde “sim” se x for uma
sentença da linguagem e “não” caso contrário. Compilamos expressões regulares
(veja 1.3.2) num reconhecedor através da construção de um diagrama de transições
generalizado, chamado autômato finito.
Os autômatos finitos se classificam em determinísticos e nãodeterminísticos.
Um autômato finito determinístico pode ser visto como uma máquina
simples, composta de fita, unidade de controle e programa ou função.
A fita é finita (nos dois sentidos), sendo dividida em células de um símbolo
ou caractere. Esta fita não permite gravação e contém toda a informação de entrada.
Os símbolos pertencem ao alfabeto de entrada.
Figura 1 - Fita e unidade de controle
A unidade de controle possui um número finito e predefinido de estados.
Inicialmente a cabeça de leitura está posicionada no símbolo mais à esquerda da
fita. A cada símbolo lido, desloca-se a cabeça de leitura uma célula para a direita.
O programa é uma função parcial que dependendo do símbolo lido
determina o estado corrente do autômato. É importante notar que um autômato não
possui memória, devendo-se utilizar estados intermediários para armazenar
resultados.
Formalmente, podemos definir um autômato finito determinístico como
uma quíntupla:
M=(Σ,Q,δ,q0,F)
Onde:
Σ Alfabeto de símbolos de entrada
Q Conjunto de estados possíveis do autômato
21

δ Função programa ou de transição
q0 Estado inicial
F Conjunto de estados finais, tal que F ⊂ Q
ComPort – Compilador Portugol
O processamento de um autômato finito M, para uma palavra de entrada
w, consiste na sucessiva aplicação de δ para cada símbolo de w (da esquerda para
a direita), até ocorrer uma condição de parada.
Um autômato finito determinístico pode parar em três casos:
1. Quando o processamento da entrada leva a um estado finito e a
entrada é aceita.
2. Quando um símbolo de entrada possui uma saída indeterminada pela
função programa, neste caso a entrada é rejeitada.
3. Quando a fita acaba e o autômato está num estado não-final, a entrada
é rejeitada.
Um autômato finito sempre pára, uma vez que um novo símbolo de
entrada é lido a cada aplicação da função programa, não existindo a possibilidade
de loop infinito, dada a natureza finita da fita.
Figura 2 - Representação gráfica de um autômato
Um exemplo de autômato finito determinístico seria aquele responsável
por validar uma entrada que possua a seqüência ab, considerando-se Σ={a,b} como
alfabeto, Q={q0, q1,qf} como os possíveis estados e F={qf}.
Sendo δ a função programa abaixo:
Tabela 1 - Função programa
δ a b
q0 q1 q0
q1 q1 qf
Qf qf qf
Graficamente este autômato seria representado por:
22

Figura 3 - Exemplo de autômato finito
ComPort – Compilador Portugol
Supondo aabab como entrada, iniciaríamos no estado q0, lendo o “a”
mais à esquerda. Pela função programa da Tabela 1, teríamos trocado de estado
para q1 e leríamos o segundo “a”, permanecendo em q1. Ao lermos o “b”,
trocaríamos de estado para qf, onde permaneceremos, enquanto “a” ou “b” forem
lidos até o fim da fita. Como chegamos a um estado final no fim da fita, este
autômato diz que a seqüência é válida.
Em autômatos finitos não-determinísticos temos a mesma definição
formal, exceto em relação a função programa que pode gerar um conjunto de
estados para um símbolo de entrada.
Ao executar um autômato finito não-determinístico e obtermos um
conjunto de estados como resultado da função programa, “cria-se” uma linha de
execução independente para cada elemento do conjunto. Como se tivéssemos uma
nova máquina para cada elemento, com recursos e destinos próprios.
Todo autômato finito não determinístico pode ser transformado em
autômato finito determinístico, como é provado em MENEZES (2001).
Segundo AHO (1995), tanto os autômatos finitos determinísticos
quanto os não-determinísticos são capazes de reconhecer precisamente expressões
regulares. Conseqüentemente, ambos podem validar exatamente o que estas
expressões podem denotar. Entretanto, existe uma barganha tempo-espaço:
enquanto os autômatos finitos determinísticos podem levar a reconhecedores mais
rápidos que os não determinísticos, um autômato finito determinístico pode ser muito
maior que um não determinístico equivalente.
23

1.2. COMPILADOR
ComPort – Compilador Portugol
Segundo WIRTH (1996), programas de computador são formulados em
uma linguagem de programação e especificam classes de processos
computacionais. Computadores, entretanto, interpretam seqüências de instruções
particulares, mas não textos de programas. Assim sendo, o texto do programa deve
ser traduzido em uma seqüência de instruções específicas, antes de poder ser
processado por um computador. Esta tradução pode ser automatizada, o que implica
que pode ser formulada como um programa. O programa de tradução é chamado
compilador e o texto a ser traduzido é chamado de texto fonte ou código fonte.
Definido em AHO (1995) como: “um compilador é um programa que lê
um programa escrito em uma linguagem – a linguagem de origem – e o traduz em
um programa equivalente em outra linguagem – a linguagem destino. Como uma
importante parte no processo de tradução, o compilador reporta ao seu usuário a
presença de erros no programa origem”.
Figura 4 - Diagrama de tradução
A linguagem de origem pode ser qualquer linguagem de alto nível
como C, Pascal ou Modula e a de destino qualquer outra linguagem de alto nível ou
código de máquina de qualquer processador.
Na Figura 4, vemos o programa fonte, escrito na linguagem de origem,
o compilador e o programa objeto, escrito na linguagem destino.
Um compilador pode ter várias partes como: analisador léxico,
analisador sintático, analisador semântico, otimizador e gerador de código. Um
esquema de todas as suas partes e interelações pode ser visto na Figura 5 abaixo.
24

Figura 5 - Fases de um compilador
1.3. ANÁLISE LÉXICA E ANALISADOR LÉXICO
ComPort – Compilador Portugol
Em AHO (1995), análise léxica é a primeira fase de um compilador.
Sua principal tarefa é ler os caracteres de entrada e produzir como saída uma
seqüência de tokens que serão utilizados na análise sintática. Esta interação é
normalmente implementada fazendo com que o analisador léxico seja uma subrotina
do analisador sintático (parser). Ao receber o comando “obter próximo token”
do parser, o analisador léxico lê caracteres da entrada até que identifique o próximo
token. Este processo pode ser visualizado na figura abaixo:
Figura 6 - O papel do analisador léxico
25

ComPort – Compilador Portugol
Como o analisador léxico é a parte do compilador que lê o texto fonte
(origem), ele também pode realizar outras funções secundárias como remover
espaços em branco, comentários e geração de mensagens de erro com referências
a linhas do programa.
1.3.1. Tokens, Padrões e Lexemas
É impossível falar sobre análise léxica e analisadores léxicos sem
definir o significado de tokens, padrões e lexemas.
Tokens são símbolos terminais na gramática de uma linguagem. Na
maioria das linguagens de programação, as seguintes construções são tratadas
como tokens: palavras-chave, operadores, identificadores, constantes, cadeias
literais (strings) e símbolos de pontuação como parênteses, vírgulas e pontos.
Um padrão (pattern) é uma regra descrevendo o conjunto de lexemas
que podem representar um token na linguagem. Estas regras normalmente são
descritas na forma de expressões regulares (Ver 1.3.2).
Lexemas são seqüências de caracteres descritas por um padrão de um
token. Ou seja, o lexema é o valor do token, muitas vezes aparecendo como um
atributo para as fases seguintes de compilação. Enquanto o analisador léxico
procura por tokens, na geração de código precisaremos dos lexemas para produzir
significado.
Exemplo: 3.1415
Tabela 2 - Token x Lexema x Padrão
Token Lexema Padrão
Numero 3.1415 ([+,-])([0-9])*(.([0-9])+)
1.3.2. Expressões regulares
Expressões regulares são uma forma muito interessante de descrever
padrões, especialmente aqueles que consistem em cadeias de caracteres. Através
destas expressões podemos especificar que seqüências de caracteres são aceitas
em um token, especificando caracteres opcionais e o número de repetições aceitos.
26

3, abaixo:
ComPort – Compilador Portugol
A notação utilizada nos exemplos deste texto é especificada na Tabela
Tabela 3 - Notação para as expressões regulares
Símbolo Significado
+ Indica repetição de 1..n.
Exemplo: [a-z]+
* Indica repetição de 0..n.
Exemplo: [0-9]*
? Denota que um item é opcional.
Exemplo: [0-9]?
[ ] Utilizados para definir conjuntos de caracteres.
Exemplo: [afgh] [159]
( ) Utilizados para agrupar itens.
Exemplo: ([0-9]+)?
- Indica faixa em conjuntos.
Exemplo: [0-9] [a-z] [A-Z]
{ } Indicam um número conhecido de repetições.
Caso haja um número mínimo e um máximo,
pode-se representar a faixa utilizando uma “,“.
| Significa “ou”. Aparece entre parênteses e
separa os elementos de uma lista. Somente um
item da lista pode ser usado por vez.
^ Denota início de linha
$ Fim de linha
Exemplos de uso:
Exemplo 1: [0-9] Indica que um caractere, na faixa de 0 à 9 é aceito, ou seja, o
conjunto {0,1,2,3,4,5,6,7,8,9}.
Exemplo 2: [a-z] O mesmo do exemplo anterior, mas para letras minúsculas. É
importante notar que para aceitar maiúsculas e minúsculas é necessário a
expressão: [A-Za-z]
Exemplo 3: (+|-)?[0-9]{1,10} Indica que podemos ter o símbolo “-“ ou “+” uma ou
zero vezes, seguido de dígitos de 0 à 9 em número mínimo de uma ocorrência e
máximo de 10.
27

1.3.3. Tabela de Símbolos
ComPort – Compilador Portugol
É uma estrutura de dados utilizada para armazenar atributos dos
tokens. Ela começa a ser preenchida pelo analisador léxico, mas continua
recebendo dados das outras fases de compilação. Um exemplo é o reconhecimento
de um número, considerando-se como referência a Tabela 2, teríamos dois campos
na tabela de símbolos: o token e o lexema. Em identificadores mais complexos,
como variáveis, poderíamos ter outros campos como o tipo da variável e até mesmo
informações sobre diversos identificadores, como se são nomes de procedimentos,
funções ou rótulos.
O uso de uma tabela de símbolos para a representação das palavras
reservadas de uma linguagem dá flexibilidade à sua extensão, além de proporcionar
um método único para identificação de identificadores, como visto em AHO (1995) e
WIRTH (1996).
As tabelas de símbolos também são responsáveis pelo registro do
endereço de identificadores, possibilitando a tradução de instruções de salto,
chamadas de procedimentos e acesso a variáveis de memória.
1.4. ANÁLISE SINTÁTICA
Segundo AHO (1995), o analisador sintático (parser) obtém uma
seqüência de tokens do analisador léxico e verifica se esta seqüência pode ser
gerada pela gramática da linguagem.
Todas as linguagens de programação possuem regras que descrevem
a estrutura sintática de programas corretamente formados. A sintaxe de uma
linguagem de programação pode ser descrita através de uma gramática livre de
contexto ou notação BNF (Backus-Naur-Form).
1.4.1. Gramáticas livres de contexto
Segundo WIRTH (1996), o termo livre de contexto deve-se a Chomsky
e indica que a substituição do símbolo à esquerda da � pela seqüência derivada da
direita é sempre permitida, independente do contexto em que o símbolo foi inserido.
28

ComPort – Compilador Portugol
Esta restrição de liberdade de contexto é aceitável e desejável para linguagens de
programação.
Muitas linguagens de programação possuem estruturas que são
naturalmente recursivas que podem ser definidas por gramáticas livres de contexto.
Por exemplo, poderíamos ter uma declaração condicional definida por uma regra
como:
se E então S1 senão S2
Esta forma de declaração condicional não pode ser expressa através
de uma expressão regular. Por outro lado, utilizando a variável sintática stmt para
denotar a classe da declaração e expr a classe das expressões, poderíamos
expressar a declaração condicional como:
1.5. ANÁLISE SEMÂNTICA
stmt � se expr então stmt senão stmt
Segundo AHO (1995), a fase de análise semântica verifica o código
fonte para detectar erros de semântica e ao mesmo tempo coleta informações de
tipo para a geração de código. Usando a estrutura hierárquica gerada pela fase de
análise sintática, operadores e operandos de expressões e declarações são
identificados. Um importante componente da análise semântica é a verificação de
tipos. Nesta fase o compilador verifica se cada operador tem os operandos
permitidos pela especificação da linguagem. Um exemplo é a utilização de números
para índices de vetores. A maioria das linguagens permite o uso apenas de números
inteiros, sendo números reais tratados como erro neste caso.
1.6. GERAÇÃO DE CÓDIGO
Nesta fase a representação intermediária do código é traduzida para a
linguagem de máquina da máquina alvo, ou para a linguagem destino. Entre as
tarefas do gerador de código estão: gerenciamento de memória, seleção de
instruções e alocação de registradores entre outras.
29

1.7. OTIMIZAÇÃO DE CÓDIGO
ComPort – Compilador Portugol
Segundo AHO (1995), compiladores devem produzir código tão bons
quanto se fossem escritos à mão. A realidade é que este objetivo só é alcançado em
poucos casos e com dificuldade. Entretanto, o código produzido por compiladores
pode quase sempre rodar mais rápido ou ocupar menos espaço, ou ainda ambos.
Esta melhoria é alcançada através de transformações que tradicionalmente são
chamadas de “otimizações”, sendo o termo otimização não muito preciso, já que não
há garantias de que o código resultante é o melhor possível.
O nível e o tipo de otimizações podem variar entre otimizações
independentes de máquina e otimizações dependentes de máquina. As
independentes são normalmente simplificações de expressões através de regras
matemáticas como no exemplo: x = x * 1. As dependentes podem ocorrer em função
da plataforma destino, como o uso de registradores e operações especiais de
máquina.
30

2. PORTUGOL
ComPort – Compilador Portugol
O portugol como linguagem não é bem definido, variando de autor para
autor. Na maioria das vezes é apenas uma tradução de Pascal para o português,
inclusive trazendo símbolos que o tornam perigoso para uso no estudo de
algoritmos, justamente por o tornar tão dependente de uma certa linguagem. O
Portugol, aqui definido, será baseado em [FARRER], mas com algumas
modificações, principalmente, nas estruturas de repetição e de bloco.
2.1. COMENTÁRIOS
Várias formas de comentários são aceitas, com o objetivo de se estimular
seu uso no código. Tanto o // usado no C e C++ quanto o # (cerquilha) usado no
Shell do Unix são aceitos como comentários de uma linha. Os { } (colchetes) são a
única forma aceita de comentários para várias linhas ou comentários de bloco.
2.2. TIPOS BÁSICOS
Como o objetivo do Portugol aqui definido é o ensino de lógica de
programação e algoritmos, os tipos básicos serão o mais restritos possíveis, a fim de
promover a independência de linguagem e de máquina.
2.2.1. Numérico
O tipo numérico resume todos os tipos para cálculo aritmético. Não se faz
distinção entre números inteiros ou números reais (ponto flutuante). Caso um
algoritmo necessite de alguma propriedade específica de algum desses tipos deverá
especificá-la através de funções. A vírgula é o símbolo usado para separar a parte
decimal dos números. Não se escrevem os separadores de milhar.
31

2.2.2. Literal
ComPort – Compilador Portugol
Tipo responsável por armazenar seqüências de letras e símbolos, o
popular tipo string de muitas linguagens. Para simplificar o entendimento do
Portugol, o tipo caractere, será suprimido e tratado como um literal de comprimento
um. O tratamento do tamanho do caractere será tratado via funções. A alocação de
espaço para armazenamento é automática.
2.2.3. Lógico
Responsável pelo armazenamento das constantes verdadeiro e falso. O
tipo lógico é muito importante na definição de algoritmos, sendo o tipo básico
retornado pela execução de várias operações.
2.2.4. Vetores e matrizes
É permitida a criação de vetores e matrizes de qualquer tipo básico,
incluindo registros definidos pelo usuário. As operações sobre matrizes e vetores
deverão ser especificadas na forma de algoritmos escritos em Portugol, logo não são
definidas na linguagem. As operações básicas deste tipo são as mesmas permitidas
em seus tipos básicos. A palavra-chave matriz é reservada para este tipo. A base ou
número inicial dos índices sempre é 1.
Exemplo:
a matriz numérico[30] // Cria uma matriz 30x1
b matriz lógico[3][3] // Cria uma matriz 3x3
2.2.5. Registros
São definidos pela palavra-chave registro e são compostos pelos campos
declarados, da mesma forma que variáveis, até a palavra fimregistro.
Exemplo:
registro dia, mês, ano numérico
nome literal
matriculado lógico
fimregistro
32

2.3. VARIÁVEIS E IDENTIFICADORES
ComPort – Compilador Portugol
As variáveis são uma importante parte da linguagem. Qualquer
identificador válido tem como primeiro símbolo uma letra. Números e _ (sublinha)
são aceitos após o segundo caractere. Fica estabelecido o tamanho máximo de 32
caracteres para o tamanho do maior nome válido.
É importante observar que símbolos ignorados ou proibidos por outros
compiladores são aceitos em Portugol. Como exemplo os caracteres acentuados da
língua portuguesa: â, á, ã, à, ê, é, è, ..., ç.
Uma vez declarado um nome de identificador com acentos, estes não
serão considerados opcionais. Assim sendo, a variável avião é diferente da variável
aviao. Não há distinção entre maiúsculas e minúsculas.
2.4. DECLARAÇÃO DE VARIÁVEIS
Não há uma seção específica para declaração de variáveis, mas esta
deve ser feita no início de uma seção, seja o programa principal ou um
procedimento/função. O comando declare será usado para declarar as variáveis em
Portugol, sendo permitida a enumeração de identificadores do mesmo tipo, mas não
a declaração de tipos diferentes na mesma linha.
Exemplo:
declare a, b, c numérico
declare d, e, f literal
declare g, h, i lógico
declare j registro dia, mês, ano inteiro
nome literal
matriculado lógico
fimregistro
Exemplo de declaração inválida:
declare a numérico, b literal
33

declarou.
ComPort – Compilador Portugol
A visibilidade de uma variável é definida pelo escopo da estrutura que a
2.5. ATRIBUIÇÃO
A atribuição de valores será denotada pelo símbolo :=.
Só é permitido a atribuição de um valor por vez. Construções do tipo
a:=b:=c:=0 não são aceitas. Uma atribuição válida possui um identificador válido à
esquerda e uma expressão do mesmo tipo do identificador a direita.
Exemplos:
declare a,b numérico
declare c,d literal
declare e,f lógico
a := 5
b := 4,5
2.6. OPERADORES
2.6.1. Operadores Aritméticos
Tabela 4 - Operadores aritméticos
Operação Símbolo
Adição +
Subtração -
Divisão /
Multiplicação *
34

2.6.2. Operadores Lógicos
Tabela 5 - Operadores lógicos
Operação Símbolo
inversão – não não
junção e
disjunção ou
2.6.3. Operadores Relacionais
2.6.4. Operadores Literais
Tabela 6 - Operadores Relacionais
Operação Símbolo
Igualdade =
Maior >
Menor <
Maior ou igual >=
Menor ou igual
Menor <
Maior ou igual >=
Menor ou igual

2.7. ESTRUTURA SEQÜENCIAL
ComPort – Compilador Portugol
O programa começa com a palavra programa e termina em
fimprograma. A importação de outros módulos deve ser especificada como um
comando, logo após a declaração de programa.
Em portugol não se utilizam símbolos especiais ou visuais para marcar o
fim de linha e sim o retorno de carro, mais conhecido pela tecla ENTER, definido na
posição 13 da tabela ASCII. Para manter uma independência de sistemas
operacionais, mas para não dificultar a criação dos programas, seqüências de
símbolos 10 e 13, utilizadas no MS-DOS, como o 10 do UNIX serão tratadas como
fim de linha.
Qualquer símbolo ou comando, exceto comentários, feitos fora da
declaração de programa serão considerados erro. Funções e procedimentos devem
ser declarados em módulos externos e importados pelo programa que as utilize.
Esta decisão visa estimular a modularização do código, bem como a criação de
arquivos menores e mais fáceis de entender.
2.8. ESTRUTURAS CONDICIONAIS
Apenas duas são definidas em Portugol, o se e o caso.
O se avalia uma condição ou expressão condicional, que
obrigatoriamente retorna um valor lógico. Dependendo deste valor a execução passa
para o bloco então, ou senão, para valores verdadeiros e falsos, respectivamente. A
fim de eliminar a criação de blocos, tipo início e fim, define-se em Portugol o
fimentão e o fimsenão, de uso obrigatório.
Exemplo:
se a > b
então a = 1
fimentão
senão b = 1
fimsenão
fimse
36

ComPort – Compilador Portugol
A estrutura caso permite a avaliação de múltiplos valores e admite
variável dos tipos lógico, numérico e literal.
caso idade
10: i := 10
20: j := 10
30: k := 30
fimcaso
2.9. ESTRUTURAS DE REPETIÇÃO
Utiliza-se o faça, enquanto e repita.
O faça substitui o for da maioria das outras linguagens. Sua construção é
demonstrada abaixo:
faça a de 1 até 10
fimfaça
A estrutura acima executará os comandos dez vezes, variando o valor de
a de 1 até 10. A variável de controle, no exemplo acima “a”, não deve ter seu valor
alterado pelos comandos internos. Sempre ao chegar no fimfaça o valor da variável
de controle é incrementado de 1. O valor de “a” após o fimfaça será igual ao limite
estipulado, no caso 10.
O enquanto substitui o while.
enquando a > b
fimenquanto
A estrutura enquanto executa o bloco de comandos até que a condição
seja falsa. É importante notar que os comandos podem nem ser executados,
dependendo da condição inicial.
O repita é definido como uma estrutura de repetição básica. O ponto de
verificação e interrupção é livre, sendo especificado pelo comando interrompa.
repita
37

ComPort – Compilador Portugol
interrompa
fimrepita
Após a execução do interrompa, a execução vai para depois de
fimrepita.
2.10. PROCEDIMENTOS E FUNÇÕES
Procedimentos e funções seguem as mesmas regras de um programa,
exceto por não poderem importar módulos.
A declaração de procedimento é exemplificada abaixo:
procedimento calculaA ( i numérico
j literal
k lógico
)
fimprocedimento
As variáveis declaradas em uma função ou procedimento são internas a
eles, ou seja, possuem escopo local.
Para denotar a passagem por parâmetro, colocamos o prefixo param
antes do nome do parâmetro. Exemplo:
procedimento calculaA ( param i numérico
j literal
k lógico
)
fimprocedimento
Neste caso somente o parâmetro i é passado por referência. Caso haja
mais de um parâmetro na mesma linha, todos serão marcados como passados por
referência:
procedimento calculaA (param i, j, k numérico)
38

ComPort – Compilador Portugol
As funções obedecem todas as regras e possuem todas as propriedades
dos procedimentos. O que diferencia uma função é sua capacidade de retornar um
valor. O valor a ser retornado deve ser atribuído a um identificador, com o mesmo
nome e tipo da função de seu tipo de retorno, antes do fimfunção. Observar que
esta atribuição não força o retorno, o que só ocorre ao executarmos o fimfunção.
Exemplo:
função calculaB( i numérico
j literal
k lógico
) numérico
calculaB:=r
fimfunção
2.11. MÓDULOS
Os módulos iniciam com a palavra módulo seguida do nome e terminam
com fimmodulo. Este nome deve ser utilizado na hora de importar o módulo no
programa principal ou em outro módulo, através da cláusula importe.
As variáveis declaradas dentro do módulo, mas fora de funções e
procedimentos são globais ao módulo, podendo ser acessadas de fora se utilizando
o nome do módulo seguido de ponto e nome da variável. Não é permitida a
repetição de nomes de módulos ou a re-declaração destes na forma de variável.
2.12. FUNÇÕES PRÉ-DEFINIDAS
Tabela 8 - Funções pré-definidas
Formato Função
inteiro(x numérico) numérico Retorna a parte inteira de um número.
tamanho(y literal) numérico Retorna o tamanho em caracteres de uma
variável literal. 0 caso esteja vazia.
ordem(x literal) numérico Retorna o valor correspondente ao primeiro
caractere da seqüência passada na tabela
39

Formato Função
ASCII.
ComPort – Compilador Portugol
caractere(x numérico) literal Retorna o caractere correspondente a posição
denotada por x na tabela ASCII.
número(x literal) numérico Converte uma seqüência literal em número.
Caso não consiga, retorna 0.
lit(n numérico) literal Converte um número em seqüência literal.
2.13. ESPECIFICAÇÃO BNF 1
S = “programa” identificador novalinha comandos “fimprograma” novalinha
digito = [“0”| ”1”| ”2”| “3”| ”4”| ”5”| ”6”| ”7”| “8”| ”9”]
letras-minusculas = [“a”|”b”|”c”|”d”| “e”| “f”| “g”| “h”| “i”| “j”| “k”| “l”| “m”| “n”| “o”| “p”|
“q”| “r”|”s”|”t”| “u”| “v”| “w”| “x”| “y”| “z”| “á”| “é”| “í”| “ó”| “ú”| “ý”|
“ã”| “õ”| “ñ”| “à”| “è”| “ì”| “ò”| “ù”| “ä”| “ë”| “ï”| “ö”| “ü”| “ÿ”| “â”| “ê”|
“î”| “ô”| “û”| “ç”]
letras-maiusculas = [“A”|”B”|”C”|”D”| “E”| “F”| “G”| “H”| “I”| “J”| “K”| “L”| “M”| “N”| “O”|
“P”| “Q”| “R”|”S”|”T”| “U”| “V”| “W”| “X”| “Y”| “Z”| “Á”| “É”| “Í”| “Ó”|
“Ú”| “Ý”| “Ô| “Õ”| “Ñ”| “À”| “È”| “Ì”| “Ò”| “Ù”| “Ä”| “Ë”| “Ï”| “Ö”|
“Ü”| “Ÿ”| “”| “Ê”| “Δ| “Ô”| “Û”| “Ç”]
letra = (letras-minusculas|letras-maiusculas)
numeral = digito{digito}
numero = [+|-] numeral
valor = numero | identificador
literal = \"{*}\"
logico = “verdadeiro” | ”falso”
identificador = letra{letra|digito|”_”}
novalinha = \n | \r | \n\r
op-logico = “não” | “e” | “ou”
op-numerico = “+” | “-“ | “*” | “/”
op-literal = “+” | “=” | “>” | “=” | “

ComPort – Compilador Portugol
op-relacional = “” | “>=” | “

expressao-logica = valor-logico |
expressão-numerica op-relacional expressao-numerica |
valor-logico op-logico expressao-logica
ComPort – Compilador Portugol
42

3. O COMPILADOR PORTUGOL
3.1. ANALISADOR LÉXICO
3.2. ANALISADOR SINTÁTICO
3.3. GERADOR DE CÓDIGO
3.4. FUNÇÕES ADICIONAIS
ComPort – Compilador Portugol
43

4. A MÁQUINA VIRTUAL
ComPort – Compilador Portugol
A máquina virtual escolhida é baseada na de WIRTH (1996), que por
sua vez se baseia na máquina DLX de Hannessy e Patterson (1995) 2 , aproximandose
da arquitetura da máquina MIPS.
O conjunto completo de instruções da máquina DLX encontra se no
apêndice C. O subconjunto particular implementado é descrito a seguir.
4.1. REGISTRADORES
Registradores são memórias especiais à disposição do processador
para diversos fins. Em linguagem de máquina, valores são guardados na memória e
as operações com estes são realizadas nos registradores. Diversas instruções,
especialmente em máquinas RISC, utilizam registradores como seus operandos.
Diferente de máquinas CISC (conjunto de instruções complexo) que possuem
dúzias de formas diferentes de endereçamento (gerando uma instruções para cada
um deles), as máquinas RISC trocam o número de instruções pelo número de
registradores. Uma máquina CISC tem normalmente de 4 a 6 registradores e
enquanto máquinas RISC operam com 32. Este número também é justificado pelo
pequeno número de formas de endereçamento disponível para máquinas RISC, o
que obriga que valores sejam movidos da memória para um registrador antes de
serem utilizados em uma instrução.
A máquina virtual possui 32 registradores de 32 bits cada. Estes
registradores são nomeados de R0 a R31, sendo alguns de uso específico:
R0 sempre contém o valor 0.
R31 é utilizado para armazenar o endereço de retorno em instruções
de salto.
2 HANNESEY J.L., PATTERSON D.A. Computer Architecture – A Quantitative
Approach. Morgan Kaufmann:1995
44

ComPort – Compilador Portugol
IR, ou Instruction Register, contém a instrução atualmente sendo
executada.
PC, ou Program Counter, contém o endereço da próxima instrução a
ser lida da memória.
4.2. FORMATO DE INSTRUÇÕES
A máquina virtual utiliza três formatos de instruções:
Formato 1 – Operações com constantes
6 5 5 16
Op a b c
op é o código de 6 bits do opcode
a é o número de um registrador (5 bits)
b é o número de um registrador (5 bits)
c é a constante de 16 bits
Formato 2 – Operações com registros
6 5 5 11 5
Op a b c
op é o código de 6 bits do opcode
a é o número de um registrador (5 bits)
b é o número de um registrador (5 bits)
c é o número de um registrador (5 bits)
Formato 3 – Operações de Salto
6 26
Op c
op é o código de 6 bits do opcode
c é o deslocamento com 26 bits
45

4.3. INSTRUÇÕES
Instrução Significado Formato Descrição
ComPort – Compilador Portugol
ADD a,b,c R.a := R.b + R.c 2 Adição entre registradores
ADDI a,b,c R.a := R.b + c 1 Adição com constante
SUB a,b,c R.a := R.b - R.c 2 Subtração entre
registradores
SUBI a,b,c R.a := R.b - c 1 Subtração com constante
MUL a,b,c R.a := R.b * R.c 2 Multiplicação entre
registradores
MULI a,b,c R.a := R.b * c 1 Multiplicação com constante
DIV a,b,c R.a := R.b / R.c 2 Divisão entre registradores
DIVI a,b,c R.a := R.b / c 1 Divisão com constante
MOD a,b,c R.a := Rb % R.c 2 Módulo entre registradores
MODI a,b,c R.a := Rb % c 1 Módulo com constante
CMP a,b,c R.a := Ra – Rc 2 Comparação entre
registradores
CMPI a,b,c R.a := Ra – c 1 Comparação com constante
CHK a,c 0

Instrução Significado Formato Descrição
ComPort – Compilador Portugol
XOR a,b,c R.a := R.b ^ R.c 2 Ou exclusivo entre
registradores
XORI a,b,c R.a := R.b ^ c 1 Ou exclusivo com constante
LSH a,b,c R.a := LSH(R.b,R.c) 2 Deslocamento à esquerda
LSHI a,b,c R.a := LSH(R.b, c) 1 Deslocamento à esquerda
com constante
ASH a,b,c R.a := ASH(R.b,R.c) 2 Ajuste aritmético entre
registradores
ASHI a,b,c R.a := ASH(R.b,c) 1 Ajuste aritmético com
constante
LDW a,b,c R.a := Mem[R.b+c] 1 Carrega palavra
LDB a,b,c R.a := Mem[R.b+c] 1 Carrega byte
POP a,b,c R.a := Mem[R.b];
R.b := R.b+c
1 Retira da pilha (pop)
STW a,b,c Mem[R.b+c]:=R.a 1 Armazena palavra
STB a,b,c Mem[R.b+c]:=R.a 1 Armazena byte
PSH a,b,c R.b:=R.b-c;
Mem[R.b]:=R.a
1 Coloca na pilha (push)
BEQ a,c 2 Salta para c seR.a = 0
BNE a,c 2 Salta para c seR.a 0
BLT a,c 2 Salta para c seR.a < 0
BGE a,c 2 Salta para c seR.a >= 0
BGT a,c 2 Salta para c seR.a > 0
BLE a,c 2 Salta para c seR.a

4.4. LIMITAÇÕES
ComPort – Compilador Portugol
A máquina implementada não possui sistema operacional ou suporte a
operações de ponto flutuante. Tais limitações são candidatas para futuras extensões
deste projeto.
A implementação de ponto flutuante exige o suporte de instruções para
operação de simples e dupla precisão, bem como suporte aos registradores de
ponto flutuante. Instruções para conversão de tipo também são necessárias. A
adoção de um padrão numérico deve observar as normas do IEEE
4.5. IMPLEMENTAÇÃO
A máquina virtual encontra-se nos arquivos RISC.H e RISC.CPP,
ambos no anexo A.
48

CONCLUSÃO
ComPort – Compilador Portugol
O estudo de compiladores se mostra fundamental, não só para a área de
compilação, mas para diversos assuntos afins. Compreender o processo de
construção e implementação de uma linguagem é um processo rico e proveitoso. A
criação do ComPort – Compilador Portugol é de grande valor para futuras extensões
e pode ser o embrião para projetos mais ambiciosos, como orientação a objetos e
interface gráfica, entre outros.
49

REFERÊNCIA BIBLIOGRÁFICA
Comport – Compilador Portugol
AHO, Alfred. SETHI, Ravi. ULLMAN Jeffrey. Compiladores – Princípios, Técnicas e
Ferramentas. 1. ed. – Rio de Janeiro: LTC – Livros Técnicos e Científicos:1995.
FARRER, Henry. BECKER, Cristiano Gonçalves. FARIA, Eduardo Chaves. MATOS,
Helton Fábio de. SANTOS, Marcos Augusto. MAIA, Miriam Lourenço. Programação
Estruturada de Computadores - Algoritmos Estruturados. 2. ed. – Rio de Janeiro:
Editora Guanabara: 1989
FRIEDL, Jeffrey E. F. Mastering Regular Expressions – Powerful Techniques for Perl
and Other Tools. 7. ed. – Sebastopol, Califórnia, EEUU:O’Reilly Associates:1998.
MENEZES, Paulo Blauth. Linguagens Formais e Autômatos. 4. ed. - Porto Alegre:
Instituto de Informática da UFRGS:Editora Sagra Luzzatto:2001
PRICE, Ana Maria de Alencar. TOSCANI, Simão Sirineo. Implementação de
Linguagens de Programação: Compiladores. 1. ed. - Porto Alegre: Instituto de
Informática da UFRGS:Editora Sagra Luzzatto:2000
SEBESTA, Robert W. Conceitos de Linguagens de Programação. 4. ed. – Porto
Alegre:Bookman:2000.
WIRTH, Niklaus. Compiler Construction. 1. ed. – Essex, Inglaterra:Addison-
Wesley:1996.
50

SCANNER.H
#ifndef ISCANNER
#define ISCANNER
#include "funcoes.h"
// Tamanho do maior identificador
#define IdLen 32
// Número máximo de palavras chaves
#define KW 50
APÊNDICE A – CÓDIGO FONTE
#define LISTA_DE_ACENTOS "áéíóúâêîôûäëïöüÿãõàèìòùñç"
/*
#define null 0
#define times 1
#define div 3
#define mod 4
#define and 5
#define plus 6
#define minus 7
#define or 8
#define eql 9
#define neq 10
#define lss 11
#define geq 12
#define leq 13
#define gtr 14
#define period 18
#define comma 19
#define colon 20
#define rparen 22
#define rbrak 23
#define of 25
#define then 26
#define DO 27
#define lparen 29
#define lbrak 30
#define not 32
#define becomes 33
#define number 34
#define ident 37
#define semicolon 38
#define END 40
#define ELSE 41
#define ELSIF 42
#define IF 44
#define WHILE 46
Comport – Compilador Portugol
51

#define ARRAY 54
#define RECORD 55
#define CONST 57
#define TYPE 58
#define VAR 59
#define PROCEDURE 60
#define BEGIN 61
#define MODULE 63
#define eof 64
#define TRUE 1
#define FALSE 0
*/
#define MAXLONGINT 1000000
#define NULO 0
#define NUMERICO 1
#define LITERAL 2
#define LOGICO 3
#define MATRIZ 4
#define REGISTRO 5
#define FIMREGISTRO 6
#define DECLARE 7
#define PROGRAMA 8
#define FIMPROGRAMA 9
#define SE 10
#define FIMSE 11
#define ENTAO 12
#define SENAO 13
#define FIMENTAO 14
#define FIMSENAO 15
#define CASO 16
#define FIMCASO 17
#define DEFINA 18
#define FACA 20
#define FIMFACA 21
#define ENQUANTO 22
#define FIMENQUANTO 23
#define REPITA 24
#define FIMREPITA 25
#define INTERROMPA 26
#define DE 27
#define ATE 28
#define PROCEDIMENTO 30
#define FIMPROCEDIMENTO 31
#define FUNCAO 32
#define FIMFUNCAO 33
#define MODULO 40
#define FIMMODULO 41
#define INTEIRO 50
#define TAMANHO 51
#define ORDEM 52
ComPort – Compilador Portugol
52

#define CARACTERE 53
#define NUMERO 54
#define LIT 55
#define ATRIBUICAO 60
#define MAIS 61
#define MENOS 62
#define DIVISAO 63
#define MULTIPLICACAO 64
#define RESTO 65
#define NAO 70
#define E 71
#define OU 72
#define IGUAL 80
#define MAIOR 81
#define MENOR 82
#define MAIOR_IGUAL 83
#define MENOR_IGUAL 84
#define DIFERENTE 85
#define VIRGULA 86
#define PONTO 87
#define DOIS_PONTOS 88
#define VERDADEIRO 90
#define FALSO 91
#define PARENTESE_E 92
#define PARENTESE_D 93
#define CHAVE_E 94
#define CHAVE_D 95
#define IDENTIFICADOR 96
#define ENUMERO 97
#define NOVALINHA 100
#define FDA 101
#define TIPO 102
#define VARIAVEL 103
#define CONSTANTE 104
#define LITERALVALOR 105
#define NUMEROVALOR 106
#define BOOLEANOVALOR 107
#define COLCHETE_E 108
#define COLCHETE_D 109
typedef char Ident[IdLen];
// Valores temporários
extern long val;
extern char sval[255];
extern bool bval;
extern Ident id;
extern unsigned int error;
extern char ch;
extern int numerodeid;
extern long errpos;
extern long linha;
extern long coluna;
extern FILE *R;
extern FILE *W;
ComPort – Compilador Portugol
53

Listas de tokens
extern char comandos[MAX_ELEM_CJ];
extern char fimdecomandos[MAX_ELEM_CJ];
extern char cjfator[MAX_ELEM_CJ];
void Mark (char *msg);
void fIdent (int &sym);
void Number (int &sym);
//void comment (int &sym);
void Get (int &sym);
void EnterKW (int sym, char *name);
void Init (long pos, FILE *C);
void mainScanner (void);
char leiaMinC(FILE *R);
#endif
ComPort – Compilador Portugol
54

SCANNER.CPP
ComPort – Compilador Portugol
/*
* Módulo OSS - Scanner Universidade do Amazonas Comport - Compilador
* Portugol Aluno: Nilo Ney Coutinho Menezes
*
* Baseado no compilador Oberon-0 de Niklaus Wirth
*
*/
#define SCANNER
#include
#include
#include
#include
#include "scanner.h"
#include "funcoes.h"
long val;
char sval[255]={0};
bool bval=false;
// Identificador
// id é usado para retornar o resultado da pesquisa de um identificador
Ident id;
// Código do erro
unsigned int error;
char ch;
// Número de palavras chaves cadastradas
// numerodeid e KW é o máximo
int numerodeid;
// Posição do erro
long errpos;
long linha=1;
long coluna=1;
// R é o arquivo fonte em Portugol
FILE *R;
// W é o stdout, mas pode ser usada para redirecionar a saída se necessário
FILE *W;
// Estrutura que armazena as palavras-chaves já cadastradas,
// Associando um código (sym) com o nome da palavra-chave (id)
struct
{
int sym;
char id[IdLen];
}
keyTab[KW]; // Vetor de palavras-chave
55

char comandos[MAX_ELEM_CJ];
char fimdecomandos[MAX_ELEM_CJ];
char cjfator[MAX_ELEM_CJ];
ComPort – Compilador Portugol
// Função usada para ler um caracter e converte-lo para minuscula
char leiaMinC(FILE *R)
{
return minusculaC(fgetc(R));
}
// Função usada para imprimir mensagens de erro
void
Mark (char *msg)
{
long p;
p = ftell (R);
if (p > errpos)
{
fprintf (W, " Linha: %d Coluna: %d Posição %d %s\n", linha, pcoluna+1,
p, msg);
}
errpos = p;
error = VERDADEIRO;
}
// Função usada para ler e localizar um identificador
void
fIdent (int &sym)
{
int i = 0, k;
do
{
if (i < IdLen)
{
id[i] = ch;
i++;
}
ch = minusculaC(fgetc (R));
}
while ((ch >= '0' && ch = 'a' && ch

}
sym = ENUMERO;
do
{
if (val = '0' && ch

}
do
{
while (ch == '{')
{
ch = fgetc (R);
if (ch == '*')
Comentario (sym);
}
if (ch == '*')
{
ch = fgetc (R);
break;
}
if (feof (R))
break;
ch = fgetc (R);
}
while (1);
if (ch == ')')
{
ch = fgetc (R);
break;
}
if (feof (R))
{
Mark ("Comentário não terminado");
break;
}
}
while (1);
ComPort – Compilador Portugol
// Função mais importante do parser. Usada para caminhar na árvore léxica
// Sempre é chamada para identificar o tipo do próximo sym.
void
Get (int &sym)
{
// Ignora espaços e caracteres de controle
while (!feof (R) && ch

case '-':
ch = fgetc (R);
sym = MENOS;
break;
case '=':
ch = fgetc (R);
sym = IGUAL;
break;
// case '#':
// ch = fgetc (R);
// sym = ;
// break;
case '')
{
ch=leiaMinC(R);
sym = DIFERENTE;
}
else
{
sym = MENOR;
}
break;
case '>':
ch = fgetc (R);
if (ch == '=')
{
ch = fgetc (R);
sym = MAIOR_IGUAL;
}
else
{
sym = MAIOR;
}
break;
case 10: // LF
case 13: // NL
do
{
ch=leiaMinC(R);
} while (ch==13 || ch==10);
sym = NOVALINHA;
linha++;
coluna=ftell(R);
break;
case ',':
ch = fgetc (R);
sym = VIRGULA;
break;
case '"':
Literal(sym);
break;
case ':':
ch = fgetc (R);
if (ch == '=')
ComPort – Compilador Portugol
59

ComPort – Compilador Portugol
{
ch = fgetc (R);
sym = ATRIBUICAO;
}
else
{
sym = DOIS_PONTOS;
}
break;
case '.':
ch = fgetc (R);
sym = PONTO;
break;
//NILO: Ver o caso do comentário // e #
case '(':
ch = fgetc (R);
if (ch == '*')
{
Comentario (sym);
Get (sym);
}
else
sym = PARENTESE_E;
break;
case ')':
ch = fgetc (R);
sym = PARENTESE_D;
break;
//NILO: Mudar de chave para colchete
case '[':
ch = fgetc (R);
sym = COLCHETE_E;
break;
case ']':
ch = fgetc (R);
sym = COLCHETE_D;
break;
// case '~':
// ch = fgetc (R);
// sym = not;
// break;
default:
if ((ch >= 'A' && ch = 'a' && ch = '0' && ch

{
}
error = FALSO;
errpos = pos;
R = C;
ch = fgetc (R);
void
EnterKW (int sym, char *name)
{
keyTab[numerodeid].sym = sym;
strcpy (keyTab[numerodeid].id, name);
numerodeid++;
}
ComPort – Compilador Portugol
// Para testar o cadastro de identificadores, defina SPRINCIPAL.
// Isso fará com que a mainScanner se torne a main
#ifndef SPRINCIPAL
void mainScanner(void)
#else
int main (int argc, char **argv)
#endif
{
W = stdout;
error = VERDADEIRO;
numerodeid = 0; // Inicializa o índice de palavras-chave
EnterKW( NUMERICO, "numérico"); // 1
EnterKW( LITERAL, "literal"); // 2
EnterKW( LOGICO, "lógico"); // 3
EnterKW( MATRIZ, "matriz"); // 4
EnterKW( REGISTRO, "registro"); // 5
EnterKW( FIMREGISTRO, "fimregistro"); // 6
EnterKW( DECLARE, "declare"); // 7
EnterKW( PROGRAMA, "programa"); // 8
EnterKW( FIMPROGRAMA, "fimprograma"); // 9
EnterKW( SE, "se"); // 10
EnterKW( FIMSE, "fimse"); // 11
EnterKW( ENTAO, "então"); // 12
EnterKW( SENAO, "senão"); // 13
EnterKW( FIMENTAO, "fimentão"); // 14
EnterKW( FIMSENAO, "fimsenão"); // 15
EnterKW( CASO, "caso"); // 16
EnterKW( FIMCASO, "fimcaso"); // 17
EnterKW( FACA, "faça"); // 20
EnterKW( FIMFACA, "fimfaça"); // 21
EnterKW( ENQUANTO, "enquanto"); // 22
EnterKW( FIMENQUANTO, "fimenquanto"); // 23
EnterKW( REPITA, "repita"); // 24
EnterKW( FIMREPITA, "fimrepita"); // 25
EnterKW( INTERROMPA, "interrompa"); // 26
EnterKW( DE, "de"); // 27
EnterKW( ATE, "ate"); // 28
EnterKW( PROCEDIMENTO,"procedimento");// 30
EnterKW( FIMPROCEDIMENTO, "fimprocedimento"); // 31
61

EnterKW( FUNCAO, "função"); // 32
EnterKW( FIMFUNCAO, "fimfunção"); // 33
EnterKW( MODULO, "módulo"); // 40
EnterKW( FIMMODULO, "fimmódulo"); // 41
EnterKW( INTEIRO, "inteiro"); // 50
EnterKW( TAMANHO, "tamanho"); // 51
EnterKW( ORDEM, "ordem"); // 52
EnterKW( CARACTERE, "caractere"); // 53
EnterKW( NUMERO, "número"); // 54
EnterKW( LIT, "lit"); // 55
// EnterKW( ATRIBUICAO 60
// EnterKW( MAIS 61
// EnterKW( MENOS 62
// EnterKW( DIVISAO 63
// EnterKW( MULTIPLICACAO 64
EnterKW( NAO, "não"); // 70
EnterKW( E, "e"); // 71
EnterKW( OU, "ou"); // 72
// EnterKW( IGUAL, ""); 80
// EnterKW( MAIOR, ""); 81
// EnterKW( MENOR, ""); 82
// EnterKW( MAIOR_IGUAL, ""); 83
// EnterKW( MENOR_IGUAL, ""); 84
// EnterKW( DIFERENTE, ""); 85
EnterKW( VERDADEIRO, "verdadeiro"); // 90
EnterKW( FALSO, "falso"); // 91
// EnterKW( NOVALINHA, "\n"); // 100
// Conjuntos
// Conjunto de Comandos (Statements)
CriaConjunto(comandos);
AdicionaConjunto(comandos, SE);
AdicionaConjunto(comandos, FIMSE);
AdicionaConjunto(comandos, ENTAO);
AdicionaConjunto(comandos, FIMENTAO);
AdicionaConjunto(comandos, SENAO);
AdicionaConjunto(comandos, FIMSENAO);
AdicionaConjunto(comandos, ENQUANTO);
AdicionaConjunto(comandos, REPITA);
AdicionaConjunto(comandos, FIMREPITA);
AdicionaConjunto(comandos, FACA);
AdicionaConjunto(comandos, FIMFACA);
AdicionaConjunto(comandos, CASO);
AdicionaConjunto(comandos, FIMCASO);
AdicionaConjunto(comandos, MATRIZ);
AdicionaConjunto(comandos, REGISTRO);
AdicionaConjunto(comandos, FIMREGISTRO);
AdicionaConjunto(comandos, DECLARE);
AdicionaConjunto(comandos, FIMPROGRAMA);
AdicionaConjunto(comandos, PROGRAMA);
AdicionaConjunto(comandos, MODULO);
AdicionaConjunto(comandos, FIMMODULO);
AdicionaConjunto(comandos, PROCEDIMENTO);
AdicionaConjunto(comandos, FIMPROCEDIMENTO);
AdicionaConjunto(comandos, FUNCAO);
ComPort – Compilador Portugol
62

AdicionaConjunto(comandos, FIMFUNCAO);
AdicionaConjunto(comandos, FDA);
CriaConjunto(fimdecomandos);
AdicionaConjunto(fimdecomandos, FIMSE);
AdicionaConjunto(fimdecomandos, FIMENTAO);
AdicionaConjunto(fimdecomandos, FIMSENAO);
AdicionaConjunto(fimdecomandos, FIMREPITA);
AdicionaConjunto(fimdecomandos, FIMFACA);
AdicionaConjunto(fimdecomandos, FIMCASO);
AdicionaConjunto(fimdecomandos, MATRIZ);
AdicionaConjunto(fimdecomandos, REGISTRO);
AdicionaConjunto(fimdecomandos, FIMREGISTRO);
AdicionaConjunto(fimdecomandos, DECLARE);
AdicionaConjunto(fimdecomandos, FIMPROGRAMA);
AdicionaConjunto(fimdecomandos, PROGRAMA);
AdicionaConjunto(fimdecomandos, MODULO);
AdicionaConjunto(fimdecomandos, FIMMODULO);
AdicionaConjunto(fimdecomandos, PROCEDIMENTO);
AdicionaConjunto(fimdecomandos, FIMPROCEDIMENTO);
AdicionaConjunto(fimdecomandos, FUNCAO);
AdicionaConjunto(fimdecomandos, FIMFUNCAO);
AdicionaConjunto(fimdecomandos, FDA);
CriaConjunto(cjfator);
AdicionaConjunto(cjfator,NULO);
AdicionaConjunto(cjfator,MULTIPLICACAO);
AdicionaConjunto(cjfator,DIVISAO);
AdicionaConjunto(cjfator,E);
AdicionaConjunto(cjfator,MAIS);
AdicionaConjunto(cjfator,MENOS);
AdicionaConjunto(cjfator,OU);
AdicionaConjunto(cjfator,IGUAL);
AdicionaConjunto(cjfator,DIFERENTE);
AdicionaConjunto(cjfator,MENOR);
AdicionaConjunto(cjfator,MAIOR_IGUAL);
AdicionaConjunto(cjfator,MENOR_IGUAL);
AdicionaConjunto(cjfator,MAIOR);
AdicionaConjunto(cjfator,VIRGULA);
AdicionaConjunto(cjfator,DOIS_PONTOS);
AdicionaConjunto(cjfator,PARENTESE_D);
AdicionaConjunto(cjfator,CHAVE_D);
AdicionaConjunto(cjfator,COLCHETE_D);
AdicionaConjunto(cjfator,ENTAO);
#ifdef SPRINCIPAL
Init(0);
if(argc==2)
R=fopen(argv[1],"r");
ch=leiaMinC(R);
int i;
for(i=0;i

eturn(0);
#endif
}
ComPort – Compilador Portugol
64

PARSER.H
#ifndef IPARSER
#define IPARSER
#include
#include
#include
#include "scanner.h"
#include "codegenerator.h"
#include "risc.h"
#include "funcoes.h"
#define WordSize 4
#ifndef PARSER
extern int sym;
extern int loaded;
extern Object topScope;
extern Object universe;
extern Object guard;
#endif
#define VERSAO "0.92"
void NewObj (Object & obj, int Class);
void find (Object & obj);
void FindField (Object & obj, Object list);
int IsParam (Object obj);
void OpenScope (void);
void CloseScope (void);
void selector (Item & x);
void factor (Item & x);
void term (Item & x);
void SimpleExpression (Item & x);
void expression (Item & x);
void parameter (Object & fp);
void param (Item & x);
void StatSequence (void);
void IdentList (int Class, Object & first);
void fType (Type & type);
ComPort – Compilador Portugol
65

void declarations (long varsize);
void FPSection (long &parblksize);
void ProcedureDecl (void);
void Module (FILE * S);
void Compile (FILE *C);
void enter (int cl, long n, Ident name, Type type);
void mainParser (void);
#endif
ComPort – Compilador Portugol
66

PARSER.CPP
ComPort – Compilador Portugol
/*
* Módulo OSP - Parser Universidade do Amazonas Comport - Compilador
* Portugol Aluno: Nilo Ney Coutinho Menezes
*
* Baseado no compilador Oberon-0 de Niklaus Wirth
*
*/
#include
#include
#include
#define PARSER
#include "parser.h"
#include "codegenerator.h"
int sym, loaded;
Object topScope, universe, guard;
void
NewObj (Object & obj, int Class)
{
Object nova, x;
x = topScope;
strcpy(guard->name, id);
while (strcmp(x->next->name, id)!=0)
x = x->next;
if (x->next==guard)
{
nova = new ObjDesc;
strcpy(nova->name, id);
nova->Class = Class;
nova->next = guard;
x->next = nova;
obj = nova;
}
else
{
obj = x->next;
Mark ("Definição múltipla !");
}
}
void
find (Object & obj)
{
Object s, x;
s = topScope;
strcpy(guard->name, id);
do
{
x = s->next;
while (!strcmp (x->name, id))
67

}
x = x->next;
if (x != guard)
{
obj = x;
break;
}
if (s == universe)
{
obj = x;
Mark ("Não definido");
break;
}
s = s->dsc;
}
while (1);
//NILO: Verificar se não há problema caso não encontre
void
FindField (Object & obj, Object list)
{
strcpy(guard->name,id);
while (!strcmp (list->name, id))
list = list->next;
obj = list;
}
ComPort – Compilador Portugol
int
IsParam (Object obj)
{
return (obj->Class == Par || obj->Class == Var && obj->val > 0);
}
void
OpenScope (void)
{
Object s;
s = new ObjDesc;
s->Class = Head;
s->dsc = topScope;
s->next = guard;
topScope = s;
}
void
CloseScope (void)
{
topScope = topScope->dsc;
}
void
selector (Item & x)
{
Item y;
Object obj;
while (sym == COLCHETE_E || sym == PONTO)
{
switch(sym)
{
case COLCHETE_E:
68

}
}
}
Get (sym);
expression (y);
if (x.type->form == MATRIZ)
{
Index (x, y);
}
else
{
Mark ("Não é uma matriz");
}
if (sym == COLCHETE_D)
{
Get (sym);
}
else
Mark ("Falta ]?");
break;
case PONTO:
Get (sym);
if (sym == IDENTIFICADOR)
{
if (x.type->form == REGISTRO)
{
FindField (obj, x.type->fields);
Get (sym);
if (obj != guard)
Field (x, obj);
else
Mark ("Não definido");
}
else
Mark ("Não é um registro");
}
break;
default:
Mark ("IDENTIFICADOR?");
//NILO: Verificar a equivalencia de Simbolos
void
factor (Item & x)
{
Object obj;
if (PertenceConjunto(cjfator, sym))
{
Mark ("IDENTIFICADOR?");
do
{
Get (sym);
} while (PertenceConjunto(cjfator, sym));
}
switch(sym)
{
case IDENTIFICADOR:
find (obj);
Get (sym);
MakeItem (x, obj);
selector (x);
break;
ComPort – Compilador Portugol
69

}
}
case ENUMERO:
MakeConstItem (x, intType, val);
Get (sym);
break;
case PARENTESE_E:
Get (sym);
expression (x);
if (sym == PARENTESE_D)
Get (sym);
else
Mark (")?");
break;
case COLCHETE_E:
Get (sym);
expression (x);
if (sym == COLCHETE_D)
Get (sym);
else
Mark ("]?");
break;
case NAO:
Get (sym);
factor (x);
Op1 (NAO, x);
break;
default:
Mark ("factor?");
MakeItem (x, guard);
void
term (Item & x)
{
Item y;
int op;
factor (x);
// Modulo retirado, pois não é definido em portugol
while (sym == MULTIPLICACAO || sym==DIVISAO || sym == E)
{
op = sym;
Get (sym);
if (op == E)
Op1 (op, x);
factor (y);
Op2 (op, x, y);
}
}
void
SimpleExpression (Item & x)
{
Item y;
int op;
switch(sym)
{
ComPort – Compilador Portugol
70

}
case MAIS:
Get (sym);
term (x);
break;
case MENOS:
Get (sym);
term (x);
Op1 (MENOS, x);
break;
default:
term (x);
}
while (sym == MAIS || sym==MENOS || sym == OU)
{
op = sym;
Get (sym);
if (op == OU)
{
Op1 (op, x);
}
term (y);
Op2 (op, x, y);
}
//NILO: Verificar a equivalencia de Simbolos
void
expression (Item & x)
{
Item y;
int op;
SimpleExpression (x);
}
if (sym == IGUAL || sym == MAIOR || sym == MENOR
|| sym == MAIOR_IGUAL || sym == MENOR_IGUAL
|| sym == DIFERENTE)
{
op = sym;
Get (sym);
SimpleExpression (y);
Relation (op, x, y);
}
void
parameter (Object & fp)
{
Item x;
expression (x);
if (IsParam (fp))
{
Parameter (x, fp->type, fp->Class);
fp = fp->next;
}
else
Mark ("Parâmetros demais");
}
void
param (Item & x)
{
ComPort – Compilador Portugol
71

if (sym == PARENTESE_E)
Get (sym);
else
Mark ("(?");
expression (x);
if (sym == PARENTESE_D)
Get (sym);
else
Mark (")?");
}
//NILO: Verificar a equivalencia de Simbolos
void
StatSequence (void)
{
Object par, obj;
Item x, y;
long L;
do
{
obj = guard;
if (!PertenceConjunto(comandos, sym))
{
Mark ("Comando?");
do
{
Get (sym);
}
while (!PertenceConjunto(comandos,sym));
}
switch(sym)
{
case IDENTIFICADOR:
find (obj);
Get (sym);
MakeItem (x, obj);
selector (x);
switch(sym)
{
case ATRIBUICAO:
Get (sym);
expression (y);
Store (x, y);
break;
case IGUAL:
Mark (":= ?");
Get (sym);
expression (y);
break;
default:
if (x.mode == Proc)
{
par = obj->dsc;
if (sym == PARENTESE_E)
{
Get (sym);
if (sym == PARENTESE_D)
Get (sym);
else
{
do
{
ComPort – Compilador Portugol
72

}
ComPort – Compilador Portugol
parameter (par);
if (sym == VIRGULA)
Get (sym);
else
{
if (sym == PARENTESE_D)
{
Get (sym);
break;
}
else
{
if (sym == NOVALINHA)
break;
else
Mark (") or , ?");
}
}
} while (1);
}
if (obj->val < 0)
Mark ("forward call");
else if (!IsParam (par))
Call (x);
else
Mark ("Poucos parâmetros");
}
else if (x.mode == SProc)
{
if (obj->val Class == Typ)
Mark ("Atribuição ilegal?");
else
Mark ("Comando?");
}
break;
case SE:
Get (sym);
expression (x);
CJump (x);
if (sym == ENTAO)
Get (sym);
else
Mark ("então?");
StatSequence ();
L = 0L;
while (sym == SENAO)
{
Get (sym);
FJump (L);
FixLink (x.a);
expression (x);
CJump (x);
if (sym == ENTAO)
Get (sym);
else
Mark ("Então?");
73

}
StatSequence ();
}
if (sym == SENAO)
{
Get (sym);
FJump (L);
FixLink (x.a);
StatSequence ();
}
else
FixLink (x.a);
FixLink (L);
if (sym == FIMSE)
Get (sym);
else
Mark ("Fimse?");
break;
case ENQUANTO:
Get (sym);
L = pc;
expression (x);
CJump (x);
// if (sym == DO)
// Get (sym);
// else
// Mark ("DO?");
StatSequence ();
BJump (L);
FixLink (x.a);
if (sym == FIMENQUANTO)
Get (sym);
else
Mark ("fimenquanto?");
break;
}
if (sym == NOVALINHA)
Get (sym);
else if (PertenceConjunto(fimdecomandos, sym))
break;
else
Mark ("Fim de linha ?");
} while (1);
void
IdentList (int Class, Object & first)
{
Object obj;
if (sym == IDENTIFICADOR)
{
NewObj (first, Class);
Get (sym);
while (sym == VIRGULA)
{
Get (sym);
if (sym == IDENTIFICADOR)
{
NewObj (obj, Class);
Get (sym);
ComPort – Compilador Portugol
74

}
}
else
Mark ("IDENTIFICADOR?");
//NILO: Aqui vem o tipo da variável
// if (sym == DOIS_PONTOS)
// Get (sym);
// else
// Mark (":?");
}
}
void
fType (Type & type)
{
Object obj, first;
Item x;
Type tp;
ComPort – Compilador Portugol
if (sym != IDENTIFICADOR && sym != MATRIZ && sym != REGISTRO &&
sym != NUMERICO && sym !=LITERAL && sym !=LOGICO)
{
Mark ("Tipo ?");
do
{
Get (sym);
}
while (sym != IDENTIFICADOR && sym !=NOVALINHA);
}
switch (sym) {
case LITERAL:
type = litType;
Get(sym);
break;
case NUMERICO:
type = intType;
Get(sym);
break;
case LOGICO:
type = boolType;
Get(sym);
break;
case IDENTIFICADOR: // Tipo definido pelo usuário
find (obj);
Get (sym);
if (obj->Class == Typ)
type = obj->type;
else
Mark ("Tipo ?");
break;
case MATRIZ:
Get (sym);
expression (x);
if (x.mode != Const || x.a < 0)
Mark ("Índice inválido");
// if (sym == of)
// Get (sym);
// else
// Mark ("OF?");
tp = new TypeDesc;
type->form = MATRIZ;
75

}
type->base = tp;
type->len = SHORT (x.a);
type->size = type->len * tp->size;
break;
case REGISTRO:
Get (sym);
type = new TypeDesc;
type->form = REGISTRO;
type->size = 0;
OpenScope ();
do
{
if (sym == IDENTIFICADOR)
{
IdentList (Fld, first);
fType (tp);
obj = first;
while (obj != guard)
{
obj->type = tp;
obj->val = type->size;
type->size += (obj->type->size);
obj = obj->next;
}
}
if (sym == NOVALINHA)
Get (sym);
else if (sym == IDENTIFICADOR)
Mark (" ?");
else break;
} while (1);
type->fields = topScope->next;
CloseScope ();
if (sym == FIMREGISTRO)
Get (sym);
else
Mark ("fimregistro ?");
break;
default:
Mark ("Identificador ?");
}
int EInicioDeDeclaracaoDefinicaoOuFim(int s)
{
switch(s)
{
case PROCEDIMENTO:
case FUNCAO:
case FIMPROGRAMA:
case FIMMODULO:
case FDA:
case DECLARE:
case DEFINA:
return(VERDADEIRO);
}
return(FALSO);
}
//NILO: Verificar a equivalencia de Simbolos
void
declarations (long varsize)
ComPort – Compilador Portugol
76

ComPort – Compilador Portugol
{
Object obj, first;
Item x;
Type tp;
long L;
if (sym != DECLARE && sym != DEFINA)
{
Mark ("declaração?");
do // Pula o código até a próxima declaração de bloco
{
Get (sym);
}
while (EInicioDeDeclaracaoDefinicaoOuFim(sym));
}
do
{
switch (sym) {
case DEFINA:
{
Get (sym);
while (sym == IDENTIFICADOR)
{
NewObj (obj, Const);
Get (sym);
if (sym == IGUAL)
Get (sym);
else
Mark ("= ?");
expression (x);
fprintf(stderr, "Constante %s definida como %d", id, x.a);
if (x.mode == Const)
{
obj->val = x.a;
obj->type = x.type;
}
else
Mark ("A expressão não é uma constante!");
if (sym == NOVALINHA)
Get (sym);
else
Mark ("?");
}
break;
}
/* TODO: não há no portugol sintaxe para declaração de tipo */
case TIPO:
{
Get (sym);
while (sym == IDENTIFICADOR)
{
NewObj (obj, Typ);
Get (sym);
if (sym == IGUAL)
Get (sym);
else
Mark ("=?");
fType (obj->type);
if (sym == NOVALINHA)
Get (sym);
else
Mark ("?");
77

lista
ComPort – Compilador Portugol
}
break;
}
case DECLARE:
{
Get (sym);
while (sym == IDENTIFICADOR)
{
IdentList (Var, first);
fType (tp);
//atualiza a informação de tipo do primeiro ao ultimo da
obj = first;
while (obj != guard)
{
obj->type = tp;
obj->lev = curlev;
varsize = varsize + obj->type->size;
obj->val = -varsize;
fprintf(stderr, "Variável %s criada sendo do tipo %s\n",
obj->name , id);
obj = obj->next;
}
if (sym == NOVALINHA)
Get (sym);
else
Mark (" ?");
}
break;
}
}
}
while (sym == DECLARE || sym == DEFINA);
}
void
FPSection (long &parblksize)
{
Object obj, first;
Type tp;
long parsize;
if (sym == VARIAVEL)
{
Get (sym);
IdentList (Par, first);
}
else
IdentList (VARIAVEL, first);
if (sym == IDENTIFICADOR)
{
find (obj);
Get (sym);
if (obj->Class == Typ)
tp = obj->type;
else
{
Mark ("type?");
tp = intType;
}
}
else
78

}
{
Mark ("IDENTIFICADOR?");
tp = intType;
}
if (first->Class == VARIAVEL)
{
parsize = tp->size;
if (tp->form >= MATRIZ)
Mark ("no struct params");
}
else
parsize = WordSize;
obj = first;
while (obj != guard)
{
obj->type = tp;
parblksize += parsize;
obj = obj->next;
}
void
ProcedureDecl (void)
{
const int marksize = 8;
Object proc, obj;
Ident procid;
long locblksize, parblksize;
Get (sym);
if (sym == IDENTIFICADOR)
{
strcpy(procid,id);
NewObj (proc, Proc);
Get (sym);
parblksize = marksize;
IncLevel (1);
OpenScope ();
proc->val = -1;
if (sym == PARENTESE_E)
{
Get (sym);
if (sym == PARENTESE_D)
Get (sym);
else
{
FPSection (parblksize);
while (sym == NOVALINHA)
{
Get (sym);
FPSection (parblksize);
}
if (sym == PARENTESE_D)
Get (sym);
else
Mark (")?");
}
}
else if (curlev == 1)
EnterCmd (procid);
ComPort – Compilador Portugol
79

obj = topScope->next;
locblksize = parblksize;
while (obj != guard)
{
obj->lev = curlev;
if (obj->Class == Par)
locblksize -= WordSize;
else
locblksize -= obj->type->size;
obj->val = locblksize;
obj = obj->next;
}
proc->dsc = topScope->next;
if (sym == NOVALINHA)
Get (sym);
else
Mark ("?");
locblksize = 0;
declarations (locblksize);
while (sym == PROCEDIMENTO)
{
ProcedureDecl ();
if (sym == NOVALINHA)
Get (sym);
else
Mark ("?");
}
proc->val = pc;
Enter (locblksize);
// if (sym == BEGIN)
// {
Get (sym);
StatSequence ();
// }
if (sym == FIMPROCEDIMENTO)
Get (sym);
else
Mark ("fimprocedimento?");
if (sym == IDENTIFICADOR)
{
if (procid != id)
Mark ("no match");
Get (sym);
}
Return (parblksize - marksize);
CloseScope ();
IncLevel (-1);
}
}
void
Module (FILE * S)
{
Ident modid;
long varsize;
fprintf (W, " compilando: ");
if (sym == MODULO)
{
Get (sym);
Open ();
ComPort – Compilador Portugol
80

ComPort – Compilador Portugol
OpenScope ();
varsize = 0;
if (sym == IDENTIFICADOR)
{
strcpy(modid, id);
Get (sym);
fprintf (W, "%s\n", modid);
}
else
Mark ("IDENTIFICADOR?");
if (sym == NOVALINHA)
Get (sym);
else
Mark ("?");
if(sym==DECLARE || sym ==DEFINA)
declarations (varsize);
while (sym == PROCEDIMENTO)
{
ProcedureDecl ();
if (sym == NOVALINHA)
Get (sym);
else
Mark ("?");
}
Header (varsize);
// if (sym == BEGIN)
// {
// Get (sym);
StatSequence ();
// }
if (sym == FIMMODULO)
Get (sym);
else
Mark ("fimmódulo?");
if (sym == IDENTIFICADOR)
{
if (modid != id)
Mark ("Nome do módulo diferente do declarado");
Get (sym);
}
else
Mark ("Nome do módulo ?");
if (sym != PONTO)
Mark (". ?");
CloseScope ();
if (!error)
{
/* TODO: Vericar este item no código original do Wirth */
/*
IF ~OSS.error THEN
COPY(modid, S.s); OSG.Close(S, varsize); Texts.WriteString(W, "code
generated");
Texts.WriteInt(W, OSG.pc, 6); Texts.WriteLn(W);
Texts.Append(Oberon.Log, W.buf)
END
*/
}
fscanf (S, "%s", modid);
Close (S, varsize);
fprintf (W, "code generated%6d\n", pc);
81

}
}
else
Mark ("módulo?");
void
Compile (FILE *C)
{
long beg, end, time;
FILE *S;
loaded = FALSO;
S = C;
Init (0,C);
Get (sym);
Module (S);
}
ComPort – Compilador Portugol
/* TODO: Ver o que fazem estas funções: Decode, Load e Exec */
/*
*
*
* PROCEDURE Decode*; VAR V: MenuViewers.Viewer; T: Texts.Text; X, Y:
* INTEGER; BEGIN T := TextFrames.Text("");
* Oberon.AllocateSystemViewer(Oberon.Par.frame.X, X, Y); V :=
* MenuViewers.New( TextFrames.NewMenu("Log.Text", "System.Close
* System.Copy System.Grow Edit.Search Edit.Store"), TextFrames.NewText(T,
* 0), TextFrames.menuH, X, Y); OSG.Decode(T) END Decode;
*
* PROCEDURE Load*; VAR S: Texts.Scanner; BEGIN IF ~OSS.error & ~loaded
* THEN Texts.OpenScanner(S, Oberon.Par.text, Oberon.Par.pos);
* OSG.Load(S); loaded := TRUE END END Load;
*
* PROCEDURE Exec*; VAR S: Texts.Scanner; BEGIN IF loaded THEN
* Texts.OpenScanner(S, Oberon.Par.text, Oberon.Par.pos); Texts.Scan(S);
* IF S.class = Texts.Name THEN OSG.Exec(S) END END END Exec;
*/
void
enter (int cl, long n, Ident name, Type type)
{
Object obj;
obj = new ObjDesc;
obj->Class = cl;
obj->val = n;
strcpy (obj->name, name);
obj->type = type;
obj->dsc = NULL;
obj->next = topScope->next;
topScope->next = obj;
}
void
mainParser (void)
{
fprintf (W, "Portugol Compiler %s\n", VERSAO);
guard = new ObjDesc;
guard->Class = VARIAVEL;
guard->type = intType;
guard->val = 0;
topScope = NULL;
82

}
OpenScope ();
// Tipos predefinidos
enter (Typ, 1, "LOGICO", boolType);
enter (Typ, 2, "INTEIRO", intType);
enter (Typ, 3, "LITERAL", litType);
// Constantes
enter (Const, 1, "VERDADEIRO", boolType);
enter (Const, 0, "FALSO", boolType);
// Funções Predefinidas
enter (SProc, 1, "leia", NULL);
enter (SProc, 2, "escreva", NULL);
enter (SProc, 3, "escreva_hex", NULL);
enter (SProc, 4, "escreva_nl", NULL);
enter (SProc, 5, "inteiro", NULL);
enter (SProc, 6, "tamanho", NULL);
enter (SProc, 7, "ordem", NULL);
enter (SProc, 8, "caractere", NULL);
enter (SProc, 8, "número", NULL);
enter (SProc, 9, "lit", NULL);
universe = topScope;
ComPort – Compilador Portugol
83

CODEGENERATOR.H
#ifndef ICODEGENERATOR
#define ICODEGENERATOR
#define maxCode 1000
#define maxRel 200
#define NofCom 16
#define Head 0
#define Var 1
#define Par 2
#define Const 3
#define Fld 4
#define Typ 5
#define Proc 6
#define SProc 7
#define Reg 10
#define Cond 11
#define Boolean 0
#define Integer 1
#define Array 2
#define Record 3
#define Literal 4
// Registradores reservados
#define FP 29
#define SP 30
#define LNK 31
// Tipos
typedef struct ObjDesc *Object;
typedef struct TypeDesc *Type;
typedef struct Item
{
int mode, lev;
Type type;
long a, b, c, r;
} Item;
struct ObjDesc
{
int Class, lev;
Object next, dsc;
Type type;
Ident name;
long val;
};
struct TypeDesc
{
int form;
Object fields;
ComPort – Compilador Portugol
84

Type base;
int size, len;
};
#ifndef CODEGENERATOR
extern Type boolType;
extern Type intType;
extern Type litType;
extern int curlev;
extern int pc;
#endif
void mainCodeGenerator (void);
void ClearReg ();
void GetReg (long &r);
void Put (long op, long a, long b, long c);
void EXCL (char *reg, int p);
void TestRange (long x);
void load (Item & x);
void loadBool (Item & x);
void PutOp (long cd, Item & x, Item & y);
long negated (long cond);
long merged (long L0, long L1);
void fix (long at, long with);
void FixWith (long L0, long L1);
void FixLink (long L);
void IncLevel (int n);
void MakeConstItem (Item & x, Type typ, long val);
void MakeItem (Item & x, Object y);
void Field (Item & x, Object & y);
void Index (Item & x, Item & y);
void Op1 (int op, Item & x);
void Op2 (int op, Item & x, Item & y);
void Relation (int op, Item & x, Item & y);
void Store (Item & x, Item & y);
void Parameter (Item & x, Type & ftyp, int Class);
ComPort – Compilador Portugol
85

void CJump (Item & x);
void BJump (long L);
void FJump (long &L);
void Call (Item & x);
void IOCall (Item & x, Item & y);
void Header (long size);
void Enter (long size);
void Return (long size);
void Open (void);
void Close (FILE * S, long globals);
void EnterCmd (char *name);
void Load (FILE * S);
void Exec (FILE * S);
void Decode (FILE * T);
#endif
ComPort – Compilador Portugol
86

CODEGENERATOR.CPP
ComPort – Compilador Portugol
/*
* Módulo OSG - Code Generator Universidade do Amazonas Comport -
* Compilador Portugol Aluno: Nilo Ney Coutinho Menezes
*
* Baseado no compilador Oberon-0 de Niklaus Wirth
*
*/
#define CODEGENERATOR
#include
#include
#include
#include "scanner.h"
#include "instrucoes.h"
#include "risc.h"
#include "funcoes.h"
#include "codegenerator.h"
// int curlev, pc;
Type boolType, intType, litType;
int curlev, pc;
int relx, cno;
long entry, fixlist;
char regs[32]; // Verificar troca por SET -- forcar o
// ClearReg!!!
extern FILE *W;
long code[maxCode];
int rel[maxRel];
Ident comname[NofCom];
long comadr[NofCom];
char mnemo[54][5];
void
ClearReg ()
{
int i;
for (i = 0; i < 32; i++)
regs[i] = 0;
}
void
GetReg (long &r)
{
int i;
for (i = 1; (i < FP && !regs[i]); i++);
regs[i] = 1;
r = i;
}
87

ComPort – Compilador Portugol
void
Put (long op, long a, long b, long c)
{
if (op >= 32)
op = op - 64;
code[pc] = fASH (fASH (fASH (op, 5) + a, 5) + b, 16) + (c % 0x10000);
pc++;
}
void
EXCL (char *reg, int p)
{
reg[p] = 0;
}
void
TestRange (long x)
{
if (x >= 0x8000 || x form != Boolean)
88

}
Mark ("Boolean ?");
load (x);
x.mode = Cond;
x.a = 0;
x.b = 0;
x.c = 1;
void
PutOp (long cd, Item & x, Item & y)
{
long r;
if (x.mode != Reg)
load (x);
if (x.r == 0)
{
GetReg (x.r);
r = 0;
}
else
{
r = x.r;
}
if (y.mode == Const)
{
TestRange (y.a);
Put (cd + 16, r, x.r, y.a);
}
else
{
if (y.mode != Reg)
load (y);
Put (cd, x.r, r, y.r);
EXCL (regs, y.r);
}
}
long
negated (long cond)
{
if (ODD (cond))
return (cond - 1);
else
return (cond + 1);
}
long
merged (long L0, long L1)
{
long L2, L3;
if (L0 != 0)
{
L2 = L0;
do
{
L3 = code[L2] % 0x10000;
if (L3 == 0)
break;
L2 = L3;
}
ComPort – Compilador Portugol
89

}
while (1);
code[L2] = code[L2] - L3 + L1;
return (L0);
}
else
return (L1);
void
fix (long at, long with)
{
code[at] = code[at] / 0x10000 * 0x10000 + (with % 0x10000);
}
void
FixWith (long L0, long L1)
{
long L2;
while (L0 != 0)
{
L2 = code[L0] % 0x10000;
fix (L0, L1 - L0);
L0 = L2;
}
}
void
FixLink (long L)
{
long L1;
while (L != 0)
{
L1 = code[L] % 0x10000;
fix (L, pc - L);
L = L1;
}
}
void
IncLevel (int n)
{
curlev += n;
}
void
MakeConstItem (Item & x, Type typ, long val)
{
x.mode = Const;
x.type = typ;
x.a = val;
}
void
MakeItem (Item & x, Object y)
{
long r;
x.mode = y->Class;
x.type = y->type;
x.lev = y->lev;
x.a = y->val;
if (y->lev == 0)
ComPort – Compilador Portugol
90

}
x.r = 0;
else if (y->lev == curlev)
x.r = FP;
else
{
Mark ("level!");
x.r = 0;
}
if (y->Class == Par)
{
GetReg (r);
Put (LDW, r, x.r, x.a);
x.mode = Var;
x.r = r;
x.a = 0;
}
void
Field (Item & x, Object & y)
{
x.a += y->val;
x.type = y->type;
}
void
Index (Item & x, Item & y)
{
if (y.type != intType)
Mark ("index not integer");
if (y.mode == Const)
{
if (y.a < 0 || y.a >= x.type->len)
Mark ("bad index");
x.a += y.a * x.type->base->size;
}
else
{
if (y.mode != Reg)
load (y);
Put (CHKI, y.r, 0, x.type->len);
Put (MULI, y.r, y.r, x.type->base->size);
if (x.r != 0)
{
Put (ADD, y.r, x.r, y.r);
EXCL (regs, x.r);
}
x.r = y.r;
}
x.type = x.type->base;
}
void
Op1 (int op, Item & x)
{
long t;
if (op == MENOS)
{
if (x.type->form != Integer)
Mark ("bad type");
else
ComPort – Compilador Portugol
91

}
{
}
if (x.mode == Const)
x.a = -x.a;
else
{
if (x.mode == Var)
load (x);
Put (SUB, x.r, 0, x.r);
}
}
else
{
if (op == NAO)
{
if (x.mode != Cond)
loadBool (x);
x.c = negated (x.c);
t = x.a;
x.a = x.b;
x.b = t;
}
else
{
if (op == E)
{
if (x.mode != Cond)
loadBool (x);
Put (BEQ + negated (x.c), x.r, 0, x.a);
EXCL (regs, x.r);
x.a = pc - 1;
FixLink (x.b);
x.b = 0;
}
else
{
if (op == OU)
{
if (x.mode != Cond)
loadBool (x);
Put (BEQ + x.c, x.r, 0, x.b);
EXCL (regs, x.r);
x.b = pc - 1;
FixLink (x.a);
x.a - 0;
}
}
}
}
void
Op2 (int op, Item & x, Item & y)
{
if (x.type->form == Integer && y.type->form == Integer)
{
if (x.mode == Const && y.mode == Const)
ComPort – Compilador Portugol
92

}
{
if (op == MAIS)
x.a += y.a;
else if (op == MENOS)
x.a -= y.a;
else if (op == MULTIPLICACAO)
x.a *= y.a;
else if (op == DIVISAO)
x.a /= y.a;
else if (op == RESTO)
x.a %= y.a;
else
Mark ("bad type");
}
else
{
if (op == MAIS)
PutOp (ADD, x, y);
else if (op == MENOS)
PutOp (SUB, x, y);
else if (op == MULTIPLICACAO)
PutOp (MUL, x, y);
else if (op == DIVISAO)
PutOp (DIV, x, y);
else if (op == RESTO)
PutOp (MOD, x, y);
else
Mark ("bad type");
}
}
else
{
if (x.type->form == Boolean && y.type->form == Boolean)
{
if (y.mode != Cond)
loadBool (y);
if (op == OU)
{
x.a = y.a;
x.b = merged (y.b, x.b);
x.c = y.c;
}
else
{
if (op == E)
{
x.a = merged (y.a, x.a);
x.b = y.b;
x.c = y.c;
}
}
}
else
Mark ("bad type");
}
void
Relation (int op, Item & x, Item & y)
{
ComPort – Compilador Portugol
93

}
ComPort – Compilador Portugol
if (x.type->form != Integer || y.type->form != Integer)
Mark ("bad type");
else
{
if (y.mode == Const && y.a == 0)
load (x);
else
PutOp (CMP, x, y);
x.c = op - IGUAL; // Revisar esta construção misteriosa!!!
EXCL (regs, y.r);
}
x.mode = Cond;
x.type = boolType;
x.a = 0;
x.b = 0;
void
Store (Item & x, Item & y)
{
long r;
if ((x.type->form == Boolean || x.type->form == Integer) &&
x.type->form == y.type->form)
{
if (y.mode == Cond)
{
Put (BEQ + negated (y.c), y.r, 0, y.a);
EXCL (regs, y.r);
y.a = pc - 1;
FixLink (y.b);
GetReg (y.r);
Put (ADDI, y.r, 0, 1);
Put (BEQ, 0, 0, 2);
FixLink (y.a);
Put (ADDI, y.r, 0, 0);
}
else
{
if (y.mode != Reg)
load (y);
}
if (x.mode == Var)
{
if (x.lev == 0)
{
rel[relx] = SHORT (pc);
relx++;
}
Put (STW, y.r, x.r, x.a);
}
else
Mark ("illegal assignment");
EXCL (regs, x.r);
EXCL (regs, y.r);
}
else
Mark ("incompatible assignment");
}
void
Parameter (Item & x, Type & ftyp, int Class)
94

{
}
long r;
if (x.type == ftyp)
{
if (Class == Par)
{
if (x.mode == Var)
{
if (x.a != 0)
{
if (x.lev != 0)
{
rel[relx] = SHORT (pc);
relx++;
}
GetReg (r);
Put (ADDI, r, x.r, x.a);
}
else
r = x.r;
}
else
Mark ("illegal parameter mode");
Put (PSH, r, SP, 4);
EXCL (regs, r);
}
else
{
if (x.mode != Reg)
load (x);
Put (PSH, x.r, SP, 4);
EXCL (regs, x.r);
}
}
else
Mark ("bad parameter type");
void
CJump (Item & x)
{
if (x.type->form == Boolean)
{
if (x.mode != Cond)
loadBool (x);
Put (BEQ + negated (x.c), x.r, 0, x.a);
EXCL (regs, x.r);
FixLink (x.b);
x.a = pc - 1;
}
else
{
Mark ("Boolean?");
x.a = pc;
}
}
void
BJump (long L)
{
Put (BEQ, 0, 0, L - pc);
ComPort – Compilador Portugol
95

}
void
FJump (long &L)
{
Put (BEQ, 0, 0, L);
L = pc - 1;
}
void
Call (Item & x)
{
Put (BSR, 0, 0, x.a - pc);
}
void
IOCall (Item & x, Item & y)
{
Item z;
if (x.a < 4)
{
if (y.type->form != Integer)
Mark ("Integer?");
}
}
if (x.a == 1)
{
GetReg (z.r);
z.mode = Reg;
z.type = intType;
Put (RD, z.r, 0, 0);
Store (y, z);
}
else
{
if (x.a == 2)
{
load (y);
Put (WRD, 0, 0, y.r);
EXCL (regs, y.r);
}
else
{
if (x.a == 3)
{
load (y);
Put (WRH, 0, 0, y.r);
EXCL (regs, y.r);
}
else
Put (WRL, 0, 0, 0);
}
}
void
Header (long size)
{
entry = pc;
Put (ADDI, SP, 0, MemSize - size);
Put (PSH, LNK, SP, 4);
ComPort – Compilador Portugol
96

}
void
Enter (long size)
{
Put (PSH, LNK, SP, 4);
Put (PSH, FP, SP, 4);
Put (ADD, FP, 0, SP);
Put (SUBI, SP, SP, size);
}
void
Return (long size)
{
Put (ADD, SP, 0, FP);
Put (POP, FP, SP, 4);
Put (POP, LNK, SP, size + 4);
Put (RET, 0, 0, LNK);
}
void
Open (void)
{
curlev = 0;
pc = 0;
relx = 0;
ClearReg ();
}
void
Close (FILE * S, long globals)
{
Put (POP, LNK, SP, 4);
Put (RET, 0, 0, LNK);
}
void
EnterCmd (char *name)
{
strcpy (name, comname[cno]);
comadr[cno] = pc * 4;
cno++;
}
ComPort – Compilador Portugol
void
Load (FILE * S)
{
long i = 0L, k;
while (i < relx)
{
k = rel[i++];
code[k] = (code[k] / 0x10000 * 0x10000) + (code[k] + MemSize) %
0x10000;
}
RISC.Load (code, pc);
fprintf (W, " code loaded\n");
RISC.Execute (entry * 4, S, stderr);
}
void
97

Exec (FILE * S)
{
int i = 0;
//NILO: traduzir a pesquisa
//Carrega o nome e endereco das procedures
// while(i 0x8000)
a -= 0x10000;
fprintf (W, "%4d\t%s\t%4d,%4d,%8d\n",
4 * i,
mnemo[cd / 0x4000000 % 0x40],
cd / 0x200000 % 0x20, cd / 0x10000 % 0x20, a);
i++;
}
fprintf (W, "reloc\n");
i = 0;
while (i < relx)
{
fprintf (W, "%5d", rel[i++] * 4);
if (i % 16 == 0)
fprintf (W, "\n");
}
fprintf (W, "\n");
// Concatena a saída de W em T ...
}
void
mainCodeGenerator (void)
{
boolType = new TypeDesc;
boolType->form = Boolean;
boolType->size = 4;
intType = new TypeDesc;
intType->form = Integer;
intType->size = 4;
litType = new TypeDesc;
litType->form = Literal;
litType->size = 8;
strcpy (mnemo[ADD], "ADD ");
strcpy (mnemo[SUB], "SUB ");
strcpy (mnemo[MUL], "MUL ");
strcpy (mnemo[DIV], "DIV ");
strcpy (mnemo[MOD], "MOD ");
strcpy (mnemo[CMP], "CMP ");
ComPort – Compilador Portugol
98

}
strcpy (mnemo[OR], "OR ");
strcpy (mnemo[AND], "AND ");
strcpy (mnemo[BIC], "BIC ");
strcpy (mnemo[XOR], "XOR ");
strcpy (mnemo[LSH], "LSH ");
strcpy (mnemo[ASH1], "ASH ");
strcpy (mnemo[CHK], "CHK ");
strcpy (mnemo[ADDI], "ADDI");
strcpy (mnemo[SUBI], "SUBI");
strcpy (mnemo[MULI], "MULI");
strcpy (mnemo[DIVI], "DIVI");
strcpy (mnemo[MODI], "CMPI");
strcpy (mnemo[CMPI], "MODI");
strcpy (mnemo[ORI], "ORI ");
strcpy (mnemo[ANDI], "ANDI");
strcpy (mnemo[BICI], "BICI");
strcpy (mnemo[XORI], "XORI");
strcpy (mnemo[LSHI], "LSHI");
strcpy (mnemo[ASHI], "ASHI");
strcpy (mnemo[CHKI], "CHKI");
strcpy (mnemo[LDW], "LDW ");
strcpy (mnemo[LDB], "LDB ");
strcpy (mnemo[POP], "POP ");
strcpy (mnemo[STW], "STW ");
strcpy (mnemo[STB], "STB ");
strcpy (mnemo[PSH], "PSH ");
strcpy (mnemo[BEQ], "BEQ ");
strcpy (mnemo[BNE], "BNE ");
strcpy (mnemo[BLT], "BLT ");
strcpy (mnemo[BGE], "BGE ");
strcpy (mnemo[BLE], "BLE ");
strcpy (mnemo[BGT], "BGT ");
strcpy (mnemo[BSR], "BSR ");
strcpy (mnemo[JSR], "JSR ");
strcpy (mnemo[RET], "RET ");
strcpy (mnemo[RD], "READ");
strcpy (mnemo[WRD], "WRD ");
strcpy (mnemo[WRH], "WRH ");
strcpy (mnemo[WRL], "WRL ");
ComPort – Compilador Portugol
99

FUNCOES.H
#ifndef IFUNCOES
#define IFUNCOES
#define MAX_ELEM_CJ 128
#ifndef FUNCOES
extern char minusculaC(char texto);
extern void minusculaS(char *texto);
extern long fASH (long R, long c);
extern long fLSH (long R, long c);
extern long SHORT (long x);
extern int ODD (long x);
extern bool PertenceConjunto(char *a, int elemento);
extern void AdicionaConjunto(char *a, int elemento);
extern void CriaConjunto(char *a);
#endif
#endif
ComPort – Compilador Portugol
100

FUNCOES.CPP
#include
#include
#define FUNCOES
#include "funcoes.h"
long
fASH (long R, long c)
{
long t, s;
const m = (1 = 0)
for (; c >= 0; c--)
t = 1;
t = (t & !m) + s;
return (t);
}
long
fLSH (long R, long c)
{
long t;
t = R;
if (c >= 0)
for (; c >= 0; c--)
t = t > 1;
return (t);
}
int
ODD (long x)
{
return ((1 & x));
}
int
SHORT (long x)
{
return ((0xFFFF & x));
}
char minusculaC(char texto)
{
char minus[] = "áéíóúâêîôûäëïöüÿãõàèìòùñç";
char maius[] = "ÁÉÍÓÚÂÊÎÔÛÄËÏÖÜYÃÕÀÈÌÒÙÑÇ";
char *c;
if(texto>='A' && texto

}
else {
c = strchr(maius, texto);
if(c)
texto=minus[c-maius];
}
return texto;
void minusculaS(char *texto)
{
int i;
char *c;
for (i=0; texto[i]!=0;i++)
texto[i] = minusculaC(texto[i]);
}
void CriaConjunto(char *a)
{
memset(a, MAX_ELEM_CJ, 0);
}
void AdicionaConjunto(char *a, int elemento)
{
a[elemento]=1;
}
bool PertenceConjunto(char *a, int elemento)
{
return(a[elemento]==1);
}
ComPort – Compilador Portugol
102

RISC.H
#ifndef IRISC
#define IRISC
#define MemSize 4096
class TRisc
{
public:
long PC, IR, R[32], M[MemSize / 4];
void Execute (long pc0, FILE * in, FILE * out);
void Load (long code[], long len);
void State ();
};
extern TRisc RISC;
#endif
ComPort – Compilador Portugol
103

RISC.CPP
ComPort – Compilador Portugol
/*
*
* Módulo RISC - Interpretador de código Universidade do Amazonas Comport
* - Compilador Portugol Aluno: Nilo Ney Coutinho Menezes
*
* Baseado no compilador Oberon-0 de Niklaus Wirth
*
*/
#include
#include
#include
#include "instrucoes.h"
#include "risc.h"
#include "funcoes.h"
void
TRisc::Execute (long pc0, FILE * in, FILE * out)
{
long opc, a, b, c, nxt;
int ii;
R[31] = 0;
PC = pc0 / 4;
do
{
R[0] = 0;
nxt = PC + 1;
IR = M[PC];
opc = (IR / 0x4000000) % 0x40;
a = (IR / 0x200000) % 0x20;
b = (IR / 0x10000) % 0x20;
c = (IR % 0x10000);
if (opc < ADDI)
c = R[c % 0x20];
else
{
if (c > 0x8000)
c -= 0x10000;
}
switch (opc)
{
case ADD:
case ADDI:
R[a] = R[b] + c;
break;
case SUB:
case SUBI:
case CMP:
case CMPI:
R[a] = R[b] - c;
break;
case MUL:
case MULI:
104

ComPort – Compilador Portugol
R[a] = R[b] * c;
break;
case DIV:
case DIVI:
R[a] = R[b] / c;
break;
case MOD:
case MODI:
R[a] = R[b] % c;
break;
case OR:
case ORI:
R[a] = R[b] | c;
break;
case AND:
case ANDI:
R[a] = R[b] & c;
break;
case BIC:
case BICI:
R[a] = R[b] & !c;
break;
case XOR:
case XORI:
R[a] = R[b] ^ c;
break;
case LSH:
case LSHI:
fLSH (R[b], c);
break;
case ASH1:
case ASHI:
R[a] = fASH (R[b], c);
break;
case CHK:
case CHKI:
if (R[a] < 0 || R[a] > c)
{
fprintf (stderr, "Trap at %d\n", PC);
return;
}
break;
case LDW:
R[a] = M[(R[b] + c) / 4];
break;
case LDB:
R[a] = fLSH (M[(R[b] + c) / 4], (R[b] + c) / 4 * 8) % 0x100;
break;
case POP:
R[a] = M[R[b] / 4];
R[b] += c;
break;
case STW:
M[(R[b] + c) / 4] = R[a];
break;
case STB:
break; // Não implementado
case PSH:
R[b] -= c;
M[(R[b] / 4)] = R[a];
break;
105

}
case BEQ:
if (R[a] == R[b])
nxt = PC + c;
break;
case BNE:
if (R[a] != R[b])
nxt = PC + c;
break;
case BLT:
if (R[a] < R[b])
nxt = PC + c;
break;
case BGE:
if (R[a] >= R[b])
nxt = PC + c;
break;
case BLE:
if (R[a] R[b])
nxt = PC + c;
break;
case BSR:
nxt = PC + c;
R[31] = (PC + 1) * 4;
break;
case JSR:
nxt = IR % 0x4000000;
R[31] = (PC + 1) * 4;
break;
case RET:
nxt = R[c % 0x20] / 4;
if (nxt == 0)
return;
break;
case RD:
fscanf (in, "%d", &ii);
R[a] = ii;
break;
case WRD:
fprintf (stdout, " %d", R[c]);
break;
case WRH:
fprintf (stdout, "%x", R[c]);
break;
case WRL:
fprintf (stdout, "\n");
break;
}
PC = nxt;
}
while (1);
void
TRisc::Load (long code[], long len)
{
int i;
ComPort – Compilador Portugol
106

}
for (i = 0; i < len; i++)
M[i] = code[i];
void
TRisc::State ()
{
fprintf (stderr, "PC=%d\n", PC * 4);
fprintf (stderr, "SP=%d\n", R[30]);
fprintf (stderr, "FP=%d\n", R[29]);
fprintf (stderr, "R1=%d\n", R[1]);
fprintf (stderr, "R2=%d\n", R[2]);
fprintf (stderr, "R3=%d\n", R[3]);
fprintf (stderr, "R4=%d\n", R[4]);
}
ComPort – Compilador Portugol
107

INSTRUCOES.H
// Instruções
#define ADD 0
#define SUB 1
#define MUL 2
#define DIV 3
#define MOD 4
#define CMP 5
#define OR 8
#define AND 9
#define BIC 10
#define XOR 11
#define LSH 12
#define ASH1 13
#define CHK 14
#define ADDI 16
#define SUBI 17
#define MULI 18
#define DIVI 19
#define MODI 20
#define CMPI 21
#define ORI 24
#define ANDI 25
#define BICI 26
#define XORI 27
#define LSHI 28
#define ASHI 29
#define CHKI 30
#define LDW 32
#define LDB 33
#define POP 34
#define STW 36
#define STB 37
#define PSH 38
#define BEQ 40
#define BNE 41
#define BLT 42
#define BGE 43
#define BLE 44
#define BGT 45
#define BSR 46
#define JSR 48
#define RET 49
#define RD 50
#define WRD 51
#define WRH 52
#define WRL 53
ComPort – Compilador Portugol
108

PRINCIPAL.CPP
#include
#include
#include
// extern void mainScanner(void);
// extern void mainCodeGenerator(void);
#include "scanner.h"
#include "codegenerator.h"
#include "risc.h"
#include "parser.h"
#define VERSAO "0.92"
#define DATA "2003-09-06"
TRisc RISC;
int
main (int argc, char **argv)
{
FILE *FONTE;
spawnl(P_WAIT, "pagina.bat", "pagina.bat","1252",NULL);
}
mainScanner ();
mainCodeGenerator ();
mainParser ();
ComPort – Compilador Portugol
if(argc==2)
{
FONTE = fopen(argv[1],"r");
if(FONTE==NULL)
{
fprintf(stderr, "Erro ao abrir arquivo fonte!! [%s]\n", argv[1]);
exit(1);
}
}
else
{
FONTE=stdin;
fprintf(stderr, "Lendo fonte da entrada padrão [stdin]\n");
}
Compile (FONTE);
// Pausa para manter a janela aberta (tecla para terminar)
fgetc(stdin);
109

MAKEFILE
ComPort – Compilador Portugol
# -------------------------------------------------------------------------
--
!if !$d(BCB)
BCB = $(MAKEDIR)\..
!endif
# -------------------------------------------------------------------------
--
# IDE SECTION
# -------------------------------------------------------------------------
--
# The following section of the project makefile is managed by the BCB IDE.
# It is recommended to use the IDE to change any of the values in this
# section.
# -------------------------------------------------------------------------
--
VERSION = BCB.06.00
# -------------------------------------------------------------------------
--
PROJECT = portugol.exe
OBJFILES = scanner.obj parser.obj risc.obj codegenerator.obj funcoes.obj
principal.obj
RESFILES =
MAINSOURCE = portugol.bpf
RESDEPEN = $(RESFILES)
LIBFILES =
IDLFILES =
IDLGENFILES =
LIBRARIES =
PACKAGES = dbrtl.bpi vcldb.bpi adortl.bpi ibsmp.bpi bdertl.bpi vcldbx.bpi
qrpt.bpi \
teeui.bpi teedb.bpi tee.bpi dss.bpi teeqr.bpi ibxpress.bpi dsnap.bpi \
vclie.bpi inetdb.bpi inet.bpi nmfast.bpi webdsnap.bpi bcbie.bpi \
bcb2kaxserver.bpi
SPARELIBS =
DEFFILE =
OTHERFILES =
# -------------------------------------------------------------------------
--
DEBUGLIBPATH = $(BCB)\lib\debug
RELEASELIBPATH = $(BCB)\lib\release
USERDEFINES = _DEBUG;PRINCIPAL
SYSDEFINES = NO_STRICT;_NO_VCL
INCLUDEPATH = $(BCB)\include;$(BCB)\include\vcl
LIBPATH = $(BCB)\lib\obj;$(BCB)\lib
WARNINGS= -w-par
PATHCPP = .;
PATHASM = .;
PATHPAS = .;
PATHRC = .;
PATHOBJ = .;$(LIBPATH)
# -------------------------------------------------------------------------
--
110

ComPort – Compilador Portugol
CFLAG1 = -Od -H=c:\ARQUIV~1\borland\CBUILD~1\lib\vcl60.csm -Hc -Q -Vx -X- -
A -r- \
-a8 -6 -b- -k -y -v -vi- -tWC -tWM- -c
IDLCFLAGS = -src_suffix cpp -D_DEBUG -DPRINCIPAL -I$(BCB)\include -
I$(BCB)\include\vcl \
-boa
PFLAGS = -$YD -$W -$O- -$A8 -v -JPHNE -M
RFLAGS =
AFLAGS = /mx /w2 /zi
LFLAGS = -D"" -ap -Tpe -x -Gn -v
# -------------------------------------------------------------------------
--
ALLOBJ = c0x32.obj $(OBJFILES)
ALLRES = $(RESFILES)
ALLLIB = $(LIBFILES) $(LIBRARIES) import32.lib cw32.lib
# -------------------------------------------------------------------------
--
!ifdef IDEOPTIONS
[Version Info]
IncludeVerInfo=0
AutoIncBuild=0
MajorVer=1
MinorVer=0
Release=0
Build=0
Debug=0
PreRelease=0
Special=0
Private=0
DLL=0
[Version Info Keys]
CompanyName=
FileDescription=
FileVersion=1.0.0.0
InternalName=
LegalCopyright=
LegalTrademarks=
OriginalFilename=
ProductName=
ProductVersion=1.0.0.0
Comments=
[Debugging]
DebugSourceDirs=$(BCB)\source\vcl
!endif
# -------------------------------------------------------------------------
--
# MAKE SECTION
# -------------------------------------------------------------------------
--
# This section of the project file is not used by the BCB IDE. It is for
# the benefit of building from the command-line using the MAKE utility.
111

ComPort – Compilador Portugol
# -------------------------------------------------------------------------
--
.autodepend
# -------------------------------------------------------------------------
--
!if "$(USERDEFINES)" != ""
AUSERDEFINES = -d$(USERDEFINES:;= -d)
!else
AUSERDEFINES =
!endif
!if !$d(BCC32)
BCC32 = bcc32
!endif
!if !$d(CPP32)
CPP32 = cpp32
!endif
!if !$d(DCC32)
DCC32 = dcc32
!endif
!if !$d(TASM32)
TASM32 = tasm32
!endif
!if !$d(LINKER)
LINKER = ilink32
!endif
!if !$d(BRCC32)
BRCC32 = brcc32
!endif
# -------------------------------------------------------------------------
--
!if $d(PATHCPP)
.PATH.CPP = $(PATHCPP)
.PATH.C = $(PATHCPP)
!endif
!if $d(PATHPAS)
.PATH.PAS = $(PATHPAS)
!endif
!if $d(PATHASM)
.PATH.ASM = $(PATHASM)
!endif
!if $d(PATHRC)
.PATH.RC = $(PATHRC)
!endif
!if $d(PATHOBJ)
.PATH.OBJ = $(PATHOBJ)
!endif
# -------------------------------------------------------------------------
--
112

ComPort – Compilador Portugol
$(PROJECT): $(OTHERFILES) $(IDLGENFILES) $(OBJFILES) $(RESDEPEN) $(DEFFILE)
$(BCB)\BIN\$(LINKER) @&&!
$(LFLAGS) -L$(LIBPATH) +
$(ALLOBJ), +
$(PROJECT),, +
$(ALLLIB), +
$(DEFFILE), +
$(ALLRES)
!
# -------------------------------------------------------------------------
--
.pas.hpp:
$(BCB)\BIN\$(DCC32) $(PFLAGS) -U$(INCLUDEPATH) -
D$(USERDEFINES);$(SYSDEFINES) -O$(INCLUDEPATH) --BCB {$< }
.pas.obj:
$(BCB)\BIN\$(DCC32) $(PFLAGS) -U$(INCLUDEPATH) -
D$(USERDEFINES);$(SYSDEFINES) -O$(INCLUDEPATH) --BCB {$< }
.cpp.obj:
$(BCB)\BIN\$(BCC32) $(CFLAG1) $(WARNINGS) -I$(INCLUDEPATH) -
D$(USERDEFINES);$(SYSDEFINES) -n$(@D) {$< }
.c.obj:
$(BCB)\BIN\$(BCC32) $(CFLAG1) $(WARNINGS) -I$(INCLUDEPATH) -
D$(USERDEFINES);$(SYSDEFINES) -n$(@D) {$< }
.c.i:
$(BCB)\BIN\$(CPP32) $(CFLAG1) $(WARNINGS) -I$(INCLUDEPATH) -
D$(USERDEFINES);$(SYSDEFINES) -n. {$< }
.cpp.i:
$(BCB)\BIN\$(CPP32) $(CFLAG1) $(WARNINGS) -I$(INCLUDEPATH) -
D$(USERDEFINES);$(SYSDEFINES) -n. {$< }
.asm.obj:
$(BCB)\BIN\$(TASM32) $(AFLAGS) -i$(INCLUDEPATH:;= -i) $(AUSERDEFINES) -
d$(SYSDEFINES:;= -d) $

APENDICE B – TABELA ASCII
ComPort – Compilador Portugol
114

ComPort – Compilador Portugol
APENDICE C – OPCODES DA MÁQUINA VIRTUAL
Tipo da
Instrução/opcode
Transferência de
dados
LB, LBU, SB
LH, LHU, SH
LW, SW
LF, LD, SF, SD
MOVI2S, MOVS2I
MOVF, MOVD
MOVFP2I, MOVI2FP
Aritmético/Lógico
ADD, ADDI, ADDU,
ADDUI
SUB, SUBI, SUBU,
SUBUI
Significado
Movimentação de dados entre os registradores e
a memória ou entre um registrador inteiro, de
ponto flutuante ou de propósito especial. Só há
uma forma de endereçamento: deslocamento de
16 bits + o valor de um registrador de uso geral.
Carrega byte, carrega byte sem sinal e armazena
byte
Carrega meia-palavra, carrega meia-palavra sem
sinal, armazena meia palavra
Carrega palavra, armazena palavra (de/para)
registradores inteiros
Carrega número de ponto flutuante de precisão
simples, carrega número de ponto flutuante de
precisão dupla, armazena número de ponto
flutuante de precisão simples, armazena número
de ponto flutuante de precisão dupla
Move de ou para um registrador de uso geral de
ou para um registrador de uso especial
Copia um registrador de ponto flutuante ou um
para de dupla precisão para outro registrador ou
par.
Move 32 bits de/para um registrador de ponto
flutuante de/para um registrador inteiro
Operações em inteiros ou tipos lógicos em
registros de uso geral. Operações aritméticas
com sinalsetam o trap em caso de overflow
Adiciona, adiciona com constante (16 bits); com
sinal e sem.
Subtraia, subtraia com constante (16 bits); com e
sem sinal
MULT, MULTU, DIV, Multiplique e divida, com e sem sinal
115

ComPort – Compilador Portugol
DIVU paraoperadores de ponto flutuante. Todas as
operações com valores de 32-bits
AND, ANDI E lógico e E lógico com constante
OR, ORI, XOP, XOPI
LHI
SLL, SRL, SRA,
SLLI, SRLI, SRAI
S__, S__I
Controle
BEQZ, BNEZ
BFPT, BFPF
J, JR
JAL, JALR
TRAP
RFE
Ponto Flutuante
Ou, Ou com constante, Ou exclusivo e Ou
exclusive com constante
Carrega a metade superior de um registro com
uma constante
Deslocamentos: com constante (S__I) ou com
variável (S__); deslocamentos a esquerda lógico,
a direita lógico e a direita aritmético
Marca se condição: "__" pode ser LT, GT, LE, GE,
EQ, NE (menor, maior, menor ou igual, maior ou
igual, igual, não igual)
Saltos condicionais e desvios. Relativos ao PC
(program counter) ou através de registrador
Salta se o registrador é igual ou diferente a zero.
Deslocamento de 16 bits a partir do PC
Testa o bit de comparação do registrador de
status FP e salta (16 bits a partir do PC)
Salta a partir do PC com deslocamento de 26 bits
ou para endereço no registrador (JR)
Salta e marca retorno: salva PC+4 no R31. O
endereço destino é relative a PC(JAL) ou a um
registro (JALR)
Transfere a execução para o sistema operacional
num endereço armazenado em um vetor
Retorna para o código do usuário de uma
exceção. Retorna a execução para o código do
usuário.
Operações de ponto flutuante em dupla
precisão (DP) ou precisão simples (SP)
ADDD, ADDF Soma números de DP, SP
SUBD, SUBF Subtrai números de DP, SP
MULTD, MULTF Multiplica números de DP, SP
DIVD, DIVF Divide números de DP, SP
CVTF2D, CVTF2I, Instruções de converção: CVTx2y converte do tipo
116

CVTD2F,
CVTD2I, CVTI2F,
CVTI2D
__D, __F
ComPort – Compilador Portugol
x para o tipo y, onde x e y podem ser I para
inteiro, D para precisão dupla e F para simples
precisão. Ambos operandos devem estar em
registradores FP.
Compara números de DP e SP compares: "__"
pode ser LT, GT, LE, GE, EQ, NE(menor, maior,
menor ou igual, maior ou igual, igual, não igual);
Ativa o bit de comparação no registrador de status
FP.
117

ComPort – Compilador Portugol
APENDICE D – EMENTAS DE CURSOS DE COMPILAÇÃO
DE OUTRAS UNIVERSIDADES
Instituição: UNESP
URL: http://www.dcce.ibilce.unesp.br/comp/alldisc.html
Disciplina: Construção de Compiladores
Pré requisito: Fundamentos em Linguagens e Teoria da Computação e Autorização
do Coordenador do Curso
Ementa: Estudo dos componentes de um compilador, com o projeto de um
compilador para uma linguagem simples, incluíndo os módulos de análise léxica,
sintática e semântica, além do gerador de código e otimizador.
Instituição: UFMG
URL: http://www.dcc.ufmg.br/~mariza/Cursos/Compiladores/Comp2001-2/Prog2001-
2/comp_txt.html
Disciplina: Compiladores
Pré-Requisitos: Esta disciplina é oferecida aos alunos do sexto período do
Bacharelado em Ciência da Computação da UFMG. Os pré-requisitos da disciplina
são: Algoritmos e Estruturas de Dados I, Algoritmos e Estruturas de Dados II e
Fundamentos da Teoria da Computação.
Programa do Curso: O objetivo da disciplina é ensinar técnicas básicas de
construção de compiladores e conceitos relacionados com linguagens de
programação. A matéria apresentada tem aplicação não somente em projeto de
linguagens de programação, mas é também importante para a compreensão e
implementação de interfaces que tornem mais natural a comunicação
homem/máquina. Concluindo o curso, os alunos deverão ser capazes de definir a
gramática de uma linguagem e programar seu compilador ou interpretador.
Ementa: Gramáticas. Análise léxica. Análise sintática. Tabela de símbolos.
Linguagens intermediárias. Alocação de memória em tempo de execução. Tradução
dirigida por sintaxe.
118

ComPort – Compilador Portugol
Instituição: UFMG - Pós-graduação
URL: http://www.dcc.ufmg.br/pos/html/node5.html
Disciplina: Linguagens de Programação e Compiladores
Ementa: Compiladores, Teoria de Linguagens, Semântica Formal, Tópicos em
Compiladores, Tópicos em Linguagens de Programação.
Instituição: Centro Universitário Feevale
URL: http://www.feevale.tche.br/graduacao/icet/cico/ementa.htm#compiladores-B
Disciplina: Compiladores.
Ementa: Organização e estrutura de compiladores e interpretadores. Análise léxica.
Análise sintática. Alocação e gerência de memória. Formas internas de programa
fonte. Análise semântica. Geração de código. Optimização de código.
Instituição: Universidade Estadual Vale do Acaraú - Sobral/CE
URL: http://uvanet.br/computacao/ementa.php
Curso: Bacharelado em Ciências da Computação
Disciplina: Compiladores
Ementa: Organização de um compilador. Tabela de símbolos durante a compilação
e execução. Varredura Léxica. Varredura Sintática. Geração de código objeto.
Otimização e Recuperação de Erros. Linguagens para escrever compiladores.
Instituição: Universidade Estadual de Ponta Grossa
URL: http://www.deinfo.uepg.br/ementas.html
Disciplina: Compiladores
Ementa: Estrutura lógica dos compiladores. Fases de análise e síntese. Obtenção de
compiladores. Teoria das linguagens. Gramáticas formais. Autômatos finitos
determinísticos e não determinísticos. Reconhecedores léxicos. Autômatos de pilha.
Reconhecedores sintáticos. Geração e otimização de código. Projeto de um
compilador.
Instituição: Pontifícia Unive rsidade Católica do Rio Grande do Sul
URL: http://pucrs.campus2.br/faci/info/5/
Disciplina: Compiladores I
119

ComPort – Compilador Portugol
Objetivos: O cumprimento da disciplina busca dar ao aluno, ao final do semestre,
capacidade de: Descrever, formalmente, os componentes de um compilador;
Projetar linguagens de programação; Elaborar rotinas para análise lexicográfica,
gerenciamento de tabelas de símbolos e análise sintática; Projetar compiladores.
Ementa: Tradução e compilação, etapas da compilação. Análise léxica: tabelas de
símbolos. Análise sintática: construção e geração de analisadores, precedência de
operadores, LR. Tradução dirigida à sintaxe: translação, definições, gramáticas de
atributos. Análise semântica estática: verificação de tipos, escopo, equivalência e
compatibilidade, coerção, sobrecarga e polimorfismo.
Programa: Introdução à Compilação, Introdução: Fases de um compilador, Fase de
Análise, Fase de Síntese, Tabela de Símbolos, Detecção de erros, Análise Léxica,
Funções de Analisador Léxico, A relação: Analisadores Léxicos X Autômatos Finitos
X Expressões Regulares, Implementação de Analisadores Léxicos, Tabela de
símbolos, Ferramentas para construção de Analisadores Léxicos, Análise Sintática,
Funções de Analisador Sintático, A relação: Analisadores Sintáticos X Gramáticas
Livres de Contexto, Analisadores Sintáticos Descendentes, Analisador Preditivo,
Analisador Sintático Descendente Recursivo, Analisadores Sintáticos Ascendentes,
Precedência de Operadores, Técnicas LR, Ferramentas para construção de
Analisadores Sintáticos, Tradução dirigida por Sintaxe, Introdução a Tradução
Dirigida por Sintaxe, Definição Dirigida pos Sintaxe, Esquemas de Tradução,
Verificação Semântica, Sistemas de tipos, Sub-linguagem de tipos genérica,
Verificação de tipos estática X dinâmica, Verificação de tipos simples: expressões e
comandos, Equivalência de tipos, Coerção, Sobrecarga, Polimorfismo.
Instituição: Universidade do Planalto Catarinense - UNIPLAC
URL: http://www.uniplac.rct-sc.br/Ensino/Informatica/ementa_biblio_.htm
Disciplina: Compiladores
Ementa: Análise Léxica e Sintática. Tabelas de Símbolos. Esquemas de Tradução.
Ambientes de Tempo de Execução. Linguagens intermediárias. Geração de Código.
Otimização de Código. Montadores. Ligadores.
Sociedade Brasileira de Computação
120

ComPort – Compilador Portugol
URL:http://www.sbc.org.br/notitia/servlet/newstorm.notitia.apresentacao.ServletDeNo
ticia?codigoDaNoticia=38&dataDoJornal=atual
Currículo de Referência da SBC para Cursos de Graduação em Computação e
Informática
Disciplina: Compiladores
Ementa: Análise léxica e sintática. Tabelas de símbolos. Esquemas de tradução.
Ambientes de tempo de execução. Linguagens intermediárias. Geração de código.
Otimização de código. Montadores, ligadores.
Instituição: PUC-Minas
URL: http://www.inf.pucminas.br/dcc/bh/disciplinas/cmpl.html
Curso: Ciência da Computação
Disciplina: Compiladores
Objetivos: preparar o aluno para entender o processo de compilação no que tange
aos seus processos internos nos métodos de análise léxica, sintática e semântica,
com o objetivo de otimizar o projeto de sistemas e detalhamento de programas, e
para iniciar o aluno no processo de construção de um compilador.
Ementa: análise léxica, sintática e semântica, geração de código
Instituição: Universidade Federal de Goiás
URL: http://www.inf.ufg.br/~cedric/comp.html
Disciplina: Compiladores
Ementa: O processo de compilação. Análise léxica. O analisador léxico como um
autômato finito. Análise sintática Ascendente e descendente. Tabelas de símbolos:
estruturas de blocos. Análise de contexto e geração de código. Recuperação de
erros. Implementação de um compilador para uma linguagem de alto nível.
Instituição: Universidade Federal de Mato Grosso do Sul
URL: http://www.ufms.br/ensino/grad/ccet/ccomp/ementa.htm
Curso: Ciência da Computação
Disciplina: Compiladores
Ementa: Introdução à compilação. Análise léxica. Análise sintática. Tradução dirigida
por sintaxe. Checagem de tipos. Ambiente de execução. Geração de código
121

ComPort – Compilador Portugol
intermediário. Geração de código. Otimização de código. A construção de um
compilador.
Instituição: Universidade Tiradentes - Sergipe
URL: http://www.unit.br/graduacao/sistemas_de_informacao/ementasgrade2000.htm
Disciplina: Linguagens Formais e Compiladores
Ementa: Gramáticas e Autômatos. Gramáticas Livres de Contexto e Autômatos a
Pilha. Gramáticas Irrestritas e Sensíveis ao contexto. Introdução à Arquitetura de
Compiladores. Análise Léxica, Sintática e Semântica. Geração de Código
Intermediário. Otimização e Geração de Código.
Instituição: Universidade Federal de Uberlândia
URL: http://www.feelt.ufu.br/graduacao/ementas/ELT81.htm
Disciplina: Construção de Compiladores 1
Objetivo: Apresentar noções da teoria de Linguagens Formais e Automáticas.
Capacitar o aluno a construir parte de um compilador de interpretador para
linguagem de alto nível. Ensinar as técnicas de análise léxica e sintática.
Disciplina: Construção de Compiladores 2
Ementa: Análise de contexto. Geração de código intermediário. Geração de código.
Otimização de códigos. Recuperação de erros.
Instituição: UFRJ
URL: http://www.dcc.ufrj.br/informatica/curriculo/obrigatorias.html
Disciplina: Compiladores I
Ementa: Visão Geral. Tabelas de símbolos. Análise Léxica. Especificação Sintática
de Linguagens de Programação. Análise Sintática Top-Down e Bottom-Up. Formas
intermediárias. Conceitos Básicos de tradução dirigida pela sintaxe. Conceitos
Básicos de Otimização. Recuperação de erros. Conceitos Básicos de Alocação de
Registradores.
Disciplina: Compiladores II
Ementa: Revisão de Análise Léxica e Sintática. Especificação Semântica através de
Gramáticas de Atributos. Avaliação de Atributos. Otimização e Geração de Código.
122

ComPort – Compilador Portugol
Instituição: USP
URL: http://www.ime.usp.br/grad/catalogo/2000/mac/node40.html
Disciplina: Projeto de Compiladores
Objetivos: Construção de um compilador e o ensino associado à geração de código
e otimização.
Instituição: Universidade Federal de Lavras - UFLA / MG
URL: http://www.prg.ufla.br/cursos/cienc_comp/ementas_cc.htm
Disciplina: Compiladores
Ementa: Gramáticas e Linguagens Formais. Estrutura de um compilador. Análise
léxica. Análise sintática. Análise semântica. Gerador de código intermediário.
Otimização de código.
Conteúdo: O processo de compilação. Implementação de analisadores sintáticos.
recuperação de erros sintáticos. Tabela de símbolos; estrutura de blocos. A análise
de contexto e geração de código objeto. Expressões aritméticas e booleanas.
Comandos repetitivos e de seleção. Variáveis indexadas. Procedimentos e
recursividade. Otimização e alocação de registradores.
123

-, 27
( ), 27
*, 27
?, 27
[ ], 27
{ }, 27
|, 27
+, 27
a
(
*
?
[
{
|
+
A
alfabeto, 19
analisador léxico, 26
analisador sintático, 28
autômato finito
ÍNDICE REMISSIVO
ComPort – Compilador Portugol
determinístico, 21
fita, 21
não-determinísticos, 23
programa, 21
unidade de controle, 21
Backus-Naur-Form. Consulte BNF
BNF, 28
compilador, 24
comprimento, 20
B
C
E
Expressões regulares, 26
gramática, 28
G
L
Lexemas, 26
linguagem, 19
linguagem de origem, 24
padrão, 26
palavra, 20
palavra vazia, 20
P
124

símbolos, 19
inicial, 19
não-terminais, 19
terminais, 19
S
Tokens, 26
vocabulário, 19
ComPort – Compilador Portugol
T
V
125