Modula-2

Origem: Wikipédia, a enciclopédia livre.
Ir para: navegação, pesquisa
Modula-2
Paradigma Imperativa, Estruturada, Modular
Surgido em 1978
Criado por Niklaus Wirth
Estilo de tipagem: Forte, Estática
Compiladores Native-XDS
Dialetos: PIM2, PIM3, PIM4, ISO
Influenciada por Pascal,Modula, Mesa, ALGOL, Simula-67
Influenciou Modula-3, Oberon, Ada, Fortran 90, Lua, Zonnon, Modula-GM

Descrição[editar | editar código-fonte]

Modula-2 é uma linguagem de programação projetada e criada por Niklaus Wirth no Instituto Federal de Tecnologia de Zurique (ETH), em torno de 1978, e surgiu a partir da necessidade de criar uma linguagem prática, eficiente e essencialmente independente do hardware sobre o qual fosse executada. É descendente, principalmente, de duas outras linguagens: o Modula e o Pascal. Da primeira herdou o nome e o conceito de módulos, além da sintaxe sistemática e moderna, dentre outras características, do Pascal. Assim como seus precursores, o Modula-2 classifica-se dentre as linguagens do Paradigma Imperativo.

Sua história é intrínseca a do Projeto de Lilith, cujo objetivo explícito era usar uma mesma linguagem para todos seus softwares, alinhado à necessidade de utilizar uma linguagem de programação estruturada e simples para que, além da construção de sistemas grandes e complexos, também fosse capaz de expressar toda a gama de programas necessários para tornar Lilith em uma poderosa ferramenta de desenvolvimento de software. A solução para tal necessidade foi à concepção de uma linguagem que viabiliza a criação de módulos que podem ser compilados separadamente e que possuem checagem completa de tipos, além de suporte à programação concorrente.


Vertentes[editar | editar código-fonte]


O Modula-2 possui duas principais vertentes. Seguem algumas das variantes entre as elas:

PIM 
Denominada com o nome do livro "Programming in Modula-2" de Niklaus Wirth, que por sua vez teve três edições principais, cada uma descrevendo as ligeiras variantes da mesma;
  • PIM2 (1983): A cláusula “EXPORT” deve ser explicitamente declarada na criação de “DEFINITION MODULE”;
  • PIM3 (1985): A cláusula “EXPORT” foi suprimida nos módulos de definição, pois tudo que se encontra dentro de um “DEFINITION MODULE” define a interface para esse módulo, removendo assim a redundância;
  • PIM4 (1989): Especificado o comportamento do operador “MOD” quando os operandos são negativos e do tipo "ARRAY OF CHAR" para sempre serem encerrados com “ASCII-NUL”;


ISO 
Foi concebida a partir do esforço de sua padronização pela Organização Internacional de Normalização.
  • ISO (1996): O ISO Modula-2 resolveu a maioria das ambigüidades existentes no PIM Modula-2. Acrescentaram os tipos de dados “COMPLEX” e “LONGCOMPLEX”, tratamento de exceções, a criação da cláusula “FINALLY” e uma completa e padronizada biblioteca de Entrada/Saída (do inglês I/O, Input/Output), além do outras inúmeras variantes menores.


Boa prática[editar | editar código-fonte]


O conceito de módulo pode ser usado para encapsular um conjunto de subprogramas e estruturas de dados, sendo importante tanto para a reusabilidade de código-fonte, quanto à restrição de visibilidade desnecessária de determinadas partes do programa, pois, exceto para identificadores padrão, nenhum objeto de escopos externos são visíveis dentro de um módulo a menos que explicitamente importados, ou então, nenhum objeto interno do módulo é visível de um escopo exterior, a menos que explicitamente exportados. Sua implementação é composta de duas partes:

  • Módulo de definição (do inglês DEFINITION MODULE): Contém apenas a interface, ou seja, os protótipos de “PROCEDURE” que serão exportados (visível para outros módulos).
  • Módulo de execução (do inglês IMPLEMENTATION MODULE): Contém o código de trabalho que é interno ao módulo, ou seja, a codificação de cada “PROCEDURE”.


Soluções Desenvolvidas[editar | editar código-fonte]


Além dos softwares criados para o Lilith, é possível encontrar diversos módulos gratuitos e disponíveis para download, como por exemplo, módulos para expressões regulares, interface com banco de dados MySQL, leitura de arquivos XML, criação de arquivos Excel, compactação e descompactação de arquivos, dentre outros.

Sintaxe[editar | editar código-fonte]

A sintaxe básica do Modula-2 será apresentada a seguir com alguns exemplos:

Palavras Reservadas
São palavras chaves que ajudam o compilador a reconhecer a construção da linguagem, portanto não podem ser utilizadas pelo programador como identificadores.
AND         ELSIF           LOOP       REPEAT
ARRAY       END             MOD        RETURN
BEGIN       EXIT            MODULE     SET
BY          EXPORT          NOT        THEN
CASE        FOR             OF         TO
CONST       FROM            OR         TYPE
DEFINITION  IF              POINTER    UNTIL
DIV         IMPLEMENTATION  PROCEDURE  VAR
DO          IMPORT          QUALIFIED  WHILE
ELSE        IN              RECORD     WITH
Identificadores
São os nomes definidos pelo programador para representar constantes, variáveis, procedures, etc. Um identificador não é válido quando inicia com um número ou possui caracteres que não são letras ou números.
Exemplos:
  • Declaração correta
     VAR n : CARDINAL;
  • Declaração incorreta
     VAR 123número : CARDINAL;
     
