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
» Pb 16 (en analyse): ON_CLOSE plante à l'exécution
par Jack Aujourd'hui à 20:00

» Pb 15 (en analyse): TIMER_ON plante à l'exécution
par Jack Aujourd'hui à 19:58

» Compilateur FBPano
par jean_debord Aujourd'hui à 8:49

» un nouveau editeur panobasic
par Jean Claude Hier à 20:05

» COMPILATEUR V 0.9 beta 7 du 10 aout 2017
par Pedro Alvarez Hier à 19:31

» KGF_dll - nouvelles versions
par Yannick Dim 13 Aoû 2017 - 17:35

» probleme d'outil
par Yannick Dim 13 Aoû 2017 - 17:32

» Carte de France des régions
par Yannick Sam 12 Aoû 2017 - 21:33

» Pb 14 (en analyse): PRINT_LOCATE plante à l'exécution
par Jack Ven 11 Aoû 2017 - 22:37

» Petit avertissement [Mots réservés]
par papydall Ven 11 Aoû 2017 - 13:45

» Distances sur plan
par JL35 Jeu 10 Aoû 2017 - 21:29

» Tracé : Triangle, Carrée, Dents de scie, Sinusoïde redressée
par papydall Jeu 10 Aoû 2017 - 14:52

» Troncature dans une image
par JL35 Mer 9 Aoû 2017 - 13:45

» A chacun son point de vue
par papydall Mar 8 Aoû 2017 - 17:20

» Problème avec les chaines de caractères
par bignono Dim 6 Aoû 2017 - 9:33

Navigation
 Portail
 Index
 Membres
 Profil
 FAQ
 Rechercher
Rechercher
 
 

Résultats par :
 
Rechercher Recherche avancée
Août 2017
LunMarMerJeuVenSamDim
 123456
78910111213
14151617181920
21222324252627
28293031   
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 : 464
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 : 5849
Age : 45
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 : 7961
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 : 5849
Age : 45
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 : 464
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: