Entrée et sortie
Toutes les routines d'entrée et de sortie de Highspeed Pascal sont décrites ici. Ils sont tous prédéclarés; certains d'entre eux sont «magiques» en ce sens qu'ils prennent un nombre variable de paramètres, ils ne peuvent donc pas être définis en utilisant la programmation Pascal normale. Il existe trois types de fichiers dans Highspeed Pascal : les fichiers texte, tapés et non typés. Ils sont déclarés comme :
Var
aTextFile:Text;
aTypedFile:File of SomeThing;
anUntypedFile:File;
Tous les fichiers utilisés doivent avoir un nom leur étant associé; la manière standard de le faire est via la procédure d'affectation. Ce nom est ce que le fichier est appelé sur le périphérique physique où il est entreposé (normalement un disque). Tous les fichiers doivent être ouverts avant utilisation (leur donner un nom en même temps si vous n'avez pas déjà utilisé la procédure d'affectation). Après utilisation, ils doivent être refermés. Ceci est particulièrement important avec les fichiers ouverts à l'écriture car si vous ne fermez pas un tel fichier, il ne peut pas être consulté ou supprimé tant que vous n'avez pas réinitialisé la machine ! Vous pouvez ouvrir un fichier texte existant pour l'entrée ou pour l'ajout de sortie, pour écrire généralement dans un fichier texte, vous devez le créer, en supprimant d'abord tout fichier existant. D'autres types de fichiers peuvent être ouverts pour l'entrée et la sortie. Les fichiers texte sont toujours accessibles de manière séquentielle, vous ne pouvez pas y chercher. En utilisant d'autres types de fichiers, vous pouvez définir la position de lecture / écriture actuelle en utilisant la procédure de recherche. En plus des fonctionnalités fournies par le système d'exploitation pour utiliser des éléments tels que l'écran et l'imprimante en tant que fichiers, le Highspeed Pascal vous permet également d'écrire vos propres pilotes de périphériques spécialisés. Après tous les appels au système d'entrée/sortie, une routine de vérification d'entrée/sortie est appelée pour voir si quelque chose s'est mal passé dans la dernière routine. Cette situation peut être désactivé à l'aide de la directive {$I-} ou en désactivant les vérifications d'entrée/sortie dans le demandeur des paramètres du compilateur.
Routines d'entrée et de sortie
Voici les routines pouvant être utilisées pour les entrées/sorties de fichiers : Assign, Reset, Rewrite, Append, Close, Seek, FilePos, FileSize, Eof, Eoln, SeekEof, SeekEoln, Read, Readln, Write, WriteLn, Page, BlockRead, BlockWrite, Rename, Erase, IOResult et SetTextBuf.
Routines de contrôle générales
Voici les routines utilisées pour créer, effacer, renommer et ouvrir des fichiers : Reset, Rewrite, Append, Close, Rename, Erase, IOResult.
| Assign(F,Title) |
Associe le nom Title au fichier F. Ce nom sera conservé jusqu'à ce qu'une autre affectation soit utilisée sur le fichier ou que la réinitialisation, la réécriture ou l'ajout soit appelée avec deux paramètres.
| Reset(F) |
Ouvrez un fichier en utilisant le nom précédemment utilisé pour l'attribution. Le fichier doit être en lecture uniquement s'il s'agit d'un fichier texte. Si le fichier est déjà ouvert, il est rembobiné au début du fichier.
| Reset(F,Title) |
Ouvrez le fichier nommé Title. Cela équivaut à :
Assign(F,Title); Reset(F);
| Rewrite(F) |
Crée et ouvre un fichier dont le nom est associé à un signe. Tout fichier précédent du même est supprimé. Le fichier est en écriture uniquement s'il s'agit d'un fichier texte.
| Rewrite(F, Title) |
Crée et ouvre le fichier nommé Title. Cela équivaut à :
Assign(F,Title); Rewrite(F);
| Append(F) |
Commencez à ajouter un fichier texte déjà ouvert. Append est comme Rewrite sauf que l'écriture commence à la fin de tout fichier existant.
| Append(F, Title) |
Commencez à ajouter un fichier texte appelé Titre. Cela équivaut à :
Assign(F,Title); Rewrite(F);
| Close(F) |
Videz les données non écrites de le périphérique et fermez le fichier. Assurez-vous de l'appeler pour chaque fichier.
| Rename(OldName, NewName) |
Renommez un fichier OldName en NewName. Les deux paramètres sont des types de chaîne de caractères.
| Erase(Title) |
Supprimez le fichier du disque.
| IOResult:Integer |
Renvoie le résultat de la dernière opération d'entrée ou de sortie. Zéro est renvoyé lorsqu'aucune erreur ne s'est produite. IOResult est effacé par cet appel, de sorte que les appels suivants renverront 0 jusqu'à ce qu'une autre erreur se produise.
Fichiers typés et non typés
Un fichier non typé est traité comme un fichier typé avec un type de : File Of ShortInt. Voici les routines à utiliser sur les fichiers tapés et non typés : Seek , FilePos, FileSize, Eof, Read, Write, BlockRead, BlockWrite.
| Seek(F,N:Longint) |
Positionnez la position actuelle de lecture et d'écriture. La première position est le numéro zéro.
| FilePos(F):Longint |
Renvoie la position actuelle du fichier. FilePos renvoie zéro après réinitialisation et réécriture.
| FileSize(F):Longint |
Renvoie le nombre d'éléments dans le fichier F.
| Eof(F):Boolean |
Renvoie FALSE s'il reste des données à lire après la position actuelle du fichier.
| Read(F, v { ,vn } ) |
Lisez un ou plusieurs composantes de fichier dans une ou plusieurs variables. La ou les variables v doivent être du même type que le type de composante de F. La position actuelle du fichier est avancée d'une position pour chaque variable.
| Write(F, v { ,vn } ) |
Écrit un ou plusieurs composantes de fichier à partir d'une ou de plusieurs variables. La ou les variables v doivent être du même type que le type de composante de F. La position actuelle du fichier est avancée d'une position pour chaque variable.
| BlockRead(F, Buffer, Count) |
Lit Count octets du fichier F dans le tampon. Une erreur IOError est renvoyée si Count octets n'a pas pu être lu.
| BlockRead(F, Buffer, Count, ActualCount) |
Lit Count octets du fichier F dans le tampon. Le nombre réel lu est renvoyé dans ActualCount. Aucune erreur n'est générée.
| BlockWrite(F, Buffer, Count) |
Ecrit Count octets dans le fichier F à partir du tampon. Une erreur IOError se produit si Count octets n'a pas pu être écrit.
| BlockWrite(F, Buffer, Count, ActualCount) |
Ecrit Count octets dans le fichier F à partir du tampon. Le nombre réel écrit est retourné dans ActualCount. Aucune erreur n'est générée. BlockRead et BlockWrite peuvent être utilisés à la fois sur des fichiers tapés et non typés. Un fichier non typé est traité comme un fichier typé avec un type de : File of ShortInt. La taille ShortInt indique à réinitialiser, réécrire et rechercher que la taille de l'élément est d'un octet. BlockRead et BlockWrite prennent leurs tailles en nombre d'octets. Pour lire un LongInt à partir d'un fichier de LongInt, vous devrez utiliser :
BlockRead(F,B, 1*SizeOf(LongInt))
Fichiers texte
Voici les routines pour les entrées/sorties de fichiers texte : Read, Readln, Write, WriteLn, Page, Eof, Eoln, SeekEof, SeekEoln , SetTextBuf. Pour les routines de fichier texte, vous n'avez pas à spécifier de variable de fichier; si vous ne le faites pas, le fichier est alors supposé être le fichier standard Input ou Output. Write et WriteLn prennent Output comme fichier par défaut, tandis que toutes les autres procédures mentionnées ci-dessus prennent Input comme fichier par défaut.
| Read(F,v { ,Vn } ) |
La variable V peut être l'un de ces types : Integer, Real, Char, String. Lors de la lecture de nombres entiers ou réels, Highspeed Pascal s'attend à lire une séquence de chiffres et de symboles spéciaux comme e ou E. Tous les espaces blancs (tabulation, espace et fin de ligne) sont ignorés en premier. Lors de la lecture d'une variable Char, un octet est lu dans le fichier. En Pascal standard, le symbole de fin de ligne est lu comme un espace, Chr(32), mais dans Highspeed Pascal, vous le lirez comme une nouvelle ligne, Chr(10). La lecture d'une chaîne de caractères sera lue jusqu'à ce que la fin de la ligne soit atteinte. Autant de caractères que la longueur de la chaîne de caractères le permet seront alors mis dans la chaîne de caractères. La lecture d'une chaîne de caractères ne lira jamais au-delà d'une nouvelle ligne. Si cela est nécessaire, utilisez ReadLn.
| ReadLn(F, v {, Vn } ) |
ReadLn fait exactement la même chose que Read, juste suivi d'un ReadLn(F).
ReadLn(F, v1, v2, v3);
est le même chose que :
Read(F, v1);
Read(F, v2);
Read(F, v3);
ReadLn(F);
| Write(F, p { , Pn } ) |
| WriteLn(F, p { , Pn } ) |
La variable P peut être de l'un de ces types : Integer, Real, Char, String, PackedString, Boolean.
WriteLn(F, p1 , p2 , p3);
est le même chose que :
Write(F, p1, p2, p3);
WriteLn(F);
qui est le même chose que :
Write(F, p1);
Write(F, p2);
Write(F, p3);
WriteLn(F);
Les paramètres d'écriture p, P1, P2 .. Pn ont la format :
| Expression [ [ : MinWidth] : DecPlaces] . |
où Expression est la sortie requise et MinWidth et DecPlaces sont des expressions entières. Au moins les positions MinWidth sont utilisées lors de l'écriture de l'expression. Si l'expression a besoin de plus d'espace, plus d'espace est utilisé. La valeur par défaut pour MinWidth est 0. DecPlaces spécifie le nombre de chiffres décimaux qu'un nombre réel doit avoir lorsqu'il est converti en texte; il ne peut être spécifié que si MinWidth est également présent. Les variables de type Integer, Char, String et PackedString sont écrites justifiées à gauche dans un champ de largeur MinWidth. Si MinWidth est trop petit, aucun espace n'est placé devant. Les variables de type booléen sont écrites en écrivant la chaîne de caractères FALSE ou TRUE. Les variables de type réel sont plus compliquées. Ils sont d'abord convertis au format texte à l'aide de la valeur MinWidth et DecPlaces. Si MinWidth est omis, il est supposé être 10. Si DecPlaces est omis, le nombre est converti en une chaîne de caractères décimale à virgule flottante, sinon il est converti en une chaîne de caractères décimale à virgule fixe. Chaîne de caractères décimale à virgule flottante :
| ( | - ) chiffre . décimales e (+ | -) exposant. |
Chaîne de caractères décimale à virgule fixe :
| [ blancs ] - chiffres . décimales . |
| Eof(F):Boolean |
Renvoie FALSE s'il reste des données à lire après la position actuelle du fichier.
| Eoln(F):Boolean |
Renvoie FALSE s'il reste des données à lire après la position actuelle du fichier, mais avant la prochaine nouvelle ligne.
| SeekEof(F): Boolean |
Comme Eof, mais d'abord il saute tous les espaces blancs.
| SeekEoln(F): Boolean |
Comme Eoln, mais d'abord, il saute tous les espaces blancs sauf la nouvelle ligne.
| Page(F) |
Écrit un saut de pager dans le fichier. Identique à Write(Chr(12)).
| SetTextBuf(F,Buffer) |
Cela associe un tampon d'entrée/sortie de la variable Buffer à utiliser avec le fichier texte F. La taille de tampon par défaut est de 128 octets mais cet appel utilisera un tampon de SizeOf(Buffer). Le SetTextBuf est normalement appelé juste après assign, mais vous pouvez également l'utiliser après une réinitialisation ou une réécriture mais avant toute opération d'entrée/sortie.
| SetTextBuf(F,Buffer,Size) |
Ceci associe un tampon d'entrée/sortie à utiliser avec le fichier texte F de la même manière que la version à deux paramètres mais avec une taille de tampon de Size octets.
La gestion des erreurs
Après tous les appels au système d'entrée/sortie, une routine de vérification d'entrée/sortie est appelée pour voir si quelque chose s'est mal passé dans la dernière routine. Cela peut être désactivé à l'aide de la directive {$I-} ou en désactivant l'élément I / O Checks dans la zone Compiler Settings des paramètres du compilateur. Si la vérification d'entrée/sortie est désactivée, le résultat de chaque opération peut être vérifié à l'aide de la fonction IOResult. S'il renvoie zéro, aucune erreur ne s'est produite. Notez que IOResult est une fonction ne renvoyant sa valeur qu'une seule fois, la prochaine fois qu'elle renvoie zéro. Vous devez donc normalement appeler IOResult immédiatement après chaque opération d'entrée/sortie.
Périphériques de fichiers texte
Chaque fois qu'un fichier texte est sur le point d'être ouvert, une chaîne de caractères de «fichiers» connus est recherchée. Si vous essayez d'ouvrir l'un de ces fichiers, vous aurez accès à un gestionnaire interne décidant quoi faire pour tous vos appels d'entrée et de sortie. Les fichiers d'entrée et de sortie l'utilisent par défaut. Vous pouvez, bien sûr, écraser cela simplement en effectuant une nouvelle réinitialisation et en les réécrivant.