Section courante

A propos

Section administrative du site

Extensions du système de langage Atari Pascal

Cette page décrit la fonction et l'utilisation des extensions ATARI Pascal. Il couvre les domaines suivants :

Compilation modulaire

ATARI Pascal prend en charge un système de compilation modulaire flexible. Les programmes peuvent être développés de manière monolithique jusqu'à ce qu'ils deviennent trop volumineux pour être gérés (ou compilés), puis divisés en modules à ce moment-là. Le système de compilation modulaire ATARI Pascal permet un accès complet aux procédures et variables de n'importe quel module à partir de n'importe quel autre module. Une bascule du compilateur est fournie pour vous permettre de "masquer" (c'est-à-dire de rendre privé) n'importe quel groupe de variables ou de procédures.

La structure d'un module est similaire à celle d'un programme. Il commence par le mot réservé MODULE, suivi d'un identifiant et d'un point-virgule (par exemple, MODULE TEST1;) et se termine par le mot réservé MODEND, suivi d'un point (par exemple, MODEND.). Entre ces deux lignes, vous pouvez déclarer les sections des étiquettes (label), constante, type, variable, procédure et fonction comme dans un programme. Cependant, contrairement à un programme, il n'y a pas de section BEGIN..END après les déclarations de procédure et de fonction, juste le mot MODEND suivi d'un point «.».

Exemple :

  1. MODULE MOD1;
  2.  
  3. (* declarations labels, const, type et var *)
  4.  
  5. (* declarations de corps de procedure et fonction *)
  6.  
  7. MODEND.

Pour accéder aux variables, procédures et fonctions dans d'autres modules (ou dans le programme principal), un nouveau mot réservé, EXTERNAL, a été ajouté et est utilisé à deux fins.

Premièrement, le mot EXTERNAL peut être placé après les deux points et avant le type dans une déclaration de variable GLOBAL, indiquant que cette liste de variables ne doit pas réellement être allouée dans ce module mais plutôt dans un autre module. Aucun espace d'entreposage n'est alloué pour les variables déclarées de cette manière.

Exemple :

  1. I,J,K:  EXTERNAL INTEGER; (* dans un autre module *)
  2. R:      EXTERNAL RECORD   (* encore dans un autre module *)
  3.          (* ... *)        (* quelques champs *)
  4.         END;

Vous devez être responsable de la correspondance des déclarations de manière identique, car le compilateur et l'éditeur de liens n'ont pas la possibilité de de vérifier le type.

Deuxièmement, le mot EXTERNAL est utilisé pour déclarer des procédures et des fonctions existant dans d'autres modules. Ces déclarations doivent apparaître avant la première déclaration de procédure normale ou de fonction dans le module/programme. Les éléments externes ne peuvent être déclarés qu'au niveau global (le plus externe) d'un programme ou d'un module.

Tout comme dans les déclarations de variables, le langage ATARI Pascal vous oblige à vous assurer que le nombre et le type de paramètres correspondent exactement et que le type renvoyé correspond exactement aux fonctions, car le compilateur et l'éditeur de liens n'ont pas la capacité de taper une vérification entre les modules. Les routines externes peuvent ne pas avoir de procédures et de fonctions comme paramètres.

Notez que dans ATARI Pascal, les noms externes n'ont de signification que pour sept caractères et non pour huit. Lors de l'interface avec le langage assembleur, limitez la longueur des identifiants accessibles par le langage assembleur pour corriger les caractères.

Vous trouverez ci-dessous un squelette de programme principal et un squelette de module. Le programme principal fait référence aux variables et aux sous-programmes du module, et le module fait référence aux variables et aux sous-programmes du programme principal. Les seules différences entre un programme principal et un module sont qu'au début d'un programme principal, il y a 16 octets de code d'entête et le corps du programme principal suivant les procédures et les fonctions.

Exemple de programme principal :

  1. PROGRAM EXTERNAL_DEMO;
  2.  
  3. (* Declaration d'etiquette, constante ou type *)
  4.  
  5. VAR
  6.  I,J:INTEGER;           (* DISPONIBLE DANS D'AUTRES MODULES *)
  7.  K,L:EXTERNAL INTEGER;  (* SITUE AILLEURS *)
  8.  
  9. EXTERNAL PROCEDURE SORT(VAR Q:LIST;LEN:INTEGER);
  10.  
  11. EXTERNAL FUNCTION IOTEST:INTEGER;
  12.  
  13. PROCEDURE PROC1;BEGIN
  14.  IF IOTEST=1 THEN
  15.   (* APPELER UNE FONCTION EXTERNE NORMALEMENT *)
  16.   (* ... *)
  17. END;
  18.  
  19. BEGIN
  20.  SORT(...);
  21.   (* APPELER UNE FONCTION EXTERNE NORMALEMENT *)
  22. END.

Exemple de module : (Notez qu'il s'agit de fichiers distincts) :

  1. MODULE MODULE_DEMO;
  2.  
  3. (* Declaration d'etiquette, constante ou type *)
  4.  
  5. VAR
  6.  I,J:EXTERNAL INTEGER;     (* UTILISEZ CEUX DU PROGRAMME PRINCIPAL *)
  7.  K,L:INTEGER;              (* DEFINISSEZ-LES ICI *)
  8.  
  9. EXTERNAL PROCEDURE PROC1;  (* UTILISEZ LE FORMAT UNIQUE DU PROGRAMME PRINCIPAL *)
  10.  
  11. PROCEDURE SORT(...);       (* DÉFINIR LE TRI ICI *)
  12.  
  13.  (* ... *)
  14.  
  15. FUNCTION IOTEST:INTEGER;   (* DÉFINIR IOTEST ICI *) 
  16.  
  17.  (* peut-etre d'autres procedures et fonctions ici *)
  18.  
  19. MODEND.

Allocation de données et passage de paramètres

Allocation de données

En plus d'accéder aux variables par leur nom, vous devez savoir comment les variables sont allouées en mémoire. Les variables allouées dans la zone de données GLOBAL sont allouées essentiellement affichées ici. Cependant, les variables d'une liste d'identifiants précédant un type (par exemple, A, B, C:INTEGER) sont allouées dans l'ordre inverse (c'est-à-dire C en premier, suivi de B, suivi de A).

Exemple :

  1. A       : INTEGER;
  2. B       : CHAR;
  3. I,J,K   : BYTE;
  4. L       : INTEGER;

Disposition d'entreposage :

+0 A LSB
+1 A MSB
+2 B
+3 K
+4 J
+5 I
+6 L LSB
+7 L MSB

Types de données structurées : les ARRAY, les RECORD et les SET nécessitent des explications supplémentaires. Les ARRAY sont entreposés dans l'ordre principal de la colonne. Par exemple A:ARRAY[1..3,1..3] OF CHAR est entreposé sous la forme :

+0 A[1,1]
+1 A[1,2]
+2 A[1,3]

+3 A[2,1]
+4 A[2,2]
+5 A[2,3]

+6 A[3,1]
+7 A[3,2]
+8 A[3,3]

Il s'agit logiquement d'un tableau unidimensionnel de vecteurs. Dans ATARI Pascal, tous les tableaux sont des tableaux logiquement unidimensionnels d'un autre type.

Les RECORD sont entreposés de la même manière que les variables globales.

Les SET sont toujours entreposés sous forme d'éléments de 32 octets. Chaque élément de l'ensemble est entreposé sous la forme d'un bit. Les SET sont orientés octets et le bit de poids faible de chaque octet est le premier bit de cet octet de l'ensemble. Ci-dessous, l'ensemble 'A'..'Z' :

Numéro d'octet 00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F ... 1F
Valeur 00 00 00 00 00 00 00 00 FE FF FF 07 00 00 00 00 ... 00

Le premier bit est le bit 65 (41$) et se trouve dans l'octet 8, bit 1. Le dernier bit est le bit 90 et se trouve dans l'octet 11, bit 2. Dans cette ensemble, le bit 0 est le bit le moins significatif de l'octet.

Passage de paramètres

Lors de l'appel d'une routine en langage assembleur depuis ATARI Pascal ou lors de l'appel d'une routine ATARI Pascal depuis le langage assembleur, les paramètres sont transmis sur la pile. La pile de passage de paramètres dans ATARI Pascal est différente de la pile matérielle 6502. Cette pile logicielle se trouve aux emplacements $600 à $6FF en mémoire. Le registre X matériel doit être enregistré et restauré lors de l'exécution des routines du langage assembleur et est utilisé comme pointeur vers la pile logicielle. Vous pouvez charger le haut de la pile en utilisant "LDA $600,X",... Lors de l'entrée dans la routine, le haut de la pile matérielle contient l'adresse de retour. Sur la pile logicielle, dans l'ordre inverse, la déclaration (A,B:INTEGER;C:CHAR) entraînerait C au-dessus de B au-dessus de A. Chaque paramètre nécessite au moins un MOT de 16 bits d'espace de pile. Un caractère ou un booléen est transmis sous forme de mot de 16 bits avec un octet de poids fort de 00. Les paramètres VAR sont transmis par adresse. L'adresse représente l'octet de la variable avec l'adresse mémoire la plus basse.

Les paramètres non scalaires (hors SET) sont toujours transmis par adresse. Si le paramètre est un paramètre de valeur, le code est généré par le compilateur dans une routine Pascal pour déplacer les données. Les paramètres SET sont transmis par valeur sur la pile, puis l'interpréteur est utilisé pour l'entreposer.

L'exemple ci-dessous montre une liste de paramètres typique à l'entrée d'une procédure :

  1. PROCEDURE DEMI(I,J:INTEGER; VAR Q:STRING;C,D:CHAR);

À la pile d'entrée (600$,X) :

+0 D
+1 BYTE DE 00
+2 C
+3 BYTE DE 00
+4 ADRESSE DE L'ACTUELLE STRING
+5 ADRESSE DE L'ACTUELLE STRING
+6 J (LSB)
+7 J (MSB)
+8 I (LSB)
+9 I (MSB)

Le programme en langage assembleur doit supprimer tous les paramètres de la pile d'évaluation avant de revenir à la routine appelante.

Les SET sont entreposés sur la pile avec l'octet de poids faible en bas (adresse haute).

Les valeurs des fonctions sont renvoyées sur la pile. Ils sont placés «logiquement» sous l'adresse de retour avant l'exécution du retour. Ils restent donc en haut de la pile après la nouvelle saisie du programme appelant après le retour. Les fonctions du langage assembleur ne peuvent renvoyer que les types scalaires INTEGER, REAL, BOOLEAN et CHAR.

Segmentation du programme - Chaînage

Il y a des moments où les programmes dépassent la mémoire disponible et aussi souvent où la segmentation des programmes à des fins de compilation et de maintenance est souhaitée. ATARI Pascal fournit un mécanisme de «chaînage» dans lequel un programme peut transférer le contrôle à un autre programme.

Vous devez déclarer un fichier non typé (FILE) et utiliser les procédures ASSIGN et RESET pour initialiser le fichier. Vous pouvez ensuite exécuter un appel à la procédure CHAIN, en passant le nom de la variable du fichier comme seul paramètre. La routine de la bibliothèque d'exécution exécutera ensuite les fonctions appropriées à charger dans le fichier que vous avez ouvert à l'aide de l'instruction RESET. La taille du programme n'a pas d'importance. Un petit programme peut s'enchaîner à un grand et un grand programme peut s'enchaîner à un petit. Si vous souhaitez communiquer entre les programmes chaînés, vous pouvez choisir de communiquer de deux manières : variables globales partagées et variables ABSOLUES.

Si vous utilisez la méthode des variables globales partagées, vous devez garantir qu'au moins la première section des variables globales est la même dans les deux programmes souhaitant communiquer. Le reste des variables globales n'a pas besoin d'être le même et la déclaration des variables externes dans la section globale n'affectera pas cette cartographie. En plus d'avoir des déclarations correspondantes, vous devez utiliser le commutateur d'option /D disponible dans l'éditeur de liens pour placer les variables au même endroit dans tous les programmes souhaitant communiquer.

Pour utiliser la méthode des variables ABSOLUES, vous définirez généralement un enregistrement utilisé comme zone de communication, puis définirez cet enregistrement à un emplacement absolu dans chaque module. Cette méthode ne nécessite pas l'utilisation du commutateur /D dans l'éditeur de liens mais nécessite la connaissance de la mémoire utilisée par le programme et le système.

Vous trouverez ci-dessous deux exemples de programmes communiquant entre eux en utilisant la méthode des variables ABSOLUTE. Le premier programme enchaînera avec le deuxième programme, affichant les résultats de l'exécution du premier programme :

  1. PROGRAM PROG1;
  2.  
  3. TYPE
  4.  COMMAREA=RECORD
  5.   I,J,K:INTEGER;
  6.  END; 
  7.  
  8. VAR
  9.  GLOBALS : ABSOLUTE[$8000] COMMAREA;
  10.  CHAINFIL: FILE;
  11.  
  12. BEGIN (* PROGRAMME PRINCIPAL #1 *)
  13.  WITH GLOBALS DO BEGIN
  14.   I:=3;
  15.   J:=3;
  16.   K:=I*J;
  17.  END; 
  18.  ASSIGN(CHAINFIL,'D1:PROG2.COM');
  19.  RESET(CHAINFIL);
  20.  IF IORESULT<>0 THEN BEGIN
  21.   WRITELN('IMPOSSIBLE D''OUVRIR D1:PROG2.COM');
  22.   EXIT;
  23.  END;
  24.  CHAIN(CHAINFIL);
  25. END. (* FIN DE PROG1 *)

Voici le programme #2 dans la démonstration de chaîne :

  1. PROGRAM PROG2;
  2.  
  3. TYPE
  4.  COMMAREA=RECORD
  5.   I,J,K:INTEGER;
  6.  END;
  7.  
  8. VAR
  9.  GLOBALS:ABSOLUTE [$8000] COMMAREA;
  10.  
  11. BEGIN (* PROGRAMME #2 *)
  12.  WITH GLOBALS DO 
  13.   WRITELN('RESULTAT DE ',I,' FOIS ',J,' EST = ',K); 
  14.    (* RETOURNE AU SYSTEME D'EXPLOITATION QUAND C'EST COMPLETE *)
  15. END.

Procédures et paramètres intégrés

Cette section décrit les procédures et fonctions intégrées d'ATARI Pascal. Chaque routine est décrite syntaxiquement, suivie d'une description des paramètres et d'un exemple de programme utilisant la procédure de la fonction.

MOVE, MOVERIGHT, MOVELEFT

PROCEDURE MOVE(SOURCE,DESTINATION,NUM_BYTES);
PROCEDURE MOVELEFT(SOURCE,DESTINATION,NUM_BYTES);
PROCEDURE MOVERIGHT(SOURCE,DESTINATION,NUM_BYTES);

Ces procédures déplacent le nombre d'octets contenus dans NUM_BYTES de l'emplacement nommé dans SOURCE vers l'emplacement nommé dans DESTINATION. MOVE est un synonyme de MOVELEFT. MOVELEFT se déplace de l'extrémité gauche de la source vers l'extrémité gauche de la destination. MOVERIGHT se déplace de l'extrémité droite de la source vers la droite et vers la destination (les paramètres passés à MOVERIGHT précisent l'extrémité gauche de la source et de la destination).

Utilisez MOVELEFT et MOVERIGHT pour transférer un octet d'une structure de données à une autre ou pour déplacer des données au sein d'une seule structure de données. Le déplacement est effectué au niveau de l'octet, le type de structure de données est donc ignoré. MOVERIGHT est utile pour transférer des octets de l'extrémité inférieure d'un tableau vers l'extrémité supérieure. Sans cette procédure, une boucle FOR serait nécessaire pour récupérer chaque caractère et le déposer à une adresse plus élevée. MOVERIGHT est également beaucoup, beaucoup plus rapide. MOVERIGHT est idéal à utiliser dans une routine d'insertion de caractères dont le but est de libérer de la place pour les caractères dans un tampon.

MOVELEFT est utile pour transférer des octets d'un tableau à un autre, supprimer des caractères d'un tampon ou déplacer les valeurs d'une structure de données vers une autre.

La source et la destination peuvent être n'importe quel type de variable et il n'est pas nécessaire que les deux soient du même type. Il peut également s'agir de pointeurs vers des variables ou d'entiers utilisés comme pointeurs. Ils ne peuvent pas être des constantes nommées ou littérales. Le nombre d'octets est une expression entière supérieure à zéro.

Attention à ces problèmes :

Exemple :

  1. PROCEDURE MOVE_DEMO;
  2. CONST
  3.  STRINGSZ=80;
  4. VAR
  5.  BUFFER:STRING[STRINGSZ];
  6.  LINE:STRING;
  7.  
  8.  PROCEDURE INSRT(VAR DEST:STRING;INDEX:INTEGER;VAR SOURCE:STRING);BEGIN
  9.   IF LENGTH(SOURCE)<=STRINGSZ-LENGTH(DEST)THEN BEGIN
  10.    MOVERIGHT(DEST[INDEX],DEST[INDEX+LENGTH(SOURCE)],LENGTH(DEST)-INDEX+1);
  11.    MOVELEFT(SOURCE[1],DEST[INDEX],LENGTH(SOURCE));
  12.    DEST[0]:=CHR(ORD(DEST[O])+LENGTH(SOURCE))
  13.   END;
  14.  END;
  15.  
  16. BEGIN
  17.  WRITELN('MOVE_DEMO......');
  18.  BUFFER:='Steeve Tremblay/335 Fleurs/Alma,QC,CA,G1Q 1Q9';
  19.  WRITELN(BUFFER);
  20.  LINE:='Jean-';
  21.  INSRT(BUFFER,POS('5',BUFFER)+2,LINE);
  22.  WRITELN(BUFFER);
  23. END;

La sortie de cette procédure est :

MOVE_DEMO......
Steeve Tremblay/335 Fleurs/Alma,QC,CA,G1Q 1Q9
Steeve Tremblay/335 Jean-Fleurs/Alma,QC,CA,G1Q 1Q9

EXIT

PROCEDURE EXIT;

EXIT est l'équivalent de l'instruction RETURN en FORTRAN ou BASIC. Il quittera la procédure/fonction ou le programme principal actuel. EXIT chargera également les registres et réactivera les interruptions avant de quitter si EXIT est utilisé dans une procédure INTERRUPT. Il est généralement exécuté sous forme d'instruction suite à un test.

Exemple :

  1. PROCEDURE EXITTEST;
  2.  (* SORTIR DE LA FONCTION COURANTE OU DU PROGRAMME PRINCIPALE *)
  3.  
  4.  PROCEDURE EXITPROC(BOOL:BOOLEAN);BEGIN
  5.   IF BOOL THEN BEGIN
  6.    WRITELN('SORTIR DE EXITPROC');
  7.    EXIT;
  8.   END;
  9.   WRITELN('TOUJOURS EN EXITPROC, SUR LE POINT DE QUITTER NORMALEMENT');
  10.  END;
  11.  
  12. BEGIN
  13.  WRITELN('EXITTEST......');
  14.  EXITPROC(TRUE);
  15.  WRITELN('DANS EXITTEST APRES LE PREMIER APPEL A EXITPROC');
  16.  EXITPROC(FALSE);
  17.  WRITELN('DANS EXITTEST APRES LE DEUXIEME APPEL A EXITPROC');
  18.  EXIT;
  19.  WRITELN('CETTE LIGNE NE SERA JAMAIS AFFICHER');
  20. END;

Sortie :

EXITTEST......
SORTIR DE EXITPROC
DANS EXITTEST APRES LE PREMIER APPEL A EXITPROC
TOUJOURS EN EXITPROC, SUR LE POINT DE QUITTER NORMALEMENT
DANS EXITTEST APRES LE DEUXIEME APPEL A EXITPROC

TSTBIT, SETBIT et CLRBIT

FUNCTION TSTBIT(BASIC_VAR,BIT_NUM):BOOLEAN;
PROCEDURE SETBIT(VAR BASIC_VAR,BIT_NUM);
PROCEDURE CLRBIT(VAR BASIC_VAR,BIT_NUM);

TSTBIT renvoie TRUE si le bit désigné dans basic_var est activé, et renvoie FALSE si le bit est désactivé. SETBIT définit le bit désigné dans le paramètre. CLRBIT efface le bit désigné dans le paramètre.

BASIC_VAR est n'importe quelle variable de 8 ou 16 bits telle qu'un entier, un caractère, un octet, un mot ou un booléen. BIT_NUM est 0..15 avec le bit 0 à droite. Tenter de définir le bit 10 d'une variable de 8 bits ne provoque pas d'erreur mais n'a aucun effet sur le résultat final.

Ces procédures sont utiles pour générer des boucles d'attente ou modifier les données entrantes en les retournant un peu si nécessaire. Une autre application est en manipulation d'écran par bit cartographié.

Exemple :

  1. PROCEDURE TST_SET_CLR_BITS;
  2. VAR
  3.  I:INTEGER;
  4. BEGIN
  5.  WRITELN('TST_SET_CLR_BITS......');
  6.  I:=0;
  7.  SETBIT(I,5);
  8.  IF I=32 THEN
  9.   IF TSTBIT(I,5)THEN
  10.    WRITELN('I=',I);
  11.  CLRBIT(I,5);
  12.  IF I=0 THEN
  13.   IF NOT(TSTBIT(I,5))THEN
  14.    WRITELN('I=',I);
  15. END;

on obtiendra la sortie suivante :

TST_SET_CLR_bITS.......
I=32
I=0

SHR et SHL

FUNCTION SHR(BASIC_VAR,NUM):INTEGER;
FUNCTION SHL(BASIC_VAR,NUM):INTEGER;

SHR décale le BASIC_VAR de NUM bits vers la droite, en insérant 0 bits. SHL décale le BASIC_VAR de NUM bits vers la gauche, en insérant 0 bits. BASIC_VAR est une variable 8 ou 16 bits. NUM est une expression entière.

Les utilisations de SHR et SHL sont généralement évidentes. Par exemple, supposons qu'une valeur de 10 bits doive être obtenue à partir de deux ports d'entrée distincts. Vous pouvez utiliser SHL pour les lire :

  1. VAR
  2.  PORT1:ABSOLUTE [$D000] BYTE;
  3.  PORT2:ABSOLUTE [$D232] BYTE;
  4. BEGIN 
  5.  X:=SHL(PORT1 & $1F, 3) ! (PORT2 & $1F);
  6. END;

L'exemple ci-dessus lit à partir du port1, masque les trois bits forts renvoyés par le tableau INP et décale le résultat vers la gauche. Ensuite, ce résultat est logiquement OR appliqué à l'entrée du port2, ayant également été masquée.

La procédure suivante démontre le résultat attendu de l'exécution de ces deux fonctions.

Exemple :

  1. PROCEDURE SHIFT_DEMO;
  2. VAR I:INTEGER;
  3. BEGIN
  4.  WRITELN('SHIFT_DEMO ......');
  5.  I:=4;
  6.  WRITELN('I=',I);
  7.  WRITELN('SHR(I,2)=',SHR(I,2));
  8.  WRITELN('SHR(I,4)=',SHR(I,4));
  9. END;

On obtiendra la sortie :

SHIFT_DEMO ......
I=4
SHR(I,2)=1
SHR(I,4)=64

HI, LO et SWAP

FUNCTION HI(BASIC_VAR):INTEGER;
FUNCTION LO(BASIC_VAR):INTEGER;
FUNCTION SWAP(BASIC_VAR):INTEGER;

HI renvoie les 8 bits supérieurs de BASIC_VAR (une variable de 8 ou 16 bits) dans les 8 bits inférieurs du résultat. LO renvoie les 8 bits inférieurs avec les 8 bits supérieurs forcés à zéro. SWAP renvoie les 8 bits supérieurs de BASIC_VAR dans les 8 bits inférieurs du résultat et les 8 bits inférieurs de BASIC_VAR dans les 8 bits supérieurs du résultat. Passer une variable de 8 bits à HI fait que le résultat est 0 et passer 8 bits à LO ne fait rien.

Ces fonctions améliorent les capacités d'ATARI Pascal à lire et écrire sur les ports d'entrée/sortie. Si un élément de données a 16 bits d'informations à envoyer à un port capable de gérer 8 bits à la fois, utilisez LO et HI pour envoyer l'octet de poids faible suivi de l'octet de poids fort. De la même manière, la lecture de 16 bits de données à partir d'un port envoyant 8 bits à la fois peut être effectuée en échangeant les 8 premiers bits dans l'octet de poids fort :

  1. VAR
  2.  PORT6:ABSOLUTE [$D234] BYTE;
  3.  
  4. PORT6:=LO(B);
  5. PORT6:=HI(B);
  6. B:=SWAP(PORT6) ! PORT6;

L'exemple suivant montre quels devraient être les résultats attendus de ces fonctions :

  1. PROCEDURE HI_LO_SWAP;
  2. VAR
  3.  HL:INTEGER;
  4. BEGIN
  5.  WRITE('HI_LO_SWAP.........');
  6.  HL:=$104;
  7.  WRITELN('HL=',HL);
  8.  IF HI(HL)=1 THEN
  9.   WRITELN('HI(HL)=',HI(HL));
  10.  IF LO(HL)=4 THEN
  11.   WRITELN('LO(HL)=',LO(HL));
  12.  IF SWAP(HL)=$0401 THEN
  13.   WRITELN('SWAP(HL)=',SWAP(HL));
  14. END;

On obtiendra la sortie :

HI_LO_SWAP.........
HL=260
HI(HL)=1
LO(HL)=4
SWAP(HL)=1025

ADDR

FUNCTION ADDR(VARIABLE REFERENCE):INTEGER;

ADDR renvoie l'adresse de la variable référencée. La référence aux variables comprend les noms de procédures/fonctions, les variables en index et les champs d'enregistrement. Il n'inclut pas les constantes nommées, les types définis par l'utilisateur ou tout élément n'occupant pas de code ou d'espace de données.

Cette fonction est utilisée pour renvoyer l'adresse de n'importe quoi : compiler les horaires générés par INLINE, l'adresse d'une structure de données à utiliser dans une instruction MOVE,...

Exemple :

  1. PROCEDURE ADDR_DEMO(PARAM:INTEGER);
  2. VAR
  3.  REC:RECORD
  4.   J:INTEGER;
  5.   BOOL:BOOLEAN;
  6.  END;
  7.  ADDRESS:INTEGER;
  8.  R:REAL;
  9.  S1:ARRAY[1..10] OF CHAR;
  10. BEGIN
  11.  WRITELN('ADDR_DEMO.....');
  12.  WRITELN('ADDR(ADDR_DEMO)=',ADDR(ADDR_DEMO));
  13.  WRITELN('ADDR(PARAM)=',ADDR(PARAM));
  14.  WRITELN('ADDR(REC)=',ADDR(REC));
  15.  WRITELN('ADDR(REC.J)=',ADDR(REC.J));
  16.  WRITELN('ADDR(ADDRESS)=',ADDR(ADDRESS));
  17.  WRITELN('ADDR(R)=',ADDR(R));
  18.  WRITELN('ADDR(S1)=',ADDR(S1));
  19. END.

La sortie dépend du système.

SIZEOF

FUNCTION SIZEOF(VARIABLE OU NOM DE TYPE):INTEGER;

SIZEOF renvoie la taille du paramètre en octets. Il est utilisé dans les instructions MOVE pour le nombre d'octets à déplacer. Avec SIZEOF, vous n'avez pas besoin de changer de constantes à mesure que le programme évolue. Le paramètre peut être n'importe quelle variable : caractère, tableau, enregistrement,..., ou tout type défini par l'utilisateur.

Exemple :

  1. PROCEDURE SIZE_DEMO;
  2. VAR
  3.  B:ARRAY[1..10] OF CHAR;
  4.  A:ARRAY[1..15] OF CHAR;
  5. BEGIN
  6.  WRITELN('SIZE_DEMO......');
  7.  A:='***************';
  8.  B:='0123456789';
  9.  WRITELN('SIZEOF(A)=',SIZEOF(A),' SIZEOF(B)=',SIZEOF(B));
  10.  MOVE(B,A,SIZEOF(B));
  11.  WRITELN('A=',A);
  12. END;

On obtiendra la sortie :

SIZEOF(A)=15 SIZEOF(B)=10
A=0123456789******

FILLCHAR

PROCEDURE FILLCHAR(DESTINATION,LENGTH,CHARACTER)

Cette procédure remplit la DESTINATION (un tableau compacté de caractères) avec le nombre de CHARACTERS spécifié par LENGTH. DESTINATION est un tableau rempli de caractères. Il peut être souscrit. LENGTH est une expression entière. Si LENGTH est supérieure à la longueur de DESTINATION, le code ou les données adjacents sont écrasés. De plus, s'il est négatif, la mémoire adjacente peut être écrasée. CHARACTER est un littéral ou une variable de type char.

Le but de FILLCHAR est de fournir une méthode rapide pour remplir de grandes structures de données avec les mêmes données. Par exemple, la suppression des tampons se fait avec FILLCHAR.

Exemple :

  1. PROCEDURE FILL_DEMO;
  2. VAR
  3.  BUFFER:PACKED ARRAY[1..256] OF CHAR;
  4. BEGIN
  5.  FILLCHAR(BUFFER,256,' '); (* BLANC DANS LES TAMPONS *)
  6. END;

LENGTH

FUNCTION LENGTH(STRING):INTEGER;

Cette fonction renvoie la valeur entière de la longueur de la chaîne de caractères.

Exemple :

  1. PROCEDURE LENGTH_DEMO;
  2. VAR
  3.  S1:STRING[40];
  4. BEGIN
  5.  S1:='Ceci est un chaine de caracteres de 57 caracteres de long';
  6.  WRITELN('LONGUEUR DE ',S1,'=',LENGTH(S1));
  7.  WRITELN('LONGUEUR DE CHAINE DE CARACTERES VIDE = ',LENGTH(''));
  8. END;

On obtiendra la sortie :

LONGUEUR DE Ceci est un chaine de caracteres de 57 caracteres de long=57
LONGUEUR DE CHAINE DE CARACTERES VIDE = 0

CONCAT

FUNCTION CONCAT(SOURCE1,SOURCE2,...,SOURCE):STRING;

Cette fonction renvoie une chaîne de caractères dans laquelle toutes les sources de la liste de paramètres sont concaténées. Les sources peuvent être des variables de chaîne de caractères, des chaînes littérales ou des caractères. Une SOURCE de longueur zéro peut être concaténée sans problème. Si la longueur totale de toutes les SOURCES dépasse 256 octets, la chaîne de caractères est tronquée à 256 octets. Voir la note sous COPY dans la section suivante concernant les restrictions lors de l'utilisation à la fois de CONCAT et de COPY.

Exemple :

  1. PROCEDURE CONCAT_DEMO;
  2. VAR
  3.  S1,S2:STRING;
  4. BEGIN
  5.  S1:='Lien gauche, lien droit';
  6.  S2:='Racine racine racine';
  7.  WRITELN(S1,'/',S2);
  8.  S1:=CONCAT(S1,' ',S2,'!!!!!!');
  9.  WRITELN(S1);
  10. END;

On obtiendra la sortie :

Lien gauche, lien droit/Racine racine racine
Lien gauche, lien droit Racine racine racine !!!!!!

COPY

FUNCTION COPY(SOURCE,LOCATION,NUM_BYTE):STRING;

Copy renvoie une chaîne de caractères contenant le nombre de caractères spécifié dans NUM_BYTES à partir de SOURCE commençant à l'index spécifié dans LOCATION. SOURCE doit être une chaîne de caractères. LOCATION et NUM_BYTES sont des expressions entières. Si LOCATION est hors limites ou est négatif, aucune erreur ne se produit. Si NUM_BYTES est négatif ou si NUM_BYTES plus LOCATION dépasse la longueur de SOURCE, une troncature se produit.

Exemple :

  1. PROCEDURE COPY_DEMO;BEGIN
  2.  LONG_STR:='Salut de Sylvain-par-l-ocean';
  3.  WRITELN(COPY(LONG_STR,10,LENGTH(LONG_STR)-10+1));
  4. END;

On obtiendra la sortie :

Sylvain-par-l-ocean

Remarque : COPY et CONCAT sont des fonctions de retour de chaîne de caractères "pseudo" et n'ont qu'un seul tampon alloué statiquement pour la valeur de retour. Ainsi, si ces fonctions sont utilisées plusieurs fois au sein d'une même expression, la valeur de chaque occurrence de ces fonctions devient la valeur de la dernière occurrence. Par exemple, "IF (CONCAT(A,STRING1)=(CONCAT(A,STRING2))" sera toujours vrai car la concaténation de A et STRING1 est remplacée par celle de A et STRING2. De plus, "WRITELN(COPY(STRING1),1,4),COPY(STRING1,5,4))" écrit deux fois le deuxième ensemble de quatre caractères dans STRING1.

POS

FUNCTION POS(PATTERN,SOURCE):INTEGER;

Cette fonction renvoie la valeur entière de la position de la première occurrence de PATTERN dans SOURCE. Si le modèle n'est pas trouvé, un zéro est renvoyé. SOURCE est une chaîne de caractères et PATTERN est une chaîne de caractères, un caractère ou un littéral.

Exemple :

  1. PROCEDURE POS_DEMO;
  2. VAR
  3.  STR,PATTERN:STRING;
  4.  CH:CHAR;
  5. BEGIN
  6.  STR:='ABCDEFGHIJKLMNO';
  7.  PATTERN:='FGHIJ';
  8.  CH:='B';
  9.  WRITELN('POS de ',PATTERN,' dans ',STR,' est ',POS(PATTERN,STR));
  10.  WRITELN('POS de ',CH,' dans ',STR,' est ',POS(CH,STR));
  11.  WRITELN('POS de ''z'' dans ',STR,' est ',POS('z',STR));
  12. END.

On obtiendra la sortie :

POS de FGHIJ dans ABCDEFGHIJKLMNO est 6
POS de B dans ABCDEFGHIJKLMNO est 2
POS de 'z' dans ABCDEFGHIJKLMNO est 0

DELETE

PROCEDURE DELETE(TARGET,INDEX,SIZE);

Cette procédure est utilisée pour supprimer les caractères SIZE de TARGET, en commençant par l'octet nommé dans INDEX. TARGET est une chaîne de caractères. INDEX et SIZE sont des expressions entières. Si SIZE est égal à zéro, aucune action n'est effectuée. S'il est négatif, de graves erreurs en résultent. Si l'INDEX plus la SIZE est supérieur à la TARGET ou si la TARGET est vide, les données et la mémoire environnante peuvent être détruites.

Exemple :

  1. PROCEDURE DELETE_DEMO
  2. VAR
  3.  LONG_STR:STRING;
  4. BEGIN
  5.  LONG_STR:='   se debarrasser des premiers blancs';
  6.  WRITELN(LONG_STR);
  7.  DELETE(LONG_STR,1,POS('g',LONG_STR)-1);
  8.  WRITELN(LONG_STR);
  9. END;

On obtiendra la sortie :

   se debarrasser des premiers blancs
se debarrasser des premiers blancs

INSERT

PROCEDURE INSERT(SOURCE,DESTINATION,INDEX);

Cette procédure est utilisée pour insérer la SOURCE dans la DESTINATION à l'emplacement spécifié dans INDEX. DESTINATION est une chaîne de caractères. SOURCE est un caractère ou une chaîne de caractères, un littéral ou une variable. INDEX est une expression entière. SOURCE peut être vide. Si INDEX est une expression entière. SOURCE peut être vide. Si INDEX est hors limites ou si DESTINATION est vide, la destruction des données se produit. Si l'insertion de SOURCE dans DESTINATION fait que DESTINATION est plus longue que celle autorisée, DESTINATION est tronquée.

Exemple :

  1. PROCEDURE INSERT_DEMO;
  2. VAR
  3.  LONG_STR:STRING;
  4.  S1:STRING[10];
  5. BEGIN
  6.  LONG_STR:='Souviens-toi du 12 mai';
  7.  S1:='Fete des meres';
  8.  INSERT(S1,LONG_STR,14);
  9.  WRITELN(LONG_STR);
  10.  INSERT('de celebrer',LONG_STR,14);
  11.  WRITELN(LONG_STR);
  12. END;

On obtiendra la sortie :

Souviens-toi du 12 mai
Souviens-toi de celebrer Fete des meres du 12 mai

ASSIGN

PROCEDURE ASSIGN(FILE, NAME);

Utilisez cette procédure pour attribuer un nom de fichier externe à une variable de fichier avant une réinitialisation ou une réécriture. FILE est un nom de fichier, NAME est un littéral ou une chaîne de caractères variable contenant le nom du fichier à créer. FILE doit être de type TEXT pour utiliser les noms de périphériques spéciaux ci-dessous.

Notez que le Pascal standard définit un fichier "local". ATARI Pascal implémente cette fonctionnalité en utilisant des noms de fichiers temporaires sous la forme PASTMPxx où "xx" est attribué séquentiellement, en commençant à zéro au début de chaque programme. Si un fichier externe REWRITE n'est pas précédé d'un ASSIGN, alors un nom de fichier temporaire sera également attribué à ce fichier avant sa création.

NAME est normalement un nom de fichier sur disquette au format standard :dn:filename.ext, mais peut également être un nom de périphérique spécial.

Périphérique Description
E: Périphérique d'édition d'écran de console
S: Périphérique de sortie d'écran de console
K: Périphérique d'entrée clavier de console
P: Périphérique de sortie d'imprimante

Remarque : les fichiers cassette (C:) ne sont pas pris en charge par ATARI Pascal.

Exemples d'utilisation d'ASSIGN :

  1. ASSIGN(PRINTFILE,'P:');
  2. ASSIGN(F,'D2:MT280.OVL');
  3. ASSIGN(KEYBOARD,'K:');
  4. ASSIGN(CRT,'S:');

Remarque : Après ASSIGN(CRT,'S:'), vous devez utiliser REWRITE, car l'affectation n'ouvre pas le fichier.

WNB et GNB

FUNCTION GNB(FILEVAR:FILE OF POAC):CHAR;
FUNCTION WNB(FILEVAR:FILE OF CHAR;CH:CHAR):BOOLEAN;

Ces fonctions vous permettent d'avoir un accès au niveau BYTE à un fichier à grande vitesse. POAC est tout type étant fondamentalement un Packed Array of Char. La taille du tableau compacté est idéalement comprise entre 128 et 4095.

GNB vous permettra de lire un fichier octet par octet. Il renvoie une valeur de type CHAR. La fonction EOF sera valide lorsque la fin physique du fichier est atteinte mais ne sera basée sur aucune donnée du fichier.

WNB vous permettra d'écrire un fichier octet par octet. Il faut un fichier et un caractère pour écrire. Il renvoie une valeur booléenne étant vraie s'il y a eu une erreur lors de l'écriture de cet octet dans le fichier. Aucune interprétation n'est effectuée sur les octets écrits.

GNB et WNB sont utilisés (par opposition aux combinaisons F^, GET/PUT) car ils sont nettement plus rapides.

BLOCKREAD et BLOCKWRITE

PROCEDURE BLOCKREAD(F:FILEVAR;BUF:ANY;VAR IOR:INTEGER;SZ,RB:INTEGER);
PROCEDURE BLOCKWRITE(F:FILEVAR;BUF:ANY;VAR IOR:INTEGER;SZ,RB:INTEGER);

Ces procédures sont utilisées pour un accès direct aux disquettes. FILEVAR est un fichier non typé (FILE;). BUF est n'importe quelle variable suffisamment grande pour contenir les données. IOR est un entier qui reçoit la valeur renvoyée par le DOS. SZ est le nombre d'octets à transférer et RB doit toujours être égal à 0.

Les données sont transférées vers ou depuis la variable BUF de l'utilisateur pour le nombre d'octets spécifié.

OPEN

PROCEDURE OPEN(FILE,TITLE,RESULT);

La procédure OPEN augmente la flexibilité d'ATARI Pascal. FILE est n'importe quelle variable de type de fichier. TITLE est une chaîne de caractères contenant le nom du fichier. RESULT est un paramètre VAR INTEGER et, au retour de OPEN, a la même valeur que IORESULT. Le nombre maximum de fichiers pouvant être ouverts à tout moment est de trois, sans compter les fichiers de console (E:, S: ou K:).

La procédure OPEN revient à exécuter une séquence ASSIGN(FILE, TITLE), RESET(FILE) et RESULT:=IORESULT.

Exemple :

  1. OPEN(INFILE,'D:FNAME.DAT',RESULT);

CLOSE et CLOSEDEL

PROCEDURE CLOSE(FILE,RESULT);
PROCEDURE CLOSEDEL(FILE,RESULT);

Les procédures CLOSE et CLOSEDEL sont utilisées respectivement pour la fermeture et la fermeture avec suppression. La procédure CLOSE doit être appelée pour garantir que les données écrites dans un fichier à l'aide d'une méthode quelconque sont correctement purgées du tampon du fichier vers la disquette. Le CLOSEDEL est normalement utilisé sur les fichiers temporaires pour les supprimer après utilisation. FILE et RESULT sont les mêmes que ceux utilisés dans OPEN.

Les fichiers sont implicitement fermés lorsqu'un fichier ouvert est réinitialisé à l'aide RESET.

PURGE

PROCEDURE PURGE(FILE);

La procédure PURGE permet de supprimer un fichier dont le nom est entreposé dans une chaîne de caractères. Vous devez d'abord associé (avec la procédure ASSIGN) le nom au fichier puis exécuter PURGE.

Exemple :

  1. ASSIGN(F,'D2:BADFILE.BAD');
  2. PURGE(F); (* SUPPRIME D2:BADFILE.BAD *)

IORESULT

FUNCTION IORESULT:INTEGER;

Après chaque opération d'entrée/sortie, la valeur renvoyée par la fonction IORESULT est définie par les routines de la bibliothèque d'exécution. Sur le ATARI Home Computer, la règle générale est qu'un résultat différent de zéro signifie une erreur et zéro est un bon résultat.

Exemple :

  1. ASSIGN(F,'D2:BONJOUR');
  2. RESET(F);
  3. IF IORESULT<>0 THEN WRITELN('C:BONJOUR EST PRESENT');

MEMAVAIL et MAXAVAIL

FUNCTION MAXAVAIL:INTEGER;
FUNCTION MEMAVAIL:INTEGER;

Les fonctions MEMAVAIL et MAXAVAIL sont utilisées conjointement avec NEW et DISPOSE pour gérer la zone mémoire de tas dans ATARI Pascal. La fonction MEMAVAIL renvoie la plus grande mémoire totale disponible à un moment donné, quelle que soit la fragmentation. La fonction MAXAVAIL effectuera d'abord le ramasse miettes, puis signalera le plus grand bloc disponible. La fonction MAXAVAIL peut être utilisée pour forcer le ramasse miettes avant une section de programmation urgente.

Le système ATARI Pascal prend entièrement en charge les mécanismes NEW et DISPOSE définis par le standard Pascal. La zone du mémoire de tas s'agrandit à partir de la fin de la zone de données et le cadre de pile (pour la récursivité) s'agrandit du haut de la mémoire vers le bas.

Guide de référence rapide des procédures et paramètres intégrés

Voici la liste par ordre alphabétique au sein de chaque groupe :

Routines de manipulation de tableaux de caractères

PROCEDURE FILLCHAR(DESTINATION,LENGTH,CHARACTER);
PROCEDURE MOVELEFT(SOURCE,DESTINATION,NUM_BYTES);
PROCEDURE MOVERIGHT(SOURCE,DESTINATION,NUM_BYTES);

Routines de manipulation de bits et d'octets

PROCEDURE CLRBIT(VAR BASIC_VAR,BIT_NUM);
FUNCTION  HI(BASIC_VAR):INTEGER;
FUNCTION  LO(BASIC_VAR):INTEGER;
PROCEDURE SETBIT(VAR BASIC_VAR,BIT_NUM);
FUNCTION  SHL(BASIC_VAR,NUM):INTEGER;
FUNCTION  SHR(BASIC_VAR,NUM):INTEGER;
FUNCTION  SWAP(BASIC_VAR):INTEGER;
FUNCTION  TSTBIT(BASIC_VAR,BIT_NUM):BOOLEAN;

Routines de gestion de fichiers

PROCEDURE ASSIGN(FILE, NAME);
PROCEDURE BLOCKREAD(F:FILEVAR;BUF:ANY;VAR IOR:INTEGER;SZ,RB:INTEGER);
PROCEDURE BLOCKWRITE(F:FILEVAR;BUF:ANY;VAR IOR:INTEGER;SZ,RB:INTEGER);
PROCEDURE CLOSE(FILE,RESULT);
PROCEDURE CLOSEDEL(FILE,RESULT);
FUNCTION  GNB(FILEVAR:FILE OF POAC):CHAR;
FUNCTION  IORESULT:INTEGER;
PROCEDURE OPEN(FILE,TITLE,RESULT);
PROCEDURE PURGE(FILE);
FUNCTION  WNB(FILEVAR:FILE OF CHAR;CH:CHAR):BOOLEAN;

Routines diverses

FUNCTION ADDR(VARIABLE REFERENCE):INTEGER;
PROCEDURE EXIT;
FUNCTION MAXAVAIL:INTEGER;
FUNCTION MEMAVAIL:INTEGER;
FUNCTION SIZEOF(VARIABLE OU NOM DE TYPE):INTEGER;

Accès aux données non standard

Variables absolues

variable absolue ::= ABSOLUTE[constante] variable

Les variables ABSOLUTE peuvent être déclarées si vous connaissez l'adresse au moment de la compilation. Vous déclarez les variables comme étant absolues en utilisant une syntaxe spéciale dans une déclaration VAR. Les variables ABSOLUTE ne se voient allouer aucun espace dans votre segment de données par le compilateur et vous êtes responsable de vous assurer qu'aucune variable allouée par le compilateur n'entre en conflit avec les variables absolues. Remarque : les variables STRING peuvent ne pas exister en dessous de [$100] en mémoire.

Exemples :

  1. I:      ABSOLUTE [$8000] INTEGER;
  2. SCREEN: ABSOLUTE [$C000] ARRAY[0..15] OF ARRAY[0..63] OF CHAR;

INLINE

ATARI Pascal possède une fonctionnalité intégrée très utile appelée INLINE. Cette fonctionnalité vous permet d'insérer des données au milieu d'une procédure ou d'une fonction ATARI Pascal. De cette manière, de petits codes machine ou séquences de P-code et des tables de constantes peuvent être insérés dans un programme ATARI Pascal.

Syntaxe

INLINE(valeur1/valeur2/...);

La syntaxe de la fonctionnalité INLINE est très similaire à celle d'un appel de procédure en Pascal. Le mot INLINE est utilisé suivi d'une parenthèse gauche "(" caractère et terminé par une parenthèse droite ")". Les paramètres entre les barres obliques doivent être des constantes ou des références à des variables étant évaluées comme des constantes. Ces constantes peuvent être de l'un des types suivants : CHAR, STRING, BOOLEAN, INTEGER ou REAL. Notez qu'un STRING entre guillemets ne génère pas d'octet de longueur mais simplement les données de la chaîne de caractères.

Les constantes littérales de type entier se verront attribuer un octet si la valeur est comprise entre 0 et 255. Les constantes entières nommées, déclarées se verront toujours attribuer deux octets.

Applications

La fonction INLINE peut être utilisée pour insérer du code ou pour créer des tableaux de temps de compilation. Les deux sections suivantes donnent des exemples de chacune de ces utilisations.

Le fragment de programme ci-dessous montre comment la fonction INLINE peut être utilisée pour construire un calendrier de compilation.

Exemple :

  1. PROGRAM DEMO_INLINE;
  2.  
  3. TYPE
  4.  IDFIELD=ARRAY[1..4] OF ARRAY[1..10] OF CHAR;
  5.  
  6. VAR
  7.  TPTR:^IDFIELD;
  8.  
  9. PROCEDURE TABLE;BEGIN
  10.  INLINE('ATARI    ' /
  11.         'HOME     ' /
  12.         'COMPUTER ' /
  13.         'SYSTEMS...');
  14. END;
  15.  
  16. BEGIN (* PROGRAMME PRINCIPAL *)
  17.  TPTR:=ADDR(TABLE)+5; (* +5 pour P-code seulement *)
  18.  WRITELN(TPTR^[3]);   (* Doit écrire 'COMPUTER ' *)
  19. END.

Extensions graphique et sonore

Le paquet graphique, son et contrôleur se compose d'un fichier d'inclusion, GSPROCS, et d'un module Pascal, GRSND.ERL. Le fichier inclus définit les points d'entrée disponibles dans le module Pascal. Le module Pascal doit être lié à votre programme.

Pour utiliser le paquet, tapez ($ID:GSPROCS*) après les variables globales de votre programme et exécutez INITGRAPHICS comme première instruction de votre programme principal.

Exemple :

  1. PROGRAM GRSND;
  2.  
  3. LABEL
  4.  .....;
  5.  
  6. CONST 
  7.  .....;
  8.  
  9. TYPE
  10.  .....;
  11.  
  12. VAR
  13.   .....;
  14.   
  15. (* INCLURE LES DEFINITIONS DE GRAPHIQUES ET DE SON *)
  16. (*$ID:GSPROCS*)
  17.  
  18. (* PROCEDURES LOCAL *)
  19.  
  20. PROCEDURE XXXX;
  21.   BEGIN
  22.   .....;
  23.   END;
  24.  
  25. PROCEDURE YYYY;
  26.   BEGIN
  27.   .....;
  28.   END;
  29.  
  30. (* PROGRAMME PRINCIPALE *)
  31. BEGIN
  32.  INITGRAPHICS(5); (* INITIALISE LE PAQUET GRAPHIQUE AVEC UN MODE MAXIMUM GRAPHIQUE DE 5 *)
  33.   .....;
  34. END.

Les sections suivantes décrivent chacun des éléments disponibles dans le paquet graphique et sonore.

Types d'écran

  1. TYPE
  2.  SCRN_TYPE=(SPLIT_SCEEEN,FULL_SCREEN);
  3.  CLEAR_TYPE=(CLEAR_SCREEN,DO_NOT_CLEAR_SCREEN); 

Ces types d'écran sont utilisés par la procédure GRAPHICS pour définir le type d'écran et si l'écran sera effacé ou non lors de la procédure GRAPHICS.

Variables

  1. VAR
  2.  SCRNFILE: EXTERNAL TEXT;
  3.  GRRESULT: EXTERNAL INTEGER;

SCRNFILE peut être utilisé pour effectuer des entrées/sorties Pascal standard sur l'écran telles que :

  1. WRITE(SCRNFILE,'A');

Cette variable enverra un "A" à l'écran et en fonction de ce mode actuel, le "A" sera affiché d'une manière ou d'une autre. Notez que cette technique n'est normalement utilisée que dans les modes graphiques 1 et 2. Pour les autres modes graphiques, utilisez les procédures décrites ci-dessous.

GRRESULT est utilisé pour déterminer si des erreurs se sont produites lors de l'une des procédures graphiques. Voici les procédures et fonctions modifiant GRRESULT :

Procédures ou fonctions Résultat
INITGRAPHICS GRRESULT = 0 correcte, 255 = Erreur
GRAPHICS GRRESULT = 0 correcte, 255 = Erreur
PLOT GRRESULT = Résultat d'un appel XIO
LOCATE GRRESULT = Résultat d'un appel XIO
FILL GRRESULT = Résultat d'un appel XIO
DRAWTO GRRESULT = Résultat d'un appel XIO

Procédures et fonctions graphique

Procédure d'initialisation

PROCEDURE INITGRAPHICS(MAX_MODE:INTEGER);

INITGRAPHICS doit être la première instruction d'un programme utilisant le module graphique et sonore. Il y a un paramètre :

Paramètre Description
MAX_MODE Le mode maximum utilisé par ce programme doit être une valeur comprise entre 0 et 9.

Si une erreur se produit, le GRRESULT=255 sinon ; GRRESULT = 0.

Procédure graphique

PROCEDURE GRAPHICS(MODE:INTEGER; SCREEN:SCRN_TYPE; CLEAR:CLEAR_TYPE);

GRAPHICS remplit la même fonction que l'instruction GRAPHICS dans ATARI BASIC, sauf qu'elle a trois paramètres au lieu d'un :

Paramètre Description
MODE Le mode graphique souhaité 0 à MAX_MODE
SCREEN FULL_SCREEN ou SPLIT_SCREEN
CLEAR CLEAR_SCREEN ou DO_NOT_CLEAR_SCREEN.

Si une erreur se produit, alors GRRESULT = 255 ; sinon, GRRESULT = 0.

Procédure en mode texte (Textmode)

PROCEDURE TEXTMODE;

TEXTMODE ferme "S:" et rouvre "E:". GRRESULT est inchangé.

Procédure Setcolor

PROCEDURE SETCOLOR(REGISTER,HUE,LUMINANCE:INTEGER);

SETCOLOR remplit la même fonction que l'instruction SETCOLOR dans ATARI BASIC. GRRESULT est inchangé.

Paramètre Description
REGISTER Une valeur de 0 à 4. Voir SetColor du ATARI BASIC.
HUE Une valeur de 0 à 15. Voir SetColor du ATARI BASIC.
LUMINANCE Une valeur de 0 à 14. Voir SetColor du ATARI BASIC.

Procédure Color

PROCEDURE COLOR(COLOR_VALUE:INTEGER);

COLOR remplit la même fonction que l'instruction COLOR en BASIC.

Paramètre Description
COLOR_VALUE Une valeur de 0 à 255. Voir Color du ATARI BASIC.

Procédure Plot

PROCEDURE PLOT(X,Y:INTEGER);

PLOT remplit la même fonction que l'instruction PLOT dans ATARI BASIC. Il trace un point dans la couleur actuelle à la position X,Y de l'écran.

Paramètre Description
X La coordonnée horizontale sur l'écran.
Y La coordonnée verticale sur l'écran.

GRRESULT = valeur d'un appel de caractère XIO PUT.

Procédure Locate

FUNCTION LOCATE(X,Y:INTEGER):INTEGER;

LOCATE remplit la même fonction que l'instruction LOCATE dans ATARI BASIC. Il renvoie la valeur du pixel à la position de l'écran X,Y.

Paramètre Description
X La coordonnée horizontale sur l'écran.
Y La coordonnée verticale sur l'écran.

GRRESULT = valeur d'un appel de caractère XIO GET.

Procédure Position

PROCEDURE Position(X,Y:INTEGER);

POSITION remplit la même fonction que l'instruction POSITION dans ATARI BASIC. Il déplace le curseur graphique invisible vers la position X,Y. Notez que le curseur n'est pas déplacé jusqu'à ce que la fonction d'entrée/sortie suivante soit exécutée.

Paramètre Description
X La coordonnée horizontale sur l'écran.
Y La coordonnée verticale sur l'écran.

Procédure DrawTo

PROCEDURE DrawTo(X,Y:INTEGER);

DRAWTO remplit la même fonction que l'instruction DRAWTO dans ATARI BASIC. Il trace une ligne depuis la position graphique actuelle jusqu'à la position X,Y dans la couleur actuelle.

Paramètre Description
X La coordonnée horizontale sur l'écran.
Y La coordonnée verticale sur l'écran.

GRRESULT = valeur d'un appel de XIO DRAWTO.

Procédure Fill

PROCEDURE FILL(X,Y:INTEGER);

FILL remplit la même fonction que l'appel XIO 18 dans ATARI BASIC sauf qu'il effectue un tracé à la position X,Y pour déplacer le curseur vers X,Y à la fin du FILL.

Paramètre Description
X La coordonnée horizontale sur l'écran.
Y La coordonnée verticale sur l'écran.

GRRESULT = valeur d'un appel de XIO FILL.

Procédures et fonctions de son

Procédure Sound

PROCEDURE SOUND(VOICE,PITCH,DISTORTION,VOLUME:INTEGER);

SOUND remplit la même fonction que l'instruction SOUND dans ATARI BASIC. Il active le canal sonore indiqué par VOICE aux valeurs PITCH, DISTORTION et VOLUME indiquées.

Paramètre Description
VOICE Ce paramètre permet d'indiquer le numéro du canal, soit une valeur entre 0 et 3
PITCH Ce paramètre permet d'indiquer une période, soit une valeur entre 0 et 255, correspondant à la formule : Fréquence = 31960/Période. Plus la période est grande, plus la fréquence est basse
DISTORTION Ce paramètre permet d'indiquer la distorsion, soit une valeur entre 0 et 14.
VOLUME Ce paramètre permet d'indiquer le volume, soit une valeur entre 0 et 15. La valeur maximal est 15.

Procédure Soundoff

PROCEDURE SOUNDOFF;

SOUNDOFF coupe le son sur tous les canaux sonores.

Dispositif de contrôle

Fonction Paddle

FUNCTION PADDLE(PDLNUM:INTEGER):INTEGER;

PADDLE remplit la même fonction que l'instruction PADDLE dans ATARI BASIC. Il renvoie la valeur actuelle de l'une des huit palettes.

Paramètre Description
PDLNUM Le numéro de palette à renvoyer doit-il être une valeur comprise entre 0 et 7.

Fonction Trigger

FUNCTION PTRIG(PDLNUM:INTEGER):INTEGER;

PTRIG remplit la même fonction que l'instruction PTRIG dans ATARI BASIC. Il renvoie la valeur de déclenchement actuelle de l'une des huit palettes.

Paramètre Description
PDLNUM Le numéro de palette à renvoyer doit-il être une valeur comprise entre 0 et 7.

Manette de jeux

Fonction Stick

FUNCTION STICK(STKNUM:INTEGER):INTEGER;

STICK remplit les mêmes fonctions que l'instruction STICK dans ATARI BASIC. Il renvoie la valeur actuelle de l'un des quatre manettes de jeux.

Paramètre Description
STKNUM Est-ce le numéro de la manette de jeux à retourner ; doit être une valeur 0 et 3.


Dernière mise à jour : Jeudi, le 29 février 2024