DLL C++ -> Delphi

Version imprimable

DLL C++ -> Delphi

Bonjour tout le monde,

voilà le problème, j'ai une DLL écrite en C++ et que j'aimerai intégrer sous Delphi (j'utilise donc des liaisons dynamiques).

Comme prévu, je ne peux que capter des fonctions ou des procédures ne faisant pas appel à d'autre appel de fonction, du style :

Je peux capter une simple fonction :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 BYTE Classe::Function(void) { BYTE by_truc = 0; BYTE * pby_truc = 0; WORD w_value_len = 0; if (w_value_len >= 2) { by_output_nb = (pby_value[1] & 0x0F) * 4; } return by_output_nb; }
Par contre une fonction qui appelle d'autre fonction, là j'ai une "violation d'accès" :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 BYTE Classe::Function(void) { BYTE by_truc = 0; BYTE * pby_truc = Valeur(); WORD w_value_len = Longueur(); if (w_value_len >= 2) { by_output_nb = (pby_value[1] & 0x0F) * 4; } return by_output_nb; }
Donc je sais qu'il faudrait "mapper" tout ça mais les exemples sont rares sur le net, alors si jamais quelqu'un à un exemple tout bête à me proposer je serai très content :)

Merci pour vos réponses d'avance en tout cas !
Greg

les objets C++ placés dans une DLL publient leurs méthodes, il est donc possible de les lier dans une application Delphi. Mais ce que la DLL ne fourni pas c'est la structure de la classe et tout le code présent dans le .h

l'approche classique est de créer un wrapper C pour l'objet C++, ce qui nécessaire un peu de développement en C.

ensuite il est théroriquement possible de créer le wrapper sous Delphi mais c'est loin d'être facile et ce n'est surtout pas automatique.

à l'époque de Kylix j'avais fait des tests sur QT sous Linux
Code:

1 2 3 4 5 6 7 8 const qt='libqt.so'; procedure Create_QApplication(this,argc,argv:pointer); cdecl external qt name '__12QApplicationRiPPc'; procedure Destroy_QApplication(this:pointer); cdecl external qt name '_._12QApplication'; procedure QApplication_setMainWidget(this,Widget:pointer); cdecl external qt name 'setMainWidget__12QApplicationP7QWidget'; procedure QApplication_exec(this:pointer); cdecl external qt name 'exec__12QApplication';
après toute la question est de savoir ce que l'on met dans "this" dont la structure est déclarée dans un .h, c'est la structure de l'objet C++ avec la table de méthodes virtuelles etc....

le fruit des mes recherches de l'époque se trouve ici

pour construire ce code j'avais utilisé des petites applications C qui me donnaient à coup de sizeof() et de pointeurs le format des structures...

17/08/2015, 13h45
phoenixgreg

Bien en effet, je me doutais que cela n'était pas aussi facile mais bon je dois quand même le faire ! :p
Merci pour tes sources en tout cas, est-ce que par hasard il te reste de la doc sur comment construire un wrapper en C etc ... ?

Bonne journée !

un wrapper c'est tout bête, en voici un sous Delphi avec TForm pour comprendre le principe, ensuite il "suffit" de faire la même chose en C pour l'objet C++
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 function CreateForm: THandle; var Form: TForm1; begin Form := TForm1.Create(Application); Result := THandle(Form); end; procedure ShowForm(Handle: THandle); begin TForm(Handle).Show(); end; procedure SetCaptionForm(Handle: THandle; Caption: PChar); begin TForm(Handle).Caption := Caption; end; procedure FreeForm(Handle: THandle); begin TForm(Handle).Free; end;
toutes les méthodes sont transformées en fonctions avec un paramètre opaque "Handle" qui est en fait un pointeur sur l'instance de classe.

la DLL expose de simples fonctions et c'est le wrapper qui se charge d'instancier, libérer, de résoudre les méthodes virtuelles etc...bref tous les concepts objets.

Ok donc par exemple :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
class Test
{
  public:
    Test();
    void getHello(char * &AString); 
};
 
Test::Test()
{
}
 
void Test::getHello(char * &AString)
{
  const char * str = "Hello World from C++";
  strcpy(AString, str);
}
 
extern "C"{ // j'exporte pour le C
  void createTestInstance(void * &instance)
  {
    instance = new Test(); // je créé l'instance
  }
 
  void doHello(void * instance, char * &AString)
  {
    Test * lInstance = (Test *) instance; // Je passe la fonction en paramètre comme pointeur
    lInstance->getHello(AString);
  }
 
  void deleteTestInstance(void  * instance)
  {
    delete (Test *)instance; // et mon desctructeur 
    instance = NULL;
  }
}

