Executing External Programs/de

│ 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) │

Zurück zu den Zusätzlichen Informationen.

Einleitung

Es gibt verschiedene Wege, ein externes Programm auszuführen, aber ich will mich hier auf einen konzentrieren: TProcess.

Wenn Sie bereits ShellExecute und/oder WinExec in Delphi verwenden, dann können Sie damit beginnen, TProcess als Alternative in FPC/Lazarus zu verwenden (dies ist auch gültig, wenn Sie Lazarus unter Linux starten, weil TProcess plattformübergreifend ist).

  Hinweis: Die englische Variante dieser Seite ist teilweise ausführlicher(+: MSWindows: CreateProcess, ShellExecute and WinExec + Unix fpsystem, fpexecve and shell + macOS + Run detached program und auch danach noch einiges mehr)

  Hinweis: FPC/Lazarus bietet Unterstützung für ShellExecute und/oder WinExec, aber diese Unterstützung gibt es nur unter Win32. Wenn Ihr Programm plattformunabhängig sein soll, dann ist die Verwendung von TProcess der beste Weg!

Überblick : Vergleich

Unit	Methode	Plattformen	Befehlszeile	Features und Anmerkungen
SysUtils	ExecuteProcess	Cross-Platform	Ja	Sehr limitiert, synchron
ShellApi	ShellExecute	Nur MS Windows	Ja	Viele. Kann Programme mit Admin Rechten starten.
	WinExec	Nur MS Windows	Ja	Kompatibilität mit 16-bit-Anwendungen
	CreateProcess	Nur MS Windows	Ja	Voll
Unix	fpsystem	Nur Unix	Ja	Ruft die Systemshell /bin/sh auf.
BaseUnix	fpexecve	Nur Unix	Nein	Vollständige Kontrolle über Parameter und Umgebungsvariablen. Aktuelles Programm wird nicht weiter ausgeführt.
Process	TProcess	Cross-Platform	Nein	Voll
Process	RunCommand, RunCommandInDir	Cross-Platform Benötigt FPC 2.6.2+	Ja	Wie TProcess
LCLIntf	OpenDocument	Cross-Platform	Ja	Nur Dokument öffnen
LCLIntf	OpenURL	Cross-Platform	Ja	URL öffnen

(Process.)RunCommand

• RunCommand siehe dort
• RunCommandInDir siehe dort

Mit FPC 2.6.2 wurden für TProcess einige Hilfsfunktionen zur Unit Process hinzugefügt basierend auf Wrapper im fpcup-Projekt.

Diese Funktionen sind grundlegend und sofort benutzbar, sowohl wenn als Ergebnis des Kommandos ein einfacher String als auch wenn ein längeres Ergebnis zu erwarten ist.

Ein einfaches Beispiel:

program project1;

{$mode objfpc}{$H+}

uses 
  Process;

var 
  s : ansistring;

begin

if RunCommand('/bin/bash',['-c','echo $PATH'],s) then
   writeln(s); 

end.

Aber bitte beachten Sie, dass nicht alle 'built-in' Aufrufe (z. B. in Linux Alias) funktionieren,
1.) weil Alias-Werte nur in interaktiven Shells standardmäßig expandiert werden und
2.) weil auch .bashrc nur in interaktiven Shells gelesen wird, es sei denn die BASH_ENV Environment Variable ist gesetzt.
So ergibt z. B. folgendes Programm keinen Output.

program project2;

{$mode objfpc}{$H+}

uses 
  Process;

var 
  s : ansistring;

begin

if RunCommand('/bin/bash',['-c','alias'],s) then
  writeln(s); 

end.

Eine überladene Variante von RunCommand liefert zusätzlich den Exitcode des Programs. RunCommandInDir setzt noch zusätzlich das Standardverzeichnis (setzt p.CurrentDirectory):

function RunCommandIndir(const curdir:string;const exename:string;const commands:array of string;var outputstring:string; var exitstatus:integer): integer;
function RunCommandIndir(const curdir:string;const exename:string;const commands:array of string;var outputstring:string): boolean;
function RunCommand(const exename:string;const commands:array of string;var outputstring:string): boolean;

