plusieur return procedure (et procedure dll)

Vous avez une idée pour améliorer ou modifier PureBasic ? N'hésitez pas à la proposer.
Backup
Messages : 14526
Inscription : lun. 26/avr./2004 0:40

Message par Backup »

Ollivier a écrit :(je débroussaille un peu les araignées de ce post)

En fait, actuellement, et j'espère ne pas dire une bêtise, PB retourne une seule valeur.

Mh...
oui ! :D

mais libre a nous de mettre des conditions pour qu'une valeur soit retournée
en fonction de tel ou tel condition !

ou bien de retourner une chaine qui en son sein contient plusieur valeur separé par un signe particulier qui pourra etre lu par StringField(Chaine$, Index, Delimiteur$) par exemple !! :D

comme ça par exemple !!


Procedure.s addition_et_multiplication (a,b)
    Resultat=a+b ; on addition les deux valeur
    resultat2=a*b ; on multiplie les deux valeur
    camion$= Str (Resultat)+ "," + Str (resultat2) ; on concatene le tout dans une chaine (on va leur faire passer la douanne en planque : D)
     ProcedureReturn camion$
EndProcedure


camion$=addition_et_multiplication (5,5) ; on lance le calcul

For i=1 To 2
     Debug StringField (camion$,i, "," ) ; on va extraire nos clandestins du camion :lol:
Next i



:D
Ollivier
Messages : 4190
Inscription : ven. 29/juin/2007 17:50
Localisation : Encore ?
Contact :

Message par Ollivier »

Ce n'est pas encore ça, mais peut-être qu'on s'en rapproche...De ton GFA tant rêvé :D

Code : Tout sélectionner

Macro _ProcedureReturn
! Ret
EndMacro

Macro HopLa()
! Pop [v_a]
! Pop [v_b]
! Pop [v_c]
! Pop [v_d]
EndMacro

Procedure x(a, b, c, d)
  a = 29
  b = 22
  c = 56
  d = 35 
  _ProcedureReturn
EndProcedure


; *** PRINCIPE ***

x(a, b, c, d)
Debug "Voici 4 départements où circulent de magnifiques créatures:"
HopLa()
Debug a
Debug b
Debug c
Debug d
Ollivier
Messages : 4190
Inscription : ven. 29/juin/2007 17:50
Localisation : Encore ?
Contact :

Message par Ollivier »

Attention /!\ Ne modifie pas de trop, c'est violent sinon...

Il y a peut-être moyen de faire plus souple.
Avatar de l’utilisateur
Kwai chang caine
Messages : 6962
Inscription : sam. 23/sept./2006 18:32
Localisation : Isere

Message par Kwai chang caine »

Toi aussi t'es un magicien.
Cet ASM, c'est une baguette magique ou quoi :D

Encore une question qui tue .....
On peut faire pareil avec des strings :D

Je sais je sais, il est casse c..... ce KCC, on lui donne le doigt il veut le bras :lol:
Ollivier
Messages : 4190
Inscription : ven. 29/juin/2007 17:50
Localisation : Encore ?
Contact :

Message par Ollivier »

wouahou! Touche pas trop Kcc: ça peut faire mal! Il y a une méthode moins trash que ce code pour parvenir aux mêmes fins. Je verrai ça après le boulot.
MorpheusDX
Messages : 36
Inscription : mar. 21/août/2007 17:31

Message par MorpheusDX »

Une autre technique générales, si tu veux retouner plusieurs paramètres suite à l'appel
d'une fonction, tu peux passer par une structure, genre comme cela:

Code : Tout sélectionner

Structure RESULTAT
  a.l
  b.f
  c.s
EndStructure


Declare Test(*res)

Global res.RESULTAT

Test(res) 
Debug res\a
Debug res\b
Debug res\c

End


Procedure Test(*res)
 ; ta procedure et ces calculs
 ; puis tu alimente la structure
 ; avec les données que tu 
 ; voulais
 res\a = 10
 res\b = 3.44
 res\c=  "essais"
EndProcedure
Force et sagesse...
Backup
Messages : 14526
Inscription : lun. 26/avr./2004 0:40

Message par Backup »

MorpheusDX a écrit :Une autre technique générales, si tu veux retouner plusieurs paramètres suite à l'appel
d'une fonction, tu peux passer par une structure, genre comme cela:

Code : Tout sélectionner

Global res.RESULTAT 
ben en utilisant des globales, ta meme pas besoin de structure pour ça !! :lol: :D
là ,ont parle de ressortir des valeurs locale a une procedure !!

il est evident qu'en utilisant des global, pas de probleme :)
MorpheusDX
Messages : 36
Inscription : mar. 21/août/2007 17:31

Message par MorpheusDX »

Ce n'était que pour l'exemple, cela s'emploi très bien entre fonctions ;)

Code : Tout sélectionner

Structure RESULTAT
  a.l
  b.f
  c.s
EndStructure


Declare Test(*res.RESULTAT)
Declare Test2()

Test2()

End


Procedure Test2()
  Protected res.RESULTAT
  Test(res) 
  Debug res\a
  Debug res\b
  Debug res\c
EndProcedure 

Procedure Test(*res.RESULTAT)
 ; ta procedure et ces calculs
 *res\a = 10
 *res\b = 3.44
 *res\c=  "essais"
EndProcedure
Dernière modification par MorpheusDX le mar. 28/août/2007 8:39, modifié 1 fois.
Force et sagesse...
Backup
Messages : 14526
Inscription : lun. 26/avr./2004 0:40

Message par Backup »

:D
Ollivier
Messages : 4190
Inscription : ven. 29/juin/2007 17:50
Localisation : Encore ?
Contact :

Message par Ollivier »

ça ressemble pas mal à l'exemple de Flype page 1. ça m'arrive aussi de looper les pages! :D Par contre, le transfert proc/proc c'est bien urbain de l'avoir précisé.

Cette méthode est, il me semble la plus commune pour les DLLs. Et sûrement la mieux adaptée.

@Kcc : non je n'ai pas de baguette magique!

Quand je serai grand, je commencerai à illustrer mes posts. Tu verras qu'il y a des rudiments qui ne sont pas bien complexes avec un beau dessin à côté. L'Asm sert au quelque peu que Fred a préféré éviter de nous laisser directement à portée de main. Dans ce cas-ci, c'est la pile interne.

Pour persister dans cette technique, voici un code un peu plus 'soft'. C'est un code 'prototype': il ne transfert que les données de type LONG. Si elle semble intéressante, je peux peut-être faire un source méta-macro (un source direct prend pas mal de place et je préfère laisser le choix du nombre max de paramètres) pour traiter tous les types jusqu'à x paramètres (x à préciser dans la méta-macro). Et qui englobe les structures, puisque comme on est fous, on peut duppliquer les champs de structure.

Code : Tout sélectionner

;{ Macros pour retour de LONG }
Macro ProcReturn
! Ret 
EndMacro 

Macro P1(p, a)
  p(a)
