Section courante

A propos

Section administrative du site

Types prédéfinis

En plus des types prédéfinis de Pascal Standard (REAL, INTEGER, CHAR, ARRAY,...), l'Apple Pascal a un type STRING, un type de fichier INTERACTIVE et un type LONG INTEGER. De plus, les détails de certains autres types prédéfinis diffèrent de Standard Pascal.

Le type STRING

L'Apple Pascal a un nouveau type prédéclaré, STRING. La valeur d'une variable STRING est une séquence de caractères. Les variables de type de données STRING sont essentiellement PACKED ARRAY OF CHAR ayant un nombre d'éléments (caractères) changeant dynamiquement. Cependant, la valeur d'une variable STRING ne peut pas être affectée à un PACKED ARRAY OF CHAR, et la valeur d'un PACKED ARRAY OF CHAR ne peut pas être affectée à une variable STRING. Les chaînes de caractères sont prises en charge par un ensemble de procédures et de fonctions intégrées.

Le nombre de caractères dans une chaîne de caractères à tout moment correspond à la longueur de la chaîne de caractères. La longueur maximale par défaut d'une variable STRING est de 80 caractères, mais cela peut être remplacé dans la déclaration d'une variable STRING (jusqu'à la limite absolue de 255). Pour ce faire, mettez la longueur maximale souhaitée entre [crochets] après l'identificateur de type de données STRING. Des exemples de déclarations de variables STRING sont :

  1. TITLE:STRING; (* par défaut, une longueur maximale de 80 caractères *)
  2. NAME:STRING[30]; (* autorise STRING à contenir au maximum 30 caractères *)

La valeur d'une variable STRING peut être modifiée à l'aide d'une instruction d'affectation avec une constante de chaîne de caractères ou une autre variable STRING :

  1. TITLE := '  C''EST UN TITRE   '

ou

  1. NAME := TITLE

ou au moyen de la procédure READ :

  1. READLN(TITLE)

ou au moyen des modules intégrés STRING :

  1. NAME:=COPY(TITLE,1,30)

Notez qu'une constante de chaîne de caractères ne peut pas contenir de fin de ligne; la constante doit être sur une seule ligne du programme.

Les caractères individuels dans une STRING sont indexés de 1 à la LENGTH de la STRING. Le LENGTH est une fonction intégrée. Par exemple, si TITLE est le nom d'une chaîne de caractères, alors :

  1. TITLE[1]

est une référence au premier caractère de TITLE, et :

  1. TITLE[LENGTH(TITLE)]

est une référence au dernier caractère de TITLE. Une variable de type STRING peut être comparée à une autre variable de type STRING ou à une constante de chaîne de caractères, quelle que soit sa longueur dynamique actuelle. La comparaison est lexicographique: exemple, une chaîne est supérieure à une autre si elle venait en premier dans une liste alphabétique de chaînes de caractères. Le calcul d'un ensemble de caractères ASCII est utilisé pour le déterminer. Le programme suivant est une démonstration de comparaisons légales impliquant des variables de type de données STRING :

  1. PROGRAM COMPARESTRINGS;
  2. VAR S: STRING;
  3.     T: STRING[40];
  4. BEGIN
  5.  S:= 'QUELQUE CHOSE';
  6.  T:= 'QUELQUE CHOSE DE PLUS GRAND';
  7.  IF S = T THEN 
  8.    WRITELN('Les chaîne de caractères ne fonctionnent pas très bien ')
  9.  ELSE
  10.    IF S > T THEN
  11.      WRITELN(S,' est supérieur à ',T)
  12.   ELSE
  13.      IF S < T THEN
  14.    WRITELN(S,' est inférieur à ',T);
  15.  IF S = 'QUELQUE CHOSE'THEN
  16.    WRITELN(S,' égale ',S);
  17.  IF S > 'MEME CHOSE' THEN WRITELN(S,' est supérieur à MEME CHOSE');
  18.  IF S = 'QUELQUE CHOSE ' THEN
  19.   WRITELN('LES BLANCS NE COMPTE PAS')
  20.  ELSE
  21.   WRITELN('LES BLANCS PARAISSENT FAIRE UNE DIFFERENCE',T);
  22.  IF S > T THEN
  23.   WRITELN(S,' est supérieur à ',T)
  24.  ELSE
  25.   WRITELN(S,' est inférieur à ',T);
  26. END.

on obtiendra le résultat suivant :

QUELQUE CHOSE est inférieur à QUELQUE CHOSE DE PLUS GRAND
QUELQUE CHOSE égale QUELQUE CHOSE
QUELQUE CHOSE est supérieur à MEME CHOSE
LES BLANCS PARAISSENT FAIRE UNE DIFFERENCEQUELQUE CHOSE DE PLUS GRAND
QUELQUE CHOSE est inférieur à QUELQUE CHOSE DE PLUS GRAND

Les chaînes de caractères peuvent également être déclarées en tant que constantes, comme dans l'exemple suivant :

  1. PROGRAM CONST1;
  2. CONST SYLVAIN='Salut, je suis Sylvain la String!';
  3. BEGIN
  4.  WRITELN(SYLVAIN);
  5. END.

Une variable de type de données STRING ne peut pas être indexée au-delà de sa longueur dynamique actuelle. La séquence suivante entraînera une erreur d'exécution d'index non valide :

  1. TITLE:= '1234';
  2. TITLE[5]:='5';

Méfiez-vous des chaînes de caractères de longueur 0 : elles ne peuvent pas du tout être indexées sans provoquer de résultats imprévisibles ou une erreur d'exécution. Si un programme indexe une chaîne de caractères pouvant avoir une longueur 0, il doit d'abord utiliser la fonction LENGTH pour voir si la longueur est égale à zéro. Si la longueur est égale à zéro, le programme ne doit pas exécuter d'instructions indexant la chaîne de caractères. Notez qu'une valeur de chaîne de caractères contenant un seul caractère n'est pas la même chose qu'une valeur CHAR; les chaînes de caractères et CHAR sont des types de données distincts. Une exception existe, c'est qu'une constante de chaîne de caractères contenant un seul caractère a exactement la même forme qu'une constante CHAR, et une telle constante peut être utilisée soit une valeur CHAR soit une valeur de chaîne de caractères. Vous ne pouvez pas définir une fonction de type STRING. Cependant, il existe des fonctions intégrées de type de données STRING.

Les types FILE

Dans les explications allant suivre, pour chaque fichier nommé F déclaré dans un programme Pascal, il existe une variable déclarée automatiquement nommée F^. Il s'agit de la variable tampon du fichier. Certains manuels Pascal utilisent également le terme plus vague «fenêtre» pour décrire la façon dont différents enregistrements de fichiers peuvent être chargés dans la variable de tampon. Dans cette page, on parle d'un pointeur de fichier associé à chaque fichier ouvert. Le pointeur de fichier pointe vers un enregistrement du fichier, appelé «enregistrement actuel». Veuillez comprendre que le pointeur de fichier n'est pas une variable Pascal POINTER mais juste un moyen pratique de discuter des enregistrements de fichiers.

FICHIERS INTERACTIVE

Comme un fichier TEXT, un fichier INTERACTIVE est un fichier de caractères. La différence réside dans la manière dont les fichiers INTERACTIVE et TEXT sont traités par les procédures RESET, READ et READLN.

Lorsqu'un programme Pascal effectue un READ de caractères d'un fichier TEXT, le programme doit d'abord ouvrir le fichier avec RESET. La procédure RESET effectue automatiquement une opération GET; autrement dit, il charge le premier caractère du fichier dans la variable tampon du fichier, puis fait avancer le pointeur de fichier sur le caractère suivant. Un READ ou READLN subséquent avec une variable de type CHAR commence ses opérations en prenant en premier le caractère étant déjà dans la variable tampon, puis en exécutant un GET.

Si le fichier est de type INTERACTIVE au lieu de TEXT, l'ouverture RESET n'effectue pas de GET. La variable de tampon n'est pas définie et le pointeur de fichier pointe vers le premier caractère du fichier au lieu du second. Par conséquent, un READ ou READLN ultérieur doit commencer son opération en effectuant d'abord un GET, puis en prononçant le caractère ayant été placé dans la variable de tampon par le GET. C'est l'inverse de la séquence READ utilisée avec un fichier TEXT.

Il y a une raison principale pour utiliser le type INTERACTIVE. Si un fichier n'est pas un fichier de disquette mais représente un périphérique tel que le clavier, il n'est pas possible d'effectuer un GET dessus tant qu'un caractère n'a pas été saisi. Si RESET essayait de faire un GET, le programme n'irait pas plus loin jusqu'à ce qu'un caractère soit tapé. Avec le type INTERACTIVE, le programme n'effectue pas de GET jusqu'à ce qu'il exécute un READ ou READLN. Les fichiers prédéclarés standard INPUT et OUTPUT sont des fichiers INTERACTIVE représentant le clavier et l'écran de la console; un autre fichier prédéfini appelé KEYBOARD représente également le clavier.

Fichiers non typés

En plus des types de fichiers standard et du type INTERACTIVE, l'Apple Pascal autorise les fichiers «non typés» - des objets étant déclarés avec le mot FILE et rien de plus. Exemple :

  1. VAR F:FILE;

Les fichiers non typés ne peuvent être utilisés qu'avec la fonction intégrée BLOCKREAD et BLOCKWRITE pour les transferts de données à grande vitesse. Un fichier non typé F peut être considéré comme un fichier sans variable tampon F^. Toutes les entrées/sorties de ce fichier doivent être effectuées par BLOCKREAD et BLOCKWRITE.

Fichiers prédéfinis

Les fichiers prédéfinis standard INPUT et OUTPUT font référence respectivement au clavier et à l'écran. En plus de ceux-ci, Apple Pascal fournit un fichier prédéfini appelé KEYBOARD. La différence entre INPUT et KEYBOARD est que lorsque INPUT est utilisé pour désigner le clavier, les caractères saisis sont automatiquement affichés à l'écran; lorsque KEYBOARD est utilisé, les caractères ne sont pas affichés automatiquement. Il permet à un programme Pascal d'avoir un contrôle complet sur la réponse aux caractères tapés par l'utilisateur. Les trois fichiers prédéfinis sont de type INTERACTIVE, et tous les trois sont automatiquement ouverts via RESET lorsque le programme Pascal commence à s'exécuter.

Fichiers texte

Le système Apple Pascal prévoit qu'un fichier de disquette TEXT ou INTERACTIVE créé avec ".TEXT" comme dernière partie de son titre a un format interne spécial. Ces fichiers sont appelés «fichiers texte». Ne confondez pas les fichiers texte avec les fichiers de type TEXT ou INTERACTIVE mais n'ayant pas de titres se terminant par ".TEXT".

Toutes les parties du système Pascal traitant des fichiers de caractères (comme l'éditeur) sont conçues pour utiliser le format spécial de fichiers texte: et si un fichier texte est accédé par un programme Pascal, alors le programme Pascal utilisera également le format spécial. Par conséquent, la procédure normale consiste à utiliser un titre se terminant par ".TEXT" chaque fois que vous créez un fichier de disquette de type Pascal TEXT ou INTERACTIVE. Le format d'un fichier texte est le suivant : Au début du fichier se trouve une page d'entête de 1024 octets, contenant des informations pour l'utilisation de l'éditeur de texte. Cet espace est respecté par toutes les parties du système. Lorsqu'un programme utilisateur Pascal crée un fichier texte (via REWRITE), le système crée automatiquement l'entête. Lorsqu'un programme utilisateur Pascal accède à un fichier texte existant (via RESET), le système ignore l'entête. En d'autres termes, l'entête est invisible pour un programme Pascal utilisateur utilisant REWRITE et RESET.

Lorsqu'un programme utilise BLOCKREAD et BLOCKWRITE pour accéder aux fichiers, la structure spéciale n'est pas respectée.

Le système transférera l'entête uniquement sur un transfert de disquette à disquette, et l'omettra lors d'un transfert vers un périphérique série (ainsi les transferts de disquette vers une imprimante ou vers la console omettra l'entête). Après la page d'entête, le contenu du contenu texte lui-même apparaît dans des pages de texte de 1024 octets. Chaque page de texte est une séquence de lignes et la dernière ligne de la page est suivie de suffisamment de caractères nuls (ASCII 00) pour remplir les 1024 octets. Une ligne est définie comme :

[DLE indent] [text] CR

où les crochets indiquent que le DLE et le code de retrait peuvent être absents et le texte lui-même peut être absent.

Le CR est le caractère de contrôle «Retour de chariot» (ASCII 13) et peut être absent à la fin de la dernière ligne du fichier. Le DLE est le caractère de contrôle «Data Link Escape» (ASCII 16). S'il est présent, il est suivi d'un code indiquant l'indentation de la ligne. Le code est 32 + le nombre d'espaces à indent. Ainsi, tous les espaces de début sur une ligne sont remplacés par le DLE et le code d'indentation.

Le code DLE et indent et les valeurs nulles à la fin d'une page de texte sont, comme l'entête, invisibles pour un programme Pascal. Les identifiants DLE et indent sont automatiquement converties en espaces de début, et vice versa.

La fin du fichier est marquée par le caractère de contrôle ETX (ASCII 3).

Les types d'ensemble

Le Apple Pascal prend en charge toutes les constructions Standard Pascal pour les ensembles. Deux limitations sont imposées aux ensembles :

Un ensemble de 512 éléments occupera 32 mots de mémoire.

Les comparaisons et les opérations sur des ensembles ne sont autorisées qu'entre des ensembles dont les éléments individuels sont du même type. Par exemple, dans l'exemple de programme ci-dessous, le type de base de l'ensemble S est le type de sous-plage 0..49, tandis que le type de base de l'ensemble R est le type de sous-plage 1..100. Le type sous-jacent des deux ensembles est le type INTEGER, donc les comparaisons et les opérations sur les ensembles S et R dans le programme suivant sont légales :

  1. PROGRAM COMPARESET;
  2. VAR S: SET OF 0..49;
  3.     R: SET OF 1..100;
  4. BEGIN
  5.  S:= [0,5,10,15,20,25,30,35,40,45];
  6.  R:= [10,20,30,40,50,60,70,80,90];
  7.  IF S = R THEN
  8.   WRITELN('... est égale ...')
  9.  ELSE
  10.   WRITELN('Ensemble le travail');
  11. END.

Dans l'exemple suivant, la comparaison I = J n'est pas légale car les deux ensembles sont de deux types sous-jacents distincts.

  1. PROGRAM SETILLEGAL;
  2. TYPE TRUCS=(ZERO,UN,DEUX);
  3. VAR I: SET OF TRUCS;
  4.     J: SET OF 0..2;
  5. BEGIN
  6.  I:= [ZERO];
  7.  J:= [1,2];
  8.  IF I=J THEN (* ... *)
  9. END.

Variables compactées

Pack et Unpack

L'Apple Pascal ne nécessite pas les procédures PACK et UNPACK du Pascal Standard, et ces procédures ne sont pas fournies. Si une variable est PACKED, tous les emballages et déballages requis sont effectués automatiquement élément par élément.

Fichiers compactées

L'Apple Pascal ne prend pas en charge les types PACKED FILE. Un PACKED FILE peut être déclaré, mais les données du fichier ne seront pas réellement compressées.

Tableaux (ARRAY) compactées

Le compilateur Apple Pascal prend en charge les ARRAY PACKED tels que définis dans le Pascal Standard. Par exemple, considérez les déclarations suivantes :

  1. A:ARRAY[0..9] OF CHAR;
  2. B:PACKED ARRAY[0..9] OF CHAR; 

Le tableau A occupera dix mots de mémoire de 16 bits, chaque élément du tableau occupant un mot. Le PACKED ARRAY B, quant à lui, n'occupera qu'un total de 5 mots, car chaque mot de 16 bits contient deux caractères de 8 bits. Chaque élément de B a une longueur de 8 bits. Le PACKED ARRAY n'a pas besoin d'être limité aux tableaux de type CHAR. Par exemple :

  1. C: PACKED ARRAY[0..1] OF 0..3;
  2. D: PACKED ARRAY[1..9] OF SET OF 0..15;
  3. D2: PACKED ARRAY[0..239,0..319] OF BOOLEAN;

Chaque élément du PACKED ARRAY C ne mesure que 2 bits, car seuls 2 bits sont nécessaires pour représenter les valeurs comprises entre 0 et 3. Par conséquent, C n'occupe qu'un seul mot de mémoire de 16 bits et 12 des bits de ce mot sont inutilisés. Le PACKED ARRAY D est un tableau de 9 mots, puisque chaque élément de D est un SET pouvant être représenté dans un minimum de 16 bits. Chaque élément d'un PACKED ARRAY OF BOOLEAN, tel que D2 dans l'exemple ci-dessus, n'occupe qu'un seul bit.

Les détails de la manière exacte dont les variables sont compactées ne sont pas spécifiés. Dans la plupart des cas, l'espace minimum dans lequel un tableau peut être compressé est d'un mot (deux octets de huit bits). Par exemple, considérez :

  1. BITS: PACKED ARRAY[0..7] OF BOOLEAN;

Il s'agit d'un tableau à huit éléments où chaque élément nécessite un bit, vous pouvez donc vous attendre à ce qu'il occupe huit bits ou un octet. En fait, il occupe un mot ou deux octets. De plus, le tableau bidimensionnel :

  1. BATS: PACKED ARRAY[0..3] OF PACKED ARRAY[0..7] OF BOOLEAN;

ou est l'équivalent :

  1. BATS: PACKED ARRAY[0..3,0..7] OF BOOLEAN;

se compose de quatre tableaux. Chacun d'eux, comme le tableau précédent, occupe un mot. Par conséquent, BATS occupe quatre mots. Notez qu'un PACKED ARRAY OF CHAR occupe toujours un octet par élément. De plus, le conditionnement ne se produit jamais au-delà des limites des mots. Il signifie que si le type d'élément à compresser nécessite un nombre de bits ne se divisant pas uniformément en 16, il y aura des bits inutilisés dans chacun des mots où le tableau est entreposé. Les deux déclarations suivantes ne sont PAS équivalentes en raison de la façon dont le compilateur Pascal est mise en oeuvre :

  1. E: PACKED ARRAY[0..9] OF ARRAY[0..3] OF CHAR;
  2. F: PACKED ARRAY[0..9,0..3] OF CHAR; 

Dans les déclarations de E, la deuxième occurrence du mot réservé ARRAY provoque la désactivation de l'option de compression dans le compilateur. Le E devient un tableau non compressé de 40 mots. Par contre, le PACKED ARRAY F n'occupe que 20 mots car le mot réservé ARRAY n'apparaît qu'une seule fois dans la déclaration. Si E est déclaré comme ceci :

  1. E: PACKED ARRAY[0..9] OF PACKED ARRAY[0..3] OF CHAR;

ou est :

  1. E: ARRAY[0..9] OF PACKED ARRAY[0..3] OF CHAR;

Le F et E auront des configurations identiques.

Lors de la déclaration d'un PACKED ARRAY, le mot PACKED n'a de sens qu'avant la dernière apparition du mot ARRAY dans la déclaration. En cas de doute, une bonne règle de base pour déclarer un PACKED ARRAY multidimensionnel pour vous assurer que le tableau résultant sera PACKED.

Le tableau ne sera compressé que si le type de chaque élément du tableau est scalaire, sous-gamme ou un ensemble et que chaque élément du tableau peut être représenté en 8 bits ou moins. Pour un tableau dont les éléments sont des ensembles, cela signifie que le type sous-jacent de l'ensemble ne doit pas contenir plus de 8 éléments et ne doit contenir aucun entier supérieur à 255.

La déclaration suivante n'entraînera aucun compactage car le type final du tableau ne peut pas être représenté dans un champ de 8 bits :

  1. G: PACKED ARRAY[0..3] OF 0..1000;

Le G sera un tableau occupant quatre mots de 16 bits. Notez qu'une constante de chaîne de caractères peut être affectée à un PACKED ARRAY OF CHAR (s'il a exactement la même longueur), mais pas à un ARRAY OF CHAR non compressé. De même, les comparaisons entre un ARRAY OF CHAR et une constante de chaîne de caractères sont illégales. En raison de leurs différentes tailles, le PACKED ARRAY ne peut pas être comparé à un ARRAY ordinaire non compacté. Un PACKED ARRAY OF CHAR peut être affiché avec une seule instruction d'écriture (exactement comme s'il s'agissait d'une chaîne de caractères) :

  1. PROGRAM TRESLISSE;
  2. VAR T:PACKED ARRAY[0..10] OF CHAR;
  3. BEGIN
  4.  T:='BONJOUR ICI';
  5.  WRITELN(T)
  6. END.

