C++ DLL in Delphi einbinden

[Andru]

Mahlzeit zusammen,

habe hier ein Problem. Und zwar muss ich eine DLL in ein Programm einbinden.
Weiß nur leider genau, ob ich das richtiug mache.
In der Beschreibung steht folgendes:

Code:

eResult InitLibrary(const char* szLibPath,
eLogLevels logLevel,
bool bInternalCtx,
bool bInternalPTZ,
const char* szLanguage);

eResult ist ein 'enumeration type'. Ein Rückgabewert von -4 bis +1 kann zurückkommen.
Wird da in C++ mit Integer gearbeitet?

Code:

typedef enum eResult
{
failed = -4,
invalid = -3,

usw. ...

}

'eLogLevels' gehen von 0 bis 5.


Das ganze hab ich dann so eingepflegt:

Delphi-Quellcode:

function InitLibrary(szLibPath: String; eLogLevels: Integer; bInternalCtxMenu: boolean;
          bInternalPTZ: boolean; szLanguage: String): Integer; external 'PlayerLib.dll';

Ich führe das dann folgend aus:

Delphi-Quellcode:

procedure TForm1.Button1Click(Sender: TObject);
const
eLevel = 1;
var
 initResult: Integer;
begin

  initResult := InitLibrary('.\', eLevel, false, false, 'de');

end;

Gibt es irgendwo eine Liste, in der steht, mit welchen Datentypen man eine solche DLL umsetzt?
Hab leider absolut keine Ahnung.


Würde mich freuen, wenn mir jemand weiterhelfen kann..

Ich bekomme halt eine Fehlermeldung, dass er in dieser Adresse nicht lesen kann...
EAccessViaolation bei Adresse 0044F150.
Lesen von Adresse FFFFFFFF.

Bin leider noch n ziemlich Noob.


Danke Euch!

Gruß,

Andru

[ste_ett]

Es sind ein paar kleinere Fehler drin. :)

Zitat:

Zitat von Andru

Code:

eResult InitLibrary(const char* szLibPath,
eLogLevels logLevel,
bool bInternalCtx,
bool bInternalPTZ,
const char* szLanguage);

eResult ist ein 'enumeration type'. Ein Rückgabewert von -4 bis +1 kann zurückkommen.
Wird da in C++ mit Integer gearbeitet?

Code:

typedef enum eResult
{
failed = -4,
invalid = -3,

usw. ...

}

'eLogLevels' gehen von 0 bis 5.

Du solltest an den Anfang der UNIT noch folgenden Compilerschalter setzen:

{$MINENUMSIZE 4}

Damit wird jedes Element aus deiner Enumeration 4 Byte groß.
Sollte gesetzt sein, da die DLL aus der C/C++-Welt kommt.

"eLogLevels" solltest du als eigenen Typ deklarieren.


BOOL <> Boolean

BOOL ist 4 Byte groß, Boolean nur 1 Byte.
Wenn du als Variablendeklaration irgendwo BOOL findest, musst du unter Delphi auch BOOL nehmen. :)

Zitat:

Zitat von Andru

Das ganze hab ich dann so eingepflegt:

Delphi-Quellcode:

function InitLibrary(szLibPath: String; eLogLevels: Integer; bInternalCtxMenu: boolean;
          bInternalPTZ: boolean; szLanguage: String): Integer; external 'PlayerLib.dll';

"char *Name" ist unter Delphi "Name: PChar".



Da für die DLL keine Aufrufkonvention angegeben ist, gehe ich mal von "cdecl;" aus.
Delphi nutzt standardmäßig "stdcall;".

Delphi-Quellcode:

function InitLibrary(szLibPath: PChar; LogLevel: eLogLevels; bInternalCtxMenu: BOOL;
          bInternalPTZ: BOOL; szLanguage: PChar): eResult; cdecl; external 'PlayerLib.dll';

[Robert Marquardt]

BOOL != bool. bool ist der C++ Typ nicht der Microsoft Typ BOOL. BOOL entspricht LongBool. bool entspricht wohl Boolean (da bin ich nicht ganz sicher).

Das hier koennte besser hinhauen.

Delphi-Quellcode:

function InitLibrary(szLibPath: PChar; eLogLevels: Integer; bInternalCtxMenu: boolean;
          bInternalPTZ: boolean; szLanguage: PChar): Integer; cdecl; external 'PlayerLib.dll';

Es ist allerdings nicht klar mit welcher Calling Convention die Funktion exportiert wird. Bitte schau mal mit einem Tool nach was fuer Funktionsnamen aus der DLL exportiert werden.

