remplir une variable par son nom : VARIABLE_FILL(T,N)

Dernière édition par silverman le Sam 8 Oct 2016 - 23:25, édité 2 fois

Bonjour à tous

Suite à une demande que j'ai fait ICI, j'ai réussi à la concrétiser en panoramic pur!
Cette sub permet d'écrire dans une variable, en lui transmettant le nom de cette variable dans une chaîne de caractères, ce qui est très pratique si une sub doit renvoyer une valeur(c'est tout l'intérêt de cette sub). Elle a 2 paramètres : une chaîne de caractères contenant le nom de la variable, et le résultat que l'on veut attribuer à cette variable; Il n'y a pas à se soucier du type de variable qu'on lui passe, c'est reconnu automatiquement.
Exemple:

Code:: dim mon_nombre
mon_nombre=1/3

' avant l'arrondi
print mon_nombre

round_float("mon_nombre",mon_nombre,4)

' après l'arrondi
print : print mon_nombre
END
'
sub round_float(v$,float,decimales%)
dim_local tmp%
   ' arrondi 'float'
   tmp%=float*power(10,decimales%)
   float=tmp%/(power(10,decimales%))
   ' écrit la variable arrondi 'float' dans la variable utilisateur
   VARIABLE_FILL(v$,float)
end_sub

sub VARIABLE_FILL(user_variable$,push$)
dim_local start%,suivant%,null$,type%,tmp_swap%,lire%,tmp$
dim_local adr_destination%,adr_source%,long%,float
   '
   null$="" :' null$ est une chaîne 'null'(cad pointeur vers chaîne de caractère=0), il faudra la remettre dans cet état avant de quitter la sub (sinon violation de mémoire!)
   :' son pointeur vers chaîne de caractère va être réaffecté pour effectuer des recherches en mémoire
   suivant%=80
   start%=adr(number_3d_target)+56-suivant% :' début de la table des symboles
   user_variable$=upper$(user_variable$) :' transforme la variable de l'utilisateur en majuscule car la table des symboles est en majuscule

   repeat
   start%=start%+suivant%
   ' commence à récupérer les noms des variables stockées dans la table des symboles
' GET_STRING_PTR(adr(null$),start%)
   adr_destination%=adr(null$)
   adr_source%=start%
   for lire%=0 to 3
   poke adr_destination%+lire%,peek(adr_source%+lire%)
   next lire%
   tmp$=null$ :' utilisation d'une variable intermédiaire, par sécurité
   '
   ' si la variable de l'utilisateur est trouvé, la remplir
   if tmp$=user_variable$
   type%=peek(start%+4)
   select type%
   case 1
   ' écriture d'un nombre entier
   '
' WRITE_LONG(start%+12,val(push$))
   adr_destination%=start%+12
   long%=val(push$)
   for lire%=0 to 3
   poke adr_destination%+lire%,peek(adr(long%)+lire%)
   next lire%
   case 2
   ' écriture d'une chaîne de caractère
   '
' GET_STRING_PTR(adr(tmp_swap%),start%+16)
   adr_destination%=adr(tmp_swap%)
   adr_source%=start%+16
   for lire%=0 to 3
   poke adr_destination%+lire%,peek(adr_source%+lire%)
   next lire%
' GET_STRING_PTR(start%+16,adr(push$))
   adr_destination%=start%+16
   adr_source%=adr(push$)
   for lire%=0 to 3
   poke adr_destination%+lire%,peek(adr_source%+lire%)
   next lire%
' WRITE_LONG(adr(push$),tmp_swap%)
   adr_destination%=adr(push$)
   long%=tmp_swap%
   for lire%=0 to 3
   poke adr_destination%+lire%,peek(adr(long%)+lire%)
   next lire%
   case 3
   ' écriture d'un nombre à virgule
   '
