PureBoard

Code: Alles auswählen

DataSection
a:
;(Zahl = 286331152)
;$11111110
Data.b $10,$11,$11,$11
b:
;(Zahl = 4294967294)
;$FFFFFFFE
Data.b $FE,$FF,$FF,$FF
EndDataSection

Procedure grosser(a,b)
 aHigh= (a>>16)&$FFFF
 aLow = a&$FFFF
 bHigh= (b>>16)&$FFFF
 bLow = b&$FFFF
 ret=1
 If blow<alow
  ret=0
 EndIf 
 If blow>alow
  ret=1
 EndIf 
 If bhigh<ahigh
  ret=0
 EndIf 
 If bhigh>ahigh
  ret=1
 EndIf 
ProcedureReturn ret
EndProcedure

a = PeekL(?a)
b = PeekL(?b)

Debug ("Hex")
Debug ("a :"+Hex(a))
Debug ("b :"+Hex(b))
Debug ("Dez")
Debug ("a :"+Str(a))
Debug ("b :"+Str(b))

Debug" ok ... PB rechnet signed (also in meinem Fall Falsch ?) ..... "
If a < b 
 Debug ("b grösser a")
Else 
 Debug ("b nicht grösser a")
EndIf

Debug" ok ... unsigned  ..... "
If grosser(a,b) 
 Debug ("b grösser a")
EndIf

Code: Alles auswählen

; Some procedures to compare 2 32-bit-integers unsigned
; the scheme is always:
; - test if exactly one of them is larger than $7FFFFFFF, then return result
; - if not, then compare their lower 31 bits
; 
; = and <> work with unsigned integers, too
;
; by Froggerprogger

Procedure UINT_Greater(a.l, b.l)
  If (a ! b) & $80000000
    If a & $80000000 : ProcedureReturn 1 : Else : ProcedureReturn 0 : EndIf
  EndIf
  If a & $7FFFFFFF > b & $7FFFFFFF : ProcedureReturn 1 : Else : ProcedureReturn 0 : EndIf
EndProcedure

Procedure UINT_GreaterEq(a.l, b.l)
  If (a ! b) & $80000000
    If a & $80000000 : ProcedureReturn 1 : Else : ProcedureReturn 0 : EndIf
  EndIf
  If a & $7FFFFFFF >= b & $7FFFFFFF : ProcedureReturn 1 : Else : ProcedureReturn 0 : EndIf
EndProcedure

Procedure UINT_Less(a.l, b.l)
  If (a ! b) & $80000000
    If a & $80000000 : ProcedureReturn 0 : Else : ProcedureReturn 1 : EndIf
  EndIf
  If a & $7FFFFFFF < b & $7FFFFFFF : ProcedureReturn 1 : Else : ProcedureReturn 0 : EndIf
EndProcedure

Procedure UINT_LessEq(a.l, b.l)
  If (a ! b) & $80000000
    If a & $80000000 : ProcedureReturn 0 : Else : ProcedureReturn 1 : EndIf
  EndIf
  If a & $7FFFFFFF <= b & $7FFFFFFF : ProcedureReturn 1 : Else : ProcedureReturn 0 : EndIf
EndProcedure

;-
;- examples
;-
x.l = $80000000
y.l = $7FFFFFFF
Debug UINT_Greater(x,y)
Debug UINT_GreaterEq(x,y)
Debug UINT_Less(x,y)
Debug UINT_LessEq(x,y)
Debug ""

x.l = $80000010
y.l = $80000020
Debug UINT_Greater(x,y)
Debug UINT_GreaterEq(x,y)
Debug UINT_Less(x,y)
Debug UINT_LessEq(x,y)
Debug ""

x.l = 17
y.l = 17
Debug UINT_Greater(x,y)
Debug UINT_GreaterEq(x,y)
Debug UINT_Less(x,y)
Debug UINT_LessEq(x,y)
Debug ""

Code: Alles auswählen

Procedure grosser(a,b)
  MOV Eax, a
  CMP Eax, b
  JNA @f ; not above
  
  ProcedureReturn 1
  !@@:
EndProcedure
Procedure kleiner(a,b)
  MOV Eax, a
  CMP Eax, b
  JNB @f ; not below
  
  ProcedureReturn 1
  !@@:
EndProcedure
Procedure gleich(a,b)
  MOV Eax, a
  CMP Eax, b
  JNE @f ; not equal
  
  ProcedureReturn 1
  !@@:
EndProcedure
Procedure klgleich(a,b)
  MOV Eax, a
  CMP Eax, b
  JA @f ; above
  
  ProcedureReturn 1
  !@@:
EndProcedure
Procedure grgleich(a,b)
  MOV Eax, a
  CMP Eax, b
  JB @f ; below
  
  ProcedureReturn 1
  !@@:
EndProcedure

Code: Alles auswählen

Procedure kleiner(a,b)
  SUB Eax,Eax
  MOV Ebx,a
  CMP Ebx,b
  RCL Eax,1
ProcedureReturn 
EndProcedure 

Code: Alles auswählen

Procedure kleiner(a,b) 
  SUB Eax,Eax 
  MOV Ebx,a 
  CMP Ebx,b 
  RCL Eax,1 
ProcedureReturn 
EndProcedure 

a= $FFFFFFFF
b= $11111111

Debug kleiner(a,b)
Debug kleiner(b,a)
Debug kleiner(a,a)

Code: Alles auswählen

;/ Macros (and Procedures) for comparing two unsigned 32-bit-values (version 1.2)
;/
;/ all of them compare the first against the second parameter and
;/ store the result in the third parameter
;/
;/ To call them from PB you must introduce the line with '!', and mask
;/ all variablenames with '[v_MYVARIABLENAME]' (MYVARIABLENAME is case sensitive!!)
;/ Further you might use decimal values such as 12345,
;/ or hexadecimal values using leading '0x' instead of '$'
;/ In the macros the result-value is treated as if it were of type byte,
;/ so just the lower 8 bit are manipulated.
;/
;/ e.g. valid calls are (variables 'res', 'a', 'b' suspected to be already defined):
;/
;/ !greater 3, 9, [v_res]
;/ !smaller [v_a], 0x7FFFFFFF, [v_res]
;/ !smallerequal [v_a], [v_b], [v_res]
;/
;/ These Macros are about 4 times faster than the respective procedure.
;/ But if you don't really need this speed and want the convenience of a procedure,
;/ than you might use the ones below instead of the macros.
;/ These macros and proceudures are all independant of each other, so you can
;/ easily copy & paste the ones you need.
;/
;/ 14.02.2005 by Froggerprogger with the BIG help of remi_meier & horst & Helle

;- the macros: 
!macro greater a, b, res
!{
  !MOV  ebx,a
  !CMP  ebx,b
  !SETA byte res
!}

!macro greaterequal a, b, res
!{
  !MOV  ebx,a
  !CMP  ebx,b
  !SETAE byte res
!}

!macro smaller a, b, res
!{
  !MOV  ebx,a
  !CMP  ebx,b
  !SETB byte res
!}

!macro smallerequal a, b, res
!{
  !MOV  ebx,a
  !CMP  ebx,b
  !SETBE byte res
!}

;- the procedures:
Procedure.l UINT_Greater(a.l, b.l)
  !XOR eax,eax
  !MOV ebx,[esp]
  !CMP ebx,[esp+4]
  !SETA al
  ProcedureReturn
EndProcedure

Procedure.l UINT_GreaterEqual(a.l, b.l)
  !XOR eax,eax
  !MOV ebx,[esp]
  !CMP ebx,[esp+4]
  !SETAE al
  ProcedureReturn
EndProcedure

Procedure.l UINT_Smaller(a.l, b.l)
  !XOR eax,eax
  !MOV ebx,[esp]
  !CMP ebx,[esp+4]
  !SETB al
  ProcedureReturn
EndProcedure

Procedure.l UINT_SmallerEqual(a.l, b.l)
  !XOR eax,eax
  !MOV ebx,[esp]
  !CMP ebx,[esp+4] 
  !SETBE al
  ProcedureReturn
EndProcedure


;-
;- examples
;-

x         = $99000000
y         = $88000000
result.b  = 0           ; we might use LONG instead if we don't manipulate the upper 24 bits, though BYTE is more safe because of that

!greater [v_x], [v_y], [v_result]
Debug result
Debug UINT_Greater(x, y)

!smallerequal 0x80000000, [v_y], [v_result]
Debug result 
Debug UINT_SmallerEqual($88000000, y)