symbol was eliminated by linker!

**bouzaidi** · 27/04/2007, 18h13

j'ai supprimé le far et pourtant le même probleme reside...

**Fabrice ROUXEL 1** · 27/04/2007, 18h24

Essayes quand même mon truc de tout à l'heure avec les variables globales.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
library ED_DLL;
uses
  ShareMem,  Dialogs, SysUtils,
  Classes,  Windows,
  FM_Main in 'FM_Main.pas',
  FM_Options in 'FM_Options.pas' {F_Options},
  U_Constantes in 'U_Constantes.pas',
  U_OptionsValues in 'U_OptionsValues.pas',
  FM_Params in 'FM_Params.pas' {F_Params},
  FM_About in 'FM_About.pas' {F_About},
  U_Obligation in 'U_Obligation.pas',
  U_SwapTaux in 'U_SwapTaux.pas',
  U_TCN in 'U_TCN.pas',
  U_PretEmprunt in 'U_PretEmprunt.pas',
  U_ValMob_OLF in 'U_ValMob_OLF.pas',
  U_ObjectTypes in 'U_ObjectTypes.pas',
  U_ObligationConvertible in 'U_ObligationConvertible.pas',
  FM_Recap in 'FM_Recap.pas' {F_Recap},
  U_PJJ in 'U_PJJ.pas',
  U_CFD in 'U_CFD.pas',
  FM_SendTicketsUnitaires in 'FM_SendTicketsUnitaires.pas' {F_SendTicketsUnitaires},
  U_TRS in 'U_TRS.pas',
  U_ValMob_OLF_Sophis in 'U_ValMob_OLF_Sophis.pas',
  U_SwapChange in 'U_SwapChange.pas',
  U_ChangeSpotTerme in 'U_ChangeSpotTerme.pas',
  U_SwiftMT304 in 'U_SwiftMT304.pas',
  U_Tools in 'U_Tools.pas',
  U_CDS in 'U_CDS.pas',
  U_Options_CDS in 'U_Options_CDS.pas',
  U_OptionChange in 'U_OptionChange.pas',
  U_VarSwap in 'U_VarSwap.pas',
  U_OptionOTC in 'U_OptionOTC.pas',
  U_DividendSwap in 'U_DividendSwap.pas',
  U_Outperform in 'U_Outperform.pas',
  U_CapFloor in 'U_CapFloor.pas',
  U_Swaptions   in 'U_Swaptions.pas',
  U_SwapEquities in 'U_SwapEquities.pas';
 
{$R *.res}
var
 GExportType : Integer;
 GListrefcon : Pchar;
 GDestinationType: Integer;
 GMajStatuts,
 GchoixRepertoire : Boolean;
 GRepertoireCible : Pchar;
 GCreerUnitaire : Boolean;
 
 
 
 
procedure CallBackExportToFile(ExportType : TFileType; Listrefcon : Pchar; DestinationType: TDestType;
                       MajStatuts,choixRepertoire : Boolean; RepertoireCible : Pchar;
                       CreerUnitaire : Boolean); stdcall; external 'exportdeals.exe';
 
function  TypeExport(TE : Integer): TFileType; stdcall;
begin
  case TE of
     1: Result:= ftCreation ;
     2: Result:= ftModification;
     3: Result:= ftAnnulation;
     //else MessageDlg('Votre type d export n est pas valide!', mtError, [mbOk], 0);
  end;
end;
 
function  TypeDest(TD : Integer): TDestType; stdcall;
begin
  case TD of
     1: Result:= dtDepositaire;
     2: Result:= dtValorisateur;
     3: Result:= dtPrimeBroker;
     //else MessageDlg('Votre type destination n est pas valide!', mtError, [mbOk], 0);
  end;
end;
 
procedure ProcExportDll(ExportType : Integer; Listrefcon : Pchar; DestinationType: Integer;
                        MajStatuts,choixRepertoire : Boolean; RepertoireCible : Pchar;
                        CreerUnitaire : Boolean); stdcall;
var
   j,k: integer;
begin
    j:=ExportType;
    k:=DestinationType;
 
 
 GExportType        := ExportType;
 GListrefcon          := Listrefcon;
 GDestinationType  := DestinationType;
 GMajStatuts         :=MajStatuts;
 GchoixRepertoire   := choixRepertoire;
 GRepertoireCible    := RepertoireCible;
 GCreerUnitaire       := CreerUnitaire ;
 
 
 
 
    CallBackExportToFile(GTypeExport(j), GListrefcon,
                         GTypeDest(k), GMajStatuts,
                         GchoixRepertoire, GRepertoireCible, GCreerUnitaire);