' WRITE_FLOAT(start%+24,val(push$))
   adr_destination%=start%+24
   float=val(push$)
   for lire%=0 to 7
   poke adr_destination%+lire%,peek(adr(float)+lire%)
   next lire%
   end_select
   ' recherche terminé
   ' on ne peux pas faire 'null$=""' pour réaffecter 'null' à null$, car 'null$' contient une partie de la table des symboles, qui est une zone de mémoire protégé contre l'écriture(effacement)
   ' donc on remet le pointeur de chaîne de caractère à 0(cela revient à réaffecter 'null' à null$)
' WRITE_LONG(adr(null$),0)
   adr_destination%=adr(null$)
   long%=0
   for lire%=0 to 3
   poke adr_destination%+lire%,peek(adr(long%)+lire%)
   next lire%
   '
   ' quitter
   exit_repeat
   end_if
   ' sinon continuer la recherche tant que l'on a pas atteind la fin de la table des symboles
   until tmp$=""

   ' un message d'erreur à l'utilisateur si la variable n'a pas été trouvé
   if tmp$=""
   if message_error_ok("La variable '"+user_variable$+"' n'existe pas")=1
   end_if
   end_if
end_sub

La sub seule :

Code:: sub VARIABLE_FILL(user_variable$,push$)
dim_local start%,suivant%,null$,type%,tmp_swap%,lire%,tmp$
dim_local adr_destination%,adr_source%,long%,float
   '
   null$="" :' null$ est une chaîne 'null'(cad pointeur vers chaîne de caractère=0), il faudra la remettre dans cet état avant de quitter la sub (sinon violation de mémoire!)
   :' son pointeur vers chaîne de caractère va être réaffecté pour effectuer des recherches en mémoire
   suivant%=80
   start%=adr(number_3d_target)+56-suivant% :' début de la table des symboles
   user_variable$=upper$(user_variable$) :' transforme la variable de l'utilisateur en majuscule car la table des symboles est en majuscule

   repeat
   start%=start%+suivant%
   ' commence à récupérer les noms des variables stockées dans la table des symboles
' GET_STRING_PTR(adr(null$),start%)
   adr_destination%=adr(null$)
   adr_source%=start%
   for lire%=0 to 3
   poke adr_destination%+lire%,peek(adr_source%+lire%)
   next lire%
   tmp$=null$ :' utilisation d'une variable intermédiaire, par sécurité
   '
   ' si la variable de l'utilisateur est trouvé, la remplir
   if tmp$=user_variable$
   type%=peek(start%+4)
   select type%
   case 1
   ' écriture d'un nombre entier
   '
' WRITE_LONG(start%+12,val(push$))
   adr_destination%=start%+12
   long%=val(push$)
   for lire%=0 to 3
   poke adr_destination%+lire%,peek(adr(long%)+lire%)
   next lire%
   case 2
   ' écriture d'une chaîne de caractère
   '
' GET_STRING_PTR(adr(tmp_swap%),start%+16)
   adr_destination%=adr(tmp_swap%)
   adr_source%=start%+16
   for lire%=0 to 3
   poke adr_destination%+lire%,peek(adr_source%+lire%)
   next lire%
' GET_STRING_PTR(start%+16,adr(push$))
   adr_destination%=start%+16
   adr_source%=adr(push$)
   for lire%=0 to 3
   poke adr_destination%+lire%,peek(adr_source%+lire%)
   next lire%
' WRITE_LONG(adr(push$),tmp_swap%)
   adr_destination%=adr(push$)
   long%=tmp_swap%
   for lire%=0 to 3
   poke adr_destination%+lire%,peek(adr(long%)+lire%)
   next lire%
   case 3
   ' écriture d'un nombre à virgule
   '
' WRITE_FLOAT(start%+24,val(push$))
   adr_destination%=start%+24
   float=val(push$)
   for lire%=0 to 7
   poke adr_destination%+lire%,peek(adr(float)+lire%)
   next lire%
   end_select
   ' recherche terminé
   ' on ne peux pas faire 'null$=""' pour réaffecter 'null' à null$, car 'null$' contient une partie de la table des symboles, qui est une zone de mémoire protégé contre l'écriture(effacement)
   ' donc on remet le pointeur de chaîne de caractère à 0(cela revient à réaffecter 'null' à null$)
