32-Bit-Programm soll 32- und 64-Bit-OS erkennen

[Luckie]

Also diese:

Delphi-Quellcode:

function IsWOW64: Boolean;
type
  TIsWow64Process = function( // Type of IsWow64Process API fn
    Handle: THandle;
    var Res: BOOL
  ): BOOL; stdcall;
var
  IsWow64Result: BOOL;              // result from IsWow64Process
  IsWow64Process: TIsWow64Process;  // IsWow64Process fn reference
begin
  // Try to load required function from kernel32
  IsWow64Process := GetProcAddress(
    GetModuleHandle('kernel32'), 'IsWow64Process'
  );
  if Assigned(IsWow64Process) then
  begin
    // Function is implemented: call it
    if not IsWow64Process(GetCurrentProcess, IsWow64Result) then
      raise Exception.Create('Bad process handle');
    // Return result of function
    Result := IsWow64Result;
  end
  else
    // Function not implemented: can't be running on Wow64
    Result := False;
end;

Genau das haben wir ja schon gesagt: Dynamisch einbinden.

Aber ich würde sie umbenennen: Is32BitProcess bei IsWow64Process bekomme ich immer einen Knoten im Hirn. Ich muss dann immer überlegen was es eigentlich heißt.

[DeddyH]

Und die Funktion muss ja im Gegensatz zur ersten Behauptung in beiden DLL-Versionen vorhanden sein:
- 32Bit-Exe: kann keine 64Bit-DLL laden und somit die Funktion gar nicht ermitteln -> sie wäre somit nutzlos
- 64Bit-Exe: sobald sie läuft, ist das ja wohl automatisch ein 64Bit-OS

[CCRDude]

Die 32 bit .exe lädt automatisch die 32 bit kernel32.dll, eine 64 bit .exe lädt automatisch die 64 bit kernel32.dll

Somit sähe das korrekt so aus:

- 32Bit-Exe unter 32Bit-Win: lädt kernel32.dll(32Bit), findet dort kein IsWow64Process - also false.
- 32Bit-Exe unter 64Bit-Win: lädt kernel32.dll(32Bit), findet dort IsWow64Process - also true.
- 64Bit-Exe: lädt kernel32.dll(64bit), findet dort IsWow64Process, welches false zurückgeben dürfte.

Ein Umbenennen in Is32BitProcess wäre etwas anderes (bzw. das kommt halt drauf an, wie man obige Situationen auswertet) - Is32BitProcess wäre für mich aber vermutlich sinnlos, weil ich das bereits zur Compile Time per Direktive regeln könnte.

[DeddyH]

Ja eben, von daher stimmt die anfangs getroffene Behauptung, die Funktion gäbe es nur in der 64Bit-Version der DLL, nicht bzw. kann ja gar nicht stimmen.

[Delphi-Laie]

Für ein 32-Bit-Programm ist die hier verlinkte und auch hier veröffentlichte Funktion erschöpfend. Für einen allgemeingültigen Quelltext, nämlich einen, der 32- und 64-Bit-Compilate - möglichst ohne Compilerschalter - übersetzt, taugt sie jedoch nicht(s), denn ein 64-Bit-Programm wird sich nie in einer Wow64-Umgebung wiederfinden und mithin fälschlicherweise 32 Bit zurückmelden (bzw. genaugenommen die 64 Bit verneinen).

Wird von dem Programm vorher auf 64 Bit geprüft, so z.B. mit der Größe eines Pointers, müßte dieser Quelltext "bitanzahlübergreifend" funktionieren, denn ein 64-Bit-Programm wird dann die 64 Bit zurückliefern, anderenfalls geht es wie gewohnt weiter. Diese Prüfung kann vorangestellt werden und mithin vor dem Funktionsaufruf oder am Anfang derselben geschehen (Quellcode etwas vereinfacht und an das originale PBool angepaßt):

Delphi-Quellcode:

function Is64BitWin:Boolean;
var
  IsWow64Result:BOOL;
  IsWow64Process:function(Handle:THandle;var Res:PBOOL):BOOL;stdcall;
begin
if SizeOf(Pointer)>4 {=8?!} then 
  begin
  result:=true;
  exit
  end
else
  begin
  IsWow64Process:=GetProcAddress(GetModuleHandle('kernel32'),'IsWow64Process');
  if Assigned(IsWow64Process) then
    begin
    if not IsWow64Process(GetCurrentProcess, IsWow64Result) then
      raise Exception.Create('Bad process handle');
    Result:=Boolean(IsWow64Result)
    end
  else Result:=false
  end
end;

Die Exceptionmeldung ist n.m.B. nicht nötig und stört nur. Auch wenn der Funktionsaufruf "IsWow64Process" fehlschlägt, sind die Ergebnisse korrekt.

[RWarnecke]

Irgendwie verstehe ich Dein Vorgehen nicht. Wenn ich ein Programm für 64Bit kompiliere, wozu brauche ich dann noch eine Abfrage ob mein Betriebssystem 32 oder 64 Bit ist. Ein 64Bit Programm greift auf die richtige Struktur zurück. Nur bei einem 32Bit Programm, welches auf einem 64Bit OS ausgeführt wird ist es wichtig auf die WOW6432Node - Registry Schlüssel zuzugreifen. Deshalb muss hier im Vordergrund eine Prüfung auf 32 oder 64 Bit stattfinden.

[Delphi-Laie]

Zitat von RWarnecke:

Irgendwie verstehe ich Dein Vorgehen nicht. Wenn ich ein Programm für 64Bit kompiliere, wozu brauche ich dann noch eine Abfrage ob mein Betriebssystem 32 oder 64 Bit ist. Ein 64Bit Programm greift auf die richtige Struktur zurück. Nur bei einem 32Bit Programm, welches auf einem 64Bit OS ausgeführt wird ist es wichtig auf die WOW6432Node - Registry Schlüssel zuzugreifen. Deshalb muss hier im Vordergrund eine Prüfung auf 32 oder 64 Bit stattfinden.

Das ist mir völlig klar. Ich schrieb doch oben, daß sich so der Quelltext wenigstens bei der Prüfung der "Bittigkeit" des Windows in bezug auf die Bitanzahlen vereinheitlichen läßt, man kommt demnach ohne die Compilerschalter WIN32 und/oder WIN64 aus.

[RWarnecke]

Zitat von Delphi-Laie:

Das ist mir völlig klar. Ich schrieb doch oben, daß sich so der Quelltext wenigstens bei der Prüfung der "Bittigkeit" des Windows in bezug auf die Bitanzahlen vereinheitlichen läßt, man kommt demnach ohne die Compilerschalter WIN32 und/oder WIN64 aus.

Was machst Du, wenn Du für 64Bit einen komplett anderen Quelltext brauchst als für 32 Bit und dieser unter 32Bit nicht zu kompilieren ist ? Du kommst aus meiner sicht nicht um die Compiler-Schalter drumrum. Da zum Teil die verwendeten Units unterschiedlich sein können. Hier mal ein Beispiel :

Delphi-Quellcode:

uses
  System.SysUtils, System.Types, System.UITypes, System.Classes, System.Variants,
  FMX.Types, FMX.Controls, FMX.Forms, FMX.Dialogs, {$IFDEF POSIX} Posix.SysTypes, Posix.Time, {$ENDIF}
  FMX.Layouts, FMX.Memo;

Wenn ich hier die IFDEF-Deklaration entferne, kann ich das Programm mit der USES-Klausel nur noch für MAC OSX kompilieren. Steht die IFDEF-Deklaration drin, kann ich es für 32/64Bit Windows und für Mac OSX kompilieren. Es ist eine Firemonkey-Anwendung.

Deshalb nochmal meine Frage, wozu brauche ich die IF-Abfrage auf den Pointer in der Procedure Is64BitWin ? Wenn ich das ganze über die Kompilerschalter regel habe ich es doch viel sauberer.

[Delphi-Laie]

Man kann diesen Code unabhängig für die Bitanzahl verwenden - er ist sozusagen bitanzahlneutral. Es ist ein gemeinsamer Code für beide Bitanzahlen. Mehr kann ich dazu wirklich nicht mehr sagen, zumal ich mich inzwischen wiederhole. Man muß es ja so nicht lösen, sondern es ist auch so möglich:

Zitat von RWarnecke:

Wenn ich das ganze über die Kompilerschalter regel habe ich es doch viel sauberer.

Richtig, so geht es auch. Sauberer? Womöglich übersichtlicher? Das ist mit Sicherheit (auch) eine Geschmacks-/Ansichtsfrage. Compilerschalter zerstückeln den Code ja gewissermaßen, es werden auf Ihrer Basis beim Compilieren i.d.R. nur Teile des Codes verarbeitet (sonst wären sie nicht sinnvoll). Das andere Extrem (oder neudeutsch "Ende der Fahnenstange") wären zwei in Form separater Dateien getrennte Quelltexte.

Insofern sollte mein Beispiel das eine/andere Ende der Fahnenstange aufzeigen - nicht mehr und nicht weniger.