Documentação de uma linguagem de progração

Projeto de uma Linguagem de Programa¸c˜ao
Caio C´esar, Gabriel Vasiljevic, Jean Silva, Victor
20 de maio de 2013

Sumário
1 Principais caracter´ısticas da linguagem 2
1.1 Dom´ınio de Aplica¸cão . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.2 Caracter´ısticas da linguagem . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
2 Valores, tipos e expressões 4
2.1 Tipos Primitivos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
2.2 Tipos Compostos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
2.3 Sistema de tipos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
2.4 Tipos definidos pelo usuário . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
2.5 Representa¸cão dos valores de cada tipo . . . . . . . . . . . . . . . . . . . . . 6
2.5.1 Designadores dos tipos primitivos . . . . . . . . . . . . . . . . . . . . 8
2.5.2 Forma BNF de declara¸cão de um tipo na Linguagem . . . . . . . . . 8
2.6 Expressões da linguagem . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
2.6.1 Operadores Aritméticos . . . . . . . . . . . . . . . . . . . . . . . . . 9
2.6.2 Incremento e decremento . . . . . . . . . . . . . . . . . . . . . . . . . 9
2.6.3 Operadores Relacionais . . . . . . . . . . . . . . . . . . . . . . . . . . 9
2.6.4 Operadores lógicos . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
2.6.5 Operadores bit-a-bit . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
3 Variáveis e comandos 11
3.1 Modelo de armazenamento de valores . . . . . . . . . . . . . . . . . . . . . . 11
3.2 Uso de variáveis na Linguagem . . . . . . . . . . . . . . . . . . . . . . . . . 11
3.3 Caracter´ısticas dos arrays da linguagem . . . . . . . . . . . . . . . . . . . . . 12
3.4 Escopo e tempo de vida das variáveis . . . . . . . . . . . . . . . . . . . . . . 13
3.5 Comandos da linguagem . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
3.5.1 Entrada e Sa´ıda . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
3.5.2 Estruturas de Controle . . . . . . . . . . . . . . . . . . . . . . . . . . 14
3.5.3 Comandos alternadores de fluxo (jumps) . . . . . . . . . . . . . . . . 16
3.5.4 Primitivas de sa´ıdas dos blocos (escapes) . . . . . . . . . . . . . . . . 16
3.5.5 Tratamento de Exce¸cões . . . . . . . . . . . . . . . . . . . . . . . . . 17
3.6 Aloca¸cão de memória das veriáveis compostas . . . . . . . . . . . . . . . . . 17
1

4 Vincula¸cões e regras de escopo 18
4.1 Bindings da linguagem . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
4.2 Aliasing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
4.3 Estrutura de blocos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
4.4 Regras de visibilidade e resolu¸cão de escopo . . . . . . . . . . . . . . . . . . 19
5 Subprogramas 20
5.1 Procedimentos e fun¸cões . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
5.2 Parâmetros . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
5.3 Formas de passagem de parâmetros . . . . . . . . . . . . . . . . . . . . . . . 22
5.4 Verifica¸cão dos tipos de parâmetros . . . . . . . . . . . . . . . . . . . . . . . 22
5.5 Subprogramas sobrecarregados ou genéricos . . . . . . . . . . . . . . . . . . 23
5.6 Sistema de Implementa¸cão . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
6 Sistema de tipos da linguagem 24
6.1 Principais caracter´ısticas do sistema de tipos . . . . . . . . . . . . . . . . . . 24
6.2 Conversões de Tipos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
6.3 Regras de compatibilidade de tipos . . . . . . . . . . . . . . . . . . . . . . . 24

Cap´ıtulo 1
Defini¸cão das diretrizes de uso e
caracter´ısticas principais da linguagem
de programa¸cão
1.1 Dom´ınio de Aplica¸cão
A linguagem proposta é baseada em C e FORTRAN. Seu dom´ınio de aplica¸cão é cient´ıfico,
o que implica que além das estruturas de dados simples, ela também disporá de estruturas
que possibilitam a manipula¸cão de grandes quantidades de dados e de alta precisão numérica
para as computa¸cões com números reais.
A linguagem terá como público alvo matemáticos e cientistas, que precisam trabalhar
com números muito grandes, altas precisões e boas estruturas de controle.
1.2 Caracter´ısticas da linguagem
Há algumas caracter´ısticas que determinam o quão boa é uma linguagem de programa¸cão,
tais como:
Legibilidade: Um dos critérios mais importantes. Os programas desenvolvidos numa
determinada linguagem de programa¸cão devem ser fáceis de serem lidos e compreen-
didos. A linguagem a ser especificada é simples e dispõe de um pequeno número de
componentes básicos, o que garante a simplicidade global. Os nomes dos tipos primi-
tivos e das outras palavras reservadas refletem bem suas finalidades tornando a leitura
mais natural.
Confiabilidade: Diz-se que uma linguagem é confiável se ela se comporta de acordo
com suas especifica¸cões. A verifica¸cão de tipos é de extrema importância e nossa
linguagem fornece essa verifica¸cão, o que não ocorre em linguagens não-fortemente
tipadas, e.g. Phyton. A linguagem oferece também a capacidade de tratamento de
exce¸cões em tempo de execu¸cão, o que existe em Java, C++ e C#, ao contrário de C.
3

