Module n'est pas un programme exécutable, mais contient uniquement un ensemble de fonctionnalités à utiliser dans un programme exécutable : types de données, variables, procédures et fonctions. Le texte source du module porte l'extension .pas. Le module est compilé séparément du programme principal, le module compilé porte l'extension .tpu (Turbo Pascal Unit). Un module compilé peut être utilisé dans le programme principal en utilisant la clause uses, qui est écrite immédiatement après le nom du programme.
Turbo Pascal a des modules standards : DOS, CRT (tube cathodique, tube cathodique), imprimante, graphique, système autre. Ils n'ont pas besoin d'être décrits, mais peuvent être immédiatement inclus dans le programme avec la clause uses. Le module System est utilisé dans tous les programmes, donc une exception est faite pour lui, vous ne pouvez pas l'inclure dans la clause uses, il sera inclus automatiquement. D'autres modules doivent être inclus dans la clause uses si le programme utilise les ressources du module, telles que les procédures et les fonctions.
Structure des modules
Le module a la structure suivante :
unité< имя >;
Interface
< интерфейсная часть >
Mise en œuvre
< исполняемая часть >
[Commencer< инициирующая часть > ]
finir.
Ici:
unité- mot de code (module anglais); démarreur d'en-tête de module ;
<имя>
- nom du module (identifiant correct) ;
Interface- mot de code qui démarre la partie interface du module ;
Mise en œuvre- mot de code (implémentation en anglais) ; lance la partie exécutable ;
Commencer- mot de code qui commence la partie d'initiation ;
(partie du module Begin< инициирующая часть >optionnel);
finir.- signe de fin de module.
Ainsi, un module se compose d'un en-tête et de trois composants, chacun pouvant être vide.
La partie interface s'ouvre avec un mot de code Interface. Cette partie contient les déclarations de tous les objets globaux du module (types, constantes, variables et sous-programmes) qui doivent être mis à la disposition du programme principal et/ou d'autres modules.
Il est à noter que toutes les constantes et variables déclarées dans la partie interface du module, ainsi que les objets globaux du programme principal, sont placés par le compilateur Turbo-Pascal dans une multitude de segments de données (la longueur maximale des segments est de 65521 octets ).
L'ordre dans lequel les différentes sections d'annonces apparaissent et leur nombre peut être arbitraire.
Dans la partie interface des modules, la description directe ne peut pas être utilisée.
Partie exécutable
La partie exécutable commence par un mot de code Mise en œuvre et contient les corps de procédures et de fonctions déclarés dans la partie interface. Dans cette partie, peuvent également être déclarés des objets locaux au module : types auxiliaires, constantes, variables et blocs, ainsi que des labels, s'ils sont utilisés dans la partie initiatrice. Les procédures et fonctions globales précédemment déclarées dans la partie interface doivent être déclarées dans le même ordre que leurs en-têtes apparaissent dans la partie interface. La description du bloc global dans la partie exécutable doit être précédée d'un en-tête dans lequel il est permis d'omettre la liste des variables formelles (et le type de résultat pour la fonction), puisqu'elles sont déjà décrites dans la partie interface.
Mais si l'en-tête du bloc est donné en entier, c'est-à-dire avec une liste de paramètres formels et une déclaration du résultat, il doit correspondre à l'en-tête déclaré dans la partie interface.
Les variables et constantes locales, ainsi que tous les codes de programme générés lors de la compilation du module, sont placés dans un segment de mémoire partagée.
Compiler des modules
L'environnement Turbo Pascal fournit des outils qui contrôlent la façon dont les modules sont compilés et facilitent le développement de grands projets logiciels. En particulier, trois modes de compilation sont définis : Compile, Make et Build.Les modes ne diffèrent que par la manière dont le module en cours de compilation ou le programme principal en cours de compilation est associé aux autres modules déclarés dans la clause Uses.
Lors de la compilation d'un module ou d'un programme principal en mode Compilation, tous les modules mentionnés dans la clause Uses doivent être pré-compilés et les résultats de leur compilation doivent être placés dans des fichiers du même nom avec l'extension .TPU. Par exemple, si un programme (dans un module) contient la clause Uses Global, alors le répertoire déclaré par l'option Répertoires unitaires doit déjà contenir le fichier GLOBAL.TPU sur le disque. Un fichier avec l'extension .TPU (de l'unité anglaise Turbo-Pascal) est créé à la suite de la compilation du module.
En mode MAKE, le compilateur vérifie les fichiers TPU pour chaque module déclaré. Si l'un des fichiers n'est pas trouvé, le système essaie de trouver le fichier portant le même nom avec l'extension .PAS, c'est-à-dire fichier avec le code source du module, et si le fichier PAS est trouvé, il commence à le compiler. De plus, dans ce cas, le système surveille les éventuelles modifications du code source de tout module utilisé. Si des modifications sont apportées au fichier PAS (code source du module), que le fichier TPU correspondant existe déjà dans le répertoire ou non, le système le compile avant de compiler le programme principal.
De plus, si des modifications sont apportées à la partie interface d'un module, tous les autres modules qui y accèdent seront également recompilés. Le mode Make simplifie donc grandement le processus de développement de gros programmes avec de nombreux modules : le programmeur se débarrasse de la nécessité de surveiller la correspondance des fichiers TPU existants et de leur code source, puisque le système le fait automatiquement.
En mode Build, les fichiers TPU existants sont ignorés et le système essaie de trouver (et de compiler) le fichier PAS approprié pour chaque module déclaré dans Uses. Après avoir compilé en mode Build, le programmeur peut être sûr que toutes les modifications apportées par lui dans l'un des modules sont prises en compte.
La connexion des modules au programme principal et leur éventuelle compilation s'effectuent dans l'ordre de leur déclaration dans la clause Uses. Lors du passage au module suivant, le système recherche d'abord tous les modules auxquels il se réfère. Les liens de modules entre eux peuvent former une arborescence de complexité quelconque, cependant la référence explicite ou indirecte d'un module à lui-même est interdite.
6 questions
Le module CRT est une bibliothèque de procédures et de descriptions qui améliore la capacité de l'utilisateur à travailler avec du texte, l'écran de texte et le clavier. Considérons certains d'entre eux.
une). TextMode(mode: integer) - sélectionne les modes CRT en mode texte spécifiés :
2).TextBackground (couleur : octet) - Sélectionne la couleur d'arrière-plan.
Le paramètre "color" est une expression de type entier, par exemple :
- 0- noir
- 1-bleu
- 2-vert
- 3-bleu
3). ClrScr - Nettoyage de l'écran. Toutes les positions des caractères sont remplies d'espaces. Cela utilise la couleur d'arrière-plan actuelle spécifiée dans la procédure TextBackGround.
4). TextColor (color:byte) - Définit la couleur des caractères. (constantes pour définir la couleur)
5). Window(x1,y1,x2,y2) - Spécifie une zone de texte à l'écran. Les paramètres x1,y1 sont les coordonnées du coin supérieur gauche de la fenêtre, les paramètres x2,y2 sont les coordonnées du coin inférieur droit La taille minimale est d'une colonne par ligne. Maximum - X = 80, Y = 25. Si les coordonnées ne sont pas valides, l'appel à la procédure Window est ignoré. Par défaut, la fenêtre est définie en plein écran.
6).GoToXY(x,y : byte) - Positionne le curseur. Le curseur se déplace vers la position dans la fenêtre actuelle, qui est spécifiée par les coordonnées x et y (x - spécifie une colonne, y - spécifie une ligne). Le coin supérieur gauche est spécifié par les coordonnées (1,1) exemple : Window( 1,10,60,20); AllerVersXY(1,1); Cela amènera le curseur à se déplacer vers un point avec des coordonnées absolues (1,10).
7).WhereX et WhereY renvoient respectivement les coordonnées X et Y de la position actuelle du curseur par rapport à la fenêtre actuelle. Le type de résultat est Octet.
8).Delay(ms: word) - Retarde le nombre donné de millisecondes. Le paramètre ms spécifie le nombre de millisecondes de l'intervalle de temporisation. Mais cette procédure est approximative, de sorte que la période de retard ne sera pas exactement égale au nombre de millisecondes spécifié.
9).READKey - Lit un caractère du clavier.
10).Sound - est une procédure qui comprend un haut-parleur interne ; Description : Son (hertz : mot) ; où le paramètre "hertz" spécifie la fréquence du signal généré en hertz.Le son retentira jusqu'à ce qu'il soit désactivé en appelant la procédure NoSound ;
11).NoSound - Éteint le haut-parleur interne.
Exemple de son, retard, pas de son
Son(220); (activer le son)
retard(300); (attendre 300ms)
pas de son; (couper le son)
7 questions.
Module graphique
TP dispose d'une grande variété d'outils pour travailler avec un écran VGA standard.
L'adaptateur VGA a une résolution de 640x480 pixels (point (0,0) dans le coin supérieur gauche de l'écran), 16 couleurs.
Avant de commencer à travailler avec des graphiques, vous devez l'initialiser et, une fois terminé, le fermer. Toutes les procédures et fonctions graphiques sont situées dans le module Graph, son inclusion est donc également nécessaire.
La structure générale du programme graphique :
Utilisez crt, graphique ;
var Gd, Gm : Entier ;
commencer
Gd := Détecter ;
InitGraph(Gd, Gm, "c:\bp\bgi");
...
(Ici la construction de l'image)
...
ReadKey ;
Fermer le graphique ;
finir.
Le chemin c:\bp\bgi spécifie l'emplacement du fichier egavga.bgi (pilote graphique). Sur différents ordinateurs, ce chemin peut être différent. Si le fichier egavga.bgi est placé dans le répertoire avec le programme, le chemin peut être omis.
Procédures et fonctions graphiques de base :
Chiffres de construction
PutPixel(x,y,c)
- affiche un point à l'écran avec les coordonnées (x,y) et la couleur c
Ligne(x1,y1,x2,y2)
- trace une ligne commençant à (x1,y1) et se terminant à - (x2,y2)
Rectangle(x1,y1,x2,y2)
- dessine le contour d'un rectangle de diagonale (x1,y1) - (x2,y2)
Barre(x1,y1,x2,y2)
- dessine un rectangle rempli de diagonale (x1,y1) - (x2,y2)
Cercle(x,y,r)
- dessine un cercle de centre (x,y) et de rayon r
Ellipse(x,y,ba,ea,xr,yr)
- dessine un arc d'ellipse centré en (x,y), des rayons horizontaux et verticaux xr et yr, et des angles de début et de fin ba et ea
FillEllipse(x,y,xr,yr)
- dessine une ellipse pleine centrée en (x,y), rayon horizontal et vertical xr et yr
Module
(UNITÉ-module, unité) est une unité de programme compilée de manière autonome (séparément) qui contient les composants de la section de description (étiquettes, constantes, types, variables, procédures, fonctions) et peut également contenir des opérateurs de partie d'initialisation.
Le module lui-même n'est pas un programme exécutable, mais est destiné à être utilisé par d'autres programmes et modules.
Structure des modules
Le module a la structure suivante :
UNITÉ<
nom du module >
INTERFACE
<
partie interfaces >
LA MISE EN OEUVRE
<
section de mise en œuvre >
COMMENCER
<
section d'initialisation >
FINIR.
En-tête de module consiste en un mot réservé unité(module) et le nom du module.
Le nom du module est choisi selon les règles générales et doit correspondre au nom du fichier disque contenant le code source du module.
Extension de nom de module (. pas
) n'est pas spécifié, il est défini par défaut.
Le nom du module est utilisé pour le lier au programme principal avec une clause les usages .
Offre les usages mb placé après l'en-tête du module ou derrière les mots
Interface et Mise en œuvre .
Partie interface Interface(interface, articulation, connexion) et contient des références à d'autres modules et des déclarations (descriptions) d'objets globaux, c'est-à-dire des étiquettes, des constantes, des types, des variables et des en-têtes de procédures et de fonctions qui sont disponibles pour le programme principal et d'autres modules (c'est-à-dire de dehors).
Rubrique Mise en œuvre - commence par un mot-clé Mise en œuvre(exécution) et contient une description des objets locaux au module, c'est-à-dire des étiquettes, des constantes, des types, des variables qui ne sont pas disponibles pour le programme principal et les autres modules (c'est-à-dire non visibles de l'extérieur) et une description complète des procédures et des fonctions . Dans ce cas, dans l'en-tête des sous-programmes, la liste des paramètres formels peut être omis, mais s'il est donné, il doit correspondre exactement à la description dans la partie interface.
Section d'initialisation
- entre parenthèses DEBUT FIN.
et contient des instructions qui seront exécutées avant que le contrôle ne soit transféré au programme principal. Cela pourrait être opérateurs d'initialisation de données (variables) Par exemple, les opérateurs d'affectation et de saisie, ainsi que les procédures de liaison et d'ouverture de fichiers. La section Opérateurs peut être. vider DEBUT FIN ou juste absent FINIR .
Un point est placé à la fin du module.
Compiler et utiliser des modules
Le système RAM a une structure de segment (un segment est égal à 64K = 65535 octets). Le code du programme peut être pas plus d'un segment, la quantité de données ne peut pas dépasser un segment (sauf si vous utilisez de la mémoire dynamique) et un segment pour la pile. La taille de la pile est définie par la directive (M$<>). La taille de pile minimale est de 1 Ko et le segment unique maximal est de 16 Ko par défaut. Les valeurs des variables locales sont poussées sur la pile lorsque le sous-programme est appelé et extraites de la pile lors de la sortie.
Le code du module est placé dans un segment séparé, car il est diffusé de manière autonome par rapport au programme principal, et le nombre de modules utilisés par le programme ne dépend que de l'OP disponible. Cela vous permet de créer de grands programmes.
Le compilateur génère du code de module avec le même nom mais l'extension tpu
(unité turbo pascal).
Pour utiliser le module par le programme principal ou d'autres modules, son nom (sans extension) est placé dans la liste de suggestion les usages
Si le module est compact et souvent utilisé par les programmes d'application, il peut être placé dans la bibliothèque de modules standard TURBO.TPL (Turbo-Pasacal-bibliothèque )
à l'aide de l'utilitaire TPUMOVER.
Mais cela ne devrait être fait qu'en cas d'urgence. la bibliothèque est chargée dans l'OP et réduit l'espace pour le programme.
Lors de la compilation du fichier avec le code source du module, un fichier du même nom apparaît avec l'extension tpu
et placé dans le répertoire spécifié par l'option
OPTIONS/RÉPERTOIRES/RÉPERTOIRES D'UNITÉS
ou dans le répertoire courant si cette option n'est pas présente.
Lors de la compilation du programme principal, les modules utilisés doivent être dans le répertoire spécifié par l'option
OPTIONS/REPERTOIRES/REPERTOIRES EXE & TPU
ou dans le répertoire courant en l'absence de cette option
Recevoir EXE fichier de tâche en option
COMPILATION/DESTINATION/DISQUE(MEMORI)
installer DISQUE
.
Il existe trois modes de compilation des modules :
- COMPILER
-CONSTRUIRE
- FABRIQUER
Modes définis par menu COMPILER
1.Mode COMPILER(appelé Alt-F9
). Dans ce cas, le programme est compilé, et les modules utilisés doivent l'être. pré-compilé et stocké dans les répertoires appropriés.
2.Mode CONSTRUIRE(appelé -
F9). Dans ce cas, les modules précédemment compilés sont ignorés et les modules avec l'extension pas
et recompilé.
3.Mode FABRIQUER(appelé F9). Dans ce cas, seuls les modules dont le texte a été modifié sont recompilés.
Exemple 16.1.
Dans le fichier inp.txt il y a trois tableaux de nombres réels
2.1 3.1 -2.4 5.6 5.4 -6.7 3.5 -3.6
Fonction de calcul
où Max_a, Max_b, Max_c, Sa, Sb, Sc, ka, kb, kc sont l'élément maximum, la somme et le nombre d'éléments positifs des tableaux correspondants a, b et c.
Sortir le résultat dans un fichier dehors.
SMS
et sur l'écran.
Texte du module
UNMAS ;
Interface
Const n=10 ;
Tapez vec=tableau de réels ;
Varz:vec;
i :entier ;
f1,f2 :texte ;
Procédure SK1(z:vec; num:byte; Var s:real; Var k:byte);
Fonction MAX(z:vec; num:byte):real;
Mise en œuvre
ProcedureV(s:char; num:byte;Var z:vec);
Commencer
Writeln("Tableau ",s);
Pour i:=1 à num faire
Commencer
Lire(f1,z[i]); Ecrire(z[i]:4:1," ":3);
finir;
lireln(f1); Écrire ;
finir;
Procédure SK1(z:vec;num:byte; Var s:real; Var k:byte);
Commencer
s:=0 ; k==0;
pour i:=1 à num faire si z[i]>0 alors
Commencer
s:=s+z[i] ;
k:=k+1
finir;
finir;
Fonction MAX(z:vec;num:byte):real;
varm:réel;
Commencer
m = z;
for i:=1 to num do if z[i]>m then m:=z[i] ;
MAX:=m
finir;
Commencer
Assign(f1,"inp.txt"); réinitialiser(f1);
Assign(f2,"out.txt"); Réécrire (f2)
finir.
Texte du programme
programme lr7_16 ;
Utilise CRT, UNMAS ;
Var
a,b,c:vec;
y,sa,sb,sc:réel ;
ka,kb,kc:octet ;
Commencer
clrscr ;
Vv("a",8,a);
vv("b",9,b);
vv("c",n,c);
SK1(a,8,sa,ka);
SK1(b,9,sb,kb);
SK1(c,n,sc,kc);
y :=(MAX(a,8)+MAX(b,9)+MAX(c,n))+(sa+sb+sc+ka+kb+kc) ;
Writeln("Résultat :":20);
Write ("Tableau a : ");
Writeln("sa=",sa:5:1," ka=",ka);
Write("Tableau b : ");
Writeln("sb=",sb:5:1," kb=",kb);
Ecrire("Tableau c : ");
Writeln("sc=",sc:5:1," kc=",kc);
Writeln(" ":10,"y=",y:10);
lire ;
Writeln(f2,"ђҐ§g"mv to:");
Writeln(f2," ":10,"y=",y:10);
fermer(f1);
Fermer(f2)
finir.
Résultats du programme
Tableau un
-2.1 3.1 -2.4 5.6 5.4 -6.7 3.5 -3.6
Tableau b
2.3 -4.3 2.1 2.5 -3.7 -5.6 4.6 3.5 -7.5
Tableau c
-2.1 4.3 -2.3 7.6 4.5 -8.9 5.7 -4.5 6.8 -5.8
Résultat:
Tableau a : sa= 17,6 ka=4
Tableau b : sb= 15,0 ko=5
Tableau c : sc= 28,9 kc=5
y=9.330E+01
Modules en Pascal par rapport à la partie principale du programme, ils ressemblent à des sous-programmes (procédures et fonctions). Mais par définition, ce sont des programmes indépendants dont les ressources peuvent être utilisées dans d'autres programmes. De plus, la description des modules se produit en dehors de l'application appelante, mais dans un fichier séparé, donc un module est un programme compilé séparément. Le fichier de module compilé (qui est celui que vous devez utiliser) aura l'extension fournie par l'environnement de programmation (par exemple, .tpu, .ppu, .pcu).
Les modules sont créés, en règle générale, pour assurer la compacité du code, dont les grands projets doivent s'occuper. Il convient également de noter que l'utilisation de modules supprime en quelque sorte la restriction sur la segmentation de la mémoire, puisque le code de chaque module est situé dans un segment séparé.
La structure du module ressemble à ceci :
unité<имя модуля>;
Interface
<интерфейсная часть>
Mise en œuvre
<исполняемая часть>
Commencer
<инициализация>
finir.
Nom du module (Unité)
Le nom du module après le mot-clé unité, doit correspondre au nom du fichier (sans .pas) qui contient son code. De plus, en utilisant le nom, le module est connecté à un autre module, ou au programme principal. Pour ce faire, vous devez spécifier le mot de service les usages, et répertoriez la liste des plug-ins séparés par des virgules :
les usages<список имен модулей>;
Partie interface (Interface)
La partie interface décrit les en-têtes des objets auxquels d'autres modules et programmes auront accès. Ce sont des constantes, des types, des variables et des sous-programmes. Par exemple, voici à quoi peut ressembler la partie interface du module Search, qui contient des algorithmes de recherche d'éléments dans un tableau.
|
1 |
recherche d'unité ; |
Pour déclarer ce module, il faut préciser son nom dans le programme :
Après cela, il sera possible d'utiliser tous les objets décrits dans la partie interface.
Partie exécutable (Implémentation)
Cette section commence par le mot Mise en œuvre(la mise en oeuvre). C'est ici qu'il faut décrire les sous-programmes déclarés dans la partie interface. Dans le même temps, il est permis de ne pas spécifier de paramètres formels dans leurs en-têtes, sinon ils doivent coïncider complètement avec ceux de la partie interface. De plus, la partie interface peut contenir des objets locaux (inaccessibles au programme appelant) pour le module.
Partie d'initiation
La partie initiatrice commence son travail avant le début de l'exécution du programme principal. Dans celui-ci (entre Begin et End), en règle générale, sont décrits des opérateurs destinés à différents types de travaux auxiliaires. Cette partie peut être manquante ou ne contenir aucun code. Dans le premier cas, vous devez spécifier End avec un point, dans le second, laissez un espace vide entre Begin et End.
Compiler des modules
Seuls les modules compilés qui ont une extension fournie par votre environnement de développement d'application peuvent être utilisés dans le programme. Considérez les trois plus populaires d'entre eux:
TurboPascal
Le résultat de la compilation d'un module en Turbo Pascal sera un fichier avec l'extension .tpu (Unité Turbo Pascal) qui stocke son code.
Pascal libre
Après avoir compilé un module dans l'environnement Free Pascal, deux fichiers sont créés avec des permissions différentes : .ppu et .o. Le premier contient la partie interface du module, et le second (nécessaire pour lier le programme) est la partie implémentation.
Pascal ABC.NET
Pascal ABC.Net ne génère pas de code en langage machine lors de la compilation des modules. Si la compilation réussit, le code est enregistré dans un fichier avec la permission .pcu.
Il existe trois modes de compilation pour les environnements de programmation Turbo Pascal et Free Pascal : Compiler, fabriquer et construire. En mode compilation, tous les modules utilisés dans le programme doivent être préalablement compilés. L'application en mode make-compilation vérifie tous les modules connectés pour la présence de fichiers avec l'autorisation appropriée pour l'environnement de programmation (.tpu ou .o). Si l'un d'entre eux n'est pas trouvé, un fichier portant le nom du module introuvable et l'extension .pas est recherché. Le plus fiable des modes est Build. La recherche et la compilation de fichiers (avec l'extension .pas) dans ce mode se produit même lorsque les fichiers de module existent déjà.
Exemple
Créons un petit module contenant des procédures de recherche binaire et linéaire d'éléments dans un tableau. Code module :
|
1 |
recherche d'unité ; |
Tout ce code doit être dans un fichier séparé. Écrivons maintenant le programme principal, dans lequel nous allons connecter notre module de recherche.
Module (unité) est un ensemble de constantes, de types de données, de variables, de procédures et de fonctions. Chaque module est similaire à un programme Pascal séparé : il peut avoir un corps principal qui est appelé avant que votre programme ne démarre et effectue l'initialisation nécessaire. En bref, un module est une bibliothèque de déclarations que vous pouvez insérer dans votre programme et qui vous permettra de décomposer le programme en parties compilées séparément.
Turbo Pascal vous donne accès à un grand nombre de constantes, de types de données, de variables, de procédures et de fonctions intégrés. Certains d'entre eux sont spécifiques à Turbo Pascal ; d'autres sont spécifiques à l'IBM PC (et aux ordinateurs compatibles) ou au système d'exploitation MS-DOS. Leur nombre est important, cependant, dans votre programme, vous les utilisez rarement tous à la fois. Par conséquent, ils sont divisés en groupes liés appelés modules. Dans ce cas, vous ne pouvez utiliser que les modules nécessaires au programme.
Structure des modules
Un module fournit un ensemble de fonctionnalités via des procédures et des fonctions prises en charge par des constantes, des types de données et des variables, mais l'implémentation réelle de ces fonctionnalités est masquée car le module est divisé en deux sections : interface et implémentation. Si un programme utilise un module, alors toutes les déclarations de module deviennent disponibles pour ce programme comme si elles étaient définies en lui-même.
La structure d'un module est similaire à celle d'un programme, mais il existe quelques différences significatives. Par exemple, considérons le module :
unité<идентификатор>; utilisations de l'interface<список модулей>; (Optionnel) (descriptions ouvertes) la mise en oeuvre (descriptions fermées de procédure et de fonction) commencer (code d'initialisation) finir.L'en-tête du module commence par le mot réservé unit suivi du nom du module (identifiant) de la même manière que pour le nom du programme. L'élément suivant dans un module est le mot-clé interface. Il marque le début de la section d'interface d'un module - la section qui est visible pour tous les autres modules ou programmes qui l'utilisent.
Un module peut utiliser d'autres modules, pour cela ils sont définis dans la clause uses. La clause uses, si elle est présente, suit immédiatement le mot-clé interface. Notez que la règle générale d'utilisation de la clause uses est satisfaite ici : si le module dont le nom est spécifié dans la clause uses utilise d'autres modules, alors les noms de ces modules doivent également être spécifiés dans la clause uses, et avant qu'ils ne soient utilisés.
Modules standards
Le fichier TURBO.TPL contient tous les packages standard à l'exception de Graph et des packages de compatibilité (Graph3 et Turbo3) : System, Overlay, Crt, Dos et Printer. Ces packages sont chargés en mémoire avec Turbo Pascal et sont toujours disponibles pour vous. Généralement, le fichier TURBO.TPL est stocké dans le même répertoire que TURBO.EXE (ou TPC.EXE). Vous pouvez le stocker dans un autre répertoire tant qu'il est décrit comme un répertoire Turbo Pascal. Pour ce faire, utilisez TINST.EXE pour définir ce répertoire dans le fichier TURBO.EXE.
Forfaits utilisés : non
Le système contient toutes les procédures et fonctions standard et intégrées de Turbo Pascal. Toute sous-routine Turbo Pascal qui ne fait pas partie du Pascal standard et ne se trouve dans aucun autre module est contenue dans System. Ce module est attaché à tous les programmes.
Forfaits utilisés : non
DOS définit de nombreuses routines et fonctions pascaliennes équivalentes aux appels DOS les plus couramment utilisés, tels que GetTime, SetTime, DiskSize, etc. De plus, il définit deux programmes de bas niveau, MsDos et Intr, qui vous permettent d'activer n'importe quel appel MS-DOS ou interruption système. Registers est le type de données pour le paramètre dans MsDos et Intr. De plus, d'autres constantes et types de données sont définis.
Forfaits utilisés : non
Superposition - contient des outils pour créer des programmes de superposition. Le programme OVERKAY est un programme qui ne charge pas tout, mais en partie.
Forfaits utilisés : non
Crt fournit un ensemble de descriptions spécifiques au PC des constantes, des variables et des programmes pour les opérations d'E/S. Ce dernier permet de travailler avec l'écran (paramétrage des fenêtres, contrôle direct du curseur, couleurs du texte et du fond). De plus, vous pouvez effectuer une entrée au clavier "brute" et contrôler la carte de génération de sons d'un ordinateur personnel. Ce module fournit de nombreuses routines qui étaient standard dans la version 3.0.
Forfaits utilisés : Crt
Le module Imprimante définit une variable de fichier texte, Lst, qui est associée à un pilote de périphérique qui permet d'envoyer une sortie Pascal standard à une imprimante à l'aide de Write et Writeln. Par exemple, en incluant Printer dans votre programme, vous pouvez effectuer les actions suivantes :
Write (Lst,"Sum of " ,A:4 ," and " ,B:4 ," equals " ) ; C :=A+B ; WriteIn(Lst,C:8) ;Forfaits utilisés : Crt
Graph3 prend en charge l'ensemble complet de routines graphiques pour la version 3.0 - pour les graphiques réguliers, les graphiques avancés et les graphiques utilisant des commandes relatives. Ils sont identiques dans le nom, les paramètres de fonction et les routines de la version 3.0.
Forfaits utilisés : Crt
Ce module contient deux variables et plusieurs procédures qui ne sont plus supportées par Turbo Pascal. Celles-ci incluent la variable de fichier intégrée Kbd, la variable booléenne CBreak et les versions entières originales de MemAvail et MaxAvail (qui renvoient de la mémoire libre dans les paragraphes, et non des octets comme le font les versions originales).
Forfaits utilisés : Crt
Graph fournit un ensemble de routines graphiques rapides et efficaces qui vous permettent de tirer pleinement parti des capacités graphiques de votre ordinateur personnel.
Ce module implémente un pilote graphique Borland indépendant du périphérique qui permet la prise en charge des adaptateurs graphiques CGA, EGA, Hercules, ATT 400, MCGA, 3270 PC et VGA.
Écrire vos propres modules
Supposons que vous ayez écrit un module IntLib, que vous l'ayez écrit dans le fichier INTLIB.PAS et que vous l'ayez traduit sur le disque ; le code résultant se trouve dans le fichier INTLIB.TRU. Pour utiliser ce module dans votre programme, vous devez inclure une instruction uses indiquant au compilateur quel module utiliser. Votre programme pourrait ressembler à ceci :
programmez MyProg ; utilise IntLib ;Notez que Turbo Pascal suppose que le fichier contenant le module porte le même nom que le module lui-même. Si le nom de votre module est MyUtilities, alors Turbo Pascal cherchera un fichier nommé MYUTILIT.PAS.
Compilation de modules
Un module est compilé exactement de la même manière qu'un programme est compilé : il est créé à l'aide de l'éditeur, puis la commande Compiler / Compiler est appelée (Compiler / Compiler) (ou les touches Alt-C sont enfoncées). Cependant, au lieu d'un fichier avec l'extension .EXE, Turbo Pascal crée un fichier avec l'extension .TRU (Turbo Pascal Unit - Turbo Pascal Unit). Après cela, vous pouvez laisser ce fichier tel quel ou l'insérer dans TURBO.TPL à l'aide de TPUMOVER.EXE.
Dans les deux cas, il est logique d'envoyer les fichiers *.TRU (ainsi que les fichiers source) au répertoire de l'unité, qui est défini avec la commande O/D/Unit directories. Il ne peut y avoir qu'un seul module par fichier source, car la compilation s'arrête dès que l'instruction end finale est rencontrée.
Exemple:
Écrivons un petit module. Appelons-la IntLib et insérons-y deux sous-routines simples pour les entiers - une procédure et une fonction :
unité IntLib ; procédure d'interface ISwap(var I,J : entier ) ; fonction IMax(I,J : entier ) : entier ; procédure de mise en œuvre ISwap ; var Temp : entier ; débutTemp :=I ; I :=J ; J:=temp fin ; (fin de la procédure ISwap) fonction IMax ; début si I > J alors IMax:=I sinon IMax:=J fin ; (fin de la fonction IMax) finir. (fin du module IntLib)Introduisons ce sous-programme, écrivons-le dans le fichier INTLIB.PAS, puis traduisons-le sur disque. En conséquence, nous obtenons le code du module dans le fichier INTLIB.TRU. Envoyons-le dans le répertoire des modules. Le programme suivant utilise le module IntLib :
programme IntTest ; utilise IntLib ; varA,B : entier ; commencer à écrire ( "Entrez deux valeurs entières : ") ; Lireln(A,B) ; ISwap(A,B) ; WriteIn("A=" ,A," B=" ,B) ; écris( "La valeur maximale est",IMax(A,B) ) ; finir. (fin du programme IntTest)Toutes les déclarations d'un module sont liées les unes aux autres. Par exemple, le module Crt contient toutes les descriptions nécessaires aux routines d'écran sur votre ordinateur personnel.
Dans le langage Pascal, les bibliothèques de sous-programmes sont utilisées pour mettre en œuvre une technologie de programmation structurée à l'aide de modules. Textuellement, les bibliothèques sont combinées en unités de programme indépendantes appelées modules du langage Pascal. Des modules sont créés pour implémenter des bibliothèques de routines. En règle générale, les modules combinent des sous-programmes qui exécutent des tâches de la même classe.
Module est une unité de programme indépendante qui compile de manière autonome et a une certaine structure.
Le module a la structure suivante :
Le titre d'un module Pascal est composé du mot de service Unit suivi du nom du module. Il existe des exigences strictes pour le nom du module, et ce nom doit correspondre au nom du fichier disque avec l'extension .pas, qui contient le texte du module.
UnitéMonType ; //fichier MonType.pas
Le nom du module est utilisé pour lier le module aux programmes et autres modules. Les programmes et les modules sont liés au module requis dans la section Utilisations du programme ou du module. Les modules peuvent appeler d'autres modules pour leur travail, si un module appelle un autre module, alors la section Uses doit suivre le mot clé INTERFACE.
La partie interface du langage Pascal commence par le mot réservé INTERFACE. Il sert à lier le module au programme hôte ou à d'autres modules. La partie interface contient la déclaration de tous les objets globaux du module. Tout d'abord, les sous-programmes, et en plus, les types globaux et les variables sont déclarés. Si un objet est déclaré globalement, il peut être utilisé dans le programme et le module appelant sans déclaration spéciale.
Unité de masse d'eau ;
INTERFACE
UTILISE MonType ;
[nom_type] :[type] ;
[list_of_global_variables] :[type] ;
Dans la partie interface, les sous-programmes sont déclarés par leurs en-têtes, qui incluent le nom du sous-programme et une liste de paramètres formels.
La partie exécutable du langage Pascal commence par le mot de service IMPLEMENTATION et contient une description des sous-programmes déclarés dans la partie interface, de plus, des objets locaux au module (variables, constantes) peuvent être déclarés dans la partie exécutable. La description d'un sous-programme dans la partie exécutable doit commencer par le titre du sous-programme, tandis que la liste des paramètres formels est omise.
La partie initiatrice du langage Pascal termine le module, et cette partie peut être absente ou peut être vide. Faire la partie d'initiation n'est pas recommandé car des situations de blocage peuvent se produire. Il contient des instructions exécutables, définit les valeurs initiales des variables globales, ouvre les fichiers nécessaires et établit des liens avec d'autres fichiers.
Compiler des modules en Pascal
Lorsque vous travaillez avec des modules, vous devez compiler les modules eux-mêmes et compiler les programmes qui utilisent les modules. Comme vous le savez, il existe trois modes de compilation dans l'environnement Borland Pascal (Compile, Build, Make). Lors de la compilation du module lui-même, le mode Compile est généralement utilisé, bien que d'autres modes soient possibles si le module est utilisé par d'autres modules. La compilation d'un module ne crée pas un programme exécutable, mais crée un fichier de module compilé spécial avec l'extension .tpw. Les fichiers unitaires compilés sont placés dans des répertoires, généralement nommés Units (spécifiés dans les paramètres d'environnement). Lors de la compilation de programmes contenant des modules, les trois modes de compilation peuvent être utilisés. La compilation de différents modes diffère en durée et en fiabilité.
Mode Compiler- le plus simple et le plus rapide. Dans ce mode, le compilateur vérifie la présence de plug-ins dans la section Uses et compile les programmes s'ils sont présents. Si le module est manquant, la compilation s'arrête et un message concernant le module manquant s'affiche.
En mode Faire, construire le compilateur vérifie la présence de plug-ins et si un module n'est pas trouvé, le compilateur recherche le texte du module avec l'extension .pas, compile le module, puis compile le programme. De plus, le compilateur vérifie les dates de création des modules .tpw et .pas. S'il constate que la date de création du fichier .pas est postérieure à celle du fichier .tpw, il en déduit que des modifications ont été apportées au texte du module et recompile les modules. Ainsi, il est plus fiable.
En mode Construire tous les fichiers .tpw sont ignorés, le compilateur recompilera tous les modules utilisés dans le programme principal et compilera le programme. C'est le mode le plus fiable, mais en même temps le plus long.