[Luckie]

Zitat:

Zitat von ste_ett

Delphi nutzt standardmäßig "stdcall;".

Nein. Delphi nutzt standardmäßig Register als Aufrufkonvention.

[Andru]

Wow..
Das ging ja mal wieder super flott hier mit den Antworten.
Also erstma schönen Dank dafür!!

Die Aufrufkonvention, war wohl mit das größte Problem.
Jedenfalls klappt es mit dem 'cdecl'.

Ich bekomme zwar noch eine -1 zurück, was InitFailed bedeutet,
aber das kann ja noch an vielen Dingen liegen.

Zitat:

"eLogLevels" solltest du als eigenen Typ deklarieren.

Wie funktioniert sowas? Bin leider wirklich noch ziemlicher Anfänger.
Inwiefern hat das Auswirkungen, als wenn ich einfach nur ein Integerwert übergebe?

[Robert Marquardt]

Ein Integer ist korrekt, aber nicht ideal. Uebernimm einfach das enum von C++, aber vergiss das MINENUMSIZE 4 nicht. die kleinen Syntaxunterschiede der Deklaration wirst du wohl hinkriegen.
Zeig mal deinen aktuellen Funktionsaufruf. Experimentiere auch mit WordBool und LongBool statt Boolean in der Deklaration. Ich weiss jetzt gerade nicht wie C++ bool auf dem Stack uebergibt.

[OregonGhost]

Zitat:

Du solltest an den Anfang der UNIT noch folgenden Compilerschalter setzen:

{$MINENUMSIZE 4}

Damit wird jedes Element aus deiner Enumeration 4 Byte groß.
Sollte gesetzt sein, da die DLL aus der C/C++-Welt kommt.

Kleine ergänzende Frage. Ist es garantiert, dass ein enum in C++ 4 Byte groß ist? Diverse Microsoft-Header (u.a. Direct3D) beinhalten in den enums nämlich immer noch einen Wert, der sinngemäß XYZ_FORCEDWORD heißt und den Wert 0xFFFFFFFF hat und laut Beschreibung dazu da ist, dass das enum eben DWORD-Größe hat. Würde mich mal interessieren (zumal ich arbeitstechnisch bald wieder in die C++-Welt eintauchen muss ;)).

[Robert Marquardt]

An sich ja, denn ein enum ist in C ein int. Es kann sein das dies fuer andere Programmeirsprachen gedacht ist, wie VB und C#.

[Andru]

also einen typ enum hab ich in der hilfe nicht gefunden.
wie deklarier ich diesen?

also ist das auch ein dateityp wie integer, oder bin ich jetzt auf nem ganz falschen dampfer?

[ste_ett]

Delphi-Quellcode:

{$MINENUMSIZE 4}

type
  eResult = (
    a = -4,
    b = -3,
    c = -2,
    d = -1,
    e =  0,
    f =  1
  );

[Andru]

also danke erstmal an alle.
habe den letzten fehler gefunden. es hat noch eine datei im verzeichnis gefehlt... :oops:

allerdings würd ich gern nochmal wissen, was das jetzt mit dem type auf sich hat.

habe jetzt folgendes unter den uses:

Delphi-Quellcode:

{$MINENUMSIZE 4}


type
  eResult = (
    OperationFailed = -4,
    InvalidPlayerRef = 3,
    LibNotInitialized = -2,
    LibInitFailed = -1,
    LibAlreadyInitialized =  0,
    Success =  1
  );

aber wie komm ich jetzt daran?

Delphi-Quellcode:

eResult := InitLibrary('', eLevel, false, false, 'de');

klappt nicht, da er nach eResult eine Klammer erwartet, aber ich kann die function
auch nicht als Parameter dann übergeben.

Um das richtig zu verstehen:
Die Typ-Deklaration ist doch dafür gedacht, dass ich den Text (z.B. 'InvalidPlayerRef') zurück bekomme, oder?


Gruß,

Andru

[Robert Marquardt]

Na du weist an einen Typen zu und nicht an eine Variable. Das ist doch Unsinn.

Delphi-Quellcode:

var
  Ret: eResult;
begin
  Ret := InitLibrary('', eLevel, false, false, 'de');

[Andru]

Ach klar...
Der Typ wird erstellt und demnach erhält dann eine Variable des Typs das Ergebnis.

Aber kann ich das jetzt auch noch auswerten?
Also z.b. in einer Label-Komponente anzeigen?

Denn ich hab da ja jetzt keinen Integerwert mehr, den ich z.B. mit IntToStr konvertieren könnte...

[ste_ett]