end;
 
exports
     ProcExportDll;
 
begin
end.

**Eric Boisvert** · 27/04/2007, 19h20

Je ne crois pas qu'on puisse definir une fonction callback de cette facon:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
 
procedure CallBackExportToFile(ExportType : TFileType; Listrefcon : Pchar; DestinationType: TDestType;
                       MajStatuts,choixRepertoire : Boolean; RepertoireCible : Pchar;
                       CreerUnitaire : Boolean); stdcall; external 'exportdeals.exe';

ici on dit a la dll de charger un nouveau exportdeals.exe en memoire et
de trouver l'adresse de la fonction CallBackExportToFile....humm

... désolé mais les mots
me manque pour être plus claire...

Pour une fonction callback, d'Habitude le exe appele une fonction à l'intérieur de la dll
qui mémorisera tout simplement l'adresse de la fonction callback....

un truc du genre dans le programme appelant:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
type
    TCallBackfunc=procedure (ExportType : TFileType; Listrefcon : Pchar; DestinationType: TDestType;
                       MajStatuts,choixRepertoire : Boolean; RepertoireCible : Pchar;
                       CreerUnitaire : Boolean); stdcall;
    pCallBackFunc=^TCallBackFunc;
 
 
procedure SetCallBackProc(cbFunc:pCallBackFunc); stdcall; external 'MyDll.dll';
 
 
//=== Passe l'adresse de notre fonction Callback à la DLL
SetCallBackProc( CallBackExportToFile );

Ensuite dans la dll:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
type
    TCallBackfunc=procedure (ExportType : TFileType; Listrefcon : Pchar; DestinationType: TDestType;
                       MajStatuts,choixRepertoire : Boolean; RepertoireCible : Pchar;
                       CreerUnitaire : Boolean); stdcall;
    pCallBackFunc=^TCallBackFunc;
 
var
  //==Variable globale pour mémorisé l'adresse de la function...==
  CallBackFunc:pCallBackFunc;
 
 
procedure SetCallBackProc(cbFunc:pCallBackFunc); stdcall;
begin
	//==Memorise la fonction callback qui vient du exe....==
	CallBackFunc:=cvFunc;
end;
 
//== alors plus tard dans la dll... on peut appeler la bonne procedure....===
ProcExportDll(ExportType : Integer; Listrefcon : Pchar; DestinationType: Integer;
                        MajStatuts,choixRepertoire : Boolean; RepertoireCible : Pchar;
                        CreerUnitaire : Boolean); stdcall;
var
   j,k: integer;
begin
    j:=ExportType;
    k:=DestinationType;
    //== Verifie que la variable global est bien assigné à quelque chose...==
    if CallBackFunc<>nil then
	 CallBackFunc(TypeExport(j), Listrefcon,
                         TypeDest(k), MajStatuts,
                         choixRepertoire, RepertoireCible, CreerUnitaire);
end;
 
//=== Il faut bien sur exporter notre nouvelle fonction ===
exports
     ProcExportDll;
     SetCallBackProc;

bon c'est peut-être moi qui à manqué un bout quelque part?

**ShaiLeTroll** · 27/04/2007, 19h33

Envoyé par Eric Boisvert

Je ne crois pas qu'on puisse definir une fonction callback de cette facon:

J'ai plus l'impression que c'est un abus de langage, dans le sens CallBack -> Redirection, que dans le sens EnumWindows, par Exemple ...

"Exe en C++" appel "DLL en Delphi" qui encapsule si j'ai compris un "Exe en Delphi) ...

**Eric Boisvert** · 27/04/2007, 19h38

Envoyé par ShaiLeTroll

J'ai plus l'impression que c'est un abus de langage

je vais suivre cette discussion avec attention alors...

j'vais peut-être même tenter une experience toute simple...

si ca fonctionne, ca simplifie drôlement l'écriture d'un call back...
J'en reviens tjrs pas!

je m'y attaque tout de suite...

**Fabrice ROUXEL 1** · 27/04/2007, 19h45

Sa fonction CallBackExportToFile n'est pas une fonction de Callback.

Son appli C++ manipule et crée des données qui sont transmise à une fonction contenue dans la Dll.
Cette fonction, qui sert de controleur en quelque sorte, transfert les données à un exe en Delphi qui stoque ou traite les données.

