Italian community of Lazarus and Free Pascal

Vediamo un po' di capire come sono strutturati i file e come si riescono a gestire in Lazarus....

Un po' di teoria:
Un file non è altro che una sequenza di byte memorizzata su un supporto di massa, puo' essere strutturato con record di dimensione fissa, variabile, mista o solamente come archivio informazioni; quasi tutti i file con estenzione conosciuta (txt, jpg, doc, pdf, exe, ...) sono strutturati con una parte a record fissa ed una parte come contenitore dati.

Si vabbè ma che significa dimensione fissa, variabile e mista:
I file con record a dimensione fissa sono composti da una sequenza di byte (sempre quella) che corrisponde ad un pacchetto informazioni.
In Lazarus l'accesso a questi tipi di file è reso immediato in quanto il compilatore gestisce i puntatori di salto all'interno del file in maniera automatica, in base alla dimensione della struttura record che lo compone.
I file a dimensione variabile o mista sono composti da una serie di strutture di dimensioni differenti, l'accesso a questi è dato attraverso librerie specifiche di gestione (come quelle di caricamento immagini o quelle di gestione dei file di testo)

Esempio di file con struttura variabile:
Il file di testo è l'esempio più eclatante di file a struttura variabile. E composto da una sequenza ordinata di caratteri e deve sottostare solamente ad una regola: la linea termina con la coppia di caratteri Return (13) e LineFeed (10) in Windows o solamente con LineFeed sotto Linux
Per la gestione di questi tipi di file Lazarus ci viene in aiuto con l'utilizzo del tipo TextFile; se un file è identificato in questo modo è Lazarus che si occupa di controllare i caratteri di fine linea ed è sempre lui a gestire i salti.

Bene, dopo la teoria, la pratica:

Funzioni di base per la gestione dei file

AssignFile(File, Nome)
Serve ad assegnare un determinato nome file alla mia variabile

Esempio: AssignFile(F, 'C:\Temp\Dati.dat') : Assegna alla variabie F il file memorizzato in 'C:\Temp\Dati.dat'

Reset(File, Dimensione)
Apre un file in lettura/scrittura e mette il puntatore all'inizio
note:
     .Nei file tipizzati o di testo il campo dimensione non deve essere inserito
     .Nei file identificati solamente come File la dimesione deve essere impostata
     .Nei file di testo apre il file solamente in lettura
     .Se il file non esiste viene generata un'eccezione

Esempio: Reset(F)

Rewrite(File)
Come reset ma se il file esiste lo cancella e, se non esiste, lo crea

Esempio: Rewrite(F)

Append(File)
Apre un file di testo in scrittura e si pone alla fine dello stesso

Esempio: Append(F)

Read(File, Dato)
Legge la struttura record Dato dal file partendo dalla posizione attuale ed incrementa il puntatore

Esempio: Read(F, Rec)

ReadLn(File, Stringa)
Legge una linea da un file di testo e si posiziana sulla successiva

Esempio: ReadLn(F, Stringa)

Write(File, Dato)
Scrive la struttura Dato nel file alla posizione attuale e sposta il puntatore a +1

Esempio: Write(F, Rec)

WriteLn(File, Stringa)
Aggiunge una linea al file di testo

