PureBasic

Salut à tous.

Je commence à créer une Dll, mais ce n'est pas aussi simple que je le pensais.
Ben oui, il ne suffit pas de remplacer uniquement Procedure par ProcedureDLL.

Voici mon code de test :

Code : Tout sélectionner

ProcedureDLL$ LireDonneeRepertoire()
    repertoire$  = "Dossier_test" 
    
    ; MessageRequester uniquement pour un test.
    MessageRequester("Test", repertoire$)
    
    ProcedureReturn repertoire$
    
EndProcedure

Au début j'ai fais ça :

Code : Tout sélectionner

If OpenLibrary(0, "DLLtest.dll") 

    String$ = PeekS(CallFunction(0,"LireDonneeRepertoire"))
    
    Debug "-----"
    Debug "Resultat : "+ String$
    Debug "-----"
    CloseLibrary(0)
Else
    Debug "Pas de dll"
EndIf

Ça fonctionne mais dans ce post j'ai vu que certains préconisaient d'utiliser les prototypes.

Serait-il possible de me filer un coup de patte ?
Si possible en privilégiant le nommage de variable de cette façon variable$ plutôt que celle-ci variable.s

Bye.

Bon en lisant la doc j'ai essayé ça.

Code : Tout sélectionner

Prototype$ LireDonneeRepertoire()

If OpenLibrary(0, "DLLtest.dll") 
  
    Test.LireDonneeRepertoire = GetFunction(0, "LireDonneeRepertoire")
    debug Test()
    
    string$ = Test()
    debug string$
EndIf

Ca déclenche bien le messageRequester, mais je n'arrive pas à récupérer la valeur de ProcedureReturn qui devrait être "Dossier_test"

EDIT : La doc dit :"le prototype peut gérer les paramètres de types 'double', 'float' et 'quad' sans aucun problème" donc pour les strings, peut-être dois-je utiliser la technique de mon 1er post ?

Ton code renvoi un pointeur, il faut toujours passer par PeekS :

Code : Tout sélectionner

Prototype LireDonneeRepertoire()

If OpenLibrary(0, "C:\test.dll")
 
    Test.LireDonneeRepertoire = GetFunction(0, "LireDonneeRepertoire")
    ;Debug Test()
   
    string.l = Test()
    Debug PeekS(string)
EndIf

Merci Cls, cela fonctionne.

Mais du coup, quoi utiliser ?
La 1ère technique :
String$ = PeekS(CallFunction(0,"LireDonneeRepertoire"))

Ou ta technique ?

C'est peut-être une histoire de goût, ou alors peut-être que dés qu'il commence à y avoir des paramètres, une technique est peut-être plus appropriée.

Mais en tout cas pour les autres types (double, float et quad), Gnozal ainsi que Fred préconisent plutôt les prototypes d'après ce que j'ai pu lire.

Zut, avec EnableExplicit je ne sais pas quoi mettre dans ta solution Cls.

Déjà, tu as mis Prototype sans le typer est ce normal ?

Ensuite j'ai le droit à "Avec EnableExplicit les variables doivent être déclarées : Test" et je ne sais pas quoi mettre pour Test.

Tu peux mettre un .l, c'est le type des pointeurs.

Voici un exemple que j'utilise dans une dll :
1) Le code de la DLL

Code : Tout sélectionner

ProcedureDLL.i version()
string.s{100} = "Version 0.0.1 - 19/08/2009 "
*string=@string
  ProcedureReturn *string
EndProcedure

2) Le code du programme qui utilise la DLL

Code : Tout sélectionner

Enumeration
#hdlDLL
Endenumeration
CompilerIf #PB_Compiler_OS = #PB_OS_Linux
  OpenLibrary(#hdlDLL,"DLL.so")
CompilerEndIf
CompilerIf #PB_Compiler_OS = #PB_OS_Windows 
  OpenLibrary(#hdlDLL,"DLL.dll")
CompilerEndIf
; declaration
Prototype.i version()
Global version.version                                      = GetFunction(#hdlDLL, "version")

debug PeekS(version(),-1, #PB_Unicode  ) ; mettre #PB_Ascii si complilé avec Ascii

Une variable sans type est normalement déclaré un .i

En gros, dans une procedure, on utilise Protected

Protected Test
reviens à
Protected Test.i

pourquoi .i et pas .l

.l est équivalent à .i sur un OS 32bits
mais en 64 bits, un pointeur n'est pas un .l mais un .q
et .i est équivalent à .q en 64 bits

En gros, la variable par défaut qui permet d'être compatible 32bits et 64 bits, c'est .i (compatible du point de vue compilation, quelqu'un qui a un OS 64 bits peux compiler ton code si il utilise des .i au lieu de .l pour les pointeurs et autres trucs du genre)

Ah!!! Ben voilà quelque chose qui me semble plus logique.

Je rappelle le code de ma DLL :

Code : Tout sélectionner

ProcedureDLL$ LireDonneeRepertoire() 
  repertoire$  = "Dossier_test"  
  MessageRequester("Test", repertoire$) 
   
  ProcedureReturn repertoire$ 
EndProcedure

Celle-ci me retourne une string, c'est pour cela que je demandais quel était le type pour Prototype du code que m'avais donné Cls parce que "Prototype$" ne voulais plus fonctionner.

Par contre le code de f1roe fonctionne correctement et comme la procédure renvoie un pointeur on peut donc mettre "Prototype.i"

Donc voici mon nouveau code :

Code : Tout sélectionner

ProcedureDLL.i LireDonneeRepertoire()
    repertoire$ = "Dossier_test" 
    *repertoire = @repertoire$
    
    ; MessageRequester uniquement pour un test.
    MessageRequester("Test", PeekS(*repertoire))
    
    ProcedureReturn *repertoire
EndProcedure

Et celui du programme :

Code : Tout sélectionner

Prototype.i LireDonneeRepertoire()

If OpenLibrary(0, "DLLtestPointeur.dll")
    Global Test.LireDonneeRepertoire
    
    Test.LireDonneeRepertoire = GetFunction(0, "LireDonneeRepertoire") 
    
    Debug PeekS(Test())
EndIf

Le Soldat Inconnu a écrit :Une variable sans type est normalement déclaré un .i

Oui, j'avais vu ça dans la doc.

Le Soldat Inconnu a écrit :pourquoi .i et pas .l

.l est équivalent à .i sur un OS 32bits
mais en 64 bits, un pointeur n'est pas un .l mais un .q
et .i est équivalent à .q en 64 bits

En gros, la variable par défaut qui permet d'être compatible 32bits et 64 bits, c'est .i (compatible du point de vue compilation, quelqu'un qui a un OS 64 bits peux compiler ton code si il utilise des .i au lieu de .l pour les pointeurs et autres trucs du genre)

En regardant dans la section : "Variables, Types et Opérateurs" j'en avais déduis ça et c'est pour cela que j'ai pris cette bonne habitude dés le début de ne jamais utiliser ".l" mais ".i".
Cela confirme donc ce que je pensais.

En tout cas merci à vous 3 pour votre aide.
A plus.

PureBasic

[Résolu] Dll

[Résolu] Dll

Re: Dll

Re: Dll

Re: Dll

Re: Dll

Re: Dll

Re: Dll

Re: Dll

Re: Dll