Section courante

A propos

Section administrative du site

Les modules

Le compilateur Pascal accepte deux types d'unités de compilation : un programme et un module. Un module est une routine autonome, telle qu'une routine de bibliothèque, à laquelle d'autres modules et programmes peuvent accéder et exécuter. Un module permet la compilation séparée de code et de données encapsulés.

L'unité de compilation de module est une extension CRI de la norme ISO niveau 1 Pascal.

Les modules sont normalement définis comme des ensembles de données de bibliothèque. Pour plus d'informations sur la génération et la maintenance des ensembles de données de bibliothèque sous COS, consultez la description de BUILD. La commande ar crée des bibliothèques sous UNICOS. (Lorsque vous utilisez l'éditeur de liens ld de UNICOS, spécifiez la bibliothèque contenant les modules avec l'option -L plutôt que l'option -l.)

En termes de structure, un module est similaire à un programme, sauf qu'il n'a pas de paramètres de programme et pas de bloc de programme principal délimité par les mots réservés BEGIN et END. Un module contient une série de procédures et de fonctions internes et accepte également des routines externes référencées à partir de programmes ou d'autres modules.

La syntaxe d'un module est la suivante :

module = "module" id ";" module-block "." .

module-block = {
   constant-def-part
   type-def-part
   common-dcl-part
   imported-dcl-part
   exported-dcl-part
   static-dcl-part
   var-dcl-part
}
[ value-def-part ]
{ procedure-and-function-dcl-part } .

Un module ne peut pas être directement référencé par un appelant. En revanche, les procédures et fonctions situées au niveau le plus externe d'un module peuvent être exportées et donc référencées (comme importées) par d'autres modules et programmes. Les procédures et fonctions n'étant pas au niveau le plus externe peuvent être référencées par des procédures et fonctions exportées mais ne peuvent pas être exportées elles-mêmes.

Les données sont communiquées entre les modules et les programmes uniquement par le biais de paramètres. Un module appelé à partir d'un programme ne peut pas utiliser les variables globales déclarées dans le programme à moins qu'elles ne soient passées en tant que paramètres. Les constantes et les types définis au niveau du module permettent à l'utilisateur de passer des paramètres structurés, tels que des enregistrements.

Aucune vérification de type n'est effectuée entre les modules. Par conséquent, vous devez garantir la compatibilité de type entre les modules et les programmes en utilisant une méthode de déclarations de TYPE communes.

Les variables déclarées au niveau du module sont globales au sein du module. Cela permet aux règles de portée normales de s'appliquer au sein du module, mais masque les variables du module aux routines extérieures au module. Étant donné que les variables du module sont allouées de manière statique (pas sur la pile d'exécution), les variables conservent leurs valeurs d'un appel à l'autre.

Les modules ne prennent pas en charge les fichiers texte prédéfinis INPUT et OUTPUT. Vous devez transmettre ces fichiers en tant que paramètres. Dans l'exemple suivant, une pile cachée est utilisée pour contenir les jetons à évaluer. Si plusieurs piles sont nécessaires, les piles peuvent être déclarées dans le programme et le code modifié pour transmettre la pile souhaitée aux routines STK$.

  1. PROGRAM pushpop(INPUT,OUTPUT);
  2.  TYPE token = PACKED ARRAY[1..8] OF CHAR;
  3.  VAR t,t1,r:token;
  4.  
  5. PROCEDURE push(t:token); IMPORTED(stk$push);
  6. PROCEDURE pop(VAR t:token); IMPORTED(stk$pop);
  7. PROCEDURE stackinit; IMPORTED(stk$init);
  8. FUNCTION empty:BOOLEAN; IMPORTED(stk$mt);
  9. FUNCTION full:BOOLEAN; IMPORTED(stk$full);
  10. PROCEDURE gettok(VAR t:token;VAR fromfile:TEXT); IMPORTED(token);
  11. PROCEDURE crunch(VAR t1,t2,t3 : token); IMPORTED(doittoit);
  12. PROCEDURE error(i:INTEGER);IMPORTED;
  13.  
  14. BEGIN (* Code de programme principal *)
  15.  stackinit; (* Initialise la pile *)
  16.  gettok(t,INPUT);
  17.  WHILE t<>'        ' DO BEGIN
  18.   IF t = '(        ' THEN push(t) ELSE 
  19.   IF t = ')        'THEN BEGIN
  20.    pop(tl);
  21.    crunch(t,tl,r);
  22.    push(r)
  23.   END
  24.    ELSE 
  25.   error(l); (* Jeton ignoré *)
  26.   gettok(t,INPUT);
  27.  END;
  28.  IF NOT empty THEN error(2) (* La pile de jetons n'est pas vide à la fin *)
  29.               ELSE WRITELN(' La réponse est  : ',r);
  30. END.

Les procédures utilisées dans ce programme peuvent être codées dans un module tel que celui-ci. Ce module déclare certaines des routines mentionnées dans le programme et en référence d'autres via la directive IMPORTED.

  1. MODULE stk;
  2.  
  3. TYPE token=PACKED ARRAY[1..8] OF CHAR;
  4.      astack=RECORD
  5.       stackptr:INTEGER;
  6.       stack:ARRAY[1..1024] OF token;
  7.      END;
  8. VAR thestack:astack;
  9.  
  10. PROCEDURE stk$init;EXPORTED;BEGIN
  11.  thestack.stackptr:=0;
  12. END;
  13.  
  14. FUNCTION stkfull:BOOLEAN;EXPORTED(stk$full);BEGIN
  15.  stkfull:=thestack.stackptr > 1024;
  16. END;
  17.  
  18. PROCEDURE stkempty:BOOLEAN;EXPORTED(stk$mt);BEGIN
  19.  stkempty := thestack.stackptr = 0;
  20. END;
  21.  
  22. PROCEDURE error(i:INTEGER); IMPORTED;
  23.  
  24. PROCEDURE push(t:token); EXPORTED(stk$push);BEGIN
  25.  IF stkfull THEN BEGIN (* OUPS! *)
  26.   error(2);
  27.   HALT;
  28.  END
  29.   ELSE 
  30.  WITH thestack DO BEGIN
  31.   stackptr := stackptr + 1;
  32.   stack [stackptr] := t;
  33.  END;
  34. END;
  35.  
  36. PROCEDURE pop(VAR t:token); EXPORTED(stk$pop);BEGIN
  37.  IF stkempty THEN BEGIN (* OOPS! *)
  38.   error(3);
  39.   HALT;
  40.  END
  41.   ELSE 
  42.  WITH thestack DO BEGIN
  43.   t:=stack[stackptr];
  44.   stackptr:=stackptr-1;
  45.  END;
  46. END.

Dernière mise à jour : Vendredi, le 13 octobre 2017