Übersetzung C++ -> Pascal, Callback, Zugriffsverletzung

[_BlackDragon_]

Hi Leute,

hab ein Problem bei der Übersetzung einer API von C++ nach Pascal/Delphi.

Erstmal die Deklaration der Original Callback Routine:

Code:

typedef void*( * ADL_MAIN_MALLOC_CALLBACK)(int)

Zitat:

Memory Allocation Call back.

Die Callback-Routine in Delphi als Typ deklariert:

Delphi-Quellcode:

type TADL_MAIN_MALLOC_CALLBACK = function(iSize: Integer): Pointer; stdcall;

So weit denke ich, das es richtig übersetzt ist.

Jetzt kommt die Routine aus der API, welche diese Callback-Routine nutzen soll.

Code:

int  ADL_Main_Control_Create (ADL_MAIN_MALLOC_CALLBACK callback, int iEnumConnectedAdapters)

Zitat:

Function to initialize the ADL interface. This function should be called first.

This function initializes the ADL library. It also initializes global pointers and, at the same time, calls the ADL_Main_Control_Refresh function.

Supported Platforms:
Linux and Windows(XP and Vista); 32bit and 64bit
Parameters:
[in] callback,: The memory allocation function for memory buffer allocation. This must be provided by the user. ...

Und meine Übersetzung:

Delphi-Quellcode:

type
  TADL_Main_Control_Create = function(CallBack: TADL_MAIN_MALLOC_CALLBACK;
                                      iEnumConnectedAdapters: Integer): Integer; stdcall;

Laut der Doku und den Beispielen, sieht die Implementierung der Callback-Routine
in C++ so aus:

Code:

void* __stdcall ADL_Main_Memory_Alloc ( int iSize )
{
    void* lpBuffer = malloc ( iSize );
    return lpBuffer;
}

Meine Implementierung:

Delphi-Quellcode:

function ADL_Main_Memory_Alloc(iSize: Integer): Pointer; stdcall;
begin
  Result := AllocMem(iSize);
end;

Des weiteren geht aus den Beispielen hervor, das die Initialisierung und der Aufruf wie folgt von statten gehen soll:

Code:

...
ADL_Main_Control_Create = (ADL_MAIN_CONTROL_CREATE)GetProcAddress(hDLL,"ADL_Main_Control_Create");
        if ( NULL != ADL_Main_Control_Create)
            ADL_Err = ADL_Main_Control_Create (ADL_Main_Memory_Alloc, 0);
...

In Delphi mache ich das so:

Delphi-Quellcode:

...
var
  ADL_Main_Control_Create: TADL_Main_Control_Create = nil;
...

function ADL_Initialize: Integer;
...

  @ADL_Main_Control_Create := GetProcAddress(hLib, 'ADL_Main_Control_Create');

  if (ADL_Main_Control_Create <> nil) then
  begin
    Result := ADL_Main_Control_Create(@ADL_Main_Memory_Alloc,0); // als Result wird 0 (= OK) zurück
                                                                 // gegeben, was laut Doku aussagt
                                                                 // das der Aufruf klappt.
  end;
...
end;

Der Aufruf klappt und die anderen Funktions-Variablen werden auch zugewiesen.
Aber beim Verlassen der Routine 'ADL_Initialize', wird nicht in den Programmteil, der den Aufruf
tätigt zurückgegehrt, sondern folgende Exception geworfen.

Zitat:

---------------------------
Benachrichtigung über Debugger-Problem
---------------------------
Im Projekt M:\Projekte\ADL_Test\debug\ADL_Test.exe sind zu viele auseinanderfolgende Exceptions aufgetreten: ''access violation at 0x00000000: read of address 0x00000000''. Prozess wurde angehalten. Mit Einzelne Anweisung oder Start fortsetzen.

Leider bin ich bisher noch nicht dahinter gekommen warum, und möchte nun wissen ob
die Übersetzung wenigstens korrekt ist und ich Fehler darin ausschließen kann.

Vielen Dank schon mal für eure Hilfe.

Gruss

BlackDragon

[Apollonius]

Anscheinend ist die Aufrufkonvention cdecl und nicht stdcall.

[_BlackDragon_]

Hi,

kann es jetzt leider nicht testen, aber ich hatte mich beim kopieren vertan.

Die richtige Implementation laut Original Header lautet:

Code:

#if defined (LINUX)
#define __stdcall
#endif /* (LINUX) */

/// Memory Allocation Call back 
typedef void* ( __stdcall *ADL_MAIN_MALLOC_CALLBACK )( int );

Deshalb ging ich davon aus, das der Aufruf stdcall sein müsste. Für die anderen Routinen
habe ich leider nur die Dokumentation. Dort steht aber nichts über die Aufrufkonvention
drin.

@Apollonius:
Prinzipiell meinst du aber, dass die Übersetzung so korrekt ist, oder?

Gruss

BlackDragon

[Apollonius]

Abgesehen von der Aufrufkonvention müsste das so stimmen. Bezüglich der Aufrufkonvention müsstest du schauen, ob __stdcall irgendwo noch definiert ist (defined(LINUX) müsste hier false ergeben, also ist das keine Definition). Falls es mit cdecl nicht klappt, solltest du dich mal in die unendlichen Weiten der CPU-Ansicht vorwagen. :P Das Problem sieht so aus, also hättest du dir den Stack zerschossen, und da ist eine falsche Aufrufkonvention sehr wahrscheinlich.

[Cyf]

Das ganze sieht für mich auch so aus, als sollte unter Linux stdcall und ansonsten cdecl verwendet werden (eigentlich eine untypische Sache).