Eine (unschöne) Möglichkeit wäre das Umcasten auf Integer. :)

Delphi-Quellcode:

  i := Integer(Ret);
  ShowMessage(IntToStr(i));

[Robert Marquardt]

Doch natuerlich. Alle Enums sind ordinale Typen und daher kann ihr Zahlenwert mittels der Funktion Ord() erhalten werden.
Ich glaube hier bestehen noch Defizite bei der Kenntnis von Pascal.

[Andru]

Ohja.. die bestehen bei mir auf jeden Fall!!
Allerdings kommt man durch solche Probleme ja immer ein Stückchen weiter.

Jedenfalls schönen Dank für eure Hilfe!


Gruß,

Andru

[Reinhard Kern]

Noch eine Ergänzung zu Bool (Zitat MSDN):

Microsoft Specific
In Visual C++4.2, the Standard C++ header files contained a typedef that equated bool with int. In Visual C++ 5.0 and later, bool is implemented as a built-in type with a size of 1 byte. That means that for Visual C++ 4.2, a call of sizeof(bool) yields 4, while in Visual C++ 5.0 and later, the same call yields 1. This can cause memory corruption problems if you have defined structure members of type bool in Visual C++ 4.2 and are mixing object files (OBJ) and/or DLLs built with the 4.2 and 5.0 or later compilers.

END Microsoft Specific

Wie man sieht, ist sich nicht einmal MS einig mit MS. Man muss also wohl oder übel wissen, wo die Library herkommt und womit sie erstellt wurde. Und dabei ist das noch der einfachste aller Datentypen. Meistens wird dann die genaue Typdefiniton noch durch 5fach verschachtelte Präprozessoranweisungen versteckt.

Delphi hat doch auch Vorteile.

Gruss Reinhard

[Andru]

... da bin ich schon wieder.

Ich kann leider noch nicht auf alle Funktionen der DLL zugreifen.
Init und Destroy klappen. Dort bekomme ich das richtige Result.
Nun hab ich aber eine PlayerCreate-Funktion, die mir nicht das gewünschte
Ergebnis liefert.
Kann das mit folgendem zusammenhängen?
Es gibt wohl zwei Arten des DLL-Einbinden unter C. implicit und explizit.
Ist das so wie bei Delphi statisch und dynamisch?

Dort steht, dass bei einer impliziten Einbindung eine Präprozessoranweisung
gemacht werden muss: PLAYER_SDK_USE_IMPLICIT

Bei einer expliziten Einbindung ein Include:

Code:

#define LOAD_FUNCTION_POINTER
#include <PlayerLibInterface.h>

//Einmaliger Aufruf wohl im ganzen Projekt:

PlayerLib::LoadPlayerLib( "<path>\\PlayerLib.dll" );

Meine Problem-Funktion ist folgende:

Code:

int CreatePlayer( HWND hWNdParent,
RECT& rectPlayer,
const char* szWndTitle);

umgesetzt hab ich sie wie folgt:

Delphi-Quellcode:

function CreatePlayer(hWndParent: HWND; rectPlayer: TRect;
         szWndTitle: PChar): Integer; cdecl; external 'lib\PlayerLib.dll';

und führe sie so aus:

Delphi-Quellcode:

procedure TForm1.Button4Click(Sender: TObject);
var
rechteck: TRect;
resultCreate: Integer;
begin

rechteck.Left := 128;
rechteck.Top := 80;
rechteck.Right := 270;
rechteck.Bottom := 273;

  resultCreate := CreatePlayer(Form1.Handle, rechteck, 'test');
  Label5.Caption := IntToStr(resultCreate);
end;

Oh man,
bin wirklich aufgeschmissen ohne dieses Forum...


Danke euch allen!


Gruß,
Andru

[Robert Marquardt]

Knapp daneben:

Delphi-Quellcode:

function CreatePlayer(hWndParent: HWND; var rectPlayer: TRect;
         szWndTitle: PChar): Integer; cdecl; external 'lib\PlayerLib.dll';

Das & in der C++-Deklaration bedeutet Call-by-Reference. Es gibt drei Arten dies nach Delphi zu konvertieren.
"rectPlayer: PRect" reflektiert das auf dem Stack letztlich ein Pointer auf ein TRect uebergeben wird.
"var rectPlayer: TRect" ist die korrekte Konversion wenn die Funktion den Inhalt des TRect aendert.
"const rectPlayer: TRect" funktioniert wenn der Inhalt des TRect nicht von der Funktion geaendert wird. Es wird ausgenutzt das Delphi bei const Parametern mit mehr als 4 Bytes ein implizites Call-By-Reference macht.