Enregistrement (RECORD) compactées

La déclaration RECORD suivante déclare un RECORD avec quatre champs. Le RECORD entier occupe un mot de 16 bits suite à sa déclaration comme étant un PACKED RECORD.

  1. VAR R:PACKED RECORD
  2.        I,J,K:0..31;
  3.        B:BOOLEAN;
  4.     END;

Les variables I, J, K occupent chacune 5 bits dans le mot. La variable booléenne B est allouée au 16e bit du même mot. De la même manière que PACKED ARRAY peut être multidimensionnel PACKED ARRAY, PACKED RECORD peut contenir des champs étant eux-mêmes PACKED RECORD ou PACKED ARRAY. Là encore, de légères différences dans la manière dont les déclarations sont faites affecteront les degrés de compactage obtenus. Par exemple, notez que les deux déclarations suivantes ne sont pas équivalentes :

  1. VAR A:PACKED RECORD
  2.  C:INTEGER;
  3.  F:PACKED RECORD
  4.   R:CHAR;
  5.   K:BOOLEAN;
  6.  END;
  7.  H:PACKED ARRAY[0..3] OF CHAR;
  1. VAR B:PACKED RECORD
  2.  C:INTEGER;
  3.  F:RECORD
  4.   R:CHAR;
  5.   K:BOOLEAN;
  6.  END;
  7.  H:PACKED ARRAY[0..3] OF CHAR;

