Executing External Programs/it

│ Deutsch (de) │ English (en) │ español (es) │ français (fr) │ italiano (it) │ 日本語 (ja) │ Nederlands (nl) │ polski (pl) │ português (pt) │ русский (ru) │ slovenčina (sk) │ 中文（中国大陆）‎ (zh_CN) │

Introduzione

Ci sono diversi modi di eseguire un programma esterno, ma questo articolo ne esamina solo uno: TProcess.

Se solitamente usi ShellExecute e/o WinExec in Delphi, puoi iniziare ad usare TProcess come un'alternativa in FPC/Lazarus (vale anche se usi Lazarus in Linux, perché TProcess è cross-platform).

Nota: FPC/Lazarus supporta ShellExecute e/o WinExec, ma questo supporto è solo in Win32. Se vuoi programmare 'cross-platform', allora usa TProcess, è la miglior scelta!

SysUtils.ExecuteProcess

Se non hai bisogno di 'pipes' né di altre forme di controllo, il sistema più semplice è quello di usare SysUtils.ExecuteProcess('/percorso/completo/al/file/binario',['arg1','arg2']);

TProcess

Puoi usare TProcess per lanciare programmi esterni. Alcuni vantaggi nell'uso di TProcess sono:

• Piattaforma Indipendente
• Capacità di leggere da stdout e scrivere in stdin.

Nota: TProcess non è un terminal/shell! Non puoi eseguire direttamente scripts or redirigere output usando operatori tipo "|", ">", "<", "&" etc. E' possibile ottenere gli stessi risultati con TProcess usando Pascal; puoi vedere alcuni esempi più avanti.

Importante: Devi specificare il percorso completo dell'eseguibile. Per esempio '/bin/cp' invece di 'cp'. Se il programma è nel percorso standard PATH allora puoi usare la funzione FindDefaultExecutablePath dalla unit FileUtil di LCL.

Un semplice esempio

 // Questo è un programma dimostrativo che mostra come lanciare
 // un programma esterno.
 program launchprogram;
 
 // Qui includiamo i files che hanno utilizzo funzionale
 // e le procedure che ci occorreranno.
 uses 
   Classes, SysUtils, Process;
 
 // Questa è la definizione della variabile "AProcess" 
 // come una variabile di tipo "TProcess"
 var 
   AProcess: TProcess;
 
 // Qui è dove il nostro programma inizia
 begin
   // Adesso creeremo l'oggetto TProcess e
   // lo assegneremo  alla variabile  var AProcess.
   AProcess := TProcess.Create(nil);
 
   // Diremo al nuovo  AProcess quale è il comando da eseguire.
   // Usa il compilatore  FreePascal
   AProcess.CommandLine := 'ppc386 -h';
 
   // Definiremo una opzione per quando il programma
   // è in esecuzione. Questa opzione ci assicurerà che il nostro programma
   // non continuerà sin quando il programma che lanceremo
   // non sarà terminato.                vvvvvvvvvvvvvv
   AProcess.Options := AProcess.Options + [poWaitOnExit];
 
   // Adesso che AProcess sa qual'è la linea di comando 
   // verrà lanciato.
   AProcess.Execute;
 
   // Questo non avverrà sino a quando ppc386 non fermerà la sua esecuzione.
   AProcess.Free;   
 end.

Questo è quanto! Hai appena imparato come eseguire un programma esterno dall'interno del tuo programma.

Un esempio più elaborato

Che bello!, ma come faccio a leggere l'Output di un programma che ho eseguito?

Bene, sviluppiamo un po' il nostro esempio in modo da ottenere questo:

 // Questo è un programma dimostrativo che mostra come
 // lanciare un programma esterno e leggere dal suo output.
 program launchprogram;
 
 // Qui mettiamo i files che contengono funzioni utili
 // e le procedure di cui abbiamo bisogno.
 uses 
   Classes, SysUtils, Process;
 
 // Questa è la definizione della variabile "AProcess"
 // come variabile del tipo "TProcess"
 // Aggiungiamo anche una TStringList per memorizzare
 // i dati che leggeremo dall'output del programma.
 var 
   AProcess: TProcess;
   AStringList: TStringList;
 
 // Questo è l'inizio del programma
 begin
   // Ora creeremo l'oggetto TProcess, e lo
   // assegneremo alla variabile AProcess.
   AProcess := TProcess.Create(nil);
 
   // Creazione dell'oggetto TStringList.
   AStringList := TStringList.Create;
 
   // Diciamo al nuovo AProcess quale comando eseguire.
   // Utilizza il compilatore FreePascal
   AProcess.CommandLine := 'ppc386 -h';
 
   // Definiamo un'opzione per il programma durante
   // l'esecuzione. Questa opzione garantisce che il nostro
   // programma rimane in attesa finché il programma che
   // abbiamo lanciato non si ferma. Gli diciamo anche che
   // vogliamo leggere l'output.
   AProcess.Options := AProcess.Options + [poWaitOnExit, poUsePipes];
 
   // Ora che AProcess qual'è la linea di comando 
   // lo eseguiamo.
   AProcess.Execute;
   
   // Quanto segue non viene eseguito finché ppc386 non
   // termina l'esecuzione.
 
   // Ora leggiamo l'output del programma che abbiamo
   // appena eseguito all'interno della TStringList.
   AStringList.LoadFromStream(AProcess.Output);
   
   // Salviamo l'output in un file.
   AStringList.SaveToFile('output.txt');
 
   // Ora che il file è stato salvato, possiamo liberare
   // la TStringList e il TProcess.
   AStringList.Free;
   AProcess.Free;   
 end.