' WRITE_LONG(adr(null$),0)
   adr_destination%=adr(null$)
   long%=0
   for lire%=0 to 3
   poke adr_destination%+lire%,peek(adr(long%)+lire%)
   next lire%
   '
   ' quitter
   exit_repeat
   end_if
   ' sinon continuer la recherche tant que l'on a pas atteind la fin de la table des symboles
   until tmp$=""

   ' un message d'erreur à l'utilisateur si la variable n'a pas été trouvé
   if tmp$=""
   if message_error_ok("La variable '"+user_variable$+"' n'existe pas")=1
   end_if
   end_if
end_sub

bonjour Silverman,

Ta SUB fonctionne parfaitement, mais je n'arrive pas à comprendre la finalité.

Code:: a=4/3
i=a
print i

dans le code ci-dessus, j'ai le même résultat que dans celui ci-desous drunken

Alors à quoi sert cette SUB Question

Code:: dim a,i, b%,j%, c$,my_txt$ ,var$

a=4/3
i=a
print i

print

var$="i"
variable_fill("i",a) : print i
print

END
sub VARIABLE_FILL(v$,push$)
dim_local strt%,i%,b$,tpe%,adrs%,tmp%,lire%,tmp$
dim_local adr_destination%,adr_source%,long%,float
'
b$="" :' b$ est une chaîne 'null'(cad pointeur vers chaîne de caractère=0), il faudra la remettre dans cet état avant de quitter la sub (sinon violation de mémoire!)
:' son pointeur vers chaîne de caractère va être réaffecté pour effectuer des recherches en mémoire
i%=80
strt%=adr(number_3d_target)+56-i% :' début de la table des symboles
v$=upper$(v$) :' transforme la variable de l'utilisateur en majuscule car la table des symboles est en majuscule

repeat
strt%=strt%+i%
' commence à récupérer les noms des variables stockées dans la table des symboles
' GET_STRING_PTR(adr(b$),strt%)
adr_destination%=adr(b$)
adr_source%=strt%
for lire%=0 to 3
poke adr_destination%+lire%,peek(adr_source%+lire%)
next lire%
tmp$=b$ :' utilisation d'une variable intermédiaire, par sécurité
'
tpe%=peek(strt%+4)
adrs%=strt%+8+(4*tpe%)
' si la variable de l'utilisateur est trouvé, la remplir
if tmp$=v$
select tpe%
case 1
' écriture d'un nombre entier
'
' WRITE_LONG(adrs%,val(push$))
adr_destination%=adrs%
long%=val(push$)
for lire%=0 to 3
poke adr_destination%+lire%,peek(adr(long%)+lire%)
next lire%
case 2
' écriture d'une chaîne de caractère
'
' GET_STRING_PTR(adr(tmp%),adrs%)
adr_destination%=adr_destination%
adr_source%=adr_source%
for lire%=0 to 3
poke adr_destination%+lire%,peek(adr_source%+lire%)
next lire%
' GET_STRING_PTR(adrs%,adr(push$))
adr_destination%=adrs%
adr_source%=adr(push$)
for lire%=0 to 3
poke adr_destination%+lire%,peek(adr_source%+lire%)
next lire%
' WRITE_LONG(adr(push$),tmp%)
adr_destination%=adr(push$)
long%=tmp%
for lire%=0 to 3
poke adr_destination%+lire%,peek(adr(long%)+lire%)
next lire%
case 3
' écriture d'un nombre à virgule
'
' WRITE_FLOAT(adrs%+4,val(push$))
adr_destination%=adrs%+4
float=val(push$)
for lire%=0 to 7
poke adr_destination%+lire%,peek(adr(float)+lire%)
next lire%
end_select
' recherche terminé
' on ne peux pas faire 'b$=""' pour réaffecter 'null' à b$, car 'b$' contient une partie de la table des symboles, qui est une zone de mémoire protégé contre l'écriture(effacement)
' donc on remet le pointeur de chaîne de caractère à 0(cela revient à réaffecter 'null' à b$)
' WRITE_LONG(adr(b$),0)
adr_destination%=adr(b$)
long%=0
for lire%=0 to 3
poke adr_destination%+lire%,peek(adr(long%)+lire%)
next lire%
'
' quitter
exit_repeat
end_if
' sinon continuer la recherche tant que l'on a pas attenid la fin de la table des symboles
until tmp$=""

