Home page > Delphi, tips bulk > Tips for beginners > MiscSwaps: swapping things

MiscSwaps: swapping things

Saturday 27 August 2011, by CapJack

This Delphi unit shows how to exchange bytes in a variable, by accessing its content via the directive "absolute".

It also gives an example of the use of the "overload" to write routines for different types of parameters.

  1. (*********************************************************)
  2. (***)                                                 (***)
  3. (***)               UNIT MiscSwaps;                   (***)
  4. (***)                                                 (***)
  5. (*********************************************************)
  6.  
  7. (*********************************************************)
  8. (* Feel free to use it, but at your own risk!            *)
  9. (* À utiliser librement, mais à vos risques et périls !  *)
  10. (* CapJack - http://capjack.fr                           *)
  11. (*********************************************************)
  12.  
  13.  
  14. (*********************************************************)
  15. (***)                                                 (***)
  16. (***)                  INTERFACE                      (***)
  17. (***)                                                 (***)
  18. (*********************************************************)
  19.  
  20.  
  21. (*********************************************************)
  22. (* DTSwapWordBytesProc, DTSwapWordBytes                  *)
  23. (* ----------------------------------------------------- *)
  24. (* Swaps byte order of a Word variable.                  *)
  25. (* ----------------------------------------------------- *)
  26. (* Échange les octets d'une variable de type Word.       *)
  27. (*********************************************************)
  28.  
  29. Procedure DTSwapWordBytesProc(var AWordVar:Word);
  30.  
  31. function  DTSwapWordBytes(const AWordConst:Word):Word;
  32.  
  33. (*********************************************************)
  34. (* DTSwapLongBytesProc, DTSwapLongBytes                  *)
  35. (* ----------------------------------------------------- *)
  36. (* Swaps byte order of a LongInt variable.               *)
  37. (* ----------------------------------------------------- *)
  38. (* Inverse l'ordre des octets d'une variable LongInt.    *)
  39. (*********************************************************)
  40.  
  41. Procedure DTSwapLongBytesProc(var ALongIntVar:LongInt);
  42.  
  43. function  DTSwapLongBytes(const ALongIntConst:LongInt):LongInt;
  44.  
  45. (*********************************************************)
  46. (* DTSwap                                                *)
  47. (* ----------------------------------------------------- *)
  48. (* Swaps the two parameters; example of overload.        *)
  49. (* ----------------------------------------------------- *)
  50. (* Échange les deux paramètres ; exemple d'overload.     *)
  51. (*********************************************************)
  52.  
  53. Procedure DTSwap(var Param1, Param2:Byte);overload;
  54. Procedure DTSwap(var Param1, Param2:Word);overload;
  55. Procedure DTSwap(var Param1, Param2:Integer);overload;
  56. Procedure DTSwap(var Param1, Param2:Int64);overload;
  57. Procedure DTSwap(var Param1, Param2:string);overload;
  58.  
  59.  
  60. (*********************************************************)
  61. (***)                                                 (***)
  62. (***)                IMPLEMENTATION                   (***)
  63. (***)                                                 (***)
  64. (*********************************************************)
  65.  
  66. {---------------------------------------------------------}
  67.  
  68. Procedure DTSwapWordBytesProc(var AWordVar:Word);
  69.  var lBytes   : array[0..1] of Byte absolute AWordVar;
  70.      lByteBuf : Byte;
  71.  begin
  72.   lByteBuf  := lBytes[0];
  73.   lBytes[0] := lBytes[1];
  74.   lBytes[1] := lByteBuf
  75.  end;
  76.  
  77. {---------------------------------------------------------}
  78.  
  79. function  DTSwapWordBytes(const AWordConst:Word):Word;
  80.  begin
  81.   Result := AWordConst;
  82.   DTSwapWordBytesProc(Result);
  83.  end;
  84.  
  85. {---------------------------------------------------------}
  86.  
  87. Procedure DTSwapLongBytesProc(var ALongIntVar:LongInt);
  88.  var lBytes   : array[0..3] of Byte absolute ALongIntVar;
  89.      lByteBuf : Byte;
  90.  begin
  91.   lByteBuf  := lBytes[0];
  92.   lBytes[0] := lBytes[3];
  93.   lBytes[3] := lByteBuf;
  94.   lByteBuf  := lBytes[1];
  95.   lBytes[1] := lBytes[2];
  96.   lBytes[2] := lByteBuf
  97.  end;
  98.  
  99. {---------------------------------------------------------}
  100.  
  101. function  DTSwapLongBytes(const ALongIntConst:LongInt):LongInt;
  102.  begin
  103.   Result := ALongIntConst;
  104.   DTSwapLongBytesProc(Result);
  105.  end;
  106.  
  107. {---------------------------------------------------------}
  108.  
  109. Procedure DTSwap(var Param1, Param2:Byte);overload;
  110. var Buf : Byte;
  111. begin Buf := Param1; Param1 := Param2 ; Param2 := Buf end;
  112.  
  113. Procedure DTSwap(var Param1, Param2:Word);overload;
  114. var Buf : Word;
  115. begin Buf := Param1; Param1 := Param2 ; Param2 := Buf end;
  116.  
  117. Procedure DTSwap(var Param1, Param2:Integer);overload;
  118. var Buf : Integer;
  119. begin Buf := Param1; Param1 := Param2 ; Param2 := Buf end;
  120.  
  121. Procedure DTSwap(var Param1, Param2:Int64);overload;
  122. var Buf : Int64;
  123. begin Buf := Param1; Param1 := Param2 ; Param2 := Buf end;
  124.  
  125. Procedure DTSwap(var Param1, Param2:string);overload;
  126. var Buf : string;
  127. begin Buf := Param1; Param1 := Param2 ; Param2 := Buf end;
  128.  
  129. {---------------------------------------------------------}
  130.  
  131.  
  132. END.