Langage de programmation - QuickPascal - Utilisation de fichiers et de répertoires

Utilisation de fichiers et de répertoires

Le QuickPascal n'offre pas juste la possibilité de faire des programmes effectuant des entrées et sorties du clavier et de l'écran, il permet également de manipuler de façon assez profondes les fichiers et les répertoires du système d'exploitation DOS. Cette possibilité est très utiles car elle permet d'entreposer des données au-delà de la fin de chaque session. Le QuickPascal résout ce problème en prenant en charge l'utilisation de fichiers sur disque.

Effectuer l'entrée et la sortie de fichiers

Le concept de fichier est fondamental pour la conception du système d'exploitation. Le DOS, par exemple, considère tout ce qui se trouve en dehors de la mémoire interne du compatible IBM PC sous forme de fichier. Par conséquent, le clavier est un fichier d'entrée, l'écran et l'imprimante sont des fichiers de sortie et un unité de disque peut servir de fichier d'entrée ou de sortie.

Pour le DOS, chacun de ces attachements physiques est appelé un périphérique. Tous les périphériques de même nature doivent - en interne, au moins - répondre aux mêmes instructions électroniques. Étant donné que tous les périphériques sont conçus pour être électroniquement identiques, les mêmes services DOS communiquant avec un périphérique peuvent également être utilisés pour communiquer avec n'importe quel autre périphérique. C'est pourquoi DOS peut fournir une prise en charge équivalente pour une si grande variété de périphériques, comme les imprimantes matricielles et laser, les unités de disquettes et de disque dur et les moniteurs monochromes et couleur.

Étant donné que tous les périphériques répondent aux mêmes commandes DOS, vous pouvez utiliser les mêmes procédures QuickPascal que vous avez utilisées pour échanger des données avec le clavier et l'écran (Read, ReadLn, Write et WriteLn) pour échanger des informations avec les fichiers disque.

Utilisation de fichiers d'entrée et de sortie standard

Tout d'abord, il existe l'unité Printer contenant un code associant l'identificateur Lst au périphérique LPT1 de votre compatible IBM PC, étant très probablement votre imprimante système. L'utilisation de l'imprimante système devient alors un processus en deux étapes. Tout d'abord, vous incluez la déclaration suivante au début de votre programme :



Uses Printer;

Ensuite, vous incluez Lst comme premier paramètre dans une procédure Write ou WriteLn :



WriteLn('Ce message va vers l''écran');	

WriteLn(Lst,'Ce message va vers l''imprimante');

De la même manière, l'unité System associe automatiquement les identificateurs Input et Output à vos périphériques d'entrée et de sortie standard - en d'autres termes, votre clavier et votre écran, respectivement. D'où l'énoncé suivant :



ReadLn(Input,Value);

est interprété par QuickPascal comme signifiant «Prenez la prochaine entrée du clavier et attribuez-la à l'élément de données nommé Value». La déclaration :



WriteLn(Output,'Bonjour !');

est interprété comme signifiant «Afficher Bonjour ! à l'écran.»

Certains compilateurs Pascal exigent que vous utilisiez les identificateurs d'entrée et de sortie à chaque fois que vous accédez au clavier et à l'écran. Heureusement, le QuickPascal est plus tolérant. Dans QuickPascal, Input est le fichier par défaut pour Read et ReadLn, et Output est le fichier par défaut pour Write et WriteLn. Par conséquent, chaque fois que vous omettez un nom de fichier dans l'une de ces procédures, le QuickPascal insère simplement le fichier par défaut automatiquement.

Comprendre les fichiers logiques et physiques

Le DOS (signifiant Disk Operating System) est responsable de la gestion de toutes les entrées et sorties de fichiers disque. Le DOS prend en charge des détails potentiellement gênants tels que la taille et la configuration de l'unité de disque, si de l'espace libre est disponible ou non sur le disque, et l'emplacement physique du fichier sur le support d'entreposage lui-même. De même, lorsque vous créez ou modifiez un fichier, le DOS garantit que la date et l'heure actuelles (les informations que vous voyez lorsque vous exécutez une commande DIR) sont mises à jour.

En fait, DOS gère si bien ses tâches de gestion de fichiers que le QuickPascal est inconscient de tout sauf des données transférées. Le fichier physique est caché derrière un mur de services DOS. Le QuickPascal donne simplement au système d'exploitation le nom du fichier physique qu'il souhaite utiliser, puis envoie et reçoit des informations. En conséquence, un programme QuickPascal peut se concentrer sur le fichier logique, se composant d'un nom d'identificateur et des données elles-mêmes. En d'autres termes, dans QuickPascal, un fichier logique n'est qu'un autre type de données, et l'utilisation d'un fichier logique est aussi simple que d'inclure l'identificateur du fichier comme premier paramètre dans un Read, ReadLn, Write ou WriteLn déclaration.