SysUtils.ExecuteProcess

Wenn Sie keine Pipes oder sonstige Kontrollmechanismen benötigen, kann das Ausführen externer Programme über folgenden Befehl erreicht werden:

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

Leider wird der aufrufende Prozess synchron ausgeführt: er "hängt", wartet also, bis das aufgerufene Programm beendet wurde. Es ist deshalb besser, den Befehl CreateProcess() zu verwenden, wie es hier beschrieben ist:

http://msdn.microsoft.com/en-us/library/ms682512%28v=vs.85%29.aspx

TProcess

Man kann TProcess benutzen, um externe Programme zu starten. Vorteile von TProcess sind

• Plattform-Unabhängigkeit
• die Fähigkeit, von stdout zu lesen und auf stdin zu schreiben.

Anmerkung: TProcess ist kein Terminal bzw. keine Shell! Weder können Skripte direkt ausgeführt werden, noch kann die Ausgabe mit Operatoren wie "|", ">", "<", "&" etc. umgeleitet werden. Es ist möglich, die gleichen Ergebnisse mit TProcess und FreePascal zu erzielen. Ein paar Beispiele finden Sie weiter unten.

Wichtig: Sie müssen den vollständigen Pfad zum ausführbaren Programm angeben. Zum Beispiel '/bin/cp' anstelle von 'cp'. Wenn das Programm im Vorgabepfad steht, dann können Sie die Funktion FindDefaultExecutablePath aus der Unit FileUtil der LCL dazu benutzen.

Ein einfaches Beispiel

// Dies ist ein Demoprogramm, das zeigt, wie man ein
// externes Programm startet.
program launchprogram;

// Hier binden wir Dateien ein, die hilfreiche Funktionen
// und Prozeduren haben, die wir benötigen.
uses 
  Classes, SysUtils, Process;

// Dies definiert die Variable "AProcess" als eine Variable 
// vom Typ "TProcess"
var 
  AProcess: TProcess;

// Hier beginnt der Befehlstext:
begin
  // Nun erstellen wir das Objekt TProcess und
  // weisen es der Variable AProcess zu.
  AProcess := TProcess.Create(nil);

  // Lassen sie uns den FreePascal Compiler verwenden.
  // Dazu müssen wir den Programmnamen an AProcess 
  // übergeben:
  AProcess.Executable:= 'ppc386';

  // An das Programm soll der Parameter -h übergeben werden:
  AProcess.Parameters.Add('-h');

  // Während das externe Programm läuft, soll unser
  // Programm natürlich nicht weiterlaufen.
  // Dies regeln wir mit folgender Bedingung: 
  AProcess.Options := AProcess.Options + [poWaitOnExit];

  // Nun muss AProcess noch ausgeführt werden...
  AProcess.Execute;

  // Wegen der oben gesetzter Bedingung wird dieser
  // Codeabschnitt erst erreicht, wenn ppc386 beendet
  // ist:
  AProcess.Free;   
end.

Das war's. Sie haben gerade gelernt, wie Sie in Ihrem Programm ein externes Programm aufrufen.

Ein verbessertes Beispiel

Das ist nett, aber wie lese ich den Output von einem Programm, das ich laufen habe?

Lassen Sie uns unser Beispiel ein wenig erweitern und einfach das tun:

// Dies ist ein Demoprogramm, das zeigt, wie man ein externes
// Programm startet und dessen Output einliest.
program launchprogram;

// Hier binden wir Dateien ein, die hilfreiche Funktionen
// und Prozeduren haben, die wir benötigen.
uses 
  Classes, SysUtils, Process;

// Dies definiert die Variable "AProcess" als eine 
// Variable vom Typ "TProcess"
// Jetzt fügen wir auch eine TStringList hinzu, um die vom
// Programm ausgegebenen Daten zu speichern
var 
  AProcess: TProcess;
  AStringList: TStringList;

