PureBasic

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 !

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

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
Next i

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

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

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

Il y a peut-être moyen de faire plus souple.

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

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

Je sais je sais, il est casse c..... ce KCC, on lui donne le doigt il veut le bras

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.

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

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

là ,ont parle de ressortir des valeurs locale a une procedure !!

il est evident qu'en utilisant des global, pas de probleme

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

ça ressemble pas mal à l'exemple de Flype page 1. ça m'arrive aussi de looper les pages!

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

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é

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.

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, ...

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..

@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

PureBasic

plusieur return procedure (et procedure dll)