Est-il possible de tester la présence d'une procedure ?
Est-il possible de tester la présence d'une procedure ?
Bonsoir a tous !
Je cherche un moyen de tester la présence d'une procédure donnée !
Je n'est rien trouvé du côté du compilo, ou alors j'ai zappé.
Une commande du genre "xinclude" mais pour les procédures me serais bien utile !
Je vous explique pourquoi !
J'ai de nombreux modules (que je veux le plus autonome possible), que j'inclus dans mon
programme principale selon le besoin. Mais souvent dans ces modules se retrouve des
procédures déjà présente dans le programme principale ou dans d'autres modules.
Et le compilo gueule "déjà présent" : Il me faut donc a chaque fois retirer la déclaration,
et la dite procédure...Etc... Et relancer la compil (et j'ai encore oublié cette autre procédure
et je recommence... ) Bref pourquoi ne pas avoir une fonction du genre : xincludeproc...
Si quelqu'un a une astuce ! Merci d'avance
Ulix
Je cherche un moyen de tester la présence d'une procédure donnée !
Je n'est rien trouvé du côté du compilo, ou alors j'ai zappé.
Une commande du genre "xinclude" mais pour les procédures me serais bien utile !
Je vous explique pourquoi !
J'ai de nombreux modules (que je veux le plus autonome possible), que j'inclus dans mon
programme principale selon le besoin. Mais souvent dans ces modules se retrouve des
procédures déjà présente dans le programme principale ou dans d'autres modules.
Et le compilo gueule "déjà présent" : Il me faut donc a chaque fois retirer la déclaration,
et la dite procédure...Etc... Et relancer la compil (et j'ai encore oublié cette autre procédure
et je recommence... ) Bref pourquoi ne pas avoir une fonction du genre : xincludeproc...
Si quelqu'un a une astuce ! Merci d'avance
Ulix
Re: Est-il possible de tester la présence d'une procedure ?
Bonjour,
Oui il y a une solution et voila un exemple :
Pour le test, il faut retirer les commentaires de la procédure du haut pour voir la différence.
Cordialement,
GallyHC
Oui il y a une solution et voila un exemple :
Code : Tout sélectionner
; Procedure test()
; Debug "Test"
; EndProcedure
CompilerIf Defined(test, #PB_Procedure) = #False
Debug "On creer"
Procedure test()
Debug "Test"
EndProcedure
CompilerEndIf
Cordialement,
GallyHC
Configuration : Tower: Windows 10 (Processeur: i7 "x64") (Mémoire: 16Go) (GeForce GTX 760 - 2Go) - PureBasic 5.72 (x86 et x64)
Re: Est-il possible de tester la présence d'une procedure ?
Merci GallyHC !
J'avais complètement zappé cette fonction de BP !
Je vais regardé ça de plus prés, et faire des tests.
Apparemment, cela devrait marcher pour les procédure (#PB_Procedure),
mais pour la déclaration de procédure (#PB_Declare ????), il faut que je regarde.
Merci !
A+ Ulix
J'avais complètement zappé cette fonction de BP !
Je vais regardé ça de plus prés, et faire des tests.
Apparemment, cela devrait marcher pour les procédure (#PB_Procedure),
mais pour la déclaration de procédure (#PB_Declare ????), il faut que je regarde.
Merci !
A+ Ulix
Re: Est-il possible de tester la présence d'une procedure ?
Bonjour,
Pour moi le plus simple et de faire comme indiqué plus haut dans tes modules, tu déclares tes procédures avec un "CompilerIf Defined(......., #PB_Procedure) = #False". comme cela si la "function" est déjà présente elle ne sera pas déclarer et dans le cas contraire elles le sera, mais tu es sur que ton module fonctionne toujours.
Cordialement,
GallyHC
Pour moi le plus simple et de faire comme indiqué plus haut dans tes modules, tu déclares tes procédures avec un "CompilerIf Defined(......., #PB_Procedure) = #False". comme cela si la "function" est déjà présente elle ne sera pas déclarer et dans le cas contraire elles le sera, mais tu es sur que ton module fonctionne toujours.
Cordialement,
GallyHC
Configuration : Tower: Windows 10 (Processeur: i7 "x64") (Mémoire: 16Go) (GeForce GTX 760 - 2Go) - PureBasic 5.72 (x86 et x64)
Re: Est-il possible de tester la présence d'une procedure ?
perso j'utilise un outil qui ajoute les déclarations automatiquement en fonction des procédures crées a la compilation.
du coup je ne declare plus rien ...
je passe a l'outil l'argument suivants
arguments :%FILE@%COMPILEFILE
event to trigger the tool :before compilation
et je coche :wait until tool quit
dans le code j'ajoute un commentaire
;autodeclare
a l'endroit ou je veux que mes déclarations soient ajoutées.
code a compiler et a configurer comme outil dans PB
du coup je ne declare plus rien ...
je passe a l'outil l'argument suivants
arguments :%FILE@%COMPILEFILE
event to trigger the tool :before compilation
et je coche :wait until tool quit
dans le code j'ajoute un commentaire
;autodeclare
a l'endroit ou je veux que mes déclarations soient ajoutées.
code a compiler et a configurer comme outil dans PB
Code : Tout sélectionner
OpenConsole()
st$=ProgramParameter()
Global NewList decl.s() ; declares
Global NewList origin.s() ; original code
IN$=StringField(st$,1,"@") ; code d'origine
OUT$=StringField(st$,2,"@") ; code a envoyer au compilateur
;
rd=ReadFile(#PB_Any,IN$)
If rd
Repeat
AddElement( origin())
origin()=ReadString(rd)
If FindString(origin(),"EndProcedure")=0
If FindString(origin(),"ProcedureReturn")=0
If FindString(origin(),"Procedure")
dec$=ReplaceString(origin(),"Procedure","Declare")
fnd=0
ForEach decl()
If decl()=dec$
fnd=1
Break
EndIf
Next
If fnd=0
AddElement(decl())
decl()=dec$
EndIf
EndIf
EndIf
EndIf
Until Eof(rd)
CloseFile(rd)
EndIf
wr=CreateFile(#PB_Any,OUT$)
If wr
ForEach origin()
WriteStringN(wr,origin())
If Trim(LCase(origin()))=";autodeclare"
ForEach decl()
WriteStringN(wr,decl())
Next
EndIf
Next
CloseFile(wr)
EndIf
Re: Est-il possible de tester la présence d'une procedure ?
@ GallyHC !
Je viens de tester la fonction : CompilerIf Defined(......., #PB_Procedure) = #False"
Elle marche bien pour les "procedure", mais pas pour les "declare".
Peut-être faut-il une constante : #PB_Declare ! Elle n'existe pas (en tout cas pas trouver)!
J'ai bien chercher dans l'aide a "Defined", il y a la liste des constates a utilisé avec,
mais pas de #PB_Declare ????
Temps que je n'aurais pas trouvé comment tester les "declare" le compilo me renvoirat
".... The module procedure 'xxxx' has been declared but not defined."
@case !
Merci pour ta proposition : Je n'est jamais utilisé d'outil extérieure !
J’apprécie déclarer mes procédures au fur et a mesure de leurs créations, alors travailler sans
ma liste de "Declare" en but de programme.... !!! Je sais pas... A voir si j'ai pas d'autre solution !
En tous cas merci !
Je viens de tester la fonction : CompilerIf Defined(......., #PB_Procedure) = #False"
Elle marche bien pour les "procedure", mais pas pour les "declare".
Peut-être faut-il une constante : #PB_Declare ! Elle n'existe pas (en tout cas pas trouver)!
J'ai bien chercher dans l'aide a "Defined", il y a la liste des constates a utilisé avec,
mais pas de #PB_Declare ????
Temps que je n'aurais pas trouvé comment tester les "declare" le compilo me renvoirat
".... The module procedure 'xxxx' has been declared but not defined."
@case !
Merci pour ta proposition : Je n'est jamais utilisé d'outil extérieure !
J’apprécie déclarer mes procédures au fur et a mesure de leurs créations, alors travailler sans
ma liste de "Declare" en but de programme.... !!! Je sais pas... A voir si j'ai pas d'autre solution !
En tous cas merci !
- falsam
- Messages : 7244
- Inscription : dim. 22/août/2010 15:24
- Localisation : IDF (Yvelines)
- Contact :
Re: Est-il possible de tester la présence d'une procedure ?
Une question me brûle les lèvres : Pourquoi faire un déclare d'une procédure qui n'existe pas ?
Configuration : Windows 11 Famille 64-bit - PB 6.03 x64 - AMD Ryzen 7 - 16 GO RAM
Vidéo NVIDIA GeForce GTX 1650 Ti - Résolution 1920x1080 - Mise à l'échelle 125%
Vidéo NVIDIA GeForce GTX 1650 Ti - Résolution 1920x1080 - Mise à l'échelle 125%
Re: Est-il possible de tester la présence d'une procedure ?
Salut falsam !
Non !
La procédure et sa déclaration existe dans son module !
Mais module son autonome (le plus possible), cela veut dire que en plus de leurs fonction principale,
ils ont toutes les fonctions ou procédures pour être autonome !
Exemple : Mon module BDGPrinter (Boite de Dialogue Imprimante) a tous ces procédures et fonctions
pour assurer cette autonomie. Je dois avoir +15 procédures (DessinBouton, UserName...) qui ne sont pas
liées directement a la fonction de ce module(gestion imprimante, options d'impression...),
mais permette de faire fonctionné le module (Ex: BDGPrinter).
Lorsque que je développe une application, j'inclus au fur et à mesure les modules (BDGPrinter, OutputVoice,
BDGScanner...) donc j'ai besoin !
Pas besoin de chercher toutes les procédures (annexes ou fonctions), tous est inclus.
Mon problème c'est que le compilo qui "gueule" a chaque fois d'une procédure est déjà dans un autre module
ou dans programme principal...
CompilerIf Defined(......., #PB_Procedure) = #False" marche bien pour éviter d'inclure la procédure une
nouvelle fois, cela a résolu 50% de mes problèmes !
Mais il n'y rien de prévu pour la déclaration !. Une constance : #PB_Declare permettrait (peut-être...)
de ne pas mettre en rogne le compilo !
J'espéres que j'ai été assez claire, que tu a compris mon propos !
Je suis toujours a la recherche d'une solution (peut-être demander a Fred une nouvelle constante...)
Ulix
Non !
La procédure et sa déclaration existe dans son module !
Mais module son autonome (le plus possible), cela veut dire que en plus de leurs fonction principale,
ils ont toutes les fonctions ou procédures pour être autonome !
Exemple : Mon module BDGPrinter (Boite de Dialogue Imprimante) a tous ces procédures et fonctions
pour assurer cette autonomie. Je dois avoir +15 procédures (DessinBouton, UserName...) qui ne sont pas
liées directement a la fonction de ce module(gestion imprimante, options d'impression...),
mais permette de faire fonctionné le module (Ex: BDGPrinter).
Lorsque que je développe une application, j'inclus au fur et à mesure les modules (BDGPrinter, OutputVoice,
BDGScanner...) donc j'ai besoin !
Pas besoin de chercher toutes les procédures (annexes ou fonctions), tous est inclus.
Mon problème c'est que le compilo qui "gueule" a chaque fois d'une procédure est déjà dans un autre module
ou dans programme principal...
CompilerIf Defined(......., #PB_Procedure) = #False" marche bien pour éviter d'inclure la procédure une
nouvelle fois, cela a résolu 50% de mes problèmes !
Mais il n'y rien de prévu pour la déclaration !. Une constance : #PB_Declare permettrait (peut-être...)
de ne pas mettre en rogne le compilo !
J'espéres que j'ai été assez claire, que tu a compris mon propos !
Je suis toujours a la recherche d'une solution (peut-être demander a Fred une nouvelle constante...)
Ulix
Re: Est-il possible de tester la présence d'une procedure ?
oO mais pourtant la procedure peut etre declarée 50 fois sans erreur
du coup faut juste metre le
CompilerIf / endif dans chaque module autour de chaque procédure a déclarer
comme ca pas de compilo gui gueule
idem pour les constantes utilises par les dites procedures faut juste les mettre dans le compilerif / endif pour ne pas les compiler une seconde fois
a noter que si on met un déclare test() en début de code le compilateur ne trouve pas la procédure test et renvoi une erreur
ce qui rend le système
CompilerIf Defined(test, #PB_Procedure) = #False
CompilerEndIf
inutile étant donner qu'il faudrait que la procédure soit une fois au moins hors de cette condition
il serait alors préférable de mettre les modules en début de code et de ne pas utiliser de déclare. pour pouvoir utiliser cette astuce.
Code : Tout sélectionner
Declare test()
Declare test()
Declare test()
Declare test()
Declare test()
Declare test()
Declare test()
Declare test()
test()
Procedure test()
Debug "test"
EndProcedure
du coup faut juste metre le
CompilerIf / endif dans chaque module autour de chaque procédure a déclarer
comme ca pas de compilo gui gueule
idem pour les constantes utilises par les dites procedures faut juste les mettre dans le compilerif / endif pour ne pas les compiler une seconde fois
Code : Tout sélectionner
; module test
CompilerIf Defined(test, #PB_Procedure) = #False
Declare test()
Debug "Not defined"
#blah=1
Procedure test()
If #blah=1
Debug "test"
EndIf
EndProcedure
CompilerEndIf
; module test
CompilerIf Defined(test, #PB_Procedure) = #False
Declare test()
Debug "Not defined"
#blah=1
Procedure test()
If #blah=1
Debug "test"
EndIf
EndProcedure
CompilerEndIf
test()
ce qui rend le système
CompilerIf Defined(test, #PB_Procedure) = #False
CompilerEndIf
inutile étant donner qu'il faudrait que la procédure soit une fois au moins hors de cette condition
il serait alors préférable de mettre les modules en début de code et de ne pas utiliser de déclare. pour pouvoir utiliser cette astuce.
Dernière modification par case le mar. 24/avr./2018 19:27, modifié 1 fois.
Re: Est-il possible de tester la présence d'une procedure ?
Salut case !
Ton exemple marche parce que tu n'utilise pas les modules !
Test l'exemple suivant :
C'est la structure générale de mes applications !
Re moi ! Pour reprendre ton 2ème code module
Pas réussi a faire marché, je dois pas être bon sur ce coup là
A+
Ton exemple marche parce que tu n'utilise pas les modules !
Test l'exemple suivant :
Code : Tout sélectionner
; Programme principale
; Ici : Enumeration
; Ici : Structure
; ici Globale...
Declare test()
; Ici mes includes dont mes modules
; XIncludeFile "xxxx... module "
;=============================
DeclareModule Patate
Declare test()
EndDeclareModule
Module Patate
CompilerIf Defined(test, #PB_Procedure) = #False
Procedure test()
EndProcedure
CompilerEndIf
EndModule
;==========================
UseModule Patate
; Mes procedure du programme principales
Procedure test()
Debug "test"
EndProcedure
; Lancement du programme
test()
Re moi ! Pour reprendre ton 2ème code module
Code : Tout sélectionner
; Programme principale
; Ici : Enumeration
; Ici : Structure
; ici Globale...
Declare test()
; Ici mes includes dont mes modules
; XIncludeFile "xxxx... module "
;=============================
DeclareModule Patate
CompilerIf Defined(test, #PB_Procedure) = #False
Declare test()
Debug "Not defined"
#blah=1
Procedure test()
If #blah=1
Debug "test"
EndIf
EndProcedure
CompilerEndIf
EndDeclareModule
Module Patate
CompilerIf Defined(test, #PB_Procedure) = #False
Declare test()
Debug "Not defined"
#blah=1
Procedure test()
If #blah=1
Debug "test"
EndIf
EndProcedure
CompilerEndIf
EndModule
;==========================
UseModule Patate
; Mes procedure du programme principales
Procedure test()
Debug "test"
EndProcedure
; Lancement du programme
test()
A+
Re: Est-il possible de tester la présence d'une procedure ?
ah !
j'ai peur qu'il n'y ai pas de solution miracle ^^
en tout cas dans cette voie de compilerif/endif
j'ai peur qu'il n'y ai pas de solution miracle ^^
en tout cas dans cette voie de compilerif/endif
Re: Est-il possible de tester la présence d'une procedure ?
A mon avis, c'est un bug du compilo / macro, a part arrêter d'utilisé les modules, je ne vois pasPas réussi a faire marché, je dois pas être bon sur ce coup là
Re: Est-il possible de tester la présence d'une procedure ?
Salut G-Rom !
Le compilo me dit :
Ligne 23: A Procedure can't be declared inside 'DeclareModule'. Use 'Declare' instead.
Traduction google:
Ligne 23: Une procédure ne peut pas être déclarée dans 'DeclareModule'. Utilisez 'Declare' à la place.
Je pense que la réponse du compilo est fausse, ou mauvaise traduction !
L'aide de PB explique de DeclareModule sert a déclarer les procedures (public) !
Il y a une contradiction entre la réponse du compilo est l'aide... mais c'est pas là le plus important !
Es-ce qu'une constante : #PB_Declare, pourrait faire l'affaire ?
On pourrait alors tester la declaration comme suit :
CompilerIf Defined(......., #PB_Declare) = #False"
Je vais attendre une solution, sinon je posterais dans section bug, peut-être que Fred .....!
Ulix
Le compilo me dit :
Ligne 23: A Procedure can't be declared inside 'DeclareModule'. Use 'Declare' instead.
Traduction google:
Ligne 23: Une procédure ne peut pas être déclarée dans 'DeclareModule'. Utilisez 'Declare' à la place.
Je pense que la réponse du compilo est fausse, ou mauvaise traduction !
L'aide de PB explique de DeclareModule sert a déclarer les procedures (public) !
Il y a une contradiction entre la réponse du compilo est l'aide... mais c'est pas là le plus important !
Es-ce qu'une constante : #PB_Declare, pourrait faire l'affaire ?
On pourrait alors tester la declaration comme suit :
CompilerIf Defined(......., #PB_Declare) = #False"
Je vais attendre une solution, sinon je posterais dans section bug, peut-être que Fred .....!
Ulix
Re: Est-il possible de tester la présence d'une procedure ?
Et comme cela ?
Cordialement,
GallyHC
Code : Tout sélectionner
; ****************************************************************************
DeclareModule Patate
CompilerIf Defined(test, #PB_Procedure) = #False
Declare test()
Debug "Not defined"
CompilerEndIf
EndDeclareModule
Module Patate
CompilerIf Defined(test, #PB_Procedure) = #True
Debug "Not defined"
#blah = 1
Procedure test()
If #blah=1
Debug "test 1 "
EndIf
EndProcedure
CompilerEndIf
EndModule
; ****************************************************************************
; A METTRE AVEC OU SANS COMMENTAIRE.
;UseModule Patate
; A METTRE AVEC OU SANS COMMENTAIRE.
; ****************************************************************************
CompilerIf Defined(test, #PB_Procedure) = #False
Procedure test()
Debug "test 2"
EndProcedure
CompilerEndIf
test()
GallyHC
Configuration : Tower: Windows 10 (Processeur: i7 "x64") (Mémoire: 16Go) (GeForce GTX 760 - 2Go) - PureBasic 5.72 (x86 et x64)
Re: Est-il possible de tester la présence d'une procedure ?
ton code a un probleme et démontre le bug :
et après tu définis la procédure alors que d'après cette ligne, elle est déjà déclarée, c'est incohérent.
Code : Tout sélectionner
CompilerIf Defined(test, #PB_Procedure) = #True