Est-il possible de tester la présence d'une procedure ?

[Ulix]

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

[GallyHC]

Bonjour,

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

Pour le test, il faut retirer les commentaires de la procédure du haut pour voir la différence.

Cordialement,
GallyHC

[Ulix]

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

[GallyHC]

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

[case]

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

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

[Ulix]

@ 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 !

[falsam]

Une question me brûle les lèvres : Pourquoi faire un déclare d'une procédure qui n'existe pas ?

[Ulix]

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

[case]

oO mais pourtant la procedure peut etre declarée 50 fois sans erreur

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()

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.

[Ulix]

Salut case !


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()

C'est la structure générale de mes applications !

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()

Pas réussi a faire marché, je dois pas être bon sur ce coup là

A+

[case]

ah !
j'ai peur qu'il n'y ai pas de solution miracle ^^

en tout cas dans cette voie de compilerif/endif

[G-Rom]

Pas réussi a faire marché, je dois pas être bon sur ce coup là

A mon avis, c'est un bug du compilo / macro, a part arrêter d'utilisé les modules, je ne vois pas

[Ulix]

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

[GallyHC]

Et comme cela ?

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()

Cordialement,
GallyHC

[G-Rom]

ton code a un probleme et démontre le bug :

Code : Tout sélectionner

CompilerIf Defined(test, #PB_Procedure) = #True

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.