{ File: eso2-1.pas }

{ Scopo: primo esercizio della seconda simulazione di una prova di esonero }

program Problema1;
{ Legge due liste di interi da due file e stampa gli interi comuni ai due file
  su standard output. }

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

var
  lis1, lis2, ris : TipoLista;
  nomefile        : string[12];

function EsisteInLista (lis: TipoLista; elem: TipoElemLista): boolean;
{ Restituisce TRUE se l'elemento elem compare nella lista lis,
  FALSE altrimenti. }

var
  trovato : boolean; { indica se l'elemento e` stato trovato }

begin
  trovato := FALSE;
  while (lis <> NIL) and (not trovato) do
    if lis^.info = elem then
      trovato := TRUE       { forza l'uscita dal ciclo }
    else
      lis := lis^.next;
  EsisteInLista := trovato
end; { EsisteInLista }

{*****************************************************************}
{*****************************************************************}
{*** NB la procedura Esercizio1 va messa nel file SOLUZ1.PAS *****}
{*****************************************************************}
{*****************************************************************}

{$I SOLUZ1.PAS}   {Inclusione del file con la procedura Esercizio1}



procedure LeggiLista (nomefile: string; var lis: TipoLista);
{ Restituisce in lis una lista i cui elementi vengono letti dal
  file di nome nomefile.
  L'ordine degli elementi nella lista e` lo stesso che nel file. }

var
  paux     : TipoLista;
  datafile : text;

begin
  assign(datafile, nomefile);
  reset(datafile);
  new(lis);
  paux := lis;
  while not eof(datafile) do
  begin
    new(paux^.next);
    paux := paux^.next;
    read(datafile, paux^.info)
  end;
  paux^.next := NIL;
  paux := lis;
  lis := lis^.next;
  dispose(paux);
  close(datafile)
end; { LeggiLista }

procedure StampaLista (lis: TipoLista);
{ Stampa gli elementi della lista lis in output. }

begin
  while lis <> NIL do
  begin
    write(lis^.info:4);
    lis := lis^.next
  end;
  writeln;
end; { StampaLista }

procedure CancellaLista (var lis: TipoLista);
{ Pone lis uguale alla lista vuota e rende disponibile la memoria occupata.
  Versione iterativa. }

var
   paux : TipoLista;

begin
   while lis <> NIL do
   begin
     paux := lis;
     lis := lis^.next;
     dispose(paux)
   end
 end; { CancellaLista }


 begin { Problema1 }
   writeln;
   writeln('--- Inizio programma ---');
   writeln;
   writeln('Memora disponibile all''inizio del programma :', memavail);
   writeln;
   write('Nome primo file contenente una sequenza di interi? ');
   readln(nomefile);
   LeggiLista(nomefile, lis1);
   writeln('Prima lista letta:');
   StampaLista(lis1);
   write('Nome secondo file contenente una sequenza di interi? ');
   readln(nomefile);
   LeggiLista(nomefile, lis2);
   writeln('Seconda lista letta:');
   StampaLista(lis2);
   writeln;
   writeln('CHIAMATA procedura Esercizio1');

{***************************************}

  Esercizio1(lis1, lis2, ris);

{***************************************}

  writeln('Lista con gli interi comuni ai due file');
  StampaLista(ris);
  CancellaLista(lis1);
  CancellaLista(lis2);
  CancellaLista(ris);
  writeln;
  writeln('Memora disponibile alla fine del programma :', memavail);
  writeln;
  writeln('--- Fine programma, premere return ---');
  readln;
end. { Problema1 }