[Unicode/NT] Argumente eines Programms holen ...

[Assarbad]

Hiho,

als Delphianer lehnt man sich ja oft zurück und benutzt mal eben ParamCount und ParamStr(x). Leider ist diese Variante nur mit ANSI-Longstrings möglich ... Unicode ... keine Spur :-/

Leider, aber genau dazu gibt es ja eine wunderschöne Funktion seit Windows NT 3.5: CommandLineToArgvW()

Hier der Prototyp:

Delphi-Quellcode:

type
  TWCarr = array[0..0] of PWideChar;
  PWCarr = ^TWCarr;

function CommandLineToArgvW(
  lpCmdLine: PWideChar;
  var NumArgs: Integer
  ): PWCarr; stdcall; external 'shell32.dll';

Hier ein Anwendungsbeispiel. Parameter 1 ist der Modulname ... Parameter 2 ist dann das nächste etc pp.
Die Indizes in im Array sind aber nullbasiert ... also ist Parameter 1 mit Index 0 erreichbar etc pp.
Im Integerwert wird die Anzahl der zurückgegebenen Parameter eingetragen.
Freigeben obliegt dem Programm, welches die Funktion benutzt (siehe FINALLY).

Delphi-Quellcode:

var
  i: Integer;
  arrParams: PWCarr;
begin
  arrParams := CommandLineToArgvW(GetCommandLineW, i);
  if arrParams <> nil then
  try
    case i of
      3:
        Writeln(String(arrParams^[i - 1])); // Parameter 3
    else
        Writeln(String(arrParams^[i - 2])); // Parameter 2
    end;
  finally
    GlobalFree(THandle(arrParams));
  end;
end;

[CalganX]

Nachtrag von himitsu:

Zitat von Assarbad:

Leider ist diese Variante nur mit ANSI-Longstrings möglich ... Unicode ... keine Spur :-/

Erstens sind in Delphi aus historischen Gründen viele Funktionen/Prozeduren nur als Ansi-Varianten und einige sogar nur in SingleByte-Ausführung vorhanden.
Und dann steht auch noch vollgendes im Win32 SDK.

Zitat von Microsoft Win32 Software Development Kit:

Non-Unicode console processes written in C can use the argc and argv arguments to access the command-line arguments. The parameters of the command-line string, excluding the program name, are also available to such non-Unicode applications as a parameter of the WinMain function. The reason for the Unicode exclusion from these options is that WinMain, argc, and argv use the LPSTR data type for parameters, not the LPTSTR datatype.

So, nun muß ich wohl auch noch meine Version vorstellen -.-''

Delphi-Quellcode:

Function _ParamCount: LongInt;
Function ParamStrA(Index: LongInt): AnsiString;
Function ParamStrW(Index: LongInt): WideString;

Delphi-Quellcode:

// © 1997-2005 by FNS Enterprize's™
//   2003-2005 by himitsu @ Delphi-PRAXiS

  Function _ParamCount: LongInt;
    Var P: PAnsiChar;
      B: Boolean;

    Begin
      Result := 0;
      P := GetCommandLineA;
      If P <> nil Then Dec(Result) Else Exit;
      While P^ <> #0 do Begin
        While (P^ <> #0) and (P^ <= ' ') do Inc(P);
        B := False;
        If P^ <> #0 Then Inc(Result);
        While (P^ <> #0) and ((P^ > ' ') or B) do Begin
          If P^ = '"' Then B := not B;
          Inc(P);
        End;
      End;
    End;

  Function ParamStrA(Index: LongInt): AnsiString;
    Var P, P2: PAnsiChar;
      i: Integer;
      B: Boolean;

    Begin
      If Index = 0 Then Begin
        SetLength(Result, MaxPath);
        SetLength(Result, GetModuleFileNameA(0, Pointer(Result), MaxPath));
        Exit;
      End Else If Index < 0 Then Inc(Index);
      P := GetCommandLineA;
      If P <> nil Then
        While P^ <> #0 do Begin
          While (P^ <> #0) and (P^ <= ' ') do Inc(P);
          P2 := P;  i := 0;  B := False;
          While (P2^ <> #0) and ((P2^ > ' ') or B) do Begin
            If P2^ <> '"' Then Inc(i) Else B := not B;
            Inc(P2);
          End;
          If (Index = 0) and (P <> P2) Then Begin
            SetLength(Result, i);
            i := 1;
            Repeat
              If P^ <> '"' Then Begin  Result[i] := P^;  Inc(i);  End;
              Inc(P);
            Until P >= P2;
            Exit;
          End;
          P := P2;
          Dec(Index);
        End;
      Result := '';
    End;

  Function ParamStrW(Index: LongInt): WideString;
    Var P, P2: PWideChar;
      i: Integer;
      B: Boolean;

    Begin
      If Index = 0 Then Begin
        SetLength(Result, MaxPath);
        SetLength(Result, GetModuleFileNameW(0, Pointer(Result), MaxPath));
        Exit;
      End Else If Index < 0 Then Inc(Index);
      P := GetCommandLineW;
      If P <> nil Then
        While P^ <> #0 do Begin
          While (P^ <> #0) and (P^ <= ' ') do Inc(P);
          P2 := P;  i := 0;  B := False;
          While (P2^ <> #0) and ((P2^ > ' ') or B) do Begin
            If P2^ <> '"' Then Inc(i) Else B := not B;
            Inc(P2);
          End;
          If (Index = 0) and (P <> P2) Then Begin
            SetLength(Result, i);
            i := 1;
            Repeat
              If P^ <> '"' Then Begin  Result[i] := P^;  Inc(i);  End;
              Inc(P);
            Until P >= P2;
            Exit;
          End;
          P := P2;
          Dec(Index);
        End;
      Result := '';
    End;

Und hier noch die weiteren Funktionsdefinitionen, falls diese fehlen sollten.
Allerdings kann man diese vermutlich schon in der Windows-Unis von Delphi finden.

Delphi-Quellcode:

Const Kernel = 'kernel32.dll';

Function GetModuleFileNameA(Module: THandle; Buffer: PAnsiChar; BufferSize: LongInt): LongInt; StdCall;
  External Kernel Name 'GetModuleFileNameA';
Function GetModuleFileNameW(Module: THandle; Buffer: PWideChar; BufferSize: LongInt): LongInt; StdCall;
  External Kernel Name 'GetModuleFileNameW';
Function GetCommandLineA: PAnsiChar; StdCall; External Kernel Name 'GetCommandLineA';
Function GetCommandLineW: PWideChar; StdCall; External Kernel Name 'GetCommandLineW';