Et bien j'ai pas fini car j'ai une sacrée grosse DLL sous la main ... ^^

Citation:

Envoyé par phoenixgreg

Et bien j'ai pas fini car j'ai une sacrée grosse DLL sous la main ... ^^

oui c'est le principal problème :)

ceci dit tu peux alléger le code en trichant sur les déclarations qui ne changeront strictement rien à l'API...exemple sous Delphi:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 function CreateForm: TForm1; begin Result := TForm1.Create(Application); end; procedure ShowForm(Form: TForm); begin Form.Show(); end; procedure SetCaptionForm(Form: TForm; Caption: PChar); begin Form.Caption := Caption; end; procedure FreeForm(Form: TForm); begin Form.Free; end;
on garde la notion de Handle uniquement sur l'importation
Code:

1 2 3 4 5 function CreateForm: THandle; external 'madll.dll'; procedure ShowForm(Handle: THandle); external 'madll.dll'; procedure SetCaptionForm(Handle: THandle; Caption: PChar); external 'madll.dll'; procedure FreeForm(Handle: THandle); external 'madll.dll';

salut ,

un truc du genre ne suffirais pas pour wrapper une dll en C++ ?

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
 
TMONWRAPP = Class(TOBJECT) 
Private
  Type
     T_init = function(): Pointer; cdecl;
     T_cleanup = procedure(const p_qpdf: Pointer); cdecl;
 
     TMaFonction_Wrap = function (const TmonInstance: Pointer): TMonType; cdecl;
     TMaProcedure_Wrap = procedure (const TmonInstance: Pointer; const Maval : TMonType); cdecl;
 
     ....
Public
    constructor Create(const dllName: string = 'maddl.dll'); overload;
    procedure Cleanup;
    destructor Destroy(); override;
protected
    fDLL_Handle: Cardinal;
    fInstance: Pointer;
    fError: Pointer;
     ...
    Ma_function    : TMaFonction_Wrap;
    Ma_Procedure : TMaProcedure_Wrap;
    cleanup: T_cleanup;
    procedure Initialize;
    procedure LoadFunction(var func: Pointer; const funcName: string);
end;
...
implemantation
 
procedure TMONWRAPP.SetProcedure(const Maval : TMonType);
begin
  LoadFunction(@Ma_Procedure, 'set_MaProcedure');
  Ma_Procedure(fInstance, Maval);
end;
 
function TMONWRAPP.MaFirstFonction: TMonType;
begin
  LoadFunction(@Ma_function, 'Ma_function');
  result := Ma_function(fInstance);
end;
 
procedure TMONWRAPP.LoadFunction(var func: Pointer; const funcName: string);
begin
  if func = nil then
  begin
    func := GetProcAddress(fDLL_Handle, PChar(funcName));
    if func = nil then raise Exception.Create(Format('Error loading function: "%s"', [funcName]));
  end;
end;
 
procedure TMONWRAPP.Cleanup;
begin
  if Assigned(fInstance) then
  begin
    LoadFunction(@cleanup, 'cleanup');
    cleanup(@fInstance);
  end;
end;
 
procedure TMONWRAPP.Initialize;
var
  Init: T_init;
begin
  Init := GetProcAddress(FDLL_Handle, PChar('init'));
  if @Init = nil then raise Exception.Create('Error loading function: init');
  fInstance := Init;
  if (fInstance = nil) then Exception.Create('Could not init library!');
 
end;
 
 
constructor TMONWRAPP.Create(const dllName: String);
begin
  fDLL_Handle := LoadLibrary(PChar(dllName));
  if fDLL_Handle = 0 then raise Exception.Create('Error: Cannot find ' + dllName + #13#10#13#10 + SysErrorMessage(GetLastError));
 
  Initialize;
end;
 
destructor TMONWRAPP.Destroy;
begin
  if fDLL_Handle = 0 then Exit;
  Cleanup;
  FreeLibrary(fDLL_Handle);
  inherited;
end;

07/10/2015, 18h51
phoenixgreg

Oui c'est une solution également en utilisant GetProcAddress(), moi j'avais résolu ce problème sur ce topic et en expliquant me solution à la fin de celui-ci :
http://www.developpez.net/forums/d15.../dll-extern-c/

@+