Utilisation des fichiers disque dans QuickPascal

Vous pouvez considérer le type de données du fichier comme une séquence de données. (Dans le langage de programmation C, cette séquence est appelée un flux de données.) Comme dans un tableau, chaque composante d'un fichier doit être du même type de données. Et tout comme la déclaration d'un tableau dépend de la nature des données la composant, la déclaration d'un fichier dépend du type de données qu'il entrepose. En particulier, le QuickPascal prend en charge trois types de fichiers logiques, nommés en fonction du type de données qu'ils contiennent :

Un fichier texte contient principalement des lignes de caractères ASCII affichables ou imprimables et des espaces blancs. Une ligne peut être de n'importe quelle longueur, mais elle se termine toujours par un retour chariot et un saut de ligne (#13#10). Un bon exemple de fichier texte est un programme source QuickPascal avec l'extension «.PAS». De même, la plupart des traitements de texte entreposent les documents dans des fichiers texte.
Un fichier typé est constitué exclusivement d'un seul type de données : soit un type de données simple comme un Byte ou un Integer, soit un type de données défini par l'utilisateur comme un enregistrement. Étant donné que chaque composante a la même taille, le QuickPascal peut accéder directement (ou de manière aléatoire) à une composante individuel sans avoir à lire chacun de manière séquentielle depuis le début du fichier.
Un fichier non typé est complètement déstructuré. Il peut contenir n'importe quel type de données sous n'importe quelle forme. Un fichier non typé est généralement appelé fichier binaire car son contenu n'est généralement intelligible que par le processeur lui-même. Vous n'utiliserez probablement pas de fichier non typé à moins que vous ne vouliez déplacer des données en gros blocs. En fait, vous constaterez que la plupart des fichiers non typés sont utilisés par le système d'exploitation lui-même. Par exemple, un fichier exécutable .EXE est un fichier non typé.

De toute évidence, le type de fichier que vous utilisez dépend de la nature des données que vous souhaitez traiter.

Déclarer un identificateur de fichier

Déclarer un identificateur de fichier revient à déclarer n'importe quel autre type de données, bien que chaque type de fichier soit déclaré à sa manière. Vous déclarez un fichier texte avec le mot clef TEXT :



Var

 TextFileID:Text;

Vous déclarez un fichier typé en donnant explicitement son type de données composant. Voici les déclarations de deux fichiers typés :



Type

 EtudiantEnr=Record

  Nom:String[30];

  Cours:String;

  Grade:Word;

 End;

 

Var

 FicheEtudiante:File Of EtudiantEnr;

 FichierDonnees:File Of Real;

Un fichier non typé a la déclaration la plus générale :



Var

 UntypedFileID:File;

Vous pouvez définir n'importe quel nombre d'identificateurs de fichiers dans votre programme. Bien que chaque déclaration puisse être locale ou globale, presque toutes les déclarations de fichiers sont globales.

Spécification du fichier physique

Avant de pouvoir travailler avec un fichier, vous devez utiliser la procédure Assign pour associer votre identificateur de fichier (votre fichier logique) aux données réelles entreposées sur le disque (le fichier physique). La procédure Assign a la même syntaxe pour les trois types de fichiers. Il prend deux paramètres : l'identificateur du fichier et une chaîne de caractères contenant le nom du fichier disque.

Voici quelques instructions d'affectation pour les identificateurs déclarés dans la dernière section :



StrVar:='ENTREPOS.FAX';	

Assign(TextFileID,'QP_DEMO.PAS');

Assign(FicheEtudiant,'C:\BACKUP\ETDINFO.DAT');

Assign(DataFile,StrVar);

Assign(UntypedFileID,ParamStr(1));

Si vous n'incluez pas l'unité de disque et le chemin, le QuickPascal supposera que le fichier réside dans le répertoire actuel.

Ouvrir un fichier

Après avoir donné à DOS le nom du fichier que vous souhaitez utiliser, vous devez physiquement ouvrir le fichier. Ouvrir un fichier signifie dire à DOS comment vous voulez que le fichier soit accessible. Vous avez trois choix, selon le type de fichier que vous déclarez :

Entrée uniquement
Sortie uniquement
Entrée et sortie

Le QuickPascal propose trois procédures différentes pour ouvrir un fichier : Reset, Rewrite et Append. Le fonctionnement de chacun dépend du type de fichier que vous souhaitez utiliser.

Ouvrir un fichier texte

Vous pouvez ouvrir un fichier texte pour l'entrée ou la sortie, mais pas pour les deux opérations en même temps. Voici les trois procédures que vous pouvez utiliser :

