Créer mémoire tampon, application

EDIT1: harmonisé le nom des SUBs pour rendre l'utilisation de la bibliothèque plus aisé.

Bonjour à tous,

suite à ce sujet: créer mémoire tampon(très utile pour CALL_DLLx()), voici un exemple très complet de gestion mémoire tampon pour DLL

Code:: ' Panoramic 0.9.25

' ==============================================================
' = Title : Structure pour DLL
' =
' = Author : Silverman
' =
' = Date : Avril 2015
' =
' = Version: 1.0
' ==============================================================
' Comments : Créer une mémoire tampon pour DLL. Cette mémoire
' : tampon s'appelle une structure. Dans ce programme,
' : j'appelle cette structure un "buffer"
' ==============================================================

' Cette mémoire tampon est utilisé par certaines fonctions des DLL windows.
' La mémoire créé par ce programme est une mémoire statique.
' Ce code gère des buffers au standard WINDOWS, donc 100% compatible avec les
' DLL systèmes.
'
' On peut aussi par exemple, utiliser un buffer pour passer des variables
' (locales, pourquoi pas) d'une sub, à une autre sub. Cela permet à ces sub
' de "communiquer" entre elles sans avoir à passer par plein de paramètres.

' NOTE: un buffer de x BYTE se lit de la position 0 la position 0 à x-1
' un buffer de x WORD se lit de la position 0 la position 0 à x-2
' un buffer de x DWORD se lit de la position 0 la position 0 à x-4
' un buffer de x LONG se lit de la position 0 la position 0 à x-4
' un buffer de x FLOAT se lit de la position 0 la position 0 à x-8

' Par ex., si notre buffer taille 8 BYTEs, et qu'on veut lire 4 WORD, le:
' 1ier commence à la position 0
' 2ieme commence à la position 2
' 3ieme commence à la position 4
' 4ieme commence à la position 6
' et on a bien lu 4 WORD!
'
' Bref, ne pas confondre taille et position. le mot BYTE est équivalent à OCTET.
' C'est la même chose, sauf que le premier est en anglais.

' Pour cette démo, je décide de créer un buffer devant contenir 1 BYTE, 2 FLOAT, 3 WORD
DIM taille_buff,buffer$,buffer_ptr%
   '
   taille_buff=(1*1)+(2*8)+(3*2) : ' toujours en nb de BYTE !!!
   '
   buffer$=string$(taille_buff,chr$(0))

' On récupère l'adresse du buffer:
GET_BUFFER_PTR(adr(buffer_ptr%) , adr(buffer$))

' Maintenant que l'on connait le POINTEUR(adresse) de cette STRUCTURE(buffer), c'est ici que commence la DEMO
full_space 0
picture 1
full_space 1
print_target_is 1

' Initialisation des données
DIM mon_byte,mon_float1,mon_float2,mon_word1,mon_word2,mon_word3
DIM byte_dest%,float_dest,word_dest%
DIM pos
DIM c$,i,size%

' On rempli le buffer comme on veux, du moment que la somme des tailles des types
' de données, n'est pas supérieur à "taille_buff".
mon_byte=250
mon_float1=3.1415
mon_float2=10/3
mon_word1=1000
mon_word2=2000
mon_word3=3000