Esempio: WriteLn('F, 'Linea numero x');

Seek(File, Posizione)
Sposta il puntatore attuale del file alla posizione Posizione
Nota: il primo puntatore è 0

Esempio: Seek(F, 12)

CloseFile(File)
Chiude il file

Esempio: CloseFile(F)

Eof(File)
Ritorna se siamo giunti alla fine del file

Esempio: If Eof(F) Then Messaggio := 'Fine File';

FileSize(File)
Ritorna il numero di record presenti all'interno del file

Esempio: Dimensione := FileSize(F);

FilePos(File)
Ritorna la posizione corrente al file

Esempio: Corrente := FilePos(F)

BlockRead(File, Dato, NumByte, Risultato)
Legge, partendo dalla posizione attuale del file, NumByte caratteri e li memorizza nella variabile Dato.
Se Risultato è passato ritorna il numero di caratteri realmente letti
Se Risultato non è passato ed il numero di caratteri letti e minore di quanto aspettato viene generata un'accezione

Esempio: BlockRead(F, Data, SizeOf(Data), NumLetti)

BlockWrite(File, Dato, NumByte, Risultato)
Scrive, partendo dalla posizione attuale del file, NumByte caratteri prelevati dalla variabile Dato.
Se Risultato è passato ritorna il numero di caratteri realmente scritti
Se Risultato non è passato ed il numero di caratteri scritti e minore di quanto aspettato viene generata un'accezione

Esempio: BlockWrite(F, Data, SizeOf(Data), NumScritti)

FileExists(NomeFile)
Ritorna se un determinato file è presente sul supporto

Esempio: If Not FileExists('C:\Pippo.txt') Then Exit;

DeleteFile(NomeFile)
Cancella un file dal supporto

Esempio: If FileExists('C:\Pippo.txt') Then DeleteFile('C:\Pippo.txt');

RenameFile(NomeFile, NomeNuovo)
Rinomina un file

Esempio: RenameFile('C:\Pippo.txt', 'C:\Pluto.txt');

FileGetAttr(NomeFile)
Ritornano gli attributi del file (sistema, nascosto, sola lettura, ...)

Esempio: If (FileGetAttr('C:\Pippo.txt') And faReadOnly) <> 0 Then Messaggio := 'File di sola lettura';

FileSetAttr(NomeFile, Attributi)
Modifica gli attributi del file

Esempio: FileSetAttr('C:\Pippo.txt', faReadOnly or faSysFile);

Gestire file con record a dimensione fissa

Per prima cosa dobbiamo create un tipo che identifichi la nostra struttura (nota che in una struttura per file le stringhe DEVONO avere dimensione prefissata)

Type
  MioRecord = Record
                Nome      : String[30];
                Eta       : Byte;
                Stipendio : Integer;
              End;
             
Abbiamo creato la nostra prima struttura che ci dice che i primi 30+1 byte identificano i caratteri di una stringa contenuta nel campo Nome (uno in più per la lunghezza), il byte che segue identifica il campo eta e gli ultimi due identificano il campo stipendio.

Var
  F : File of MioRecord;
  R : MioRecord;
 
con questa dichiarazione abbiamo detto che la variabile F è il gestore di file con strutture record uguali a MioRecord e la variabile R è una struttura di tipo MioRecord

AssignFile(F, 'C:\Pippo.dat');

ora abbiamo detto al compilatore che F deve puntare al file che è o sarà memorizzato in 'C:\Pippo.dat'

If FileExists('C:\Pippo.dat')
Then
  Reset(F)
Else
  Rewrite(F);
 
per aprirlo caccciamo un controllo iniziale, ovvero se esiste lo apriamo normalmente altrimenti lo creiamo

While not Eof(F) Do Read(F, R)

questo è un ciclo di lettura dalla posizione corrente (se lo abbiamo appena aperto è la 0) alla fine del file

se vogliamo leggere un record ad una posizione specifica basta fare

Seek(F, Posizione);
Read(F, R);

idem per scriverlo

Seek(F, Posizione);
Write(F, R);

Gestire file di testo

Questa è la gestione più semplice in assoluto anche se ha alcune limitazioni:
1) Non si possono eseguire salti a posizioni prefissate
2) Non si puo' sapere a priori quante linee contiene
3) Si deve decidere all'inizio se leggere o aggiungere linee

comunque per prima cosa dichiariamo la nostra variabile

Var
  F : TextFile;
 
ora lo apriamo in lettura e leggiamo le linee

AssignFile(F, 'C:\Pippo.txt');
Reset(F);

While Not EOF(F) Do ReadLn(F, Stringa);

facile facile, unica cosa notate il ReadLn al posto del Read usato per i file tipizzati

atro esempio: lo apriamo in scrittura ed aggiungiamo alcune linee

AssignFile(F, 'C:\Pippo.txt');
Append(F);

WriteLn(F, 'Penultima riga');
WriteLn(F, 'Ultima riga');

facile no?

Ora complichiamoci la vita con i file a dimensione variabile.

Mettiamo che il nostro file abbia la prima struttura come questa:

Type
  Header = Record
             Identificativo : Byte;
             Versione       : Integer;
           End;
          
la seconda cosi':

Type
  Intestata = Record
                Nome    : String[10];
                Cognome : String[30];
              End;
             
La terza non è altro che una word che identifica il numero di byte che seguono

quindi il mio file sarà

!------------------------!
!         Header         !
!------------------------!
!        Intestata       !
!------------------------!
!          Word          !
!------------------------!
!       ...........      !
!                  !
!       ...........      !
!------------------------!

bene, dopo aver dichiarato le strutture andiamo a gestire il file