Rewrite(TextFileID) ouvre TextFileID et dirige la sortie vers le début du fichier. Si le fichier n'existe pas, Rewrite le crée. Si le fichier existe déjà, Rewrite le supprime d'abord, puis crée un nouveau fichier avec le nom. Dans tous les cas, Rewrite rend un fichier vide disponible pour votre programme.
Append(TextFileID) ouvre TextFileID et dirige la sortie vers la fin du fichier.
Reset(TextFileID) ouvre TextFileID pour l'entrée, en commençant au début du fichier.

Ouvrir un fichier typé

Vous pouvez ouvrir un fichier typé pour l'entrée et la sortie avec les procédures suivantes :

Rewrite(TypedFileID) ouvre TypedFileID pour l'entrée ou la sortie. Si le fichier n'existe pas, Rewrite le crée. Si le fichier existe déjà, Rewrite le supprime d'abord, puis crée un nouveau fichier avec le même nom.
Reset(TypedFileID) ouvre TypedFileID pour l'entrée ou la sortie, en commençant au début du fichier, Reset générera une erreur d'exécution si le fichier n'existe pas.

Étant donné que les éléments de données dans un fichier tapé ne sont pas séparés par des caractères de fin de ligne, vous ne pouvez pas utiliser ReadLn et WriteLn pour l'entrée ou la sortie. Seules les procédures Read et Write sont disponibles. Rappelons que l'identificateur du fichier typé doit apparaître en premier paramètre.

Ouvrir un fichier non typé

Vous pouvez ouvrir un fichier non typé pour l'entrée et la sortie. Les fichiers non typés étant conçus pour traiter des blocs de données plus volumineux, vous ne pourrez pas utiliser les procédures Read et Write. Au lieu de cela, vous devez utiliser l'instruction BlockWrite pour toutes les sorties de fichiers et l'instruction BlockRead pour toutes les entrées de fichiers. Voici les procédures que vous pouvez utiliser pour ouvrir un fichier non typé :

Rewrite(UntypedFileID,BlockSize) ouvre UntypedFileID pour l'entrée ou la sortie. Si le fichier n'existe pas, Rewrite le crée. Si le fichier existe déjà, Rewrite le supprime d'abord, puis crée un nouveau fichier avec le même nom.
Reset(UntypedFileID,BlockSize) ouvre UntypedFileID pour l'entrée ou la sortie, en commençant au début du fichier. Reset générera une erreur d'exécution si le fichier n'existe pas.

Pour Rewrite et Reset, le paramètre BlockSize est facultatif. Cependant, étant donné que BlockRead et BlockWrite ne peuvent transférer que des blocs complets, vous devez sélectionner une taille de bloc se divisant uniformément dans la taille du fichier. Si vous n'êtes pas sûr de la taille du fichier, vous devez définir BlockSize sur 1.

Fermeture d'un fichier

Le QuickPascal ferme automatiquement tous les fichiers ouverts lorsque votre programme se termine. Vous pouvez également utiliser la procédure Close pour fermer un fichier dès que vous avez fini de l'utiliser. Puisque DOS place une limite supérieure sur le nombre de fichiers pouvant être ouverts à tout moment, la fermeture d'un fichier inutilisé est une bonne pratique de programmation.

Si le fichier a été ouvert pour la sortie, Close garantit que toutes les données restantes dans la mémoire tampon du programme sont écrites sur le disque. De plus, Close met à jour l'entrée du répertoire du disque DOS du fichier avec la nouvelle taille de fichier et la date et l'heure actuelles.

Vous pouvez rouvrir un fichier fermé plus tard dans le programme avec un autre Reset, Rewrite ou Append. Étant donné que QuickPascal conserve le lien d'origine entre l'identificateur de fichier et le fichier physique, vous n'avez pas besoin d'effectuer d'autres opérations Assign.

Détecter la fin d'un fichier et la fin d'une ligne

Lorsque vous lisez un fichier, vous ne savez généralement pas combien de composants il contient. Par exemple, vous avez peut-être considérablement modifié un fichier texte source de programme lors de votre dernière session d'édition. Même si vous saviez combien de lignes il contenait à l'origine, combien de lignes contient-il maintenant ?

Dans le monde réel, peu de programmes connaissent à l'avance le nombre de composantes de données entreposés dans un fichier donné. Après tout, un programme de paie ne doit se soucier que du fait qu'un fichier contienne les enregistrements de travail des employés - le nombre d'enregistrements n'a pas d'importance. (Imaginez le recodage et la recompilation de vos programmes simplement parce que vous ne pouvez pas prédire la taille des fichiers qu'ils doivent lire.)