Identificadores Padrão
Não precisam ser declarados.
ABS         EXCL            LONGINT    REAL
BITSET      FALSE           LONGREAL   SIZE
BOOLEAN     FLOAT           MAX        TRUE
CAP         HALT            MIN        TRUNC
CARDINAL    HIGH            NIL        VAL
CHAR        INC             ODD
CHR         INCL            ORD
DEC         INTEGER         PROC
Operadores
+       Adição, união de conjuntos
-       Subtração, diferença de conjuntos
*       Multiplicação, interseção de conjuntos
/       Divisão
&   " E " lógico
~       " NÃO " lógico
Operadores relacionais
=       Igual
#       Diferente
<    Menor que
>    Maior que
:=      Atribuição
<=   Menor ou igual a
>=   Maior ou igual a
' "        Strings
< >       Diferente
(**)    Comentários
Delimitadores
.       Ponto
,       Vírgula
;       Ponto e vírgula
:       Dois pontos
|       Barra vertical
^       Derreferenciador
Forma de pares
( )     Expressões, tipos de enumeração
{ }     Conjuntos
[ ]     Tipo subfaixa, indexação de arrays
Estruturas de Atribuição/Controle
Permite que dentro de um bloco de comandos, exista uma tomada de decisão quanto a instrução a ser executada ou então a repetição de um determinado bloco de instruções.
ATRIBUIÇÃO              WHILE     WITH 
Chamada de procedure    REPEAT    EXIT 
IF                      LOOP      RETURN 
CASE                    FOR 


Exemplos[editar | editar código-fonte]

Hello World[editar | editar código-fonte]

   MODULE hello;
     FROM InOut IMPORT writestring, writeln;
     BEGIN
       WriteString("Hello, world!");
       Writeln;
   END hello.

Manipulação de Vetor com FOR[editar | editar código-fonte]

   MODULE  Vetores;
     FROM InOut IMPORT ReadCard,WriteCard,WriteLn,WriteString;
      VAR    Index      :  CARDINAL;
             Automoveis :  ARRAY  [1..12]  OF  CARDINAL;
      BEGIN
        FOR  Index  :=  1  TO  12   DO
          Automoveis [Index] := Index + 10;
        END;
        Automoveis [7] := 54;
        WriteString ( " Este é o primeiro programa com um vetor. ");
        WriteLn;
        WriteLn;                
        FOR  Index  :=  1  TO  12  DO
          WriteString( " Numero do Automovel " );
          WriteCard( Index , 3);
          WriteString( " Possui o valor de " );
          WriteCard( Automoveis [Index] , 3);
          WriteLn;
        END;
    END  Vetores.
Através do exemplo acima, podem ser feitas as seguintes observações sobre a sintaxe:
  • Um programa em Modula-2 deve ser iniciado com a palavra “MODULE” seguido do nome do programa (“Vetores” no exemplo acima) e um símbolo “;”. O término do mesmo deve ser feito utilizando a palavra “END” seguido do nome do módulo novamente e de um símbolo “.”
  • A “Lista de Importações” determina as entidades a serem importadas. A palavra reservada “FROM” pode ser omitida caso após a palavra “IMPORT” contenha o nome do módulo.
Ex: A lista de importações pode ser feita das seguintes maneiras:
     IMPORT IO
     ...
     IO.WrStr(“Não utilizando FROM”);
     ...
     
     ou
     
     FROM IO IMPORT WrStr
     ...
     WrStr(“Não utilizando FROM”);
     ...
  • A declaração das variáveis a serem utilizadas dentro do bloco de comandos devem ser feitas após a palavra “VAR”, seguidos do nome da variável, do símbolo “:”, o tipo da variável e o símbolo “;”
  • Os blocos contendo os comandos devem ser escritas entre as palavras “BEGIN ... END;”. Após o final de cada comando deve conter o símbolo “;”

Fatorial utilizando Sub Rotina[editar | editar código-fonte]

   MODULE fatorial;
     FROM InOut IMPORT ReadCard,WriteCard,WriteLn,WriteString;
     VAR n : CARDINAL;
     PROCEDURE Fat(n : CARDINAL) : CARDINAL;
     BEGIN
       IF n=0 THEN 
         RETURN 1
       ELSE
         RETURN n*Fat(n-1);
       END;
     END Fat;
   BEGIN
     WriteString("Este modulo calcula o fatorial de 'N'");
     WriteLn;WriteLn;
     WriteString("Entre com o valor de 'N':");
     ReadCard(n);
     WriteLn;WriteLn;
     WriteString("O fatorial de");
     WriteCard(n,3);
     WriteString("  e'");
     WriteCard(Fat(n),6);
   END fatorial.

Cálculo dos Números Perfeitos[editar | editar código-fonte]

   MODULE perfectNumbers;
     FROM InOut IMPORT ReadCard,WriteCard,WriteLn,WriteString;
     VAR n           : CARDINAL;
         loop         : CARDINAL;
         soma         : CARDINAL;
         loopInterno  : CARDINAL;
   BEGIN
     WriteString("Calculo de numeros perfeitos");
     WriteLn;
     WriteString("Digite o valor de N - inteiro");
     ReadCard(n);
     IF(n > 0) THEN
       loopInterno:=0;
     FOR loop:=1 TO n DO
       soma := 0;
       FOR loopInterno:=1 TO loop-1 DO
          IF(loop MOD loopInterno = 0)THEN
            soma := soma + loopInterno;
          END;
       END;
       IF(soma =loop)THEN
         WriteString("Perfeito:");
         WriteCard(soma,6);
         WriteLn;
       END;
     END;
     ELSE
       WriteString("Numero invalido");
     END;
   END perfectNumbers.


Compiladores[editar | editar código-fonte]

Livros[editar | editar código-fonte]

Ligações externas[editar | editar código-fonte]

Ícone de esboço Este artigo sobre programação de computadores é um esboço. Você pode ajudar a Wikipédia expandindo-o.