Leggere output di grandi dimensioni

Nel precedente esempio noi abbiamo aspettato fino all'uscita del programma. Quindi leggiamo, quello che il programma ha scritto nel suo output. Ma supponiamo che il programma scriva molti dati nell'output, il buffer si riempie e il programma richiamato aspetta sinché il buffer non viene letto. Ma il programma chiamante non legge dal buffer, sinché il programma chiamato non ha terminato. Avviene un blocco.

Il seguente esempio quindi non usa poWaitOnExit, ma legge dall'output, mentre il programma è ancora in esecuzione. L'output è immagazzinato in un buffer di memoria, che potrà essere usato più tardi per leggere l'output all'interno di una TStringList.

 program procoutlarge;
 {
     Copyright (c) 2004 by Marc Weustink
 
     This example is creeated in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 }
 
 uses
   Classes, Process, SysUtils;
 
 const
   READ_BYTES = 2048;
   
 var
   S: TStringList;
   M: TMemoryStream;
   P: TProcess;
   n: LongInt;
   BytesRead: LongInt;
 
 begin
   // We cannot use poWaitOnExit here since we don't
   // know the size of the output. On Linux the size of the
   // output pipe is 2 kB. If the output data is more, we 
   // need to read the data. This isn't possible since we are 
   // waiting. So we get a deadlock here.
   //
   // A temp Memorystream is used to buffer the output
   
   M := TMemoryStream.Create;
   BytesRead := 0;
 
   P := TProcess.Create(nil);
   P.CommandLine := 'ppc386 -va bogus.pp';
   P.Options := [poUsePipes];
   WriteLn('-- executing --');
   P.Execute;
   while P.Running do
   begin          
     // make sure we have room
     M.SetSize(BytesRead + READ_BYTES);
     
     // try reading it
     n := P.Output.Read((M.Memory + BytesRead)^, READ_BYTES);
     if n > 0 
     then begin
       Inc(BytesRead, n);
       Write('.')
     end
     else begin     
       // no data, wait 100 ms
       Sleep(100); 
     end;
   end;
   // read last part
   repeat
     // make sure we have room
     M.SetSize(BytesRead + READ_BYTES);
     // try reading it
     n := P.Output.Read((M.Memory + BytesRead)^, READ_BYTES);
     if n > 0 
     then begin
       Inc(BytesRead, n);
       Write('.');
     end;
   until n <= 0;
   if BytesRead > 0 then WriteLn;
   M.SetSize(BytesRead); 
   WriteLn('-- executed --');
   
   S := TStringList.Create;
   S.LoadFromStream(M);
   WriteLn('-- linecount = ', S.Count, ' --');
   for n := 0 to S.Count - 1 do
   begin
     WriteLn('| ', S[n]);
   end;
   WriteLn('-- end --');
   S.Free;
   P.Free;
   M.Free;
 end.

Usare input e output di TProcess

Vedi l'esempio dimostrativo in Lazarus-CCR SVN.

Accorgimenti nell'uso di TProcess

Se stai creando un programma multipiattaforma (cross-platform) , Puoi cambiare la linea di comando in base al Sistema Operativo , usando le direttive "{$IFDEF}s" and "{$ENDIF}s".

Esempio:

 {...}
   AProcess:TProcess.Create(nil)
   {$IFDEF WIN32}
   AProcess.CommandLine := 'calc.exe'; //Windows Calc
   {$ENDIF}
   {$IFDEF LINUX}
   AProcess.CommandLine := 'kcalc'; //KDE Calc
   {$ENDIF}
   AProcess.Execute; //in alternative, you can use AProcess.Active:=True
 {...}

Esempio di dialogo con il processo aspell

All'interno di pasdoc Codice sorgente puoi trovare due units che fanno spell-checking mediante "dialogo" con aspell in esecuzione attraverso pipes:

• PasDoc_ProcessLineTalk.pas unit implements TProcessLineTalk class, descendant of TProcess, that can be easily used to talk with any process on a line-by-line basis.

• PasDoc_Aspell.pas units implements TAspellProcess class, that performs spell-checking by using underlying TProcessLineTalk instance to execute aspell and communicate with running aspell process.

Entrambe le units sono indipendenti dal resto di pasdoc sorgente, cosi che esse possono servire come esempio reale dell'uso di TProcess per eseguire e comunicare attraverso pipes con altri programmi.