Langage de programmation - MPW Pascal - Fichiers et entrée/sortie

Fichiers et entrée/sortie

Cette page décrit l'utilisation des fichiers Pascal, y compris la déclaration des fichiers dans un programme. Il comprend également des informations détaillées sur chacune des procédures et fonctions prédéfinies pour effectuer des entrées et des sorties, ou E/S.

Routines d'entrée/sortie

Le MPW Pascal vous propose trois manières distinctes d'effectuer des entrées et des sorties dans votre programme :

En appelant les routines d'entrée/sortie dans la ROM du Macintosh.
En utilisant les procédures et fonctions d'entrée/sortie intégrées au compilateur Pascal et à la bibliothèque PasLib.o.
En utilisant les procédures d'entrée/sortie de la bibliothèque d'Environnement Intégré.

En général, les routines ROM du Macintosh constituent le moyen le plus direct d'accéder à l'écran, au clavier et à la souris du Macintosh. Les routines intégrées de Pascal constituent le moyen le plus simple d'accéder au contenu des fichiers et d'effectuer des opérations d'entrée/sortie avec des périphériques externes. Les routines d'environnement intégré sont utilisées uniquement par les programmes allant s'exécuter sous MPW Shell et utiliser ses fonctionnalités d'entrée/sortie.

La plupart de ce que vous devez savoir sur l'accès au système d'exploitation Macintosh et aux routines Toolbox est contenu dans Inside Macintosh. Consultez les parties suivantes pour plus d'informations :