' un message d'erreur à l'utilisateur si la variable n'a pas été trouvé
if tmp$=""
if message_error_ok("La variable '"+v$+"' n'existe pas")=1
end_if
end_if
end_sub

Dernière édition par silverman le Sam 8 Oct 2016 - 23:26, édité 1 fois

Bonjour jean-claude

En fait, c'est putôt utile pour les subs. J'ai repris une des tiennes pour te montrer.
Dans ta sub, tu réserves les variables globales 'bandeau%' et 'bord%', donc si celui qui utilises ta sub, utilise aussi ces variables dans son programme, il peut y avoir des pb.
Avec ma sub, tu n'a pas besoin de créer des variables globales, c'est celui qui utilisera ta sub qui les crééra dans son programme.

Code:: dim ba%,bo%

Retourne_Dimension_Bandeau_Et_Bord("ba%","bo%")

print "taille du bandeau = ",ba%
print "taille du bord = ",bo%

end
' ------------------------------------------------------------------------------
SUB Retourne_Dimension_Bandeau_Et_Bord(result_1$ , result_2$)
   ' controle de la position de la procédure dans le programme
   IF NUMBER_OBJECTS>0
   message "La SUB 'Retourne_Dimension_Bandeau_Et_Bord' doit être placée avant la création du premier objet !"
   terminate
   END_IF
   DIM_LOCAL bandeau%,bord%
   ' création des VARIABLES GLOBALES
' IF VARIABLE("bandeau%")=0 then DIM bandeau%
' IF VARIABLE("bord%")=0 then DIM bord%
   ' Calcul de bandeau% et bord%
   dim_local w0%,h0%,w1%,h1%,w2%,h2%
   w0%=WIDTH(0) : h0%=HEIGHT(0)
   picture 1 : full_space 1 : w1%=WIDTH(1) : h1%=HEIGHT(1)
   w2%=w0%-w1% : h2%=h0%-h1% : bandeau%=h2%-(w2%/2) : bord%=w2%/2
   ' Suppression du Picture devenu inutile
   delete 1
   '
   VARIABLE_FILL(result_1$,bandeau%)
   VARIABLE_FILL(result_2$,bord%)
END_SUB

sub VARIABLE_FILL(user_variable$,push$)
dim_local start%,suivant%,null$,type%,tmp_swap%,lire%,tmp$
dim_local adr_destination%,adr_source%,long%,float
   '
   null$="" :' null$ est une chaîne 'null'(cad pointeur vers chaîne de caractère=0), il faudra la remettre dans cet état avant de quitter la sub (sinon violation de mémoire!)
   :' son pointeur vers chaîne de caractère va être réaffecté pour effectuer des recherches en mémoire
   suivant%=80
   start%=adr(number_3d_target)+56-suivant% :' début de la table des symboles
   user_variable$=upper$(user_variable$) :' transforme la variable de l'utilisateur en majuscule car la table des symboles est en majuscule

   repeat
   start%=start%+suivant%
   ' commence à récupérer les noms des variables stockées dans la table des symboles