CAPÍTULO 1. PRINCIPAIS CARACTERÍSTICAS DA LINGUAGEM 4
A linguagem C dispõe de apelidos. Um exemplo de seu uso é o union, que reserva a uma
mesma área de memória para duas ou mais variáveis. Essa ferramente é amplamente
considerada perigosa e, portanto, não será contemplada na linguagem a ser projetada.
Capacidade de escrita: A linguagem é de fácil escrita e terá pouca ortogonalidade,
fazendo com que a codifica¸cão de um programa nessa linguagem seja de escrita mais
objetiva. As restri¸cões na combina¸cão dos tipos de dados e estruturas básicas devido à
pouca ortogonalidade evitará problemas de incompatibilidade de tipos que são dif´ıceis
de serem percebidas tanto pelo programadores quanto pelo compilador.
Assim como em Java, C e C++, a linguagem proposta é Case Sensitive1
. C não dispõe
de algumas estruturas de dados mais complexas como, por exemplo, conjuntos, listas, pilhas
e filas enquanto a nossa oferece estes tipos como primitivos além dos dispon´ıveis em C.
Outra novidade é o tipo primitivo bigInt que comporta um número inteiro bem maior que
o convencional.
O fator que mais influencia na eficiência dos programas escritos na linguagem proposta é a
flexibilidade de baixo n´ıvel herdada de C. E os fatores que mais influenciam na produtividade
do programador são a legibilidade, a capacidade de escrita e forma como o erro se apresenta
a ele durante os testes, permitindo a corre¸cão mais rápida dos erros.
Levando em conta o dom´ınio de aplica¸cão da nossa linguagem, foi escolhido o sistema
de implementa¸cão por compila¸cão. A razão disso é que este sistema confere uma maior
eficiência aos programas, requisito esse de alta relevância no dom´ınio cient´ıfico em fun¸cão da
necessidade de realizar computa¸cões de alto custo.
Para que nossa linguagem atinja o sucesso e justifique sua cria¸cão, é necessária uma
análise cuidadosa das necessidades de seu dom´ınio de aplica¸cão. As linguagens COBOL e
FORTRAN, por exemplo, atendem suficientemente bem as necessidades de seus respectivos
dom´ınios. As linguagens posteriores não trouxeram modifica¸cões realmente relevantes aos
recursos que estas já ofereciam. Deve-se tentar suprir todas estas necessidades, tentado fazer
um balanceamento entre os pontos fracos e fortes da linguagem proposta.
1
Case sensitive, do inglês “caixa alta”, significa que o sistema diferencia letras maiúsculas e minúsculas.
Por exemplo, a palavra “variável” é diferente de “Variável” ou “VARIÁVEL”, mesmo tendo a mesma escrita.

Cap´ıtulo 2
Valores, tipos e expressões
2.1 Tipos Primitivos
Tipos primitivos são tipos que não são derivados de nenhum outro; são, de certa forma,
estruturas atômicas da linguagem. Abaixo listamos os tipos primitivos oferecidos pela lin-
guagem, e na sessão 2.5 os detalharemos.
char - caractere
short - inteiro curto
int representando o tipo inteiro
long - inteiro de faixas maiores (dobro do int)
bigInt - inteiro de maior faixa que long
bool
float - ponto flutuante
double - precisão dupla para ponte flutuante
string - cadeia de caracteres
unsigned int - inteiro não sinalizado
unsigned long - long não sinalizado
unsigned bigInt - bigInt não sinalizado
unsigned short - short não sinalizado
unsigned float - float não sinalizado
unsigned double - double não sinalizado
5

CAPÍTULO 2. VALORES, TIPOS E EXPRESS ÕES 6
complex - representando um número complexo
< tipo > * - guarda o endere¸co de uma posi¸cão de memória;
2.2 Tipos Compostos
Tipos compostos são aqueles constru´ıdos a partir de tipos primitivos ou até mesmo de
outros tipos compostos. Como exemplo de tipos compostos na nossa linguagem temos:
Conjunto (set);
Fila (queue);
Pilha (stack);
Lista (list);
Vetor;
Struct;
Além desses, vale destacar um tipo composto bastante peculiar, que é o tipo recursivo.
Nessa categoria, se encaixam aqueles tipos que são compostos por elementos de mesmo tipo.
Um tipo recursivo clássico é a lista, onde cada elemento vai referenciar um próximo elemento
da mesma natureza. Isso é poss´ıvel com a utiliza¸cão de ponteiros. Árvores binárias e Grafos
também seguem a mesma linha de racioc´ınio, mas esses últimos não são suportados pela
linguagem.
A constru¸cão de um tipo recursivo é feita da seguinte forma, segundo a forma BNF:
<declara¸c~ao_tipo_recursivo> -> struct <nome_do_tipo> {
<conjunto_de_declara¸c~oes>
<nome_do_tipo> * <nome_do_atributo>;
};
Exemplo de uso:
 struct ListaT{
 int info;
 ListaT * prox;
 };
Código 1: Estrutura de lista recursiva
No código 2.2 acima temos uma estrutura de lista recursiva. Neste caso, uma lista é
composta por um campo info, onde podemos armazenar e recuperar um dado do tipo inteiro,
e uma lista do mesmo tipo, ou seja, o interior da lista contém outra lista, que por sua vez
tem outra, e assim por diante, e dessa forma conseguimos fazer constru¸cões recursivas na
linguagem.

2.3 Sistema de tipos
A linguagem proposta será fortemente tipada. Diferentemente de C e C++, que não
fazem a verifica¸cão de tipos de parâmetros de uma fun¸cão. Destarte, não haverá conversões
impl´ıcitas de tipo (coer¸cão). Quanto a compatibilidade, usaremos a combina¸cão de dois
métodos: a compatibilidade de nomes e estruturas. Escolhemos esta abordagem por acharmos
mais segura e prática, além de mais eficiente, pois, no melhor caso, não precisaremos comparar
as estruturas das variáveis, e no pior só verificamos os nomes.
Esse assunto é abordado de forma mais detalhada no cap´ıtulo 6.
2.4 Tipos definidos pelo usuário
Muitas vezes o usuário deseja criar seus próprios tipos, e isso é poss´ıvel usando a primitiva
struct. É poss´ıvel, ainda, a defini¸cão de estruturas genéricas, nas quais possamos declarar
uma variável ora de um tipo, ora de outra, sem a necessidade de implementar mais de um
estrutura de tipo (ver exemplo do código 2.4 e 2.4).
 template <typedef struct T>
 typedef struct Par {
 T a, b;
 };

 template <typedef struct T>
 function getMax (Par <T> p ) : T {
 return p.a > p.b ? p.a : p.b;
 }
Código 2: Defini¸cão de tipos e fun¸cões genéricas através do uso do templates
2.5 Representa¸cão dos valores de cada tipo
Nesta sessão apresentamos cada tipo e em seguida um exemplo do uso.
char: É representado internamente por 1 byte, ou seja, a faixa de valores que esse tipo
cobre é −128 a 127, e quando não sinalizado (unsigned char) compreende uma faixa de 0 a
255. Para a representa¸cão de cada caractere usamos a tabela ASCII.
 char c = ’a’;
 unsigned d = ’b’;
short: É representado na base binária por 16 bits = 2 bytes. Usamos a representa¸cão de
complemento de 2 para permitirmos a representa¸cão de números negativos. O intervalo de
cobertura desse é de −32768 a 32767, para o unsinged short temos de 0 a 65535.

 import io;
 import Par;

 function main(): int {
 Par<int> pi;
 pi.a = 2;
 pi.b = 7;
 Par <float> pf;
 pf.a = 2.5;
 pf.b = 3.1415;

 write("%dn", getMax(pi));
 write("%dn", getMax(pf));
 return 0;
 }
