Types de fichier
À bien des égards, la méthode de structuration la plus simple est la séquence. Dans la profession informatique, le terme généralement accepté pour décrire une séquence est un fichier séquentiel. Le Pascal utilise simplement le mot FILE pour spécifier une structure constituée d'une séquence de composantes - ayant tous le même type. Un fichier de type spécial appelé fichier texte est constitué en une séquence de lignes de caractères de longueur variable et constitue la base de communications lisibles entre les personnes et les systèmes informatiques.
La structure des fichiers
Un ordre naturel des composantes est défini par la séquence, et en tout cas, une seule composante est directement accessible. Les autres composantes sont accessibles en progressant séquentiellement dans le fichier. Le nombre de composantes, appelé la longueur du fichier, n'est pas fixé par la définition du type de fichier. C'est une caractéristique distinguant clairement le fichier du tableau. Un fichier sans composantes est dit vide. Un type de fichier, par conséquent, diffère des types tableau, enregistrement et ensemble car il s'agit d'une structure à accès séquentiel dont les composantes ont tous le même type.
| file of type |
| packed file of type |
La déclaration de chaque variable de fichier F introduit automatiquement une variable tampon, notée que F↑ est de type composante. Il peut être considéré comme un accès au fichier à travers lequel on peut soit inspecter (lire) la valeur des composantes existantes, soit générer (écrire) de nouveaux composantes, et étant automatiquement avancé par certaines opérations sur les fichiers. L'affectation n'est pas possible à des variables de fichier entières. La variable tampon est plutôt utilisée pour ajouter des composantes un par un, de manière unidirectionnelle (séquentielle). La variable tampon devient indéfinie si le fichier est positionné au-delà de sa dernière composante.
Le traitement séquentiel, la longueur variable et l'existence d'une variable de tampon suggèrent que les fichiers peuvent être associés au entreposage secondaire et aux périphériques. La manière exacte dont les composantes sont alloués dépend de la mise en oeuvre, mais nous pouvons supposer que seuls certains des composantes sont présents dans l'entreposage principal à tout moment et que seul la composante indiqué par F↑ ou F^ est directement accessible. Lorsque la variable tampon F↑ ou F^ est déplacée au-delà de la fin d'un fichier F, la fonction booléenne prédéclarée EOF(F) renvoie la valeur TRUE, sinon FALSE. Les procédures de base de gestion des fichiers sont :
| Nom | Description |
|---|---|
| Reset(F) | Cette procédure lance l'inspection (lecture) de F en plaçant le fichier à son début. Si F n'est pas vide, la valeur de la première composante de F est affectée à F↑ et EOF(F) devient FALSE. |
| Rewrite(F) | Cette procédure lance la génération (écriture) du fichier F. La valeur actuelle de F est remplacée par le fichier vide. EOF(F) devient TRUE, et un nouveau fichier peut être écrit. |
| Get(F) | Cette procédure permet de faire passer le fichier aux composante suivante et affecte la valeur de cette composante à la variable tampon F↑. Si aucune composante suivante n'existe pas, alors EOF(F) devient TRUE et F↑ devient indéfini. L'effet de GET(F) est une erreur si EOF(F) est TRUE avant ou avant son exécution ou si F est généré. |
| Put(F) | Cette procédure permet d'ajouter la valeur de la variable tampon F↑ au fichier F. L'effet est une erreur sauf si avant l'exécution le prédicat EOF(F) est TRUE. EOF(F) reste TRUE, et F↑ devient indéfini, Put(F) est une erreur si F est inspecté. |
En principe, toutes les opérations de génération et d'inspection de fichiers séquentiels peuvent être entièrement exprimées en termes des quatre opérateurs de fichiers primitifs et du prédicat EOF. En pratique, il est souvent naturel de combiner l'opération d'avancement de la position du fichier avec l'accès à la variable tampon. Nous introduisons donc les deux procédures Read et Write comme suit :
Read(F,X)
(pour X, une variable) équivaut à :
Begin
X:=F↑; Get(F)
End
ou :
Begin
X:=F^; Get(F)
End
Et la procédure Write :
Write(F,E)
(pour E, une expression) équivaut à :
Begin
F↑:=E; Put(F)
End
Les procédures Read et Write sont en fait des procédures spéciales étendues pour accepter un nombre variable de paramètres réels (V1...Vn sont des variables et E1...En sont des expressions) :
Read(F,V1,...,Vn)
équivaut à la déclaration :
Begin
Read(F,V);...;Read(F,Vn);
End;
Et la procédure Write :
Write(F, E1,...,En);
équivaut à la déclaration :
Begin
Write(F,E1);...;Write(F,En);
End;
L'avantage de l'utilisation de ces procédures réside non seulement dans la brièveté, mais aussi dans la simplicité conceptuelle, car l'existence d'une variable tampon F↑, parfois indéfinie, peut être ignorée. La variable de tampon peut, cependant, être utile en tant que dispositif d'anticipation. Exemple de déclaration :
Var
Donnees:File of Integer;
A:Integer;
Var
FichierTrace:File of Record
Couleur:Color;
Longueur:Natural;
End;
Var
Club:File of Personne;
P:Personne;
Exemple d'instructions avec fichiers :
A:=Donnees↑; Get(Donnees);
Read(Donnees,A);
FichierTrace↑.c:=Red;
FichierTrace↑.Len:=17; Put(FichierTrace);
Club↑:=P; Put(C1ub);
Write(Club,P);
Les fichiers peuvent être locaux pour un programme (ou locaux pour une procédure), ou ils peuvent déjà exister en dehors du programme. Ces derniers sont appelés fichiers externes. Les fichiers externes sont passés en tant que paramètres dans l'entête du programme dans le programme.
Fichiers texte
Les fichiers texte sont des fichiers constitués d'une séquence de caractères subdivisée en lignes de longueur variable. Le type prédéfini Text est utilisé pour déclarer des fichiers texte. On peut considérer le type Text comme étant défini sur le type de base Char étendu par un terminateur de ligne (hypothétique) ou un marqueur de fin de ligne. Par conséquent, le type Text est équivalent à (Packed) file of Char. Ce marqueur de fin de ligne peut être à la fois reconnu et généré par les procédures et fonctions spéciales de fichier texte suivantes :
| Nom | Description |
|---|---|
| Writeln(F) | Cette procédure permet de terminer la ligne courante du fichier texte F. |
| Readln(F) | Cette procédure permet de passer au début de la ligne suivante du fichier texte F (F↑ devient le premier caractère de la ligne suivante). |
| Eoln(F) | Cette fonction booléenne permet d'indiquer si la fin de la ligne courante dans le fichier texte F a été atteinte. (Si elle vrai, alors F↑ correspond à la position d'un séparateur de ligne, mais F↑ est un blanc.) |
Si F est un fichier texte et Ch une variable de caractère, alors :
Write(F,Ch);
est une abréviation de :
Begin
F↑:=Ch; Put(F)
End
Pour la lecture :
Read(F,Ch);
affecte le caractère à la position actuelle du fichier F ou la valeur de F↑ à Ch, suivi d'un Get(F). Le choix dépend de la mise en oeuvre.
Les Input et Output sont les noms de deux variables de fichier texte standard utilisées comme paramètres de programme pour la lecture et l'écriture lisibles de texte. Elles peuvent être utilisés par des procédures Read, Write, Readln et Writeln.
Le schéma de programme suivant utilise les conventions ci-dessus pour illustrer certaines opérations typiques effectuées sur des fichiers texte. Premièrement, l'écriture d'un fichier texte Y. Supposons que P(C) calcule un caractère (suivant) et l'affecte au paramètre C. Si la ligne courante doit se terminer, une variable booléenne B1 est mise à TRUE; et si le texte doit être terminé, B2 est mis à TRUE.
Deuxièmement, lire un fichier texte X. Supposons que Q(C) désigne le traitement d'un caractère (suivant) C. Le R désigne une action à exécuter lors de la rencontre de la fin d'une ligne.
Troisièmement, copie d'un fichier texte X dans un fichier texte Y tout en préservant la structure de ligne de X :
Remarque
- Une méthode simple pour représenter le marqueur de fin de ligne consiste à utiliser des caractères de contrôle. Par exemple, dans l'ensemble de caractères ASCII, les deux caractères, CR (retour chariot) et LF (saut de ligne), sont généralement utilisés pour marquer la fin d'une ligne. Cependant, certains systèmes informatiques utilisent un ensemble de caractères dépourvu de tels caractères de contrôle; cela implique que d'autres méthodes pour indiquer la fin d'une ligne doivent être employées.