De toute évidence, vous avez besoin d'un moyen de savoir quand vous avez rencontré le dernier composant d'un fichier. Dans QuickPascal, vous pouvez tester cette situation avec la fonction booléenne Eof (fin de fichier). La fonction Eof renvoie TRUE lorsque vous ouvrez un fichier vide en entrée, ou lorsqu'il ne reste plus de composantes à lire.

L'exemple suivant montre un programme affichant le contenu d'un fichier texte à l'écran. Remarquez comment la fonction Eof teste un fichier texte à l'écran. Remarquez comment la fonction Eof teste si le fichier est vide ou non avant que la première ligne ne soit entrée.



Program VoirFich;	

 
Var

 FileIdent:Text;

 FileName:String;

 Info:String[79];

 

BEGIN

 Write('Nom de fichier : ',FileName);

 Assign(FileIdent,FileName);

 Reset(FileIdent);

 While Not Eof(FileIdent)do Begin

   ReadLn(FileIDent,Info);

   WriteLn(Info);

 End;

 Close(FileIdent);

END.

Vous pouvez utiliser Eof avec n'importe quel type de fichier : texte, typé ou non typé. Lorsque vous travaillez avec des fichiers texte, vous pouvez utiliser la fonction SeekEof au lieu de la fonction Eof. La fonction SeekEof renvoie également TRUE lorsqu'il ne reste plus de données dans le fichier. Cependant, SeekEof ignorera tous les caractères d'espacement restants tels que les blancs, les tabulations, les sauts de ligne et les retours chariot. Ainsi, lorsque vous utilisez la fonction SeekEof, votre programme ignore les lignes vides restant à la fin de votre fichier.

De plus, les fichiers texte prennent également en charge les fonctions Eoln et SeekEoln. La fonction Eoln renvoie TRUE lorsque vous avez lu la dernière donnée de la ligne courante. La fonction SeekEoln est comme la fonction Eoln mais il saute les blancs et les tabulations. Par conséquent, l'utilisation de SeekEoln permet à votre programme d'ignorer tout espace vide à la fin d'une ligne.

Vérification des erreurs d'entrée/sortie

Par défaut, toutes les erreurs d'entrée/sortie d'exécution sont fatales. Cependant, vous pouvez désactiver la vérification des erreurs d'entrées/sorties avec la directive du compilateur {$I-} à tout moment. En désactivant la vérification des erreurs d'entrées/sorties, vous désactivez la capacité de QuickPascal à répondre automatiquement à une erreur d'entrée ou de sortie. Au lieu de cela, vous devez utiliser la fonction IOResult pour tester l'état de chaque routine d'entrée et de sortie. Si la routine d'entrée/sortie a réussi, la fonction IOResult renvoie 0 ; sinon, la fonction IOResult renvoie une valeur non nulle correspondant à l'erreur qui s'est produite. Vous pouvez utiliser le résultat de la fonction IOResult pour déterminer l'action corrective la plus appropriée.

Si une erreur se produit alors que la vérification des erreurs d'entrée/sortie est désactivée, le QuickPascal ignorera tous les appels de procédure et de fonction d'entrée/sortie jusqu'à ce que la fonction IOResult soit appelé. Habituellement, l'erreur spécifique peut être déduite du contexte du programme. Par exemple, vous pouvez utiliser la routine suivante pour tester l'existence d'un fichier :



Function FileExists(NomFichier:String):Boolean;

Var

 FichierLocal:File of Byte;

 Rechercher:Word;

Begin

 Assign(FichierLocal,NomFichier);

 {$I-} Reset(FichierLocal);

 Rechercher:=IOResult; {$I+}

 If Rechercher=0 Then FileExists:=True

                 Else FileExists:=False;

 Close(FichierLocal);

End;

De même, une erreur survenant lors de la procédure d'ajout indique généralement un fichier inexistant. Le code suivant teste si le fichier OUTNAME existe. Si tel est le cas, la sortie est dirigée vers la fin du fichier ; sinon, un nouveau fichier est créé :



Program TESTFICH;	

 
Var

 OutName:String;

 FileParam:File Of Byte;

 Finding:Word;

 
BEGIN	

 OutName:='MONFICH.TXT';

 {$I-}

 Assign(FileParam,OutName);

 Finding:=IOResult;

 {$I+}

 If Finding<>0 Then ReWrite(FileParam);

END.

Remarquez comment ces exemples affectent IOResult à une variable, puis testez la valeur de la variable. Cela est dû au fait que l'appel à la fonction IOResult réinitialise l'indicateur d'état d'erreur QuickPascal ; par conséquent, appeler IOResult une deuxième fois renverra toujours 0.

Gestion des répertoires DOS