Comme avec PACKED ARRAY, le mot PACKED doit apparaître à chaque occurrence du mot RECORD pour que PACKED RECORD conserve ses qualifications compactées dans tous les champs de RECORD. Dans l'exemple ci-dessus, seul RECORD A a tous ses champs regroupés en un seul mot. En B, le champ F n'est pas compressé et occupe donc deux mots de 16 bits. Il est important de noter qu'un ARRAY ou RECORD compacté ou décompacté étant un champ d'un PACKED RECORD commencera toujours au début de la limite de mot suivante. Il signifie que dans le cas de A, même si le champ F ne remplit pas complètement un mot, le champ H commence au début de la limite de mot suivante.

Une variante de cas peut être utilisée comme dernier champ d'un PACKED RECORD, et la quantité d'espace lui étant allouée sera la taille de la plus grande variante parmi les divers cas.

  1. VAR K:PACKED RECORD
  2.  B:BOOLEAN;
  3.  CASE F:BOOLEAN OF
  4.   TRUE: (Z:INTEGER);
  5.   FALSE: (M:PACKED ARRAY[0..3] OF CHAR)
  6.  END;

Dans l'exemple ci-dessus, les champs B et F sont entreposés dans deux bits du premier mot de 16 bits de l'enregistrement. Les 14 bits restants ne sont pas utilisés. La taille du champ de variante de cas est toujours la taille de la plus grande variante, donc dans le champ de variante de cas occupera deux mots. Ainsi, l'intégralité de l'enregistrement PACKED occupera trois mots.