print "on affiche les variables une par une:"
POS=0 :' 0 puisqu'on a encore rien écrit dans le buffer(c'est la première donnée)
WRITE_BUFFER_BYTE(buffer_ptr% , POS , mon_byte) :' on écrit dans le buffer
READ_BUFFER_BYTE(adr(byte_dest%) , buffer_ptr% , POS) :' Test: on lit le buffer et on copie le résultat dans la variable "byte_dest%"
print byte_dest% :' puis on l'affiche pour voir que tout se passe bien

POS=(1*1) :' attention, on a écrit 1 BYTE dans le buffer !!!
WRITE_BUFFER_FLOAT(buffer_ptr% , POS , mon_float1)
READ_BUFFER_FLOAT(adr(float_dest) , buffer_ptr% , POS)
print float_dest

POS=(1*1)+(1*8) :' il y a 1 BYTE et 1 FLOAT dans le buffer
WRITE_BUFFER_FLOAT(buffer_ptr% , POS , mon_float2)
READ_BUFFER_FLOAT(adr(float_dest) , buffer_ptr% , POS)
print float_dest

POS=(1*1)+(2*8) :' il y a 1 BYTE et 2 FLOAT dans le buffer
WRITE_BUFFER_WORD(buffer_ptr% , POS , mon_word1)
READ_BUFFER_WORD(adr(word_dest%) , buffer_ptr% , POS)
print word_dest%

POS=(1*1)+(2*8)+(1*2) :' il y a 1 BYTE, 1 FLOAT et 1 WORD dans le buffer
WRITE_BUFFER_WORD(buffer_ptr% , POS , mon_word2)
READ_BUFFER_WORD(adr(word_dest%) , buffer_ptr% , POS)
print word_dest%

POS=(1*1)+(2*8)+(2*2) :' il y a 1 BYTE, 1 FLOAT et 2 WORD dans le buffer
WRITE_BUFFER_WORD(buffer_ptr% , POS , mon_word3)
READ_BUFFER_WORD(adr(word_dest%) , buffer_ptr% , POS)
print word_dest%

print

' On peut retrouver la taille du buffer de cette manière
BUFFER_SIZE(adr(size%),buffer_ptr%)
print "taille du buffer = ";size%;" octets"

print

' Rappel, le buffer contient 1 BYTE, 2 FLOAT, 3 WORD
' On affiche le contenu du buffer
print "On affiche le contenu du buffer:"
DISPLAY_BUFFER(buffer_ptr% , "bffwww")

print

' Effacement du buffer
CLEAR_BUFFER(buffer_ptr%)
print "On affiche le contenu du buffer après effacement:"
DISPLAY_BUFFER(buffer_ptr% , "bffwww")

print

' Exemple de remplissage; NB: le buffer ne peut être rempli qu'avec des BYTE !!!
FILL_BUFFER(buffer_ptr% , 255)
' c$="bffwww"
c$="" : for i=0 to taille_buff-1 : c$=c$+"b" : next i :' que des BYTE
print "On affiche le contenu du buffer après remplissage avec la valeur 255:"
DISPLAY_BUFFER(buffer_ptr% , c$)

' Au besoin, on peut supprimmer le buffer, toutes les données qu'il contient
' sont supprimées
free buffer$

END
'
' ##############################################################################
' # #
' # Bibliothèque de SUBs pour gérer des mémoires tampons V1.0 #
' # #
' ##############################################################################
sub READ_BUFFER_BYTE(adr_destination%,adr_source%,buffer_position%)
' BYTE = OCTET(en français)
' adr_destination% = adresse destination
' adr_source% = adresse adr_source
' copie un BYTE, 0 < BYTE < 255
   poke adr_destination%,peek(adr_source% + buffer_position%)
end_sub

sub READ_BUFFER_WORD(adr_destination%,adr_source%,buffer_position%)
' WORD = 2 BYTEs
' adr_destination% = adresse destination
' adr_source% = adresse adr_source
' copie un WORD, 0 < WORD < 65535
   poke adr_destination%,peek(adr_source%+buffer_position%)
   poke adr_destination%+1,peek(adr_source%+1+buffer_position%)
end_sub

sub READ_BUFFER_DWORD(adr_destination%,adr_source%,buffer_position%)
' DWORD = 4 BYTEs
' adr_destination% = adresse destination
' adr_source% = adresse adr_source
' copie un DWORD, 0 < DWORD < 4294967295
   poke adr_destination%,peek(adr_source%+buffer_position%)
   poke adr_destination%+1,peek(adr_source%+1+buffer_position%)
   poke adr_destination%+2,peek(adr_source%+2+buffer_position%)
   poke adr_destination%+3,peek(adr_source%+3+buffer_position%)
end_sub

sub READ_BUFFER_LONG(adr_destination%,adr_source%,buffer_position%)
' LONG = 4 BYTEs
' adr_destination% = adresse destination
' adr_source% = adresse adr_source
' copie un LONG, –2147483648 < LONG < 2147483647
   poke adr_destination%,peek(adr_source%+buffer_position%)
   poke adr_destination%+1,peek(adr_source%+1+buffer_position%)
   poke adr_destination%+2,peek(adr_source%+2+buffer_position%)
   poke adr_destination%+3,peek(adr_source%+3+buffer_position%)
end_sub

sub READ_BUFFER_INT(adr_destination%,adr_source%,buffer_position%)
' INT = 4 BYTEs
' adr_destination% = adresse destination
' adr_source% = adresse adr_source
' copie un INTeger, –2147483648 < INT < 2147483647
   poke adr_destination%,peek(adr_source%+buffer_position%)
   poke adr_destination%+1,peek(adr_source%+1+buffer_position%)
   poke adr_destination%+2,peek(adr_source%+2+buffer_position%)
   poke adr_destination%+3,peek(adr_source%+3+buffer_position%)
end_sub

sub READ_BUFFER_FLOAT(adr_destination%,adr_source%,buffer_position%)
' FLOAT = 8 BYTEs
' adr_destination% = adresse destination
' adr_source% = adresse adr_source
' copie un FLOAT, -1,7976931348623157×10^308 < FLOAT < 1,7976931348623157×10^308
   poke adr_destination%,peek(adr_source%+buffer_position%)
   poke adr_destination%+1,peek(adr_source%+1+buffer_position%)
   poke adr_destination%+2,peek(adr_source%+2+buffer_position%)
   poke adr_destination%+3,peek(adr_source%+3+buffer_position%)
   poke adr_destination%+4,peek(adr_source%+4+buffer_position%)
   poke adr_destination%+5,peek(adr_source%+5+buffer_position%)
   poke adr_destination%+6,peek(adr_source%+6+buffer_position%)
   poke adr_destination%+7,peek(adr_source%+7+buffer_position%)
end_sub

'###############################################################################
sub WRITE_BUFFER_BYTE(adr_destination%,buffer_position%,byte%)
' BYTE = OCTET(en français)
' adr_destination% = adresse destination
' byte% = 0 < BYTE < 255
   poke adr_destination%+buffer_position%,peek(adr(byte%))
end_sub

sub WRITE_BUFFER_WORD(adr_destination%,buffer_position%,word%)
' WORD = 2 BYTEs
' adr_destination% = adresse destination
' word% = 0 < WORD < 65535
   poke adr_destination%+buffer_position%,peek(adr(word%))
   poke adr_destination%+1+buffer_position%,peek(adr(word%)+1)
end_sub

sub WRITE_BUFFER_DWORD(adr_destination%,buffer_position%,dword%)
' DWORD = 4 BYTEs
' adr_destination% = adresse destination
' dword% = 0 < DWORD < 4294967295
   poke adr_destination%+buffer_position%,peek(adr(dword%))
   poke adr_destination%+1+buffer_position%,peek(adr(dword%)+1)
   poke adr_destination%+2+buffer_position%,peek(adr(dword%)+2)
   poke adr_destination%+3+buffer_position%,peek(adr(dword%)+3)
end_sub

sub WRITE_BUFFER_LONG(adr_destination%,buffer_position%,long%)
' LONG = 4 BYTEs
' adr_destination% = adresse destination
' long% = –2147483648 < LONG < 2147483647
   poke adr_destination%+buffer_position%,peek(adr(long%))
   poke adr_destination%+1+buffer_position%,peek(adr(long%)+1)
   poke adr_destination%+2+buffer_position%,peek(adr(long%)+2)
   poke adr_destination%+3+buffer_position%,peek(adr(long%)+3)
end_sub

sub WRITE_BUFFER_INT(adr_destination%,buffer_position%,long%)
' INT = 4 BYTEs
' adr_destination% = adresse destination
' int% = –2147483648 < INT < 2147483647
   poke adr_destination%+buffer_position%,peek(adr(long%))
   poke adr_destination%+1+buffer_position%,peek(adr(long%)+1)
   poke adr_destination%+2+buffer_position%,peek(adr(long%)+2)
   poke adr_destination%+3+buffer_position%,peek(adr(long%)+3)
end_sub

sub WRITE_BUFFER_FLOAT(adr_destination%,buffer_position%,float)
' FLOAT = 8 BYTEs
' adr_destination% = adresse destination
' float = -1,7976931348623157×10^308 < FLOAT < 1,7976931348623157×10^308
   poke adr_destination%+buffer_position%,peek(adr(float))
   poke adr_destination%+1+buffer_position%,peek(adr(float)+1)
   poke adr_destination%+2+buffer_position%,peek(adr(float)+2)
   poke adr_destination%+3+buffer_position%,peek(adr(float)+3)
   poke adr_destination%+4+buffer_position%,peek(adr(float)+4)
   poke adr_destination%+5+buffer_position%,peek(adr(float)+5)
   poke adr_destination%+6+buffer_position%,peek(adr(float)+6)
   poke adr_destination%+7+buffer_position%,peek(adr(float)+7)
end_sub

'###############################################################################
sub BUFFER_SIZE(adr_destination%,buffer_ptr%)
' retouve la taille du buffer
   poke adr_destination%,peek(buffer_ptr%-4)
   poke adr_destination%+1,peek(buffer_ptr%-3)
   poke adr_destination%+2,peek(buffer_ptr%-2)
   poke adr_destination%+3,peek(buffer_ptr%-1)
end_sub

sub FILL_BUFFER(buffer_ptr%,value%)
' uniquement des BYTEs
dim_local size%,i
   value%=bin_and(value%,255)
   BUFFER_SIZE(adr(size%),buffer_ptr%)
   size%=size%-1
   for i=0 to size%
   poke buffer_ptr%+i,value%
   next i
end_sub

sub CLEAR_BUFFER(buffer_ptr%)
' effacer un buffer revient à le remplir de 0
   FILL_BUFFER(buffer_ptr%,0)
end_sub

sub DISPLAY_BUFFER(buffer_ptr%,c$)
' affiche le contenu du buffer
dim_local buffer_position%,i,value,tmp%,tmp,j,k
   buffer_position%=0
   c$=upper$(c$)
   for i=1 to len(c$)
   value=asc(mid$(c$,i,1))
   select value
   case 66
   tmp%=0
   READ_BUFFER_BYTE(adr(tmp%),buffer_ptr%,buffer_position%)
   buffer_position%=buffer_position%+1
   print tmp%

   case 68
   tmp%=0
   READ_BUFFER_DWORD(adr(tmp%),buffer_ptr%,buffer_position%)
   buffer_position%=buffer_position%+4
   print tmp%

   case 70
   tmp=0
   READ_BUFFER_FLOAT(adr(tmp),buffer_ptr%,buffer_position%)
   buffer_position%=buffer_position%+8
   k=0 : for j=0 to 7 : k=k+peek(adr(tmp)+j) : next j
   if k=2040
   print "NaN"
   else
   print tmp
   end_if

   case 73
   tmp%=0
   READ_BUFFER_INT(adr(tmp%),buffer_ptr%,buffer_position%)
   buffer_position%=buffer_position%+4
   print tmp%

   case 76
   tmp%=0
   READ_BUFFER_LONG(adr(tmp%),buffer_ptr%,buffer_position%)
   buffer_position%=buffer_position%+4
   print tmp%

   case 87
   tmp%=0
   READ_BUFFER_WORD(adr(tmp%),buffer_ptr%,buffer_position%)
   buffer_position%=buffer_position%+2
   print tmp%
   end_select
   next i
end_sub

sub GET_BUFFER_PTR(adr_destination%,adr_source%)
' retrouve l'adresse du pointeur
   poke adr_destination%,peek(adr_source%)
   poke adr_destination%+1,peek(adr_source%+1)
   poke adr_destination%+2,peek(adr_source%+2)
   poke adr_destination%+3,peek(adr_source%+3)
end_sub

sub DEBUG(adr%, tai%)
dim_local i,k
   print
   for i=0 to tai%-1
   k=peek(adr%+i)
   if k<16
   print "0";hex$(k);" ";
   else
   print hex$(k);" ";
   end_if
   next i
   print
   for i=0 to tai%-1
   k=peek(adr%+i)
   print chr$(k);" ";
   next i
   print
end_sub

Les SUBs en action avec l'exemple posté par Nardo26 ici:

Code:: ' code original : Nardo26
' ici : http://panoramic.1fr1.net/t4136-appel-d-une-fct-dll-avec-pointeur-sur-une-structure#48513
'
'
' modifié par Silverman, pour montrer comment gérer une mémoire tampon(structure) sans DLL

' FLASHWINFO structure:
'
' typedef struct {
' UINT cbSize; (32bits)The size of the structure, in bytes.
' HWND hwnd; (un HWND est un 32bits NON SIGNE, donc logiquement un DWORD) A handle to the window to be flashed. The window can be either opened or minimized.
' DWORD dwFlags; (32bits) The flash status. This parameter can be one or more of the following values.
' UINT uCount; The number of times to flash the window.
' DWORD dwTimeout; The rate at which the window is to be flashed, in milliseconds.
' }
'

   ' Exemple d'appel de fonction avec passage d'un pointeur sur une structure
   ' Clignotement de la fenêtre de l’éditeur Panoramic

   DIM ret% : ' retour de fct DLL
   DIM cbSize%,hwnd%,dwFlags%,uCount%,dwTimeout% : ' Les membres de la structure FLASHWINFO
   DIM FLASHW_CAPTION:FLASHW_CAPTION=1 : ' Type de clignotement (cf doc)
   DIM FLASHWINFO$,pFLASHWINFO% : ' La chaine qui va servir de buffer ainsi que son pointeur

   ' -------- init de la structure ------------------
   cbSize% = 5 * 4 : ' Taille de la structure -> 5 membres de 4 octets (variable : 32/64 bits)
   hwnd% = HANDLE_FORM("PANORAMIC EDITOR") : ' le handle de la fenêtre que l'on veut faire clignoter
   dwFlags% = FLASHW_CAPTION : ' Le type de clignotement (cf. doc)
   uCount% = 20 : ' le nb de fois que la fenêtre doit clignoter
   dwTimeout% = 150 : ' La rapidité du clignotement (dans l'exemple 150ms)

   FLASHWINFO$ = string$(cbSize%,chr$(0)) : ' On déclare une chaine de caractères de même longueur que la structure

   ' On recupere l'adresse de base du buffer
   ' Pour rappel: la valeur retournée par ADR(chaine$) est un pointeur (adresse) sur la zone qui contient les caractères
   GET_BUFFER_PTR(ADR(pFLASHWINFO%) , ADR(FLASHWINFO$)) : ' on transfere le contenu de ADR(buffer) dans pPFLASHWINFO%

   ' Puis on met à jour la structure :
   WRITE_BUFFER_INT( pFLASHWINFO% , 0 , cbSize% )
   WRITE_BUFFER_DWORD( pFLASHWINFO% , 4 , hwnd% )
   WRITE_BUFFER_DWORD( pFLASHWINFO% , 8 , dwFlags% )
   WRITE_BUFFER_INT( pFLASHWINFO% , 12 , uCount% )
   WRITE_BUFFER_DWORD( pFLASHWINFO% , 16 , dwTimeout% )

   ' On lance le clignotement de la fenêtre :
   dll_on "user32.dll"
   ret% = DLL_CALL1("FlashWindowEx",pFLASHWINFO%)
   DLL_OFF

   ' C'est tout !!

   ' Affiche le contenu de la structure
   print "Contenu du buffer :"
   DISPLAY_BUFFER(pFLASHWINFO%,"iddid")