// Ab hier startet Ihr Programm
begin
  // Jetzt erzeugen wir das TProcess Objekt und
  // ordnen es der Variablen AProcess zu.
  AProcess := TProcess.Create(nil);

  // Erzeugen des TStringList Objekts.
  AStringList := TStringList.Create;

  // Gibt an, welcher Befehl vom Prozess ausgeführt werden soll
  // Lassen sie uns den FreePascal Compiler verwenden
  AProcess.CommandLine := 'ppc386 -h';

  // Wir definieren eine Option, wie das Programm
  // ausgeführt werden soll. Dies stellt sicher, dass
  // unser Programm nicht vor Beendigung des aufgerufenen
  // Programmes fortgesetzt wird. Außerdem geben wir an,
  // dass wir die Ausgabe lesen wollen
  AProcess.Options := AProcess.Options + [poWaitOnExit, poUsePipes];

  // Startet den Prozess, nachdem die Parameter entsprechend
  // gesetzt sind
  AProcess.Execute;

  // Folgendes wird erst nach Beendigung von ppc386 ausgeführt

  // Die Ausgabe wird nun in die Stringliste gelesen
  AStringList.LoadFromStream(AProcess.Output);

  // Speichert den output in eine Datei.
  AStringList.SaveToFile('output.txt');

  // Nun da die Datei gespeichert ist können wir 
  // TStringList und TProcess freigeben.
  AStringList.Free;
  AProcess.Free;   
end.

Einlesen eines großen Outputs

Im vorherigen Beispiel haben wir gewartet, bis das Programm beendet wurde. Dann haben wir gelesen, was das Programm in seinen output geschrieben hatte. Aber angenommen, das Programm schreibt eine Menge Daten in den Output, wird die Pipe voll und das Programm angehalten, weil es wartet, bis die Pipe geleert wird. Aber das aufrufende Programm liest nicht aus der Pipe, bis das aufgerufene Programm beendet wurde. Ein dead lock tritt auf.

Das folgende Beispiel benutzt daher nicht poWaitOnExit, sondern liest den Output, während das Programm immer noch läuft. Der Output wird in einem TMemoryStream gespeichert, der später verwendet werden kann, um den Output in eine TStringList einzulesen.

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
  // Wir können poWaitOnExit hier nicht nutzen, weil wir die
  // Größe des Outputs nicht kennen. In Linux ist die Größe der
  // Pipe 2kB. Wenn die Ausgabe größer ist, müssen die Daten 
  // zwischenzeitlich ausgelesen werden. Dies ist nicht möglich,
  // wenn auf das Ende gewartet wird - ein Deadlock tritt auf.
  //
  // Ein temporärer Memorystream wird verwendet, um den output zu puffern.
  
  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          
    // stellt sicher, dass wir Platz haben
    M.SetSize(BytesRead + READ_BYTES);
    
    // versuche, es zu lesen
    n := P.Output.Read((M.Memory + BytesRead)^, READ_BYTES);
    if n > 0 
    then begin
      Inc(BytesRead, n);
      Write('.')
    end
    else begin     
      // keine Daten, warte 100 ms
      Sleep(100); 
    end;
  end;
  // lese den letzten Teil
  repeat
    // stellt sicher, dass wir Platz haben
    M.SetSize(BytesRead + READ_BYTES);
    // versuche es zu lesen
    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.

Verwendung von input und output eines TProcess

Siehe das Beispiel 'processdemo' im Lazarus-CCR SVN.

Hinweise für die Verwendung von TProcess

Mit den Direktiven {$IFDEF} und {$ENDIF} können Sie das Programm je nach Betriebssystem auswählen.

AProcess:TProcess.Create(nil)
{$IFDEF WIN32} 
AProcess.Executable := 'calc.exe'; // Windows Rechner
{$ENDIF}
{$IFDEF LINUX}
AProcess.Executable := 'kcalc';    // KDE Rechner
{$ENDIF}
AProcess.Execute;                  // alternativ können sie AProcess.Active := True verwenden

Beispiel von "talking" mit dem aspell Prozess

Innerhalb des pasdoc Quellcodes können Sie zwei Units finden, die die Rechtschreibung prüfen, in dem sie mit dem laufenden aspell-Prozess durch Pipes kommunizieren:

• PasDoc_ProcessLineTalk.pas unit implementiert die Klasse TProcessLineTalk, einen Nachfahren von TProcess, der einfach benutzt werden kann, um eine "zeilenweise" Kommunikation mit einem laufenden Prozess zu ermöglichen.

• PasDoc_Aspell.pas units implementiert die Klasse TAspellProcess, welche die Rechtschreibprüfung ausführt, indem sie den darunter liegenden Prozess von TProcessLineTalk nutzt, um aspell auszuführen und mit dem laufenden Prozess zu kommunizieren.

Beide Units sind ziemlich unabhängig vom Rest der pasdoc Quellen, so dass sie als praktische Demo für die Nutzung von TProcess dienen können.

Ersetzen von Shell-Operatoren wie "| < >"

Gelegentlich möchten Sie einen komplizierteren Befehl starten, der seine Daten an einen anderen Befehl oder eine Datei weiterleitet. Also etwa folgendes

ShellExecute('ersterBefehl.exe | zweiterBefehl.exe');

oder

ShellExecute('dir > output.txt');

Das mit TProcess auszuführen klappt nicht, also:

// das klappt nicht
Process.CommandLine := 'ersterBefehl.exe | zweiterBefehl.exe'; 
Process.Execute;

Warum die Verwendung von Spezialoperatoren zum Umleiten der Ausgabe nicht funktioniert

TProcess ist keine Shell-Umgebung, sondern nur ein Prozess. Also nicht zwei Prozesse, nur einer. Dennoch ist die Umleitung der Ausgabe in der gewünschten Weise möglich. Siehe dazu den nächsten Abschnitt Wie leitet man die Ausgabe mit TProcess um.

Wie leitet man die Ausgabe mit TProcess um

Sie können die Ausgaben eines Befehls an einen anderen Befehl umleiten, indem Sie für jeden Befehl eine Instanz des TProcess verwenden.

Hier ist ein Beispiel das die Umleitung von einem Prozess an einen anderen erläutert. Für die Umleitung der Ausgabe von einem Prozess zu einer Datei/einem Stream siehe das Beispiel Einlesen eines großen Outputs

Sie können nicht nur die "normale" Ausgabe (auch als "stdout" bekannt) umleiten, sondern auch die Fehlerausgabe (stderr), wenn Sie die Option "poStderrToOutPut" angeben, wie in den Optionen des zweiten Prozesses ersichtlich.

program Project1;
  
uses
  Classes, sysutils, process;
  
var
  FirstProcess,
  SecondProcess: TProcess;
  Buffer: array[0..127] of char;
  ReadCount: Integer;
  ReadSize: Integer;
begin
  FirstProcess  := TProcess.Create(nil);
  SecondProcess := TProcess.Create(nil);
 
  FirstProcess.Options  := [poUsePipes];
  SecondProcess.Options := [poUsePipes,poStderrToOutPut];
  
  FirstProcess.CommandLine  := 'pwd';
  SecondProcess.CommandLine := 'grep '+ DirectorySeparator+ ' -';    
  // dies liefert das gleiche wie "pwd | grep / -"
  
  FirstProcess.Execute;
  SecondProcess.Execute;
  
  while FirstProcess.Running or (FirstProcess.Output.NumBytesAvailable > 0) do
  begin
    if FirstProcess.Output.NumBytesAvailable > 0 then
    begin
      // stellen Sie sicher, dass Sie nicht mehr Daten lesen als im Puffer
      // bereitstehen
      ReadSize := FirstProcess.Output.NumBytesAvailable;
      if ReadSize > SizeOf(Buffer) then
        ReadSize := SizeOf(Buffer);
      // jetzt lesen wir die Ausgabe in den Puffer
      ReadCount := FirstProcess.Output.Read(Buffer[0], ReadSize);
      // und schreiben den Puffer an den zweiten Prozess
      SecondProcess.Input.Write(Buffer[0], ReadCount);
  
      // falls der SecondProcess große Datenmengen an seine Ausgabe sendet, dann 
      // sollten wir diese Daten auslesen, um einen Deadlock zu vermeiden.
      // siehe das vorhergehende Beispiel "Einlesen eines großen Outputs"
    end;
  end;
  // Schließt die Eingabe an den SecondProcess,
  // sodass der die Verarbeitung seiner Daten beendet
  SecondProcess.CloseInput;
 
  // und warte auf seine Beendigung.
  // Sei achtsam, welcher Befehl ausgeführt werden soll, weil er nicht beendet würde,
  // wenn seine Eingabe geschlossen ist. Die folgende Zeile führt dann zu einer unendlichen Schleife
  while SecondProcess.Running do
    Sleep(1);
  // Das wars! Der Rest des Programms ist nur dazu da, dass das Beispiel
  // irgendwas 'nützliches' macht.

  // Wir benutzen wieder den Puffer, diesmal für die Ausgabe vom SecondProcess
  // an die Standardausgabe stdout dieses Beispielprogrammes.
  WriteLn('Grep output Start:');
  ReadSize := SecondProcess.Output.NumBytesAvailable;
  if ReadSize > SizeOf(Buffer) then
    ReadSize := SizeOf(Buffer);
  if ReadSize > 0 then
  begin
    ReadCount := SecondProcess.Output.Read(Buffer, ReadSize);
    WriteLn(Copy(Buffer,0, ReadCount));
  end
  else
    WriteLn('grep did not find what we searched for. ', SecondProcess.ExitStatus);
  WriteLn('Grep output Finish:');
  
  // free our process objects
  FirstProcess.Free;
  SecondProcess.Free;