Lorsque vous exécutez la commande DIR de DOS, vous voyez des informations sur votre système. Par exemple, vous pouvez apprendre le nom, la taille et la date et l'heure de création des fichiers sélectionnés. Vous pouvez également connaître l'unité de disque et le répertoire actuellement actifs, ainsi que la quantité d'espace libre restant sur l'unité de disque.

Demande d'informations sur l'unité de disque

Vous pouvez utiliser la fonction DiskSize pour obtenir l'espace d'entreposage total, en octets, sur un unité de disque spécifié. La fonction DiskFree renvoie le nombre d'octets actuellement disponibles.

Les deux fonctions prennent un seul paramètre pour indiquer l'unité de disque : 1 désigne l'unité de disque A, 2 désigne l'unité de disque B, et ainsi de suite. Une valeur de 0 indique l'unité de disque par défaut actuel. Voici une fonction renvoyant la proportion d'espace disponible (PourcentageDisponible) sur un unité de disque sélectionné :



Program PourDisp;

 
Uses DOS;

 
Function PourcentageDisponible(NumeroDisque:Byte):Real;Begin

 PourcentageDisponible:=DiskFree(NumeroDisque)/DiskSize(NumeroDisque);

End;

 
BEGIN

 WriteLn('Pourcentage disponible de l''unité courante : ',PourcentageDisponible(0),'%');

END.

Les fonctions DiskSize et DiskFree renvoient -1 lorsque vous spécifiez un unité de de disque non valide. Le code suivant montre comment vous pouvez utiliser ce fait pour tester la disponibilité d'un unité de disque :



Program DSTest;	

 
Uses DOS;

 
BEGIN

 If DiskSize(1)=-1 Then Begin

  WriteLn('Unité de disque A: pas prête.');

  WriteLn('SVP inséré l''unité de disquette à formater.');

 End;

END.

Sélection de répertoires

Vous pouvez utiliser la procédure GetDir pour obtenir le répertoire actuellement actif pour n'importe quel unité de disque. La procédure GetDir accepte le numéro d'unité de disque (0 pour la valeur par défaut, 1 pour l'unité de disque A, 2 pour l'unité de disque B,...) et une chaîne de caractères pour contenir le nom du répertoire une fois la procédure terminée :



Procedure ShowDirInfo(DrvNum:Byte);

Var

 CurrDir:String;

 Finding:Word;

Begin

 {$I-}

 GetDir(DrvNum,CurrDir);

 Finding:=IOResult;

 {$I+}

 If Finding=0 Then WriteLn('Unité de disque ',DrvNum,' : ',CurrDir);

End; 

 
BEGIN

 ShowDirInfo(0);

END.

La chaîne de caractères renvoyée par GetDir contient la spécification complète de l'unité de disque et du chemin. Ainsi, l'unité de disque actuel est dans la première position de la chaîne de caractères :



Function GetCurrentDrive:Char;

Var

 CurrDir:String;

 Finding:Word;

Begin

 {$I-}

 GetDir(0,CurrDir);

 Finding:=IOResult;

 {$I+}

 If Finding=0 Then GetCurrentDrive:=CurrDir[1];

End;

 
BEGIN

 WriteLn(GetCurrentDrive);

END.

Le QuickPascal fournit également la procédure ChDir pour modifier l'unité de disque et le répertoire par défaut, la procédure MkDir pour créer un nouveau répertoire et la procédure RmDir pour supprimer un répertoire vide. Ces routines se comportent exactement comme les commandes CD, MD et RD du DOS, respectivement.

Déterminer la taille d'un fichier

Vous pouvez utiliser la fonction FileSize sur des fichiers typés et non typés pour obtenir la taille d'un fichier disque. Dans un fichier typé, FileSize renvoie le nombre de composantes. Dans un fichier non typé, la fonction FileSize renvoie le nombre de blocs. (La taille par défaut d'un bloc est de 128 octets, mais vous pouvez modifier ce nombre en utilisant un paramètre de taille de bloc différent dans la routine Reset ou Rewrite que vous avez utilisée lors de la dernière mise à jour du fichier.)

Évidemment, à moins d'avoir des connaissances spécifiques sur ce que contient un fichier, connaître le nombre de composantes ou de blocs n'est pas très utile. Pour aggraver les choses, FileSize ne fonctionnera pas sur un fichier texte car chaque ligne (la composante de base des informations textuelles) peut varier en longueur.

Vous pouvez contourner ce problème en déclarant qu'un fichier contenant du texte ASCII est un FILE OF BYTE ou un FILE OF CHAR. Cela rend chaque composante long de 1 octet ; par conséquent, le nombre de composantes correspond à la taille du fichier.

Vous pouvez utiliser la routine suivante pour obtenir la taille d'un fichier. Notez que la fonction renvoie -1 si le fichier est introuvable :



Function SizeOfFile(FileName:String):LongInt;

