| ------------------------------------------------------------------------------ |
| -- -- |
| -- GNAT RUN-TIME COMPONENTS -- |
| -- -- |
| -- G N A T . B Y T E _ S W A P P I N G -- |
| -- -- |
| -- S p e c -- |
| -- -- |
| -- Copyright (C) 2006-2012, AdaCore -- |
| -- -- |
| -- GNAT is free software; you can redistribute it and/or modify it under -- |
| -- terms of the GNU General Public License as published by the Free Soft- -- |
| -- ware Foundation; either version 3, or (at your option) any later ver- -- |
| -- sion. GNAT is distributed in the hope that it will be useful, but WITH- -- |
| -- OUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY -- |
| -- or FITNESS FOR A PARTICULAR PURPOSE. -- |
| -- -- |
| -- As a special exception under Section 7 of GPL version 3, you are granted -- |
| -- additional permissions described in the GCC Runtime Library Exception, -- |
| -- version 3.1, as published by the Free Software Foundation. -- |
| -- -- |
| -- You should have received a copy of the GNU General Public License and -- |
| -- a copy of the GCC Runtime Library Exception along with this program; -- |
| -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- |
| -- <http://www.gnu.org/licenses/>. -- |
| -- -- |
| -- GNAT was originally developed by the GNAT team at New York University. -- |
| -- Extensive contributions were provided by Ada Core Technologies Inc. -- |
| -- -- |
| ------------------------------------------------------------------------------ |
| |
| -- Simple routines for swapping the bytes of 16-, 32-, and 64-bit objects |
| |
| -- The generic functions should be instantiated with types that are of a size |
| -- in bytes corresponding to the name of the generic. For example, a 2-byte |
| -- integer type would be compatible with Swapped2, 4-byte integer with |
| -- Swapped4, and so on. Failure to do so will result in a warning when |
| -- compiling the instantiation; this warning should be heeded. Ignoring this |
| -- warning can result in unexpected results. |
| |
| -- An example of proper usage follows: |
| |
| -- declare |
| -- type Short_Integer is range -32768 .. 32767; |
| -- for Short_Integer'Size use 16; -- for confirmation |
| |
| -- X : Short_Integer := 16#7FFF#; |
| |
| -- function Swapped is new Byte_Swapping.Swapped2 (Short_Integer); |
| |
| -- begin |
| -- Put_Line (X'Img); |
| -- X := Swapped (X); |
| -- Put_Line (X'Img); |
| -- end; |
| |
| -- Note that the generic actual types need not be scalars, but must be |
| -- 'definite' types. They can, for example, be constrained subtypes of |
| -- unconstrained array types as long as the size is correct. For instance, |
| -- a subtype of String with length of 4 would be compatible with the |
| -- Swapped4 generic: |
| |
| -- declare |
| -- subtype String4 is String (1 .. 4); |
| -- function Swapped is new Byte_Swapping.Swapped4 (String4); |
| -- S : String4 := "ABCD"; |
| -- for S'Alignment use 4; |
| -- begin |
| -- Put_Line (S); |
| -- S := Swapped (S); |
| -- Put_Line (S); |
| -- end; |
| |
| -- Similarly, a constrained array type is also acceptable: |
| |
| -- declare |
| -- type Mask is array (0 .. 15) of Boolean; |
| -- for Mask'Alignment use 2; |
| -- for Mask'Component_Size use Boolean'Size; |
| -- X : Mask := (0 .. 7 => True, others => False); |
| -- function Swapped is new Byte_Swapping.Swapped2 (Mask); |
| -- begin |
| -- ... |
| -- X := Swapped (X); |
| -- ... |
| -- end; |
| |
| -- A properly-sized record type will also be acceptable, and so forth |
| |
| -- However, as described, a size mismatch must be avoided. In the following we |
| -- instantiate one of the generics with a type that is too large. The result |
| -- of the function call is undefined, such that assignment to an object can |
| -- result in garbage values. |
| |
| -- Wrong: declare |
| -- subtype String16 is String (1 .. 16); |
| |
| -- function Swapped is new Byte_Swapping.Swapped8 (String16); |
| -- -- Instantiation generates a compiler warning about |
| -- -- mismatched sizes |
| |
| -- S : String16; |
| |
| -- begin |
| -- S := "ABCDEFGHDEADBEEF"; |
| -- |
| -- Put_Line (S); |
| -- |
| -- -- the following assignment results in garbage in S after the |
| -- -- first 8 bytes |
| -- |
| -- S := Swapped (S); |
| -- |
| -- Put_Line (S); |
| -- end Wrong; |
| |
| -- When the size of the type is larger than 8 bytes, the use of the non- |
| -- generic procedures is an alternative because no function result is |
| -- involved; manipulation of the object is direct. |
| |
| -- The procedures are passed the address of an object to manipulate. They will |
| -- swap the first N bytes of that object corresponding to the name of the |
| -- procedure. For example: |
| |
| -- declare |
| -- S2 : String := "AB"; |
| -- for S2'Alignment use 2; |
| -- S4 : String := "ABCD"; |
| -- for S4'Alignment use 4; |
| -- S8 : String := "ABCDEFGH"; |
| -- for S8'Alignment use 8; |
| |
| -- begin |
| -- Swap2 (S2'Address); |
| -- Put_Line (S2); |
| |
| -- Swap4 (S4'Address); |
| -- Put_Line (S4); |
| |
| -- Swap8 (S8'Address); |
| -- Put_Line (S8); |
| -- end; |
| |
| -- If an object of a type larger than N is passed, the remaining bytes of the |
| -- object are undisturbed. For example: |
| |
| -- declare |
| -- subtype String16 is String (1 .. 16); |
| |
| -- S : String16; |
| -- for S'Alignment use 8; |
| |
| -- begin |
| -- S := "ABCDEFGHDEADBEEF"; |
| -- Put_Line (S); |
| -- Swap8 (S'Address); |
| -- Put_Line (S); |
| -- end; |
| |
| with System; |
| |
| package GNAT.Byte_Swapping is |
| pragma Pure; |
| |
| -- NB: all the routines in this package treat the application objects as |
| -- unsigned (modular) types of a size in bytes corresponding to the routine |
| -- name. For example, the generic function Swapped2 manipulates the object |
| -- passed to the formal parameter Input as a value of an unsigned type that |
| -- is 2 bytes long. Therefore clients are responsible for the compatibility |
| -- of application types manipulated by these routines and these modular |
| -- types, in terms of both size and alignment. This requirement applies to |
| -- the generic actual type passed to the generic formal type Item in the |
| -- generic functions, as well as to the type of the object implicitly |
| -- designated by the address passed to the non-generic procedures. Use of |
| -- incompatible types can result in implementation- defined effects. |
| |
| generic |
| type Item is limited private; |
| function Swapped2 (Input : Item) return Item; |
| -- Return the 2-byte value of Input with the bytes swapped |
| |
| generic |
| type Item is limited private; |
| function Swapped4 (Input : Item) return Item; |
| -- Return the 4-byte value of Input with the bytes swapped |
| |
| generic |
| type Item is limited private; |
| function Swapped8 (Input : Item) return Item; |
| -- Return the 8-byte value of Input with the bytes swapped |
| |
| procedure Swap2 (Location : System.Address); |
| -- Swap the first 2 bytes of the object starting at the address specified |
| -- by Location. |
| |
| procedure Swap4 (Location : System.Address); |
| -- Swap the first 4 bytes of the object starting at the address specified |
| -- by Location. |
| |
| procedure Swap8 (Location : System.Address); |
| -- Swap the first 8 bytes of the object starting at the address specified |
| -- by Location. |
| |
| pragma Inline (Swap2, Swap4, Swap8, Swapped2, Swapped4, Swapped8); |
| |
| end GNAT.Byte_Swapping; |