Código 3: Uso do tipo genérico Par para float
 short a;
 unsigned short b;
int: É representado da mesma forma que o short, mas compreende uma faixa maior que o
mesmo (4 bytes). O tipo int sinalizado compreende uma faixa de −2147483648 a 2147483647,
já o não sinalizado 0 a 4294967295.
 int n = 50;
 unsigned int m = 8;
long: Sua representa¸cão é da mesma forma que o tipo int, porém com uma faixa de
valores superior aos inteiros anteriores: 8 bytes. A faixa de representa¸cão do tipo inteiro
longo é de −263
à 263
− 1. 0 não sinalizado vai de 0 à 264
− 1.
 long l = 5000;
 unsigned long l1 = 6000;
bigInt: Da mesma forma, o bigInt é representado de maneira similar, mas com o dobro
do tamanho do long: 16 bytes. Assim, a representa¸cão do bigInt é a seguinte −2127
à 2127
−1,
e não sinalizado vai de 0 à 2128
− 1.
 bigInt bi = 10000000;
 unsigned bigInt b = 100000000;
bool: Pode assumir dois valores: true ou false e é representado por 1 byte. O true será
representado por todos os 8 bits do byte em 1, caso contrário todos em 0.

 bool a = true;
 bool b = false;
float: O ponto flutuante é representado por 32 bits, sendo 1 reservado para o sinal, 8 de
expoente e 23 para a parte fracionária. Isso equivale a uma faixa de valores de ±3.4e±38.
 float a = .2;
 float b = 2.5;
double: O double é representado de forma semelhante ao float, mas com o dobro de
precisão (8 bytes). A faixa de valores é de ±1.7e ± 308.
 double a = 5.65
complex: O tipo complexo utilizará dois números reais, um para representar sua parte
real e o outro a parte imaginária e terá 8bytes e a faixa será de −264
à 264
− 1.
 complex c(5.5, 7.8);
string: O tipo string será uma lista encadeada de caracteres. Para esta lista, as opera¸cões
de concatena¸cão e conversão para uma cadeia de caractere estarão fundamentadas na lingua-
gem.
 string s = "cplusminus.com";
vetor: Como um vetor aponta para um bloco de memória, sua implementa¸cão se dá por
um ponteiro para apontar ao primeiro bloco de memória alocado.
 int v[10];
 int vet[3] = {1, 2, 3};
 int mat[2][2] = {1, 0;
 0, 1};
set: Os conjuntos serão armazenados com uma cadeia de bits internamente. Quando em
1, o bit significa que o elemento está presente e, caso contrário, não estará. Consideremos o
seguinte conjunto:
[ a , . . . , p ]
Podemos utilizar 16 bits para representar esse conjunto. Desta forma, o conjunto [ a , b , f , j , p ]
seria representado como a seguir:
1100010001000001
Um conjunto terá um tamanho de 4 bytes, ou seja, será poss´ıvel representar um conjunto
com no máximo 32 elementos.

 import utility.set;
 ...
 set <int> A;
 set < set <int> > B;
 B.add(A);
 /**
 * B ⊃ A
 */
list: A lista é definida recursivamente - uma lista é composta de outra lista.
 import utility.list;
 ...
 list <int> a;
 list < list <int> > b;
ponteiros: Ponteiros e referências são geralmente representados por valores únicos, arma-
zenados em células de memória de 2 ou 4 bytes, dependendo da arquitetura do computador.
Na maioria dos computadores, os microprocessadores são baseados na arquitetura intel; as-
sim, os ponteiros e as referências são representadas como pares de palavras de 16 bits, uma
para cada uma das duas partes de um endere¸co (segmento e deslocamento(offset)).
 int * prt;
 char * pt;
 short * p;
2.5.1 Designadores dos tipos primitivos
Tabela 2.1: Designadores dos tipos primitivos da linguagem
Nome Descri¸cão Tamanho Faixa
char Caractere 1byte −128 a 127 e unsigned: 0 a 255
short Inteiro curto 2bytes −32768 a 32767 e unsigned: 0 à
65535
int Inteiro 4bytes −2147483648 a 2147483647 e un-
signed: 0 à 4294967295
long Inteiro longo 8bytes −263
à 263
− 1 e unsigned: 0 à
264
− 1
bigInt Inteiro muito longo 16bytes −2127
à 2127
− 1 e unsigned: 0 à
2128
− 1
bool Valor booleano. Pode assumir dois va-
lores: true ou false
1byte true ou false
float Pronto flutuante 4bytes ±3.4e ± 38
double Precisão dupla do ponto flutuante 8bytes ±1.7e ± 308
complex Números complexos 8bytes −264
à 264
− 1

2.5.2 Forma BNF de declara¸cão de um tipo na Linguagem
<tipo_primitivo> -> char | short | int | long | bitInt | bool | float | double | complex | string
<tipo_composto> -> vetor | set | list
<tipo_vetor> -> <tipo_primitivo> | set
<tipo> -> <tipo_primitivo> | <tipo_composto>
<definicao_tamanho> -> [<tamanho>]
| <definicao_tamanho> <definicao_tamanho>
<declaracao_vetor> -> <tipo_vetor> <nome_variavel> <definicao_tamanho>;
<tipo_list> -> list < <tipo> >
<declaracao_list> -> <tipo_list> <nome_variavel>;
| list < <tipo_list> > <nome_variavel>;
<declaracao_set> -> <declaracao_set> <nome_variavel>;
| set < <declacao_set> >;
| set < <tipo> >
2.6 Expressões da linguagem
2.6.1 Operadores Aritméticos
Os cinco operadores se referem as seguintes, respectivas, opera¸cões: adi¸cão ( + ), sub-
tra¸cão ( - ), multiplica¸cão ( * ), divisão ( / ) e mod ou resto ( % ). Estes operadores atuam
sobre dois operandos, por este motivos, são classificados como binários.
2.6.2 Incremento e decremento
Os operadores (++) e (−−) respectivamente incremento, aumenta o valor da variável em
1, e decremento, diminui o valor da variável em 1.
2.6.3 Operadores Relacionais
Estes operadores representam as seguintes rela¸cões:
Igualdade ( == ): A igualdade é uma opera¸cão booleana que retorna o valor true,
caso dois operadores sejam considerados iguais, segundo um critério de verifica¸cão, e
false, caso contrário.
Diferen¸ca ( ! = ): A diferen¸ca retorna false, nos casos em que a igualdade retornaria
true, e retorna true, nos casos contrários.
Maior ( > ): A compara¸cão maior retorna true, caso o primeiro operando seja maior
que o segundo, e false, quando o segundo operando é maior que o primeiro.
Menor (< ): A compara¸cão menor retorna true, quando o primeiro operando é menor
que o segundo, e false, quando o contrário acontece.

Maior ou igual (>=): A compara¸cão maior ou igual é a jun¸cão de duas compara¸cões,
esta compara¸cão retorna true, sempre que pelo menos uma das duas return true, e false,
caso contrários.
Menor ou igual ( <= ): A compara¸cão menor ou igual tem o mesmo funcionamento
da compara¸cão maior ou igual, retornando true, quando o primeiro operando é menor
ou igual ao segundo.
2.6.4 Operadores lógicos
A seguir uma breve vincula¸cão dos operadores com seus respectivos significados booleanos.
O operador “ ! ” representa a fun¸cão lógica NOT.
O operador “ && ” representa a fun¸cão lógica AND.
Por fim, o operador “||” representa a fun¸cão lógica OR.
2.6.5 Operadores bit-a-bit
Estes operadores são caracterizados por fazer opera¸cões com bit e bytes (palavras de
8 bit). Podemos reconhecer alguns operadores lógicos ou booleanos como o operador “ &
”, representando o AND bit a bit, o operador “|”, representando o OR bit a bit, o “ ˆ ”,
representando o XOR e por fim o “ ˜ ” que representa o NOT bit a bit. Os operadores de
deslocamento “>>” e “<<” de bits a direita e a esquerda respectivamente.

Cap´ıtulo 3
Variáveis e comandos
3.1 Modelo de armazenamento de valores
Visando permitir uma maior flexibilidade à escrita dos programadores, serão permitidos
os seguintes modelos de armazenamento de valores na memória:
(a) Estático: Em várias situa¸cões, variáveis globalmente acess´ıveis são de grande utilidade.
O modelo de vincula¸cão estática permite isso da forma mais eficiente (endere¸camento
direto). Este modelo v´ıncula à variável um determinado endere¸co de armazenamento
antes que o programa inicia, o qual permanece até o fim do programa.
(b) Dinâmico na pilha: As variáveis dinâmicas na pilha são aquelas em que o tipo é
vinculado estaticamente, mas a vincula¸cão de armazenamento é feita no momento em
que o programa atinge a declara¸cão da variável, em tempo de execu¸cão. Esse modelo é o
requisito básico para permitir subprogramas recursivos. Devido à sobretaxa de aloca¸cão
e desaloca¸cão em tempo de execu¸cão, este modelo perde em desempenho.
(c) Dinâmico no heap expl´ıcitas: O uso de variáveis dinâmicas no heap permite ao
programador interagir em mais baixo n´ıvel com blocos de memória. A aloca¸cão é feita
através de operadores ou fun¸cões definidos(as) na linguagem e a manipula¸cão é feita
através de ponteiros ou referências. Esse modelo se aplica perfeitamente na defini¸cão
de estruturas dinâmicas, mas a manuten¸cão dos blocos envolve riscos, que passam a ser
responsabilidade do programador.
3.2 Uso de variáveis na Linguagem
Na nossa linguagem, ao se declarar uma variável, é vinculado um valor aleatório a ela (lixo
da memória). Isso pode ser evitado realizando-se a inicializa¸cão da variável no momento de
sua declara¸cão, tornando responsabilidade do programador a verifica¸cão dessa necessidade.
Alem disso, é poss´ıvel vincular valores dinamicamente à variável através de opera¸cões de
atribui¸cão ou de leitura. Quanto à atribui¸cão de variáveis compostas, no caso dos arrays,
13

CAPÍTULO 3. VARI ÁVEIS E COMANDOS 14
deverá ser especificado o ´ındice da posi¸cão do array a ter seu valor atualizado. De modo que,
esse ´ındice denota o deslocamento do ponteiro na memória em rela¸cão ao endere¸co base do
array. Dessa forma, o programador tem uma forma mais intuitiva de manipular os arrays.
No caso dos tipos definidos através de structs, não será poss´ıvel fazer uma atribui¸cão direta
da forma < tipo composto >=< outro tipo composto >. Para este fim, a atribui¸cão deve ser
feita campo à campo.
Na forma BNF logo abaixo, apresentamos a forma geral da declara¸cão de uma variável,
e em seguida, alguns exemplos que segue a BNF descrita.
<declaracao_var> -> <tipo> <nome_var>;
| <tipo> <nome_var> = <valor>;
| <tipo> <lista_nomes_vars>;
<lista_nomes_vars> -> <nome>
| <nome>, <lista_nomes_vars>
 int a, b, c, d;
 string str = "CPlusMinus";
 float f = .6;
3.3 Caracter´ısticas dos arrays da linguagem
Os elementos do array são referênciados por meio de seu endere¸co base, e de um ou mais
´ındices do tipo inteiro. A sintaxe da referência consiste, basicamente, no nome da estrutura
seguido de uma lista de ´ındices, cada um colocado entre colchetes. Para evitar erros de faixa,
é vinculado ao array uma faixa de valores (com limite inferior no zero) de modo a evitar o
acesso a posi¸cões inválidas. Os arrays serão categorizados como:
(a) Estático: a faixa de valores do ´ındice e a aloca¸cão de armazenamento são vinculados
estaticamente antes da execu¸cão do programa (eficiente).
(b) Fixo dinâmico na pilha: a faixa de valores do ´ındice é vinculada estaticamente, mas
a aloca¸cão é feita no momento da elabora¸cão da declara¸cão (melhor uso do espa¸co de
armazenamento).
(c) Dinâmico na pilha: a faixa de valores do ´ındice e o espa¸co de endere¸camento são
vinculados dinamicamente. Ocorrendo a vincula¸cão, sua faixa de valores do ´ındice e seu
armazenamento alocado permanecem os mesmos até o fim de seu tempo de vida (maior
flexibilidade em rela¸cão ao array fixo dinâmico na pilha)
(d) Dinâmico no heap: semelhante ao dinâmico na pilha, exceto pela possibilidade da faixa
de valores do ´ındice e seu armazenamento alocado serem modificados qualquer número
de vezes (ainda mais flex´ıvel).
Para fornecer maior poder de expressão ao programador, é permitido a defini¸cão de uma
lista de ´ındices com tamanho sem imposi¸cão de limites de tamanho para arrays estáticos.

Por outro lado, para evitar maiores problemas com eficiência e manipula¸cão de ponteiros, é
limitado para sete o tamanho da lista de ´ındices para arrays dinâmicos de heap. Por último
mas não menos importante, é permitida a inicializa¸cão dos elementos do array no momento
de sua declara¸cão se ele for estático, e, para facilitar a manipula¸cão e melhorar o desempenho
de referenciamento, os arrays poderão ser subdivididos em fatias, o que possibilita o uso de
menos expressões de ´ındice do que se fosse referênciado o array inteiro.
3.4 Escopo e tempo de vida das variáveis
A variável global (estática) quando declarada estará acess´ıvel desde o in´ıcio do programa
até o final do mesmo. A vincula¸cão dessa variável a um espa¸co de memória é feita antes da
execu¸cão do programa. Uma variável local estará acess´ıvel somente durante a execu¸cão da
fun¸cão onde ela foi declarada. Nesse caso, a váriável é vinculada a um espa¸co de memória em
tempo de execu¸cão, mas logo quando essa fun¸cão é finalizada, esse espa¸co de memória que
foi alocado para a variável é desalocado. É importante não confundirmos a acessibilidade de
uma variável com o seu escopo. Em geral, é muito comum pensarmos que o escopo de uma
variável estática é somente durante a execu¸cão do programa inteiro, mas isso não é verdade;
podemos declarar uma variável estática dentro de uma fun¸cão com o aux´ılio do modificador
static, e a mesma não estar acess´ıvel ao longo da execu¸cão do programa inteiro. O que
acontece é que a variável é estática e, mesmo após o término da fun¸cão, ela continua alocada,
mas não permanece acess´ıvel.
3.5 Comandos da linguagem
Nessa sessão apresentaremos para cada comando sua forma BNF, e em seguida, um
exemplo de uso do comando em questão.
3.5.1 Entrada e Sa´ıda
3.5.1.1 Forma Normal
<cod_leitura> -> "%i"|"%d"|"%s"|"%f"|"%lf"|"%bi"|"%ld"
<cod_escrita> -> <string> | <cod_leitura>
|<string > <cod_escrita>
|<cod_leitura> <cod_escrita>
<lista_enderecos>-> &<variavel> | &<variavel>, <lista_enderecos>
<lista_vars> -> <variavel> | <variavel>, <lista_vars>
<comando_read> -> read(<cod_leitura>, <lista_enderecos>);
<comando_write> -> write (<cod_escrita>, <lista_vars>)
 import io;

 function main(): int {
 int a, b;
 read("%i %i", &a, &b);
 int soma = a + b;

 write("%in", soma);
 return 0;
 }
3.5.2 Estruturas de Controle
3.5.2.1 Condicional
3.5.2.1.1 Comando if
Forma Normal
<comando_if> -> if ( <condicao> ) {
<comando>
} else if (<condicao2>) {
<lista_de_comandos>
} else {
<lista_de_comandos>
}
| if ( <condicao> ) {
<lista_de_comandos>
} else {
<lista_de_comandos>
}
| if ( <condicao> ) {
<lista_de_comandos>
}
| if ( <condicao> )
<comando>
 import io;

 int n;
 read("%d", &n);
 if (n > 0) {
 write("%d eh um numero positivon", n);
 } else if(n < 0){
 write("%d eh um numero negativon", n);
 } else {
 write("%d eh zeron", n);
 }
 return 0;
 }
3.5.2.1.2 Comando switch-case
Forma Normal
<comando_switch-case> -> switch( <var_escolha> ) {
case <op1>:
<lista_de_comandos>
break;
case <op2>:
<lista_de_comandos>

break;
...
default:
<lista_de_comandos>
break;
}
 import io;

 string op;
 read("%s", &op);
 switch(op) {
 case "um":
 write("1n");
 break;
 case "dois":
 write("2n");
 break;
 case "tres":
 write("3n");
 break;
 default:
 write("qwertyn");
 break;
 }
 return 0;
 }
3.5.2.2 Repeti¸c˜ao
3.5.2.2.1 Comando for
Forma Normal
<comando_for> -> for (<inicializacao>; <condicao_de_parada>; <incremento/decremento>) {
<lista_de_comandos>
<comando_for>
}
| for (<inicializacao>; <condicao_de_parada>; <incremento/decremento>)
<comando>
 import io;

 int n;
 read("%d", &n);
 for (int i = 0; i < n; i++) {
 write("%d ", 2 * (i + 1));
 }
 write("n");
 return 0;
 }

3.5.2.3 Comando for-each
3.5.2.3.1 Forma Normal
<comando_foreach> -> foreach (<tipo> <nome_var> : <nome_list/nome_vetor>) {
<lista_de_comandos>
<comando_foreach>
}
| foreach (<tipo> <nome_var> : <nome_list/nome_vetor>)
<comando>
 import io;
 import utility.list;

 function main(): int {
 list <int> lst;
 lst.add(0);
 lst.add(2);
 lst.add(3);
 lst.add(4);

 foreach (int a : lst) {
 write("%d ", a);
 }
 write("n");
 return 0;
 }
3.5.2.4 Comando while
<comando_while> -> while (<condicao_de_parada>) {
<lista_de_comandos>
<comando_while>
}
 import io;

 int n;
 read("%d", &n);
 int i = 0;
 while(i < n) {
 ++i;
 write("%d ", 2 * i);
 }
 write("n");
 return 0;
 }
3.5.2.5 Comando do-while

<comando_do-while> -> do {
<lista_de_comandos>
} while ( <condicao_de_parada> );
 import io;

 int i = 5;
 do {
 write("%d ", i);
 i--;
 } while (i != 0);
 write("n");
 return 0;
 }
3.5.3 Comandos alternadores de fluxo (jumps)
Os tipos de jumps (alteradores de fluxo) da linguagem são descritos na subse¸cões seguintes.
3.5.3.1 Comando break
No código 3.5.3.1 abaixo, que ilustra o uso do break, as linhas 4 e 5 sempre serão exe-
cutadas até que i = 10, quando a condi¸cão da linha 5 é satisfeita e as linhas 6 e 7 serão
executadas. A sa´ıda do programa será os números de 1 a 10 e uma quebra de linha. Na linha
7 o comando break é executado e o fluxo de execu¸cão é desviado para a próxima instru¸cão,
fazendo com que o programa não entre no la¸co novamente.
 int i = 0;
 while(true) {
 i++;
 write("%d ", i);
 if (i == 10) {
 write("n");
 break;
 }
 }
Código 4: Uso do break
3.5.3.2 Comando continue
No código 3.5.3.2, que exibe um trecho de código com o emprego do comando continue,
enquanto i < 10 a linha 5 será executada. O comando continue faz com que o programa
volte à condi¸cão do loop que o engloba, (linha 1) ignorando as linhas abaixo dele (linhas 6 e
7), ou seja, o programa entrará em loop mais uma vez. Quando i = 10 o programa escreve
uma quebra de linha e encerra o loop com o comando break.

 while(true) {
 i++;
 write("%i ", i);
 if (i < 10)
 continue;
 write("n");
 break;
 }
Código 5: Trecho de código com o uso do continue.
3.5.4 Primitivas de sa´ıdas dos blocos (escapes)
3.5.4.1 Comando return
O comando return serve para retornar o que uma fun¸cão se propôs a computar. Como
exemplo temos o trecho de código do Código 3.5.4.1, onde é definida uma fun¸cão par(i:int):
bool que retorna true se i for par e false caso contrário. Se i for par a linha 3 é executada e
o subprograma é finalizado. Caso contrário, a linha 4 é executada e o programa é finalizado.
Veja que uma fun¸cão pode somente retornar um valor por execu¸cão.
 function par(i: int): bool {
 if (i % 2 == 0)
 return true;
 return false;
 }
Código 6: Trecho de código com o uso do return.
3.5.4.2 Comando exit
O comando exit é usado para finalizar o programa como um todo. Vejamos o código
3.5.4.2, a sa´ıda será:
msg de teste
Saindo ...
Na fun¸cão f(), na linha 5 temos um comando exit(0), pontanto tudo que está após a
chamada dessa fun¸cão na main() não será executado, pois o programa finaliza sua execu¸cão
quando o comando exit(0) é usado. Se comentarmos a linha 11 do programa sua sa´ıda seria
a seguinte:
msg de teste
Saindo ...
msg de teste 2

 import io;

 procedure f() {
 write("Saindo ... n");
 exit(0);
 }

 function main(): int {

 write("msg de testen");
 f();
 write("msg de teste 2n");

 return 0;
 }
Código 7: Trecho de código com o uso do exit.
3.5.5 Tratamento de Exce¸cões
Nossa linguagem usará a estrutura de try-catch como forma de tratamento de exce¸cões,
de forma semelhante a C++. As exce¸cões serão definidas como os tipos presentes na lingua-
gem, podendo, assim, o próprio usuário criar suas exce¸cões. A seguir (código 3.5.5), tem-se
um exemplo de um código utilizando tratamento de exce¸cões.
 procedure g(){
 int x;
 write("Digite um numero positivo: n");
 try{
 read(x);
 if(x < 0){
 throw x;
 }
 }
 catch(int erro){
 write("Erro! numero negativo: %i n", erro);
 }
 }
Código 8: Trecho de código com o uso do try-catch.
3.6 Aloca¸cão de memória das veriáveis compostas
Para as variáveis compostas homogêneas, como os vetores, sua aloca¸cão será em blocos de
memória sequenciais, e seu escopo será como o de uma variável comum. Seu referenciamento
será em rela¸cão ao primeiro bloco de memória alocado por ele. Ou seja, o referenciamento
da próxima variável da sequência será apenas o incremento unitário da posi¸cão da memória.
Quanto a passagem destas variáveis por parâmetro, será feito por referência. As variáveis
compostas heterogêneas (registros) também serão alocadas sequencialmente, mas o acesso

aos campos se dá através de um deslocamento, que é guardado junto ao campo, já que o
tamanho de cada bloco não é necessariamente igual. Seu referenciamento é feito como o de
uma variável comum, ou seja, copiando seus atributos. O mesmo vale para seu escopo - igual
ao de uma variável comum.

Cap´ıtulo 4
Vincula¸cões e regras de escopo
4.1 Bindings da linguagem
Quanto a vincula¸cão de tipos, que esta associada a declara¸cão de variáveis, será, sem-
pre que poss´ıvel, feita estáticamente devido ao sistema de implementa¸cão escolhido, a com-
pila¸cão, e a maior eficiência dessa abordagem. Sendo assim, a vincula¸cão de tipos será
em tempo de compila¸cão. Quanto a vincula¸cão de armazenamento, temos como assunto,
variáveis estáticas,stack-dinâmicas e heap-dinâmicas. As variáveis estáticas tem seu espa¸co
de armazenamento vinculado em tempo de compila¸cão. E as variáveis stack-dinâmicas e
heap-dinâmicas tem seus epa¸cos de armazenamento vinculados em tempo de execu¸cão mas,
não da mesma forma. Variáveis stack-dinâmicas são armazenadas temporariamente em uma
pilha e sua retirada é feita pela linguagem, dependendo de seu ambiente de referenciamento.
Variáveis heap-dinâmica são armazenadas numa heap e sua retirada é responsabilidade do
programador. As caracter´ısticas mais básicas e elementares da linguagem, que estão sendo
definidas durante esta disciplina, estão sendo vinculadas em tempo de projeto.
4.2 Aliasing
Na linguagem haverá dois casos do uso de aliasing, os quais são explicados abaixo. O
primeiro caso, é mais evidente em linguagens que dão suporte a aliasing, é o uso de referência.
Por exemplo, quando usamos passagem de parâmetros por referência, passam a existir dois
nomes vinculados ao mesmo espa¸co de memória, o que caracteriza o aliasing. O uso de
ponteiros pode ser também considerado aliasing em alguns casos. Caracterizamos seu uso
como aliasing quando dois ponteiros estão referenciando um mesmo bloco de memória. Este
tipo de apelido é indireto, pois os ponteiros em si não são aliasing, mas sua referência o é.
4.3 Estrutura de blocos
Para definirmos os escopos das variáveis usamos blocos, que são, por sua vez, definidos
pelas chaves, ““ e “”. Segue abaixo a forma BNF.
23

CAPÍTULO 4. VINCULAÇ ÕES E REGRAS DE ESCOPO 24
<comando_da_linguagem> -> <comandos_basicos>
| <comandos_basicos> <comando_da_linguagem>
| <blocos>
| <blocos> <comando_da_linguagem>
<bloco> -> <comando_de_fluxo_ctrl> {
<comandos_da_linguagem>
}
| <decl_func> {
<comandos_da_linguagem>
}
Podemos usar a forma BNF acima descrita para definir blocos aninhados de forma re-
cursiva, visto que comando de fluxo de controle e declara¸cões de fun¸cões são comandos da
linguagem.
4.4 Regras de visibilidade e resolu¸cão de escopo
Quanto ao escopo estático, as variáveis declaradas nos blocos ancestrais serão vis´ıveis a
todos os blocos internos a eles. Já o contrário não ocorre: variáveis declaradas nos blocos mais
internos não são vis´ıveis a seus ancestrais. Quando o compilador encontra um identificador de
uma variável, é necessário saber a qual variável ele se refere. Para tanto, é preciso localizar a
sua instru¸cão de declara¸cão. Essa busca come¸ca no bloco em que foi encontrada a referência à
variável. Caso a variável não seja encontrada neste bloco, a busca se segue em seu pai estático
(bloco que engloba este bloco), e assim por diante. Caso não haja mais nenhum ancestral
estático para proceder com a busca o compilador irá retornar um erro de declara¸cão. Quanto
ao escopo dinâmico, essa busca se dá de maneira diferente, uma vez que no escopo estático
a busca pela instru¸cão de declara¸cão da variável é baseada na declara¸cão dos blocos, e no
dinâmico é baseado na ordem inversa de chamada de fun¸cões. Consideremos a seguinte
situa¸cão: a fun¸cão main fm chama uma funcão f2, que por sua vez chama uma fun¸cão
f1. Consideremos também que o compilador encontrou uma referência a uma variável x em
f1. Dessa forma a instru¸cão de declara¸cão de x será buscada na ordem de chamada dessas
fun¸cões. Primeiro o compilador verifica se a instru¸cão de declara¸cão se encontra na f1, caso
contrário, a busca continua em f2, e assim por diante. Caso não seja encontrada, o compilador
retornará um erro de declara¸cão. Analizando essas duas formas de escopo, conclu´ımos que
nossa liguagem deve ser de escopo estático.

Cap´ıtulo 5
Subprogramas
Subprogramas são uma das formas de abstra¸cão presente na linguagem, que nos for-
nece abstra¸cão de processo, cujo conceito é de suma importância para uma linguagem de
programa¸cão, uma vez que aumenta a legibilidade. Duas categorias de subprogramas são
procedimentos e fun¸cões, que serão abordadas na sessão 5.1.
5.1 Procedimentos e fun¸cões
Uma fun¸cão é uma rela¸cão que mapeia um dom´ınio de entrada em um dom´ınio de sa´ıda.
Ela recebe parâmetros e retorna um valor.
Um procedimento não retorna valor e é utilizado, normalmente, para executar um bloco
de comandos, e.g. para imprimir um texto. O código abaixo mostra a forma BNF que definem
a sintaxe das fun¸cões e procedimentos.
Essa abordagem foi adotado pois torna mais evidente as diferen¸cas entre esses conceitos.
Em C/C++, por exemplo, os procedimentos são fundamentalmente fun¸cões (que retornam o
tipo void), o que dificulta sua diferencia¸cão. Usando essa abordagem torna-se mais natural
a associa¸cão entre procedimentos e comandos e entre fun¸cões e expressões.
<lista_de_parametros> -> <tipo> <nome_param>
| <lista_de_parametros>, <tipo> <nome_param>
<declaracao_funcao> -> function <nome_funcao> (<lista_de_parametros>): <tipo_retorno> {
<conjunto_instrucoes>
return <valor>;
}
<declaracao_procedimento> -> procedure <nome_procedimento> (<lista_de_parametros>) {
<conjunto_de_instrucoes>
}
5.2 Parâmetros
Os dados que poderão ser colocados como argumentos em chamadas de fun¸cão são tanto
de tipos da linguagem, listados e descritos nos problemas anteriores. Também será poss´ıvel
ter nomes de subprogramas utilizados como parâmetro.
25

CAPÍTULO 5. SUBPROGRAMAS 26
Em sistemas de implementa¸cão de linguagens de programa¸cão é necessário incorporar
métodos de resolu¸cão de nomes. As linguagens que utilizam resolu¸cão de escopo estática
são chamadas de linguagens de escopo estático. As que utilizam resolu¸cão escopo dinâmico
são chamadas de linguagens de escopo dinâmico. No caso de linguagens que suportam fun¸cões
de alta ordem (aceitam fun¸cões como parâmetros de fun¸cões), temos três formas de resolu¸cão
de nomes. São elas vincula¸cão rasa, vincula¸cão profunda e ad hoc.
Introduziremos esses conceitos com base na explica¸cão da Figura 5.1.
1. vincula¸cão profunda: Ambiente da defini¸cão do subprograma passado. Quando exe-
cutamos o programa da Figura 5.1, o subpprograma F1 quando é chamado, temos uma
expressão com a variável A. O compilador busca a declara¸cão de A, onde encontrará
informa¸cões de sua vinculacão. Assim, a busca se dará no subprograma F1. Caso não
seja encontrado, a busca continua no bloco que o envolve, onde finalmente a declara¸cão
é encontrada. Caso a busca não obtivesse sucesso, um erro de tipo seria lan¸cado. Esse
método de resolucão de nome é semelhante ao de vincula¸cão estática.
2. vincula¸cão rasa: Ambiente de defini¸cão do subprograma que ordena o subprograma
passado. Usando mais um vez, o exemplo da Figura 5.1. Quando chamamos F3, que
chama F2 e por sua vez chama F1. O compilador irá fazer uma busca em F1 pelas
informa¸cões de vincula¸cão de A. Como não é encontrado ai, ele irá continuar a busca em
F2, e ai achará a declara¸cão de A. Caso a busca em F2 falhasse a busca continuaria
em F3, e se mais uma vez não obtivesse sucesso, o compilador lan¸caria um erro de
declara¸cão. Esse método se assemelha ao método de vincula¸cão dinâmica.
3. Vincula¸cão ad hoc: Ambiente da instru¸cão que passou o subpprograma como parâmetro
real. Por exemplo, quando executamos o código da Figura 5.1 temos a seguinte situa¸cão:
quando F3 chama F2, passando como parâmetro F1, a declara¸cão do A é encontrado
em F3.
Figura 5.1: Código para representa¸cão dos conceitos de vinculacão profunda, rasa e ad hoc.