END
'
' ##############################################################################
' # #
' # Bibliothèque de SUBs pour gérer des mémoires tampons V1.0 #
' # #
' ##############################################################################
sub READ_BUFFER_BYTE(adr_destination%,adr_source%,buffer_position%)
' BYTE = OCTET(en français)
' adr_destination% = adresse destination
' adr_source% = adresse adr_source
' copie un BYTE, 0 < BYTE < 255
   poke adr_destination%,peek(adr_source% + buffer_position%)
end_sub

sub READ_BUFFER_WORD(adr_destination%,adr_source%,buffer_position%)
' WORD = 2 BYTEs
' adr_destination% = adresse destination
' adr_source% = adresse adr_source
' copie un WORD, 0 < WORD < 65535
   poke adr_destination%,peek(adr_source%+buffer_position%)
   poke adr_destination%+1,peek(adr_source%+1+buffer_position%)
end_sub

sub READ_BUFFER_DWORD(adr_destination%,adr_source%,buffer_position%)
' DWORD = 4 BYTEs
' adr_destination% = adresse destination
' adr_source% = adresse adr_source
' copie un DWORD, 0 < DWORD < 4294967295
   poke adr_destination%,peek(adr_source%+buffer_position%)
   poke adr_destination%+1,peek(adr_source%+1+buffer_position%)
   poke adr_destination%+2,peek(adr_source%+2+buffer_position%)
   poke adr_destination%+3,peek(adr_source%+3+buffer_position%)
end_sub

sub READ_BUFFER_LONG(adr_destination%,adr_source%,buffer_position%)
' LONG = 4 BYTEs
' adr_destination% = adresse destination
' adr_source% = adresse adr_source
' copie un LONG, –2147483648 < LONG < 2147483647
   poke adr_destination%,peek(adr_source%+buffer_position%)
   poke adr_destination%+1,peek(adr_source%+1+buffer_position%)
   poke adr_destination%+2,peek(adr_source%+2+buffer_position%)
   poke adr_destination%+3,peek(adr_source%+3+buffer_position%)
end_sub

sub READ_BUFFER_INT(adr_destination%,adr_source%,buffer_position%)
' INT = 4 BYTEs
' adr_destination% = adresse destination
' adr_source% = adresse adr_source
' copie un INTeger, –2147483648 < INT < 2147483647
   poke adr_destination%,peek(adr_source%+buffer_position%)
   poke adr_destination%+1,peek(adr_source%+1+buffer_position%)
   poke adr_destination%+2,peek(adr_source%+2+buffer_position%)
   poke adr_destination%+3,peek(adr_source%+3+buffer_position%)
end_sub

sub READ_BUFFER_FLOAT(adr_destination%,adr_source%,buffer_position%)
' FLOAT = 8 BYTEs
' adr_destination% = adresse destination
' adr_source% = adresse adr_source
' copie un FLOAT, -1,7976931348623157×10^308 < FLOAT < 1,7976931348623157×10^308
   poke adr_destination%,peek(adr_source%+buffer_position%)
   poke adr_destination%+1,peek(adr_source%+1+buffer_position%)
   poke adr_destination%+2,peek(adr_source%+2+buffer_position%)
   poke adr_destination%+3,peek(adr_source%+3+buffer_position%)
   poke adr_destination%+4,peek(adr_source%+4+buffer_position%)
   poke adr_destination%+5,peek(adr_source%+5+buffer_position%)
   poke adr_destination%+6,peek(adr_source%+6+buffer_position%)
   poke adr_destination%+7,peek(adr_source%+7+buffer_position%)
