View source for S9 (language)

{{TOCright}}
<font color="red">THIS DESCRIPTION CORRESPONDS TO VERSION 200905031425</font>

'''OFFICIAL VERSION: https://fenix.ist.utl.pt/disciplinas/com-2/2008-2009/2-semestre/projecto'''

== Introdução ==

A linguagem S9 é uma linguagem imperativa e fortemente tipificada.

=== Tipos de dados ===

A linguagem define cinco tipos de dados manipuláveis, alguns dos quais estruturados. Ver também [[#Gramática|Gramática]].
* '''Números inteiros''' - Designados por <code>int</code>, ocupam 4 bytes em complemento para dois, alinhados a 32 bits.
* '''Números reais''' - Designados por <code>real</code>, ocupam 8 bytes em vírgula flutuante (norma IEEE 754).
* '''Cadeias de caracteres''' - Designadas por <code>string</code>, são terminadas pelo carácter com o valor 0 ASCII (NULL). As variáveis e literais do tipo <code>string</code> podem apenas ser utilizados em atribuições, em impressões e como argumentos/retornos de funções.
* '''Ponteiros''' - Designados pela palavra <code>ptr</code> e pelo tipo apontado, representam endereços de outros objectos, ocupando 4 bytes, alinhados a 32 bits. Podem ser objecto de operações aritméticas (deslocamentos) e permitem aceder ao valor apontado.
* '''Estruturas''' - Designados por <code>struct</code> e pelos elementos constituintes, representam tipos estruturados, i.e., organizações de objectos de outros tipos. A dimensão de uma estrutura (em bytes) depende da sua constituição.

=== Verificação de tipos ===

As operações em S9 dependem dos tipos de dados a que são aplicadas. Os tipos suportados por cada operador e a operação a realizar são indicados na definição das expressões (ver [[#Expressões|Expressões]]).

=== Manipulação de nomes ===

As entidades nomeadas (ver também [[#Identificadores|Identificadores]]) em S9 correspondem a tipos estruturados, constantes, variáveis e funções. Nos pontos que se seguem, usa-se o termo entidade para as designar indiscriminadamente, usando-se listas explícitas quando a descrição for válida apenas para um subconjunto.

==== Espaços de nomes ====

O espaço de nomes global é único, pelo que um nome utilizado para designar uma entidade num dado contexto não pode ser utilizado para designar outras (ainda que de natureza diferente).

==== Validade das variáveis ====

As entidades globais (declaradas fora de qualquer função), existem do início ao fim da execução do programa. As contantes e variáveis locais a uma função existem apenas durante a sua execução, e os argumentos formais são válidos enquanto a função está activa.

==== Visibilidade dos identificadores ====

Os identificadores estão visíveis desde a sua declaração até ao fim do seu alcance: ficheiro (globais) ou à função (locais). A reutilização de um identificador num contexto inferior encobre possíveis declarações em contextos superiores. Em particular, a redeclaração de um identificador numa função encobre o global até ao fim da função. Não é possível definir funções dentro de funções. É possível importar símbolos globais dentro de funções e seus contextos inferiores (visibilidade restringida), embora não seja possível defini-los (ver [[#Estruturas globais|Estruturas globais]]).

== Convenções Lexicais ==

Existem seis grupos de elementos lexicais (''tokens''). Em cada caso, é considerada a maior sequência de caracteres que constitua um elemento lexical válido.

=== Caracteres brancos ===

São considerados caracteres brancos aqueles que, embora servindo para separar os elementos lexicais, não representam nenhum elemento lexical. São considerados caracteres brancos: '''espaço''' ASCII SP (<code>0x20</code>), '''mudança de linha''' ASCII LF (<code>0x0A</code>, ou <code>\n</code>), '''recuo do carreto''' ASCII CR (<code>0x0D</code>, <code>\r</code>) e '''tabulação horizontal''' ASCII HT (<code>0x09</code>, ou <code>\t</code>).

=== Comentários ===

Os comentários funcionam como separadores de elementos lexicais. Existem dois tipos de comentários.
* '''Explicativos''' - Começam com a sequência <code>//</code> (desde que a sequência não faça parte de uma cadeia de caracteres), e acabam no fim da linha.
* '''Operacionais''' - Começam com <code>/*</code> e terminam com <code>*/</code> (desde que não façam parte de cadeias de caracteres). Podem estar aninhados.

=== Identificadores ===

Também designados por nomes, são iniciados por uma letra (maiúscula ou minúscula) ou por <code>_</code> (carácter sublinhado). O primeiro carácter é seguido por 0 (zero) ou mais letras, dígitos ou <code>_</code>. O número de caracteres que constituem um identificador é ilimitado e dois nomes designam identificadores distintos se houver alteração de maiúscula para minúscula, ou vice-versa, de pelo menos um carácter.

=== Palavras chave ===

As palavras indicadas de seguida estão reservados em S9 (palavras chave), não podendo ser utilizadas como identificadores. Estas palavras têm de ser escritas exactamente como indicado:
  const void int real ptr struct string public use sizeof
  next stop return if elif else while for

=== Literais ===

São notações para valores constantes de alguns tipos da linguagem (não confundir com constantes, i.e., identificadores que designam elementos cujo valor não pode sofrer alterações durante a execução do programa).

==== Inteiros ====

Um literal inteiro é um número não negativo (uma constante inteira pode, contudo, ser negativa: números negativos são construídos pela aplicação do operador menos unário (<code>-</code>) a um literal positivo).

Um literal inteiro em decimal é constituído por uma sequência de 1 (um) ou mais dígitos decimais (dígitos de 0 a 9) em que o primeiro dígito não é um 0 (zero), excepto no caso do número 0 (zero). Neste caso, é composto apenas pelo dígito único 0 (zero) (em qualquer base de numeração).

Um literal inteiro em octal começa sempre pelo dígito <code>0</code> (zero), sendo seguido de um ou mais dígitos de <code>0</code> a <code>7</code>. Um literal inteiro em hexadecimal começa sempre pela sequência <code>0x</code>, sendo seguido de um ou mais digitos de 0 a 9, de <code>a</code> a <code>f</code> ou de <code>A</code> a <code>F</code>. As letras de <code>a</code> a <code>f</code>, ou de <code>A</code> a <code>F</code>, representam os valores de 10 a 15 respectivamente. Um literal inteiro em binário começa sempre pela sequência <code>0b</code>, sendo seguido de um ou mais digitos 0 (zero) ou 1 (um).

Se não for possível representar o literal inteiro na máquina, devido a um overflow, deverá ser gerado um erro lexical.

==== Reais ====

Os literais reais são expressos em notação científica (tal como em C) ou em notação de engenharia, onde a parte exponencial não existe e o ponto decimal é substituído pelas letras
* <code>y</code> (yocto/iocto = ''10<sup>-24</sup>'' = <code>1E-24</code>),
* <code>z</code> (zecto = ''10<sup>-21</sup>'' = <code>1E-21</code>),
* <code>a</code> (atto/ato = ''10<sup>-18</sup>'' = <code>1E-18</code>),
* <code>f</code> (femto/fento = ''10<sup>-15</sup>'' = <code>1E-15</code>),
* <code>p</code> (pico = ''10<sup>-12</sup>'' = <code>1E-12</code>),
* <code>n</code> (nano = ''10<sup>-9</sup>'' = <code>1E-9</code>),
* <code>u</code> (micro = ''10<sup>-6</sup>'' = <code>1E-6</code>),
* <code>m</code> (milli/mili = ''10<sup>-3</sup>'' = 1E-3),
* <code>k</code> (kilo/quilo = ''10<sup>3</sup>'' = 1E+3),
* <code>M</code> (mega = ''10<sup>6</sup>'' = <code>1E+6</code>),
* <code>G</code> (giga = ''10<sup>9</sup>'' = <code>1E+9</code>),
* <code>T</code> (tera = ''10<sup>12</sup>'' = <code>1E+12</code>),
* <code>P</code> (peta = ''10<sup>15</sup>'' = <code>1E+15</code>),
* <code>E</code> (exa = ''10<sup>18</sup>'' = <code>1E+18</code>),
* <code>Z</code> (zetta/zeta = ''10<sup>21</sup>'' = <code>1E+21</code>),
* <code>Y</code> (yotta/yota = ''10<sup>24</sup>'' = <code>1E+24</code>).

Quando a notação for ambígua, é preferida a interpretação segundo a notação de engenharia.

==== Cadeias de caracteres ====

São consituídas por dois ou mais caracteres iniciadores seguidos, sem separadores, mas constituindo elementos lexicais distintos, bem como uma só cadeia de texto (opcionalmente, poderão existir caracteres brancos entre os elementos lexicais que compõem a cadeia de caracteres).

Os caracteres iniciadores podem ser valores inteiros, caracteres individuais ou cadeias de texto. Os valores inteiros em qualquer base, que representam um só carácter. Os caracteres individuais começam e terminam com o carácter plica (<code>'</code>) podendo conter um só carácter ou uma sequência especial iniciada por (<code>\</code>). Uma sequência especial pode ser representada pelos caracteres ASCII LF, CR e HT (<code>\n</code>, <code>\r</code> e <code>\t</code>, respectivamente), ou ainda a plica (<code>\'</code>) ou a barra (<code>\\</code>). Qualquer outro carácter pode ser representado por 1 ou 2 digitos hexadecimais precedidos do carácter <code>\</code>, por exemplo <code>\0a</code> ou apenas <code>\A</code> se o carácter seguinte não representar um digito hexadecimal.

Uma cadeia de texto, começa e termina com o carácter aspa (<code>"</code>), pode conter qualquer número de caracteres, podendo estes ser valores ASCII (excepto o 0 ou NULL). Dentro das cadeias de texto, os caracteres utilizados para iniciar ou terminar comentários têm o seu valor normal ASCII não iniciando ou terminando qualquer comentário. As mesmas sequências especiais dos caracteres individuais podem ser utilizados nas cadeia de texto, excepto a sequência <code>\'</code> que é substituída pela sequência <code>\"</code>. O carácter aspa (<code>"</code>) pode ser utilizado numa cadeia de texto, desde que precedido de <code>\</code>.

==== Estruturas ====

Os literais de estruturas são constituídos por sequências de outros literais separados por vírgulas (<code>,</code>). Estes literais são iniciados com <code>{</code> e terminados com <code>}</code>.

==== Ponteiros ====

O único literal admissível para ponteiros é <code>0</code> (zero), indicando o ponteiro nulo.

=== Operadores de expressões ===

São considerados operadores os seguintes elementos lexicais:
 -  +  #  *  /  %  ^  =  <  >  ==  >=  <=  !=  ||  &&  !  [  ] . @ ? sizeof

=== Delimitadores ===

Os elementos lexicais seguintes são considerados delimitadores/terminadores:
 ; ,

== Gramática ==

=== Gramática ===

A gramática da linguagem S9 pode ser resumida pelas regras abaixo. Considerou-se que os elementos em tipo fixo são literais, que os parênteses curvos agrupam elementos, que elementos alternativos são separados por uma barra vertical, que elementos opcionais estão entre parênteses rectos, que os elementos que se repetem zero ou mais vezes estão entre « e ». A barra vertical e os parênteses são elementos lexicais da linguagem quando representados em tipo fixo.


==== Elementos lexicais ====

Foram omitidos da gramática, por já terem sido definidos acima, os seguintes elementos: <code>identificador</code> ([[#Identificadores|Identificadores]]), <code>literal-inteiro</code> ([[#Inteiros|Inteiros]]), <code>literal-real</code> ([[#Reais|Reais]]), <code>carácter</code> ([[#Cadeias de caracteres|Cadeias de caracteres]]) e <code>cadeia</code> ([[#Cadeias de caracteres|Cadeias de caracteres]]).

==== Expressões ====

Foi omitida da gramática a regra corresponte à definição de expressões: serão tratadas em [[#Expressões|Expressões]].

==== Left value ====

Os elementos de uma expressão que podem ser utilizados como ''left-values'' encontram-se individualmente identificados em [[#Expressões|Expressões]]. Todos os ''left-values'' representam posições de memória passíveis de ser modificadas.

=== Constantes ===

A linguagem define identificadores constantes: precedem a declaração pela palavra reservada <code>const</code>, impedindo que o identificador declarado possa ser utilizado em operações que modifiquem o seu valor. Caso um identificador designe uma constante inteira não pública (ver [[#Estruturas globais|Estruturas globais]]) o seu valor deverá ser directamente substituído no código, não ocupando espaço.

=== Ficheiros ===

Os ficheiros descritos em S9 são uniformes, sendo o principal aquele que contiver a função principal, designada por <code>s9</code>.

=== Tipos estruturados ===

Uma estrutura permite agrupar um conjunto de valores de vários tipos.

==== Declaração ====

As estruturas em S9 são sempre designadas por identificadores constantes seguidas de um corpo com as definições dos campos que as compõem. Não existem estruturas com corpos vazios. Alternativamente, uma estrutura pode ser definida a partir de um modelo: definido por um literal exemplo ou por um intervalo entre dois inteiros (neste caso, a estrutura é constituída por tantos campos quantos os inteiros no intervalo indicado, sendo acedidos os seus campos pela posição que ocupam).

A declaração de uma estrutura sem corpo é utilizada para efectuar declarações antecipadas (utilizadas para pré-declarar estruturas que sejam usadas antes de serem definidas). Caso a declaração tenha corpo, define-se uma nova estrutura.

==== Estruturas globais ====

Uma estrutura pode ser utilizada fora do módulo onde foi definida, desde que não seja necessário conhecer a sua definição. A palavra reservada <code>public</code> designa uma estrutura globalmente visível no módulo actual e acessível a partir de outros módulos. A declaração de uma estrutura globalmente visível faz-se como nas declarações antecipadas (ver [[#Declaração|Declaração]]).

==== Inicialização por omissão ====

A inicialização por omissão aplica-se a cada campo da estrutura e é utilizada quando a inicialização ou operador de atribuição não contêm toda a informação necessária para preencher todos os campos. Quando se aplicam operadores sobre valores incompletos, os valores omitidos devem correspondem aos últimos campos da estrutura.

A inicialização de cada campo é como descrita para as variáveis e constantes ([[#Declaração de variáveis e constantes|Declaração de variáveis e constantes]]). Quando se reserva memória para uma estrutura, os valores por omissão devem ser respeitados.

====Declaração de variáveis e constantes  ====

Cada declaração permite declarar uma única variável ou constante. Uma declaração inclui os componentes descritos nos pontos seguintes.

==== Constante ====

Designada pela palavra reservada <code>const</code>, que torna o identificador constante, ou seja, cujo valor representado não pode ser modificado.

==== Símbolos globais ====

Existem dois qualificadores opcionais, que gerem a utilização de identificadores globais:
* '''Símbolos públicos''' - Designados pela palavra reservada <code>public</code>. Os identificadores são globalmente visíveis no módulo actual e acessíveis a partir de outros módulos.
* '''Pré-declarações''' - Designadas pela palavra reservada <code>use</code>, para o caso de constantes, variáveis ou funções, que podem estar declaradas mais à frente no ficheiro ou num outro ficheiro (possivelmente noutra linguagem).

Apenas é possível aplicar <code>use</code> a declarações. <code>public</code> pode também ser aplicada a definições.

==== Tipos de dados ====

Os tipos são como descrito em [[#Tipos de dados|Tipos de dados]].

==== Identificador ====

O identificador passa a nomear a entidade declarada.

==== Inicialização ====

A existir, inicia-se com o operador <code>=</code> seguido de expressão do tipo declarado: inteiro (uma expressão inteira), real (uma expressão real), ponteiro (uma expressão do tipo ponteiro), estrutura (uma expressão correspodente ao tipo da estrutura).

As cadeia de caracteres são (possivelmente) inicializadas com uma lista não nula de valores sem separadores (opcionalmente, poderão existir caracteres brancos entre os elementos lexicais que compõem a cadeia de caracteres). Os valores podem ser inteiros (ver [[#Cadeias de caracteres|Cadeias de caracteres]]), caracteres individuais ou cadeias de texto. Estes valores são sempre constantes, independentemente de o identificador que as designa ser constante ou não.

Estruturas com apenas um campo podem ser iniciadas a partir de elementos atómicos do tipo correspondente. Neste caso, os caracteres delimitadores do literal da estrutura são opcionais. Inicializadores de estruturas com valores por omissão devem obedecer às restrições descritas em~§\ref{sec:grammar:struct:defaults}.

Notar que declarações de constantes não iniciadas só são possíveis se corresponderem a identificadores pré-declarados, pertencentes a outros módulos.

== Funções ==

Uma função permite agrupar um conjunto de instruções num corpo, que é executado com base num conjunto de parâmetros (os argumentos formais) quando é invocada a partir de uma expressão. O programa tem início na função com nome <code>s9</code>.

=== Declaração ===

As funções em S9 são sempre designadas por identificadores constantes precedidos do tipo de dados devolvido pela função.

As funções que recebam argumentos devem indicá-los no cabeçalho. Funções sem argumentos definem um cabeçalho vazio.

Uma declaração de uma função sem corpo é utilizada para tipificar um identificador exterior ou para efectuar declarações antecipadas (utilizadas para pré-declarar funções que sejam usadas antes de ser definidas, por exemplo, entre duas funções mutuamente recursivas). Caso a declaração tenha corpo, define-se uma nova função.

=== Invocação ===

A função só pode ser invocada através de um identificador que refira uma função previamente declarada ou definida. 

Caso existam argumentos, na invocação da função, o seu identificador é seguido de uma lista de expressões delimitadas por parênteses curvos. A lista de expressões é uma sequência, possivelmente vazia, de expressões separadas por vírgulas. As expressões são avaliadas da direita para a esquerda antes da invocação da função (convenção Cdecl) e o valor resultante passado por cópia (passagem de argumentos por valor).

O número e tipo de parâmetros actuais deve ser igual ao número e tipo dos parâmetros formais da função invocada. Caso existam parâmetros opcionais, iniciados na declaração da função, os seus valores são utilizados na falta de parâmetros actuais e apenas se forem os últimos. A ordem dos parâmetros actuais deverá ser a mesma dos argumentos formais da função a ser invocada. Os parâmetros actuais devem ser colocados na pilha de dados pela ordem inversa da sua declaração (o primeiro no topo da pilha) e o endereço de retorno no topo da pilha.

A função chamadora coloca os argumentos na pilha e é também responsável pela sua remoção, após o retorno da função chamada (convenção Cdecl). Ainda de acordo com esta convenção, a passagem de retorno que não é possível colocar num registo é feita por referência passada como o primeiro argumento (i.e., o chamador reserva o espaço necessário e envia a localização à função invocada). 

=== Corpo ===

O valor devolvido por uma função, definido através do \textsl{left-value} especial que tem o mesmo nome da função, deve ser sempre do tipo declarado.

Se existir um valor declarado por omissão para o retorno da função (indicado pela notação <code>-></code> seguindo a assinatura da função), então deve ser utilizado se não for especificado outro. A especificação do valor de retorno por omissão é obrigatoriamente um literal do tipo indicado. É um erro especificar um valor de retorno se o tipo de retorno for <code>void</code>.

Uma instrução <code>return</code> causa a interrupção imediata da função.

== Instruções ==

Excepto quando indicado, as instruções são executadas em sequência, sendo os seus efeitos traduzidos, em geral, pela alteração do valor de variáveis.

=== Instrução condicional ===

Se a expressão que segue a palavra chave <code>if</code> for diferente de 0 (zero) então o bloco seguinte é executado. Caso existam cadeias com <code>elif</code> consecutivas, as suas expressões serão sucessivamente testadas, caso todas as condições anteriores sejam nulas (iguais a 0). Assim que uma dessas condições seja diferente de 0 (zero), o corpo correspondente é executado e a instrução termina. Caso exista uma palavra chave <code>else</code>, o seu corpo só é executado se nenhum dos anteriores corpos da instrução o tenha sido.

=== Instruções de iteração ===

A instrução <code>for</code> é semelhante à da linguagem C. O comportamento é controlado por três grupos de expressões, podendo o primeiro grupo corresponde a declarações de variáveis locais ao ciclo.

Existe um ciclo <code>while</code> análogo ao da linguagem C. A variante <code>while-else</code> permite que o corpo que segue a palavra reservada <code>else</code> seja executado quando a expressão de controlo do ciclo é inicialmente falsa (i.e., se o ciclo for executado, não é executada parte alternativa, mesmo que a condição fique falsa).

=== Intrução de retorno ===

Indicada pela palavra reservada <code>return</code>, a existir deverá ser a última instrução do bloco em que se insere. Ver [[#Corpo|Corpo]].

=== Instrução de continuação ===

Iniciada pela palavra reservada <code>next</code>, a existir deverá ser a última instrução do bloco em que se insere. Esta instrução reinicia o ciclo mais interior em que a instrução se encontrar, tal como a instrução <code>continue</code> em C. Quando seguida de um número inteiro ''n'', reinicia o ''n''-ésimo ciclo a contar do actual (''n=1''). Esta instrução só pode existir dentro de um ciclo.

=== Instrução de terminação ===

Iniciada pela palavra reservada <code>stop</code>, a existir deverá ser a última instrução do bloco em que se insere. Esta instrução termina a execução do ciclo interior em que a instrução se encontrar, tal como a instrução <code>break</code> em C. Quando seguida de um número inteiro ''n'', termina o ''n''-ésimo ciclo a contar do actual (''n=1''). Esta instrução só pode existir dentro de um ciclo.

=== Expressão como instrução ===

Qualquer expressão pode ser utilizada como instrução, mesmo que não produza qualquer efeito secundário. Caso a expressão seja terminada por <code>!</code> o seu valor deve ser impresso. O valor deve ser impresso em decimal para os valores do tipo <code>int</code> e em ASCII e ISO-LATIN-15 para valores do tipo <code>string</code>.

== Expressões ==

Uma expressão é uma representação algébrica de uma quantidade. Assim, todas as expressões devolvem um valor. As expressões em S9 utilizam operadores algébricos comuns: soma, subtracção, multiplicação e divisão inteira e resto da divisão, além de outros operadores.

As expressões são sempre avaliadas da esquerda para a direita, independentemente da associatividade do operador. A precedência dos operadores é a mesma para operadores na mesma secção, sendo as secções seguintes de menor prioridade que as anteriores. O valor resultante da aplicação da expressão bem como a sua associatividade são indicados para cada operador.

A tabela seguinte que resume os operadores em S9, por grupos de precedência decrescente:

TABELA

Os operadores que têm o mesmo nome que em C têm também o mesmo significado que em C.

=== Expressões primárias ===

==== Identificadores ====

Um identificador é uma expressão desde que tenha sido devidamente declarado. Um identificador pode denotar uma variável ou uma constante.

Um identificador é o caso mais simples de um ''left value'', i.e., uma entidade que pode ser utilizada no lado esquerdo (''left value'') de uma atribuição. O nome de uma função constitui um identificador especial dentro da função actual, designando o valor de retorno.

==== Expressões literais ====

Os literais podem ser valores constantes inteiros não negativos, reais, tal como definidos nas convenções lexicais, ou cadeias de caracteres. Ver [[#Literais|Literais]].

==== Parênteses curvos ====

Uma expressão entre parênteses curvos tem o valor da expressão sem os parênteses e permite alterar a prioridade dos operadores. Uma expressão entre parênteses não pode ser utilizada como ''left value'' (ver em indexação).

==== Indexação ====

Uma expressão indexação devolve o valor contido numa posição indicada por um ponteiro. Consiste de uma expressão ponteiro seguida do índice entre parênteses rectos. Se a expressão ponteiro for um ''left value'', então a expressão indexação poderá também ser um ''left value''.

Exemplos:
* <code>p[0]</code> (acesso à posição apontada por <code>p</code>);
* <code>a@p[0]</code> (acesso à posição apontada pelo campo <code>p</code> da estrutura <code>a</code>).

==== Invocação ====

Uma função só pode ser invocada através de um identificador que corresponda a uma função previamente declarada ou definida.

==== Leitura ====

A operação de leitura de um valor inteiro ou real pode ser efectuado pela expressão <code>@</code>, que devolve o valor lido, de acordo com o tipo esperado (inteiro ou real). Caso se use como argumento do operador de impressão (<code>!</code>), deve ser lido um inteiro.

==== Acesso a um campo ====

O acesso a campos de estruturas faz-se através do operador <code>.</code> e pela indicação do nome do campo (tal como em C) ou através da indicação da posição do campo na estrutura (como se de um vector se tratasse), através do operador <code>@</code>, sendo a primeira posição designada pelo valor 0 (zero).

Exemplos (sendo <code>a</code> uma variável com o campo <code>x</code>):
* <code>a.x</code> (acesso ao campo <code>x</code> de <code>a</code>);
* <code>a@0</code> (acesso ao 1º campo de <code>a</code>).

=== Expressões unárias ===

==== Identidade ====

A expressão identidade (<code>+</code>) devolve o valor do seu argumento inteiro ou real.

==== Simétrico ====

A expressão valor simétrico (<code>-</code>) devolve o simétrico do seu argumento inteiro ou real.

==== Reserva de memória ====

A expressão reserva de memória (<code>#</code>) devolve o ponteiro que aponta para a zona de memória na pilha da função actual contendo espaço suficiente para o número de objectos indicados pelo seu argumento inteiro. O tipo de retorno é idêntico ao do left-value utilizado e o espaço deve ser calculado em função do tipo apontado.

=== Expressão de potência ===

A operação é apenas aplicável a valores inteiros, devolvendo a multiplicação do primeiro argumento por ele próprio tantas vezes quantas o valor do segundo argumento.

=== Expressões aditivas ===

As operações são apenas aplicáveis a valores inteiros e reais, devolvendo o resultado da respectiva operação algébrica.

Estas operações podem realizar-se sobre ponteiros, tendo o significado das operações correspondentes em C/C++:
:(i) deslocamentos, i.e., um dos operandos deve ser do tipo ponteiro e o outro do tipo inteiro;
:(ii) diferenças de ponteiros, i.e., apenas quando se aplica o operador <code>-</code> a dois ponteiros do mesmo tipo (o resultado é o número de objectos do tipo apontado entre eles).

=== Expressões multiplicativas ===

As operações são apenas aplicáveis a valores inteiros e reais, devolvendo o resultado da respectiva operação algébrica.

=== Expressões de grandeza ===

As operações são aplicáveis a valores inteiros ou reais devolvendo o valor inteiro 0 (zero) caso seja falsa e um valor diferente de zero caso contrário.

=== Expressões de igualdade ===

As operações são aplicáveis a valores inteiros e reais, tal como no caso anterior.

=== Expressões de negação lógica ===

A operação é aplicável a valores inteiros, devolvendo o valor inteiro 0 (zero) caso o argumento seja diferente de 0 (zero) e um valor diferente de zero caso contrário.

=== Expressões de junção lógica ===

A operação é aplicável a valores inteiros, devolvendo um valor diferente de zero caso ambos os argumentos sejam diferente de 0 (zero) e um valor diferente de zero caso contrário. Caso o primeiro argumento seja 0 (zero) o segundo argumento não deve ser avaliado.

=== Expressões de alternativa lógica ===

A operação é aplicável a valores inteiros, devolvendo o valor inteiro 0 (zero) caso ambos os argumentos sejam iguais a 0 (zero) e um valor diferente de zero caso contrário. Caso o primeiro argumento seja um valor diferente de zero o segundo argumento não deve ser avaliado.

=== Expressões de atribuição ===

O valor da expressão do lado direito do operador é guardado na posição indicada pelo left-value do lado esquerdo do operador de atribuição. Só podem atribuídos valores a variáveis do mesmo tipo.

=== Expressão "sizeof" ===

Indica o número de bytes realmente ocupados pela representação em memória do objecto ou do tipo indicados como argumento. Retorna um valor inteiro.

Exemplos:
* <code>sizeof(1+2)</code> indica a dimensão do objecto resultante da avaliação (um inteiro);
* <code>sizeof(int)</code> e <code>sizeof(A)</code> são expressões que indicam o tamanho dos tipos indicados (assume-se, neste exemplo, que <code>A</code> é o identificador de um tipo estruturado).

=== Expressão de indicação de posição ===

Expressa pelo operador sufixo <code>?</code>, indica o endereço do objecto (endereçável) indicado como argumento. Retorna um valor do tipo do ponteiro apropriado para o objecto em causa.

Exemplos:
* <code>a?</code> (indica o endereço de <code>a</code>);
* <code>a@1?</code> (indica a posição do segundo campo de <code>a</code>).

== Exemplos ==

Os exemplos apresentados não são exaustivos, pelo que não ilustram todos os aspectos da linguagem.

O cálculo da função de Ackermann: esta função tem um crescimento muito rápido pelo que nos computadores actuais, mesmo utilizando C, os argumentos não deverão exceder m=3 e n=12 para executar em poucos segundos.

<c>
  public int cnt = 0;
  public int ackermann(int m, int n) {
    cnt = cnt + 1;
    if (m == 0) ackermann = n+1;
    elif (n == 0) ackermann = ackermann(m-1, 1);
    else ackermann = ackermann(m-1, ackermann(m, n-1));
  }
  public int getcnt() { getcnt = cnt; }
</c>

Exemplo da utilização das funções noutro ficheiro:

<c>
use int argc();
use string argv(int n);
use int ackermann(int m, int n);
use int getcnt();

public int s9() -> 0 {
  int m = 0;
  int n = 0;
  "Teste para a função de Ackermann\n"!
  "Introduza M (<3): "! m = @;
  "Introduza N (<5): "! n = @;
  "Valor de ackermann("! m! ", "! n! "): "! ackermann(m, n)! "\n"!
  "Calls to ackermann: "! getcnt()! "\n"!
}
</c>

[[category:Compilers]]
[[category:Teaching]]