FORUM DE DISCUSSION SUR LE LANGAGE PANORAMIC

Développement d'applications avec le langage Panoramic
 
AccueilAccueil  FAQFAQ  RechercherRechercher  S'enregistrerS'enregistrer  MembresMembres  GroupesGroupes  Connexion  
Derniers sujets
» Synedit Parameters
par Yannick Aujourd'hui à 0:27

» Code à vérifier SVP (Oups ! résolu)
par Jean Claude Hier à 21:16

» Compilateur FBPano
par jean_debord Hier à 9:56

» Bienvenue à Virtualalan !
par UltraVox Hier à 9:18

» Concours de Morpions
par jjn4 Hier à 0:04

» ShortName$(F) [Cloturé]
par papydall Mer 21 Juin 2017 - 16:19

» Remplacer espace par tiret dans noms des dossiers / fichiers
par papydall Mer 21 Juin 2017 - 15:27

» Menu personalisé avec icones et menu contextuel
par Laurent (Minibug) Mer 21 Juin 2017 - 12:44

» La liste des choses à faire ...
par Jack Mar 20 Juin 2017 - 22:49

» Quoi de neuf à propos de Goric 3D ? (@Jack)
par UltraVox Mar 20 Juin 2017 - 21:06

» Nom court et anti fenetre dos
par silverman Mar 20 Juin 2017 - 18:31

» Ludothèque Panoramic
par jjn4 Mar 20 Juin 2017 - 18:09

» Proposition à la communauté
par Yannick Mar 20 Juin 2017 - 15:02

» >199
par maelilou Mar 20 Juin 2017 - 14:13

» NUMBER_FOCUS
par Yannick Lun 19 Juin 2017 - 15:25

Navigation
 Portail
 Index
 Membres
 Profil
 FAQ
 Rechercher
Rechercher
 
 

Résultats par :
 
Rechercher Recherche avancée
Juin 2017
LunMarMerJeuVenSamDim
   1234
567891011
12131415161718
19202122232425
2627282930  
CalendrierCalendrier

Partagez | 
 

 Créer mémoire tampon, application

Voir le sujet précédent Voir le sujet suivant Aller en bas 
AuteurMessage
silverman

avatar

Nombre de messages : 441
Age : 45
Localisation : Picardie
Date d'inscription : 19/03/2015

MessageSujet: Créer mémoire tampon, application   Lun 27 Avr 2015 - 1:45

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


Dernière édition par silverman le Lun 27 Avr 2015 - 14:42, édité 2 fois
Revenir en haut Aller en bas
Voir le profil de l'utilisateur
Jicehel

avatar

Nombre de messages : 5837
Age : 44
Localisation : 77500
Date d'inscription : 19/04/2011

MessageSujet: Re: Créer mémoire tampon, application   Lun 27 Avr 2015 - 2:07

Belle bibliothèque de fonctions (multi uages) et explications claires.
Revenir en haut Aller en bas
Voir le profil de l'utilisateur
Yannick

avatar

Nombre de messages : 7809
Age : 46
Localisation : Bretagne
Date d'inscription : 15/02/2010

MessageSujet: re   Lun 27 Avr 2015 - 2:47

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 )
Revenir en haut Aller en bas
Voir le profil de l'utilisateur
Jicehel

avatar

Nombre de messages : 5837
Age : 44
Localisation : 77500
Date d'inscription : 19/04/2011

MessageSujet: Re: Créer mémoire tampon, application   Lun 27 Avr 2015 - 8:57

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)
Revenir en haut Aller en bas
Voir le profil de l'utilisateur
silverman

avatar

Nombre de messages : 441
Age : 45
Localisation : Picardie
Date d'inscription : 19/03/2015

MessageSujet: Re: Créer mémoire tampon, application   Lun 27 Avr 2015 - 14:45

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é!
Revenir en haut Aller en bas
Voir le profil de l'utilisateur
Contenu sponsorisé




MessageSujet: Re: Créer mémoire tampon, application   

Revenir en haut Aller en bas
 
Créer mémoire tampon, application
Voir le sujet précédent Voir le sujet suivant Revenir en haut 
Page 1 sur 1
 Sujets similaires
-
» [Résolu] Vidéo et mémoire tampon
» Application TV pour tablette HD
» Augmenter Mémoire Tampon
» Mon PC portable perd de la mémoire
» Lecture video interrompue avec mise en tampon

Permission de ce forum:Vous ne pouvez pas répondre aux sujets dans ce forum
FORUM DE DISCUSSION SUR LE LANGAGE PANORAMIC :: PANORAMIC 32 bits :: Vos sources, vos utilitaires à partager-
Sauter vers: