Access Violation - Interface win 32 - win 64

[TomyN]

Hallo,

Interfaces & Guid etc. sind nicht so mein Ding. Daher hier die nächste Frage

Ich habe eine C++ Vorgabe

Code:

interface IA4APRIVATE : public IUnknown
{
   virtual   DWORD  iA4APrivateGetVersion() = 0;
   virtual   void iA4APrivateEnumerate() = 0;
   virtual   void iA4APrivateEnumSetCallback(BOOL(void*), void* pCbData) = 0;
        ....
}

Das Ganze habe ich wie folgt 'verdelphiet'

Code:

 IA4APRIVATE = interface(IUnknown)
    ['{A26078C5-2840-4726-B427-E60FC8FEE403}']
    function  iA4APrivateGetVersion(): dWord; stdCall;
     procedure iA4APrivateEnumerate();   stdCall;
    procedure iA4APrivateEnumSetCallback(handled: boolean; pCbData: pByte); stdCall;
    ....
end;

Soweit, so gut.

Nun rufe ich das ganze wie folgt auf:

Code:

uses A4APrivateDeclaration, Asio, windows;

type TA4APrivate = Class (TObject)
  Private
    IA4APrivate: A4APrivateDeclaration.IA4APRIVATE;
    versionString:  String;
    function InterfaceOk: boolean;
    function IsResultOk(const lastResult: dWord): boolean;
  Public
    constructor Create;
    Destructor  Destroy; override;
    Function InitInterface(const asioInterface: Asio.IAsio): boolean;
    Function GetVersionString: String;
end;

Function TA4APrivate.InterfaceOk: boolean;
begin
  result:= ( Assigned(iA4APrivate) );
end;

Function TA4APrivate.InitInterface(const asioInterface: IASIO): boolean;
var dl: dWord;
begin
  IA4APrivate:= nil; //Just for safety
  result:= Assigned(asioInterface);
  if result then begin
    result:= ActiveX.Succeeded(asioInterface.QueryInterface(
                          A4APrivateDeclaration.IID_IA4APRIVATE, IA4APrivate));
    result:= result And InterfaceOk;
    if result then begin
      dl:= IA4APrivate.iA4APrivateGetVersion;
      versionString:= IntToHex(hiWord(dl),4) + '.' +
                        IntToHex(loWord(dl), 4);
    end else begin
      versionString:= 'Error';
    end;
  end; //Breakpoint for check
end;

Und jetzt passiert folgendes (wenn man mit dem entsprechenden AsioInterface aufruf).

- Queryinterface findet das Interface
- Für windows 64 compiliert alles okay
- Für windows 32 compiliert läuft es bis zum Ende durch (Breakpoint), versionString enthält den korrekten Wert, aber dann bekomme ich einen Access-Violation error.

Wenn im zweiten Fall nichst oder eine Schmarn zurückkäme, dann würde ich sagen, okay, funktioniert halt mit 32Bit nicht. Aber so bin ich völlig verwirrt..

Hier noch der Aufruf der Funktion

Code:

procedure TASIOIO.InitA4APrivate;
var
  bl: Boolean;
  hs: String;
begin
  if (Assigned(iA4AP)) then begin
    //Just check for the A4A Private Interface
    bl := iA4AP.InitInterface(treiber.Driver);
    if bl then begin
      hs:= iA4AP.GetVersionString;
       Messagebox(0, pChar(hs), 'Juhu', mb_Ok);
    end;
  end;
end;

Ich hab schon versucht im Netz einen Hinweis zu finden, aber anscheinend habe ich die falschen Suchworte....

Tomy

[Daniel]

Bitte gib Deinem Beitrag einen aussagekräftigen Titel - das kannst Du tun, indem Du diesen entsprechend bearbeitest.

[TiGü]

Hast du auch eine AV in Win32, wenn du den konkreten Aufruf auf

Delphi-Quellcode:

dl:= IA4APrivate.iA4APrivateGetVersion;

auskommentierst?

[TomyN]

Hi Daniel

Danke für die Erinnerung. Irgendwie hat es da was zerhaut..

Sollte jetzt behoben sein.

Tomy

[TomyN]

Hi,

Es wird immer seltsamer .....

Code:

 
 //dl:= IA4APrivate.iA4APrivateGetVersion;
 dl:= $12345678;
 versionString:= IntToHex(hiWord(dl),4) + '.' + IntToHex(loWord(dl), 4);

Funktioniert wunderbar, inkl. Abruf des Resultats über GetVersionString.
Auch der Originalcode liefert intern den richtigen String ab. Die AV kommt erst beim Aufruf von GetVersionString.

Code:

type TA4APrivate = Class (TObject)
  Private
    IA4APrivate: A4APrivateDeclaration.IA4APRIVATE;
    versionString:  String;
    function InterfaceOk: boolean;
    function IsResultOk(const lastResult: dWord): boolean;
  Public
    constructor Create;
    Destructor  Destroy; override;
    Function InitInterface(const asioInterface: Asio.IAsio): boolean;
    Function GetVersionString:string;
end;

implementation
Uses sysUtils, activeX;

....

Function TA4APrivate.GetVersionString: string;
begin
  result:= versionString;
end;

[TiGü]

Zeig uns mal den Aufruf von TA4APrivate.Create und die Zuweisung zu einer Variablen.

[TomyN]

Code:

  iA4AP:            Asio4AllPrivate.TA4APrivate;
...

iA4AP:=         Asio4AllPrivate.TA4APrivate.create;

[TiGü]

Kommt denn auch eine AV, wenn du den Inhalt der Funktion ersetzt?

Delphi-Quellcode:

Function TA4APrivate.GetVersionString: string;
begin
  result:= 'beliebiger konstanter String';
end;

[TomyN]

Hi,

Aktuell verhält sich das ganze nicht konsistent und es ist zuviel drum rum. Da werde ich die nächsten Tage mal ein simples Progrämmchen machen und mich weiter reinwühlen.
Aktuell ist es so:

Code:

Function TA4APrivate.InitInterface(const asioInterface: IASIO): boolean;
var dl: dWord;

begin
  iAp:= nil; //Just for safety
  result:= Assigned(asioInterface);
  if result then begin
    result:= ActiveX.Succeeded(asioInterface.QueryInterface(
                          A4APrivateDeclaration.IID_IA4APRIVATE, iAP));
    result:= result And InterfaceOk;
    if result then begin
      dl:= iAP.iA4APrivateGetVersion;
      myVersionString:= IntToHex(hiWord(dl), 4) + '.' +
                          IntToHex(loWord(dl), 4);
      MessageBox(0, pChar(myVersionString), 'Info', mb_ok);
    end;
  end;
end;

Läuft soweit gut, die Messagebox zeigt auch die richtige Version an, aber sobald ich OK klicke, kommt der Fehler wieder. Die CPU Ansicht zeigt vier Fragezeichen :-).
Den Aufruf habe ich inzwischen soweit reduziert:

Code:

procedure TASIOIO.InitA4APrivate;
begin
  if (Assigned(iA4AP)) then begin
    //Just check for the A4A Private Interface
    iA4AP.InitInterface(treiber.Driver);
  end;
end;

Für win64 compiliert läuft alles wie es soll. Ich vermute ein Speicherzugriffsproblem, d.h. es wird nur Speicher für 32Bit reserviert, aber für 64Bit freigegeben. Hab aber keine Ahnung, was man da machen kann.

Ich berichte weiter...

[Stevie]

Sicher, dass die Aufrufkonvention stdcall richtig ist und nicht etwa thiscall? Auf Win64 gibt es nur eine, daher funktionierts da auch.