Unsigned Long --> en PB

[graph100]

feriez vous de même pour lire un entier long non signé ?

Code : Tout sélectionner

Macro PeekULong(adr)
	(PeekA(adr) + PeekA(adr + 1) << 8 + PeekA(adr + 2) << 16 + PeekA(adr + 3) << 24)
EndMacro

mon_quad.q = PeekULong(*adresse)

[G-Rom]

Code : Tout sélectionner

Macro PeekULong(adr)
  PeekI(adr) & $FFFFFFFFFFFF
EndMacro

[Mesa]

Attention avec PeekI, la doc dit "Lit un entier 'integer' (4 octets sur un éxecutable 32-bit, 8 octets sur un éxecutable 64-bit) depuis l'adresse mémoire spécifiée".

Et PeekL "Lit un long (4 octets) depuis l'adresse mémoire spécifiée "

M.

[PAPIPP]

Bonjour graph100

Je suis en XP 32 SP3

comme cela
les 2 macros en plus permettent de visualiser en hexa long toute zone de la mémoire

Code : Tout sélectionner

Macro q_t_
  "
EndMacro
Macro __HL(__HL,_pr="$")
  q_t_#__HL#=q_t_+_PR+RSet(Hex(PeekL(@__HL),#PB_Long),8,"0")+" "
EndMacro
Macro PeekULong(adr,_vq_)
  _vq_.q=PeekA(adr+3)<<24
	_vq_+(PeekA(adr)+PeekA(adr+1)<<8+PeekA(adr+2)<<16)
EndMacro
Structure l_n_s
  StructureUnion
    Vc.c[4]
    Vl.l
  EndStructureUnion
EndStructure
;; mise au point
Debug "mise au point"
Ul.l_n_s
Ul\vl=2147483647
; Debug mp_h(Ul,32,222)
Debug Hex(ul)
Debug Ul\vl
peekulong(Ul,vqq)
Debug vqq
Ul\vl=$12345678
; Debug mp_h(Ul,32,222)
Debug __HL(ul)
Debug Ul\vl
peekulong(Ul,vqq)
Debug vqq
Debug "essai avec long non signé"
; essai avec long non signé
Ul\vl=2147483647
; Debug mp_h(Ul,32,222)
Debug __HL(ul)
peekulong(Ul,vqq)
Debug vqq
Debug "pour avoir le plus grand nombre long non signé il faut placer $ff en add+3 et l'on obtient le double du signé+1"
; pour avoir le plus grand nombre no signé il faut placer $FF en add+3
ul\vc[3]=255
; Debug mp_h(Ul,32,222)
Debug __HL(ul)
peekulong(Ul,vqq) ; formule d'origine mauvaise 
Debug vqq

A+

[PAPIPP]

Bonjour à tous
Pour lire un long non signé on peut faire plus simple.
Déplacer le long non signé dans une zone plus longue signé. Exemple long vers double long
Exemple ci-dessous :
Les 3 macros ne servent que pour visualiser la mémoire en HEXA long ou double long.

Code : Tout sélectionner

Macro q_t_
  "
EndMacro
Macro __HL(__HL,_pr="$")
  q_t_#__HL#=q_t_+_PR+RSet(Hex(PeekL(@__HL),#PB_Long),8,"0")+" "
EndMacro
Macro __HQ (__HQ,_pr="$")
q_t_#__HQ#=q_t_+_PR+RSet(Hex(PeekQ(@__HQ),#PB_Quad),16,"0")+" "
EndMacro
Structure l_n_s
  StructureUnion
    Vc.c[4]
    Vl.l
    Vq.q
  EndStructureUnion
EndStructure
;; mise au point
Debug "mise au point"
Ul.l_n_s
VVq.Q
Ul\vl=2147483647
; essai avec long non signé
Debug __HL(ul)
; peekulong(Ul,vqq)
; Debug vqq
Debug ul\Vq
Debug "pour avoir le plus grand nombre long non signé il faut placer $ff en add+3 et l'on obtient le double du signé+1"
; pour avoir le plus grand nombre no signé il faut placer $FF en add+3
ul\vc[3]=255

Debug "*************** Lecture d'un nombre en long non signé ******************"
Debug "Si l'on veut lire le plus grand nombre long non signé il suffit de le placer dans une zone signée plus grande"
CopyMemory(Ul, @VVq, 4)
Debug __hq(vvq)
Debug vvq

A+

[graph100]