! Pop [v_#a#]   
EndMacro

Macro P2(p, a, b)
  p(a, b)
! Pop [v_#a#]   
! Pop [v_#b#]   
EndMacro

Macro P3(p, a, b, c)
  p(a, b, c)
! Pop [v_#a#]   
! Pop [v_#b#]   
! Pop [v_#c#]   
EndMacro

Macro P4(p, a, b, c, d)
  p(a, b, c, d)
! Pop [v_#a#]   
! Pop [v_#b#]   
! Pop [v_#c#]   
! Pop [v_#d#]   
EndMacro

Macro P5(p, a, b, c, d, e)
  p(a, b, c, d, e)
! Pop [v_#a#]   
! Pop [v_#b#]   
! Pop [v_#c#]   
! Pop [v_#d#] 
! Pop [v_#e#] 
EndMacro
;}


; *** PRINCIPE *** 

Declare UneProcedure(a, b, c, d, e) 

; (Pn, c'est un peu comme 'CallFunction')
P5(UneProcedure, a, b, c, d, e) ; 5 est le nombre d'arguments
 
Debug "Voici 4 départements où siègent aussi un paquet de têtus:" 
Debug a 
Debug b 
Debug c 
Debug d
Debug "Et le numéro complémentaire :" 
Debug e

Procedure UneProcedure(Finistere, Morbihan, CotesDArmor, IlesEtVilaines, QuaranteQuat) 
  Finistere = 29
  Morbihan = 35
  CotesDArmor = 22
  IlesEtVilaines = 56
  QuaranteQuat = 44
  ProcReturn ; << /!\ Attention, ici 'ProcReturn' indispensable et SANS VALEUR DE RETOUR actuellement
EndProcedure
Dernière modification par Ollivier le mar. 28/août/2007 23:34, modifié 1 fois.
MorpheusDX
Messages : 36
Inscription : mar. 21/août/2007 17:31

Message par MorpheusDX »

Ollivier a écrit :ça ressemble pas mal à l'exemple de Flype page 1. ça m'arrive aussi de looper les pages!
Tout a fait raison, j'avais zappé, merci d'avoir relevé :)
Force et sagesse...
Ollivier
Messages : 4190
Inscription : ven. 29/juin/2007 17:50
Localisation : Encore ?
Contact :

Message par Ollivier »

De toute façon, si on veut éviter trop de rajout de code, c'est cette méthode la mieux adaptée. Preuve en est, c'est ainsi qu'on s'en sort avec les fonctions de l'API.

La technique que j'emploie répond plus à l'idée que l'on a des variables locales (les paramètres d'entrée), elles sont utilisées DANS la procédure. Leur valeur est stockée dans la pile. Mais, dès qu'on sort, elles sont oubliées!!

ça ne mangerait pas de pain de pouvoir récupérer de manière conviviale ces valeurs qui subsitent immédiatement après le retour de procédure.
jerexgrz
Messages : 279
Inscription : dim. 05/juin/2005 20:27

Message par jerexgrz »

Sinon, pour les procedures pour contourner le nombre de retours (resultat), il serait possible de sortir autant de valeurs qu'ils n'y rentrent !
ex:
procedure test (X.l,Y.l,X2.l,Y2.l)
...
endprocedure

on retourne X, Y, X2 et Y2.

Sinon, lorsque l'on renvoie :
procedurereturn tableau()
il n'y a rien ! pas d'erreur, pas de valeurs, ...
Backup
Messages : 14526
Inscription : lun. 26/avr./2004 0:40

Message par Backup »

bah ! j'en viens a me demander si certains veulent voir evoluer le Purebasic !!

j'ai demandé sur le forum anglais a avoir des boucles For-next
du type

Code : Tout sélectionner


a.f=1.5
b.f=10.2
c.f=1.2

For t=a to b step c
next t
bref ce qui est une boucle normale en basic
ben on me reponds en gros que je ferai mieux d'oublier, et de me mettre au While wend, et repeat-until !! :?

sont nazes ces allemandglais.. :?
Ollivier
Messages : 4190
Inscription : ven. 29/juin/2007 17:50
Localisation : Encore ?
Contact :

Message par Ollivier »

@dobro

Changements:
>> Loop = For
>> Pour une boucle croissante, rajouter le signe < devant la variable de fin
>> Pour une boucle décroissante, rajouter le signe > devant la variable de fin

@jerexgrz

Ce que tu dis est déjà réalisé (mon premier code là-haut). Par contre, il faut récupérer le nombre de paramètres dans la procédure, et ça se corse quand tu as des protected ou des chaînes en paramètres (ça prend 8 octets dans la pile(!?!) ) dont pas d'algo gérable. La procédure est une macro d'appel (j'espère être compris pour ne pas qu'on dise que j'ai tort) qui organise un saut avec transfert de paramètres donc pas de valeurs à disposition du programme concernant ce nombre de paramètres.

Code : Tout sélectionner

;Une macro pour Dobro 
Macro Loop(var, dep, fin, pas) 

    var = dep - pas 
    While var fin - pas
    var + pas 
    
EndMacro 



Loop(i.F, 0.0, < 3.14, 0.1) 

Debug i 

Wend 
Répondre