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]] e~§\ref{sec:grammar:types}.
* '''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 \verb|string| 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~§\ref{sec:grammar:globals}).

== 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: \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|).

=== 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 (\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 <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 \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.

==== 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 (\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|\|.

==== Estruturas ====

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|}|.

==== 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.


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