Var

 Handle:File Of Byte;

 Finding:Word;

Begin

 Assign(Handle,FileName);

 {$I-}

 Reset(Handle);

 Finding:=IOResult;

 {$I+}

 If Finding = 0 Then Begin

  SizeOFFile:=FileSize(Handle);

  Close(Handle)

 End

  Else

 SizeOfFile:=-1;

End;

Comprendre l'octet d'attribut

Une information que le DOS entrepose dans le répertoire mais n'affiche pas avec la commande DIR sur les anciennes versions de DOS est l'attribut du fichier. Les attributs sont des caractéristiques de fichier que vous pouvez utiliser pour affiner une recherche. Voici les catégories d'attributs de fichier :

Un fichier en lecture seulement, comme son nom l'indique, ne peut qu'être lu. Vous ne pouvez pas y écrire ou l'effacer.
Un fichier caché n'apparaît pas dans une commande DIR de DOS. La plupart des fichiers cachés contiennent des données utilisées par le système d'exploitation.
Un fichier système, comme un fichier caché, est utilisé par DOS et n'apparaît pas lorsque vous utilisez la commande DIR.
Une entrée de répertoire peut être le nom de volume du disque - c'est-à-dire l'étiquette que vous avez donnée au disque lorsque vous l'avez formaté à l'origine.
Une entrée de répertoire peut être le nom d'un sous-répertoire.

Le DOS entrepose chacun de ces attributs sous la forme d'un seul bit dans l'octet d'attribut du fichier. La disposition de ces bits est illustrée dans le tableau suivant :

Bits	Description
6 et 7	Non-utilisé
5	Archive
4	Répertoire
3	Étiquette de volume
2	Système
1	Caché
0	Lecture seulement

Les attributs ne sont pas mutuellement exclusifs. Par exemple, un fichier caché peut également être en lecture seulement. L'octet d'attribut inclut également l'état d'archivage du fichier. L'octet d'attribut inclut également l'état d'archivage du fichier. Le DOS définit le bit d'archive chaque fois qu'il modifie la date ou l'horodatage du fichier - en d'autres termes, chaque fois qu'un fichier est créé ou modifié.

La commande BACKUP de DOS utilise le bit d'archive pour identifier les changements dans le répertoire. Étant donné que BACKUP réinitialise toujours le bit à 0 après la copie du fichier sur le disque, les exécutions ultérieures de la commande BACKUP peuvent ignorer les fichiers n'ayant pas changé.

Le QuickPascal a prédéfini plusieurs constantes que vous pouvez utiliser lorsque vous accédez à un octet d'attribut :

Constante prédéfinie	Valeur	Bits affecté
ReadOnly	$01	0
Hidden	$02	1
SysFile	$04	2
VolumeID	$08	3
Directory	$10	4
Archive	$20	5
AnyFile	$3F	0 à 5

N'oubliez pas que plusieurs bits peuvent être définis en même temps. Par conséquent, un fichier caché avec un état en lecture seulement peut être représenté comme :



Hidden + ReadOnly

De même, tous les fichiers, à l'exception de ceux en lecture seulement, peuvent être représentés avec :



AnyFile - ReadOnly

Accéder à une entrée du répertoire

Vous pouvez utiliser les procédures FindFirst et FindNext pour examiner un répertoire et identifier tous les fichiers correspondant à un masque de fichier et à un ensemble d'attributs spécifiques. Utilisez FindFirst pour localiser le premier fichier correspondant à ces caractéristiques ; puis utilisez FindNext pour localiser chaque correspondance suivante. La procédure FindFirst accepte trois paramètres :

Une variable de chaîne de caractères contenant un masque de noms de fichiers. Vous pouvez utiliser ici les deux caractères génériques DOS - l'astérisque (*) et le point d'interrogation (?). Par exemple, le masque *.PAS indique à FindFirst de localiser tous les fichiers dans le répertoire actuel contenant le texte source QuickPascal. Une spécification complète de l'unité de disque et du répertoire peut également être incluse dans ce champ.
Un octet d'attribut à la constante prédéfinie AnyFile. Lorsque vous utilisez FindNext plus tard, vous pouvez filtrer les entrées que vous ne voulez pas.
Une variable déclarée comme un enregistrement de type prédéclaré SearchRec. Cette variable contient les résultats de chaque recherche. Vous pouvez l'examiner pour obtenir des informations sur chaque fichier et vous pouvez l'utiliser comme paramètre pour transmettre des informations entre les routines FindFirst et FindNext.

Vous devez examiner la variable DosError pour surveiller la progression des procédures FindFirst et FindNext. Deux erreurs possibles peuvent découler de FindFirst : une erreur de 2 indique qu'aucun fichier correspondant n'a été trouvé et une erreur de 18 indique qu'il ne reste plus de fichiers.