Ich habe die sichere var-Variante gewaehlt.

[Andru]

Super!

Er hat mir sofort das Fenster geöffnet, das ich nun brauche!
Besten Dank!

Hoffe, den Rest schaffe ich nun allein.
Aber es sind noch ein paar Funktionen, die ich umsetzen muss -
also werd ich mich Wohl oder Übel sicherlich nochmals hier melden! :roll:


Nochmals vielen Dank!!

[DMW]

Zitat:

Zitat von OregonGhost

Ist es garantiert, dass ein enum in C++ 4 Byte groß ist?

Wie die Standard-Spezifikation das sieht, ist mir nicht bekannt, aber z.B. der BCC macht enums per Default immer so klein wie möglich (mit der Compileroption -b läßt sich aber Integergröße erzwingen). Daher ist hier auch in C++ etwas Mißtrauen angebracht.

[Andru]

Hab nochmals ne abschließende Frage. :oops:
Habe soweit alle Funktionen nun umsetzen können, allerdings fehlt mir noch eine.
Sie ist zwar nicht wirklich wichtig, allerdings würd ich schon gern wissen, was ich
dort falsch machen.
Bzw. möcht ich gern den richtigen Umgang mit Pointern lernen.

Um die Version des Treibers zu erfahren gibt es folgende Funktion:

Code:

Prototype eResult GetLibraryVersion( char* pLibVersion,
char* pInterfaceVersion );

pLibVersion:
Pointer to a character buffer which receives
the lib version (max. size 12).

pInterfaceVersion:
Pointer to a character buffer which receives
the interface version (max. size
12)

Return Result value as defined in eResult enumeration type.

Nach Unmengen von Umstellungen und Versuchen ist das mein momentaner Stand,
der ja allerdings nicht funktioniert...

Definition der Procedure

Delphi-Quellcode:

function GetLibraryVersion(pLibVersion: Pointer;
         pInterfaceVersion: Pointer): Integer; cdecl; external 'lib\PlayerLib.dll';

Die Imlementierung stell ich mir so vor:

Delphi-Quellcode:

procedure TForm1.Button2Click(Sender: TObject);
var
eResult: Integer;
LibVersion, InterfaceVersion: PChar;

pLibVersion, pInterfaceVersion: ^PChar;

sLibVersion, sInterfaceVersion: String;

begin
  LibVersion := '0';
  InterfaceVersion := '0';
  pLibVersion := @LibVersion;
  pInterfaceVersion := @InterfaceVersion;

  eResult := GetLibraryVersion(pLibVersion, pInterfaceVersion);

  LibVersion := @pLibVersion;
  InterfaceVersion := @pInterfaceVersion;

  sLibVersion := LibVersion;
  sInterfaceVersion := InterfaceVersion;
  Label3.Caption :=  sLibVersion + ' / ' + sInterfaceVersion + ' / ' +  IntToStr(eResult);

end;

Fehler ist natürlich eine Zugriffsverletzung beim Lesen.
Dabei wird auch das CPU-Fenster aufgepoppt, wobei mir die Anweisung dort (nennt man das Assembler??)
natürlich noch viel weniger sagen, als der Rest.

Würd mich freuen, wenn Ihr mir heir nochmals zur Hand gehen könntet!

Wird wohl wieder ein Fehler bei der Konvertierung sein, oder?


Ich danke Euch!

Gruß,

Andru

[Robert Marquardt]

Der Fehler liegt darin das Puffer gebraucht werden. Solche mit mindestens 12 Chars.

Delphi-Quellcode:

function GetLibraryVersion(pLibVersion: PChar;
         pInterfaceVersion: PChar): Integer; cdecl; external 'lib\PlayerLib.dll';

procedure TForm1.Button2Click(Sender: TObject);
var
  eResult: Integer;
  // ein Zeichen mehr zur Sicherheit kann nicht schaden
  LibVersion, InterfaceVersion: array [0..12] of Char;
begin
  // leere C Strings bestehen aus einem 0-Byte nicht der Ziffer '0'
  LibVersion[0] := #0;
  InterfaceVersion[0] := #0;

  eResult := GetLibraryVersion(LibVersion, InterfaceVersion);

  Label3.Caption :=  LibVersion + ' / ' + InterfaceVersion + ' / ' +  IntToStr(eResult);
end;

[Andru]

Ja - spitze!

Wie erwartet klappt das reibungslos!
Muss Dir echt nomma ganz großen Dank aussprechen!

Ohne Dich wär ich hier wirklich verzweifelt! :thumb:


Merci!