[DOS] Ausgabe abfangen

[Andi1985]

Hallo,

ich rufe folgendermaßen meine Anwendung auf:

Zitat:

type C:\boot.ini | test.exe

und würde nun gerne in meiner .exe an die Ausgabe vor dem Pipe rankommen...

der ParamStr() bringt mir hier leider nichts.

Ich habe schon nach Pipes gesucht, allerdings glaub ich nicht das die Lösugnsansetze das gleiche verfolgen wie ich...

Kann mir jemand helfen?

[MrKnogge]

Es gibt hier im Forum mehrere Themen dies bezüglich, such eventuell mal nach Konsole abfangen oder ähnliches. Wenn ich heute Abend zu Hause bin kann ich dir eine Klasse mit Beispiel schicken, aber hier hab nichts zur Hand.

[Andi1985]

wie hier beschreiben
http://www.delphipraxis.net/internal...=860819#860819
brignt mich nicht sonderlich weiter, da hier eine extra Console erzeugt wird in der die abgeschickten Befehle abgefangen werden...

auch dieses beispiel brignt mich nciht weiter, da hier erst im eigendlich programm der dos befehl ausgeführt wird:
http://www.delphi-treff.de/tipps/system/tipp/524/

[Hansa]

Was soll denn das werden ? :shock: Und das hier : | ? Brauchst du den Inhalt der Boot.INI im Programm ? Das wäre dann aber so was :

Code:

type boot.ini > Text.exe

IMHO ist das egal wie alles Unfug. Lese die Datei aus und fertig. Zeilenweise mit readln oder lade sie in eine Stringliste.

[DeddyH]

Zitat:

Zitat von Hansa

Code:

type boot.ini > Text.exe

Bist Du Dir da sicher? Ich denke eher, dass damit die Text.exe mit dem Inhalt der boot.ini überschrieben wird, was ja nun gar nicht im Sinne des Erfinders sein kann.

[Andi1985]

so funktioniert es in C++, aber wie in Delphi?

Zitat:

type C:\boot.ini | test.exe

Zitat:

//--------------------------------------------------------
#include <iostream>

//---------------------------------------------------------
using namespace std;

int main(int argc, char* argv[])
{
char buf[255];
while(cin)
{
cin.getline(&buf[0], 255);

if(!cin)
break;

cout << buf << endl;
}
}
//------------------------------------------------------

[Hansa]

Zitat:

Zitat von DeddyH

Ich denke eher, dass damit die Text.exe mit dem Inhalt der boot.ini überschrieben wird..

Uff, stimmt. :shock: Auch das war Unfug. Liebe Kinder, bitte nicht nachmachen. :mrgreen: Aber der Rest bleibt so, er soll die Datei einfach auslesen.

[DeddyH]

Vielleicht ist dieser Thread hilfreich.

[r2c2]

Machts nicht zu kompliziert. Effektiv ist es doch ganz einfach. Die Pipe leitet die Standardausgabe des einen Programms zur Standardeingabe des anderen weiter. Man muss also nur die Standardeingabe auslesen. Und das funktioniert nach wie vor mit Read() und ReadLn(). Nebnbei schreibt man auf die Standradausgabe mit Write() und WriteLn(). Die Pipe an sich muss also gar nicht beachtet werden...

mfg

Christian

[Andi1985]