De même, lorsque vous utilisez FindNext, une erreur de 18 signale qu'aucun fichier supplémentaire ne correspond à votre spécification d'origine. Voici la déclaration de SearchRec de l'unité DOS :



Type	

 SearchRec=Record

  Fill:Array[1..21]of Byte;

  Attr:Byte;

  Time:LongInt;

  Size:LongInt;

  Name:String[12];

 End;

Vous pouvez librement examiner n'importe quel champ de cet enregistrement. Par exemple, Name contient le nom du fichier DOS, y compris la période et l'extension, mais pas l'unité de disque ou le chemin. Le champ Size est la taille du fichier en octets. Le champ Attr est l'octet d'attribut. Le champ Time est la date et l'heure du fichier. Le seul champ ne contenant pas d'informations utiles est le champ Fill de 21 octets ; il contient des données significatives uniquement pour le DOS lui-même.

L'exemple suivant montre un programme utilisant FindFirst et FindNext pour afficher les fichiers cachés et en lecture seulement dans le répertoire racine de votre disque dur :



Program LitReper;	

 
Uses DOS;

Const

 AttrMatch=Hidden+SysFile;

Var

 Result:SearchRec;

BEGIN

 FindFirst('C:\*.*',AnyFile,Result);

 While DosError=0 do Begin

  With Result Do If Attr and AttrMatch <> 0 Then WriteLn(Name:12,Size:7,' octets');

  FindNext(Result);

 End;

END.

Utilisation du champ Time

Le champ Time dans SearchRec contient la date et l'heure du fichier sous forme compressée. Vous pouvez convertir le champ en champs individuels (et plus intelligibles) avec la procédure UnpackTime. La procédure UnpackTime prend deux paramètres : le champ Time de SearchRec lui-même, et une variable déclarée comme l'enregistrement prédéclaré DateTime :



Type

 DateTime=Record

   Year,Month,Day,Hour,Min,Sec:Word;

 End;

Si vous avez un fichier en tête, vous pouvez accéder directement à la date et à l'horodatage du fichier avec la procédure GetFTime. De même, vous pouvez modifier la date et l'heure d'un fichier avec SetFTime. La procédure suivante affiche la date et l'heure de n'importe quel fichier :



Procedure ShowFileDate(FileName:String);

Var

 LocalFileVar:File;

 Finding:Word;

 TimeStamp:LongInt;

 TimeRec:DateTime;

Begin

 Assign(LocalFileVar,FileName);

 {$I-}

 Reset(LocalFileVar);

 Finding:=IOResult;

 {$I+}

 If Finding<>0 Then WriteLn('Fichier introuvable')

  Else

 Begin

  GetFTime(LocalFileVar,TimeStamp);

  UnpackTime(TimeStamp,TimeRec);

  With TimeRec do WriteLn('Crée le ',Year,'-',Month,'-',Day);

  Close(LocalFileVAr);

 End;

End;

Vous pouvez également modifier l'horodatage d'un fichier via le processus en deux étapes suivant :

Utilisez la procédure PackTime pour créer un champ de temps LongInt compacté.
Insérez le champ heure dans le répertoire en utilisant la procédure SetFTime.

Modification de l'octet d'attribut

Vous pouvez accéder et modifier directement l'octet d'attribut d'un fichier avec les procédures GetFAttr et SetFAttr. Les deux procédures prennent deux paramètres : un identificateur de fichier attribué mais non ouvert et un paramètre de la taille d'un mot contenant l'octet d'attribut. Le programme suivant indique si un fichier a été archivé ou non :



Program BackedUp;

 
Uses DOS;

 
Var

 FileName:String;

 FileVar:File;

 AttrByte:Word;

 

BEGIN

 FileName:=ParamStr(1);

 Assign(FileVar,FileName);

 GetFAttr(FileVar,AttrByte);

 If DosError<>0 Then WriteLn('Fichier introuvable') Else

 If AttrByte and Archive=0 Then WriteLn(FileName,' est une copie de sauvegarde')

                           Else WriteLn(FileName,' n''est pas une copie de sauvegarde');

  

END.

Renommer et effacer un fichier

Le QuickPascal fournit également deux routines spéciales de gestion de fichiers. Vous pouvez supprimer un fichier avec Erase et vous pouvez modifier le nom d'un fichier avec Rename. Les deux procédures fonctionnent avec un fichier ayant été attribué mais pas encore ouvert :



Assign(PremierFichier,'SUPPRIME.DAT');

Erase(PremierFichier);

Assign(DeuxiemeFichier,'ORIGINAL.DAT');

Assign(DeuxiemeFichier,'NOUVEAU.DAT');