Bonjour à vous, et merci pour ces réponses qui m'orientent sur de nouvelles voies qui m'étaient passées très au dessus de la caboche
Le code que j'avais posté contenait une erreur (32 au lieux de 24), que j'avais corrigé dans mes programmes après avoir posté, c'est maintenant corrigé ici aussi (bien vu PAPIPP )

Je trouve vraiment dommage de devoir utiliser des quad pour pouvoir utiliser des unsigned... Et encore je n'ai pas encore eu a utiliser des longlong unsigned, d'ailleurs on fait quoi dans ce cas la ?

Au niveau de la rapidité d'exécution, c'est le code de GRom qui se place premier :

Code : Tout sélectionner

*mem = AllocateMemory(10)

PokeQ(*mem, $F00000FF)


Define q.q



#t = 10000000


CopyMemory(*mem, @q, 4)
Debug q

time = ElapsedMilliseconds()
For i = 1 To #t
	CopyMemory(*mem, @q, 4)
Next
Debug ElapsedMilliseconds() - time



Macro PeekULong(adr)
	PeekL(adr) & $FFFFFFFF
EndMacro

q = PeekULong(*mem)
Debug q


time = ElapsedMilliseconds()
For i = 1 To #t
	q = PeekULong(*mem)
Next
Debug ElapsedMilliseconds() - time


Macro PeekULong_(adr)
		(PeekA(adr) + PeekA(adr + 1) << 8 + PeekA(adr + 2) << 16 + PeekA(adr + 3) << 24)
	EndMacro
	
q = PeekULong_(*mem)
Debug q


time = ElapsedMilliseconds()
For i = 1 To #t
	q = PeekULong_(*mem)
Next
Debug ElapsedMilliseconds() - time

4026532095
734 ms
4026532095
688 ms
4026532095
844 ms

Merci à vous !

[PAPIPP]

Bonjour graph100
on peut même avec les structures ne pas avoir de transfert exemple :

Code : Tout sélectionner

Structure l_n_s
  StructureUnion
    Vc.c[4]
    Vl.l
    Vq.q
  EndStructureUnion
EndStructure
mem.l_n_s
*mem = @mem
; *mem=mem ; même adresse que l'instruction précédente

PokeQ(*mem, $F00000FF)
Debug "**** ci-dessous sans transfert et sans conversion avec les structures "
Debug mem\vq
Debug PeekQ(*mem)

Define q.q
CopyMemory(*mem, @q, 4)
Debug q
Macro PeekULong(adr)
		PeekL(adr) & $FFFFFFFF
EndMacro
q = PeekULong(*mem)
Debug q
Macro PeekULong_(adr)
				(PeekA(adr) + PeekA(adr + 1) << 8 + PeekA(adr + 2) << 16 + PeekA(adr + 3) << 24)
		EndMacro
q = PeekULong_(*mem)
Debug q

Par contre il faut toujours une zone plus grande que celle d'origine. Avec la structureunion la zone est automatiquement plus longue.

[graph100]

Le problème lorsque tu utilises un PeekQ() est que tu liras forcément une zone de mémoire de 8 bit.
Or Imagine que tu doives interagir avec un autre programme qui possède son propre format de données (des long non signés dans mon cas), qui sont stockés dans un blob comprenant plusieurs données différentes accolées. Tu dois lire que 4bit.

[PAPIPP]

Bonjour graph100

Comme un vieil adage nous le dit.
"Qui peut le plus peut le moins"

En effet il suffit de se limiter au 4 premiers octets
Exemple

Debug Val("$"+ Hex(PeekL(*mem),#PB_Long))

Et dans le programme ;

Code : Tout sélectionner

Structure l_n_s
  StructureUnion
    Vc.c[4]
    Vl.l
    Vq.q
  EndStructureUnion
EndStructure
mem.l_n_s
*mem=@mem
; *mem=mem ; même adresse que l'instruction précédente
PokeQ(*mem,$F00000FF)
Debug "**** ci-dessous sans transfert et sans conversion avec les structures "
Debug mem\vq
Debug PeekQ(*mem)
Debug Val("$"+ Hex(PeekL(*mem),#PB_Long))

Define q.q
CopyMemory(*mem, @q, 4)
Debug q
Macro PeekULong(adr)
		PeekL(adr) & $FFFFFFFF
EndMacro
q = PeekULong(*mem)
Debug q
Macro PeekULong_(adr)
				(PeekA(adr) + PeekA(adr + 1) << 8 + PeekA(adr + 2) << 16 + PeekA(adr + 3) << 24)
		EndMacro
q = PeekULong_(*mem)
Debug q

A+