Mais le probleme vient effectivement probablement de sa déclaration ...stdcall; external 'exportdeals.exe';
Jamais essayé ce genre de truc (Borland préconisait l'usage des paquets avec le support RTTI)

**Eric Boisvert** · 27/04/2007, 20h01

Mais alors, un programme peux caller une fonction contenue dans un autre programme!?

!

ils n'ont pas de pile commune...dans ce cas... c'est donc impossible?non?

ou alors justement la dll traite le fichier .exe comme une dll? mais c'est impossible?

DllProc := @EntryPointProc;
EntryPointProc(DLL_PROCESS_ATTACH);

où est dll_entry proc dans un .exe?

Je crois que ca ce tient pas debout cette structure? Ou bien je suis dans
le champs completement depuis toujours?

**ShaiLeTroll** · 27/04/2007, 20h10

Je n'ai jamais essayé, mais j'ai vu d'autres sujets qui parlait d'exports sur un exe, faudrait que je le tente un jour, ... mais semble que certains l'utilisent ...

maintenant, ce qui me semble étrange c'est le link, perso, je n'utilise que rarement la syntaxe external ... comme dans l'unité Windows mais un truc du genre

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
function TFrmTestDivers.GetBidule(out ...): Boolean;
var
  HandleDLL: HMODULE;
  _GetBidule: procedure(...); stdcall;
begin
  HandleDLL := LoadLibrary('DLLTest.dll');
 
  if HandleDLL > 0 then
  begin
    @_GetDLLForm := GetProcAddress(HandleDLL, 'GetBidule');
    Result := Assigned(@_GetDLLForm)
    if Result then
      _GetDLLForm(...);
  end;
end;

**Eric Boisvert** · 27/04/2007, 20h16

la syntaxe external fait essentielement la même chose que toi ShaiLeTroll.
Seulement elle le fait automatiquement pour toi lors du lancement de
l'application....c'est pourquoi je disais tantôt qu'on ne peux définir une
fonction callback de cette facon....(avec external).

Comme on voit dans ton code, c'est une autre copie du .exe qui sera
loader en mémoire... donc pour un callback... c'était sûrment pas l'effet
désiré...

**ShaiLeTroll** · 27/04/2007, 20h25

Eric Boisvert, Quand je parlais d'abus de langage, c'est l'utilisation d'un mot pour ce qu'il ne veut pas dire !
dans ce cas, je pense que cela n'est pas du tout un CallBack, il a utilisé ce terme à mauvais escient ! c'est plus une redirection, non un Encapsulation de sa function dans l'Exe par une fonction dans une DLL

Sinon, je connais le principe du External, dans le journal d'évènement, c'est la déprime quand je vois tant de DLL lancé par les applis du bureau, pour des fonctionnalités, qui ne sont pas utilisé plus d'une fois par mois ...

**Eric Boisvert** · 27/04/2007, 20h31

Envoyé par ShaiLeTroll

Eric Boisvert, Quand je parlais d'abus de langage, c'est l'utilisation d'un mot pour ce qu'il ne veut pas dire !
dans ce cas, je pense que cela n'est pas du tout un CallBack, il a utilisé ce terme à mauvais escient ! c'est plus une redirection, non un Encapsulation de sa function dans l'Exe par une fonction dans une DLL

Maintenant on s'entend très bien là dessus!

pour le reste, selon moi, il faudrait penser à une communication
inter-processus entre la DLL et le programme Delphi... sinon, je vois
vraiment pas comment ca peut fonctionner comme ca....

**ShaiLeTroll** · 27/04/2007, 20h38

Sinon, as tu pensé à écrire dans un Fichier Log ou dans OutputDebugString, le contenu de tes variables, pour éviter la visualisation du débugger delphi, qui se trompe parfois (FileStream.Size internellement à zéro par exemple)

Et, je ne sais pas pour les autres, mais c'est difficile de trouver l'erreur, sans avoir des debbugers sous la main, ... tu devrais tout remettre à plat, et revoir tout depuis le début, ... procédé, étape par étape ... pour trouver la faille, si cela se trouve, c'est un truc aussi bête que le Boolean au lieu de LongBool ... mais personne ne le voit ... Bon WE à Tous ... A Mercredi !

**bouzaidi** · 30/04/2007, 10h04

Bonjour,
=>ShaiTrol, j'ai essayé ton truc des variables globales, mais les variables sont éliminés lors de l'appel de la fonction qui se trouve dans l'exe...

Précisions: Comme je l'ai déjà indiqué, mon programme a marché nickel lors de l'appel depuis l'exe mais depuis un prog C++ ca ne marche pas car les vraibales sont eliminé juste au passage à la fonction qui se trouve dans l'exe delphi!!!
Je ne crois pas que c'est l'utilisation de export 'expordeals.exe' qui pose problème. En plus, ma fonction callback... a bien son role, c'etait en fait pour encapsuler le comportement de l'exe qui depend d'un type TForm et donc que je ne peux pas appeler depuis ma dll.
Voilà, si vous avez des idées je vous en serias reconnaissant, car làà je n'ai plus d'idées a tester

**bouzaidi** · 30/04/2007, 10h12

Je tiens a noter une chose qui est tres importante aussi: Quand je teste ma dll en l'appelant depuis l'exe même, j'ai dis que ça marche, en fait ce qui est étrange c'est que quand je regarde le contenu des variables au moment de l'appel, Je tourve la meme chose "symbol was eliminated by linker"!!!!!!!!!!!!!!!!!! alors que ca marche tres bien. cela veut dire que ca peut ne pas etre le blem ce truc?

**bouzaidi** · 30/04/2007, 15h42

alors quelqu'un voit il où c'est le problème SVP?? En fait j'ai trouvé une discussion qui peut m'être utile, mais c'etais en néerlandais

Bon si kelkun conné hollandais voila le lien:
http://www.nldelphi.com/forum/showthread.php?t=16209

ou ceci aussi:
http://www.nldelphi.com/forum/showthread.php?t=1898

Merci d'avance les gas

**Eric Boisvert** · 30/04/2007, 16h27

Désolé mais je comprend rien au néerlandais moi non plus!

Bon voilà en gros ce que j'ai dans la tête à propos de ton problème...

Envoyé par MSDN

Les DLL Win32 sont mappées dans l'espace d'adressage du processus appelant. Par défaut, chaque processus utilisant une DLL possède sa propre instance des variables globales et statiques de toutes les DLL. Si votre DLL doit partager des données avec d'autres instances d'elle-même chargées par d'autres applications, vous pouvez adopter l'une des approches suivantes :

1-Créez des sections de données nommées à l'aide du pragma data_seg.

2-Utilisez des fichiers mappés en mémoire. Consultez la documentation Win32 traitant des fichiers mappés en mémoire.

alors je t'invite à utiliser la 2ème proposition...
ici en anglais la théorie:
Fichier mappés en mémoire

Commence par une recherche sur les fichier mappés...
les fonctions API utile dans les fichier mappés sont:
CreateFileMapping
MapViewOfFile
UnMapViewOfFile

**bouzaidi** · 30/04/2007, 17h09

Merci, ca donne espoir au moins

Bon je vais voir ce document et ce qu'il peut me donner

**CapJack** · 30/04/2007, 18h40

Je t'ai déjà expliqué deux fois que ça ne pouvait pas marcher !

D'où la méthode que j'ai passé quelques heures bénévoles à implémenter, et qui utilise le DDE. Mais apparemment cette méthode te déplaît. Tant pis.

**Eric Boisvert** · 30/04/2007, 19h00

Envoyé par CapJack

Je t'ai déjà expliqué deux fois que ça ne pouvait pas marcher !

Voici tout de même une petite exemple...2 programme 1 dll
il y a echange de données via un fichier mappé en mémoire.

Je démontre aussi la limite des callback...

Cela dit, je crois qu'il faut absolument que tu revois la structure des liens
entre tes programmes et que tu étudie en détail le comportement des
fichiers .dll....

et il semblerait que CapJack est d'accord avec moi!

**bouzaidi** · 30/04/2007, 19h18

Envoyé par CapJack

Je t'ai déjà expliqué deux fois que ça ne pouvait pas marcher !

D'où la méthode que j'ai passé quelques heures bénévoles à implémenter, et qui utilise le DDE. Mais apparemment cette méthode te déplaît. Tant pis.

J'ai bien vu ta methode DDE, mais d'apres ce que j'ai compris c'est que cette méthode est utilisé lors de l'appel depuis Delphi même non?? me suis je trompé.. Ne t'enerve pas CAPJACK car je suis que débutant en delphi...
Un grand merci Quand même

symbol was eliminated by linker!

Delphi

Discussions similaires

Partager

Partager