' GET_STRING_PTR(adr(null$),start%)
   adr_destination%=adr(null$)
   adr_source%=start%
   for lire%=0 to 3
   poke adr_destination%+lire%,peek(adr_source%+lire%)
   next lire%
   tmp$=null$ :' utilisation d'une variable intermédiaire, par sécurité
   '
   ' si la variable de l'utilisateur est trouvé, la remplir
   if tmp$=user_variable$
   type%=peek(start%+4)
   select type%
   case 1
   ' écriture d'un nombre entier
   '
' WRITE_LONG(start%+12,val(push$))
   adr_destination%=start%+12
   long%=val(push$)
   for lire%=0 to 3
   poke adr_destination%+lire%,peek(adr(long%)+lire%)
   next lire%
   case 2
   ' écriture d'une chaîne de caractère
   '
' GET_STRING_PTR(adr(tmp_swap%),start%+16)
   adr_destination%=adr(tmp_swap%)
   adr_source%=start%+16
   for lire%=0 to 3
   poke adr_destination%+lire%,peek(adr_source%+lire%)
   next lire%
' GET_STRING_PTR(start%+16,adr(push$))
   adr_destination%=start%+16
   adr_source%=adr(push$)
   for lire%=0 to 3
   poke adr_destination%+lire%,peek(adr_source%+lire%)
   next lire%
' WRITE_LONG(adr(push$),tmp_swap%)
   adr_destination%=adr(push$)
   long%=tmp_swap%
   for lire%=0 to 3
   poke adr_destination%+lire%,peek(adr(long%)+lire%)
   next lire%
   case 3
   ' écriture d'un nombre à virgule
   '
' WRITE_FLOAT(start%+24,val(push$))
   adr_destination%=start%+24
   float=val(push$)
   for lire%=0 to 7
   poke adr_destination%+lire%,peek(adr(float)+lire%)
   next lire%
   end_select
   ' recherche terminé
   ' on ne peux pas faire 'null$=""' pour réaffecter 'null' à null$, car 'null$' contient une partie de la table des symboles, qui est une zone de mémoire protégé contre l'écriture(effacement)
   ' donc on remet le pointeur de chaîne de caractère à 0(cela revient à réaffecter 'null' à null$)
' WRITE_LONG(adr(null$),0)
   adr_destination%=adr(null$)
   long%=0
   for lire%=0 to 3
   poke adr_destination%+lire%,peek(adr(long%)+lire%)
   next lire%
   '
   ' quitter
   exit_repeat
   end_if
   ' sinon continuer la recherche tant que l'on a pas atteind la fin de la table des symboles
   until tmp$=""

   ' un message d'erreur à l'utilisateur si la variable n'a pas été trouvé
   if tmp$=""
   if message_error_ok("La variable '"+user_variable$+"' n'existe pas")=1
   end_if
   end_if
end_sub

Oui, maintenant je comprends la finalité de la chose.

Le programmeur doit définir au préalable les variables de son programme à lui.
Et ensuite il peut utiliser une SUB trouvée sur le forum en utilisant ses propres variables.

Néanmoins, tu as dû retoucher ma SUB Retourne_Dimension_Bandeau_Et_Bord() par Retourne_Dimension_Bandeau_Et_Bord("ba%","bo%")
Qui demande le résultat dans (ba%","bo%") donc on échappe pas au deux variables globales.

Dans un sens, ce n'est pas idiot de demander à une SUB de fournir les résultats directement, pourvu qu'on ai crée les variables des résultats, et ça sans changer la SUB initiale, mais c'est à la condition que j'ai fourni une SUB utilisant ton système !

Et c'est là que commence la discussion, car il faudrait que tous les Panoramiciens suivent cette méthode (à moins que je n'ai pas compris)

A+

Jean Claude a écrit:: ...pourvu qu'on ai crée les variables des résultats, et ça sans changer la SUB initiale, mais c'est à la condition que j'ai fourni une SUB utilisant ton système !
Et c'est là que commence la discussion, car il faudrait que tous les Panoramiciens suivent cette méthode (à moins que je n'ai pas compris)