ah das hat geholfen, allerdigns bekomme ich imemr nur die erste zeile der boot.ini :(
wie setze ich den Lesezeiger weiter?

Delphi-Quellcode:

var
  sOutput: string;
begin
  { TODO -oUser -cConsole Main : Hier Code einfügen }


  repeat
    read(sOutPut);
    Write(sOutPut);
  until sOutPut <> '';



end.

[DeddyH]

Ich hab sowas auch noch nie gemacht, aber müsste da nicht ein EOF am Dateiende kommen?

[RWarnecke]

Ich habe mal im Internet diese Funktion gefunden :

Delphi-Quellcode:

function GetConsoleOutput(const Command: String; var Output, Errors: TStringList): Boolean;
var
  StartupInfo: TStartupInfo;
  ProcessInfo: TProcessInformation;
  SecurityAttr: TSecurityAttributes;
  PipeOutputRead: THandle;
  PipeOutputWrite: THandle;
  PipeErrorsRead: THandle;
  PipeErrorsWrite: THandle;
  Succeed: Boolean;
  Buffer: array [0..255] of Char;
  NumberOfBytesRead: DWORD;
  Stream: TMemoryStream;
begin
  //Initialisierung ProcessInfo
  FillChar(ProcessInfo, SizeOf(TProcessInformation), 0);

  //Initialisierung SecurityAttr
  FillChar(SecurityAttr, SizeOf(TSecurityAttributes), 0);
  SecurityAttr.nLength := SizeOf(SecurityAttr);
  SecurityAttr.bInheritHandle := true;
  SecurityAttr.lpSecurityDescriptor := nil;

  //Pipes erzeugen
  CreatePipe(PipeOutputRead, PipeOutputWrite, @SecurityAttr, 0);
  CreatePipe(PipeErrorsRead, PipeErrorsWrite, @SecurityAttr, 0);

  //Initialisierung StartupInfo
  FillChar(StartupInfo, SizeOf(TStartupInfo), 0);
  StartupInfo.cb:=SizeOf(StartupInfo);
  StartupInfo.hStdInput := 0;
  StartupInfo.hStdOutput := PipeOutputWrite;
  StartupInfo.hStdError := PipeErrorsWrite;
  StartupInfo.wShowWindow := sw_Hide;
  StartupInfo.dwFlags := STARTF_USESHOWWINDOW or STARTF_USESTDHANDLES;

  if  CreateProcess(nil, PChar(command), nil, nil, true,
  CREATE_DEFAULT_ERROR_MODE or CREATE_NEW_CONSOLE or NORMAL_PRIORITY_CLASS, nil, nil,
  StartupInfo, ProcessInfo) then begin
    result:=true;
    //Write-Pipes schließen
    CloseHandle(PipeOutputWrite);
    CloseHandle(PipeErrorsWrite);

    //Ausgabe Read-Pipe auslesen
    Stream := TMemoryStream.Create;
    try
      while true do begin
        succeed := ReadFile(PipeOutputRead, Buffer, 255, NumberOfBytesRead, nil);
        if not succeed then break;
        Stream.Write(Buffer, NumberOfBytesRead);
      end;
      Stream.Position := 0;
      Output.LoadFromStream(Stream);
    finally
      Stream.Free;
    end;
    CloseHandle(PipeOutputRead);

    //Fehler Read-Pipe auslesen
    Stream := TMemoryStream.Create;
    try
      while true do begin
        succeed := ReadFile(PipeErrorsRead, Buffer, 255, NumberOfBytesRead, nil);
        if not succeed then break;
        Stream.Write(Buffer, NumberOfBytesRead);
      end;
      Stream.Position := 0;
      Errors.LoadFromStream(Stream);
    finally
      Stream.Free;
    end;
    CloseHandle(PipeErrorsRead);

    WaitForSingleObject(ProcessInfo.hProcess, INFINITE);
    CloseHandle(ProcessInfo.hProcess);
  end
  else begin
    result:=false;
    CloseHandle(PipeOutputRead);
    CloseHandle(PipeOutputWrite);
    CloseHandle(PipeErrorsRead);
    CloseHandle(PipeErrorsWrite);
  end;
end;

Damit kann ich den Output eines Konsolenfensters auslesen.

[Reinhardtinho]

Zitat:

Zitat von Mogtar

ah das hat geholfen, allerdigns bekomme ich imemr nur die erste zeile der boot.ini :(
wie setze ich den Lesezeiger weiter?

Delphi-Quellcode:

var
  sOutput: string;
begin
  { TODO -oUser -cConsole Main : Hier Code einfügen }


  repeat
    read(sOutPut);
    Write(sOutPut);
  until sOutPut <> '';



end.

ReadLn statt Read.

ReadLn liest die Zeile und setzt den Zeiger auf die nächste Zeile, während Read nur die Zeile einliest.

[marabu]

Hi

Delphi-Quellcode:

var
  line: string;

begin
  AssignFile(input, ''); //stdin
  AssignFile(output, ''); //stdout
  Reset(input);
  Rewrite(output);
  while not Eof do
  begin
    ReadLn(line);
    WriteLn(line);
  end;
  CloseFile(output);
  CloseFile(input);
end.

Grüße vom marabu

[Andi1985]

Zitat:

Zitat von Reinhardtinho

Zitat:

Zitat von Mogtar

ah das hat geholfen, allerdigns bekomme ich imemr nur die erste zeile der boot.ini :(
wie setze ich den Lesezeiger weiter?

Delphi-Quellcode:

var
  sOutput: string;
begin
  { TODO -oUser -cConsole Main : Hier Code einfügen }


  repeat
    read(sOutPut);
    Write(sOutPut);
  until sOutPut <> '';



end.

ReadLn statt Read.

ReadLn liest die Zeile und setzt den Zeiger auf die nächste Zeile, während Read nur die Zeile einliest.

DAS geht genausowenig, ich erhalte nur die erste Zeile der Boot.ini..!

[DeddyH]

So simpel? Wer hätte das gedacht :lol:

[Andi1985]

Zitat:

Zitat von marabu

Hi

Delphi-Quellcode:

var
  line: string;

begin
  AssignFile(input, ''); //stdin
  AssignFile(output, ''); //stdout
  Reset(input);
  Rewrite(output);
  while not Eof do
  begin
    ReadLn(line);
    WriteLn(line);
  end;
  CloseFile(output);
  CloseFile(input);
end.

Grüße vom marabu

Das funktioniert. :)
vielen Dank an alle die mir geholfen haben! :)

[closed]

[gammatester]

Der Code aus den Beiträgen sollte natürlich angepasst werden. Wenn Du readln verwendest, sollte auch writeln verwendet werden. Un selbstverständlich hört man nicht auf wenn man irgendwas nichtleeres gelesen hat! (Also kein Wunder, daß Du nur die erste Zeile liest). Also ingesamt etwa so:

Delphi-Quellcode:

var
  sOutput: string;
begin
  while not eof(input) do begin
    readln(sOutPut);
    Writeln(sOutPut);
  end;
end.

Gruß Gammatester

[Andi1985]

mir ist aber noch etwas aufgefallen:
wenn ich nun meine exe normal aufrufe ohne Type C:\boot.ini | dann bleibt er bei EOF hängen :(

[Hansa]

Wiseo geht das hier nicht ?

Delphi-Quellcode:

var s : TStringList;
begin
  s.LoadFromFile ('C:\boot.ini');

Oder muss es komplizierter sein ? :shock:

[marabu]

Dein Programm erwartet Daten auf STDIN. Wenn diese Daten nicht über eine Pipe angeliefert werden, dann kannst du sie per input redirection "prog < filename" bereit stellen. Oder per command line parameter:

Delphi-Quellcode:

begin
  AssignFile(input, ParamStr(1));
  // ...
end;

Das Ende der Eingabe kannst du über die Tastatur mit Strg+Z signalisieren, wenn du keine Eingabe-Umleitung verwendet hast.

[Andi1985]

Zitat:

Zitat von marabu

Dein Programm erwartet Daten auf STDIN. Wenn diese Daten nicht über eine Pipe angeliefert werden, dann kannst du sie per input redirection "prog < filename" bereit stellen. Oder per command line parameter:

Delphi-Quellcode:

begin
  AssignFile(input, ParamStr(1));
  // ...
end;

Das Ende der Eingabe kannst du über die Tastatur mit Strg+Z signalisieren, wenn du keine Eingabe-Umleitung verwendet hast.

versteh ich nicht ganz ...

entweder hab ich den Aufruf meiner exe mit einem PIPE davor oder nicht...
wenn meine Exe normal aufgerufen wird... soll sie den quellcode (siehe oben) nicht ausführen..

ah das ist aber schlecht, kann man nicht abfragen ob "aufruf mit pipe oder ohne" ?
also

Delphi-Quellcode:

WENN PIPE DANN
AssignFile(input, ''); //stdin
  AssignFile(output, ''); //stdout
  Reset(input);
  Rewrite(output);
  while not Eof do
  begin
    ReadLn(line);
    WriteLn(line);
  end;
  CloseFile(output);
  CloseFile(input); 
END

[gammatester]

Zitat:

Zitat von Mogtar

mir ist aber noch etwas aufgefallen:
wenn ich nun meine exe normal aufrufe ohne Type C:\boot.ini | dann bleibt er bei EOF hängen :(

Dann gibt doch ein EOF ein: CtrlZ bzw. StrgZ.

Gammatester

[Andi1985]

Zitat:

Zitat von gammatester

Zitat:

Zitat von Mogtar

mir ist aber noch etwas aufgefallen:
wenn ich nun meine exe normal aufrufe ohne Type C:\boot.ini | dann bleibt er bei EOF hängen :(

Dann gibt doch ein EOF ein: CtrlZ bzw. StrgZ.

Gammatester

versteh ich jetzt nicht was du meinst...

[gammatester]

Zitat:

Zitat von Mogtar

Zitat:

Zitat von gammatester

Zitat:

Zitat von Mogtar

mir ist aber noch etwas aufgefallen:
wenn ich nun meine exe normal aufrufe ohne Type C:\boot.ini | dann bleibt er bei EOF hängen :(

Dann gibt doch ein EOF ein: CtrlZ bzw. StrgZ.

Gammatester

versteh ich jetzt nicht was du meinst...

Er hängt nicht, sondern wartet auf EOF. Und das mußt Du halt eingeben, und das ASCII-Zeichen dafür es ist nun mal ein CtrlZ bzw. StrgZ, oder vergleiche:

Zitat:

Zitat von marabu

Das Ende der Eingabe kannst du über die Tastatur mit Strg+Z signalisieren ...

[Andi1985]

aber das Programm soll ohne die Manuelle Eingabe des Benutzern laufen...
wenn ich dich jetzt richtig verstehe.. das heißt ich muss das Quellcodetechnisch abfangen... nur wie...

[gammatester]

Zitat:

Zitat von Mogtar

aber das Programm soll ohne die Manuelle Eingabe des Benutzern laufen...
wenn ich dich jetzt richtig verstehe.. das heißt ich muss das Quellcodetechnisch abfangen... nur wie...

???

Du wolltest doch wissen, wie man ein EOF eingibt, wenn man das Programm interaktiv ohne Redirection startet! (Genauer Du hast behauptet "er hängt wenn ..."). Und nur darauf habe ich geantwortet.

Wenn Du die ganze Zeit meinst, wie man feststellen kann, ob input umgeleitet ist oder eine Konsole ist: Es muß irgendwo eine API-Funktion geben, die in etwa sagt "handle is console" (jedenfalls gibt's das im DOS-API, und es würde mich wundern wenn's so eine Fkt. nicht für WIN32 gibt). Als Handle dann entweder TTextRec(input).Handle oder GetStdHandle(STD_INPUT_HANDLE) verwenden. (Ungetestet! Also ausprobieren, bzw. selbstfinden oder auf Hinweise von anderen DP-Usern warten).

Gammatester

Zusatz via Edit: Ein kurzer Test zeigt, daß

Delphi-Quellcode:

GetFileType(GetStdHandle(STD_INPUT_HANDLE))

je nach Aufrufart unterschiedliche Werte liefert, hier für die Werte siehe Delphihilfe zu GetFileType

[Andi1985]

Zitat:

Zitat von gammatester

Zusatz via Edit: Ein kurzer Test zeigt, daß

Delphi-Quellcode:

GetFileType(GetStdHandle(STD_INPUT_HANDLE))

je nach Aufrufart unterschiedliche Werte liefert, hier für die Werte siehe Delphihilfe zu GetFileType

cool, danke^^

[RWarnecke]

Zitat:

Zitat von Hansa

Wiseo geht das hier nicht ?

Delphi-Quellcode:

var s : TStringList;
begin
  s.LoadFromFile ('C:\boot.ini');

Oder muss es komplizierter sein ? :shock:

Hansa da gebe ich Dir recht, warum einfach wenn es auch umständlich geht. Das gleiche ist mit meiner Funktion. Einfach den Befehl Type boot.ini übergeben und als Ergebnis die Ausgabe.

[Hansa]

So was wie hier, das sind Threads, wo es schon fast zu blöd wird, zu antworten. :lol: @Fragesteller : warum ist LoadFromFile bei dir nicht möglich ? Nur, um Daten aus einer Textdatei im Programm auszuwerten ? :wall: Ja, echt sagenhaft. :mrgreen:

[p80286]

Hallo zusammen,

naja man kann es schon steuern.
1) wenn Parameter übergeben werden, dann darf das Programm einlesen (von STDIN) ansonsten wird nur eine Fehlermeldung ausgegeben.
2) wenn Parameter übergeben werden, dann liest das Programm aus der übergebenen Datei ansonsten von STDIN.

Wenn ich mich richtig erinnere liefert Paramamstr(1) bei solchen Konstrukten
Meinprog.exe >papierkorb.txt
dann '>papierkorb.txt' zurück. Das Umleiten muß also vom Programm selbst erledigt werden.

Die andere Möglichkeit wäre es mit zwei Threads zu versuchen. Einer lauscht, und der andere dreht den Saft ab wenn nach x Sekunden keine Eingabe erfolgte.

Die Fragestellung erinnert mich ein wenig an meine Tochter. Wenn etwas machbar war, mußte es auch gemacht werden. Das ist jetzt allerdings auch schon 18 Jahre her.

Grüße
K-H

[MSSSSM]

Zitat:

Zitat von p80286

Wenn ich mich richtig erinnere liefert Paramamstr(1) bei solchen Konstrukten
Meinprog.exe >papierkorb.txt
dann '>papierkorb.txt' zurück. Das Umleiten muß also vom Programm selbst erledigt werden.

versuch mal
Meinprog.exe > papierkorb.txt

[marabu]

Hallo,

unabhängig von den mir unbekannten Absichten des Thread Owners möchte ich noch folgendes zu bedenken geben: Jede Konsolenanwendung sollte so geschrieben werden, dass Power-User nicht behindert werden. Eigentlich ist die Unterstützung der Standard I/O-Kanäle eine Entwurfsentscheidung, die aus verschiedenen Verarbeitungsszenarien folgt, z.B. eine Eingabedatei soll verändert werden und das Resultat soll als neue Datei weggeschrieben werden - die von Unix her bekannten filter tools arbeiten genau so. In diesem Fall erwarte ich die Verwendung von STDIN und STDOUT einfach. Da hier eine INI-Datei verarbeitet werden soll und Delphi die entsprechenden Klassen zur bequemen Verarbeitung solcherart strukturierter Textdateien anbietet, gilt es beides unter einen Hut zu bringen.

Delphi-Quellcode:

uses
  Classes,
  IniFiles,
  Windows,
  SysUtils;

var
  stream: TStream;
  strings: TStrings;
  ini: TMemIniFile;

begin
  ini := TMemIniFile.Create('');
  strings := TStringList.Create;
  if ParamCount = 0
    then stream := THandleStream.Create(GetStdHandle(STD_INPUT_HANDLE))
    else stream := TFileStream.Create(ParamStr(1), fmOpenRead);
  strings.LoadFromStream(stream);
  stream.Free;
  ini.SetStrings(strings);
  strings.Free;
  if ini.SectionExists(SECTION) then
  begin {
    ... roll your own dice ...
} end;
  ini.Free;
end;

So wird ein im Programm festgeschriebener Dateiname vermieden, die Datei kann über piping oder redirection verarbeitet werden und auf den Inhalt kann bequem zugegriffen werden. Alternativ kann die Eingabedatei auch als Parameter übergeben werden.

Bei einem einfachen StringList.LoadFromFile('C:\BOOT.INI') wird die Einbettung in die Ablaufumgebung nicht berücksichtigt.

Freundliche Grüße

[gammatester]

Zitat:

Zitat von marabu

So wird ein im Programm festgeschriebener Dateiname vermieden, die Datei kann über piping oder redirection verarbeitet werden und auf den Inhalt kann bequem zugegriffen werden. Alternativ kann die Eingabedatei auch als Parameter übergeben werden.

Allerdings wird nicht zeilenweise von der Standardeingabe gelesen, wenn weder Dateiname noch piping oder redirection gewählt werden: Unter Win2000 wird nur 1 Zeile unter Win98 keine Zeile verarbeitet. Und das war ja wohl eine Vorgabe/Wunsch von Mogtar.

Gammatester

[marabu]

Moin,

ich hatte meinen Code in Beitrag #33 als unabhängig von Mogtars konkreten Anforderungen deklariert und mich nur auf das Problem der INI-Daten und deren Verarbeitung konzentriert, da das zeilenweise Verarbeiten ja schon früher im Thread gezeigt wurde, aber okay - hier die Verknüpfung der beiden Code-Teile, damit niemand stolpert:

Delphi-Quellcode:

program Demo;

{$APPTYPE CONSOLE}

uses
  Classes,
  IniFiles,
  Windows,
  SysUtils;

var
  stream: TStream;
  strings: TStrings;
  ini: TMemIniFile;
  h: THandle;
  ft: Cardinal;
  line: string;

const
  SECTION = 'boot loader';

begin
  ini := TMemIniFile.Create('');
  strings := TStringList.Create;
  h := GetStdHandle(STD_INPUT_HANDLE);
  ft := GetFileType(h);
  if ParamCount > 0 then
    stream := TFileStream.Create(ParamStr(1), fmOpenRead)
  else if ft <> FILE_TYPE_CHAR then
    stream := THandleStream.Create(h)
  else
    stream := nil;
  if Assigned(stream) then
  begin
    strings.LoadFromStream(stream);
    stream.Free;
  end else
  begin
    AssignFile(input, '');
    Reset(input);
    while not Eof do
    begin
      ReadLn(line);
      strings.Add(line);
    end;
    CloseFile(input);
  end;
  ini.SetStrings(strings);
  strings.Free;
  if ini.SectionExists(SECTION)
    then WriteLn('roll your own dice ...')
    else WriteLn('unexpected data found');
  ini.Free;
end.

Freundliche Grüße

[turboPASCAL]

[OT] Nanu, Delphi-Tags kaputt ? Sie sind eigentlich gesetzt...[/OT]