Pic et Poc, les joyeux drilles

Sujet: Pic et Poc, les joyeux drilles Jeu 11 Oct 2012 - 14:35

Je suis en train de jeter un coup d'oeil sur Peek et Poke (ça me rappelle le bon vieux temps farao

)
pour voir comment les variables sont stockées en mémoire, avec ça:

Code:: DIM v%, i%, j%, k%, a$, ad
v%=2500
PRINT "Entier v%= " + STR$(v%)
i% = adr(v%): Dump(i%, 16)
PRINT "========================="
a$ = "A1B2C3"
PRINT "Chaîne a$= " + a$
i% = ADR(a$): Dump(i%, 16)
ad = 0
FOR j% = 3 TO 0 STEP -1
ad = 256*ad + peek(i%+j%)
NEXT j%
Dump(ad, 16)
END

SUB Dump(adr%, lg%)
DIM_LOCAL hd$, cd$, kd%, vd%
hd$ = STR$(adr%) + ": ": cd$ = " "
FOR kd% = 0 TO lg%-1
vd% = PEEK(adr%+kd%)
IF vd%>31
cd$ = cd$ + CHR$(vd%)
ELSE
cd$ = cd$ + "."
END_IF
hd$ = hd$ + RIGHT$("0"+HEX$(vd%),2) + " "
NEXT kd%
PRINT hd$ + cd$
END_SUB

on obtient ça:

-> les valeurs entières sont stockées directement dans les octets à l'adresse indiquée par adr(v%), les poids faibles en tête.
-> ADR(chaîne$) pointe sur une adresse (poids faibles en tête, toujours) qui renvoie à la chaîne elle-même. Ce que je n'ai pas encore trouvé c'est où est stockée la longueur de la chaîne, ou alors c'est le premier 0 rencontré, mais ça m'étonne...?
Non, c'est pas ça, parce qu'une chaîne peut parfaitement contenir un 0 (j'ai vérifié), alors la longueur doit être stockée autre part.
Mais où ?

Sujet: Re: Pic et Poc, les joyeux drilles Jeu 11 Oct 2012 - 16:49

@JL35 : la réponse...

Code:: DIM v%, i%, j%, k%, a$,b$,c$, ad
DIM Toto$(10)
DIM Struct_str%, Struct_cpt%, Struct_long%
HEIGHT 0,SCREEN_Y
PICTURE 1:WIDTH 1,WIDTH(0)
HEIGHT 1,HEIGHT(0)
PRINT_TARGET_IS 1
2D_TARGET_IS 1
v%=2500
PRINT "Entier v%= " + STR$(v%)
i% = adr(v%): Dump(i%, 16)
PRINT "========================="
a$ = "TOTO"
PRINT "Chaîne a$= '" + a$+"' ADR(a$)="+HEX$(ADR(a$))
i% = ADR(a$)
PRINT
DUMP(i%,16,1):PRINT Dump_return$
HEX4(ADR(a$)):Struct_str%=HEX4_return%
PRINT "A cette adresse j'ai un pointeur sur le champ d'une structure : "+HEX$(Struct_Str%)

PRINT
Struct_cpt% = Struct_str%-8
Struct_long% = Struct_str%-4

HEX4(Struct_cpt%) : PRINT HEX$(Struct_cpt%)+" : Compteur sur (sur 4 octets) = "+STR$(HEX4_return%)
HEX4(Struct_long%): PRINT HEX$(Struct_long%)+" : Longueur (sur 4 octets) = "+STR$(HEX4_return%)
DUMP(Struct_str%,HEX4_return%,1)
PRINT HEX$(Struct_str%) +" : Chaine de caractères "
PRINT
PRINT DUMP_return$
PRINT
PRINT "b$=a$" : b$=a$
HEX4(Struct_cpt%) : PRINT HEX$(Struct_cpt%)+" : Compteur sur (sur 4 octets) = "+STR$(HEX4_return%)
HEX4(Struct_long%): PRINT HEX$(Struct_long%)+" : Longueur (sur 4 octets) = "+STR$(HEX4_return%)
PRINT
FOR i%=1 TO 5 : Toto$(i%)=a$: NEXT i%
PRINT "Toto(1 à 5)=a$"
HEX4(Struct_cpt%) : PRINT HEX$(Struct_cpt%)+" : Compteur sur (sur 4 octets) = "+STR$(HEX4_return%)
HEX4(Struct_long%): PRINT HEX$(Struct_long%)+" : Longueur (sur 4 octets) = "+STR$(HEX4_return%)
PRINT
PRINT "a$=a$+' machin'"
a$=a$+" machin"
HEX4(Struct_cpt%) : PRINT HEX$(Struct_cpt%)+" : Compteur sur (sur 4 octets) = "+STR$(HEX4_return%)
HEX4(Struct_long%): PRINT HEX$(Struct_long%)+" : Longueur (sur 4 octets) = "+STR$(HEX4_return%)
PRINT "L'adresse de a$ ne pointe plus sur cette structure !"
PRINT "C'est normal, le compteur s'est décrementé: on retrouve b$ et les 5 valeurs de Toto$()"
PRINT
PRINT "Maintenant a$ est définie comme ceci:"
PRINT "Chaîne a$= '" + a$+"' ADR(a$)="+HEX$(ADR(a$)) + " <-- Ici cela ne bouge pas"
i% = ADR(a$)
PRINT
DUMP(i%,16,1):PRINT Dump_return$
HEX4(ADR(a$)):Struct_str%=HEX4_return%
PRINT "A cette adresse j'ai le pointeur d'une autre structure : "+HEX$(Struct_Str%)+" <-- la structure changée!"
Struct_cpt% = Struct_str%-8
Struct_long% = Struct_str%-4

HEX4(Struct_cpt%) : PRINT HEX$(Struct_cpt%)+" : Compteur sur (sur 4 octets) = "+STR$(HEX4_return%)
HEX4(Struct_long%): PRINT HEX$(Struct_long%)+" : Longueur (sur 4 octets) = "+STR$(HEX4_return%)
DUMP(Struct_str%,HEX4_return%,1)
PRINT HEX$(Struct_str%) +" : Chaine de caractères "
PRINT
PRINT DUMP_return$
PRINT

END

SUB HEX4(adr%)
IF VARIABLE("HEX4_return%")=0 THEN DIM HEX4_return%
DIM_LOCAL Value%,i%,a$,Value$
Value% = 0
FOR i%=0 TO 3
a$=HEX$(PEEK(adr%+i%)):IF LEN(a$)<2 THEN a$="0"+a$
Value$ = a$ + Value$
NEXT i%
HEX4_return% = HEX(Value$)
END_SUB

SUB Dump(adr%, lg%,Asc%)
IF VARIABLE("Dump_return$")=0 THEN DIM Dump_return$
DIM_LOCAL cd$, kd%, vd%
Dump_return$= HEX$(adr%) + ": ": cd$ = " "
FOR kd% = 0 TO lg%-1
vd% = PEEK(adr%+kd%)
IF vd%>31
cd$ = cd$ + CHR$(vd%)
ELSE
cd$ = cd$ + "."
END_IF
Dump_return$= Dump_return$ + RIGHT$("0"+HEX$(vd%),2) + " "
NEXT kd%
IF Asc%=1 THEN Dump_return$=Dump_return$+cd$
END_SUB

Sujet: Re: Pic et Poc, les joyeux drilles Jeu 11 Oct 2012 - 17:00

Merci Nardo ! pour cette explication lumineuse et bien documentée... j'étudie tout ça avant de le garder sous le coude.
Après, il n'y a plus qu'à trouver des applications ! mais même sans ça, c'est toujours bon à savoir.

J'avais bien envisagé que la taille était avant la chaîne elle-même (cible du pointeur), mais je n'avais pas reculé assez loin...
N'empêche que c'est plus compliqué que ce que je pensais, avec cette histoire de compteur !
Mais avec la longueur et l'adresse on doit pouvoir faire ce qu'on veut. ( enfin, je ne sais pas trop quoi finalement Very Happy

)

Sujet: Re: Pic et Poc, les joyeux drilles Jeu 11 Oct 2012 - 17:59

Un petit exemple de POKE:

Code:: DIM a$,b$
DIM struct_str
a$="'"+STRING$(20,"#")+"'"
b$=a$
HEX4(ADR(a$)) : ChangeAllStr(HEX4_return%,"Essai")

print a$
print b$

END
'
' Modification du contenu de la structure
SUB ChangeAllStr(Ad%,c$)
DIM_LOCAL i%
FOR i%=1 TO LEN(c$)
POKE Ad%+i%-1,ASC(MID$(c$,i%,1))
NEXT i%
END_SUB
'
' Recupère la valeur codée sur 4 octets à l'adresse adr%
'
SUB HEX4(adr%)
IF VARIABLE("HEX4_return%")=0 THEN DIM HEX4_return%
DIM_LOCAL Value%,i%,a$,Value$
Value% = 0
FOR i%=0 TO 3
a$=HEX$(PEEK(adr%+i%)):IF LEN(a$)<2 THEN a$="0"+a$
Value$ = a$ + Value$
NEXT i%
HEX4_return% = HEX(Value$)
END_SUB

Sujet: Re: Pic et Poc, les joyeux drilles Jeu 11 Oct 2012 - 18:14

Ce qui est spectaculaire, c'est qu'en modifiant a$ ça modifie également b$... évidemment ça pointe au même endroit.

Sujet: Re: Pic et Poc, les joyeux drilles Jeu 11 Oct 2012 - 18:17

Tout à fait ! mais cela reste quand même assez limité sur le champs application... Wink

Un truc peut être plus interessant :

Une procédure SWAP pour les entiers

(J'ai renommé HEX4 pour être plus cohérent avec la syntaxe des anciens basic...)

Code:: DIM a%:a%=12345
DIM b%:b%=67890
PRINT "a=";a%;" b=";b%
SWAP(adr(a%),adr(b%))
PRINT "a=";a%;" b=";b%

END

SUB SWAP(i%,j%)
DIM_LOCAL v1
LPEEK(i%):v1=LPEEK_return% : LPEEK(j%)
LPOKE(i%,LPEEK_return%) : LPOKE(j%,v1)
END_SUB

SUB LPOKE(Ad%,v%)
DIM_LOCAL i%,j%
FOR i%=0 TO 3
j%=BIN_AND(v%,255)
POKE Ad%+i%,j% : v%=INT(v%/256)
NEXT i%
END_SUB

SUB LPEEK(adr%)
IF VARIABLE("LPEEK_return%")=0 THEN DIM LPEEK_return%
DIM_LOCAL Value%,i%,a$,Value$
Value% = 0
FOR i%=0 TO 3
a$=HEX$(PEEK(adr%+i%)):IF LEN(a$)<2 THEN a$="0"+a$
Value$ = a$ + Value$
NEXT i%
LPEEK_return% = HEX(Value$)
END_SUB

Sujet: Re: Pic et Poc, les joyeux drilles Jeu 11 Oct 2012 - 18:19

Exact, c'est un moyen de simuler le swap qui manque en panoramic. Tu me diras, ça irait plus vite avec une variable intermédiaire...

Sujet: Re: Pic et Poc, les joyeux drilles Jeu 11 Oct 2012 - 18:26

Oui tu as raison mais une fois la procédure écrite, pourquoi ne pas l'utiliser ?
Tout le monde connait SWAP et si tu dois en faire à plusieurs endroits dans ton code, c'est quand même plus sympa de taper SAWP(a,b)
que de faire comme on faisait jusqu’à maintenant avec une variable intermédiaire...

on y gagne un peu en lisibilité... (mouais.. l'argument est un peu tiré par les cheveux... )

Sujet: Re: Pic et Poc, les joyeux drilles Jeu 11 Oct 2012 - 19:22

Et si vous essayiez de trouver comment sont stockés des tableaux d'entiers, pour commencer ? Là, cela ouvrirait un champ d'application énorme pour pouvoir passer un tableau d'entiers à une DLL. Pour le moment, je n'ai pas franchement le temps pour cela - je me plonge dans les évènements de l'objet DTP.

Sujet: Re: Pic et Poc, les joyeux drilles Jeu 11 Oct 2012 - 21:06

Ce n'était que le début, la suite au prochain numéro !

Malheureusement Klaus, à première vue il semble que la fonction ADR() ne marche pas pour les tableaux...
Si je fais:
DIM tb%(10)
PRINT ADR(tb%(0))
j'obtiens toujours 0, même avec des valeurs dans le tableau.

D'ailleurs, autant pour moi, c'est bien précisé dans la doc:
La fonction ADR(V) retourne l'adresse de la variable V.
La variable doit être une variable simple (pas un élément de tableau),
entière, réelle ou chaîne de caractères.

Dans ces conditions, je ne vois pas bien comment on peut trouver l'emplacement en mémoire...

Sujet: Re: Pic et Poc, les joyeux drilles Jeu 11 Oct 2012 - 21:39

j'avais bien compris cela. Ceci dit, est-ce qu'il y un moyen, connaissant l'adresse de deux variables entières simples encadrant un tableau, de dériver l'adresse des données du tableau de l'adresse des données des deux variables ? Par exemple:

Code:: dim x%,a%(10),y%,z%

J'ai constaté que pour

Code:: dim x%,y%,z%

etc, l'écart entre les adresses est une constante. Cela pointe à l'évidence dans quelque chose qui ressemble à une table de symboles, contenant toutes les infos pour Panoramic. Dans le cas des entiers, la valeur est stockée directement dedans. Je pense que dans le cas d'un flottant également. C'est plus complexe dans le cas d'un tableau ou d'une chaîne de caractères, car les données ont par nature une longueur variable ce qui est incompatible avec la taille fixe des cellules d'une table de symboles. On doit trouver un pointeur ou une adresse à la place de la valeur, ou dans une autre cellule de la case correspondante de la table de symbole, un endroit qui ne serait pas utilisé dans le cas des entiers.
De plus, pour en revenir au premier fragment de code, adr(x%) donne l'adresse de la valeur de la variable x%, mais ce n'est pas le début de la case de la table de symboles dédiée à x%. En dumpant toutes les cellules de adr(x%) jusqu'à adr(z%), on peut entrevoir la structure des cellules de la table. Elles doivent toutes être similaires, sauf celle pour a%(10) dans laquelle on doit trouver la valeur 10 pour le nombre de cellules (ou peut-être 11...). Et on peut aller plus loin: au lieu de y%, on place y et on recommence de dump, puis on met y$ à la place et on recommence. Pourquoi ? cela permet de voir le codage du type de variable (entier, flottant ou string). Et l'emplacement de cette informatioin est certainement le début de la cellule dédiée à cette variable.

Sujet: Re: Pic et Poc, les joyeux drilles Jeu 11 Oct 2012 - 21:48

Je crois que le plus simple, là, c'est que Jack nous donne directement l'info.
S'il veut la partager, il nous dit comment ça marche, sinon s'il ne le veut pas et que l'on trouve, il pourra toujours compliquer ce codage lors de la prochaine version Wink

Sujet: Re: Pic et Poc, les joyeux drilles Jeu 11 Oct 2012 - 21:55

Effectivement, si on regarde des variables entières consécutives, elles semblent espacées de 80 octets (hexa 50).
Mais je ne comprends pas, si je fais:
i% = 160
j% = 176
PRINT "Variable i%= " + STR$(i%)
Dump(adr(i%), 128)
PRINT "Variable j%= " + STR$(j%)
Dump(adr(j%), 128)
END
j'obtiens:

Les valeurs des variables 160 et 176 (AO et BO) sont bien aux adresses données, mais pourquoi dans le 1er dump n'ai-je pas la valeur à l'adresse donnée pour le 2ème.
En clair, pourquoi est-ce que j'ai 00 en 203B928 alors que je devrais avoir déjà B0, à l'emplacement de la variable j% qui est déjà définie ?
Pourquoi, dans le 2ème dump

Sujet: Re: Pic et Poc, les joyeux drilles Jeu 11 Oct 2012 - 22:05

Je n'ai pas regardé ta routine dump. J'ai fait rapidement ceci:

Code:: height 0,800

dim a1%,a2%,a3%,b%(10),c1%,c2,c3%
dim i%,s$
a1% = 171
a2% = 172
a3% = 173
b%(0) = 271
c1% = 371
c2 = 372
c3% = 373

memo 10 : top 10,10 : left 10,10
width 10,200 : height 10,600
bar_vertical 10
memo 11 : top 11,10 : left 11,230
width 11,200 : height 11,400
bar_vertical 11

item_add 11,"adr(a1%)="+str$(adr(a1%))
item_add 11,"adr(a2%)="+str$(adr(a2%))
item_add 11,"adr(a3%)="+str$(adr(a3%))
item_add 11,"adr(b%)="+"?"
item_add 11,"adr(c1%)="+str$(adr(c1%))
item_add 11,"adr(c2)="+str$(adr(c2))
item_add 11,"adr(c3%)="+str$(adr(c3%))

for i%=adr(a1%) to adr(c3%)
item_add 10,str$(i%)+": "+str$(peek(i%))
next i%

end

Tu vois deux mémos. Celui de gauche fait un dump linéaire, et on voit bien la structure de 80 octets par case de la table se symboles. On voit d'ailleurs que la suite 127,9,1 définit un entier don la valeur est placée dans la 8ème cellule après ce code. Un flottant est introduit par 127,9,3. Et même pour un tableau, la taille de 80 octets est respectée. Pourra-t-on trouver l'endroit des données de la première valeur du tableau, de la suivante etc ?

Sujet: Re: Pic et Poc, les joyeux drilles Jeu 11 Oct 2012 - 22:25

Code:: DIM v%,a$,x, tb%(10)
v% = 10 : x = 123.456 : a$ = "SALUT" : tb%(0) = 10 : tb%(1) = 20
PRINT "ADR(v%) = " ;ADR(v%)
PRINT "ADR(a$) = " ;ADR(a$)
print "ADR(x) = " ;ADR(x)
PRINT "ADR(tb%(0)) = "; ADR(tb%(0)) : ' ça donne le contenu de tb%(0)
print "ADR(tb%(1)) = "; ADR(tb%(1)) : ' ça donne le contenu de tb%(1)

L’adresse d’un élément du tableau ne donne pas son adresse mais le contenu de cet élément
ADR(tb%(1)) est identique à tb%(1)

Sujet: Re: Pic et Poc, les joyeux drilles Jeu 11 Oct 2012 - 22:30

Là Klaus j'y perds mon latin (enfin, le peu qui me reste).
J'exécute ton code, mais je ne vois pas de suites 127,9,1 ni 127,9,3.
Je vois bien les valeurs 171, 172 et 173 de 80 en 80, puis ensuite c'est le désordre, je ne retrouve pas les autres variables...

Si pardon, je retrouve les 371, 372 et 373 (c'est sur 2 octets, c'est pour ça...) mais il faut voir ce qui se passe entre les deux (le tableau)

Sujet: Re: Pic et Poc, les joyeux drilles Jeu 11 Oct 2012 - 23:01

Voilà pour le 172, et tu vois le groupe de chiffres dont je parle:

Sujet: Re: Pic et Poc, les joyeux drilles Jeu 11 Oct 2012 - 23:04

@Papydall:
adr(b%(0)) ne peut pas donner l'adresse de l'élément 1 du tableau. b%(0) est pris comme une expression et c'est sa valeur qui est passée à adr(), et cela n'a donc plus de sens. On devrait pouvoir passer adr(b%()), mais il y a erreur de syntaxe, car justement b%() n'est pas une expression arithmétique valide. C'est pourquoi je cherche à identifier où est le pointeur dans la table de symbole qui donne l'adresse du véritable début des données du tableau.

Sujet: Re: Pic et Poc, les joyeux drilles Jeu 11 Oct 2012 - 23:19

Si on suit la progression par 80, après les 80 octets de a3% on a bien 80 octets qui correspondent au tableau, puis les 80 octets de c1%.
Dans ces zones de 80, il y a en 36 4 octets qui correspondent à une adresse, suivis d'un octet avec une valeur.
J'essaie d'aller dumper cette adresse pour le tableau, mais pour l'instant je n'y arrive pas...

Sujet: Re: Pic et Poc, les joyeux drilles Jeu 11 Oct 2012 - 23:20

JL35 a écrit:: -> les valeurs entières sont stockées directement dans les octets à l'adresse indiquée par adr(v%), les poids faibles en tête.
-> ADR(chaîne$) pointe sur une adresse (poids faibles en tête, toujours) qui renvoie à la chaîne elle-même. Ce que je n'ai pas encore trouvé c'est où est stockée la longueur de la chaîne, ou alors c'est le premier 0 rencontré, mais ça m'étonne...?
Non, c'est pas ça, parce qu'une chaîne peut parfaitement contenir un 0 (j'ai vérifié), alors la longueur doit être stockée autre part.
Mais où ?

Je viens de revoir mon très ancien cours sur la programmation système et je trouve ceci :
…
Il convient cependant de noter, notamment en ce qui concerne le buffer de texte (le plus souvent des variables du type STRING), que Turbo Pascal utilise un autre format que le DOS et le BIOS pour le stockage des chaines de caractères :
Pour stocker le string "PC" par exemple
Turbo Pascal : 2 "P" "C" == > le 2 indique la longueur de la chaine et il n’y a pas de marque de fin
DOS : "P" "C" $ == > le caractère $ (code ASCII 36) marque la fin de la chaine et il n’y a pas de définition de la longueur
BIOS : "P" "C" NULL ==> le caractère NULL (code 0) marque la fin de la chaine. Cette notation est parfois utilisée aussi par DOS

Alors, peut-être que PANORAMIC utilise la notation du BIOS!

Sujet: Re: Pic et Poc, les joyeux drilles Jeu 11 Oct 2012 - 23:32

Je pense que Panoramic utilise la structure des strings de Delphi:
(longueur du string) un entier de 32 bits
string proprement-dit (adr(s$) pointe ici
(nul) un octet 0 pour terminer
C'est ce que je rencontre quand je prends un string en paramètre dans ma DLL via adr(s$).

Sujet: Re: Pic et Poc, les joyeux drilles Jeu 11 Oct 2012 - 23:43

Non papydall, une chaîne peut très bien contenir n'importe quelle valeur de 0 à 255, y compris le 0 binaire, seule la longueur est prise en compte.
D'ailleurs j'ai déjà lu un fichier binaire entier (une image par exemple) dans une seule variable, qui fait la longueur du fichier et qui contient le contenu intact (on peut y faire des recherches de séquences binaires par INSTR, c'est pratique).

@Klaus j'ai bien l'adresse du bloc de 80 concernant le tableau, mais quand je veux récupérer par programme l'adresse qui est en 36 à 39 pour la dumper, j'y trouve des 0 -> erreur... je ne comprends pas pourquoi !
On verra demain, j'aurai peut-être les idées plus claires...

Sujet: Re: Pic et Poc, les joyeux drilles Ven 12 Oct 2012 - 0:19

Sujet: Re: Pic et Poc, les joyeux drilles Ven 12 Oct 2012 - 0:27

@Papydall:
Le NULL soit chr$(0) est bien le marqueur de fin de chaîne. C'est la convention Delphi. Ceci dit, Panoramic n'utilise pas cela pour détecter une fin de chaîne. Regarde ceci:

Code:: dim s$
s$ = "a"+chr$(0)+"b"
print len(s$)
print s$

La longueur de la chaîne est déterminée par le mot de 32 bits qui précède la chaîne et qui se trouve donc à l'adresse adr(s$)-4 !

Windows par contre l'utilise: essaie de placer s$ dans la caption d'un alpha - seul le "a" s'affichera. C'est Windows qui fait ça, pas Panoramic.

Sujet: re Ven 12 Oct 2012 - 1:25

@ JL35,

Si toi tu y perds ton Lapin, pour moi tout le monde s'est mis à parler Mandarine...heu...Mandarin Laughing

» Joyeux Noël à tous !
» Joyeux Noël
» JOYEUX NOËL !!!
» JOYEUX NOEL à TOUS
» Joyeux Noël à tous