Utilisation des variables PACKED comme paramètres

Aucune variable PACKED ne peut être transmise en tant que paramètre VAR (appel par référence) à une PROCEDURE ou FUNCTION. Les variables compactées peuvent cependant être passées en tant que paramètres d'appel par valeur ordinaires.

Le type entier long

Dans Apple Pascal, le type prédéfini INTEGER peut être modifié par un attribut de longueur comme dans l'exemple suivant :

  1. TYPE BIGNUM=INTEGER[12];
  2. VAR FATS:INTEGER[25];

Il définit BIGNUM comme un type pouvant avoir n'importe quelle valeur entière ne nécessitant pas plus de 12 chiffres décimaux. Le FATS peut avoir n'importe quelle valeur entière ne nécessitant pas plus de 25 chiffres. L'attribut length peut être n'importe quelle constante INTEGER non signée jusqu'à 36 inclus.

Il s'agit d'un nouveau type de type, appelé LONG INTEGER. Le LONG INTEGER convient aux applications commerciales, scientifiques ou autres nécessitant une longueur de nombre étendue avec une précision totale. Un LONG INTEGER est représenté en interne sous la forme d'un nombre décimal codé en binaire (BCD); c'est-à-dire que chaque chiffre décimal de la valeur est représenté en binaire. Cette situation signifie qu'il ne peut y avoir aucune erreur d'arrondi en travaillant avec des valeurs LONG INTEGER.