La page File Manager (Gestionnaire de fichiers) vous explique comment gérer les fichiers disque avec les routines ROM.
La page Event Manager (Gestionnaire d'événements) vous donne des informations sur la manière dont les événements sont gérés et sur la manière d'utiliser les routines du Gestionnaire d'événements pour obtenir des informations à partir de périphériques de caractères tels que le clavier.
La page QuickDraw contient des détails sur la façon de fournir une sortie de texte à l'écran.
La page Printing Manager (Gestionnaire d'impression) traite des routines d'impression.

Le reste de cette page traite des routines d'entrée/sortie fournies avec MPW Pascal. Certains d'entre eux sont intégrés au compilateur lui-même; d'autres sont inclus dans PasLib. Les procédures et fonctions PasLib ont des noms commençant par PL. Chaque fois que vous utilisez l'un d'entre eux, vous devez inclure l'instruction USES PasLibIntf dans votre programme ou unité. Vous devez également lier votre programme ou unité au fichier bibliothèque PasLib.o.

Cette page utilise une notation BNF modifiée au lieu de diagrammes de syntaxe pour afficher la syntaxe des listes de paramètres actuelles pour les procédures et fonctions standard.

Fichiers Pascal

Une variable de fichier Pascal est une variable structurée. Une variable de fichier ressemble à un tableau, dans le sens où elle consiste en une séquence de composants variables distincts, tous du même type. Cependant, le nombre de composantes est indéterminé et on n'y accède pas par indexation mais en utilisant les procédures et fonctions d'entrée/sortie prédéfinies.

Fichiers externes

Les variables de fichier sont utilisées pour entreposer des données en dehors de la mémoire, dans un fichier externe. Un fichier externe est soit un périphérique, soit un fichier de disque nommé. Pour qu'un programme puisse lire ou écrire des informations à l'aide d'un fichier externe, une variable de fichier doit être déclarée puis associée au fichier externe.

Variables de fichier

La caractéristique la plus importante d'une variable de fichier est que ses composantes ne sont généralement pas en mémoire, mais vous pouvez y accéder comme s'ils l'étaient. Les composantes existent en dehors du programme en tant que contenu d'un fichier externe.

Une variable de fichier est déclarée avec d'autres variables, en utilisant un type de fichier. Il existe trois types de fichiers Pascal de base :

fichiers structurés
fichiers texte
fichiers non typés

Fichiers structurés

Un fichier structuré est constitué de composantes appelés enregistrements logiques. Ces composantes peuvent être de n'importe quel type n'étant pas un type de fichier (ou un type structuré contenant une composante de type de fichier à n'importe quel niveau de structuration). Il n'est pas nécessaire qu'ils soient de type RECORD.

Par exemple, les déclarations :



Var

 IntVals:File of Integer;

 RealVals:File of Real;

 CompVals:File of Record

  I:Integer;

  R:Real;

 End;

créez trois variables de fichier :

IntVals est une variable de fichier dont les enregistrements logiques sont des valeurs entières.
RealVals est une variable fichier dont les enregistrements logiques sont des valeurs réelles.
CompVals est une variable fichier dont les enregistrements logiques sont de type RECORD, avec une valeur entière et une valeur réelle dans chaque enregistrement.

Fichiers texte

Le type de fichier texte prédéfini en Pascal peut être utilisé pour entreposer tout type de données, à condition qu'elles soient au format caractère. Par exemple, cette déclaration crée une variable fichier de type Text :



Var NameFile:Text;

Ce type de fichier est le plus efficace pour gérer les lignes de texte. Il transfère les données par blocs entre le périphérique externe et un tampon, à partir duquel votre programme peut accéder efficacement aux données, une ligne ou un caractère ou une valeur à la fois.

Remarque : Dans de nombreux cas, ce n'est pas la manière la plus efficace d'effectuer des entrées/sortie. Par exemple, si vous souhaitez entreposer des valeurs à virgule flottante dans un fichier, l'utilisation d'un fichier de type texte nécessiterait de convertir chaque valeur en son équivalent en caractères ASCII avant de l'entreposer dans le fichier. Chaque fois qu'une valeur est lue dans le fichier, elle doit être reconvertie en sa représentation binaire.

Fichiers non typés

Pour déclarer une variable de fichier comme non typée, utilisez uniquement l'identificateur de type FILE. Par exemple :



Var BlockFile:File;

Pascal transfère les données vers et depuis un tel fichier sans interpréter sa structure interne. Un fichier non typé n'a pas de variable de fenêtre de fichier et il ne peut être utilisé qu'avec les routines Reset, Rewrite, Close, Eof, BlockRead, BlockWrite, ByteRead et ByteWrite. Les opérations sur les fichiers non typés sont décrites à la fin de cette page.

Variables de fichier prédéclarées

Le MPW Pascal considère tous les périphériques, tels que le clavier et l'écran Macintosh, comme des fichiers externes. Il prédéclare deux variables de fichier correspondantes de type texte, appelées entrée et sortie. Sauf redirection spécifique, l'entrée provient du clavier standard du MPW Shell et la sortie va vers la sortie déclarée du MPW Shell.

Au début de chaque exécution du programme, les fichiers d'entrée et de sortie sont automatiquement ouverts pour utilisation sans être déclarés. Les procédures et fonctions pouvant être utilisées avec des fichiers de type texte peuvent les utiliser, directement (en les recevant comme paramètres) ou indirectement (par défaut lorsque le paramètre de variable de fichier est omis), sans les déclarer au préalable. Le programme ne doit pas essayer de fermer ces fichiers.

Remarque : La norme ANSI spécifie que les entrées et les sorties doivent apparaître dans l'entête du programme si elles sont utilisées. De nombreuses versions de Pascal s'appuient sur cela. Si vous écrivez du code pouvant être transporté vers d'autres versions de Pascal, incluez l'entrée et la sortie dans l'entête de votre programme.

Si une entrée est utilisée dans le programme, le fichier d'entrée standard est ouvert automatiquement en tant que fichier en lecture seulement (comme si une réinitialisation avait été effectuée) lorsque l'exécution du programme commence.

Si la sortie est utilisée dans le programme, le fichier de sortie standard est ouvert automatiquement en tant que fichier en écriture seulement (comme si une réécriture avait été effectuée pour celui-ci) lorsque l'exécution du programme commence.

Plusieurs des procédures et fonctions prédéfinies à utiliser avec des fichiers de type texte, décrites plus loin dans cette page, n'ont pas besoin d'avoir une variable de fichier explicitement donnée en paramètre. Dans ces cas, l'entrée et la sortie seront supposées par défaut selon que la procédure ou la fonction est orientée entrée ou orientée sortie.

La variable de fenêtre de fichier

Bien qu'une variable de fichier saisie puisse contenir un nombre illimité d'enregistrements logiques, un seul est accessible à la fois. Chaque enregistrement logique possède un numéro qui correspond à sa position dans le fichier par rapport au premier enregistrement du fichier, étant le numéro d'enregistrement 0. La position de l'enregistrement actuel dans le fichier est appelée position actuelle du fichier. L'accès du programme à l'enregistrement actuel utilise une variable spéciale associée au fichier, appelée variable de fenêtre de fichier.

À tout moment, il n'existe qu'un seul enregistrement logique d'un fichier accessible directement via la variable de fenêtre de fichier. Chaque fois qu'un fichier est ouvert, en utilisant l'une des procédures décrites dans cette page, la position actuelle du fichier est définie sur 0, le début du fichier.

La variable de fichier de fenêtre ne peut pas être utilisée avec des fichiers non typés.

Remarque : Dans certaines conditions, par exemple lorsque la position actuelle du fichier est à la fin du fichier, la valeur de la variable de fichier f est dite indéfinie. C'est une erreur de tenter d'utiliser la valeur de la variable de fenêtre de fichier f^ lorsque la valeur de f n'est pas définie. Cependant, l'affectation à f^ est toujours possible si le fichier peut être écrit.

Ouvrir un fichier

Avant de pouvoir utiliser une variable de fichier, celle-ci doit être ouverte. Trois procédures sont fournies pour ouvrir des fichiers existants et créer et ouvrir de nouveaux fichiers : Reset, Rewrite et Open. Chacune de ces procédures est expliquée en détail plus loin dans cette page.

Un nouveau fichier peut être créé et ouvert :

En utilisant Rewrite, créant un nouveau fichier pour un accès séquentiel en écriture seule.
En utilisant Open, créant un nouveau fichier pour un accès en lecture/écriture, séquentiel ou aléatoire. Un fichier existant peut être ouvert.
En utilisant Reset, ouvrant le fichier existant pour un accès séquentiel en lecture seule.
En utilisant Open, ouvrant le fichier existant pour un accès en lecture/écriture, séquentiel ou aléatoire.
En utilisant Rewrite, ouvrant le fichier existant pour un accès séquentiel en écriture seule.

Chacune de ces procédures définit la position actuelle du fichier à zéro. Vous pouvez également utiliser les procédures de Reset et de Rewrite pour définir la position actuelle d'un fichier déjà ouvert sur zéro. Ces règles sont résumées dans le tableau suivant :

Procédure	Type de fichier	Effet
Reset	Nouveau	Une erreur se produit
Reset	Existant	Ouvre un fichier existant en lecture seule avec un accès séquentiel.
Open	Nouveau	Crée un nouveau fichier en lecture/écriture avec accès aléatoire.
Open	Existant	Ouvre un fichier existant en lecture/écriture avec accès aléatoire.
Rewrite	Nouveau	Crée un nouveau fichier en écriture seule avec accès séquentiel.
Rewrite	Existant	Ouvre un fichier existant en lecture/écriture avec accès séquentiel ; contenu précédent effacé.

Fermer un fichier

Si vous souhaitez associer une variable de fichier à un autre fichier externe, vous devez d'abord fermer le fichier ouvert, à l'aide de la procédure Close.

Accès séquentiel ou aléatoire

Les fichiers peuvent être consultés de manière séquentielle ou aléatoire. Lorsqu'un fichier est ouvert et consulté de manière séquentielle, le premier enregistrement logique est lu ou écrit, puis la position actuelle du fichier passe à l'enregistrement logique numériquement suivant dans le fichier.

Alternativement, les fichiers ouverts avec Open sont accessibles de manière aléatoire avec la procédure de recherche. La procédure de recherche prend un paramètre dont la valeur est un nombre faisant référence à la séquence d'enregistrements logiques. En utilisant la procédure de recherche, vous pouvez passer d'un enregistrement à un autre, dans n'importe quel ordre, ou accéder à une position d'octet spécifique dans un fichier texte ou un fichier non typé.

La fonction PLFilepos peut être appliquée à n'importe quelle variable de fichier; il renvoie le numéro d'enregistrement de la position actuelle du fichier. Cette fonction est décrite en détail plus loin dans cette page.

Remarque : Les termes fichier aléatoire et fichier séquentiel sont couramment utilisés mais trompeurs. Aléatoire et séquentiel sont deux méthodes pour accéder au fichier, et non deux types de fichiers. N'importe quel fichier est accessible de manière aléatoire ou séquentielle, ou dans les deux sens. Les procédures prédéfinies prenant en charge l'accès aléatoire sont généralement utilisées avec des fichiers non texte, mais ne s'y limitent pas.

Routines pour tous les fichiers

Les procédures et fonctions décrites dans cette section peuvent être appliquées à des fichiers de toutes sortes, typés ou non.

Remarque : Les routines dont les identifiants commencent par PL (comme PLCrunch) sont définies dans le fichier d'interface PaslibIntf.p ; leur code est dans la bibliothèque PasLib.

La procédure Reset

La procédure Reset ouvre un fichier existant pour un accès séquentiel en lecture seule ou «rembobine» un fichier ouvert afin que sa variable de fenêtre contienne le premier enregistrement logique.

Reset(f[,filename]);

Le paramètre est une référence de variable faisant référence à une variable de fichier. Le paramètre filename est une expression facultative avec une valeur de chaîne de caractères. Si le nom de fichier est donné, le fichier ne doit pas déjà être ouvert. Si le nom du fichier n'est pas donné, le fichier doit être ouvert.

La valeur de filename, si elle est utilisée, doit être un chemin d'accès de fichier Macintosh, un nom de fenêtre, un nom de pseudo-périphérique ou un spécificateur de sélection valide.

L'instruction Reset(f), lorsque le fichier spécifié par f est déjà ouvert, provoque le "rembobinage" du fichier. Le fichier doit avoir été initialement ouvert avec Open ou Reset. Si le fichier a été ouvert avec Open, il passe désormais en lecture seule.

Notez que Reset préserve le contenu d'un fichier existant, contrairement à Rewrite, effaçant le contenu actuel de tout fichier sur lequel il est utilisé.

Une erreur se produit et IOResult renvoie une valeur différente de zéro s'il n'existe aucun fichier externe portant le nom spécifié par filename.

Les conditions suivantes sont toujours remplies après l'exécution de Reset(f[, filename]) :

Eof(f) est true si le fichier est vide. Sinon, Eof(f) est false.
La position actuelle du fichier est le premier enregistrement logique du fichier (numéro d'enregistrement logique 0), et la variable de fenêtre de fichier f^ contient la valeur de cet enregistrement logique à moins que Eof(f) soit true, auquel cas la valeur de f^ n'est pas défini.

La procédure Rewrite

La procédure Rewrite crée et ouvre un nouveau fichier vide pour un accès en écriture seule ou «rembobine» et efface un fichier ouvert.

Rwrite(f[,filename])

Le paramètre f est une variable de fichier. Si le nom de fichier est donné, le fichier ne peut pas déjà être ouvert ; si c'est le cas, une erreur se produit. Le paramètre filename est une expression facultative avec une valeur de chaîne de caractères. La chaîne de caractères doit être un chemin d'accès Macintosh, un nom de fenêtre, un nom de pseudo-périphérique ou un spécificateur de sélection valide.

Remarque : Rewrite(f) (sans nom de fichier spécifié), lorsque f n'est pas encore ouvert, n'est pas implémenté. Il est réservé à une future extension de MPW Pascal.

Rewrite(f), lorsque le fichier spécifié par f est déjà ouvert, provoque le "rembobinage" du fichier ; c'est-à-dire que la position actuelle du fichier est réinitialisée au début du fichier et tout contenu antérieur du fichier est supprimé. Le fichier doit avoir été ouvert avec Open ou Rewrite. Si le fichier a été initialement ouvert avec Open, il devient désormais en écriture seule. La réinitialisation suivie de la réécriture provoque une erreur.

Rewrite(f, filename) crée un nouveau fichier externe portant le nom filename et associe la variable fichier f à ce fichier externe. Si un fichier externe portant le nom filename existe déjà, il est tronqué (c'est-à-dire que la branche de ressources reste la même bien que la branche de données soit supprimée).

Les conditions suivantes sont toujours remplies après l'exécution de Rewrite(f[,filename]) :

Eof(f) est true, soit parce que le fichier est nouveau, soit parce que son contenu vient d'être effacé.
La position actuelle du fichier est l'enregistrement logique 0 ; c'est-à-dire que le premier enregistrement logique écrit dans le fichier deviendra le premier enregistrement logique du fichier. La valeur de f^ n'est pas définie et reste indéfinie jusqu'à ce que quelque chose soit écrit dans le fichier.

La procédure Open

La procédure d'ouverture ouvre un fichier existant ou crée et ouvre un nouveau fichier pour un accès aléatoire en lecture/écriture, en définissant la variable de fenêtre de fichier sur le premier enregistrement logique. Un fichier existant n'est pas tronqué.

Open(f, filename)

Le paramètre f est une référence de variable faisant référence à une variable de fichier. Le fichier n'est peut-être pas déjà ouvert. Le paramètre filename est une expression avec une valeur de chaîne de caractères, devant être un chemin d'accès de fichier Macintosh, un nom de fenêtre, un nom de pseudo-périphérique ou un spécificateur de sélection valide.

L'instruction Open(f, filename) ouvre un fichier externe existant portant le nom filename et associe la variable de fichier spécifiée par f à ce fichier externe. Si un fichier externe portant le nom filename n'existe pas déjà, un nouveau fichier vide est créé. Le fichier est ouvert en lecture et en écriture.

Les conditions suivantes sont toujours remplies après l'exécution de Open(f, filename) :

Eof(f) est true si le fichier est vide ; sinon, Eof(f) est false.
La position actuelle du fichier est l'enregistrement logique 0 et la variable de fenêtre de fichier f^ contient la valeur de cet enregistrement logique, sauf si Eof(f) est true.

La procédure Close

La procédure Close dose un fichier ouvert. Il met fin à l'association entre la variable fichier et le fichier externe, s'il existe.

Close(f)

Le paramètre f est une référence de variable faisant référence à une variable de fichier, devant être ouverte.

L'instruction Close(f) ferme f. Autrement dit, l'association entre f et son fichier externe est rompue et le système d e fichiers marque le fichier externe comme fermé. Toutes les références ultérieures à f ne sont pas valides (sauf pour l'ouvrir à nouveau). En particulier, la valeur de f devient indéfinie.

Si un fichier n'a pas été fermé pendant l'exécution du programme, il est automatiquement fermé à la fin du programme.

Remarque : Les fichiers ayant une portée locale dans une procédure ou un bloc fonctionnel ne sont pas automatiquement fermés lorsque la procédure ou la fonction est terminée.

La fonction Eof

La fonction Eof renvoie une valeur booléenne indiquant si la position actuelle du fichier est ou non la fin du fichier.

Eof[(f)]

Le paramètre f est une référence de variable faisant référence à une variable de fichier. Si f est omis, la fonction est appliquée à l'entrée de fichier prédéfinie. Le fichier doit être ouvert, sinon une erreur se produit.

La fonction Eof renvoie true dans les cas suivants :

La position du fichier est au-delà du dernier enregistrement logique du fichier.
Si le fichier ne contient aucun enregistrement logique.
Après une procédure Get, si la position actuelle du fichier est le dernier enregistrement logique du fichier.
Après une procédure Put, si l'enregistrement logique écrit par le Put est désormais le dernier enregistrement logique.

Dans tous les autres cas, Eof renvoie false.

La procédure IOResult

IOResult

La routine IOResult renvoie une valeur entière indiquant le résultat de la dernière opération d'entrée/sortie effectuée. Si IOResult renvoie zéro, cela signifie que la dernière opération d'entrée/sortie a réussi. Tout résultat différent de zéro indique que la dernière opération d'entrée/sortie a échoué.

Étant donné que les fichiers de type texte sont mis en mémoire tampon, IOResult n'indique pas le résultat de l'écriture sur un fichier tant que le contenu du tampon n'est pas transféré vers le fichier externe. Un transfert de tampon se produit chaque fois que le tampon est plein ou lorsqu'il y a un appel à PLFlush ou Close. Si le code IOResult est négatif, le numéro indique une erreur Toolbox. Les valeurs de retour d'erreur équivalentes de la ROM du Macintosh définies dans MacOSErr sont documentées dans la page Gestionnaire d'erreurs système de Inside Macintosh.

Si le code IOResult est positif, c'est une erreur ayant été détectée par la bibliothèque de langages sans passer par la Toolbox.

La variable ErrNo

La liste suivante documente les valeurs de la variable ErrNo. Ceci est une liste complète ; tous les ErrNo n'apparaissent pas en Pascal.

Valeur	Constante	Nom	Description
1	EPERM	No permission match	Cette erreur se produit après une tentative de modification d'un fichier d'une manière interdite sauf à son créateur.
2	ENOENT	No such file or directory	Cette erreur se produit lorsqu'un fichier dont le nom de fichier est spécifié n'existe pas ou lorsqu'un des répertoires d'un chemin d'accès n'existe pas.
3	ENORSRC	Resource not found	Une ressource requise n'a pas été trouvée. Cette erreur s'applique aux appels faccess renvoyant des informations de tabulation, de police ou d'enregistrement d'impression.
4	EINTR	System service interrupted	Un appel système demandé ne peut pas être effectué. Cette erreur peut se produire si une demande de renommage d'un fichier échoue.
5	EIO	I/O error	Une erreur d'entrée/sortie physique s'est produite. Cette erreur peut dans certains cas être signalée lors d'un appel suivant celui auquel elle s'applique effectivement.
6	ENXIO	No such device or address	Les entrées/sorties sur un fichier spécial font référence à un sous-périphérique n'existant pas, ou l'entrée/sortie dépasse les limites du périphérique. Cette erreur peut également se produire lorsque, par exemple, aucun disque n'est présent dans un unité de disque.
7	E2BIG	Insufficient space for return argument	Les données à renvoyer sont trop volumineuses pour l'espace alloué pour les recevoir.
9	E2ADF	Badfile number	Soit un descripteur de fichier ne fait pas référence à un fichier ouvert, soit une requête de lecture (ou d'écriture) est effectuée sur un fichier ouvert uniquement en écriture (ou lecture).
12	ENOMEM	Not enough space	Le système a manqué de mémoire pendant l'exécution de l'appel à la bibliothèque.
13	EACCES	Permission denied	Une tentative a été faite pour accéder à un fichier d'une manière interdite par le système de protection.
14	EFAULT	Illegal filename	Un nom de fichier ou de volume était trop long ou illégal.
15	ENOTBLK	Block device required	Cette erreur se produit si un fichier non bloc est utilisé alors qu'un périphérique bloc est requis.
16	EBUSY	Device or resource busy	Une tentative a été effectuée pour monter un volume déjà monté ou pour supprimer un fichier verrouillé.
17	EEXIST	File exists	Un dossier existant a été mentionné dans un contexte inapproprié.
18	EXDEV	Cross-device link	Cette erreur se produit après une tentative de création d'un lien vers un fichier sur un autre périphérique.
19	ENODEV	No such device	Une tentative a été effectuée pour appliquer un appel système inapproprié à un périphérique; par exemple, lire un périphérique en écriture seule.
20	ENOTDIR	Not a directory	Un objet n'étant pas un répertoire a été spécifié là où un répertoire est requis, par exemple dans un préfixe de chemin.
21	EISDIR	Is a directory	Une tentative d'écriture a été effectuée dans un répertoire.
22	EINVAL	Invalid parameter	Un paramètre non valide a été fourni à une fonction de bibliothèque.
23	ENFILE	File table overflow	La table des fichiers ouverts du système est pleine, donc temporairement un appel à l'ouverture ne peut pas être accepté.
24	EMFILE	Too many apenfiles	Le système ne peut pas allouer de mémoire pour enregistrer un autre fichier ouvert.
25	ENOTTY	Not a typewriter	Cette erreur se produit si le fichier spécifié n'est pas un fichier de caractères.
26	ETXTBSY	Text file busy	Une tentative a été effectuée pour ouvrir un fichier déjà ouvert en écriture.
27	EFBIG	File too large	Cette erreur se produit si la taille d'un fichier était supérieure à la taille maximale du fichier.
28	ENOSPC	No space left on device	Lors d'une écriture dans un fichier, il n'y a plus d'espace libre sur le périphérique.
29	ESPIPE	Illegal seek	Un lseek n'a pas été émis correctement.
30	EROFS	Read-only file system	Une tentative de modification d'un fichier ou d'un répertoire a été effectuée sur un périphérique monté pour un accès en lecture seulement.
31	EMLINK	Too many links	Une tentative de suppression d'un fichier ouvert a été effectuée.
33	EDOM	Math arg out of domain of func	Cette erreur se produit si le paramètre d'une fonction mathématique est en dehors du domaine de la fonction.
34	ERANGE	Math result not representable	Cette erreur se produit lorsque la valeur d'une fonction mathématique ne peut pas être représentée avec la précision de la machine.

Remarque : Méfiez-vous d'essayer d'accéder à la valeur de IOResult avec une opération d'entrée/sortie, telle que :



Reset(f,'myflle');

WriteLn('IOResult = ',IOResult);

Dans cet exemple, la valeur de IOResult est définie par l'appel Writeln, et non par l'appel Reset.

Attention : Certaines opérations d'entrées/sorties peuvent définir IOResult en raison d'un appel d'entrées/sorties invisible. Par exemple, l'utilisation de Rewrite pour créer un nouveau fichier renverra un IOResult Eof(-39), même si le fichier a été réécrit correctement.

La procédure Seek

Seek(f,n)

La procédure de recherche vous permet d'accéder à n'importe quel enregistrement logique dans un fichier. Cela fait deux choses :

Il définit la position actuelle du fichier sur l'enregistrement logique n.
Il lit le nouvel enregistrement logique actuel dans la variable de la fenêtre du fichier.

Le paramètre f est une variable de fichier.

Le paramètre n est une expression avec une valeur d'entier long qui spécifie un numéro d'enregistrement logique dans le fichier. Les enregistrements logiques sont numérotés à partir de zéro. Avec des fichiers non typés ou des fichiers de type texte, n est la position de l'octet depuis le début du fichier.

Par exemple :



Seek(Names, 18);

fait que la variable de fenêtre de fichier associée aux noms de fichiers pointe vers le dix-neuvième enregistrement du fichier.

La valeur de f^ devient la valeur de cet enregistrement logique sauf si n est supérieur au numéro du dernier enregistrement logique du fichier, auquel cas Eof(f) devient true, IOResult est défini sur eofErr(-39) et la valeur de f^ devient indéfini. Ainsi, Seek(f,MaxLongInt) définit toujours la position actuelle du fichier à la fin du fichier. EofErr n'est pas une erreur fatale, vous pouvez donc l'utiliser pour vérifier que la position actuelle du fichier a effectivement été déplacée vers la fin du fichier.

La fonction PLFilePos

PLFilepos(f)

La fonction PLFilepos renvoie une valeur de type LongInt étant le numéro d'enregistrement logique de la position actuelle du fichier. Avec les fichiers non typés ou les fichiers de type texte, il renvoie le nombre d'octets depuis le début du fichier jusqu'à la position actuelle du fichier. Le paramètre f est une référence de variable faisant référence à une variable de fichier. Le fichier doit être ouvert.

La procédure PLCrunch

PLCrunch(f)

La procédure PLCrunch prend en paramètre un fichier ouvert. Il tronque le fichier à la position actuelle.

La procédure PLPurge

PLPurge(f)

La procédure PLPurge supprime le fichier nommé par f. Une erreur se produit si le fichier est ouvert.

La procédure PLRename

PLRename(oldname,newname)

La procédure PLRename vous permet de renommer n'importe quel fichier.

Oldname et newname sont des chaînes de caractères. Oldname est le chemin d'accès Macintosh d'un fichier existant, pouvant être ouvert ; newname est un nouveau chemin d'accès Macintosh. Si un fichier nommé newname existe déjà, une erreur se produit et la valeur de IOResult est définie sur une valeur différente de zéro.

Routines orientées enregistrement

Les procédures décrites dans cette section permettent d'accéder aléatoirement aux enregistrements logiques d'un fichier. La plupart ne peuvent être utilisés qu'avec des fichiers structurés. Get et Put peuvent être utilisés avec des fichiers texte.

La procédure Get

Get(f)

La procédure Get fait deux choses :

Il avance la position actuelle du fichier au composante suivante.
Il lit le nouvel enregistrement logique actuel dans la variable de la fenêtre du fichier.

Le paramètre f est une référence de variable faisant référence à une variable de fichier. Le fichier doit être ouvert ; si ce n'est pas le cas, une erreur se produit. Si une procédure Get est effectuée alors qu'aucun enregistrement logique suivant n'existe, Eof(f) devient true et la valeur de f^ devient indéfinie.

La procédure Put

Put(f)

La procédure Put fait deux choses :

Il écrit la variable de fenêtre de fichier dans le fichier à la position actuelle du fichier.
Il avance la position du fichier jusqu'à l'enregistrement logique suivant.

Le paramètre f est une référence de variable faisant référence à une variable de fichier. Le fichier doit être ouvert et la valeur de f^ ne doit pas être indéfinie. L'instruction Put(f) écrit la valeur de f^ dans le fichier externe à la position actuelle du fichier et avance la position actuelle du fichier jusqu'à l'enregistrement logique suivant. Si Eof(f) est true, Put(f) ajoute la valeur de f^ à la fin du fichier/et Eof(f) reste true.

La procédure Read avec un fichier structuré

La procédure Read est généralement utilisée avec des fichiers de type texte. Lorsqu'il est utilisé avec un fichier structuré, il lit un ou plusieurs enregistrements logiques dans une ou plusieurs variables, en commençant à la position actuelle du fichier et en avançant le pointeur de position actuelle.

Read([f,] V₁ [, V₂, ..., V_n])

Le paramètre facultatif f est la variable d'un fichier structuré ouvert. Chaque paramètre v_n doit être une variable d'un type compatible en termes d'affectation avec les enregistrements logiques de f. Par exemple, si Newvals est un fichier de type File of Real, alors la procédure appelle :

Read(NewVals, Subtotal, Total);

nécessite que Subtotal et Total soient des variables de types auxquelles une valeur de type réel peut être affectée. Si NewVals est une variable de type entier, par exemple, une erreur du compilateur se produit.

La procédure Write avec un fichier structuré

La procédure Write est généralement utilisée avec des fichiers de type Text. Lorsqu'il est utilisé avec un fichier structuré, il écrit la valeur d'une ou plusieurs variables dans un ou plusieurs enregistrements logiques du fichier, en commençant à la position actuelle du fichier et en avançant le pointeur de position actuelle.

Write([f,] P1 [, P2 ... P_n] )

Le paramètre facultatif f est la variable d'un fichier structuré ouvert. Chaque paramètre p_n doit être une variable du type compatible en affectation avec les enregistrements logiques off. Par exemple, si NewVals est un fichier de type File of Real, alors l'appel de procédure :

Write(NewVals, SubTotal, Total);

requiert que SubTotal et Total soient des variables de types pouvant être affectées à une valeur de type réel (c'est-à-dire réel ou entier). Si NewVals est une variable de type Extended, par exemple une erreur du compilateur se produit.

Routines orientées texte

Cette section décrit les routines d'entrée et de sortie conçues pour être utilisées avec des variables de fichier de type Text. Les fichiers texte se distinguent des autres types de fichiers (par exemple, File of Char) par l'importance particulière accordée au caractère de fin de ligne. Ce caractère permet à un fichier de type Text d'être traité comme une séquence de lignes, plutôt que comme une séquence de caractères individuels. Toutes les routines orientées texte peuvent également être utilisées pour lire des données à partir du clavier. Une ligne entière peut être lue à partir du fichier dans une variable de type chaîne de caractères à l'aide de la procédure ReadLn, et une ligne entière peut être écrite dans le fichier à l'aide de la procédure WriteLn. Vous pouvez tester le caractère de fin de ligne en utilisant la fonction Eoln décrite plus loin dans cette page.

Remarque : Lorsque la valeur de l'enregistrement logique à la position actuelle d'un fichier est un caractère de fin de ligne, les procédures Read et Readln la lisent comme un caractère d'espace (ASCII 32).

Les procédures Read et Write peuvent être appliquées à n'importe quel fichier saisi. Cependant, les procédures Readln et Writeln dépendent de la présence du caractère Eoln, n'apparaissant que dans les fichiers de type texte.

Remarque : Aucune des procédures et fonctions prédéfinies dans cette section ne nécessite un paramètre de variable de fichier explicite. Si aucun fichier n'est nommé, l'un des fichiers prédéfinis, input ou output, sera assumé par défaut, selon que la procédure ou la fonction est orientée entrée ou orientée sortie. N'oubliez pas que le input et le output sont prédéclarées sous forme de fichiers de type Text.

La procédure Read

Read([f,] V1 [, V2,..., Vn])

La procédure Read lit une ou plusieurs valeurs d'un fichier texte dans une ou plusieurs variables.

Si f est donné, il doit s'agir d'une référence de variable faisant référence à une variable de fichier de type texte. Le fichier doit être ouvert. Si f est omis, il est supposé qu'il s'agit de l'entrée de fichier texte prédéfinie.

Chaque V_n est une référence de variable faisant référence à une variable de l'un des types suivants :

char ou une sous-intervalle de type char
Integer, LongInt ou une sous-intervalle d'Integer ou LongInt.
un des types réel
un type scalaire (y compris Boolean) ou une sous-gamme de type scalaire
un type de chaîne de caractères.
une Packed Array of Char.

Read avec un élément de tableau suit les règles relatives au type de l'élément. Les autres possibilités sont discutées ci-dessous.

Read avec une variable char

Un Read effectuée avec une variable de type char est considérée comme équivalente à cette instruction composée :



BEGIN

 v:=ff^;

 Get(ff)

END

Dans cet exemple, v est une variable de type char et ff est un File of char. N'oubliez pas que si la position actuelle du fichier se trouve à un caractère de fin de ligne, ff^ contient un caractère espace.

Read avec une variable Integer

Une procédure Read effectuée avec une variable Integer ou de sous-intervalle Integer lit une séquence de caractères formant un nombre entier signé dans l'intervalle de type Integer ou de type LongInt. Si la séquence de caractères est une représentation valide d'un Integer, la valeur Integer est affectée à la variable. Sinon, une erreur se produit.

Lors de la lecture d'un Integer, la séquence de caractères, d'espaces, de tabulations et de caractères de fin de ligne précédant le premier chiffre ou le signe est ignorée. La lecture cesse dès qu'on atteint un caractère (avec les caractères déjà lus) ne faisant pas partie d'un nombre entier signé ; ou quand Eof(f) devient true.

Si un nombre entier signé n'est pas trouvé après avoir ignoré les espaces, tabulations et caractères de fin de ligne précédents, une erreur se produit et IOResult renvoie une valeur de -1025.

Les conditions suivantes sont vraies immédiatement après une lecture à partir d'un fichier texte avec une variable entière :

La position actuelle du fichier est le caractère suivant le dernier caractère de la chaîne de caractères numérique, sauf si le dernier caractère de la chaîne de caractères était le dernier caractère du fichier.
Eof(f) retournera true si le dernier caractère de la chaîne numérique était le dernier caractère du fichier.
Eoln(f) retournera true si le dernier caractère de la chaîne numérique était le dernier caractère de la ligne.

Read avec une variable réelle

Un Read effectuée sur un fichier texte avec une variable d'un des types réels lit une séquence de caractères formant un nombre signé. Si la séquence de caractères est une représentation valide d'une valeur de type réel, la valeur est affectée à la variable. Sinon, une erreur se produit.

Lorsqu'une valeur de type Real est en cours de lecture, toute séquence d'espaces et de tabulations précédant le premier chiffre ou le signe est ignorée. La lecture cesse dès qu'un caractère est atteint qui (avec les caractères déjà lus) ne fait pas partie d'un nombre signé, ou lorsque Eof(f) devient true.

Si un nombre réel signé n'est pas trouvé après avoir ignoré les espaces et tabulations précédents, NaN est renvoyé et l'exception est Invalid.

Remarque : En plus de la syntaxe Pascal standard, le MPW Pascal considère, par exemple, inf, NaN, NaN(0), NaN(), NaN(39), .369, .369312, 1. et 1.e9 comme étant tous valides et avec des chiffres réels.

Immédiatement après une lecture depuis un fichier texte avec une variable de type réel, les conditions suivantes sont vraies :

La position actuelle du fichier est le caractère suivant le dernier caractère de la chaîne de caractères numérique, sauf si le dernier caractère de la chaîne de caractères était le dernier caractère du fichier.
Eof(f) retournera true si le dernier caractère de la chaîne de caractères numérique était le dernier caractère du fichier.
Eoln(f) retournera true si le dernier caractère de la chaîne de caractères numérique était le dernier caractère de la ligne.

Read avec une variable chaîne de caractères

Un Read effectuée avec une variable chaîne de caractères lit une séquence de caractères jusqu'au caractère de fin de ligne suivant, mais non inclus, ou jusqu'à la fin du fichier. La chaîne de caractères résultante est affectée à la variable. C'est une erreur si le nombre de caractères lus dépasse l'attribut size de la variable.

Remarque : Avec une variable chaîne de caractères, Read ne passe pas à la ligne suivante après la lecture ; un caractère de fin de ligne est laissé dans le tampon du fichier. Pour cette raison, vous ne pouvez pas utiliser des appels Read successifs pour lire une séquence de chaînes de caractères; après la première lecture, chaque lecture suivante accédera à la fin de la ligne (au lieu d'un caractère) et lira une chaîne de caractères de longueur zéro. Au lieu de cela, vous devez utiliser Readln pour lire les valeurs de chaîne de caractères; Readln passe au début de la ligne suivante après chaque entrée.

Les conditions suivantes sont vraies immédiatement après une lecture à partir d'un texte avec une variable chaîne de caractères :

La position actuelle du fichier est le caractère suivant le dernier caractère de la chaîne de caractères, sauf si le dernier caractère de la chaîne de caractères était le dernier caractère du fichier.
Eof(f) retournera true si le dernier caractère de la chaîne de caractères était le dernier caractère du fichier.
Eoln(f) renverra true sauf si Eof(f) est true, dans lequel Eoln(f) n'est pas défini.

La procédure ReadLn

Readln([f,] V1 [ , V2, ..., V_n ] )

La procédure Readln est une extension de Read. Il lit une séquence de caractères jusqu'à ce que le caractère suivant soit le caractère de fin de ligne. Il passe ensuite au début de la ligne suivante dans le champ d'entrée. Étant donné que Readln dépend de la recherche du caractère de fin de ligne, il ne peut être utilisé qu'avec des fichiers de type text.

Les paramètres autorisés avec Readln sont les mêmes que ceux pour Read. De plus, vous pouvez utiliser ReadLn :

sans variables d'entrée
sans paramètres

Si le premier paramètre ne spécifie pas de fichier ou si aucun paramètre n'est utilisé, Readln lit à partir de l'entrée du fichier standard.

Lorsque Readln est utilisé sans variables d'entrée, il avance la position actuelle du fichier au début de la ligne suivante, s'il y en a une. S'il n'y a pas de ligne suivante, il avance la position actuelle du fichier jusqu'à la fin du fichier.

Les conditions suivantes sont vraies immédiatement après une lecture Readln, quel que soit le type de variable d'entrée utilisée :

Eof(f) retournera true si la ligne lue était la dernière ligne du fichier.
Eoln(f) renverra false sauf si la ligne suivant la ligne lue est vide.

La procédure Write

Write([f,] P1 [,P2,...P_n])

La procédure Write écrit une ou plusieurs valeurs dans un fichier texte. Le paramètre f (s'il est donné) est une référence de variable faisant référence à une variable me de type Text. Le fichier doit être ouvert. Si f est omis, la procédure écrit dans la sortie du fichier prédéfini.

Chaque paramètre p_n est un paramètre d'écriture. Au moins un paramètre d'écriture doit être présent. La valeur de chaque paramètre d'écriture, p_n, est donnée par une expression de sortie, pouvant être de type Char, Inteqer, Real, STRING, PACKED ARRAY OF char ou Boolean.

Outre les expressions complexes, ces expressions de sortie incluent également des variables et des constantes uniques. Les effets de l'utilisation de la procédure d'écriture avec ces différents types sont discutés ci-dessous.

Chaque paramètre Write a le format :

OutExp [: MinWidth [:DecPlaces ]]

où OutExp est une expression de sortie. MinWidth et DecPlaces sont des expressions facultatives avec des valeurs entières. Par exemple, dans les déclarations :



Write(NewVals, Total);

Write(NewVals, Total:8:4);

Total est l'expression de sortie. La valeur de la variable de type réel Total est à écrire dans le fichier NewVals. Dans le premier cas, les spécifications facultatives MinWidth et DecPlaces sont omises. Dans le deuxième cas, MinWidth est de huit et DecPlaces de quatre. Le total sera écrit dans un champ large de huit espaces et comportant quatre caractères à droite de la décimale.

MinWidth spécifie la largeur minimale du champ. La largeur minimale doit être supérieure ou égale à zéro. Exactement les caractères de largeur minimale sont écrits (en utilisant des espaces de début si nécessaire), sauf lorsque OutExpr a une valeur qui doit être représentée par plus de caractères MinWidth, auquel cas le nombre exact de caractères requis est écrit. MinWidth peut être utilisé avec un OutExp de n'importe quel type valide dans un paramètre d'écriture.

DecPlaces spécifie le nombre de décimales à utiliser dans la représentation en virgule fixe d'une valeur réelle. Il ne peut être spécifié que si OutExpr a une valeur de type réelle et si MinWidth est également spécifié. S'il est spécifié, il doit être supérieur à zéro. Si DecPlaces n'est pas spécifié et que la valeur est l'un des types réels, une représentation à virgule flottante est écrite. La représentation à virgule flottante est abordée plus loin dans cette page.

Write avec une valeur char

Si Write reçoit une variable de type char et que MinWidth n'est pas spécifié, la valeur de caractère de OutExpr est écrite dans le fichier spécifié. Si MinWidth est inclus, exactement les espaces MinWidth-1 sont écrits, suivis de la valeur de caractère OutExpr. Par exemple :



Write(Names, Initial);

Write(Names, Initial:3);

Dans le premier exemple, le caractère correspondant à la valeur Initial est écrit dans le fichier, sans espaces de début. Dans le deuxième exemple, Initial est écrit précédé de deux espaces.

Write avec une valeur Integer

Si OutExpr est de type Integer, sa représentation décimale est écrite dans le fichier spécifié comme par cet algorithme :



Begin

 For I:=1 To MinWidth-(Length(OutDigits)+1) do Write(ff,' ');

 IF OutExpr<0 THEN

  Write(ff,'-')

 ELSE

  Write(ff,' ');

  Write(ff,OutDigits)

End;

Le paramètre ff représente la variable référencée par f. OutDigits est une valeur de chaîne de caractères contenant la représentation décimale de la valeur absolue de OutExpr, sans zéros non significatifs sauf si la valeur de OutExpr est zéro, auquel cas outDigits contient le caractère unique «0».

Par exemple, si la représentation décimale de la valeur d'OutExpr est 4545 et de MinWidth est égale à huit, l'instruction FOR écrira trois caractères d'espace dans un fichier. Étant donné que outExpr n'est pas inférieur à zéro, la clause IF ne s'exécutera pas et la clause ELSE générera un espace supplémentaire. Enfin, la dernière instruction Write affichera le nombre décimal 4545 dans le fichier.

Voici quelques règles de syntaxe supplémentaires pour l'utilisation de l'écriture avec une valeur entière :

Si la largeur minimale est utilisée et que sa valeur est supérieure au nombre de chiffres dans la représentation décimale de la valeur à écrire, des espaces seront écrits à gauche du nombre. Le nombre d'espaces dépend de la spécification MinWidth.
Si la valeur de OutExpr est inférieure à zéro, un signe moins (ASCII $2D) est écrit dans le fichier, indiquant une valeur négative.
Si la largeur minimale est omise, la valeur par défaut est huit.

Write avec une valeur de type Real

Si OutExpr a une valeur réelle, sa représentation décimale est écrite dans le fichier spécifié. Cette représentation dépend de la valeur du paramètre DecPlaces (s'il est présent).

Si DecPlaces est présent, une représentation à virgule fixe est écrite. Si DecPlaces est absent, une représentation à virgule flottante est écrite. Les deux cas sont discutés séparément ci-dessous.

Représentation en virgule fixe

Supposons que IntDigits est une valeur de chaîne de caractères contenant la représentation décimale de cette expression :



Trunc(Abs(OutExpr))

IntDigits ne contient pas de zéros non significatifs (sauf si la valeur de outExpr est zéro, auquel cas IntDigits contient le caractère unique 0). Cette expression est la valeur de la partie de outExpr à gauche du point décimal.

Supposons maintenant que FracDigits est une valeur de chaîne de caractères contenant la représentation décimale de cette expression :

Round((Abs(OutExpr)-Trunc(Abs(OutExpr))) * 10^DecPlaces)

avec suffisamment de zéros non significatifs pour que la Length(FracDigits) soit égale à DecPlaces.

Ensuite, la représentation à virgule fixe est écrite dans le fichier à l'aide de cet algorithme :




Begin

 If MinWidth>=Length(IntDigits)+Length(FracDigits)+2 Then Write(ff,' ':MinWidth-TotalDigits-3);

 If OutExpr<0 Then Write(ff,'-') 

  Else

 If MinWidth>=Length(IntDigits)+Length(FracDigits)+2 Then Write(ff, ' ');

 Write(ff,IntDigits, '.',FracDigits)

End;

Si la largeur minimale est omise dans le paramètre Write, elle est supposée être égale à dix.

Représentation à virgule flottante

L'algorithme utilisé pour écrire une représentation à virgule flottante fonctionne de cette manière. L'expression Abs(OutExpr) peut être représentée en notation à virgule flottante sous cette forme :

m.n*10^e

Dans cette expression, il y a toujours un chiffre de un à neuf, sauf si la valeur de outExpr est zéro. Supposons que IntDigit est une valeur de chaîne de caractères contenant la représentation décimale de m - un seul chiffre. Supposons que FracDigits est une valeur de chaîne de caractères contenant les premiers chiffres MinWidth-9 de la représentation décimale de n arrondi, ou avec des espaces de fin conservés et des zéros de fin ajoutés si nécessaire. Supposons que ExpDigits est une valeur de chaîne de caractères contenant la représentation décimale d'Abs(e) avec suffisamment d'espaces de début pour que Length(ExpDigits) soit égale à quatre. Supposons également que NegExp a la valeur true si e<0 et qu'elle est fausse dans le cas contraire. Compte tenu de ces hypothèses, voici l'algorithme pour écrire une représentation à virgule flottante :



Begin

 If OutExpr<0 Then Write(ff, '-') Else Write(ff,' ');

 Write(ff,IntDigit,'.', FracDigits, 'E');

 IF NeqExp Then Write(ff, '-') Else Write(ff,'+');

 Write(ff,ExpDigits)

End;

Write avec une valeur de chaîne de caractères

Les résultats de l'utilisation de Write avec une variable de chaîne de caractères dépendent de l'attribut de longueur de la chaîne de caractères apparaissant comme OutExpr et du fait que la largeur minimale soit spécifiée ou non.

Voici les règles :

Si MinWidth est spécifié et que la longueur de la chaîne de caractères est inférieure à MinWidth, alors la chaîne de caractères est écrite précédée d'un nombre d'espaces égal à MinWidth moins la longueur de la chaîne de caractères.
Si MinWidth est spécifié et que la longueur de la chaîne de caractères est supérieure à MinWidth, alors le premier nombre de caractères MinWidth est écrit.
Si MinWidth est spécifié et que la longueur de la chaîne de caractères est égale à MinWidth, ou si MinWidth n'est pas spécifié, la valeur entière de la chaîne de caractères est écrite dans le fichier.

Par exemple, dans la déclaration :



Write(LastName:8);

LastName est une variable chaîne de caractères d'une taille de dix. Si LastName contient une valeur de neuf ou dix caractères, seuls huit seront écrits dans la sortie.

Write avec un Packed Array Of Char

Si OutExpr est un PACKED ARRAY OF char, l'effet est le même que l'écriture d'une chaîne de caractères dont la longueur est le nombre d'enregistrements logiques dans le type.

Write avec une valeur Boolean

Si la valeur de OutExpr est de type Boolean, la chaîne de caractères 'TRUE' (avec un espace entête) ou la chaîne de caractères 'FALSE' est écrite dans le fichier f. La valeur par défaut de MinWidth est cinq. Si MinWidth est supérieur à cinq, des espaces de début sont ajoutés ; si MinWidth est inférieur à cinq, le caractère T ou F est écrit, complété par des espaces comme s'il s'agissait d'une valeur de type STRING[1].

La procédure WriteLn

WriteLn([f,] P1 [, P2,...,P_n])

La procédure WriteLn est une extension de Write. Il effectue les mêmes actions, puis écrit un caractère de fin de ligne dans le fichier de sortie.

Les paramètres sont les mêmes que ceux utilisés avec Write, sauf que les paramètres d'écriture peuvent être entièrement omis; sans eux, WriteLn écrit un caractère de fin de ligne dans la sortie.

La fonction Eoln

Eoln[(f)]

Le paramètre f est une référence de variable qui fait référence à une variable de fichier de type text. Le fichier doit être ouvert. Si f est omis, la fonction est appliquée à l'entrée de fichier prédéfinie.

Eoln renvoie true si le caractère à la position actuelle du fichier est un caractère de fin de ligne. Une erreur se produit si Eoln (f) est appliqué à un fichier non texte ou si f est en écriture seule. Si Eof(f) est vrai, Eoln() n'est pas défini.

La procédure Page

Page[(f)]

La procédure Page envoie un caractère de saut de page (ASCII 12) au fichier désigné par f. Si le paramètre file est omis, le caractère est envoyé à la sortie du fichier prédéfini.

La procédure PLSetVBuf

PLSetVBuf(f,bufptr,style,bufsize)

La procédure PLSetVBuf vous permet de spécifier votre propre tampon à utiliser avec les fichiers de type text.

Le paramètre f est une référence de variable faisant référence à une variable de fichier de type text. Le paramètre buffer est un pointeur vers un PACKED ARRAY OF char à utiliser comme tampon d'entrée/sortie de texte. bufsize est un entier donnant la taille du tampon en octets. Le style est un entier déterminant la manière dont la mise en mémoire tampon est effectuée.

Style	Description
_IOFBF	Les entrées/sorties sont mises en mémoire tampon.
_IOLBF	La sortie est mise en mémoire tampon de ligne ; le tampon est vidé lorsqu'il est plein ou à Eoln.
_IONBF	Les entrées/sorties ne sont pas tamponnées ; bufptr et bufsize sont ignorés.

Le système alloue normalement le tampon d'un fichier lorsque la première opération de lecture ou d'écriture est effectuée sur celui-ci. Pour allouer votre propre tampon, appelez PLSetVBuf après l'ouverture du fichier mais avant la première opération de lecture ou d'écriture. Si la valeur de bufptr est NIL, le système alloue un tampon de taille bufsize lors de la première opération de lecture ou d'écriture. Assurez-vous de fermer le fichier avant de libérer son tampon.

La procédure PLFlush

PLFlush(f)

La procédure PLFlush provoque l'écriture dans le fichier du contenu du tampon de sortie courant associé au fichier f de type text.

Les procédures Get et Put avec des fichiers texte

Les procédures Get et Put peuvent être utilisées pour le caractère à la fois d'entrée/sortie. Get avec un fichier texte diffère de Get avec un fichier structuré uniquement en ce sens qu'un caractère n'est pas lu tant qu'un programme n'a pas lu la variable de fenêtre de fichier. Ce comportement de Get permet d'interagir avec les informations saisies au clavier.

Important : Ne mélangez pas Get et Put avec Read et Write. Actuellement, ils ne sont pas compatibles.

Routines pour les fichiers non typés

Les routines suivantes ne peuvent être utilisées que sur des fichiers non typés, c'est-à-dire des variables de type FILE sans type d'enregistrement logique spécifié. Avec Blockread et Blockwrite, un fichier non typé est traité comme une séquence de blocs de 512 octets. Avec Byteread et Bytewrite, il est traité comme une séquence d'octets. Dans les deux cas, les octets du fichier ne sont pas vérifiés mais sont considérés comme des données brutes. Cela peut être utile pour les applications où les données n'ont pas besoin d'être interprétées du tout pendant les opérations d'entrées/sorties.

Les blocs d'un fichier non typé sont considérés comme numérotés séquentiellement en commençant par l'enregistrement logique 0. Le système garde la trace du numéro de bloc actuel ; c'est le bloc 0 immédiatement après l'ouverture du fichier. Chaque fois qu'un bloc est lu, le numéro du bloc actuel est incrémenté. Par défaut, chaque opération d'entrée/sortie commence au numéro de bloc actuel ; cependant, un numéro de bloc arbitraire peut être spécifié.

Un fichier non typé n'a pas de variable de fenêtre de fichier et il ne peut pas être utilisé avec la procédure Get ou Put ni avec aucune des procédures d'entrée/sortie orientées texte. Il ne peut être utilisé qu'avec Reset, Rewrite, Open, Close, Seek, Eof et les quatre fonctions décrites ci-dessous.

Pour utiliser un fichier non typé d'entrée/sortie, un fichier non typé est ouvert avec Open, Reset ou Rewrite ; les fonctions BlockRead, Blockwrite, Byteread et Bytewrite peuvent ensuite être utilisées pour l'entrée et la sortie.

La fonction Blockread

Blockread(f,databuf,count[,blocknum])

La fonction Blockread lit un ou plusieurs blocs de données de 512 octets à partir d'un fichier non typé vers une variable de programme et renvoie un entier représentant le nombre de blocs lus. Ses paramètres sont les suivants :

Le paramètre f est une référence de variable faisant référence à une variable de type FILE. Le fichier doit être ouvert.
Databuf est une référence de variable faisant référence à la variable dans laquelle les blocs de données seront lus. La taille et le type de cette variable ne sont pas vérifiés; s'il n'est pas assez grand pour contenir les données, d'autres données peuvent être écrasées et les résultats sont imprévisibles.
Count est une expression avec une valeur integer. Il précise le nombre maximum de blocs à transférer. Blockread lira les blocs jusqu'à ce que cette limite soit atteinte, que la fin du fichier soit atteinte ou qu'une erreur se produise.
Blocknum est une expression facultative avec une valeur entière. Il précise le numéro du bloc de départ du transfert. S'il est omis, le transfert commence par le bloc en cours. Ainsi les transferts sont séquentiels si le paramètre BlockNum n'est jamais utilisé ; si un paramètre BlockNum est utilisé, il fournit un accès aléatoire aux blocs.

Une fois le dernier bloc du fichier lu, le numéro de bloc actuel n'est pas spécifié et Eof(f) est true. Sinon, Eof(f) est false et le numéro de bloc actuel est avancé au bloc après le dernier bloc lu. Si Blockread lit moins de blocs BlockNum, il renvoie le nombre réel de blocs lus. Si la fin du fichier se produit pendant la lecture du dernier bloc, le reste du bloc est rempli de zéro octet. Si Eof(f) est true lorsque Blockread est appelé, Blockread renvoie zéro et IOResult renvoie une valeur de eofErr(-39).

La fonction Blockwrite

Blockwrite(f,databuf,count,[blocknum])

La fonction Blockwrite écrit un ou plusieurs blocs de données de 512 octets à partir d'un tampon vers un fichier non typé et renvoie un entier représentant le nombre de blocs écrits.

Le paramètre f est une référence de variable faisant référence à une variable de type FILE. Le fichier doit être ouvert.
Databuf est une référence de variable faisant référence à la variable à partir de laquelle les blocs de données seront écrits. La taille et le type de cette variable ne sont pas vérifiés.
Count est une expression avec une valeur Integer. Il précise le nombre maximum de blocs à transférer. Blockwrite écrira des blocs jusqu'à cette limite, sauf si une erreur se produit.
Blocknum, une expression facultative avec une valeur Integer. Il précise le numéro du bloc de départ du transfert. S'il est omis, le transfert commence par le bloc en cours. Ainsi les transferts sont séquentiels si le paramètre BlockNum n'est jamais utilisé ; si un paramètre BlockNum est utilisé, il fournit un accès aléatoire aux blocs.

Si l'espace disque s'épuise pendant le transfert de données, le numéro de bloc actuel n'est pas spécifié. Blockwrite renvoie le nombre réel de blocs écrits et définit IOResult sur une valeur différente de zéro. Sinon, le numéro de bloc actuel est avancé au bloc suivant le dernier bloc écrit.

Les fonctions Byteread et Bytewrite

Byteread(f, databuf, count [, blocknum])

Bytewrite(f, databuf, count[, blocknum])

Les fonctions Byteread et Bytewrite fonctionnent de manière identique à Blockread et Blockwrite, avec quatre différences :

Ils transfèrent des octets de données au lieu de blocs.
Le type des paramètres Bytenum et Count dans le résultat de la fonction est un LongInt au lieu d'un Integer.
La valeur Bytenum est la position actuelle de l'octet dans le fichier. Le premier octet est numéroté zéro.
Byteread et Bytewrite renvoient le nombre d'octets transférés.

Remarque : Le mélange de fonctions de fichier non typées de bloc et d'octet peut entraîner une confusion à moins que leurs paramètres Blocknum et Bytenum ne soient utilisés pour ajuster la position actuelle du fichier. Une fonction de bloc transfère toujours les 512 octets suivants; après une fonction d'octet, celle-ci peut ne plus être conforme à une limite naturelle de bloc.

Dernière mise à jour : Vendredi, le 28 juin 2024