PureBasic Forums - English

Code: Select all

Procedure.l Endian(val.l)
  ProcedureReturn ((val & $000000FF) << 24) | ((val & $0000FF00) << 8) | ((val & $00FF0000) >> 8) | ((val & $FF000000) >> 24)
EndProcedure


Procedure.l EndianFix(val.l)
  Protected Result.q
  Result = ((val & $000000FF) << 24) | ((val & $0000FF00) << 8) | ((val & $00FF0000) >> 8) | ((val & $FF000000) >> 24)
  ProcedureReturn Result
EndProcedure


Define Test.l

Test = $12345678
Debug Hex(Test, #PB_Long)
Test = Endian(Test)
Debug Hex(Test, #PB_Long)

Debug ""

Test = $87654321
Debug Hex(Test, #PB_Long)
Test = Endian(Test)
Debug Hex(Test, #PB_Long)

Debug ""

Test = $87654321
Debug Hex(Test, #PB_Long)
Test = EndianFix(Test)
Debug Hex(Test, #PB_Long)

Code: Select all

Procedure.l Endian(val.l)
  ProcedureReturn ((val & $000000FF) << 24) | ((val & $0000FF00) << 8) | ((val & $00FF0000) >> 8) | ((val & $FF000000) >> 24)
EndProcedure


Procedure.l EndianFix(val.l)
  Protected Result.q
  Result = ((val & $000000FF) << 24) | ((val & $0000FF00) << 8) | ((val & $00FF0000) >> 8) | ((val & $FF000000) >> 24)
  ProcedureReturn Result
EndProcedure


Procedure.l Endian2(val.l)
	ProcedureReturn $FF & val >> 24 | ($FF & val) << 24 | ($FF & val >> 16) << 8 | ($FF & val >> 8) << 16
EndProcedure



Define Test.l

Test = $12345678
Debug Hex(Test, #PB_Long)
Test = Endian(Test)
Debug Hex(Test, #PB_Long)

Debug ""

Test = $87654321
Debug Hex(Test, #PB_Long)
Test = Endian(Test)
Debug Hex(Test, #PB_Long)

Debug ""

Test = $87654321
Debug Hex(Test, #PB_Long)
Test = EndianFix(Test)
Debug Hex(Test, #PB_Long)

Debug ""

Test = $87654321
Debug Hex(Test, #PB_Long)
Test = Endian2(Test)
Debug Hex(Test, #PB_Long)

Code: Select all

  ;          ; Type,   Bytes,  Min,             Max,             C Type
  w.w[0]     ; Word,       2, -32768,           32767,           short

Code: Select all

Procedure.l Endian(val.l)
  ProcedureReturn ((val & $000000FF) << 24) | ((val & $0000FF00) << 8) | ((val & $00FF0000) >> 8) | ((val >> 24) & $000000FF)
EndProcedure

Code: Select all

   
  Procedure.q BSWAP64(value.q)
    
    CompilerIf #PB_Compiler_Backend = #PB_Backend_Asm
       
      CompilerIf #PB_Compiler_32Bit
        !lea ecx, [p.v_value]   ; load effective address of value (:= @value)
        !mov edx, dword [ecx]
        !mov eax, dword [ecx +4]
        !bswap edx
        !bswap eax
        ProcedureReturn         ; 64Bit Return use EAX and EDX Register
        
      CompilerElse
        !mov rax, qword [p.v_value]
        !bswap rax
        ProcedureReturn
        
      CompilerEndIf
      
    CompilerElse  ; C-Backend       
        !return __builtin_bswap64(v_value);
     CompilerEndIf  
   EndProcedure
   
 Structure pSwap ; Pointer Structure for swapping
    a.a[0]    ; unsigned Byte-Value
    u.u[0]    ; unsigned WORD-Value
  EndStructure

Procedure.q BSWAP64_PB(value.q) 
  Protected *Swap.pSwap
  *Swap = @value
  Swap *Swap\a[0], *Swap\a[7]
  Swap *Swap\a[1], *Swap\a[6]
  Swap *Swap\a[2], *Swap\a[5]
  Swap *Swap\a[3], *Swap\a[4]
  ProcedureReturn value
EndProcedure

Test = $8877665544332211
Debug Hex(Test, #PB_Quad)
Debug Hex(BSWAP64(Test), #PB_Quad)
Debug Hex(BSWAP64_PB(Test), #PB_Quad)

Code: Select all

;{ TODO:  Solve the LoCase var problem in C-Backend
;}
; ===========================================================================

CompilerIf #PB_Compiler_Backend = #PB_Backend_C
    
    ; there is a problem in C-Backend. In C-Backend we have to 
    ; call BSwapVar always with variable name in lower case
    ; if we define L.l and call BSwapVar(L) we get an error
    ; if we call  BSwapVar(l) it works!
    ; it looks like the compiler LoCase all variables but in a Macro not!
    CompilerWarning "Use of Macro BSwapVar(var) in C-Backend: Attention! Pass all variable names in LoCase : BSwapVar(myvar)! BSwapVar(MyVar) produce an Error!"
    
    Macro BSwapVar(var)          
      CompilerSelect SizeOf(var)
        CompilerCase 2
          !v_#var = __builtin_bswap16(v_#var);                   
        CompilerCase 4
          !v_#var = __builtin_bswap32(v_#var);                 
        CompilerCase 8 
          !v_#var = __builtin_bswap64(v_#var);
      CompilerEndSelect        
    EndMacro
  
  CompilerElse    ; ASM-Backend
    
    ; We use the EnableASM command only to load and save the variable
    ; because if we pass directly the 'MOV EAX, var' we have to add v_ for standard code
    ; or p.v_ for variables in a procedure. With the PB buildin ASM it is done by PB.
    Macro BSwapVar(var)
      EnableASM   
      CompilerSelect SizeOf(var)
        CompilerCase 2         
          !XOR EAX, EAX
          MOV AX, var
          !XCHG AL, AH
          MOV var, AX         
  
        CompilerCase 4          
          MOV EAX, var
          !BSWAP EAX
          MOV var, EAX          
                
        CompilerCase 8  ; Quad
          
          CompilerIf #PB_Compiler_Processor = #PB_Processor_x64           
            MOV RAX, var
            !BSWAP RAX
            MOV var, RAX
                     
          CompilerElse   ; ASM x32         
            LEA ECX, var   ; load effective address of var : ECX= @var
            !MOV EDX, DWORD [ECX]
            !MOV EAX, DWORD [ECX +4]
            !BSWAP EDX
            !BSWAP EAX
            !MOV DWORD [ECX], EAX
            !MOV DWORD [ECX +4], EDX 
                        
          CompilerEndIf    
            
      CompilerEndSelect
      DisableASM
    EndMacro
    
  CompilerEndIf
  

Code: Select all

#DrawOpaque=$FF000000
Procedure LedMerge(x,y,s,d)

	x=d&#DrawOpaque
	If x>s
		ProcedureReturn x|Calc\ColorTxt
	Else
		ProcedureReturn (s&#DrawOpaque)|Calc\ColorTxt
	EndIf

EndProcedure

Code: Select all

Procedure.l LedMerge(x,y,s.l,d.l)

	x=d&#DrawOpaque
	y=s&#DrawOpaque
	If x>y
		ProcedureReturn x|Calc\ColorTxt
	Else
		ProcedureReturn y|Calc\ColorTxt
	EndIf

EndProcedure