end.

Das war es. Nun können Sie Ausgaben von einem Programm an das nächste umleiten.

Anmerkungen

Dieses Beipiel könnte übertrieben erscheinen, weil es ermöglicht, mit TProcess auch "komplizierte" Befehle unter Verwendung einer Shell zu starten, wie:

Process.Commandline := 'sh -c "pwd | grep / -"';

Aber unser Beispiel ist dadurch wirklich plattformübergreifend. Es braucht keinerlei Modifikation um unter Windows oder Linux etc. ausgeführt zu werden. Der Befehl "sh" ist unter Ihrem Betriebssystem möglicherweise nicht verfügbar, im Allgemeinen gibt es ihn nur auf *nix Systemen.
Ebenso haben wir in unserem Beispiel mehr Flexibilität gewonnen, da wir zu und von der Eingabe, der Ausgabe und zu 'stderr' lesen und schreiben können, und das individuell für jeden Prozess. Das könnte in Ihrem Projekt sehr vorteilhaft sein.

Parameter, die Leerzeichen enthalten (Replacing Shell Quotes)

In der Linux-Shell ist es möglich, Argumente in Anführungszeichen zu schreiben, ähnlich dem Folgenden:

gdb --batch --eval-command="info symbol 0x0000DDDD" myprogram

Und GDB erhält dadurch 3 Argumente (zusätzlich zum ersten Argument, das den vollständigen Pfad zum ausführbaren Programm enthält):

1. --batch
2. --eval-command=info symbol 0x0000DDDD
3. the full path to myprogram

TProcess und auch (???) übergeben Parameter mit Leerzeichen, aber sie benutzen einen unterschiedlichen Stil dazu. Anstatt nur Teile des Parameters in Anführungszeichen zu setzen, schließen sie alles ein. Ähnlich wie:

 TProcess.CommandLine := '/usr/bin/gdb --batch "--eval-command=info symbol 0x0000DDDD" /home/me/myprogram';

Und beachten Sie auch, dass Sie nur vollständige Pfade übergeben.

Siehe dazu auch die Diskussion darüber unter: http://bugs.freepascal.org/view.php?id=14446

RunCommand Erweiterungen

Im FPC 3.2.0+ wurde die RunCommand implementation verbessert und in die TProcess Klasse eingefügt. Dies erlaubt eine schnellere Erstellung eigener Speziallisierungen der TProcess Klasse. Hier ein Beispiel mit Timeout:

program TestTProcessTimeout;

uses classes, sysutils, process, dateutils;

