{ File: listerw.pas }

{ Scopo: operazioni su liste collegate semplici:
         - lettura da file e stampa su file, usando due procedura di supporto
           per la lettura e la stampa di un elemento
}

{ Richiede le seguenti definizioni preliminari:

  type
    TipoElemLista   = ...;
    TipoLista       = ^TipoRecordLista;
    TipoRecordLista = record
                        info : TipoElemLista;
                        next : TipoLista
                      end;

    TipoFileLista = ...;

  procedure StampaElemento (var fi: TipoFileLista; elem: TipoElemLista);
  begin
    ...
  end;

  procedure LeggiElemento (var fi: TipoFileLista; var elem: TipoElemLista);
  begin
    ...
  end;

  function LetturaTerminata (var fi: TipoFileLista): boolean;
  begin
    ...
  end;

}


procedure LeggiLista (nomefile: string; var lis: TipoLista);
{ Restituisce in lis una lista i cui elementi vengono letti dal file di nome
  nomefile.  Chiama LeggiElemento per la lettura di un elemento.
  La lettura termina quando LetturaTerminata restituisce TRUE.
  L'ordine degli elementi nella lista e` lo stesso che nel file. }
var
  paux     : TipoLista;
  datafile : TipoFileLista;
begin
  assign(datafile, nomefile); { associazione tra file logico e file fisico }
  reset(datafile);            { apertura del file in lettura e posizionameno
                                all'inizio }

  { creazione del record generatore }
  new(lis);
  paux := lis;

  { lettura della lista }
  while (not LetturaTerminata(datafile)) do
  begin                { allocazione del record e lettura del nuovo elemento }
    new(paux^.next);
    paux := paux^.next;
    LeggiElemento(datafile, paux^.info)
  end;
  paux^.next := NIL;   { chiusura della lista }

  { cancellazione del record generatore }
  paux := lis;
  lis := lis^.next;
  dispose(paux);

  close(datafile)      { chiusura del file }
end; { LeggiLista }


procedure ScriviLista (nomefile: string; lis: TipoLista);
{ Scrive gli elementi della lista lis sul file di nome nomefile.
  Chiama ScriviElemento per la scrittura di un elemento.
  Il precedente contenuto del file va perduto. }
var
  datafile : TipoFileLista;
begin
  assign(datafile, nomefile);   { associazione tra file logico e file fisico }
  rewrite(datafile);            { apertura del file in scrittura e
                                  posizionamento all'inizio }
  { scrittura della lista }
  while lis <> NIL do
  begin
    ScriviElemento(datafile, lis^.info);
    lis := lis^.next
  end;
  close(datafile)               { chiusura del file }
end; { ScriviLista }


procedure LeggiListaCorr (var datafile: TipoFileLista; var lis: TipoLista);
{ Restituisce in lis una lista i cui elementi vengono letti dal file datafile,
  a partire dalla posizione corrente.
  Chiama LeggiElemento per la lettura di un elemento.
  La lettura termina quando LetturaTerminata restituisce TRUE.
  L'ordine degli elementi nella lista e` lo stesso che nel file. }
var
  paux : TipoLista;
begin
  new(lis);
  paux := lis;
  while (not LetturaTerminata(datafile)) do
  begin
    new(paux^.next);
    paux := paux^.next;
    LeggiElemento(datafile, paux^.info)
  end;
  paux^.next := NIL;
  paux := lis;
  lis := lis^.next;
  dispose(paux)
end; { LeggiListaCorr }


procedure ScriviListaCorr (var datafile: TipoFileLista; lis: TipoLista);
{ Scrive gli elementi della lista lis sul file datafile a partire dalla
  posizione corrente.
  Chiama ScriviElemento per la scrittura di un elemento. }
begin
  while lis <> NIL do
  begin
    ScriviElemento(datafile, lis^.info);
    lis := lis^.next
  end
end; { ScriviListaCorr }