4/4.4 Identificateurs standard[INCOMPLET] Utilisation | Par exemple, une des nombreuses fonctions d'un logiciel de traitement de texte. |
| ClrScr | | Type | Procédure | | Format | ClrScr; | | Fonction | Efface l'écran et place le curseur en haut et à gauche de l'écran. | | Utilisation | Par exemple, avant tout programme, pour commencer « proprement » sur l'écran. |
| Clrlnit | | Type | Procédure | | Format | Clrlnit; | | Fonction | Envoie à l'écran la chaîne d'initialisation définie lors de son installation. | | Utilisation | Initialisation de l'écran. |
| CrtExit | | Type | Procédure | | Format | CrtExit; | | Fonction | Envoie à l'écran la chaîne de réinitialisation définie lors de son installation. | | Utilisation | Réinitialisation de l'écran. |
| Con | | Type | Organe d'entrée/sortie | | Format | Con | | Fonction | Organe logique d'entrée/sortie. Comparable à l'organe TRM, à ceci près qu'une opération de lecture à travers l'organe Con mémorise la totalité de la ligne lue dans un buffer. Cette façon de lire offre évidemment des facilités d'édition non négligeables. | | Utilisation | Read(Con,< variable> ); ou Readln(Con,< variable >); |
| ConlnPtr et Conln | | Type | ConlnPtr est un pointeur, Conln la fonction associée. | | Format | < Variable 1 >: = Conln où < variable 1 > est de type Char. | | Fonction | ConlnPtr contient l'adresse de la fonction Conln. | | Utilisation | La fonction Conln fait partie de l'environnement standard du Turbo-Pascal. Conln est utilisée par les routines d'entrée/sortie classiques, mais n'est pas disponible en tant que telle pour le programmeur. Cette procédure permet de lire un caractère sur l'unité logique Con. |
| ConOutPtr et ConOut | | Type | ConOutPtr est un pointeur et ConOut la procédure associée. | | Format | ConOut( < Variable 1>) oú variable 1 est de type Char. | | Fonction | ConOutPtr contient l'adresse de la fonction ConOut. | | Utilisation | La fonction ConOut fait partie de l'environnement standard du Turbo-Pascal. ConOut est utilisée par les routines d'entrée/sortie classiques, mais n'est pas disponible en tant que telle pour le programmeur. Cette procédure permet d'envoyer un caractère sur l'unité logique Con. |
| Concat | | Type | Fonction. | | Format | < ChR >: = Concat (< Ch 1 >, < Ch2 >, ..., < ChN >) ;. | | Fonction | Cette fonction retourne la concaténation (c'est-à-dire la chaîne résultant de l'assemblage) des chaînes qui lui sont passées. La longueur de la chaîne résultante doit être inférieure ou égale à 255. | | Utilisation | Cette fonction est équivalente à l'opérateur + . Elle a été implémentée dans le Turbo-Pascal pour assurer la compatibilité avec les autres Pascal. |
| ConStPtr | | Type | Pointeur. | | Format | ConStPtr | | Fonction | ConStPtr contient l'adresse de ConSt. | | Utilisation | La fonction ConSt est appelée par la fonction KeyPressed. Elle fait partie de l'environnement standard du Turbo-Pascal. Elle renvoie True lorsqu'une touche a été pressée sur le clavier et False dans le cas contraire. |
| Copy | | Type | Fonction. | | Format | < Ch1 >: = Copy(< Ch2 >,< Départ >,< Longueur>) ; où < Ch2 > est la chaîne source, < Départ > la position de départ dans la chaîne source, < Longueur> le nombre de caractères extraits et < Ch 1 > la chaîne résultante. oú est la chaîne source, < Départ > la position de départ dans la chaîne source, le nombre de caractères extraits et la chaîne résultante. | | Fonction | Cette fonction extrait un ou plusieurs caractères de la chaîne qui lui est passée en argument, à partir d'une position donnée et sur une longueur donnée. Dans le cas oú dépasse la longueur de , une chaîne vide est retournée. | | Utilisation | Cette fonction est souvent utilisée pour extraire la partie significative d'une chaîne, lorsque sa position est connue. |
| Cos | | Type | Fonction mathématique. | | Format | < Arc > : = Cos(< Angle > ); où < Arc > est une variable de type réel qui représente le cosinus de l'angle passé. | | Fonction | Retourne le cosinus de l'angle passé qui doit être exprimé en radians. | | Utilisation | Cette fonction est surtout utilisée par les étudiants ou les programmeurs qui développent des applications graphiques. |
| Delay | | Type | Procédure. | | Format | Delay (< Durée >); où < Durée > est le nombre de millisecondes d'attente. | | Fonction | Cette procédure rend le contrôle à l'appelant lorsque le nombre de millisecondes spécifié s'est écoulé. | | Utilisation | Cette procédure peut par exemple être utilisée pour émettre des fréquences pendant une durée déterminée avec la procédure Sound ou pour afficher un message pendant une durée déterminée sur l'écran. |
| Delete | | Type | Procédure. | | Format | Delete (< Chaîne >,< Départ >,; oú < Taille > est le nombre de caractères à supprimer dans < Chaîne >, et est la position du premier caractère à supprimer dans < Chaîne >. | | Fonction | Cette procédure supprime caractères dans < Chaîne > à partir de la position < Départ >. | | Utilisation | La procédure Delete est souvent utilisée par des programmes qui manipulent des chaînes, par exemple pour effacer la partie non significative de la réponse entrée par l'utilisateur. |
| DelLine | | Type | Procédure. | | Format | DelLine; | | Fonction | Cette procédure efface la ligne courante, effectue un scrolling vers le haut d'une position des lignes qui suivent la ligne courante, et rajoute une ligne vierge en bas de l'écran. | | Utilisation | Cette procédure est typiquement utilisée dans les programmes de traitement de texte plein écran. |
| Eof | | Type | Fonction. | | Format | < Var > : = Eof ( < NL > ); où < NL > est un nom logique de fichier, et < Var > une variable de type booléen. | | Fonction | Cette fonction renvoie une valeur logique True si la fin du fichier spécifié est atteinte, et une valeur logique False dans le cas contraire. | | Utilisation | Elle est souvent utilisée dans des boucles de lecture de fichiers pour éviter la classique erreur qui se produit si on essaie d'accéder à un enregistrement situé après le dernier enregistrement du fichier. |
| EoLn | | Type | Fonction. | | Format | < Var >: = EoLn(< NL >); ' ' où < NL > est un nom logique de fichier texte, et < Var > une variable de type booléen. | | Fonction | Cette fonction renvoie la valeur logique True si le pointeur de fichier se trouve après la marque de fin de ligne ou si la fin du fichier est atteinte. Elle renvoie la valeur logique False dans le cas contraire. |
| Erase | | Type | Procédure. | | Format | Erase (< NL >); où < NL > est le nom logique d'un fichier. | | Fonction | Cette procédure efface le fichier associé (par Assign) au nom logique spécifié. | | Utilisation | La procédure Erase peut être utilisée pour effacer un fichier temporaire créé par le programme ou un autre fichier de type quelconque. |
| Execute | | Type | Procédure. | | Format | Execute(< NL >); où < NL > est le nom logique du fichier à exécuter. | | Fonction | Charge en mémoire et exécute le fichier d'extension .COM spécifié. Ce fichier est (par exemple) un programme Turbo-Pascal issu d'une compilation de type COM. | | Utilisation | Cette procédure est souvent utilisée pour activer le programme correspondant au choix de l'utilisateur dans un menu. Elle est parfois utilisée pour exécuter une partie d'un gros programme qui ne tient pas totalement en mémoire. Le programme père peut passer des valeurs au programme fils. Pour cela, la taille des segments de code et de données des deux programmes doit être identique ainsi que la disposition des variables à communiquer. |
| Exit | | Type | Procédure. | | Format | Exit; | | Fonction | Cette procédure provoque la sortie immédiate du module courant: fin de la procédure ou fonction et retour au niveau supérieur, ou fin du programme principal. | | Utilisation | Cette procédure doit être évitée autant que possible, car elle n'est pas compatible avec le concept de programmation structurée inhérent au langage Turbo-Pascal. |
| Exp | | Type | Fonction. | | Format | < Var1 >: = Exp (< Var2 >); où < Var2 > est un nombre ou une variable de type entier ou réel, et < Var1 > est une variable de type réel qui contient l'exponentielle de < Var2 >. | | Fonction | Cette fonction renvoie l'exponentielle de la valeur qui lui est passée. | | Utilisation | Exp est utilisée dans toutes sortes de calculs, comme par exemple la mise à la puissance, en effet, a'b = Exp(b*Ln(a)). |
| False | | Type | Valeur logique. | | Format | < VB > : = True; où < VB > est une variable booléenne. | | Fonction | Les variables booléennes (type Boolean) peuvent avoir deux valeurs : True et False. La valeur logique Vrai peut être affectée à une variable en utilisant le mot-clé True. |
| FilePos | | Type | Fonction. | | Format | < P >: = FilePos (< NL >); où < N L> est le nom d'un fichier logique et < P> est une variable de type entier dans laquelle sera stockée la position du pointeur de fichier. | | Fonction | Cette fonction renvoie la position du pointeur de fichier dans le fichier (ouvert) spécifié. La première position dans le fichier est 0. La dernière position dans le fichier a la même valeur que FileSize (). | | Utilisation | Cette fonction permet, par exemple, de déterminer par soustraction le nombre d'enregistrements qui se trouvent après l'enregistrement courant. |
| FileSize | | Type | Fonction. | | Format | < P > : = FileSize (< NL >); où < NL > est le nom d'un fichier logique, et < P> est une variable de type entier dans laquelle sera stockée la position du dernier enregistrement dans le fichier. | | Fonction | Cette fonction renvoie la position du dernier enregistrement dans le fichier (ouvert) passé en argument. |
| FillChar | | Type | Procédure. | | Format | FilIChar (< Variable >,< Nombre >,< Modèle >); où < Modèle > est une variable de type Byte ou Char, < Variable > est une variable de type quelconque, et < Nombre > est une expression entière qui contient le nombre de répétitions de < Modèle > dans < Variable >. | | Fonction | Cette procédure permet de copier répétitivement un modèle dans une variable. | | Utilisation | FillChar peut être utilisé, par exemple, pour initialiser une portion de la mémoire vive ou pour souligner un mot ou un titre sur l'écran avec un caractère donné. |
| Flush | | Type | Procédure. | | Format | Flush ( < NL > ); où < NL > est un nom de fichier logique. | | Fonction | Cette procédure vide la mémoire tampon du fichier texte de nom logique ouvert en écriture par Rewrite ou Append. | | Utilisation | On utilisera la procédure Flush pour s'assurer que toutes les données envoyées à un fichier disque ont bien été écrites. La fonction ioResult peut être utilisée pour connaître l'issue de l'opération. |
| Frac | | Type | Fonction. | | Format | < Var1 >: = Frac (< Var2 >); où < Var2 > est une variable de type réel, et < Var1 > est une variable de type réel qui contient la partie fractionnaire de Var2. | | Fonction | Cette fonction renvoie la partie fractionnaire (c'est-à-dire les chiffres après la virgule) de la variable réelle passée. Le résultat est de type réel. La valeur renvoyée peut également être calculée par la formule suivante : Frac(x) = x - lnt(x). |
| FreeMem | | Type | Procédure. | | Format | FreeMem (< P >,< Oct >); où < P > est une variable de type pointeur, et < Oct > est une variable entière qui indique le nombre d'octets à récupérer. | | Fonction | Cette procédure libère le tas du nombre d'octets spécifié en annulant l'accès à une variable déclarée par GetMem. | | Utilisation | Cette procédure doit être utilisée lorsque le tas est à la limite de la saturation ou lorsqu'une variable accédée par un pointeur ne sera plus référencée jusqu'à la fin du programme. |
| GetMem | | Type | Procédure. | | Format | GetMem (< P >,< Taille >); où < P > est une variable de type pointeur, et < Taille > est une variable entière qui indique le nombre d'octets à réserver. | | Fonction | Cette procédure réserve dans le tas le nombre d'octets spécifiés dans à une variable dynamique. | | Utilisation | Contrairement à la procédure New qui réserve automatiquement l'espace nécessaire dans le tas, GetMem réserve le nombre d'octets spécifiés par l'utilisateur. GetMem ou New seront utilisées selon les préférences de chacun. |
| GotoXY | | Type | Procédure. | | Format | GotoXY (< X >, < Y >); où < X >, < Y > représentent des coordonnées d'écran. | | Fonction | Cette procédure positionne le curseur sur l'écran en mode texte. Le coin supérieur gauche de la fenêtre active a pour coordonnées 1,1. | | Utilisation | GotoXY représente une alternative intéressante à l'utilisation répétée d'instructions Writeln pour afficher un texte à la position désirée sur l'écran. |
| Halt | | Type | Procédure. | | Format | Halt [( < Code> )]; où < Code > est une valeur entière renvoyée au CP/M. | | Fonction | Cette procédure avorte le programme et redonne le contrôle au CP/M. Lorsqu'un code de retour est précisé, il est renvoyé au CP/M qui peut le récupérer en utilisant la fonction 4DH de l'interruption 21 H. Reportez-vous également à la procédure Exit qui a une fonction comparable lorsqu'elle est placée dans le programme principal. | | Utilisation | Cette procédure est surtout utilisée lorsqu'une erreur grave s'est produite dans le programme. Le code renvoyé au CP/M permet au processus père de connaître la cause de l'erreur. |
| HeapPtr | | Type | Pointeur. | | Fonction | Ce pointeur donne la première position du tas en mémoire. Il est généralement égal à la fin du code objet après la compilation. |
| Hi | | Type | Fonction. | | Format | < Oct > : = Hi (< Var > ); où < Var > est une variable entière, et < Oct > est le poids fort de < Var >. | | Fonction | Cette fonction renvoie le poids fort de la variable entière qui lui est passée. Reportez-vous également à la fonction Lo qui renvoie le poids faible de la variable entière qui lui est passée. | | Utilisation | Cette fonction est particulièrement intéressante pour faire des conversions décimal -> héxadécimal de mots. |
| ioResult | | Type | Fonction. | | Format | < Test > : = IoResult; oú est une variable numérique qui contiendra le résultat de l'entrée/sortie. | | Fonction | Cette fonction est utilisée pour connaître le résultat d'une opération d'entrée/sortie lorsque la vérification des entrées/sorties est désactivée par ($l-j. La valeur renvoyée est nulle si aucune erreur ne s'est produite. Elle contient le numéro de l'erreur dans le cas contraire. | | Utilisation | Cette fonction est souvent utilisée pour activer une procédure d'erreur dans le cas oú la vérification des entrées/sorties est désactivée. Exemple :
Repeat
Write ('Nom du fichier : ');
Readln (NF);
Assign (F,NF);
{$i-}
Reset(F);
{$i+}
Test: = ioResult;
If Test <>0 then Erreur; (Activation procédure d'erreur] until Test = 0; |
| Input | | Type | Fichier d'entrée principal. | | Fonction | Ce fichier est affecté à l'organe Con: (console) ou à l'organe TRM: (terminal). | | Utilisation | Les instructions suivantes sont équivalentes : Readln(lnput,Donnee);
Readln(Donnee);
Read(lnput,Donnee);
Read(Donnee);
Eof(lnput);
Eof;
EoLn(lnput);
EoLn; |
| Insert | | Type | Procédure. | | Format | Insert (< Ch 1 >,< Ch2 >,< Position >);
où < Ch1 > est la chaîne à insérer,
< Ch2 > la chaîne réceptrice,
et < Position > la position de l'insertion. | | Fonction | Cette procédure permet d'insérer une chaîne dans une autre chaîne, à partir d'une position donnée. La longueur du résultat doit être inférieure ou égale à la longueur de , sans quoi, les derniers caractères de Ch2 sont perdus. Le paramètre < Position > doit se trouver dans l'intervalle 1 ..255. | | Utilisation | Le procédure Insert, combinée à la procédure Delete, peut être utilisée pour remplacer une chaîne par une autre chaîne, par exemple dans un programme driver d'imprimante, pour redéfinir les caractères qui ne font pas partie du jeu standard de l'imprimante. |
| InsLine | | Type | Procédure. | | Format | InsLine; | | Fonction | Cette procédure insère une ligne vierge à la position courante du curseur et effectue un scrolling vers le bas d'une position des lignes qui suivent la ligne courante. La dernière ligne de l'écran est perdue. | | Utilisation | Cette procédure est typiquement utilisée dans les programmes de traitement de texte plein écran. |
| Int | | Type | Fonction. | | Format | < Var1 > : = lnt( < Var2> );
où < Var2 > est une variable entière ou réelle,
et < Var1 > est une variable réelle qui contient la partie entière de < Var1 >. | | Fonction | Cette fonction retourne sous forme réelle la partie entière de l'argument qui lui est passé. Si l'argument passé est positif, Int renvoie le plus petit nombre entier qui lui est inférieur ou égal. Si l'argument passé est négatif, Int renvoie le plus petit nombre entier qui lui est supérieur ou égal. |
| InLine | | Type | Procédure. | | Format | InLine ( / < C2 >/.../< CN >); où les < Ci > sont des codes hexadécimaux précédés du signe $ ou des variables Turbo-Pascal exprimés en clair. | | Fonction | Cette fonction permet d'incorporer des codes opératoires de programmes Assembleur dans les programmes écrits en Turbo-Pascal. | | Utilisation | InLine sera utilisée pour accéder à des ressources inaccessibles en Turbo-Pascal, ou lorsque les temps d'exécution du Turbo-Pascal sont prohibitifs (par exemple pour créer des routines de tri complexes). |
| Integer | | Type | Type. | | Format | Var < Variable 1 >: Integer;
où < Variable > est le nom d'une variable entière. | | Fonction | Le mot-clé Integer est utilisé dans le bloc de déclaration des variables, en tête du programme. Une variable entière pourra prendre des valeurs comprises entre 0 et 2*16-1. | | Utilisation | Les variables entières sont codées sur deux octets. Si leur valeur n'excède jamais 255, on leur préférera des variables octet (Byte) qui n'occupent qu'un octet en mémoire. |
| Kbd | | Type | Organe clavier. | | Format | Kbd. | | Fonction | Les instructions Read ou Readln acquièrent des caractères par défaut sur le clavier. Lorque Kbd est précisé dans une instruction Read ou Readln, il n'y a pas d'écho sur l'écran. | | Utilisation | Cet organe doit être précisé pour lire les caractères qui se trouvent dans le buffer clavier lorsque la fonction KeyPressed a été utilisée. Reportez-vous à KeyPressed pour avoir une exemple d'utilisation. |
| KeyPressed | | Type | Fonction. | | Format | < Test > : = KeyPressed ; où < Test > est une variable booléenne. | | Fonction | Cette fonction permet de connaître l'état du buffer clavier. Elle renvoie la valeur True si une ou plusieurs touches ont été tapées et False dans * le cas contraire. La ou les touche(s) tapées sont lisibles à l'aide de la procédure Read. | | Utilisation | Cette fonction est souvent utilisée pour marquer une pause entre deux actions et attendre l'autorisation de poursuivre de l'utilisateur. Exemple : Writeln ('Appuyez sur une touche pour continuer..');
Touche_Fonction: = False;
While not KeyPressed do; [Attente de la frappe d'1 touche]
Read (Kbd,Ch1); {Lecture de la touche frappée }If (Ch1 = #27) and KeyPressed then begin
Read(Kbd,Ch2); {Lecture du scan code }
Touche_Fonction: = True;
end; |
| Length | | Type | Fonction. | | Format | < Longueur > : = Length( < Chaîne> ); où < Chaîne > est une variable String, et < Longueur > est une variable entière qui contient la longueur de < Chaîne >. | | Fonction | Cette fonction renvoie la longueur de la chaîne passée en argument. | | Utilisation | Cette fonction est fréquemment utilisée dans les programmes qui manipulent des chaînes de caractères, en particulier pour éviter des erreurs lors de l'utilisation de la fonction Copy. |
| Ln | | Type | Fonction mathématique. | | Format | < Res > : = Ln ( < EN > ); où < EN> est une expression numérique entière ou réelle, et < Res > est le logarithme népérien de < EN >. | | Fonction | Cette fonction renvoie le logarithme népérien de l'argument numérique qui lui est passé. | | Utilisation | L'opérateur puissance n'étant pas disponible, cette fonction peut être utilisée pour mettre à la puissance. En effet, a"b = exp(b*Ln(a)). |
| Lo | | Type | Fonction. | | Format | < LSB > : = Lo( < Mot > ); oú < Mot > est une variable entière, et < LSB > une variable octet qui contient le poids faible de < Mot > . | | Fonction | Cette fonction renvoie le poids faible de l'argument entier qui lui est passé. | | Utilisation | Elle est particulièrement utile pour effectuer des conversions de base 10 vers (par exemple) 16 ou 8. |
| LowVideo | | Type | Procédure. | | Format | LowVideo; | | Fonction | Cette procédure envoie au terminal les caractères définis lors de l'installation pour passer en mode caractère basse intensité. |
| Lst | | Type | Organe d'impression. | | Format | Lst | | Fonction | Cet organe correspond à l'imprimante. Il doit être précisé dans toute opération d'écriture (par Write ou WriteLn) pour accéder à l'imprimante. | | Utilisation | Writeln('coucou'); {Affiche coucou sur l'écran }
Writeln(Lst, 'coucou'); {Envoie coucou à l'imprimante } |
| LstOutPtr | | Type | Pointeur. | | Format | LstOutPtr | | Fonction | LstOutPtr contient l'adresse de la procédure LstOut. | | Utilisation | La procédure LstOut est utilisée par l'organe de sortie LST:. Elle fait partie de l'environnement standard du Turbo-Pascal, mais n'est pas disponible pour le programmeur. |
| Mark | | Type | Procédure. | | Format | Mark( < Variable > ); oú Cvariable 1 > est une variable pointeur. | | Fonction | Cette procédure affecte la valeur du pointeur de tas à la variable qui lui est passée. |
| MaxAvail | | Type | Fonction. | | Format | < Taille > : = MaxAvail; oú < Taille > est une variable entière. | | Fonction | Cette fonction retourne la taille du plus grand bloc disponible dans le tas en octets. Le nombre retourné est négatif s'il dépasse 32767. Il convient alors d'ajouter 65536 au nombre retourné pour avoir la taille réelle. | | Utilisation | Cette fonction permet de s'assurer que le tas permet l'allocation d'une nouvelle variable dynamique. |
| Mem | | Type | Tableau Pré-défini. | | Format | < Oct > := Mem[ < Déplact > ];
ou Mem[ < Déplact > ]: = < Oct > ;oú < Déplact > est l'adresse de l'octet à accéder en lecture ou en écriture, et < Oct > est la valeur de l'octet lu ou à écrire. | | Fonction | Le tableau Mem permet d'accéder à la mémpire, en entrée, ou en sortie, comme s'il s'agissait d'un tableau Turbo-Pascal. | | Utilisation | Ce tableau permet par exemple d'accéder directement à la mémoire d'écran, de lire ou de modifier des variables système ou des variables modifiées par des programmes assembleur. |
| MemW | | Type | Tableau Pré-défini. | | Format | < Mot > : = MemW[ < Déplact > ]; ou MemW[ < Déplact > ]: = < Mot > ; oú < Déplact > est l'adresse du mot à accéder en lecture ou en écriture, et < Mot > est la valeur du mot lu ou à écrire. | | Fonction | Le tableau MemW permet d'accéder à deux octets consécutifs de la mémoire, en entrée, ou en sortie, comme s'il s'agissait d'un tableau Turbo-Pascal. | | Utilisation | Ce tableau permet par exemple d'accéder directement à la mémoire d'écran, de lire ou de modifier des variables système ou des variables modifiées par des programmes assembleur. |
| MemAvail | | Type | Fonction. | | Format | < Taille > : = MemAvail; oú < Taille > est une variable entière. | | Fonction | Cette fonction permet de déteminer la place disponible dans le tas en octets. Le nombre retourné est négatif s'il dépasse 32767. Il convient alors d'ajouter 65536 au nombre retourné pour avoir la taille réelle. |
| Move | | Type | Procédure. | | Format | Move( < Début1 > , < Début2 > , < Longueur > );
oú < Début1 > est l'adresse du premier octet à recopier,
< Début > est l'adresse du premier octet oú s'effectue la copie, et < Longueur > le nombre d'octets recopiés. | | Fonction | Cette procédure recopie un ou plusieurs octets consécutifs à l'emplacement mémoire spécifié. Le bloc destination peut (éventuellement) recouvrir partiellement le bloc source. Dans ce cas, une partie du bloc source est écrasée. | | Utilisation | Cette procédure peut être utilisée pour initialiser rapidement une zone de travail ou pour écrire dans la mémoire d'écran. |
| New | | Type | Procédure. | | Format | New( < VD > );
oú < VD > est une variable dynamique. | | Fonction | Cette procédure permet de créer des variables de type pointeur. Elle doit obligatoirement être appelée avant d'utiliser le pointeur concerné. |
| NormVideo | | Type | Procédure. | | Format | NormVideo; | | Fonction | Cette procédure envoie au terminal les caractères définis lors de l'installation pour passer en mode caractère vidéo normal. |
| Odd | | Type | Fonction. | | Format | < VB > : = Odd(( < VE > ) ;
oú < VE > est une variable entière,
et < VB > est une variable booléenne. | | Fonction | Cette fonction renvoie la valeur True si < VE > est impair et la valeur False dans le cas contraire. |
| Ord | | Type | Fonction. | Format | < Résultat > : = Ord( < Variable > );
oú < variable > est une variable de type quelconque sauf réel,
et < Résultat > est la valeur ordinale de < Variable > . | | Fonction | Cette fonction retourne la valeur ordinale de l'argument qui lui est passé. | | Utilisation | Cette fonction permet par exemple de connaître le code ASCII d'un caractère. |
| Output
| | Type | Fichier de sortie principal. | | Fonction | Ce fichier est affecté à l'organe Con: (console) ou à l'organe TRM: (terminal). | Utilisation | Les instructions suivantes sont équivalentes :
Writeln(Output,Donnee);
Writeln(Donnee);
Write(Output,Donnee);
Write) Donnee); |
CPCrulez[Content Management System] v8.7-desktop/c
Page créée en 517 millisecondes et consultée 1040 foisL'Amstrad CPC est une machine 8 bits à base d'un Z80 à 4MHz. Le premier de la gamme fut le CPC 464 en 1984, équipé d'un lecteur de cassettes intégré il se plaçait en concurrent du Commodore C64 beaucoup plus compliqué à utiliser et plus cher. Ce fut un réel succès et sorti cette même années le CPC 664 équipé d'un lecteur de disquettes trois pouces intégré. Sa vie fut de courte durée puisqu'en 1985 il fut remplacé par le CPC 6128 qui était plus compact, plus soigné et surtout qui avait 128Ko de RAM au lieu de 64Ko. |
|
