Executing External Programs/sk

 SysUtils.ExecuteProcess('/full/path/to/binary',['arg1','arg2']);

 // Toto je ukážkový program ktorý vám ukáže ako
 // spustiť externý program.
 program launchprogram;
 
 // Tu si "použijeme" unity ktoré budeme potrebovať
 uses 
   Classes, SysUtils, Process;
 
 // Toto je definícia premennej APRocess
 // typu "TProcess"
 var 
   AProcess: TProcess;
 
 // Začiatok programu
 begin
   // Vytvoríme objekt TProcess
   // pridelíme ho do premennej AProcess
   AProcess := TProcess.Create(nil);
 
   // Povieme novému procesu aký príkaz má vykonať
   // Použime FPC prekladač
   AProcess.CommandLine := 'ppc386 -h';
 
   // Definujeme nastavenie pre spustenie.
   // Toto nastavenie zaručí že náš program
   // nebude pokračovať až kým sa proces neskončí
   AProcess.Options := AProcess.Options + [poWaitOnExit];
 
   // Teraz keď už proces vie čo má robiť
   // ho môžeme spustiť.
   AProcess.Execute;
 
   // Toto sa dosiahne až po skončení procesu.
   AProcess.Free;   
 end.

 // Toto je ukážkový program ktorý vám ukáže ako
 // spustiť externý program.
 program launchprogram;
 
 // Tu si "použijeme" unity ktoré budeme potrebovať
 uses 
   Classes, SysUtils, Process;
 
 // Toto je definícia premennej APRocess
 // typu "TProcess"
 // Teraz pridáme aj TStringList aby sme
 // mohli uložiť výstup procesu.
 var 
   AProcess: TProcess;
   AStringList: TStringList;
 
 // Začiatok programu
 begin
   // Vytvoríme objekt TProcess
   // pridelíme ho do premennej AProcess
   AProcess := TProcess.Create(nil);
 
   // Vytvoríme TStringList a pridelíme ho
   AStringList := TStringList.Create;
 
   // Povieme novému procesu aký príkaz má vykonať
   // Použime FPC prekladač
   AProcess.CommandLine := 'ppc386 -h';
 
   // Definujeme nastavenie pre spustenie.
   // Toto nastavenie zaručí že náš program
   // nebude pokračovať až kým sa proces neskončí
   // Zároveň ho nastavíme tak, aby sme mohli
   // čítať výstup.
   AProcess.Options := AProcess.Options + [poWaitOnExit, poUsePipes];
 
   // Teraz keď už proces vie čo má robiť
   // ho môžeme spustiť.
   AProcess.Execute;
   
   // Toto sa dosiahne až po skončení procesu.
 
   // Teraz načítame výstup programu
   // do TStringListu.
   AStringList.LoadFromStream(AProcess.Output);
   
   // Uložíme výstup do súboru
   AStringList.SaveToFile('output.txt');
 
   // Teraz keď je už výstup uložený
   // môžeme uvolniť objekty.
   AStringList.Free;
   AProcess.Free;   
 end.

 program procoutlarge;
 {
     Copyright (c) 2004 by Marc Weustink
 
     Tento príklad je vytvorený v nádeji, že bude užitočný,
     ale BEZ AKEJKOĽVEK ZÁRUKY; dokonca bez implicitnej záruky 
     MERCHANTABILITY alebo 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
   // Nemôžeme tu použiť poWaitOnExit, lebo nepoznáme 
   // veľkosť výstupu. V Linuxe je veľkosť 
   // výstupnej rúry 2 kB. Ak je výstupných dátviac, 
   // musíme dáta prečítať. To však nie je možné, keďže 
   // sme čakajúci. Takže by tu nastalo uviaznutie.
   //
   // Na buferovanie výstupu použijeme dočasný Memorystream 
   
   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          
     // overenie, že máme dosť priestoru
     M.SetSize(BytesRead + READ_BYTES);
     
     // skús ho prečítať
     n := P.Output.Read((M.Memory + BytesRead)^, READ_BYTES);
     if n > 0 
     then begin
       Inc(BytesRead, n);
       Write('.')
     end
     else begin     
       // žiadne dáta, počkať 100 ms
       Sleep(100); 
     end;
   end;
   // čítať poslednú časť
   repeat
     // overenie, že máme dosť priestoru
     M.SetSize(BytesRead + READ_BYTES);
     // skús ho prečítať
     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.

 {...}
   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
 {...}