{ File: filestrg.pas }

program StringheDaFile;
{ Legge da un file text una sequenza di stringhe, considerando solo
  i caratteri alfabetici (maiuscoli e minuscoli).
  Stampa su video le parole lette e le corrispondenti parole maiuscole,
  scaricando in un file testo di output le parole in forma maiuscola.
  Poi stampa il file di input cosi' com'e' (cioe' anche con gli eventuali
  caratteri non alfabetici, e stampa il file di output. }

const
  DIM = 30;

type
  parola = packed array [1..DIM] of char;

var
  p      : parola;
  f1, f2 : text;


  procedure LeggiStringa (var filein: text; var par: parola);
  var
    ch: char;     { carattere per leggere i caratteri della parola dal file }

    i, 	          { indice per le lettere della parola letta }
    j : integer;  { indice per mettere gli spazi bianchi in fondo alla parola }


    function Lettera (c: char): boolean;
    begin
      Lettera := ((c >= 'a') and (c <= 'z')) or ((c >= 'A') and (c <= 'Z'));
    end; { Lettera }

  begin { LeggiStringa }
    i := 0;		{nessuna lettera assegnata ancora}

    { (1)
      Legge tutti i caratteri non lettera che trova.
      Si ferma quando in ch c'e' un carattere o il file e' finito. }

    if not eof(filein) then
      repeat
        read(filein, ch);
      until Lettera(ch) or eof(filein);


    { (2)
      Se in ch c'e' gia' un carattere lo assegna alla prima componente del
      vettore e aggiorna i. }
    if Lettera(ch) then
    begin
      i := 1;
      par[i] := ch;
    end;

    { Ora se il file non e' finito si leggono i caratteri successivi della
      parola }
    if not eof(filein) then
      repeat
        read(filein, ch);
        i := i + 1;
        par[i] := ch;
      until (not Lettera(ch)) or eof(filein);

    { (3)
      par[i] (ch) e' l'ultimo carattere assegnato. Se era un carattere non
      alfabetico, da lui alla fine dell'array par dobbiamo mettere spazi
      bianchi, senno' dobbiamo mettere spazi bianchi dal successivo in poi. }
    if i = 0 then
      for j := i + 1 to DIM do par[j] := ' '
    else
      for j := i to DIM do par[j] := ' ';

  end; { LeggiStringa }


  function LMaiuscola (l: char): char;
  { l deve essere una lettera.
    Se vale ( l >= 'a' ) and ( l <= 'z' ), allora l e ' minuscola e si deve
    calcolare il codice della corrispondente maiuscola,
    senno' si restituisce l stessa. }

  begin { LMaiuscola }
    if (l >= 'a') and (l <= 'z') then
      LMaiuscola := chr(ord(l) + ord('A') - ord('a'))
    else
      LMaiuscola := l
  end; { LMaiuscola }


  procedure SMaiuscola (var s: parola);
  var
    ch : char;
    i  : integer;
  begin { SMaiuscola }
    for i := 1 to DIM do
    begin
      ch := s[i];
      s[i] := LMaiuscola(ch)
    end
  end; { SMaiuscola }


  procedure StampaFile (var f: text);
  { Stampa il file f. Esegue anche il reset del file, prima di scandirlo. }
  var
    ch : char;
  begin
    reset(f);
    writeln('--- inizio file ---');
    while not eof(f) do
    begin
      read(f, ch);
      write(ch);
    end;
    writeln;
    writeln('--- fine file ---')
  end; { StampaFile }


begin { StringheDaFile }
  { apertura FILE INPUT (lettura) }
  assign(f1, 'parole.in');
  reset(f1);
  writeln('apertura parole.in fatta');

  { apertura FILE OUTPUT (scrittura) }
  assign(f2, 'parole.out');
  rewrite(f2);
  writeln('apertura parole.out fatta');

  while not eof(f1) do
  begin
    LeggiStringa(f1, p);
    write(p, ' --- ');
    SMaiuscola(p);
    writeln(p);
    writeln(f2, p)
  end;

  { chiusura file usati }
  close(f1);
  close(f2);

  writeln('stampa file di input (<RET> per continuare): ');
  readln;

  assign(f1, 'parole.in');
  reset(f1);
  StampaFile(f1);
  close(f1);

  writeln('stampa file di output (<RET> per continuare):');
  readln;
  assign(f1, 'parole.out');
  reset(f1);
  StampaFile(f1);

  writeln('<RET> per finire');
  readln
end. { StringheDaFile }