Les constantes LONG INTEGER sont également autorisées. Toute constante entière dont la valeur dépasse MAXINT est automatiquement une constante de type LONG INTEGER.

Les opérations arithmétiques entiers (+, -, * et DIV) peuvent tous être utilisés avec des valeurs LONG INTEGER. Cependant, MOD ne peut pas être utilisé avec LONG INTEGER. En arithmétique entière, un débordement se produit si un résultat intermédiaire ou final nécessite plus de 36 chiffres décimaux. Lorsqu'une valeur LONG INTEGER est affectée à une variable LONG INTEGER, un débordement se produit si la valeur nécessite plus de chiffres décimaux que la longueur définie de la variable.

Une valeur INTEGER peut toujours être affectée à une variable LONG INTEGER; il est automatiquement converti à la longueur appropriée. Cependant, la valeur LONG INTEGER ne peut jamais être affectée à une variable INTEGER. Si les valeurs INTEGER et LONG INTEGER sont mélangées dans une expression, les valeurs INTEGER sont converties en LONG INTEGER et le résultat est une valeur LONG INTEGER. Le LONG INTEGER et REAL sont incompatibles; ils ne peuvent jamais être mélangés dans une expression arithmétique ou assignés les uns aux autres.

Tous les opérateurs relationnels standard peuvent être utilisés avec des valeurs mixtes LONG INTEGER et INTEGER.