C'est ça, il faut juste fournir ma sub dans le programme, rien de plus. Cette méthode est la mise en application d'une demande d'ajout d'une commande que j'ai fait à jack, c'est une alternative aux 'function' qui n'existe pas en panoramic. C'est plutôt élégant, tu ne trouve pas?
Quand dans ton programme tu as plusieurs subs qui renvoient un résultat dans des variables différentes, ce n'est pas facile de se rappeler de toutes ces variables, surtout si tu a mis le développement de ton programme en suspend quelque temps. Avec ce système, bien longtemps après les avoir créé(ou importé du forum) tu peux les réutiliser sans les étudier pour savoir dans quelles variable le résultat est renvoyé. Cela rend l'utilisation de ces subs plus intuitive!

De plus, cette sub a été un bon exercice pour moi, elle m'a permis de trouver une solution pour contrer le phénomène de l'allocation dynamique de mémoire affecté aux variables.

Code:: '
' Mise en évidence du phénomène de l'allocation dynamique de mémoire affecté aux variables
'
dim a%

test(adr(a%))

END
sub test(tst%)
   print "avant :"
   print "tst% = ",tst%
   print "adr(a%) = ",adr(a%)
   '
   dim_local b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z
   print
   print "après :"
   print "tst% = ",tst%
   print "adr(a%) = ",adr(a%)
end_sub

Nombre de messages : 7095 Localisation : 77 Date d'inscription : 29/11/2007

Personnellement, pour éviter le problème d'une variable connue à la fois de l'appelant et de la sub (ce qui crée une contrainte pour l'universalité des subs), j'utilise en général le presse-papier pour renvoyer des données, sous forme alphanumérique.

S'il n'y a qu'un paramètre à renvoyer, aucun problème (CLIPBOARD_STRING_COPY et CLIPBOARD_STRING_PASTE$), à charge pour l'appelant de reconvertir en numérique si besoin.

S'il y a plusieurs paramètres en retour, je les sépare arbitrairement par un caractère ';':

Code:: ...
Masub(f$,x,y)
a$ = CLIPBOARD_STRING_PASTE$: ' récupération des données en retour
k% = INSTR(a$,";"): p1$ = LEFT$(a$,k%-1): a$ = RIGHT_POS$(a$,k%+1)
k% = INSTR(a$,";"): p2$ = LEFT$(a$,k%-1): a$ = RIGHT_POS$(a$,k%+1)
k% = INSTR(a$,";"): p3$ = LEFT$(a$,k%-1): a$ = RIGHT_POS$(a$,k%+1)
p4$ = a$
' remise éventuelle au format numérique (VAL)
...
END
' =====
SUB Masub(f$,x,y)
DIM_LOCAL p1$,p2$,p3$,p4$
' ...
' calcul des paramètres p1, p2, p3, p4 à renvoyer
' mise éventuelle au format alphanumérique (STR$)
' ... puis:
CLIPBOARD_STRING_COPY p1$+";"+p2$+";"+p3$+";"+p4$
END_SUB

Dernière édition par Jean Claude le Sam 8 Oct 2016 - 18:12, édité 2 fois

@Silverman
Oui effectivement, tu as raison, c'est une bonne manière de ne pas avoir à mémoriser les variables utilisées pour le résultat.
Le grand intérêt, c'est que si je veux utiliser une SUB que tu fournirais sur le Forum, je n'ai pas besoin de chercher quelles variables de retour tu as prévu, ce qui compte c'est à quoi sert cette SUB.
Je vais adopter ta méthode, dans mes prochains programmes car je trouve que c'est bon pour le partage et comme tu l'as souligné, la reprise d'un programme après un long moment est souvent difficile.

Une remarque: tu utilises b$, i% comme variable locale. Ors j'ai nombre de programmes qui ont b$ et/ou i% en variable globale.
J'ai vérifié, et apparemment ça ne pose aucun problème d'avoir les deux, mais je ne suis pas certain q'il n'y ai pas un risque. Mais peut-être que je fais de nœuds au cerveau pour rien.

A+

On s'est croisé JL35, alors bonjour.
Heu.. le presse papier, oui mais il faut bien écrire le code Question

A+

Jean Claude a écrit:: Une remarque: tu utilises b$, i% comme variable locale. Ors j'ai nombre de programmes qui ont b$ et/ou i% en variable globale.

Ne t'inquiète pas pour ça, les variables locales sont renommées en interne par panoramic avec un nom unique. Il ne peut pas y avoir de mélange avec les variables globales. Panoramic procède ainsi : nom_de_la_sub!variable_locale
Par exemple avec le b$ de ma sub, panoramic la renomme en : VARIABLE_FILL!B$

@JL35
Je pense que ton système est compliqué pour un débutant.
Lorsque j'ai conçu cette sub, je m'étais fixé comme critères : simple, efficace, pratique. Honnêtement, je ne croyais pas que ce serait possible, je suis surpris du résultat! De plus, sans utiliser de dll, étant 100% panoramic, cela me laisse penser que cette sub peut être transformé en une commande interne très facilement.

Nombre de messages : 7095 Localisation : 77 Date d'inscription : 29/11/2007

@silverman et Jean Claude
Effectivement, on peut très bien redéfinir en local dans la sub n'importe quelle variable déjà déclarée en global dans le programme principal, sans interférence. Même les variables passées en paramètres deviennent locales dans la sub, dommage d'ailleurs, et je le regrette, ça aurait pu être un moyen très simple de renvoyer un paramètre en le déclarant dans l'appel à la sub (paramètres d'appel + paramètres attendus en retour).