type
 { TProcessTimeout }
 TProcessTimeout = class(TProcess)
                   protected
                     timeoutperiod: TTime;
                     timedout : boolean;
                     started : TDateTime;
                     procedure LocalnIdleSleep(Sender,Context : TObject;status:TRunCommandEventCode;const message:string);
                   public
                     class function RunCommandwithTimeout(const exename:TProcessString;const commands:array of TProcessString;const dir:string;out outputstring:string;out errorstring:string;out exitstate:integer; ProcessOptions : TProcessOptions = [];SWOptions:TShowWindowOptions=swoNone;timeout:integer=15):boolean;static;
                   end;



procedure TProcessTimeout.LocalnIdleSleep(Sender,Context : TObject;status:TRunCommandEventCode;const message:string);
begin
  if status=RunCommandIdle then
  begin
     writeln(Executable+'('+ Parameters.CommaText+')' +' time: '+TimeToStr(now-started));
     if (now-started)>timeoutperiod then
     begin
       writeln('process timed out ');
       timedout:=true;
       Terminate(255);
       exit;
     end;
     sleep(RunCommandSleepTime);
  end;
end;

class function TProcessTimeout.RunCommandwithTimeout(
                             const exename     : TProcessString;
                             const commands    : array of TProcessString;
                             const dir         : string;
                             out outputstring  : string;
                             out errorstring   : string;
                             out exitstate     : integer;
                             ProcessOptions    : TProcessOptions = [];
                             SWOptions         : TShowWindowOptions=swoNone;
                             timeout           : integer=15
                            ):boolean;
Var
    p : TProcessTimeout;
    i : integer;
begin
  p:=TProcessTimeout.create(nil);
  p.OnRunCommandEvent:=@p.LocalnIdleSleep;
  p.CurrentDirectory:=dir;


  //timeout in Minuten
  p.timeoutperiod:=timeout/MinsPerDay;

  (*
  //Wenn der Timeout in sekunden angegeben werden soll dies hier ausklammern
  p.timeoutperiod:=timeout/SecsPerDay;
  *)

  //Jede sekunde überprüfen.
  p.runcommandsleeptime := 1000;

  if ProcessOptions<>[] then
    P.Options:=ProcessOptions - [poRunSuspended,poWaitOnExit];
  p.options:=p.options+[poRunIdle]; // needed to run the RUNIDLE event. See User Changes 3.2.0

  P.ShowWindow:=SwOptions;
  p.Executable:=exename;
  if high(commands)>=0 then
   for i:=low(commands) to high(commands) do
     p.Parameters.add(commands[i]);
  p.timedout:=false;
  p.started:=now;
  try
    // RunCommandLoop ruft alle runcommandsleeptime Millisekcunden LocalnIdleSleep auf.
    RunCommandwithTimeout:=p.RunCommandLoop(outputstring,errorstring,exitstate)=0;
    if p.timedout then
      RunCommandwithTimeout:=false;
  finally
    p.free;
  end;
  if exitstate<>0 then RunCommandwithTimeout:=false;
end;

// Beispiel:

var
  output,errors : string;
  exitcode  :integer;
begin
  //Windows und Unix haben andere Programme
  {$if defined(WINDOWS)}
  if TProcessTimeout.RunCommandwithTimeout('cmd',['/c','dir','C:\*.exe','/s'],'c:\',output,errors,exitcode,[],swoNone,1) then // dir c:\*.exe /s
  {$else$}
  if TProcessTimeout.RunCommandwithTimeout('find',['/','-name','"*.sh"'],'/',output,errors,exitcode,[],swoNone,1) then // find / -name "*.sh"
  {$endif}
  begin
    writeln('Programm fertig');
    writeln('--------------------Ausgabe-------------------');
    writeln(output);
    writeln('--------------------Fehler--------------------');
    writeln(errors);
    if not(exitcode=0) then
    begin
      writeln('-Programm mit Fehler beendet (exitcode: '+exitcode.tostring+')-');
    end;
    readln();
  end
  else
  begin
    writeln('Programm abgebrochen');
    writeln('--------------------Ausgabe-------------------');
    writeln(output);
    writeln('--------------------Fehler--------------------');
    writeln(errors);
    writeln('-------------------EXITCODE------------------');
    writeln(exitcode);
    readln();
  end;
end.

Siehe auch

• TXMLPropStorage