end_sub

'###############################################################################
sub WRITE_BUFFER_BYTE(adr_destination%,buffer_position%,byte%)
' BYTE = OCTET(en français)
' adr_destination% = adresse destination
' byte% = 0 < BYTE < 255
   poke adr_destination%+buffer_position%,peek(adr(byte%))
end_sub

sub WRITE_BUFFER_WORD(adr_destination%,buffer_position%,word%)
' WORD = 2 BYTEs
' adr_destination% = adresse destination
' word% = 0 < WORD < 65535
   poke adr_destination%+buffer_position%,peek(adr(word%))
   poke adr_destination%+1+buffer_position%,peek(adr(word%)+1)
end_sub

sub WRITE_BUFFER_DWORD(adr_destination%,buffer_position%,dword%)
' DWORD = 4 BYTEs
' adr_destination% = adresse destination
' dword% = 0 < DWORD < 4294967295
   poke adr_destination%+buffer_position%,peek(adr(dword%))
   poke adr_destination%+1+buffer_position%,peek(adr(dword%)+1)
   poke adr_destination%+2+buffer_position%,peek(adr(dword%)+2)
   poke adr_destination%+3+buffer_position%,peek(adr(dword%)+3)
end_sub

sub WRITE_BUFFER_LONG(adr_destination%,buffer_position%,long%)
' LONG = 4 BYTEs
' adr_destination% = adresse destination
' long% = –2147483648 < LONG < 2147483647
   poke adr_destination%+buffer_position%,peek(adr(long%))
   poke adr_destination%+1+buffer_position%,peek(adr(long%)+1)
   poke adr_destination%+2+buffer_position%,peek(adr(long%)+2)
   poke adr_destination%+3+buffer_position%,peek(adr(long%)+3)