Je ne trouve pas mon système si compliqué que ça, même s'il est loin d'être aussi sophistiqué que le tien, mais bon, c'est vrai qu'une commande interne dédiée serait la bienvenue.

Dernière édition par Jean Claude le Dim 9 Oct 2016 - 9:41, édité 2 fois

Me voilà rassuré pour les variables locales ayant le même nom qu'une variable ~~locale~~ globale. C'est confirmé par deux Panoramiciens dont la compétence n'est pas à mettre en doute. Very Happy

JL35 a écrit:: ...., une commande interne dédiée serait la bienvenue.

Oui, moi comme Silverman, on est d'accord sur ce point.

A+

un copier-coller-merder s'est glissé dans la sub (--->risque d'un plantage de panoramic) Embarassed

J'ai corriger cette erreur et remis mon premier post à jour. J'en ai profité pour renommer des variables pour plus de clarté Wink

Jean Claude a écrit:: Me voilà rassuré pour les variables locales ayant le même nom qu'une variable locale. C'est confirmé par deux Panoramiciens dont la compétence n'est pas à mettre en doute.

Il y a plus de quatre années, j’ai écris ceci.

Avec l’âge, certaines personnes commencent à oublier silent

Rectification: Me voilà rassuré pour les variables locales ayant le même nom qu'une variable ~~locale~~ globale.

Merci Papydall pour ce rappel que j'ai cherché, en vain, hier.
A ce sujet: j'espère que Jack va introduire les fonctions dans Panoramic.

Merci à Silverman pour la correction de sa SUB et d'avoir renommé les variables locales qui sont plus explicites.

A+

Sujet: Re Dim 9 Oct 2016 - 12:01

Pourquoi ne pas déclarer une variable globale dans la procédure "FctRes_MaFonction+Type" par exemple ?
Si on se donne tous une règle de dénomination de cette variable résultat, cela devrait aussi fonctionner.

Cela ferait juste une ligne à ajouter en début de procédure:

Code:: if variable("FctRes_Fonction$")=0 then dim FctRes_Fonction$

» 2ème "dim" sur variable EFFACE la variable
» Remplir un FORM avec la couleur ou le papier-peint du bureau
» variable?
» renommer une variable?
» variable ne décrémente pas