Contents |
THIS DESCRIPTION CORRESPONDS TO VERSION 200905031425
OFFICIAL VERSION: https://fenix.ist.utl.pt/disciplinas/com-2/2008-2009/2-semestre/projecto
A linguagem S9 é uma linguagem imperativa e fortemente tipificada.
A linguagem define cinco tipos de dados manipuláveis, alguns dos quais estruturados. Ver também Gramática e~§\ref{sec:grammar:types}.
int, ocupam 4 bytes em complemento para dois, alinhados a 32 bits.real, ocupam 8 bytes em vírgula flutuante (norma IEEE 754).string, são terminadas pelo carácter com o valor 0 ASCII (NULL). As variáveis e literais do tipo \verb|string| podem apenas ser utilizados em atribuições, em impressões e como argumentos/retornos de funções.ptr 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.struct 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.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).
As entidades nomeadas (ver também 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.
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).
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.
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~§\ref{sec:grammar:globals}).
Existem seis grupos de elementos lexicais (tokens). Em cada caso, é considerada a maior sequência de caracteres que constitua um elemento lexical válido.
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: \textbf{espaço} ASCII SP (\verb|0x20|, ou \verb*| |), \textbf{mudança de linha} ASCII LF (\verb|0x0A|, ou \verb|\n|), \textbf{recuo do carreto} ASCII CR (\verb|0x0D|, \verb|\r|) e \textbf{tabulação horizontal} ASCII HT (\verb|0x9|, ou \verb|\t|).
Os comentários funcionam como separadores de elementos lexicais. Existem dois tipos de comentários.
// (desde que a sequência não faça parte de uma cadeia de caracteres), e acabam no fim da linha./* e terminam com */ (desde que não façam parte de cadeias de caracteres). Podem estar aninhados.Também designados por nomes, são iniciados por uma letra (maiúscula ou minúscula) ou por _ (carácter sublinhado). O primeiro carácter é seguido por 0 (zero) ou mais letras, dígitos ou _. 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.
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
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).
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 (\verb|-|) 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 \verb|0| (zero), sendo seguido de um ou mais dígitos de \verb|0| a \verb|7|. Um literal inteiro em hexadecimal começa sempre pela sequência 0x, sendo seguido de um ou mais digitos de 0 a 9, de a a f ou de A a F. As letras de a a f, ou de A a F, representam os valores de 10 a 15 respectivamente. Um literal inteiro em binário começa sempre pela sequência 0b, 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.
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 \verb|y| (yocto/iocto = $10^{-24}$ = \verb|1E-24|), \verb|z| (zecto = $10^{-21}$ = \verb|1E-21|), \verb|a| (atto/ato = $10^{-18}$ = \verb|1E-18|), \verb|f| (femto/fento = $10^{-15}$ = \verb|1E-15|), \verb|p| (pico = $10^{-12}$ = \verb|1E-12|), \verb|n| (nano = $10^{-9}$ = \verb|1E-9|), \verb|u| (micro = $10^{-6}$ = \verb|1E-6|), \verb|m| (milli/mili = $10^{-3}$ = 1E-3), \verb|k| (kilo/quilo = $10^3$ = 1E+3), \verb|M| (mega = $10^6$ = \verb|1E+6|), \verb|G| (giga = $10^9$ = \verb|1E+9|), \verb|T| (tera = $10^{12}$ = \verb|1E+12|), \verb|P| (peta = $10^{15}$ = \verb|1E+15|), \verb|E| (exa = $10^{18}$ = \verb|1E+18|), \verb|Z| (zetta/zeta = $10^{21}$ = \verb|1E+21|), \verb|Y| (yotta/yota = $10^{24}$ = \verb|1E+24|). Quando a notação for ambígua, é preferida a interpretação segundo a notação de engenharia.
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 (\verb|'|) podendo conter um só carácter ou uma sequência especial iniciada por (\verb|\|). Uma sequência especial pode ser representada pelos caracteres ASCII LF, CR e HT (\verb|\n|, \verb|\r| e \verb|\t|, respectivamente), ou ainda a plica (\verb|\'|) ou a barra (\verb|\\|). Qualquer outro carácter pode ser representado por 1 ou 2 digitos hexadecimais precedidos do carácter \verb|\|, por exemplo \verb|\0a| ou apenas \verb|\A| se o carácter seguinte não representar um digito hexadecimal.
Uma cadeia de texto, começa e termina com o carácter aspa (\verb|"|), 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 \verb|\'| que é substituída pela sequência \verb|\"|. O carácter aspa (\verb|"|) pode ser utilizado numa cadeia de texto, desde que precedido de \verb|\|.
Os literais de estruturas são constituídos por sequências de outros literais separados por vírgulas (\verb|,|). Estes literais são iniciados com \verb|{| e terminados com \verb|}|.
O único literal admissível para ponteiros é 0 (zero), indicando o ponteiro nulo.
São considerados operadores os seguintes elementos lexicais:
- + # * / % ^ = < > == >= <= != || && ! [ ] . @ ? sizeof
Os elementos lexicais seguintes são considerados delimitadores/terminadores:
; ,
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.
Foram omitidos da gramática, por já terem sido definidos acima, os seguintes elementos: identificador (Identificadores), literal-inteiro (Inteiros), literal-real (Reais), carácter (Cadeias de caracteres) e cadeia (Cadeias de caracteres).
Foi omitida da gramática a regra corresponte à definição de expressões: serão tratadas em Expressões.
Os elementos de uma expressão que podem ser utilizados como left-values encontram-se individualmente identificados em Expressões. Todos os left-values representam posições de memória passíveis de ser modificadas.
A linguagem define identificadores constantes: precedem a declaração pela palavra reservada \verb|const|, 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) o seu valor deverá ser directamente substituído no código, não ocupando espaço.
Os ficheiros descritos em S9 são uniformes, sendo o principal aquele que contiver a função principal, designada por s9.
Uma estrutura permite agrupar um conjunto de valores de vários tipos.
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.
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 public 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).
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). Quando se reserva memória para uma estrutura, os valores por omissão devem ser respeitados.
Cada declaração permite declarar uma única variável ou constante. Uma declaração inclui os componentes descritos nos pontos seguintes.
Designada pela palavra reservada const, que torna o identificador constante, ou seja, cujo valor representado não pode ser modificado.
Existem dois qualificadores opcionais, que gerem a utilização de identificadores globais:
public. Os identificadores são globalmente visíveis no módulo actual e acessíveis a partir de outros módulos.Apenas é possível aplicar \verb|use| a declarações. \verb|public| pode também ser aplicada a definições.