end_sub

sub WRITE_BUFFER_INT(adr_destination%,buffer_position%,long%)
' INT = 4 BYTEs
' adr_destination% = adresse destination
' int% = –2147483648 < INT < 2147483647
   poke adr_destination%+buffer_position%,peek(adr(long%))
   poke adr_destination%+1+buffer_position%,peek(adr(long%)+1)
   poke adr_destination%+2+buffer_position%,peek(adr(long%)+2)
   poke adr_destination%+3+buffer_position%,peek(adr(long%)+3)
end_sub

sub WRITE_BUFFER_FLOAT(adr_destination%,buffer_position%,float)
' FLOAT = 8 BYTEs
' adr_destination% = adresse destination
' float = -1,7976931348623157×10^308 < FLOAT < 1,7976931348623157×10^308
   poke adr_destination%+buffer_position%,peek(adr(float))
   poke adr_destination%+1+buffer_position%,peek(adr(float)+1)
   poke adr_destination%+2+buffer_position%,peek(adr(float)+2)
   poke adr_destination%+3+buffer_position%,peek(adr(float)+3)
   poke adr_destination%+4+buffer_position%,peek(adr(float)+4)
   poke adr_destination%+5+buffer_position%,peek(adr(float)+5)
   poke adr_destination%+6+buffer_position%,peek(adr(float)+6)
   poke adr_destination%+7+buffer_position%,peek(adr(float)+7)