5.3 Formas de passagem de parâmetros
Dentre as formas de passagem de parâmetro existentes, a nossa linguagem implementará
a passagem de parâmetro por valor e a passagem de parâmetro por referência.
Passagem de parâmetro por valor: O valor do parâmetro real é usado para inici-
alizar o parâmetro formal correspondente, que, então, age como uma variável local no
subprograma.
A passagem por valor é normalmente implementada pela transferência de dados reais
(um valor real é transmitido fisicamente para o chamador, para o chamado, ou ambos),
mas, ao invés disso, pode ser implementada transmitindo-se um caminho de acesso e,
neste caso, a célula de memória que contém o valor deve estar protegida contra grava¸cão
(read-only).
Na passagem por valor, é feita uma cópia dos valores dos parâmetros reais no espa¸co
de memória reservado para a fun¸cão chamada ou chamadora, ou até mesmo fora delas.
A desvantagem deste método, se forem feitas transferências f´ısicas, está no fato que
será necessário armazenamento adicional para os parâmetros formais do subprograma
chamado, ou em alguma área fora do subprograma chamado ou chamador. Em adi¸cão,
as opera¸cões de armazenamento e transferência podem ser custosas se o parâmetro for
grande, e.g. um vetor longo.
Passagem de parâmetro por referência: Transmite um caminho de acesso, nor-
malmente apenas um endere¸co, para a fun¸cão chamada. Isso possibilita o acesso à
célula de memória que armazena o parâmetro real.
Este método é mais eficiente que o descrito anteriormente, uma vez que não é necessário
espa¸co duplicado, nem qualquer atividade de cópia.
Suas desvantagens são as seguintes:
– O acesso aos parâmetros se darão de forma mais lenta, pois mais um n´ıvel de
endere¸camento indireto é necessário.
– Mudan¸ca inadvertidas e errôneas poderão ser feitas no parâmetro real, caso seja
exigido somente uma comunica¸cão unidirecional com a fun¸cão chamada.
– Cria¸cão de apelidos. A passagem de referência torna dispon´ıveis caminhos de
acesso aos subprogramas chamados, ampliando o acesso deles à variáveis não lo-
cais. Neste método é poss´ıvel criar um apelido de diversas maneiras. Uma dessas
maneiras foi ilustrada nos problemas anteriores, quando definimos o que era ali-
sing.
5.4 Verifica¸cão dos tipos de parâmetros
O método de protótipo será utilizado, onde o tipo dos parâmetros formais são inclu´ıdos na
assinatura da fun¸cão ou procedimento, e são verificados tanto a quantidade de parâmetros

que foram passados quanto seus tipos. No caso particular de uma fun¸cão requisitar um
número real (float) e receber uma variável inteira (int), a conversão será feita (alargamento)
e não haverá problemas, enquanto que o caso contrário não será permitido (estreitamento),
pois pode ocorrer a perda de informa¸cões na conversão de reais para inteiros.
5.5 Subprogramas sobrecarregados ou genéricos
A linguagem suportará tanto a produ¸cão de subprogramas genéricos quanto a de
subprogramas polimórficos. Este tipo de subprograma permite que não seja necessário
criar duas ou mais versões do mesmo para diferentes parâmetros. Além disso, a linguagem
também dará suporte a cria¸cão de subprogramas sobrecarregados, tendo em vista que,
há casos em que é mais conveniente escrever duas ou mais fun¸cões com parâmetros, retorno
ou quantidade de argumentos deferentes mas, com o mesmo nome.
5.6 Sistema de Implementa¸cão
Algumas linguagens imperativas tem como passo primordial a compila¸cão. Isso permite
que o programador desenvolva programas que executem diretamente no hardware. Esse tipo
de sistema de implementa¸cão, na maioria dos casos, torna o programa eficiente. Porém,
quando estamos desenvolvendo grandes sistemas, torna-se necessário compilar o programa
por completo toda vez que forem feitas altera¸cões, o que pode ser muito custoso.
Nesse sentido, o sistema de implementa¸cão utilizado na linguagem é a compila¸cão se-
parada. Um dos fatores que justificam a escolha é a conveniência de que, mesmo em um
sistema de médio e baixo porte, o programador tenha a possibilidade de compilar apenas os
módulos alterados recentemente.

Cap´ıtulo 6
Sistema de tipos da linguagem
O sistema de tipos de uma linguagem é um aspecto de grande importância para a escolha
de uma linguagem para um determinado contexto. Ele quem define se uma linguagem faz
todas as verifica¸cões de tipos, tanto em tempo de compila¸cão quanto em tempo de execu¸cão,
o que determina se a linguagem é ou não fortemente tipada.
6.1 Principais caracter´ısticas do sistema de tipos
A linguagem proposta é fortemente tipada, em vista do alto grau de confiabilidade re-
querido pelas aplica¸cões de dom´ınio cient´ıfico, o qual essa caracter´ıstica provê. Desse modo,
qualquer erro de tipo é detectado durante a compila¸cão ou em tempo de execu¸cão.
Os tipos dos parâmetros de fun¸cões são verificados durante o tempo de execu¸cão.
6.2 Conversões de Tipos
As conversões de tipos serão permitidas são impl´ıcitas e expl´ıcitas, abaixo ambas são
descritas.
Impl´ıcitas: Somente conversões de alargamento serão permitidas. Ou seja, o tipo sofrerá
conversão impl´ıcita somente quando o tipo para o qual esta sendo feita a conversão contenha
a faixa de valores do tipo convertido.
Expl´ıcitas: As conversões expl´ıcitas são oferecidas pela linguagem. Elas serão usadas
pelo usuário através de fun¸cões. Como por exemplo a fun¸cão stringToInt(a:string):int.
6.3 Regras de compatibilidade de tipos
As regras de compatibilidade de tipos adotadas pela linguagem são compatibilidade por
nome e compatibilidade por estrutura. A compatibilidade entre tipos anônimos (cujo tipo
não é expl´ıcito na declara¸cão, por exemplo vetor) deve ser feitas através da compatibilidade
29

CAPÍTULO 6. SISTEMA DE TIPOS DA LINGUAGEM 30
por estruturas. Já as estruturas de dados criadas pelo usuário a compatibilidade é verificada
por nome. Abaixo explicamos as regras descritas acima.
Compatibilidade por nome: Duas variáveis são compat´ıveis por nome se tiverem o
mesmo nome de tipo, ou estiverem na mesma declara¸cão. Essa regra de compatibilidade é
de fácil implementa¸cão, embora seja altamente restritiva.
Compatibilidade por estrutura: Duas variáveis são compat´ıveis estruturalmente se
possu´ırem estruturas idênticas. Essa regra de compatibilidade é mais flex´ıvel que a primeira,
porém é mais dif´ıcil de implementar.

Documentação de uma linguagem de progração

Recomendados

Recomendados

Mais conteúdo relacionado

Semelhante a Documentação de uma linguagem de progração

Semelhante a Documentação de uma linguagem de progração (20)

Documentação de uma linguagem de progração