La procédure intégrée STR accepte une valeur LONG INTEGER en tant que paramètre et la convertit en une chaîne de caractères de chiffres décimaux. La fonction intégrée TRUNC accepte une valeur LONG INTEGER comme paramètre et renvoie la valeur INTEGER correspondante si la valeur absolue de LONG INTEGER est inférieure ou égale à MAXINT. Ces fonctions intégrées sont les seuls fonctions acceptant les paramètres LONG INTEGER.

Une tentative de déclaration d'un LONG INTEGER dans une liste de paramètres entraînera une erreur de syntaxe. Cette restriction peut être contournée en définissant un type étant un LONG INTEGER. Par exemple :

  1. TYPE LONG=INTEGER[18];
  2. PROCEDURE BIGNUMBER(BANKACCT:LONG);

D'autres exemples :

  1. VAR I:INTEGER;
  2.     L:INTEGER[N]; { ou N est un entier constant <= 36 }
  3. R:REAL;
  4. BEGIN
  5.  I:=L; { Erreur de syntaxe : La fonction TRUNC peut être utilisé pour convertir un LONG INTEGER en INTEGER }
  6.  L:=-L; { Correcte, si -L ne require pas plus de 36 chiffres; le signe moins ne compte pas comme chiffre. }
  7.  L:=I;  { Toujours correcte }
  8.  L:=R;  { Jamais accepté }
  9.  R:=L;  { Jamais accepté }
  10. END.

L'espace mémoire alloué pour un LONG INTEGER est toujours un nombre entier de mots. Plus précisément, une variable de type INTEGER[n] occupe le nombre de mots spécifié par la formule suivante :

(n + 3) DIV 4+1

Par conséquent, la limite réelle de la valeur d'un LONG INTEGER peut dépasser le nombre de chiffres décimaux spécifié dans sa déclaration. Par exemple, une longueur de 5 à 8 occupe trois mots et peut entreposer des valeurs jusqu'à et y compris 99999999; une longueur de 9 à 12 occupe quatre mots et peut entreposer des valeurs jusqu'à 999999999999; une longueur de 13 à 16 occupe cinq mots et peut entreposer des valeurs jusqu'à 9999999999999999.



Dernière mise à jour : Dimanche, le 28 mars 2021