Difference between revisions of "Executing External Programs/de"
m (full update, some formatting) |
|||
Line 5: | Line 5: | ||
Es gibt verschiedene Wege, ein externes Programm auszuführen, aber ich will mich hier auf einen konzentrieren: [[doc:fcl/process/tprocess.html|TProcess]]. | Es gibt verschiedene Wege, ein externes Programm auszuführen, aber ich will mich hier auf einen konzentrieren: [[doc:fcl/process/tprocess.html|TProcess]]. | ||
− | Wenn | + | 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). |
− | '''Notiz:''' FPC/Lazarus bietet Unterstützung für '''ShellExecute''' und/oder '''WinExec''', aber diese Unterstützung gibt es nur unter Win32. Wenn | + | '''Notiz:''' 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! |
== SysUtils.ExecuteProcess == | == SysUtils.ExecuteProcess == | ||
Line 15: | Line 15: | ||
<delphi>SysUtils.ExecuteProcess( UTF8ToSys( '/full/path/to/binary'), '''' '', []);</delphi> | <delphi>SysUtils.ExecuteProcess( UTF8ToSys( '/full/path/to/binary'), '''' '', []);</delphi> | ||
− | Leider "hängt" | + | Leider wird der aufrufende Prozess synchron ausgeführt: er "hängt", wartet also, bis das aufgerufene Programm beendet wurde. |
− | bis das aufgerufene Programm beendet wurde. Es ist deshalb besser, den Befehl | + | Es ist deshalb besser, den Befehl CreateProcess() zu verwenden, wie es hier beschrieben ist: |
− | CreateProcess() zu verwenden wie | ||
http://msdn.microsoft.com/en-us/library/ms682512%28v=vs.85%29.aspx | http://msdn.microsoft.com/en-us/library/ms682512%28v=vs.85%29.aspx | ||
Line 27: | Line 26: | ||
*die Fähigkeit, von ''stdout'' zu lesen und auf ''stdin'' zu schreiben. | *die Fähigkeit, von ''stdout'' zu lesen und auf ''stdin'' zu schreiben. | ||
− | Anmerkung: TProcess ist kein Terminal bzw. keine Shell! Weder können | + | 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 of 'cp'. Wenn das Programm im Vorgabepfad steht, dann können Sie die Funktion [[doc:lcl/fileutil/finddefaultexecutablepath.html|FindDefaultExecutablePath]] aus der Unit [[doc:lcl/fileutil/index.html|FileUtil]] der LCL dazu benutzen. | Wichtig: Sie müssen den vollständigen Pfad zum ausführbaren Programm angeben. Zum Beispiel '/bin/cp' anstelle von of 'cp'. Wenn das Programm im Vorgabepfad steht, dann können Sie die Funktion [[doc:lcl/fileutil/finddefaultexecutablepath.html|FindDefaultExecutablePath]] aus der Unit [[doc:lcl/fileutil/index.html|FileUtil]] der LCL dazu benutzen. | ||
=== Ein einfaches Beispiel === | === Ein einfaches Beispiel === | ||
− | <delphi> // Dies ist ein Demoprogramm, das zeigt, wie man ein | + | <delphi>// 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 Kommandozeilenbefehl an AProcess | |
− | + | // übergeben: | |
− | + | AProcess.CommandLine := 'ppc386 -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.</delphi> | |
Das war's. Sie haben gerade gelernt, wie Sie in Ihrem Programm ein externes Programm aufrufen. | Das war's. Sie haben gerade gelernt, wie Sie in Ihrem Programm ein externes Programm aufrufen. | ||
Line 78: | Line 77: | ||
Lassen Sie uns unser Beispiel ein wenig erweitern und einfach das tun: | Lassen Sie uns unser Beispiel ein wenig erweitern und einfach das tun: | ||
− | <delphi> // Dies ist ein Demoprogramm, das zeigt, wie man ein externes | + | <delphi>// 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.</delphi> | |
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
=== Einlesen eines großen Outputs === | === 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 | + | 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 | + | 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. |
− | <delphi> program procoutlarge; | + | <delphi>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.</delphi> | |
=== Verwendung von input und output eines TProcess === | === Verwendung von input und output eines TProcess === | ||
Line 243: | Line 242: | ||
=== Beispiel von "talking" mit dem aspell Prozess === | === Beispiel von "talking" mit dem aspell Prozess === | ||
− | Innerhalb des [http://pasdoc.sourceforge.net/ pasdoc] Quellcodes können | + | Innerhalb des [http://pasdoc.sourceforge.net/ pasdoc] Quellcodes können Sie zwei Units finden, die die Rechtschreibung prüfen, in dem sie mit dem laufenden aspell-Prozess durch Pipes kommunizieren: |
− | * [http://pasdoc.svn.sourceforge.net/viewvc/*checkout*/pasdoc/trunk/source/component/PasDoc_ProcessLineTalk.pas PasDoc_ProcessLineTalk.pas unit] implementiert die TProcessLineTalk | + | * [http://pasdoc.svn.sourceforge.net/viewvc/*checkout*/pasdoc/trunk/source/component/PasDoc_ProcessLineTalk.pas 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. |
− | * [http://pasdoc.svn.sourceforge.net/viewvc/*checkout*/pasdoc/trunk/source/component/PasDoc_Aspell.pas PasDoc_Aspell.pas units] implementiert die TAspellProcess | + | * [http://pasdoc.svn.sourceforge.net/viewvc/*checkout*/pasdoc/trunk/source/component/PasDoc_Aspell.pas 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. | 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- | + | === Ersetzen von Shell-Operatoren wie "| < >" === |
Gelegentlich möchten Sie einen komplizierteren Befehl starten, der seine Daten an einen anderen Befehl oder eine Datei weiterleitet. | Gelegentlich möchten Sie einen komplizierteren Befehl starten, der seine Daten an einen anderen Befehl oder eine Datei weiterleitet. | ||
Line 267: | Line 266: | ||
==== Warum die Verwendung von Spezialoperatoren zum Umleiten der Ausgabe nicht funktioniert ==== | ==== 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. | 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 [[Executing_External_Programs# | + | Dennoch ist die Umleitung der Ausgabe in der gewünschten Weise möglich. Siehe dazu den nächsten Abschnitt [[Executing_External_Programs/de#Wie_leitet_man_die_Ausgabe_mit_TProcess_um]]. |
===Wie leitet man die Ausgabe mit TProcess um=== | ===Wie leitet man die Ausgabe mit TProcess um=== | ||
Line 274: | Line 273: | ||
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 [[Executing_External_Programs/de#Einlesen_eines_großen_Outputs|Einlesen eines großen Outputs]] | 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 [[Executing_External_Programs/de#Einlesen_eines_großen_Outputs|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. | ||
+ | |||
<delphi>program Project1; | <delphi>program Project1; | ||
Line 310: | Line 312: | ||
// jetzt lesen wir die Ausgabe in den Puffer | // jetzt lesen wir die Ausgabe in den Puffer | ||
ReadCount := FirstProcess.Output.Read(Buffer[0], ReadSize); | ReadCount := FirstProcess.Output.Read(Buffer[0], ReadSize); | ||
− | // und schreiben den Puffer an den | + | // und schreiben den Puffer an den zweiten Prozess |
SecondProcess.Input.Write(Buffer[0], ReadCount); | SecondProcess.Input.Write(Buffer[0], ReadCount); | ||
Line 357: | Line 359: | ||
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.<br> | 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.<br> | ||
− | 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 | + | 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): | ||
+ | #--batch | ||
+ | #--eval-command=info symbol 0x0000DDDD | ||
+ | #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 | ||
==Siehe auch== | ==Siehe auch== |
Revision as of 20:29, 30 August 2011
│
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) │
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).
Notiz: 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!
SysUtils.ExecuteProcess
Wenn Sie keine Pipes oder sonstige Kontrollmechanismen benötigen, kann das Ausführen externer Programme über folgenden Befehl erreicht werden:
<delphi>SysUtils.ExecuteProcess( UTF8ToSys( '/full/path/to/binary'), '' , []);</delphi>
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 of '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
<delphi>// 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 Kommandozeilenbefehl an AProcess // übergeben: AProcess.CommandLine := 'ppc386 -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.</delphi>
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:
<delphi>// 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.</delphi>
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.
<delphi>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.</delphi>
Verwendung von input und output eines TProcess
Siehe das Beispiel 'processdemo' im Lazarus-CCR SVN.
Hinweise für die Verwendung von TProcess
Wenn Sie ein plattformübergreifendes Programm erstellen, können Sie die Befehlszeile entsprechend dem Betriebssystem ändern, unter Verwendung der Direktiven "{$IFDEF}s" und "{$ENDIF}s".
Beispiel: <delphi>{...} AProcess:TProcess.Create(nil) {$IFDEF WIN32} AProcess.CommandLine := 'calc.exe'; //Windows Rechner {$ENDIF} {$IFDEF LINUX} AProcess.CommandLine := 'kcalc'; //KDE Rechner {$ENDIF} AProcess.Execute; //alternativ können sie AProcess.Active:=True verwenden {...}</delphi>
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 <delphi>ShellExecute('ersterBefehl.exe | zweiterBefehl.exe');</delphi> oder <delphi>ShellExecute('dir > output.txt');</delphi>
Das mit TProcess auszuführen klappt nicht, also:
<delphi>// das klappt nicht Process.CommandLine := 'ersterBefehl.exe | zweiterBefehl.exe'; Process.Execute;</delphi>
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 Executing_External_Programs/de#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.
<delphi>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.</delphi>
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: <delphi>Process.Commandline := 'sh -c "pwd | grep / -"';</delphi>
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):
- --batch
- --eval-command=info symbol 0x0000DDDD
- 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