N'oubliez pas que vous ne pourrez pas renommer ou effacer un fichier si le bit en lecture seulement dans son octet d'attribut est défini.

Développer le nom d'un fichier

Vous pouvez utiliser la fonction FExpand pour développer un nom de fichier en un nom de fichier complet en utilisant l'unité de disque et le répertoire actuels comme valeurs par défaut. Les exemples suivants supposent que le répertoire actuel est C:\QP\SOURCE :

FileName	FExpand(FileName)
SAMPLE.PAS	C:\QP\SOURCE\SAMPLE.PAS
SAMPLE.*	C:\QP\SOURCE\SAMPLE.*
.\SAMPLE.EXT	C:\QP\SOURCE\SAMPLE.EXT
..\SAMPLE.EXT	C:\SOURCE\SAMPLE.EXT
..\*.EXT	C:\SOURCE\.EXT
A:.	A:\.
C:\UP\CODE\SAMPLE.EXT	C:\UP\CODE\SAMPLE.EXT

Recherche d'un fichier dans plusieurs répertoires

Toutes les routines discutées jusqu'à présent supposent que le fichier auquel vous souhaitez accéder se trouve dans le répertoire actuel. Malheureusement, ce n'est pas toujours vrai. En fait, il est assez courant d'entreposer votre texte source, votre code exécutable et vos données dans des répertoires séparés.

Le DOS lui-même suit un tel processus. Par exemple, chaque fois que vous exécutez un programme, DOS recherche d'abord le programme dans le répertoire courant. Si le programme ne se trouve pas dans ce répertoire, le DOS recherche chaque répertoire dans la commande PATH de votre système.

De même, vous pouvez utiliser la fonction FSearch pour rechercher un fichier dans plusieurs répertoires. La fonction FSearch prend comme ses deux paramètres une chaîne de caractères contenant le nom du fichier que vous voulez trouver, et une chaîne de caractères contenant le nom du fichier que vous voulez trouver, et une chaîne de caractères contenant les répertoires cibles. Si FSearch trouve le fichier dans l'un des répertoires, il renvoie, il renvoie le nom de fichier complet ; sinon, il renvoie une chaîne de caractères nulle.

Si vous souhaitez rechercher le fichier dans les mêmes répertoires que dans la chaîne de caractères PATH de votre système, appelez GetEnv('PATH') et utilisez son résultat comme paramètre de répertoire lorsque vous appelez FSearch. Le code suivant montre comment vous pouvez rechercher FileName dans les répertoires du chemin de votre système :



Program SPath;	

 
Uses DOS;

 
Var

 FileStr,FileName:String;	

BEGIN	

 FileName:=ParamStr(1);

 FileStr:=FSearch(FileName,GetEnv('PATH'));	

 If Length(FileStr) = 0 Then WriteLn('Le fichier ',FileName,' est introuvable')

  Else

 Begin

  { Assigne et ouvre le fichier } 

 End;

END.

Demander les composantes d'un nom de fichier

Enfin, vous pouvez utiliser la procédure FSplit de QuickPascal pour diviser un nom de fichier complet en chaînes de caractères de répertoire, de nom et d'extension distinctes. Supposons que vous déclariez les variables suivantes :



Var               { Provient de l'unité DOS }

 PathVar:PathStr; { Chemin complet de fichier      STRING[79] }

 DirVar:DirStr;   { Unité de disque et répertoire  STRING[67] }

 NameVar:NameStr; { Nom de fichier                 STRING[8] }

 ExtVar:ExtStr;   { Extension de fichier           STRING[4] }

Supposons ensuite que vous exécutiez ces instructions :



PathVar:='C:\QP\SOURCE\PROGRAM1.PAS';

FSplit(PathVar,DirVar,NameVar,ExtVar);

À ce stade, DirVar contiendra C:\QP\SOURCE, NameVar contiendra PROGRAM1 et ExtVar contiendra .PAS. Vous pouvez utiliser FSplit chaque fois que vous devez créer un nom de fichier basé sur un autre nom de fichier. Par exemple, le code suivant demande à l'utilisateur le nom d'un fichier ; TEMP et .DAT seront utilisés comme valeurs par défaut pour le nom et l'extension :



WriteLn('Nom du programme (TEMP.DAT) :');	

ReadLn(PathVar);

FSplit(PathVar,DirVar,NameVar,ExtVar);

If NameVar=''Then NameVar:='TEMP';

If ExtVar=''Then ExtVar:='.DAT';

PathVar:=DirVar+NameVar+ExtVar;

WriteLn('Nous allons utiliser ce fichier : ',PathVar);

Dernière mise à jour : Mercredi, le 15 décembre 2021

Section courante

A propos

Section administrative du site