Var
  F      : File;         // Variabile di gestione file
  RH     : Header;       // Struttura Header
  RI     : Intestata;    // Struttura Intestata
  Numero : Word;         // Numero di byte da leggere
  Dato   : Byte;         // Singolo byte letto 
  Conta  : Word;         // Contatore di lettura
Begin
  // ------------------------------------------------------
  // Assegnazione file
  // ------------------------------------------------------
  AssignFile(F, 'C:\Pippo.dat');
 
  // ------------------------------------------------------
  // Apertura file impostando la lunghezza record ad 1
  // ------------------------------------------------------
  Reset(F, 1);
 
  // ------------------------------------------------------
  // Lettura della struttura Header
  // ------------------------------------------------------
  BlockRead(F, RH, SizeOf(RH));
 
  // ------------------------------------------------------
  // Lettura della struttura Intestata
  // ------------------------------------------------------
  BlockRead(F, RI, SizeOf(RI));
 
  // ------------------------------------------------------
  // Lettura del numero di byte da leggere
  // ------------------------------------------------------
  BlockRead(F, Numero, SizeOf(Numero));
 
  // ------------------------------------------------------
  // Lettura di tutti i byte validi
  // ------------------------------------------------------
  For Conta := 1 To Numero Do BlockRead(F, Dato, SizeOf(Dato));
 
  // ------------------------------------------------------
  // Chiusura del file
  // ------------------------------------------------------
  CloseFile(F);
End;

Per ultimo, ma non meno importante, gestiamo i file con strutture record diffferenti ma dimensione fissa.

mettiamo che abbiamo un file che vogliamo strutturare cosi':

abbiamo una struttura di anagrafica (nome, cognome, eta', e similari) ma, se è un adulto la struttura che segue è composta da una serie di dati sull'abitazione, mentre se è un minore la struttura che segue è una serie di dati sui suoi giocattoli.
Potremmo gestirla come nel caso di file con dimensioni variabili ma ci complicheremmo la vita, allora il pascal ci aiuta con un piccolo artifizio:

Dichiariamo le strutture dati primarie:

Type
  Anagrafica = Record
                 Nome    : String[30];
                 Cognome : String[30];
                 Eta     : Byte;
               End;

  Adulto = Record
             Indirizzo : String[60];
             Civico    : Byte;
             Telefono  : String[20];
           End;
          
  Bambino = Record
              NumeroGiocattoli    : Integeger;
              GiocattoloPreferito : String[50];
            End;
           
bene ed ora dichiariamo il record per l'accesso al file

Type
  MioRecord = Record
                Dati : Anagrafica;
               
                Case Integer Of
                     0 : (Abitazione : Adulto);
                     1 : (Giochi : Bambino);
              End;
             
notate il Case nella dichiarazione? Questo dice al compilatore che MioRecord puo' essere cosi'

Record
  Dati       : Anagrafica;
  Abitazione : Adulto;
End

oppure cosi'

Record
  Dati   : Anagrafica;
  Giochi : Adulto;
End

tenete presente che la dimensione reale della struttura dati sarà pari alla combinazione piu' grande.

Con questa tecnica la gestione è identica a quella dei file con record a dimensione fissa ma si possono avere informazioni differenti a seconda del caso

// ------------------------------------------------------
// Assegnazione ed apertura
// ------------------------------------------------------
AssignFile(F, 'C:\Pippo.dat');
Reset(F);

// ------------------------------------------------------
// Posizionamento all'interno del file
// ------------------------------------------------------
Seek(F, Posizione);

// ------------------------------------------------------
// Lettura e scrittura record
// ------------------------------------------------------
Read(F, Rec);
Write(F, Rec);

l'unica cosa che spettta a noi è l'accesso alla struttura dati esatta a seconda del caso

// ------------------------------------------------------
// Lettura record
// ------------------------------------------------------
Read(F, Rec);

// ------------------------------------------------------
// Esempio per dati anagrafica
// ------------------------------------------------------
Inserisci_Anagrafica(Rec.Dati);

// ------------------------------------------------------
// Controllo se minorenne ed inserimento dati specifici
// ------------------------------------------------------
If Rec.Dati.Eta < 18
Then
  Inserisci_Giochi(Rec.Giochi)
Else
  Inserisci_Abitazione(Rec.Abitazione);
 
// ------------------------------------------------------
// Scrittura record
// ------------------------------------------------------
Write(F, Rec);

Conclusioni:

Sbizzarritevi con la fantasia e create librerie di accesso a qualsiasi tipo di file - tutto è possibile -