end_sub

'###############################################################################
sub BUFFER_SIZE(adr_destination%,buffer_ptr%)
' retouve la taille du buffer
   poke adr_destination%,peek(buffer_ptr%-4)
   poke adr_destination%+1,peek(buffer_ptr%-3)
   poke adr_destination%+2,peek(buffer_ptr%-2)
   poke adr_destination%+3,peek(buffer_ptr%-1)
end_sub

sub FILL_BUFFER(buffer_ptr%,value%)
' uniquement des BYTEs
dim_local size%,i
   value%=bin_and(value%,255)
   BUFFER_SIZE(adr(size%),buffer_ptr%)
   size%=size%-1
   for i=0 to size%
   poke buffer_ptr%+i,value%
   next i
end_sub

sub CLEAR_BUFFER(buffer_ptr%)
' effacer un buffer revient à le remplir de 0
   FILL_BUFFER(buffer_ptr%,0)
end_sub

sub DISPLAY_BUFFER(buffer_ptr%,c$)
' affiche le contenu du buffer
dim_local buffer_position%,i,value,tmp%,tmp,j,k
   buffer_position%=0
   c$=upper$(c$)
   for i=1 to len(c$)
   value=asc(mid$(c$,i,1))
   select value
   case 66
   tmp%=0
   READ_BUFFER_BYTE(adr(tmp%),buffer_ptr%,buffer_position%)
   buffer_position%=buffer_position%+1
   print tmp%

   case 68
   tmp%=0
   READ_BUFFER_DWORD(adr(tmp%),buffer_ptr%,buffer_position%)
   buffer_position%=buffer_position%+4
   print tmp%

   case 70
   tmp=0
   READ_BUFFER_FLOAT(adr(tmp),buffer_ptr%,buffer_position%)
   buffer_position%=buffer_position%+8
   k=0 : for j=0 to 7 : k=k+peek(adr(tmp)+j) : next j
   if k=2040
   print "NaN"
   else
   print tmp
   end_if

   case 73
   tmp%=0
   READ_BUFFER_INT(adr(tmp%),buffer_ptr%,buffer_position%)
   buffer_position%=buffer_position%+4
   print tmp%

   case 76
   tmp%=0
   READ_BUFFER_LONG(adr(tmp%),buffer_ptr%,buffer_position%)
   buffer_position%=buffer_position%+4
   print tmp%

   case 87
   tmp%=0
   READ_BUFFER_WORD(adr(tmp%),buffer_ptr%,buffer_position%)
   buffer_position%=buffer_position%+2
   print tmp%
   end_select
   next i
end_sub

sub GET_BUFFER_PTR(adr_destination%,adr_source%)
' retrouve l'adresse du pointeur
   poke adr_destination%,peek(adr_source%)
   poke adr_destination%+1,peek(adr_source%+1)
   poke adr_destination%+2,peek(adr_source%+2)
   poke adr_destination%+3,peek(adr_source%+3)
end_sub

sub DEBUG(adr%, tai%)
dim_local i,k
   print
   for i=0 to tai%-1
   k=peek(adr%+i)
   if k<16
   print "0";hex$(k);" ";
   else
   print hex$(k);" ";
   end_if
   next i
   print
   for i=0 to tai%-1
   k=peek(adr%+i)
   print chr$(k);" ";
   next i
   print
end_sub

NB: on initialise un buffer comme ceci:

Citation :: buffer$=string$(taille_buff,chr$(0))

cette façon là:

Citation :: buffer$=string$(taille_buff," ")

est spécifique à KFG.dll

Belle bibliothèque de fonctions (multi uages) et explications claires.

Le sujet est certes pour un public averti mais
tu pourrais nous faire un petit article pour le mag avec çà.

Cela montrerait à des programmeurs intéressés par le langage
l' étendue de ses possibilités...

( je sais...je fais du racolage...bon...je sors... Laughing

)

En même temps tu n'as pas tord Ygeronimi. Pleins de bonnes choses ont été dites sur l'usage de DLL et des xemples donnés. Ce serait bien de les capitaliser dans un bon article (c'est quand même plus simple de rechercher les sujets dans le mag et en plus les infos sont remises en ordre dans un article)

mise à jour de la bibliotèque:
-harmonisation des noms des SUBs pour rendre leur utilisation plus aisé(voir l'exemple modifié de Nardo26)

1 ier post édité!

» Astuce : créer mémoire tampon(très utile pour CALL_DLLx())
» Créer une application *.exe
» pour memoire
» J'ai la mémoire qui flanche...
» Ma pauvre mémoire