-- --
------------------------------------------------------------------------------
+with System.Address_To_Access_Conversions;
with System.Storage_Elements;
with System.Unsigned_Types;
-- Use maximum possible alignment, given the bit field size, since this
-- will result in the most efficient code possible for the field.
- type Cluster_Ref is access Cluster;
+ package AAC is new Address_To_Access_Conversions (Cluster);
+ -- We convert addresses to access values and dereference them instead of
+ -- directly using overlays in order to work around the implementation of
+ -- the RM 13.3(19) clause, which would pessimize the generated code.
type Rev_Cluster is new Cluster
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_Cluster_Ref is access Rev_Cluster;
+
+ package Rev_AAC is new Address_To_Access_Conversions (Rev_Cluster);
------------
-- Get_03 --
N : Natural;
Rev_SSO : Boolean) return Bits_03
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
return
(if Rev_SSO then
E : Bits_03;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
-- --
------------------------------------------------------------------------------
+with System.Address_To_Access_Conversions;
with System.Storage_Elements;
with System.Unsigned_Types;
-- Use maximum possible alignment, given the bit field size, since this
-- will result in the most efficient code possible for the field.
- type Cluster_Ref is access Cluster;
+ package AAC is new Address_To_Access_Conversions (Cluster);
+ -- We convert addresses to access values and dereference them instead of
+ -- directly using overlays in order to work around the implementation of
+ -- the RM 13.3(19) clause, which would pessimize the generated code.
type Rev_Cluster is new Cluster
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_Cluster_Ref is access Rev_Cluster;
+
+ package Rev_AAC is new Address_To_Access_Conversions (Rev_Cluster);
------------
-- Get_05 --
N : Natural;
Rev_SSO : Boolean) return Bits_05
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
return
(if Rev_SSO then
E : Bits_05;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
-- --
------------------------------------------------------------------------------
+with System.Address_To_Access_Conversions;
with System.Storage_Elements;
with System.Unsigned_Types;
-- Use maximum possible alignment, given the bit field size, since this
-- will result in the most efficient code possible for the field.
- type Cluster_Ref is access Cluster;
+ package AAC is new Address_To_Access_Conversions (Cluster);
+ -- We convert addresses to access values and dereference them instead of
+ -- directly using overlays in order to work around the implementation of
+ -- the RM 13.3(19) clause, which would pessimize the generated code.
type Rev_Cluster is new Cluster
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_Cluster_Ref is access Rev_Cluster;
+
+ package Rev_AAC is new Address_To_Access_Conversions (Rev_Cluster);
-- The following declarations are for the case where the address
-- passed to GetU_06 or SetU_06 is not guaranteed to be aligned.
type ClusterU is new Cluster;
for ClusterU'Alignment use 1;
- type ClusterU_Ref is access ClusterU;
+ package AACU is new Address_To_Access_Conversions (ClusterU);
type Rev_ClusterU is new ClusterU
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_ClusterU_Ref is access Rev_ClusterU;
+
+ package Rev_AACU is new Address_To_Access_Conversions (Rev_ClusterU);
------------
-- Get_06 --
N : Natural;
Rev_SSO : Boolean) return Bits_06
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
return
(if Rev_SSO then
N : Natural;
Rev_SSO : Boolean) return Bits_06
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : ClusterU_Ref with Address => A'Address, Import;
- RC : Rev_ClusterU_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AACU.Object_Pointer := AACU.To_Pointer (A);
+ RC : constant Rev_AACU.Object_Pointer := Rev_AACU.To_Pointer (A);
+
begin
return
(if Rev_SSO then
E : Bits_06;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
E : Bits_06;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : ClusterU_Ref with Address => A'Address, Import;
- RC : Rev_ClusterU_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AACU.Object_Pointer := AACU.To_Pointer (A);
+ RC : constant Rev_AACU.Object_Pointer := Rev_AACU.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
-- --
------------------------------------------------------------------------------
+with System.Address_To_Access_Conversions;
with System.Storage_Elements;
with System.Unsigned_Types;
-- Use maximum possible alignment, given the bit field size, since this
-- will result in the most efficient code possible for the field.
- type Cluster_Ref is access Cluster;
+ package AAC is new Address_To_Access_Conversions (Cluster);
+ -- We convert addresses to access values and dereference them instead of
+ -- directly using overlays in order to work around the implementation of
+ -- the RM 13.3(19) clause, which would pessimize the generated code.
type Rev_Cluster is new Cluster
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_Cluster_Ref is access Rev_Cluster;
+
+ package Rev_AAC is new Address_To_Access_Conversions (Rev_Cluster);
------------
-- Get_07 --
N : Natural;
Rev_SSO : Boolean) return Bits_07
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
return
(if Rev_SSO then
E : Bits_07;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
-- --
------------------------------------------------------------------------------
+with System.Address_To_Access_Conversions;
with System.Storage_Elements;
with System.Unsigned_Types;
-- Use maximum possible alignment, given the bit field size, since this
-- will result in the most efficient code possible for the field.
- type Cluster_Ref is access Cluster;
+ package AAC is new Address_To_Access_Conversions (Cluster);
+ -- We convert addresses to access values and dereference them instead of
+ -- directly using overlays in order to work around the implementation of
+ -- the RM 13.3(19) clause, which would pessimize the generated code.
type Rev_Cluster is new Cluster
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_Cluster_Ref is access Rev_Cluster;
+
+ package Rev_AAC is new Address_To_Access_Conversions (Rev_Cluster);
------------
-- Get_09 --
N : Natural;
Rev_SSO : Boolean) return Bits_09
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
return
(if Rev_SSO then
E : Bits_09;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
-- --
------------------------------------------------------------------------------
+with System.Address_To_Access_Conversions;
with System.Storage_Elements;
with System.Unsigned_Types;
-- Use maximum possible alignment, given the bit field size, since this
-- will result in the most efficient code possible for the field.
- type Cluster_Ref is access Cluster;
+ package AAC is new Address_To_Access_Conversions (Cluster);
+ -- We convert addresses to access values and dereference them instead of
+ -- directly using overlays in order to work around the implementation of
+ -- the RM 13.3(19) clause, which would pessimize the generated code.
type Rev_Cluster is new Cluster
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_Cluster_Ref is access Rev_Cluster;
+
+ package Rev_AAC is new Address_To_Access_Conversions (Rev_Cluster);
-- The following declarations are for the case where the address
-- passed to GetU_10 or SetU_10 is not guaranteed to be aligned.
type ClusterU is new Cluster;
for ClusterU'Alignment use 1;
- type ClusterU_Ref is access ClusterU;
+ package AACU is new Address_To_Access_Conversions (ClusterU);
type Rev_ClusterU is new ClusterU
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_ClusterU_Ref is access Rev_ClusterU;
+
+ package Rev_AACU is new Address_To_Access_Conversions (Rev_ClusterU);
------------
-- Get_10 --
N : Natural;
Rev_SSO : Boolean) return Bits_10
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
return
(if Rev_SSO then
N : Natural;
Rev_SSO : Boolean) return Bits_10
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : ClusterU_Ref with Address => A'Address, Import;
- RC : Rev_ClusterU_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AACU.Object_Pointer := AACU.To_Pointer (A);
+ RC : constant Rev_AACU.Object_Pointer := Rev_AACU.To_Pointer (A);
+
begin
return
(if Rev_SSO then
E : Bits_10;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
E : Bits_10;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : ClusterU_Ref with Address => A'Address, Import;
- RC : Rev_ClusterU_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AACU.Object_Pointer := AACU.To_Pointer (A);
+ RC : constant Rev_AACU.Object_Pointer := Rev_AACU.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
-- --
------------------------------------------------------------------------------
+with System.Address_To_Access_Conversions;
with System.Storage_Elements;
with System.Unsigned_Types;
-- Use maximum possible alignment, given the bit field size, since this
-- will result in the most efficient code possible for the field.
- type Cluster_Ref is access Cluster;
+ package AAC is new Address_To_Access_Conversions (Cluster);
+ -- We convert addresses to access values and dereference them instead of
+ -- directly using overlays in order to work around the implementation of
+ -- the RM 13.3(19) clause, which would pessimize the generated code.
type Rev_Cluster is new Cluster
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_Cluster_Ref is access Rev_Cluster;
+
+ package Rev_AAC is new Address_To_Access_Conversions (Rev_Cluster);
-- The following declarations are for the case where the address
-- passed to GetU_100 or SetU_100 is not guaranteed to be aligned.
type ClusterU is new Cluster;
for ClusterU'Alignment use 1;
- type ClusterU_Ref is access ClusterU;
+ package AACU is new Address_To_Access_Conversions (ClusterU);
type Rev_ClusterU is new ClusterU
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_ClusterU_Ref is access Rev_ClusterU;
+
+ package Rev_AACU is new Address_To_Access_Conversions (Rev_ClusterU);
------------
-- Get_100 --
N : Natural;
Rev_SSO : Boolean) return Bits_100
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
return
(if Rev_SSO then
N : Natural;
Rev_SSO : Boolean) return Bits_100
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : ClusterU_Ref with Address => A'Address, Import;
- RC : Rev_ClusterU_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AACU.Object_Pointer := AACU.To_Pointer (A);
+ RC : constant Rev_AACU.Object_Pointer := Rev_AACU.To_Pointer (A);
+
begin
return
(if Rev_SSO then
E : Bits_100;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
E : Bits_100;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : ClusterU_Ref with Address => A'Address, Import;
- RC : Rev_ClusterU_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AACU.Object_Pointer := AACU.To_Pointer (A);
+ RC : constant Rev_AACU.Object_Pointer := Rev_AACU.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
-- --
------------------------------------------------------------------------------
+with System.Address_To_Access_Conversions;
with System.Storage_Elements;
with System.Unsigned_Types;
-- Use maximum possible alignment, given the bit field size, since this
-- will result in the most efficient code possible for the field.
- type Cluster_Ref is access Cluster;
+ package AAC is new Address_To_Access_Conversions (Cluster);
+ -- We convert addresses to access values and dereference them instead of
+ -- directly using overlays in order to work around the implementation of
+ -- the RM 13.3(19) clause, which would pessimize the generated code.
type Rev_Cluster is new Cluster
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_Cluster_Ref is access Rev_Cluster;
+
+ package Rev_AAC is new Address_To_Access_Conversions (Rev_Cluster);
------------
-- Get_101 --
N : Natural;
Rev_SSO : Boolean) return Bits_101
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
return
(if Rev_SSO then
E : Bits_101;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
-- --
------------------------------------------------------------------------------
+with System.Address_To_Access_Conversions;
with System.Storage_Elements;
with System.Unsigned_Types;
-- Use maximum possible alignment, given the bit field size, since this
-- will result in the most efficient code possible for the field.
- type Cluster_Ref is access Cluster;
+ package AAC is new Address_To_Access_Conversions (Cluster);
+ -- We convert addresses to access values and dereference them instead of
+ -- directly using overlays in order to work around the implementation of
+ -- the RM 13.3(19) clause, which would pessimize the generated code.
type Rev_Cluster is new Cluster
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_Cluster_Ref is access Rev_Cluster;
+
+ package Rev_AAC is new Address_To_Access_Conversions (Rev_Cluster);
-- The following declarations are for the case where the address
-- passed to GetU_102 or SetU_102 is not guaranteed to be aligned.
type ClusterU is new Cluster;
for ClusterU'Alignment use 1;
- type ClusterU_Ref is access ClusterU;
+ package AACU is new Address_To_Access_Conversions (ClusterU);
type Rev_ClusterU is new ClusterU
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_ClusterU_Ref is access Rev_ClusterU;
+
+ package Rev_AACU is new Address_To_Access_Conversions (Rev_ClusterU);
------------
-- Get_102 --
N : Natural;
Rev_SSO : Boolean) return Bits_102
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
return
(if Rev_SSO then
N : Natural;
Rev_SSO : Boolean) return Bits_102
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : ClusterU_Ref with Address => A'Address, Import;
- RC : Rev_ClusterU_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AACU.Object_Pointer := AACU.To_Pointer (A);
+ RC : constant Rev_AACU.Object_Pointer := Rev_AACU.To_Pointer (A);
+
begin
return
(if Rev_SSO then
E : Bits_102;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
E : Bits_102;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : ClusterU_Ref with Address => A'Address, Import;
- RC : Rev_ClusterU_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AACU.Object_Pointer := AACU.To_Pointer (A);
+ RC : constant Rev_AACU.Object_Pointer := Rev_AACU.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
-- --
------------------------------------------------------------------------------
+with System.Address_To_Access_Conversions;
with System.Storage_Elements;
with System.Unsigned_Types;
-- Use maximum possible alignment, given the bit field size, since this
-- will result in the most efficient code possible for the field.
- type Cluster_Ref is access Cluster;
+ package AAC is new Address_To_Access_Conversions (Cluster);
+ -- We convert addresses to access values and dereference them instead of
+ -- directly using overlays in order to work around the implementation of
+ -- the RM 13.3(19) clause, which would pessimize the generated code.
type Rev_Cluster is new Cluster
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_Cluster_Ref is access Rev_Cluster;
+
+ package Rev_AAC is new Address_To_Access_Conversions (Rev_Cluster);
------------
-- Get_103 --
N : Natural;
Rev_SSO : Boolean) return Bits_103
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
return
(if Rev_SSO then
E : Bits_103;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
-- --
------------------------------------------------------------------------------
+with System.Address_To_Access_Conversions;
with System.Storage_Elements;
with System.Unsigned_Types;
-- Use maximum possible alignment, given the bit field size, since this
-- will result in the most efficient code possible for the field.
- type Cluster_Ref is access Cluster;
+ package AAC is new Address_To_Access_Conversions (Cluster);
+ -- We convert addresses to access values and dereference them instead of
+ -- directly using overlays in order to work around the implementation of
+ -- the RM 13.3(19) clause, which would pessimize the generated code.
type Rev_Cluster is new Cluster
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_Cluster_Ref is access Rev_Cluster;
+
+ package Rev_AAC is new Address_To_Access_Conversions (Rev_Cluster);
-- The following declarations are for the case where the address
-- passed to GetU_104 or SetU_104 is not guaranteed to be aligned.
type ClusterU is new Cluster;
for ClusterU'Alignment use 1;
- type ClusterU_Ref is access ClusterU;
+ package AACU is new Address_To_Access_Conversions (ClusterU);
type Rev_ClusterU is new ClusterU
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_ClusterU_Ref is access Rev_ClusterU;
+
+ package Rev_AACU is new Address_To_Access_Conversions (Rev_ClusterU);
------------
-- Get_104 --
N : Natural;
Rev_SSO : Boolean) return Bits_104
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
return
(if Rev_SSO then
N : Natural;
Rev_SSO : Boolean) return Bits_104
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : ClusterU_Ref with Address => A'Address, Import;
- RC : Rev_ClusterU_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AACU.Object_Pointer := AACU.To_Pointer (A);
+ RC : constant Rev_AACU.Object_Pointer := Rev_AACU.To_Pointer (A);
+
begin
return
(if Rev_SSO then
E : Bits_104;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
E : Bits_104;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : ClusterU_Ref with Address => A'Address, Import;
- RC : Rev_ClusterU_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AACU.Object_Pointer := AACU.To_Pointer (A);
+ RC : constant Rev_AACU.Object_Pointer := Rev_AACU.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
-- --
------------------------------------------------------------------------------
+with System.Address_To_Access_Conversions;
with System.Storage_Elements;
with System.Unsigned_Types;
-- Use maximum possible alignment, given the bit field size, since this
-- will result in the most efficient code possible for the field.
- type Cluster_Ref is access Cluster;
+ package AAC is new Address_To_Access_Conversions (Cluster);
+ -- We convert addresses to access values and dereference them instead of
+ -- directly using overlays in order to work around the implementation of
+ -- the RM 13.3(19) clause, which would pessimize the generated code.
type Rev_Cluster is new Cluster
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_Cluster_Ref is access Rev_Cluster;
+
+ package Rev_AAC is new Address_To_Access_Conversions (Rev_Cluster);
------------
-- Get_105 --
N : Natural;
Rev_SSO : Boolean) return Bits_105
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
return
(if Rev_SSO then
E : Bits_105;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
-- --
------------------------------------------------------------------------------
+with System.Address_To_Access_Conversions;
with System.Storage_Elements;
with System.Unsigned_Types;
-- Use maximum possible alignment, given the bit field size, since this
-- will result in the most efficient code possible for the field.
- type Cluster_Ref is access Cluster;
+ package AAC is new Address_To_Access_Conversions (Cluster);
+ -- We convert addresses to access values and dereference them instead of
+ -- directly using overlays in order to work around the implementation of
+ -- the RM 13.3(19) clause, which would pessimize the generated code.
type Rev_Cluster is new Cluster
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_Cluster_Ref is access Rev_Cluster;
+
+ package Rev_AAC is new Address_To_Access_Conversions (Rev_Cluster);
-- The following declarations are for the case where the address
-- passed to GetU_106 or SetU_106 is not guaranteed to be aligned.
type ClusterU is new Cluster;
for ClusterU'Alignment use 1;
- type ClusterU_Ref is access ClusterU;
+ package AACU is new Address_To_Access_Conversions (ClusterU);
type Rev_ClusterU is new ClusterU
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_ClusterU_Ref is access Rev_ClusterU;
+
+ package Rev_AACU is new Address_To_Access_Conversions (Rev_ClusterU);
------------
-- Get_106 --
N : Natural;
Rev_SSO : Boolean) return Bits_106
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
return
(if Rev_SSO then
N : Natural;
Rev_SSO : Boolean) return Bits_106
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : ClusterU_Ref with Address => A'Address, Import;
- RC : Rev_ClusterU_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AACU.Object_Pointer := AACU.To_Pointer (A);
+ RC : constant Rev_AACU.Object_Pointer := Rev_AACU.To_Pointer (A);
+
begin
return
(if Rev_SSO then
E : Bits_106;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
E : Bits_106;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : ClusterU_Ref with Address => A'Address, Import;
- RC : Rev_ClusterU_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AACU.Object_Pointer := AACU.To_Pointer (A);
+ RC : constant Rev_AACU.Object_Pointer := Rev_AACU.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
-- --
------------------------------------------------------------------------------
+with System.Address_To_Access_Conversions;
with System.Storage_Elements;
with System.Unsigned_Types;
-- Use maximum possible alignment, given the bit field size, since this
-- will result in the most efficient code possible for the field.
- type Cluster_Ref is access Cluster;
+ package AAC is new Address_To_Access_Conversions (Cluster);
+ -- We convert addresses to access values and dereference them instead of
+ -- directly using overlays in order to work around the implementation of
+ -- the RM 13.3(19) clause, which would pessimize the generated code.
type Rev_Cluster is new Cluster
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_Cluster_Ref is access Rev_Cluster;
+
+ package Rev_AAC is new Address_To_Access_Conversions (Rev_Cluster);
------------
-- Get_107 --
N : Natural;
Rev_SSO : Boolean) return Bits_107
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
return
(if Rev_SSO then
E : Bits_107;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
-- --
------------------------------------------------------------------------------
+with System.Address_To_Access_Conversions;
with System.Storage_Elements;
with System.Unsigned_Types;
-- Use maximum possible alignment, given the bit field size, since this
-- will result in the most efficient code possible for the field.
- type Cluster_Ref is access Cluster;
+ package AAC is new Address_To_Access_Conversions (Cluster);
+ -- We convert addresses to access values and dereference them instead of
+ -- directly using overlays in order to work around the implementation of
+ -- the RM 13.3(19) clause, which would pessimize the generated code.
type Rev_Cluster is new Cluster
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_Cluster_Ref is access Rev_Cluster;
+
+ package Rev_AAC is new Address_To_Access_Conversions (Rev_Cluster);
-- The following declarations are for the case where the address
-- passed to GetU_108 or SetU_108 is not guaranteed to be aligned.
type ClusterU is new Cluster;
for ClusterU'Alignment use 1;
- type ClusterU_Ref is access ClusterU;
+ package AACU is new Address_To_Access_Conversions (ClusterU);
type Rev_ClusterU is new ClusterU
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_ClusterU_Ref is access Rev_ClusterU;
+
+ package Rev_AACU is new Address_To_Access_Conversions (Rev_ClusterU);
------------
-- Get_108 --
N : Natural;
Rev_SSO : Boolean) return Bits_108
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
return
(if Rev_SSO then
N : Natural;
Rev_SSO : Boolean) return Bits_108
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : ClusterU_Ref with Address => A'Address, Import;
- RC : Rev_ClusterU_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AACU.Object_Pointer := AACU.To_Pointer (A);
+ RC : constant Rev_AACU.Object_Pointer := Rev_AACU.To_Pointer (A);
+
begin
return
(if Rev_SSO then
E : Bits_108;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
E : Bits_108;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : ClusterU_Ref with Address => A'Address, Import;
- RC : Rev_ClusterU_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AACU.Object_Pointer := AACU.To_Pointer (A);
+ RC : constant Rev_AACU.Object_Pointer := Rev_AACU.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
-- --
------------------------------------------------------------------------------
+with System.Address_To_Access_Conversions;
with System.Storage_Elements;
with System.Unsigned_Types;
-- Use maximum possible alignment, given the bit field size, since this
-- will result in the most efficient code possible for the field.
- type Cluster_Ref is access Cluster;
+ package AAC is new Address_To_Access_Conversions (Cluster);
+ -- We convert addresses to access values and dereference them instead of
+ -- directly using overlays in order to work around the implementation of
+ -- the RM 13.3(19) clause, which would pessimize the generated code.
type Rev_Cluster is new Cluster
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_Cluster_Ref is access Rev_Cluster;
+
+ package Rev_AAC is new Address_To_Access_Conversions (Rev_Cluster);
------------
-- Get_109 --
N : Natural;
Rev_SSO : Boolean) return Bits_109
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
return
(if Rev_SSO then
E : Bits_109;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
-- --
------------------------------------------------------------------------------
+with System.Address_To_Access_Conversions;
with System.Storage_Elements;
with System.Unsigned_Types;
-- Use maximum possible alignment, given the bit field size, since this
-- will result in the most efficient code possible for the field.
- type Cluster_Ref is access Cluster;
+ package AAC is new Address_To_Access_Conversions (Cluster);
+ -- We convert addresses to access values and dereference them instead of
+ -- directly using overlays in order to work around the implementation of
+ -- the RM 13.3(19) clause, which would pessimize the generated code.
type Rev_Cluster is new Cluster
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_Cluster_Ref is access Rev_Cluster;
+
+ package Rev_AAC is new Address_To_Access_Conversions (Rev_Cluster);
------------
-- Get_11 --
N : Natural;
Rev_SSO : Boolean) return Bits_11
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
return
(if Rev_SSO then
E : Bits_11;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
-- --
------------------------------------------------------------------------------
+with System.Address_To_Access_Conversions;
with System.Storage_Elements;
with System.Unsigned_Types;
-- Use maximum possible alignment, given the bit field size, since this
-- will result in the most efficient code possible for the field.
- type Cluster_Ref is access Cluster;
+ package AAC is new Address_To_Access_Conversions (Cluster);
+ -- We convert addresses to access values and dereference them instead of
+ -- directly using overlays in order to work around the implementation of
+ -- the RM 13.3(19) clause, which would pessimize the generated code.
type Rev_Cluster is new Cluster
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_Cluster_Ref is access Rev_Cluster;
+
+ package Rev_AAC is new Address_To_Access_Conversions (Rev_Cluster);
-- The following declarations are for the case where the address
-- passed to GetU_110 or SetU_110 is not guaranteed to be aligned.
type ClusterU is new Cluster;
for ClusterU'Alignment use 1;
- type ClusterU_Ref is access ClusterU;
+ package AACU is new Address_To_Access_Conversions (ClusterU);
type Rev_ClusterU is new ClusterU
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_ClusterU_Ref is access Rev_ClusterU;
+
+ package Rev_AACU is new Address_To_Access_Conversions (Rev_ClusterU);
------------
-- Get_110 --
N : Natural;
Rev_SSO : Boolean) return Bits_110
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
return
(if Rev_SSO then
N : Natural;
Rev_SSO : Boolean) return Bits_110
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : ClusterU_Ref with Address => A'Address, Import;
- RC : Rev_ClusterU_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AACU.Object_Pointer := AACU.To_Pointer (A);
+ RC : constant Rev_AACU.Object_Pointer := Rev_AACU.To_Pointer (A);
+
begin
return
(if Rev_SSO then
E : Bits_110;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
E : Bits_110;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : ClusterU_Ref with Address => A'Address, Import;
- RC : Rev_ClusterU_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AACU.Object_Pointer := AACU.To_Pointer (A);
+ RC : constant Rev_AACU.Object_Pointer := Rev_AACU.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
-- --
------------------------------------------------------------------------------
+with System.Address_To_Access_Conversions;
with System.Storage_Elements;
with System.Unsigned_Types;
-- Use maximum possible alignment, given the bit field size, since this
-- will result in the most efficient code possible for the field.
- type Cluster_Ref is access Cluster;
+ package AAC is new Address_To_Access_Conversions (Cluster);
+ -- We convert addresses to access values and dereference them instead of
+ -- directly using overlays in order to work around the implementation of
+ -- the RM 13.3(19) clause, which would pessimize the generated code.
type Rev_Cluster is new Cluster
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_Cluster_Ref is access Rev_Cluster;
+
+ package Rev_AAC is new Address_To_Access_Conversions (Rev_Cluster);
------------
-- Get_111 --
N : Natural;
Rev_SSO : Boolean) return Bits_111
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
return
(if Rev_SSO then
E : Bits_111;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
-- --
------------------------------------------------------------------------------
+with System.Address_To_Access_Conversions;
with System.Storage_Elements;
with System.Unsigned_Types;
-- Use maximum possible alignment, given the bit field size, since this
-- will result in the most efficient code possible for the field.
- type Cluster_Ref is access Cluster;
+ package AAC is new Address_To_Access_Conversions (Cluster);
+ -- We convert addresses to access values and dereference them instead of
+ -- directly using overlays in order to work around the implementation of
+ -- the RM 13.3(19) clause, which would pessimize the generated code.
type Rev_Cluster is new Cluster
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_Cluster_Ref is access Rev_Cluster;
+
+ package Rev_AAC is new Address_To_Access_Conversions (Rev_Cluster);
-- The following declarations are for the case where the address
-- passed to GetU_112 or SetU_112 is not guaranteed to be aligned.
type ClusterU is new Cluster;
for ClusterU'Alignment use 1;
- type ClusterU_Ref is access ClusterU;
+ package AACU is new Address_To_Access_Conversions (ClusterU);
type Rev_ClusterU is new ClusterU
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_ClusterU_Ref is access Rev_ClusterU;
+
+ package Rev_AACU is new Address_To_Access_Conversions (Rev_ClusterU);
------------
-- Get_112 --
N : Natural;
Rev_SSO : Boolean) return Bits_112
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
return
(if Rev_SSO then
N : Natural;
Rev_SSO : Boolean) return Bits_112
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : ClusterU_Ref with Address => A'Address, Import;
- RC : Rev_ClusterU_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AACU.Object_Pointer := AACU.To_Pointer (A);
+ RC : constant Rev_AACU.Object_Pointer := Rev_AACU.To_Pointer (A);
+
begin
return
(if Rev_SSO then
E : Bits_112;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
E : Bits_112;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : ClusterU_Ref with Address => A'Address, Import;
- RC : Rev_ClusterU_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AACU.Object_Pointer := AACU.To_Pointer (A);
+ RC : constant Rev_AACU.Object_Pointer := Rev_AACU.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
-- --
------------------------------------------------------------------------------
+with System.Address_To_Access_Conversions;
with System.Storage_Elements;
with System.Unsigned_Types;
-- Use maximum possible alignment, given the bit field size, since this
-- will result in the most efficient code possible for the field.
- type Cluster_Ref is access Cluster;
+ package AAC is new Address_To_Access_Conversions (Cluster);
+ -- We convert addresses to access values and dereference them instead of
+ -- directly using overlays in order to work around the implementation of
+ -- the RM 13.3(19) clause, which would pessimize the generated code.
type Rev_Cluster is new Cluster
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_Cluster_Ref is access Rev_Cluster;
+
+ package Rev_AAC is new Address_To_Access_Conversions (Rev_Cluster);
------------
-- Get_113 --
N : Natural;
Rev_SSO : Boolean) return Bits_113
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
return
(if Rev_SSO then
E : Bits_113;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
-- --
------------------------------------------------------------------------------
+with System.Address_To_Access_Conversions;
with System.Storage_Elements;
with System.Unsigned_Types;
-- Use maximum possible alignment, given the bit field size, since this
-- will result in the most efficient code possible for the field.
- type Cluster_Ref is access Cluster;
+ package AAC is new Address_To_Access_Conversions (Cluster);
+ -- We convert addresses to access values and dereference them instead of
+ -- directly using overlays in order to work around the implementation of
+ -- the RM 13.3(19) clause, which would pessimize the generated code.
type Rev_Cluster is new Cluster
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_Cluster_Ref is access Rev_Cluster;
+
+ package Rev_AAC is new Address_To_Access_Conversions (Rev_Cluster);
-- The following declarations are for the case where the address
-- passed to GetU_114 or SetU_114 is not guaranteed to be aligned.
type ClusterU is new Cluster;
for ClusterU'Alignment use 1;
- type ClusterU_Ref is access ClusterU;
+ package AACU is new Address_To_Access_Conversions (ClusterU);
type Rev_ClusterU is new ClusterU
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_ClusterU_Ref is access Rev_ClusterU;
+
+ package Rev_AACU is new Address_To_Access_Conversions (Rev_ClusterU);
------------
-- Get_114 --
N : Natural;
Rev_SSO : Boolean) return Bits_114
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
return
(if Rev_SSO then
N : Natural;
Rev_SSO : Boolean) return Bits_114
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : ClusterU_Ref with Address => A'Address, Import;
- RC : Rev_ClusterU_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AACU.Object_Pointer := AACU.To_Pointer (A);
+ RC : constant Rev_AACU.Object_Pointer := Rev_AACU.To_Pointer (A);
+
begin
return
(if Rev_SSO then
E : Bits_114;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
E : Bits_114;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : ClusterU_Ref with Address => A'Address, Import;
- RC : Rev_ClusterU_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AACU.Object_Pointer := AACU.To_Pointer (A);
+ RC : constant Rev_AACU.Object_Pointer := Rev_AACU.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
-- --
------------------------------------------------------------------------------
+with System.Address_To_Access_Conversions;
with System.Storage_Elements;
with System.Unsigned_Types;
-- Use maximum possible alignment, given the bit field size, since this
-- will result in the most efficient code possible for the field.
- type Cluster_Ref is access Cluster;
+ package AAC is new Address_To_Access_Conversions (Cluster);
+ -- We convert addresses to access values and dereference them instead of
+ -- directly using overlays in order to work around the implementation of
+ -- the RM 13.3(19) clause, which would pessimize the generated code.
type Rev_Cluster is new Cluster
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_Cluster_Ref is access Rev_Cluster;
+
+ package Rev_AAC is new Address_To_Access_Conversions (Rev_Cluster);
------------
-- Get_115 --
N : Natural;
Rev_SSO : Boolean) return Bits_115
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
return
(if Rev_SSO then
E : Bits_115;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
-- --
------------------------------------------------------------------------------
+with System.Address_To_Access_Conversions;
with System.Storage_Elements;
with System.Unsigned_Types;
-- Use maximum possible alignment, given the bit field size, since this
-- will result in the most efficient code possible for the field.
- type Cluster_Ref is access Cluster;
+ package AAC is new Address_To_Access_Conversions (Cluster);
+ -- We convert addresses to access values and dereference them instead of
+ -- directly using overlays in order to work around the implementation of
+ -- the RM 13.3(19) clause, which would pessimize the generated code.
type Rev_Cluster is new Cluster
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_Cluster_Ref is access Rev_Cluster;
+
+ package Rev_AAC is new Address_To_Access_Conversions (Rev_Cluster);
-- The following declarations are for the case where the address
-- passed to GetU_116 or SetU_116 is not guaranteed to be aligned.
type ClusterU is new Cluster;
for ClusterU'Alignment use 1;
- type ClusterU_Ref is access ClusterU;
+ package AACU is new Address_To_Access_Conversions (ClusterU);
type Rev_ClusterU is new ClusterU
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_ClusterU_Ref is access Rev_ClusterU;
+
+ package Rev_AACU is new Address_To_Access_Conversions (Rev_ClusterU);
------------
-- Get_116 --
N : Natural;
Rev_SSO : Boolean) return Bits_116
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
return
(if Rev_SSO then
N : Natural;
Rev_SSO : Boolean) return Bits_116
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : ClusterU_Ref with Address => A'Address, Import;
- RC : Rev_ClusterU_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AACU.Object_Pointer := AACU.To_Pointer (A);
+ RC : constant Rev_AACU.Object_Pointer := Rev_AACU.To_Pointer (A);
+
begin
return
(if Rev_SSO then
E : Bits_116;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
E : Bits_116;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : ClusterU_Ref with Address => A'Address, Import;
- RC : Rev_ClusterU_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AACU.Object_Pointer := AACU.To_Pointer (A);
+ RC : constant Rev_AACU.Object_Pointer := Rev_AACU.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
-- --
------------------------------------------------------------------------------
+with System.Address_To_Access_Conversions;
with System.Storage_Elements;
with System.Unsigned_Types;
-- Use maximum possible alignment, given the bit field size, since this
-- will result in the most efficient code possible for the field.
- type Cluster_Ref is access Cluster;
+ package AAC is new Address_To_Access_Conversions (Cluster);
+ -- We convert addresses to access values and dereference them instead of
+ -- directly using overlays in order to work around the implementation of
+ -- the RM 13.3(19) clause, which would pessimize the generated code.
type Rev_Cluster is new Cluster
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_Cluster_Ref is access Rev_Cluster;
+
+ package Rev_AAC is new Address_To_Access_Conversions (Rev_Cluster);
------------
-- Get_117 --
N : Natural;
Rev_SSO : Boolean) return Bits_117
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
return
(if Rev_SSO then
E : Bits_117;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
-- --
------------------------------------------------------------------------------
+with System.Address_To_Access_Conversions;
with System.Storage_Elements;
with System.Unsigned_Types;
-- Use maximum possible alignment, given the bit field size, since this
-- will result in the most efficient code possible for the field.
- type Cluster_Ref is access Cluster;
+ package AAC is new Address_To_Access_Conversions (Cluster);
+ -- We convert addresses to access values and dereference them instead of
+ -- directly using overlays in order to work around the implementation of
+ -- the RM 13.3(19) clause, which would pessimize the generated code.
type Rev_Cluster is new Cluster
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_Cluster_Ref is access Rev_Cluster;
+
+ package Rev_AAC is new Address_To_Access_Conversions (Rev_Cluster);
-- The following declarations are for the case where the address
-- passed to GetU_118 or SetU_118 is not guaranteed to be aligned.
type ClusterU is new Cluster;
for ClusterU'Alignment use 1;
- type ClusterU_Ref is access ClusterU;
+ package AACU is new Address_To_Access_Conversions (ClusterU);
type Rev_ClusterU is new ClusterU
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_ClusterU_Ref is access Rev_ClusterU;
+
+ package Rev_AACU is new Address_To_Access_Conversions (Rev_ClusterU);
------------
-- Get_118 --
N : Natural;
Rev_SSO : Boolean) return Bits_118
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
return
(if Rev_SSO then
N : Natural;
Rev_SSO : Boolean) return Bits_118
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : ClusterU_Ref with Address => A'Address, Import;
- RC : Rev_ClusterU_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AACU.Object_Pointer := AACU.To_Pointer (A);
+ RC : constant Rev_AACU.Object_Pointer := Rev_AACU.To_Pointer (A);
+
begin
return
(if Rev_SSO then
E : Bits_118;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
E : Bits_118;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : ClusterU_Ref with Address => A'Address, Import;
- RC : Rev_ClusterU_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AACU.Object_Pointer := AACU.To_Pointer (A);
+ RC : constant Rev_AACU.Object_Pointer := Rev_AACU.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
-- --
------------------------------------------------------------------------------
+with System.Address_To_Access_Conversions;
with System.Storage_Elements;
with System.Unsigned_Types;
-- Use maximum possible alignment, given the bit field size, since this
-- will result in the most efficient code possible for the field.
- type Cluster_Ref is access Cluster;
+ package AAC is new Address_To_Access_Conversions (Cluster);
+ -- We convert addresses to access values and dereference them instead of
+ -- directly using overlays in order to work around the implementation of
+ -- the RM 13.3(19) clause, which would pessimize the generated code.
type Rev_Cluster is new Cluster
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_Cluster_Ref is access Rev_Cluster;
+
+ package Rev_AAC is new Address_To_Access_Conversions (Rev_Cluster);
------------
-- Get_119 --
N : Natural;
Rev_SSO : Boolean) return Bits_119
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
return
(if Rev_SSO then
E : Bits_119;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
-- --
------------------------------------------------------------------------------
+with System.Address_To_Access_Conversions;
with System.Storage_Elements;
with System.Unsigned_Types;
-- Use maximum possible alignment, given the bit field size, since this
-- will result in the most efficient code possible for the field.
- type Cluster_Ref is access Cluster;
+ package AAC is new Address_To_Access_Conversions (Cluster);
+ -- We convert addresses to access values and dereference them instead of
+ -- directly using overlays in order to work around the implementation of
+ -- the RM 13.3(19) clause, which would pessimize the generated code.
type Rev_Cluster is new Cluster
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_Cluster_Ref is access Rev_Cluster;
+
+ package Rev_AAC is new Address_To_Access_Conversions (Rev_Cluster);
-- The following declarations are for the case where the address
-- passed to GetU_12 or SetU_12 is not guaranteed to be aligned.
type ClusterU is new Cluster;
for ClusterU'Alignment use 1;
- type ClusterU_Ref is access ClusterU;
+ package AACU is new Address_To_Access_Conversions (ClusterU);
type Rev_ClusterU is new ClusterU
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_ClusterU_Ref is access Rev_ClusterU;
+
+ package Rev_AACU is new Address_To_Access_Conversions (Rev_ClusterU);
------------
-- Get_12 --
N : Natural;
Rev_SSO : Boolean) return Bits_12
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
return
(if Rev_SSO then
N : Natural;
Rev_SSO : Boolean) return Bits_12
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : ClusterU_Ref with Address => A'Address, Import;
- RC : Rev_ClusterU_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AACU.Object_Pointer := AACU.To_Pointer (A);
+ RC : constant Rev_AACU.Object_Pointer := Rev_AACU.To_Pointer (A);
+
begin
return
(if Rev_SSO then
E : Bits_12;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
E : Bits_12;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : ClusterU_Ref with Address => A'Address, Import;
- RC : Rev_ClusterU_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AACU.Object_Pointer := AACU.To_Pointer (A);
+ RC : constant Rev_AACU.Object_Pointer := Rev_AACU.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
-- --
------------------------------------------------------------------------------
+with System.Address_To_Access_Conversions;
with System.Storage_Elements;
with System.Unsigned_Types;
-- Use maximum possible alignment, given the bit field size, since this
-- will result in the most efficient code possible for the field.
- type Cluster_Ref is access Cluster;
+ package AAC is new Address_To_Access_Conversions (Cluster);
+ -- We convert addresses to access values and dereference them instead of
+ -- directly using overlays in order to work around the implementation of
+ -- the RM 13.3(19) clause, which would pessimize the generated code.
type Rev_Cluster is new Cluster
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_Cluster_Ref is access Rev_Cluster;
+
+ package Rev_AAC is new Address_To_Access_Conversions (Rev_Cluster);
-- The following declarations are for the case where the address
-- passed to GetU_120 or SetU_120 is not guaranteed to be aligned.
type ClusterU is new Cluster;
for ClusterU'Alignment use 1;
- type ClusterU_Ref is access ClusterU;
+ package AACU is new Address_To_Access_Conversions (ClusterU);
type Rev_ClusterU is new ClusterU
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_ClusterU_Ref is access Rev_ClusterU;
+
+ package Rev_AACU is new Address_To_Access_Conversions (Rev_ClusterU);
------------
-- Get_120 --
N : Natural;
Rev_SSO : Boolean) return Bits_120
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
return
(if Rev_SSO then
N : Natural;
Rev_SSO : Boolean) return Bits_120
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : ClusterU_Ref with Address => A'Address, Import;
- RC : Rev_ClusterU_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AACU.Object_Pointer := AACU.To_Pointer (A);
+ RC : constant Rev_AACU.Object_Pointer := Rev_AACU.To_Pointer (A);
+
begin
return
(if Rev_SSO then
E : Bits_120;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
E : Bits_120;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : ClusterU_Ref with Address => A'Address, Import;
- RC : Rev_ClusterU_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AACU.Object_Pointer := AACU.To_Pointer (A);
+ RC : constant Rev_AACU.Object_Pointer := Rev_AACU.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
-- --
------------------------------------------------------------------------------
+with System.Address_To_Access_Conversions;
with System.Storage_Elements;
with System.Unsigned_Types;
-- Use maximum possible alignment, given the bit field size, since this
-- will result in the most efficient code possible for the field.
- type Cluster_Ref is access Cluster;
+ package AAC is new Address_To_Access_Conversions (Cluster);
+ -- We convert addresses to access values and dereference them instead of
+ -- directly using overlays in order to work around the implementation of
+ -- the RM 13.3(19) clause, which would pessimize the generated code.
type Rev_Cluster is new Cluster
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_Cluster_Ref is access Rev_Cluster;
+
+ package Rev_AAC is new Address_To_Access_Conversions (Rev_Cluster);
------------
-- Get_121 --
N : Natural;
Rev_SSO : Boolean) return Bits_121
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
return
(if Rev_SSO then
E : Bits_121;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
-- --
------------------------------------------------------------------------------
+with System.Address_To_Access_Conversions;
with System.Storage_Elements;
with System.Unsigned_Types;
-- Use maximum possible alignment, given the bit field size, since this
-- will result in the most efficient code possible for the field.
- type Cluster_Ref is access Cluster;
+ package AAC is new Address_To_Access_Conversions (Cluster);
+ -- We convert addresses to access values and dereference them instead of
+ -- directly using overlays in order to work around the implementation of
+ -- the RM 13.3(19) clause, which would pessimize the generated code.
type Rev_Cluster is new Cluster
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_Cluster_Ref is access Rev_Cluster;
+
+ package Rev_AAC is new Address_To_Access_Conversions (Rev_Cluster);
-- The following declarations are for the case where the address
-- passed to GetU_122 or SetU_122 is not guaranteed to be aligned.
type ClusterU is new Cluster;
for ClusterU'Alignment use 1;
- type ClusterU_Ref is access ClusterU;
+ package AACU is new Address_To_Access_Conversions (ClusterU);
type Rev_ClusterU is new ClusterU
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_ClusterU_Ref is access Rev_ClusterU;
+
+ package Rev_AACU is new Address_To_Access_Conversions (Rev_ClusterU);
------------
-- Get_122 --
N : Natural;
Rev_SSO : Boolean) return Bits_122
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
return
(if Rev_SSO then
N : Natural;
Rev_SSO : Boolean) return Bits_122
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : ClusterU_Ref with Address => A'Address, Import;
- RC : Rev_ClusterU_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AACU.Object_Pointer := AACU.To_Pointer (A);
+ RC : constant Rev_AACU.Object_Pointer := Rev_AACU.To_Pointer (A);
+
begin
return
(if Rev_SSO then
E : Bits_122;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
E : Bits_122;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : ClusterU_Ref with Address => A'Address, Import;
- RC : Rev_ClusterU_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AACU.Object_Pointer := AACU.To_Pointer (A);
+ RC : constant Rev_AACU.Object_Pointer := Rev_AACU.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
-- --
------------------------------------------------------------------------------
+with System.Address_To_Access_Conversions;
with System.Storage_Elements;
with System.Unsigned_Types;
-- Use maximum possible alignment, given the bit field size, since this
-- will result in the most efficient code possible for the field.
- type Cluster_Ref is access Cluster;
+ package AAC is new Address_To_Access_Conversions (Cluster);
+ -- We convert addresses to access values and dereference them instead of
+ -- directly using overlays in order to work around the implementation of
+ -- the RM 13.3(19) clause, which would pessimize the generated code.
type Rev_Cluster is new Cluster
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_Cluster_Ref is access Rev_Cluster;
+
+ package Rev_AAC is new Address_To_Access_Conversions (Rev_Cluster);
------------
-- Get_123 --
N : Natural;
Rev_SSO : Boolean) return Bits_123
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
return
(if Rev_SSO then
E : Bits_123;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
-- --
------------------------------------------------------------------------------
+with System.Address_To_Access_Conversions;
with System.Storage_Elements;
with System.Unsigned_Types;
-- Use maximum possible alignment, given the bit field size, since this
-- will result in the most efficient code possible for the field.
- type Cluster_Ref is access Cluster;
+ package AAC is new Address_To_Access_Conversions (Cluster);
+ -- We convert addresses to access values and dereference them instead of
+ -- directly using overlays in order to work around the implementation of
+ -- the RM 13.3(19) clause, which would pessimize the generated code.
type Rev_Cluster is new Cluster
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_Cluster_Ref is access Rev_Cluster;
+
+ package Rev_AAC is new Address_To_Access_Conversions (Rev_Cluster);
-- The following declarations are for the case where the address
-- passed to GetU_124 or SetU_124 is not guaranteed to be aligned.
type ClusterU is new Cluster;
for ClusterU'Alignment use 1;
- type ClusterU_Ref is access ClusterU;
+ package AACU is new Address_To_Access_Conversions (ClusterU);
type Rev_ClusterU is new ClusterU
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_ClusterU_Ref is access Rev_ClusterU;
+
+ package Rev_AACU is new Address_To_Access_Conversions (Rev_ClusterU);
------------
-- Get_124 --
N : Natural;
Rev_SSO : Boolean) return Bits_124
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
return
(if Rev_SSO then
N : Natural;
Rev_SSO : Boolean) return Bits_124
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : ClusterU_Ref with Address => A'Address, Import;
- RC : Rev_ClusterU_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AACU.Object_Pointer := AACU.To_Pointer (A);
+ RC : constant Rev_AACU.Object_Pointer := Rev_AACU.To_Pointer (A);
+
begin
return
(if Rev_SSO then
E : Bits_124;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
E : Bits_124;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : ClusterU_Ref with Address => A'Address, Import;
- RC : Rev_ClusterU_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AACU.Object_Pointer := AACU.To_Pointer (A);
+ RC : constant Rev_AACU.Object_Pointer := Rev_AACU.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
-- --
------------------------------------------------------------------------------
+with System.Address_To_Access_Conversions;
with System.Storage_Elements;
with System.Unsigned_Types;
-- Use maximum possible alignment, given the bit field size, since this
-- will result in the most efficient code possible for the field.
- type Cluster_Ref is access Cluster;
+ package AAC is new Address_To_Access_Conversions (Cluster);
+ -- We convert addresses to access values and dereference them instead of
+ -- directly using overlays in order to work around the implementation of
+ -- the RM 13.3(19) clause, which would pessimize the generated code.
type Rev_Cluster is new Cluster
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_Cluster_Ref is access Rev_Cluster;
+
+ package Rev_AAC is new Address_To_Access_Conversions (Rev_Cluster);
------------
-- Get_125 --
N : Natural;
Rev_SSO : Boolean) return Bits_125
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
return
(if Rev_SSO then
E : Bits_125;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
-- --
------------------------------------------------------------------------------
+with System.Address_To_Access_Conversions;
with System.Storage_Elements;
with System.Unsigned_Types;
-- Use maximum possible alignment, given the bit field size, since this
-- will result in the most efficient code possible for the field.
- type Cluster_Ref is access Cluster;
+ package AAC is new Address_To_Access_Conversions (Cluster);
+ -- We convert addresses to access values and dereference them instead of
+ -- directly using overlays in order to work around the implementation of
+ -- the RM 13.3(19) clause, which would pessimize the generated code.
type Rev_Cluster is new Cluster
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_Cluster_Ref is access Rev_Cluster;
+
+ package Rev_AAC is new Address_To_Access_Conversions (Rev_Cluster);
-- The following declarations are for the case where the address
-- passed to GetU_126 or SetU_126 is not guaranteed to be aligned.
type ClusterU is new Cluster;
for ClusterU'Alignment use 1;
- type ClusterU_Ref is access ClusterU;
+ package AACU is new Address_To_Access_Conversions (ClusterU);
type Rev_ClusterU is new ClusterU
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_ClusterU_Ref is access Rev_ClusterU;
+
+ package Rev_AACU is new Address_To_Access_Conversions (Rev_ClusterU);
------------
-- Get_126 --
N : Natural;
Rev_SSO : Boolean) return Bits_126
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
return
(if Rev_SSO then
N : Natural;
Rev_SSO : Boolean) return Bits_126
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : ClusterU_Ref with Address => A'Address, Import;
- RC : Rev_ClusterU_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AACU.Object_Pointer := AACU.To_Pointer (A);
+ RC : constant Rev_AACU.Object_Pointer := Rev_AACU.To_Pointer (A);
+
begin
return
(if Rev_SSO then
E : Bits_126;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
E : Bits_126;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : ClusterU_Ref with Address => A'Address, Import;
- RC : Rev_ClusterU_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AACU.Object_Pointer := AACU.To_Pointer (A);
+ RC : constant Rev_AACU.Object_Pointer := Rev_AACU.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
-- --
------------------------------------------------------------------------------
+with System.Address_To_Access_Conversions;
with System.Storage_Elements;
with System.Unsigned_Types;
-- Use maximum possible alignment, given the bit field size, since this
-- will result in the most efficient code possible for the field.
- type Cluster_Ref is access Cluster;
+ package AAC is new Address_To_Access_Conversions (Cluster);
+ -- We convert addresses to access values and dereference them instead of
+ -- directly using overlays in order to work around the implementation of
+ -- the RM 13.3(19) clause, which would pessimize the generated code.
type Rev_Cluster is new Cluster
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_Cluster_Ref is access Rev_Cluster;
+
+ package Rev_AAC is new Address_To_Access_Conversions (Rev_Cluster);
------------
-- Get_127 --
N : Natural;
Rev_SSO : Boolean) return Bits_127
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
return
(if Rev_SSO then
E : Bits_127;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
-- --
------------------------------------------------------------------------------
+with System.Address_To_Access_Conversions;
with System.Storage_Elements;
with System.Unsigned_Types;
-- Use maximum possible alignment, given the bit field size, since this
-- will result in the most efficient code possible for the field.
- type Cluster_Ref is access Cluster;
+ package AAC is new Address_To_Access_Conversions (Cluster);
+ -- We convert addresses to access values and dereference them instead of
+ -- directly using overlays in order to work around the implementation of
+ -- the RM 13.3(19) clause, which would pessimize the generated code.
type Rev_Cluster is new Cluster
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_Cluster_Ref is access Rev_Cluster;
+
+ package Rev_AAC is new Address_To_Access_Conversions (Rev_Cluster);
------------
-- Get_13 --
N : Natural;
Rev_SSO : Boolean) return Bits_13
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
return
(if Rev_SSO then
E : Bits_13;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
-- --
------------------------------------------------------------------------------
+with System.Address_To_Access_Conversions;
with System.Storage_Elements;
with System.Unsigned_Types;
-- Use maximum possible alignment, given the bit field size, since this
-- will result in the most efficient code possible for the field.
- type Cluster_Ref is access Cluster;
+ package AAC is new Address_To_Access_Conversions (Cluster);
+ -- We convert addresses to access values and dereference them instead of
+ -- directly using overlays in order to work around the implementation of
+ -- the RM 13.3(19) clause, which would pessimize the generated code.
type Rev_Cluster is new Cluster
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_Cluster_Ref is access Rev_Cluster;
+
+ package Rev_AAC is new Address_To_Access_Conversions (Rev_Cluster);
-- The following declarations are for the case where the address
-- passed to GetU_14 or SetU_14 is not guaranteed to be aligned.
type ClusterU is new Cluster;
for ClusterU'Alignment use 1;
- type ClusterU_Ref is access ClusterU;
+ package AACU is new Address_To_Access_Conversions (ClusterU);
type Rev_ClusterU is new ClusterU
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_ClusterU_Ref is access Rev_ClusterU;
+
+ package Rev_AACU is new Address_To_Access_Conversions (Rev_ClusterU);
------------
-- Get_14 --
N : Natural;
Rev_SSO : Boolean) return Bits_14
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
return
(if Rev_SSO then
N : Natural;
Rev_SSO : Boolean) return Bits_14
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : ClusterU_Ref with Address => A'Address, Import;
- RC : Rev_ClusterU_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AACU.Object_Pointer := AACU.To_Pointer (A);
+ RC : constant Rev_AACU.Object_Pointer := Rev_AACU.To_Pointer (A);
+
begin
return
(if Rev_SSO then
E : Bits_14;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
E : Bits_14;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : ClusterU_Ref with Address => A'Address, Import;
- RC : Rev_ClusterU_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AACU.Object_Pointer := AACU.To_Pointer (A);
+ RC : constant Rev_AACU.Object_Pointer := Rev_AACU.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
-- --
------------------------------------------------------------------------------
+with System.Address_To_Access_Conversions;
with System.Storage_Elements;
with System.Unsigned_Types;
-- Use maximum possible alignment, given the bit field size, since this
-- will result in the most efficient code possible for the field.
- type Cluster_Ref is access Cluster;
+ package AAC is new Address_To_Access_Conversions (Cluster);
+ -- We convert addresses to access values and dereference them instead of
+ -- directly using overlays in order to work around the implementation of
+ -- the RM 13.3(19) clause, which would pessimize the generated code.
type Rev_Cluster is new Cluster
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_Cluster_Ref is access Rev_Cluster;
+
+ package Rev_AAC is new Address_To_Access_Conversions (Rev_Cluster);
------------
-- Get_15 --
N : Natural;
Rev_SSO : Boolean) return Bits_15
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
return
(if Rev_SSO then
E : Bits_15;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
-- --
------------------------------------------------------------------------------
+with System.Address_To_Access_Conversions;
with System.Storage_Elements;
with System.Unsigned_Types;
-- Use maximum possible alignment, given the bit field size, since this
-- will result in the most efficient code possible for the field.
- type Cluster_Ref is access Cluster;
+ package AAC is new Address_To_Access_Conversions (Cluster);
+ -- We convert addresses to access values and dereference them instead of
+ -- directly using overlays in order to work around the implementation of
+ -- the RM 13.3(19) clause, which would pessimize the generated code.
type Rev_Cluster is new Cluster
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_Cluster_Ref is access Rev_Cluster;
+
+ package Rev_AAC is new Address_To_Access_Conversions (Rev_Cluster);
------------
-- Get_17 --
N : Natural;
Rev_SSO : Boolean) return Bits_17
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
return
(if Rev_SSO then
E : Bits_17;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
-- --
------------------------------------------------------------------------------
+with System.Address_To_Access_Conversions;
with System.Storage_Elements;
with System.Unsigned_Types;
-- Use maximum possible alignment, given the bit field size, since this
-- will result in the most efficient code possible for the field.
- type Cluster_Ref is access Cluster;
+ package AAC is new Address_To_Access_Conversions (Cluster);
+ -- We convert addresses to access values and dereference them instead of
+ -- directly using overlays in order to work around the implementation of
+ -- the RM 13.3(19) clause, which would pessimize the generated code.
type Rev_Cluster is new Cluster
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_Cluster_Ref is access Rev_Cluster;
+
+ package Rev_AAC is new Address_To_Access_Conversions (Rev_Cluster);
-- The following declarations are for the case where the address
-- passed to GetU_18 or SetU_18 is not guaranteed to be aligned.
type ClusterU is new Cluster;
for ClusterU'Alignment use 1;
- type ClusterU_Ref is access ClusterU;
+ package AACU is new Address_To_Access_Conversions (ClusterU);
type Rev_ClusterU is new ClusterU
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_ClusterU_Ref is access Rev_ClusterU;
+
+ package Rev_AACU is new Address_To_Access_Conversions (Rev_ClusterU);
------------
-- Get_18 --
N : Natural;
Rev_SSO : Boolean) return Bits_18
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
return
(if Rev_SSO then
N : Natural;
Rev_SSO : Boolean) return Bits_18
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : ClusterU_Ref with Address => A'Address, Import;
- RC : Rev_ClusterU_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AACU.Object_Pointer := AACU.To_Pointer (A);
+ RC : constant Rev_AACU.Object_Pointer := Rev_AACU.To_Pointer (A);
+
begin
return
(if Rev_SSO then
E : Bits_18;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
E : Bits_18;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : ClusterU_Ref with Address => A'Address, Import;
- RC : Rev_ClusterU_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AACU.Object_Pointer := AACU.To_Pointer (A);
+ RC : constant Rev_AACU.Object_Pointer := Rev_AACU.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
-- --
------------------------------------------------------------------------------
+with System.Address_To_Access_Conversions;
with System.Storage_Elements;
with System.Unsigned_Types;
-- Use maximum possible alignment, given the bit field size, since this
-- will result in the most efficient code possible for the field.
- type Cluster_Ref is access Cluster;
+ package AAC is new Address_To_Access_Conversions (Cluster);
+ -- We convert addresses to access values and dereference them instead of
+ -- directly using overlays in order to work around the implementation of
+ -- the RM 13.3(19) clause, which would pessimize the generated code.
type Rev_Cluster is new Cluster
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_Cluster_Ref is access Rev_Cluster;
+
+ package Rev_AAC is new Address_To_Access_Conversions (Rev_Cluster);
------------
-- Get_19 --
N : Natural;
Rev_SSO : Boolean) return Bits_19
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
return
(if Rev_SSO then
E : Bits_19;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
-- --
------------------------------------------------------------------------------
+with System.Address_To_Access_Conversions;
with System.Storage_Elements;
with System.Unsigned_Types;
-- Use maximum possible alignment, given the bit field size, since this
-- will result in the most efficient code possible for the field.
- type Cluster_Ref is access Cluster;
+ package AAC is new Address_To_Access_Conversions (Cluster);
+ -- We convert addresses to access values and dereference them instead of
+ -- directly using overlays in order to work around the implementation of
+ -- the RM 13.3(19) clause, which would pessimize the generated code.
type Rev_Cluster is new Cluster
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_Cluster_Ref is access Rev_Cluster;
+
+ package Rev_AAC is new Address_To_Access_Conversions (Rev_Cluster);
-- The following declarations are for the case where the address
-- passed to GetU_20 or SetU_20 is not guaranteed to be aligned.
type ClusterU is new Cluster;
for ClusterU'Alignment use 1;
- type ClusterU_Ref is access ClusterU;
+ package AACU is new Address_To_Access_Conversions (ClusterU);
type Rev_ClusterU is new ClusterU
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_ClusterU_Ref is access Rev_ClusterU;
+
+ package Rev_AACU is new Address_To_Access_Conversions (Rev_ClusterU);
------------
-- Get_20 --
N : Natural;
Rev_SSO : Boolean) return Bits_20
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
return
(if Rev_SSO then
N : Natural;
Rev_SSO : Boolean) return Bits_20
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : ClusterU_Ref with Address => A'Address, Import;
- RC : Rev_ClusterU_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AACU.Object_Pointer := AACU.To_Pointer (A);
+ RC : constant Rev_AACU.Object_Pointer := Rev_AACU.To_Pointer (A);
+
begin
return
(if Rev_SSO then
E : Bits_20;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
E : Bits_20;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : ClusterU_Ref with Address => A'Address, Import;
- RC : Rev_ClusterU_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AACU.Object_Pointer := AACU.To_Pointer (A);
+ RC : constant Rev_AACU.Object_Pointer := Rev_AACU.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
-- --
------------------------------------------------------------------------------
+with System.Address_To_Access_Conversions;
with System.Storage_Elements;
with System.Unsigned_Types;
-- Use maximum possible alignment, given the bit field size, since this
-- will result in the most efficient code possible for the field.
- type Cluster_Ref is access Cluster;
+ package AAC is new Address_To_Access_Conversions (Cluster);
+ -- We convert addresses to access values and dereference them instead of
+ -- directly using overlays in order to work around the implementation of
+ -- the RM 13.3(19) clause, which would pessimize the generated code.
type Rev_Cluster is new Cluster
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_Cluster_Ref is access Rev_Cluster;
+
+ package Rev_AAC is new Address_To_Access_Conversions (Rev_Cluster);
------------
-- Get_21 --
N : Natural;
Rev_SSO : Boolean) return Bits_21
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
return
(if Rev_SSO then
E : Bits_21;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
-- --
------------------------------------------------------------------------------
+with System.Address_To_Access_Conversions;
with System.Storage_Elements;
with System.Unsigned_Types;
-- Use maximum possible alignment, given the bit field size, since this
-- will result in the most efficient code possible for the field.
- type Cluster_Ref is access Cluster;
+ package AAC is new Address_To_Access_Conversions (Cluster);
+ -- We convert addresses to access values and dereference them instead of
+ -- directly using overlays in order to work around the implementation of
+ -- the RM 13.3(19) clause, which would pessimize the generated code.
type Rev_Cluster is new Cluster
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_Cluster_Ref is access Rev_Cluster;
+
+ package Rev_AAC is new Address_To_Access_Conversions (Rev_Cluster);
-- The following declarations are for the case where the address
-- passed to GetU_22 or SetU_22 is not guaranteed to be aligned.
type ClusterU is new Cluster;
for ClusterU'Alignment use 1;
- type ClusterU_Ref is access ClusterU;
+ package AACU is new Address_To_Access_Conversions (ClusterU);
type Rev_ClusterU is new ClusterU
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_ClusterU_Ref is access Rev_ClusterU;
+
+ package Rev_AACU is new Address_To_Access_Conversions (Rev_ClusterU);
------------
-- Get_22 --
N : Natural;
Rev_SSO : Boolean) return Bits_22
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
return
(if Rev_SSO then
N : Natural;
Rev_SSO : Boolean) return Bits_22
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : ClusterU_Ref with Address => A'Address, Import;
- RC : Rev_ClusterU_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AACU.Object_Pointer := AACU.To_Pointer (A);
+ RC : constant Rev_AACU.Object_Pointer := Rev_AACU.To_Pointer (A);
+
begin
return
(if Rev_SSO then
E : Bits_22;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
E : Bits_22;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : ClusterU_Ref with Address => A'Address, Import;
- RC : Rev_ClusterU_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AACU.Object_Pointer := AACU.To_Pointer (A);
+ RC : constant Rev_AACU.Object_Pointer := Rev_AACU.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
-- --
------------------------------------------------------------------------------
+with System.Address_To_Access_Conversions;
with System.Storage_Elements;
with System.Unsigned_Types;
-- Use maximum possible alignment, given the bit field size, since this
-- will result in the most efficient code possible for the field.
- type Cluster_Ref is access Cluster;
+ package AAC is new Address_To_Access_Conversions (Cluster);
+ -- We convert addresses to access values and dereference them instead of
+ -- directly using overlays in order to work around the implementation of
+ -- the RM 13.3(19) clause, which would pessimize the generated code.
type Rev_Cluster is new Cluster
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_Cluster_Ref is access Rev_Cluster;
+
+ package Rev_AAC is new Address_To_Access_Conversions (Rev_Cluster);
------------
-- Get_23 --
N : Natural;
Rev_SSO : Boolean) return Bits_23
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
return
(if Rev_SSO then
E : Bits_23;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
-- --
------------------------------------------------------------------------------
+with System.Address_To_Access_Conversions;
with System.Storage_Elements;
with System.Unsigned_Types;
-- Use maximum possible alignment, given the bit field size, since this
-- will result in the most efficient code possible for the field.
- type Cluster_Ref is access Cluster;
+ package AAC is new Address_To_Access_Conversions (Cluster);
+ -- We convert addresses to access values and dereference them instead of
+ -- directly using overlays in order to work around the implementation of
+ -- the RM 13.3(19) clause, which would pessimize the generated code.
type Rev_Cluster is new Cluster
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_Cluster_Ref is access Rev_Cluster;
+
+ package Rev_AAC is new Address_To_Access_Conversions (Rev_Cluster);
-- The following declarations are for the case where the address
-- passed to GetU_24 or SetU_24 is not guaranteed to be aligned.
type ClusterU is new Cluster;
for ClusterU'Alignment use 1;
- type ClusterU_Ref is access ClusterU;
+ package AACU is new Address_To_Access_Conversions (ClusterU);
type Rev_ClusterU is new ClusterU
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_ClusterU_Ref is access Rev_ClusterU;
+
+ package Rev_AACU is new Address_To_Access_Conversions (Rev_ClusterU);
------------
-- Get_24 --
N : Natural;
Rev_SSO : Boolean) return Bits_24
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
return
(if Rev_SSO then
N : Natural;
Rev_SSO : Boolean) return Bits_24
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : ClusterU_Ref with Address => A'Address, Import;
- RC : Rev_ClusterU_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AACU.Object_Pointer := AACU.To_Pointer (A);
+ RC : constant Rev_AACU.Object_Pointer := Rev_AACU.To_Pointer (A);
+
begin
return
(if Rev_SSO then
E : Bits_24;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
E : Bits_24;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : ClusterU_Ref with Address => A'Address, Import;
- RC : Rev_ClusterU_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AACU.Object_Pointer := AACU.To_Pointer (A);
+ RC : constant Rev_AACU.Object_Pointer := Rev_AACU.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
-- --
------------------------------------------------------------------------------
+with System.Address_To_Access_Conversions;
with System.Storage_Elements;
with System.Unsigned_Types;
-- Use maximum possible alignment, given the bit field size, since this
-- will result in the most efficient code possible for the field.
- type Cluster_Ref is access Cluster;
+ package AAC is new Address_To_Access_Conversions (Cluster);
+ -- We convert addresses to access values and dereference them instead of
+ -- directly using overlays in order to work around the implementation of
+ -- the RM 13.3(19) clause, which would pessimize the generated code.
type Rev_Cluster is new Cluster
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_Cluster_Ref is access Rev_Cluster;
+
+ package Rev_AAC is new Address_To_Access_Conversions (Rev_Cluster);
------------
-- Get_25 --
N : Natural;
Rev_SSO : Boolean) return Bits_25
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
return
(if Rev_SSO then
E : Bits_25;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
-- --
------------------------------------------------------------------------------
+with System.Address_To_Access_Conversions;
with System.Storage_Elements;
with System.Unsigned_Types;
-- Use maximum possible alignment, given the bit field size, since this
-- will result in the most efficient code possible for the field.
- type Cluster_Ref is access Cluster;
+ package AAC is new Address_To_Access_Conversions (Cluster);
+ -- We convert addresses to access values and dereference them instead of
+ -- directly using overlays in order to work around the implementation of
+ -- the RM 13.3(19) clause, which would pessimize the generated code.
type Rev_Cluster is new Cluster
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_Cluster_Ref is access Rev_Cluster;
+
+ package Rev_AAC is new Address_To_Access_Conversions (Rev_Cluster);
-- The following declarations are for the case where the address
-- passed to GetU_26 or SetU_26 is not guaranteed to be aligned.
type ClusterU is new Cluster;
for ClusterU'Alignment use 1;
- type ClusterU_Ref is access ClusterU;
+ package AACU is new Address_To_Access_Conversions (ClusterU);
type Rev_ClusterU is new ClusterU
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_ClusterU_Ref is access Rev_ClusterU;
+
+ package Rev_AACU is new Address_To_Access_Conversions (Rev_ClusterU);
------------
-- Get_26 --
N : Natural;
Rev_SSO : Boolean) return Bits_26
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
return
(if Rev_SSO then
N : Natural;
Rev_SSO : Boolean) return Bits_26
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : ClusterU_Ref with Address => A'Address, Import;
- RC : Rev_ClusterU_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AACU.Object_Pointer := AACU.To_Pointer (A);
+ RC : constant Rev_AACU.Object_Pointer := Rev_AACU.To_Pointer (A);
+
begin
return
(if Rev_SSO then
E : Bits_26;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
E : Bits_26;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : ClusterU_Ref with Address => A'Address, Import;
- RC : Rev_ClusterU_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AACU.Object_Pointer := AACU.To_Pointer (A);
+ RC : constant Rev_AACU.Object_Pointer := Rev_AACU.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
-- --
------------------------------------------------------------------------------
+with System.Address_To_Access_Conversions;
with System.Storage_Elements;
with System.Unsigned_Types;
-- Use maximum possible alignment, given the bit field size, since this
-- will result in the most efficient code possible for the field.
- type Cluster_Ref is access Cluster;
+ package AAC is new Address_To_Access_Conversions (Cluster);
+ -- We convert addresses to access values and dereference them instead of
+ -- directly using overlays in order to work around the implementation of
+ -- the RM 13.3(19) clause, which would pessimize the generated code.
type Rev_Cluster is new Cluster
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_Cluster_Ref is access Rev_Cluster;
+
+ package Rev_AAC is new Address_To_Access_Conversions (Rev_Cluster);
------------
-- Get_27 --
N : Natural;
Rev_SSO : Boolean) return Bits_27
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
return
(if Rev_SSO then
E : Bits_27;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
-- --
------------------------------------------------------------------------------
+with System.Address_To_Access_Conversions;
with System.Storage_Elements;
with System.Unsigned_Types;
-- Use maximum possible alignment, given the bit field size, since this
-- will result in the most efficient code possible for the field.
- type Cluster_Ref is access Cluster;
+ package AAC is new Address_To_Access_Conversions (Cluster);
+ -- We convert addresses to access values and dereference them instead of
+ -- directly using overlays in order to work around the implementation of
+ -- the RM 13.3(19) clause, which would pessimize the generated code.
type Rev_Cluster is new Cluster
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_Cluster_Ref is access Rev_Cluster;
+
+ package Rev_AAC is new Address_To_Access_Conversions (Rev_Cluster);
-- The following declarations are for the case where the address
-- passed to GetU_28 or SetU_28 is not guaranteed to be aligned.
type ClusterU is new Cluster;
for ClusterU'Alignment use 1;
- type ClusterU_Ref is access ClusterU;
+ package AACU is new Address_To_Access_Conversions (ClusterU);
type Rev_ClusterU is new ClusterU
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_ClusterU_Ref is access Rev_ClusterU;
+
+ package Rev_AACU is new Address_To_Access_Conversions (Rev_ClusterU);
------------
-- Get_28 --
N : Natural;
Rev_SSO : Boolean) return Bits_28
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
return
(if Rev_SSO then
N : Natural;
Rev_SSO : Boolean) return Bits_28
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : ClusterU_Ref with Address => A'Address, Import;
- RC : Rev_ClusterU_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AACU.Object_Pointer := AACU.To_Pointer (A);
+ RC : constant Rev_AACU.Object_Pointer := Rev_AACU.To_Pointer (A);
+
begin
return
(if Rev_SSO then
E : Bits_28;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
E : Bits_28;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : ClusterU_Ref with Address => A'Address, Import;
- RC : Rev_ClusterU_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AACU.Object_Pointer := AACU.To_Pointer (A);
+ RC : constant Rev_AACU.Object_Pointer := Rev_AACU.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
-- --
------------------------------------------------------------------------------
+with System.Address_To_Access_Conversions;
with System.Storage_Elements;
with System.Unsigned_Types;
-- Use maximum possible alignment, given the bit field size, since this
-- will result in the most efficient code possible for the field.
- type Cluster_Ref is access Cluster;
+ package AAC is new Address_To_Access_Conversions (Cluster);
+ -- We convert addresses to access values and dereference them instead of
+ -- directly using overlays in order to work around the implementation of
+ -- the RM 13.3(19) clause, which would pessimize the generated code.
type Rev_Cluster is new Cluster
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_Cluster_Ref is access Rev_Cluster;
+
+ package Rev_AAC is new Address_To_Access_Conversions (Rev_Cluster);
------------
-- Get_29 --
N : Natural;
Rev_SSO : Boolean) return Bits_29
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
return
(if Rev_SSO then
E : Bits_29;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
-- --
------------------------------------------------------------------------------
+with System.Address_To_Access_Conversions;
with System.Storage_Elements;
with System.Unsigned_Types;
-- Use maximum possible alignment, given the bit field size, since this
-- will result in the most efficient code possible for the field.
- type Cluster_Ref is access Cluster;
+ package AAC is new Address_To_Access_Conversions (Cluster);
+ -- We convert addresses to access values and dereference them instead of
+ -- directly using overlays in order to work around the implementation of
+ -- the RM 13.3(19) clause, which would pessimize the generated code.
type Rev_Cluster is new Cluster
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_Cluster_Ref is access Rev_Cluster;
+
+ package Rev_AAC is new Address_To_Access_Conversions (Rev_Cluster);
-- The following declarations are for the case where the address
-- passed to GetU_30 or SetU_30 is not guaranteed to be aligned.
type ClusterU is new Cluster;
for ClusterU'Alignment use 1;
- type ClusterU_Ref is access ClusterU;
+ package AACU is new Address_To_Access_Conversions (ClusterU);
type Rev_ClusterU is new ClusterU
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_ClusterU_Ref is access Rev_ClusterU;
+
+ package Rev_AACU is new Address_To_Access_Conversions (Rev_ClusterU);
------------
-- Get_30 --
N : Natural;
Rev_SSO : Boolean) return Bits_30
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
return
(if Rev_SSO then
N : Natural;
Rev_SSO : Boolean) return Bits_30
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : ClusterU_Ref with Address => A'Address, Import;
- RC : Rev_ClusterU_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AACU.Object_Pointer := AACU.To_Pointer (A);
+ RC : constant Rev_AACU.Object_Pointer := Rev_AACU.To_Pointer (A);
+
begin
return
(if Rev_SSO then
E : Bits_30;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
E : Bits_30;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : ClusterU_Ref with Address => A'Address, Import;
- RC : Rev_ClusterU_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AACU.Object_Pointer := AACU.To_Pointer (A);
+ RC : constant Rev_AACU.Object_Pointer := Rev_AACU.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
-- --
------------------------------------------------------------------------------
+with System.Address_To_Access_Conversions;
with System.Storage_Elements;
with System.Unsigned_Types;
-- Use maximum possible alignment, given the bit field size, since this
-- will result in the most efficient code possible for the field.
- type Cluster_Ref is access Cluster;
+ package AAC is new Address_To_Access_Conversions (Cluster);
+ -- We convert addresses to access values and dereference them instead of
+ -- directly using overlays in order to work around the implementation of
+ -- the RM 13.3(19) clause, which would pessimize the generated code.
type Rev_Cluster is new Cluster
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_Cluster_Ref is access Rev_Cluster;
+
+ package Rev_AAC is new Address_To_Access_Conversions (Rev_Cluster);
------------
-- Get_31 --
N : Natural;
Rev_SSO : Boolean) return Bits_31
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
return
(if Rev_SSO then
E : Bits_31;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
-- --
------------------------------------------------------------------------------
+with System.Address_To_Access_Conversions;
with System.Storage_Elements;
with System.Unsigned_Types;
-- Use maximum possible alignment, given the bit field size, since this
-- will result in the most efficient code possible for the field.
- type Cluster_Ref is access Cluster;
+ package AAC is new Address_To_Access_Conversions (Cluster);
+ -- We convert addresses to access values and dereference them instead of
+ -- directly using overlays in order to work around the implementation of
+ -- the RM 13.3(19) clause, which would pessimize the generated code.
type Rev_Cluster is new Cluster
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_Cluster_Ref is access Rev_Cluster;
+
+ package Rev_AAC is new Address_To_Access_Conversions (Rev_Cluster);
------------
-- Get_33 --
N : Natural;
Rev_SSO : Boolean) return Bits_33
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
return
(if Rev_SSO then
E : Bits_33;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
-- --
------------------------------------------------------------------------------
+with System.Address_To_Access_Conversions;
with System.Storage_Elements;
with System.Unsigned_Types;
-- Use maximum possible alignment, given the bit field size, since this
-- will result in the most efficient code possible for the field.
- type Cluster_Ref is access Cluster;
+ package AAC is new Address_To_Access_Conversions (Cluster);
+ -- We convert addresses to access values and dereference them instead of
+ -- directly using overlays in order to work around the implementation of
+ -- the RM 13.3(19) clause, which would pessimize the generated code.
type Rev_Cluster is new Cluster
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_Cluster_Ref is access Rev_Cluster;
+
+ package Rev_AAC is new Address_To_Access_Conversions (Rev_Cluster);
-- The following declarations are for the case where the address
-- passed to GetU_34 or SetU_34 is not guaranteed to be aligned.
type ClusterU is new Cluster;
for ClusterU'Alignment use 1;
- type ClusterU_Ref is access ClusterU;
+ package AACU is new Address_To_Access_Conversions (ClusterU);
type Rev_ClusterU is new ClusterU
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_ClusterU_Ref is access Rev_ClusterU;
+
+ package Rev_AACU is new Address_To_Access_Conversions (Rev_ClusterU);
------------
-- Get_34 --
N : Natural;
Rev_SSO : Boolean) return Bits_34
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
return
(if Rev_SSO then
N : Natural;
Rev_SSO : Boolean) return Bits_34
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : ClusterU_Ref with Address => A'Address, Import;
- RC : Rev_ClusterU_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AACU.Object_Pointer := AACU.To_Pointer (A);
+ RC : constant Rev_AACU.Object_Pointer := Rev_AACU.To_Pointer (A);
+
begin
return
(if Rev_SSO then
E : Bits_34;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
E : Bits_34;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : ClusterU_Ref with Address => A'Address, Import;
- RC : Rev_ClusterU_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AACU.Object_Pointer := AACU.To_Pointer (A);
+ RC : constant Rev_AACU.Object_Pointer := Rev_AACU.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
-- --
------------------------------------------------------------------------------
+with System.Address_To_Access_Conversions;
with System.Storage_Elements;
with System.Unsigned_Types;
-- Use maximum possible alignment, given the bit field size, since this
-- will result in the most efficient code possible for the field.
- type Cluster_Ref is access Cluster;
+ package AAC is new Address_To_Access_Conversions (Cluster);
+ -- We convert addresses to access values and dereference them instead of
+ -- directly using overlays in order to work around the implementation of
+ -- the RM 13.3(19) clause, which would pessimize the generated code.
type Rev_Cluster is new Cluster
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_Cluster_Ref is access Rev_Cluster;
+
+ package Rev_AAC is new Address_To_Access_Conversions (Rev_Cluster);
------------
-- Get_35 --
N : Natural;
Rev_SSO : Boolean) return Bits_35
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
return
(if Rev_SSO then
E : Bits_35;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
-- --
------------------------------------------------------------------------------
+with System.Address_To_Access_Conversions;
with System.Storage_Elements;
with System.Unsigned_Types;
-- Use maximum possible alignment, given the bit field size, since this
-- will result in the most efficient code possible for the field.
- type Cluster_Ref is access Cluster;
+ package AAC is new Address_To_Access_Conversions (Cluster);
+ -- We convert addresses to access values and dereference them instead of
+ -- directly using overlays in order to work around the implementation of
+ -- the RM 13.3(19) clause, which would pessimize the generated code.
type Rev_Cluster is new Cluster
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_Cluster_Ref is access Rev_Cluster;
+
+ package Rev_AAC is new Address_To_Access_Conversions (Rev_Cluster);
-- The following declarations are for the case where the address
-- passed to GetU_36 or SetU_36 is not guaranteed to be aligned.
type ClusterU is new Cluster;
for ClusterU'Alignment use 1;
- type ClusterU_Ref is access ClusterU;
+ package AACU is new Address_To_Access_Conversions (ClusterU);
type Rev_ClusterU is new ClusterU
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_ClusterU_Ref is access Rev_ClusterU;
+
+ package Rev_AACU is new Address_To_Access_Conversions (Rev_ClusterU);
------------
-- Get_36 --
N : Natural;
Rev_SSO : Boolean) return Bits_36
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
return
(if Rev_SSO then
N : Natural;
Rev_SSO : Boolean) return Bits_36
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : ClusterU_Ref with Address => A'Address, Import;
- RC : Rev_ClusterU_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AACU.Object_Pointer := AACU.To_Pointer (A);
+ RC : constant Rev_AACU.Object_Pointer := Rev_AACU.To_Pointer (A);
+
begin
return
(if Rev_SSO then
E : Bits_36;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
E : Bits_36;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : ClusterU_Ref with Address => A'Address, Import;
- RC : Rev_ClusterU_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AACU.Object_Pointer := AACU.To_Pointer (A);
+ RC : constant Rev_AACU.Object_Pointer := Rev_AACU.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
-- --
------------------------------------------------------------------------------
+with System.Address_To_Access_Conversions;
with System.Storage_Elements;
with System.Unsigned_Types;
-- Use maximum possible alignment, given the bit field size, since this
-- will result in the most efficient code possible for the field.
- type Cluster_Ref is access Cluster;
+ package AAC is new Address_To_Access_Conversions (Cluster);
+ -- We convert addresses to access values and dereference them instead of
+ -- directly using overlays in order to work around the implementation of
+ -- the RM 13.3(19) clause, which would pessimize the generated code.
type Rev_Cluster is new Cluster
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_Cluster_Ref is access Rev_Cluster;
+
+ package Rev_AAC is new Address_To_Access_Conversions (Rev_Cluster);
------------
-- Get_37 --
N : Natural;
Rev_SSO : Boolean) return Bits_37
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
return
(if Rev_SSO then
E : Bits_37;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
-- --
------------------------------------------------------------------------------
+with System.Address_To_Access_Conversions;
with System.Storage_Elements;
with System.Unsigned_Types;
-- Use maximum possible alignment, given the bit field size, since this
-- will result in the most efficient code possible for the field.
- type Cluster_Ref is access Cluster;
+ package AAC is new Address_To_Access_Conversions (Cluster);
+ -- We convert addresses to access values and dereference them instead of
+ -- directly using overlays in order to work around the implementation of
+ -- the RM 13.3(19) clause, which would pessimize the generated code.
type Rev_Cluster is new Cluster
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_Cluster_Ref is access Rev_Cluster;
+
+ package Rev_AAC is new Address_To_Access_Conversions (Rev_Cluster);
-- The following declarations are for the case where the address
-- passed to GetU_38 or SetU_38 is not guaranteed to be aligned.
type ClusterU is new Cluster;
for ClusterU'Alignment use 1;
- type ClusterU_Ref is access ClusterU;
+ package AACU is new Address_To_Access_Conversions (ClusterU);
type Rev_ClusterU is new ClusterU
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_ClusterU_Ref is access Rev_ClusterU;
+
+ package Rev_AACU is new Address_To_Access_Conversions (Rev_ClusterU);
------------
-- Get_38 --
N : Natural;
Rev_SSO : Boolean) return Bits_38
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
return
(if Rev_SSO then
N : Natural;
Rev_SSO : Boolean) return Bits_38
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : ClusterU_Ref with Address => A'Address, Import;
- RC : Rev_ClusterU_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AACU.Object_Pointer := AACU.To_Pointer (A);
+ RC : constant Rev_AACU.Object_Pointer := Rev_AACU.To_Pointer (A);
+
begin
return
(if Rev_SSO then
E : Bits_38;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
E : Bits_38;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : ClusterU_Ref with Address => A'Address, Import;
- RC : Rev_ClusterU_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AACU.Object_Pointer := AACU.To_Pointer (A);
+ RC : constant Rev_AACU.Object_Pointer := Rev_AACU.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
-- --
------------------------------------------------------------------------------
+with System.Address_To_Access_Conversions;
with System.Storage_Elements;
with System.Unsigned_Types;
-- Use maximum possible alignment, given the bit field size, since this
-- will result in the most efficient code possible for the field.
- type Cluster_Ref is access Cluster;
+ package AAC is new Address_To_Access_Conversions (Cluster);
+ -- We convert addresses to access values and dereference them instead of
+ -- directly using overlays in order to work around the implementation of
+ -- the RM 13.3(19) clause, which would pessimize the generated code.
type Rev_Cluster is new Cluster
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_Cluster_Ref is access Rev_Cluster;
+
+ package Rev_AAC is new Address_To_Access_Conversions (Rev_Cluster);
------------
-- Get_39 --
N : Natural;
Rev_SSO : Boolean) return Bits_39
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
return
(if Rev_SSO then
E : Bits_39;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
-- --
------------------------------------------------------------------------------
+with System.Address_To_Access_Conversions;
with System.Storage_Elements;
with System.Unsigned_Types;
-- Use maximum possible alignment, given the bit field size, since this
-- will result in the most efficient code possible for the field.
- type Cluster_Ref is access Cluster;
+ package AAC is new Address_To_Access_Conversions (Cluster);
+ -- We convert addresses to access values and dereference them instead of
+ -- directly using overlays in order to work around the implementation of
+ -- the RM 13.3(19) clause, which would pessimize the generated code.
type Rev_Cluster is new Cluster
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_Cluster_Ref is access Rev_Cluster;
+
+ package Rev_AAC is new Address_To_Access_Conversions (Rev_Cluster);
-- The following declarations are for the case where the address
-- passed to GetU_40 or SetU_40 is not guaranteed to be aligned.
type ClusterU is new Cluster;
for ClusterU'Alignment use 1;
- type ClusterU_Ref is access ClusterU;
+ package AACU is new Address_To_Access_Conversions (ClusterU);
type Rev_ClusterU is new ClusterU
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_ClusterU_Ref is access Rev_ClusterU;
+
+ package Rev_AACU is new Address_To_Access_Conversions (Rev_ClusterU);
------------
-- Get_40 --
N : Natural;
Rev_SSO : Boolean) return Bits_40
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
return
(if Rev_SSO then
N : Natural;
Rev_SSO : Boolean) return Bits_40
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : ClusterU_Ref with Address => A'Address, Import;
- RC : Rev_ClusterU_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AACU.Object_Pointer := AACU.To_Pointer (A);
+ RC : constant Rev_AACU.Object_Pointer := Rev_AACU.To_Pointer (A);
+
begin
return
(if Rev_SSO then
E : Bits_40;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
E : Bits_40;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : ClusterU_Ref with Address => A'Address, Import;
- RC : Rev_ClusterU_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AACU.Object_Pointer := AACU.To_Pointer (A);
+ RC : constant Rev_AACU.Object_Pointer := Rev_AACU.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
-- --
------------------------------------------------------------------------------
+with System.Address_To_Access_Conversions;
with System.Storage_Elements;
with System.Unsigned_Types;
-- Use maximum possible alignment, given the bit field size, since this
-- will result in the most efficient code possible for the field.
- type Cluster_Ref is access Cluster;
+ package AAC is new Address_To_Access_Conversions (Cluster);
+ -- We convert addresses to access values and dereference them instead of
+ -- directly using overlays in order to work around the implementation of
+ -- the RM 13.3(19) clause, which would pessimize the generated code.
type Rev_Cluster is new Cluster
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_Cluster_Ref is access Rev_Cluster;
+
+ package Rev_AAC is new Address_To_Access_Conversions (Rev_Cluster);
------------
-- Get_41 --
N : Natural;
Rev_SSO : Boolean) return Bits_41
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
return
(if Rev_SSO then
E : Bits_41;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
-- --
------------------------------------------------------------------------------
+with System.Address_To_Access_Conversions;
with System.Storage_Elements;
with System.Unsigned_Types;
-- Use maximum possible alignment, given the bit field size, since this
-- will result in the most efficient code possible for the field.
- type Cluster_Ref is access Cluster;
+ package AAC is new Address_To_Access_Conversions (Cluster);
+ -- We convert addresses to access values and dereference them instead of
+ -- directly using overlays in order to work around the implementation of
+ -- the RM 13.3(19) clause, which would pessimize the generated code.
type Rev_Cluster is new Cluster
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_Cluster_Ref is access Rev_Cluster;
+
+ package Rev_AAC is new Address_To_Access_Conversions (Rev_Cluster);
-- The following declarations are for the case where the address
-- passed to GetU_42 or SetU_42 is not guaranteed to be aligned.
type ClusterU is new Cluster;
for ClusterU'Alignment use 1;
- type ClusterU_Ref is access ClusterU;
+ package AACU is new Address_To_Access_Conversions (ClusterU);
type Rev_ClusterU is new ClusterU
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_ClusterU_Ref is access Rev_ClusterU;
+
+ package Rev_AACU is new Address_To_Access_Conversions (Rev_ClusterU);
------------
-- Get_42 --
N : Natural;
Rev_SSO : Boolean) return Bits_42
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
return
(if Rev_SSO then
N : Natural;
Rev_SSO : Boolean) return Bits_42
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : ClusterU_Ref with Address => A'Address, Import;
- RC : Rev_ClusterU_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AACU.Object_Pointer := AACU.To_Pointer (A);
+ RC : constant Rev_AACU.Object_Pointer := Rev_AACU.To_Pointer (A);
+
begin
return
(if Rev_SSO then
E : Bits_42;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
E : Bits_42;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : ClusterU_Ref with Address => A'Address, Import;
- RC : Rev_ClusterU_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AACU.Object_Pointer := AACU.To_Pointer (A);
+ RC : constant Rev_AACU.Object_Pointer := Rev_AACU.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
-- --
------------------------------------------------------------------------------
+with System.Address_To_Access_Conversions;
with System.Storage_Elements;
with System.Unsigned_Types;
-- Use maximum possible alignment, given the bit field size, since this
-- will result in the most efficient code possible for the field.
- type Cluster_Ref is access Cluster;
+ package AAC is new Address_To_Access_Conversions (Cluster);
+ -- We convert addresses to access values and dereference them instead of
+ -- directly using overlays in order to work around the implementation of
+ -- the RM 13.3(19) clause, which would pessimize the generated code.
type Rev_Cluster is new Cluster
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_Cluster_Ref is access Rev_Cluster;
+
+ package Rev_AAC is new Address_To_Access_Conversions (Rev_Cluster);
------------
-- Get_43 --
N : Natural;
Rev_SSO : Boolean) return Bits_43
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
return
(if Rev_SSO then
E : Bits_43;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
-- --
------------------------------------------------------------------------------
+with System.Address_To_Access_Conversions;
with System.Storage_Elements;
with System.Unsigned_Types;
-- Use maximum possible alignment, given the bit field size, since this
-- will result in the most efficient code possible for the field.
- type Cluster_Ref is access Cluster;
+ package AAC is new Address_To_Access_Conversions (Cluster);
+ -- We convert addresses to access values and dereference them instead of
+ -- directly using overlays in order to work around the implementation of
+ -- the RM 13.3(19) clause, which would pessimize the generated code.
type Rev_Cluster is new Cluster
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_Cluster_Ref is access Rev_Cluster;
+
+ package Rev_AAC is new Address_To_Access_Conversions (Rev_Cluster);
-- The following declarations are for the case where the address
-- passed to GetU_44 or SetU_44 is not guaranteed to be aligned.
type ClusterU is new Cluster;
for ClusterU'Alignment use 1;
- type ClusterU_Ref is access ClusterU;
+ package AACU is new Address_To_Access_Conversions (ClusterU);
type Rev_ClusterU is new ClusterU
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_ClusterU_Ref is access Rev_ClusterU;
+
+ package Rev_AACU is new Address_To_Access_Conversions (Rev_ClusterU);
------------
-- Get_44 --
N : Natural;
Rev_SSO : Boolean) return Bits_44
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
return
(if Rev_SSO then
N : Natural;
Rev_SSO : Boolean) return Bits_44
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : ClusterU_Ref with Address => A'Address, Import;
- RC : Rev_ClusterU_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AACU.Object_Pointer := AACU.To_Pointer (A);
+ RC : constant Rev_AACU.Object_Pointer := Rev_AACU.To_Pointer (A);
+
begin
return
(if Rev_SSO then
E : Bits_44;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
E : Bits_44;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : ClusterU_Ref with Address => A'Address, Import;
- RC : Rev_ClusterU_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AACU.Object_Pointer := AACU.To_Pointer (A);
+ RC : constant Rev_AACU.Object_Pointer := Rev_AACU.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
-- --
------------------------------------------------------------------------------
+with System.Address_To_Access_Conversions;
with System.Storage_Elements;
with System.Unsigned_Types;
-- Use maximum possible alignment, given the bit field size, since this
-- will result in the most efficient code possible for the field.
- type Cluster_Ref is access Cluster;
+ package AAC is new Address_To_Access_Conversions (Cluster);
+ -- We convert addresses to access values and dereference them instead of
+ -- directly using overlays in order to work around the implementation of
+ -- the RM 13.3(19) clause, which would pessimize the generated code.
type Rev_Cluster is new Cluster
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_Cluster_Ref is access Rev_Cluster;
+
+ package Rev_AAC is new Address_To_Access_Conversions (Rev_Cluster);
------------
-- Get_45 --
N : Natural;
Rev_SSO : Boolean) return Bits_45
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
return
(if Rev_SSO then
E : Bits_45;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
-- --
------------------------------------------------------------------------------
+with System.Address_To_Access_Conversions;
with System.Storage_Elements;
with System.Unsigned_Types;
-- Use maximum possible alignment, given the bit field size, since this
-- will result in the most efficient code possible for the field.
- type Cluster_Ref is access Cluster;
+ package AAC is new Address_To_Access_Conversions (Cluster);
+ -- We convert addresses to access values and dereference them instead of
+ -- directly using overlays in order to work around the implementation of
+ -- the RM 13.3(19) clause, which would pessimize the generated code.
type Rev_Cluster is new Cluster
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_Cluster_Ref is access Rev_Cluster;
+
+ package Rev_AAC is new Address_To_Access_Conversions (Rev_Cluster);
-- The following declarations are for the case where the address
-- passed to GetU_46 or SetU_46 is not guaranteed to be aligned.
type ClusterU is new Cluster;
for ClusterU'Alignment use 1;
- type ClusterU_Ref is access ClusterU;
+ package AACU is new Address_To_Access_Conversions (ClusterU);
type Rev_ClusterU is new ClusterU
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_ClusterU_Ref is access Rev_ClusterU;
+
+ package Rev_AACU is new Address_To_Access_Conversions (Rev_ClusterU);
------------
-- Get_46 --
N : Natural;
Rev_SSO : Boolean) return Bits_46
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
return
(if Rev_SSO then
N : Natural;
Rev_SSO : Boolean) return Bits_46
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : ClusterU_Ref with Address => A'Address, Import;
- RC : Rev_ClusterU_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AACU.Object_Pointer := AACU.To_Pointer (A);
+ RC : constant Rev_AACU.Object_Pointer := Rev_AACU.To_Pointer (A);
+
begin
return
(if Rev_SSO then
E : Bits_46;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
E : Bits_46;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : ClusterU_Ref with Address => A'Address, Import;
- RC : Rev_ClusterU_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AACU.Object_Pointer := AACU.To_Pointer (A);
+ RC : constant Rev_AACU.Object_Pointer := Rev_AACU.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
-- --
------------------------------------------------------------------------------
+with System.Address_To_Access_Conversions;
with System.Storage_Elements;
with System.Unsigned_Types;
-- Use maximum possible alignment, given the bit field size, since this
-- will result in the most efficient code possible for the field.
- type Cluster_Ref is access Cluster;
+ package AAC is new Address_To_Access_Conversions (Cluster);
+ -- We convert addresses to access values and dereference them instead of
+ -- directly using overlays in order to work around the implementation of
+ -- the RM 13.3(19) clause, which would pessimize the generated code.
type Rev_Cluster is new Cluster
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_Cluster_Ref is access Rev_Cluster;
+
+ package Rev_AAC is new Address_To_Access_Conversions (Rev_Cluster);
------------
-- Get_47 --
N : Natural;
Rev_SSO : Boolean) return Bits_47
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
return
(if Rev_SSO then
E : Bits_47;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
-- --
------------------------------------------------------------------------------
+with System.Address_To_Access_Conversions;
with System.Storage_Elements;
with System.Unsigned_Types;
-- Use maximum possible alignment, given the bit field size, since this
-- will result in the most efficient code possible for the field.
- type Cluster_Ref is access Cluster;
+ package AAC is new Address_To_Access_Conversions (Cluster);
+ -- We convert addresses to access values and dereference them instead of
+ -- directly using overlays in order to work around the implementation of
+ -- the RM 13.3(19) clause, which would pessimize the generated code.
type Rev_Cluster is new Cluster
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_Cluster_Ref is access Rev_Cluster;
+
+ package Rev_AAC is new Address_To_Access_Conversions (Rev_Cluster);
-- The following declarations are for the case where the address
-- passed to GetU_48 or SetU_48 is not guaranteed to be aligned.
type ClusterU is new Cluster;
for ClusterU'Alignment use 1;
- type ClusterU_Ref is access ClusterU;
+ package AACU is new Address_To_Access_Conversions (ClusterU);
type Rev_ClusterU is new ClusterU
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_ClusterU_Ref is access Rev_ClusterU;
+
+ package Rev_AACU is new Address_To_Access_Conversions (Rev_ClusterU);
------------
-- Get_48 --
N : Natural;
Rev_SSO : Boolean) return Bits_48
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
return
(if Rev_SSO then
N : Natural;
Rev_SSO : Boolean) return Bits_48
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : ClusterU_Ref with Address => A'Address, Import;
- RC : Rev_ClusterU_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AACU.Object_Pointer := AACU.To_Pointer (A);
+ RC : constant Rev_AACU.Object_Pointer := Rev_AACU.To_Pointer (A);
+
begin
return
(if Rev_SSO then
E : Bits_48;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
E : Bits_48;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : ClusterU_Ref with Address => A'Address, Import;
- RC : Rev_ClusterU_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AACU.Object_Pointer := AACU.To_Pointer (A);
+ RC : constant Rev_AACU.Object_Pointer := Rev_AACU.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
-- --
------------------------------------------------------------------------------
+with System.Address_To_Access_Conversions;
with System.Storage_Elements;
with System.Unsigned_Types;
-- Use maximum possible alignment, given the bit field size, since this
-- will result in the most efficient code possible for the field.
- type Cluster_Ref is access Cluster;
+ package AAC is new Address_To_Access_Conversions (Cluster);
+ -- We convert addresses to access values and dereference them instead of
+ -- directly using overlays in order to work around the implementation of
+ -- the RM 13.3(19) clause, which would pessimize the generated code.
type Rev_Cluster is new Cluster
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_Cluster_Ref is access Rev_Cluster;
+
+ package Rev_AAC is new Address_To_Access_Conversions (Rev_Cluster);
------------
-- Get_49 --
N : Natural;
Rev_SSO : Boolean) return Bits_49
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
return
(if Rev_SSO then
E : Bits_49;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
-- --
------------------------------------------------------------------------------
+with System.Address_To_Access_Conversions;
with System.Storage_Elements;
with System.Unsigned_Types;
-- Use maximum possible alignment, given the bit field size, since this
-- will result in the most efficient code possible for the field.
- type Cluster_Ref is access Cluster;
+ package AAC is new Address_To_Access_Conversions (Cluster);
+ -- We convert addresses to access values and dereference them instead of
+ -- directly using overlays in order to work around the implementation of
+ -- the RM 13.3(19) clause, which would pessimize the generated code.
type Rev_Cluster is new Cluster
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_Cluster_Ref is access Rev_Cluster;
+
+ package Rev_AAC is new Address_To_Access_Conversions (Rev_Cluster);
-- The following declarations are for the case where the address
-- passed to GetU_50 or SetU_50 is not guaranteed to be aligned.
type ClusterU is new Cluster;
for ClusterU'Alignment use 1;
- type ClusterU_Ref is access ClusterU;
+ package AACU is new Address_To_Access_Conversions (ClusterU);
type Rev_ClusterU is new ClusterU
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_ClusterU_Ref is access Rev_ClusterU;
+
+ package Rev_AACU is new Address_To_Access_Conversions (Rev_ClusterU);
------------
-- Get_50 --
N : Natural;
Rev_SSO : Boolean) return Bits_50
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
return
(if Rev_SSO then
N : Natural;
Rev_SSO : Boolean) return Bits_50
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : ClusterU_Ref with Address => A'Address, Import;
- RC : Rev_ClusterU_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AACU.Object_Pointer := AACU.To_Pointer (A);
+ RC : constant Rev_AACU.Object_Pointer := Rev_AACU.To_Pointer (A);
+
begin
return
(if Rev_SSO then
E : Bits_50;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
E : Bits_50;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : ClusterU_Ref with Address => A'Address, Import;
- RC : Rev_ClusterU_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AACU.Object_Pointer := AACU.To_Pointer (A);
+ RC : constant Rev_AACU.Object_Pointer := Rev_AACU.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
-- --
------------------------------------------------------------------------------
+with System.Address_To_Access_Conversions;
with System.Storage_Elements;
with System.Unsigned_Types;
-- Use maximum possible alignment, given the bit field size, since this
-- will result in the most efficient code possible for the field.
- type Cluster_Ref is access Cluster;
+ package AAC is new Address_To_Access_Conversions (Cluster);
+ -- We convert addresses to access values and dereference them instead of
+ -- directly using overlays in order to work around the implementation of
+ -- the RM 13.3(19) clause, which would pessimize the generated code.
type Rev_Cluster is new Cluster
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_Cluster_Ref is access Rev_Cluster;
+
+ package Rev_AAC is new Address_To_Access_Conversions (Rev_Cluster);
------------
-- Get_51 --
N : Natural;
Rev_SSO : Boolean) return Bits_51
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
return
(if Rev_SSO then
E : Bits_51;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
-- --
------------------------------------------------------------------------------
+with System.Address_To_Access_Conversions;
with System.Storage_Elements;
with System.Unsigned_Types;
-- Use maximum possible alignment, given the bit field size, since this
-- will result in the most efficient code possible for the field.
- type Cluster_Ref is access Cluster;
+ package AAC is new Address_To_Access_Conversions (Cluster);
+ -- We convert addresses to access values and dereference them instead of
+ -- directly using overlays in order to work around the implementation of
+ -- the RM 13.3(19) clause, which would pessimize the generated code.
type Rev_Cluster is new Cluster
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_Cluster_Ref is access Rev_Cluster;
+
+ package Rev_AAC is new Address_To_Access_Conversions (Rev_Cluster);
-- The following declarations are for the case where the address
-- passed to GetU_52 or SetU_52 is not guaranteed to be aligned.
type ClusterU is new Cluster;
for ClusterU'Alignment use 1;
- type ClusterU_Ref is access ClusterU;
+ package AACU is new Address_To_Access_Conversions (ClusterU);
type Rev_ClusterU is new ClusterU
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_ClusterU_Ref is access Rev_ClusterU;
+
+ package Rev_AACU is new Address_To_Access_Conversions (Rev_ClusterU);
------------
-- Get_52 --
N : Natural;
Rev_SSO : Boolean) return Bits_52
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
return
(if Rev_SSO then
N : Natural;
Rev_SSO : Boolean) return Bits_52
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : ClusterU_Ref with Address => A'Address, Import;
- RC : Rev_ClusterU_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AACU.Object_Pointer := AACU.To_Pointer (A);
+ RC : constant Rev_AACU.Object_Pointer := Rev_AACU.To_Pointer (A);
+
begin
return
(if Rev_SSO then
E : Bits_52;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
E : Bits_52;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : ClusterU_Ref with Address => A'Address, Import;
- RC : Rev_ClusterU_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AACU.Object_Pointer := AACU.To_Pointer (A);
+ RC : constant Rev_AACU.Object_Pointer := Rev_AACU.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
-- --
------------------------------------------------------------------------------
+with System.Address_To_Access_Conversions;
with System.Storage_Elements;
with System.Unsigned_Types;
-- Use maximum possible alignment, given the bit field size, since this
-- will result in the most efficient code possible for the field.
- type Cluster_Ref is access Cluster;
+ package AAC is new Address_To_Access_Conversions (Cluster);
+ -- We convert addresses to access values and dereference them instead of
+ -- directly using overlays in order to work around the implementation of
+ -- the RM 13.3(19) clause, which would pessimize the generated code.
type Rev_Cluster is new Cluster
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_Cluster_Ref is access Rev_Cluster;
+
+ package Rev_AAC is new Address_To_Access_Conversions (Rev_Cluster);
------------
-- Get_53 --
N : Natural;
Rev_SSO : Boolean) return Bits_53
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
return
(if Rev_SSO then
E : Bits_53;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
-- --
------------------------------------------------------------------------------
+with System.Address_To_Access_Conversions;
with System.Storage_Elements;
with System.Unsigned_Types;
-- Use maximum possible alignment, given the bit field size, since this
-- will result in the most efficient code possible for the field.
- type Cluster_Ref is access Cluster;
+ package AAC is new Address_To_Access_Conversions (Cluster);
+ -- We convert addresses to access values and dereference them instead of
+ -- directly using overlays in order to work around the implementation of
+ -- the RM 13.3(19) clause, which would pessimize the generated code.
type Rev_Cluster is new Cluster
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_Cluster_Ref is access Rev_Cluster;
+
+ package Rev_AAC is new Address_To_Access_Conversions (Rev_Cluster);
-- The following declarations are for the case where the address
-- passed to GetU_54 or SetU_54 is not guaranteed to be aligned.
type ClusterU is new Cluster;
for ClusterU'Alignment use 1;
- type ClusterU_Ref is access ClusterU;
+ package AACU is new Address_To_Access_Conversions (ClusterU);
type Rev_ClusterU is new ClusterU
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_ClusterU_Ref is access Rev_ClusterU;
+
+ package Rev_AACU is new Address_To_Access_Conversions (Rev_ClusterU);
------------
-- Get_54 --
N : Natural;
Rev_SSO : Boolean) return Bits_54
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
return
(if Rev_SSO then
N : Natural;
Rev_SSO : Boolean) return Bits_54
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : ClusterU_Ref with Address => A'Address, Import;
- RC : Rev_ClusterU_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AACU.Object_Pointer := AACU.To_Pointer (A);
+ RC : constant Rev_AACU.Object_Pointer := Rev_AACU.To_Pointer (A);
+
begin
return
(if Rev_SSO then
E : Bits_54;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
E : Bits_54;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : ClusterU_Ref with Address => A'Address, Import;
- RC : Rev_ClusterU_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AACU.Object_Pointer := AACU.To_Pointer (A);
+ RC : constant Rev_AACU.Object_Pointer := Rev_AACU.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
-- --
------------------------------------------------------------------------------
+with System.Address_To_Access_Conversions;
with System.Storage_Elements;
with System.Unsigned_Types;
-- Use maximum possible alignment, given the bit field size, since this
-- will result in the most efficient code possible for the field.
- type Cluster_Ref is access Cluster;
+ package AAC is new Address_To_Access_Conversions (Cluster);
+ -- We convert addresses to access values and dereference them instead of
+ -- directly using overlays in order to work around the implementation of
+ -- the RM 13.3(19) clause, which would pessimize the generated code.
type Rev_Cluster is new Cluster
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_Cluster_Ref is access Rev_Cluster;
+
+ package Rev_AAC is new Address_To_Access_Conversions (Rev_Cluster);
------------
-- Get_55 --
N : Natural;
Rev_SSO : Boolean) return Bits_55
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
return
(if Rev_SSO then
E : Bits_55;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
-- --
------------------------------------------------------------------------------
+with System.Address_To_Access_Conversions;
with System.Storage_Elements;
with System.Unsigned_Types;
-- Use maximum possible alignment, given the bit field size, since this
-- will result in the most efficient code possible for the field.
- type Cluster_Ref is access Cluster;
+ package AAC is new Address_To_Access_Conversions (Cluster);
+ -- We convert addresses to access values and dereference them instead of
+ -- directly using overlays in order to work around the implementation of
+ -- the RM 13.3(19) clause, which would pessimize the generated code.
type Rev_Cluster is new Cluster
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_Cluster_Ref is access Rev_Cluster;
+
+ package Rev_AAC is new Address_To_Access_Conversions (Rev_Cluster);
-- The following declarations are for the case where the address
-- passed to GetU_56 or SetU_56 is not guaranteed to be aligned.
type ClusterU is new Cluster;
for ClusterU'Alignment use 1;
- type ClusterU_Ref is access ClusterU;
+ package AACU is new Address_To_Access_Conversions (ClusterU);
type Rev_ClusterU is new ClusterU
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_ClusterU_Ref is access Rev_ClusterU;
+
+ package Rev_AACU is new Address_To_Access_Conversions (Rev_ClusterU);
------------
-- Get_56 --
N : Natural;
Rev_SSO : Boolean) return Bits_56
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
return
(if Rev_SSO then
N : Natural;
Rev_SSO : Boolean) return Bits_56
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : ClusterU_Ref with Address => A'Address, Import;
- RC : Rev_ClusterU_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AACU.Object_Pointer := AACU.To_Pointer (A);
+ RC : constant Rev_AACU.Object_Pointer := Rev_AACU.To_Pointer (A);
+
begin
return
(if Rev_SSO then
E : Bits_56;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
E : Bits_56;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : ClusterU_Ref with Address => A'Address, Import;
- RC : Rev_ClusterU_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AACU.Object_Pointer := AACU.To_Pointer (A);
+ RC : constant Rev_AACU.Object_Pointer := Rev_AACU.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
-- --
------------------------------------------------------------------------------
+with System.Address_To_Access_Conversions;
with System.Storage_Elements;
with System.Unsigned_Types;
-- Use maximum possible alignment, given the bit field size, since this
-- will result in the most efficient code possible for the field.
- type Cluster_Ref is access Cluster;
+ package AAC is new Address_To_Access_Conversions (Cluster);
+ -- We convert addresses to access values and dereference them instead of
+ -- directly using overlays in order to work around the implementation of
+ -- the RM 13.3(19) clause, which would pessimize the generated code.
type Rev_Cluster is new Cluster
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_Cluster_Ref is access Rev_Cluster;
+
+ package Rev_AAC is new Address_To_Access_Conversions (Rev_Cluster);
------------
-- Get_57 --
N : Natural;
Rev_SSO : Boolean) return Bits_57
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
return
(if Rev_SSO then
E : Bits_57;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
-- --
------------------------------------------------------------------------------
+with System.Address_To_Access_Conversions;
with System.Storage_Elements;
with System.Unsigned_Types;
-- Use maximum possible alignment, given the bit field size, since this
-- will result in the most efficient code possible for the field.
- type Cluster_Ref is access Cluster;
+ package AAC is new Address_To_Access_Conversions (Cluster);
+ -- We convert addresses to access values and dereference them instead of
+ -- directly using overlays in order to work around the implementation of
+ -- the RM 13.3(19) clause, which would pessimize the generated code.
type Rev_Cluster is new Cluster
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_Cluster_Ref is access Rev_Cluster;
+
+ package Rev_AAC is new Address_To_Access_Conversions (Rev_Cluster);
-- The following declarations are for the case where the address
-- passed to GetU_58 or SetU_58 is not guaranteed to be aligned.
type ClusterU is new Cluster;
for ClusterU'Alignment use 1;
- type ClusterU_Ref is access ClusterU;
+ package AACU is new Address_To_Access_Conversions (ClusterU);
type Rev_ClusterU is new ClusterU
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_ClusterU_Ref is access Rev_ClusterU;
+
+ package Rev_AACU is new Address_To_Access_Conversions (Rev_ClusterU);
------------
-- Get_58 --
N : Natural;
Rev_SSO : Boolean) return Bits_58
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
return
(if Rev_SSO then
N : Natural;
Rev_SSO : Boolean) return Bits_58
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : ClusterU_Ref with Address => A'Address, Import;
- RC : Rev_ClusterU_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AACU.Object_Pointer := AACU.To_Pointer (A);
+ RC : constant Rev_AACU.Object_Pointer := Rev_AACU.To_Pointer (A);
+
begin
return
(if Rev_SSO then
E : Bits_58;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
E : Bits_58;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : ClusterU_Ref with Address => A'Address, Import;
- RC : Rev_ClusterU_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AACU.Object_Pointer := AACU.To_Pointer (A);
+ RC : constant Rev_AACU.Object_Pointer := Rev_AACU.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
-- --
------------------------------------------------------------------------------
+with System.Address_To_Access_Conversions;
with System.Storage_Elements;
with System.Unsigned_Types;
-- Use maximum possible alignment, given the bit field size, since this
-- will result in the most efficient code possible for the field.
- type Cluster_Ref is access Cluster;
+ package AAC is new Address_To_Access_Conversions (Cluster);
+ -- We convert addresses to access values and dereference them instead of
+ -- directly using overlays in order to work around the implementation of
+ -- the RM 13.3(19) clause, which would pessimize the generated code.
type Rev_Cluster is new Cluster
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_Cluster_Ref is access Rev_Cluster;
+
+ package Rev_AAC is new Address_To_Access_Conversions (Rev_Cluster);
------------
-- Get_59 --
N : Natural;
Rev_SSO : Boolean) return Bits_59
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
return
(if Rev_SSO then
E : Bits_59;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
-- --
------------------------------------------------------------------------------
+with System.Address_To_Access_Conversions;
with System.Storage_Elements;
with System.Unsigned_Types;
-- Use maximum possible alignment, given the bit field size, since this
-- will result in the most efficient code possible for the field.
- type Cluster_Ref is access Cluster;
+ package AAC is new Address_To_Access_Conversions (Cluster);
+ -- We convert addresses to access values and dereference them instead of
+ -- directly using overlays in order to work around the implementation of
+ -- the RM 13.3(19) clause, which would pessimize the generated code.
type Rev_Cluster is new Cluster
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_Cluster_Ref is access Rev_Cluster;
+
+ package Rev_AAC is new Address_To_Access_Conversions (Rev_Cluster);
-- The following declarations are for the case where the address
-- passed to GetU_60 or SetU_60 is not guaranteed to be aligned.
type ClusterU is new Cluster;
for ClusterU'Alignment use 1;
- type ClusterU_Ref is access ClusterU;
+ package AACU is new Address_To_Access_Conversions (ClusterU);
type Rev_ClusterU is new ClusterU
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_ClusterU_Ref is access Rev_ClusterU;
+
+ package Rev_AACU is new Address_To_Access_Conversions (Rev_ClusterU);
------------
-- Get_60 --
N : Natural;
Rev_SSO : Boolean) return Bits_60
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
return
(if Rev_SSO then
N : Natural;
Rev_SSO : Boolean) return Bits_60
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : ClusterU_Ref with Address => A'Address, Import;
- RC : Rev_ClusterU_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AACU.Object_Pointer := AACU.To_Pointer (A);
+ RC : constant Rev_AACU.Object_Pointer := Rev_AACU.To_Pointer (A);
+
begin
return
(if Rev_SSO then
E : Bits_60;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
E : Bits_60;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : ClusterU_Ref with Address => A'Address, Import;
- RC : Rev_ClusterU_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AACU.Object_Pointer := AACU.To_Pointer (A);
+ RC : constant Rev_AACU.Object_Pointer := Rev_AACU.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
-- --
------------------------------------------------------------------------------
+with System.Address_To_Access_Conversions;
with System.Storage_Elements;
with System.Unsigned_Types;
-- Use maximum possible alignment, given the bit field size, since this
-- will result in the most efficient code possible for the field.
- type Cluster_Ref is access Cluster;
+ package AAC is new Address_To_Access_Conversions (Cluster);
+ -- We convert addresses to access values and dereference them instead of
+ -- directly using overlays in order to work around the implementation of
+ -- the RM 13.3(19) clause, which would pessimize the generated code.
type Rev_Cluster is new Cluster
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_Cluster_Ref is access Rev_Cluster;
+
+ package Rev_AAC is new Address_To_Access_Conversions (Rev_Cluster);
------------
-- Get_61 --
N : Natural;
Rev_SSO : Boolean) return Bits_61
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
return
(if Rev_SSO then
E : Bits_61;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
-- --
------------------------------------------------------------------------------
+with System.Address_To_Access_Conversions;
with System.Storage_Elements;
with System.Unsigned_Types;
-- Use maximum possible alignment, given the bit field size, since this
-- will result in the most efficient code possible for the field.
- type Cluster_Ref is access Cluster;
+ package AAC is new Address_To_Access_Conversions (Cluster);
+ -- We convert addresses to access values and dereference them instead of
+ -- directly using overlays in order to work around the implementation of
+ -- the RM 13.3(19) clause, which would pessimize the generated code.
type Rev_Cluster is new Cluster
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_Cluster_Ref is access Rev_Cluster;
+
+ package Rev_AAC is new Address_To_Access_Conversions (Rev_Cluster);
-- The following declarations are for the case where the address
-- passed to GetU_62 or SetU_62 is not guaranteed to be aligned.
type ClusterU is new Cluster;
for ClusterU'Alignment use 1;
- type ClusterU_Ref is access ClusterU;
+ package AACU is new Address_To_Access_Conversions (ClusterU);
type Rev_ClusterU is new ClusterU
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_ClusterU_Ref is access Rev_ClusterU;
+
+ package Rev_AACU is new Address_To_Access_Conversions (Rev_ClusterU);
------------
-- Get_62 --
N : Natural;
Rev_SSO : Boolean) return Bits_62
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
return
(if Rev_SSO then
N : Natural;
Rev_SSO : Boolean) return Bits_62
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : ClusterU_Ref with Address => A'Address, Import;
- RC : Rev_ClusterU_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AACU.Object_Pointer := AACU.To_Pointer (A);
+ RC : constant Rev_AACU.Object_Pointer := Rev_AACU.To_Pointer (A);
+
begin
return
(if Rev_SSO then
E : Bits_62;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
E : Bits_62;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : ClusterU_Ref with Address => A'Address, Import;
- RC : Rev_ClusterU_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AACU.Object_Pointer := AACU.To_Pointer (A);
+ RC : constant Rev_AACU.Object_Pointer := Rev_AACU.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
-- --
------------------------------------------------------------------------------
+with System.Address_To_Access_Conversions;
with System.Storage_Elements;
with System.Unsigned_Types;
-- Use maximum possible alignment, given the bit field size, since this
-- will result in the most efficient code possible for the field.
- type Cluster_Ref is access Cluster;
+ package AAC is new Address_To_Access_Conversions (Cluster);
+ -- We convert addresses to access values and dereference them instead of
+ -- directly using overlays in order to work around the implementation of
+ -- the RM 13.3(19) clause, which would pessimize the generated code.
type Rev_Cluster is new Cluster
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_Cluster_Ref is access Rev_Cluster;
+
+ package Rev_AAC is new Address_To_Access_Conversions (Rev_Cluster);
------------
-- Get_63 --
N : Natural;
Rev_SSO : Boolean) return Bits_63
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
return
(if Rev_SSO then
E : Bits_63;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
-- --
------------------------------------------------------------------------------
+with System.Address_To_Access_Conversions;
with System.Storage_Elements;
with System.Unsigned_Types;
-- Use maximum possible alignment, given the bit field size, since this
-- will result in the most efficient code possible for the field.
- type Cluster_Ref is access Cluster;
+ package AAC is new Address_To_Access_Conversions (Cluster);
+ -- We convert addresses to access values and dereference them instead of
+ -- directly using overlays in order to work around the implementation of
+ -- the RM 13.3(19) clause, which would pessimize the generated code.
type Rev_Cluster is new Cluster
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_Cluster_Ref is access Rev_Cluster;
+
+ package Rev_AAC is new Address_To_Access_Conversions (Rev_Cluster);
------------
-- Get_65 --
N : Natural;
Rev_SSO : Boolean) return Bits_65
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
return
(if Rev_SSO then
E : Bits_65;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
-- --
------------------------------------------------------------------------------
+with System.Address_To_Access_Conversions;
with System.Storage_Elements;
with System.Unsigned_Types;
-- Use maximum possible alignment, given the bit field size, since this
-- will result in the most efficient code possible for the field.
- type Cluster_Ref is access Cluster;
+ package AAC is new Address_To_Access_Conversions (Cluster);
+ -- We convert addresses to access values and dereference them instead of
+ -- directly using overlays in order to work around the implementation of
+ -- the RM 13.3(19) clause, which would pessimize the generated code.
type Rev_Cluster is new Cluster
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_Cluster_Ref is access Rev_Cluster;
+
+ package Rev_AAC is new Address_To_Access_Conversions (Rev_Cluster);
-- The following declarations are for the case where the address
-- passed to GetU_66 or SetU_66 is not guaranteed to be aligned.
type ClusterU is new Cluster;
for ClusterU'Alignment use 1;
- type ClusterU_Ref is access ClusterU;
+ package AACU is new Address_To_Access_Conversions (ClusterU);
type Rev_ClusterU is new ClusterU
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_ClusterU_Ref is access Rev_ClusterU;
+
+ package Rev_AACU is new Address_To_Access_Conversions (Rev_ClusterU);
------------
-- Get_66 --
N : Natural;
Rev_SSO : Boolean) return Bits_66
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
return
(if Rev_SSO then
N : Natural;
Rev_SSO : Boolean) return Bits_66
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : ClusterU_Ref with Address => A'Address, Import;
- RC : Rev_ClusterU_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AACU.Object_Pointer := AACU.To_Pointer (A);
+ RC : constant Rev_AACU.Object_Pointer := Rev_AACU.To_Pointer (A);
+
begin
return
(if Rev_SSO then
E : Bits_66;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
E : Bits_66;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : ClusterU_Ref with Address => A'Address, Import;
- RC : Rev_ClusterU_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AACU.Object_Pointer := AACU.To_Pointer (A);
+ RC : constant Rev_AACU.Object_Pointer := Rev_AACU.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
-- --
------------------------------------------------------------------------------
+with System.Address_To_Access_Conversions;
with System.Storage_Elements;
with System.Unsigned_Types;
-- Use maximum possible alignment, given the bit field size, since this
-- will result in the most efficient code possible for the field.
- type Cluster_Ref is access Cluster;
+ package AAC is new Address_To_Access_Conversions (Cluster);
+ -- We convert addresses to access values and dereference them instead of
+ -- directly using overlays in order to work around the implementation of
+ -- the RM 13.3(19) clause, which would pessimize the generated code.
type Rev_Cluster is new Cluster
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_Cluster_Ref is access Rev_Cluster;
+
+ package Rev_AAC is new Address_To_Access_Conversions (Rev_Cluster);
------------
-- Get_67 --
N : Natural;
Rev_SSO : Boolean) return Bits_67
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
return
(if Rev_SSO then
E : Bits_67;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
-- --
------------------------------------------------------------------------------
+with System.Address_To_Access_Conversions;
with System.Storage_Elements;
with System.Unsigned_Types;
-- Use maximum possible alignment, given the bit field size, since this
-- will result in the most efficient code possible for the field.
- type Cluster_Ref is access Cluster;
+ package AAC is new Address_To_Access_Conversions (Cluster);
+ -- We convert addresses to access values and dereference them instead of
+ -- directly using overlays in order to work around the implementation of
+ -- the RM 13.3(19) clause, which would pessimize the generated code.
type Rev_Cluster is new Cluster
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_Cluster_Ref is access Rev_Cluster;
+
+ package Rev_AAC is new Address_To_Access_Conversions (Rev_Cluster);
-- The following declarations are for the case where the address
-- passed to GetU_68 or SetU_68 is not guaranteed to be aligned.
type ClusterU is new Cluster;
for ClusterU'Alignment use 1;
- type ClusterU_Ref is access ClusterU;
+ package AACU is new Address_To_Access_Conversions (ClusterU);
type Rev_ClusterU is new ClusterU
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_ClusterU_Ref is access Rev_ClusterU;
+
+ package Rev_AACU is new Address_To_Access_Conversions (Rev_ClusterU);
------------
-- Get_68 --
N : Natural;
Rev_SSO : Boolean) return Bits_68
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
return
(if Rev_SSO then
N : Natural;
Rev_SSO : Boolean) return Bits_68
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : ClusterU_Ref with Address => A'Address, Import;
- RC : Rev_ClusterU_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AACU.Object_Pointer := AACU.To_Pointer (A);
+ RC : constant Rev_AACU.Object_Pointer := Rev_AACU.To_Pointer (A);
+
begin
return
(if Rev_SSO then
E : Bits_68;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
E : Bits_68;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : ClusterU_Ref with Address => A'Address, Import;
- RC : Rev_ClusterU_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AACU.Object_Pointer := AACU.To_Pointer (A);
+ RC : constant Rev_AACU.Object_Pointer := Rev_AACU.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
-- --
------------------------------------------------------------------------------
+with System.Address_To_Access_Conversions;
with System.Storage_Elements;
with System.Unsigned_Types;
-- Use maximum possible alignment, given the bit field size, since this
-- will result in the most efficient code possible for the field.
- type Cluster_Ref is access Cluster;
+ package AAC is new Address_To_Access_Conversions (Cluster);
+ -- We convert addresses to access values and dereference them instead of
+ -- directly using overlays in order to work around the implementation of
+ -- the RM 13.3(19) clause, which would pessimize the generated code.
type Rev_Cluster is new Cluster
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_Cluster_Ref is access Rev_Cluster;
+
+ package Rev_AAC is new Address_To_Access_Conversions (Rev_Cluster);
------------
-- Get_69 --
N : Natural;
Rev_SSO : Boolean) return Bits_69
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
return
(if Rev_SSO then
E : Bits_69;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
-- --
------------------------------------------------------------------------------
+with System.Address_To_Access_Conversions;
with System.Storage_Elements;
with System.Unsigned_Types;
-- Use maximum possible alignment, given the bit field size, since this
-- will result in the most efficient code possible for the field.
- type Cluster_Ref is access Cluster;
+ package AAC is new Address_To_Access_Conversions (Cluster);
+ -- We convert addresses to access values and dereference them instead of
+ -- directly using overlays in order to work around the implementation of
+ -- the RM 13.3(19) clause, which would pessimize the generated code.
type Rev_Cluster is new Cluster
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_Cluster_Ref is access Rev_Cluster;
+
+ package Rev_AAC is new Address_To_Access_Conversions (Rev_Cluster);
-- The following declarations are for the case where the address
-- passed to GetU_70 or SetU_70 is not guaranteed to be aligned.
type ClusterU is new Cluster;
for ClusterU'Alignment use 1;
- type ClusterU_Ref is access ClusterU;
+ package AACU is new Address_To_Access_Conversions (ClusterU);
type Rev_ClusterU is new ClusterU
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_ClusterU_Ref is access Rev_ClusterU;
+
+ package Rev_AACU is new Address_To_Access_Conversions (Rev_ClusterU);
------------
-- Get_70 --
N : Natural;
Rev_SSO : Boolean) return Bits_70
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
return
(if Rev_SSO then
N : Natural;
Rev_SSO : Boolean) return Bits_70
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : ClusterU_Ref with Address => A'Address, Import;
- RC : Rev_ClusterU_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AACU.Object_Pointer := AACU.To_Pointer (A);
+ RC : constant Rev_AACU.Object_Pointer := Rev_AACU.To_Pointer (A);
+
begin
return
(if Rev_SSO then
E : Bits_70;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
E : Bits_70;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : ClusterU_Ref with Address => A'Address, Import;
- RC : Rev_ClusterU_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AACU.Object_Pointer := AACU.To_Pointer (A);
+ RC : constant Rev_AACU.Object_Pointer := Rev_AACU.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
-- --
------------------------------------------------------------------------------
+with System.Address_To_Access_Conversions;
with System.Storage_Elements;
with System.Unsigned_Types;
-- Use maximum possible alignment, given the bit field size, since this
-- will result in the most efficient code possible for the field.
- type Cluster_Ref is access Cluster;
+ package AAC is new Address_To_Access_Conversions (Cluster);
+ -- We convert addresses to access values and dereference them instead of
+ -- directly using overlays in order to work around the implementation of
+ -- the RM 13.3(19) clause, which would pessimize the generated code.
type Rev_Cluster is new Cluster
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_Cluster_Ref is access Rev_Cluster;
+
+ package Rev_AAC is new Address_To_Access_Conversions (Rev_Cluster);
------------
-- Get_71 --
N : Natural;
Rev_SSO : Boolean) return Bits_71
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
return
(if Rev_SSO then
E : Bits_71;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
-- --
------------------------------------------------------------------------------
+with System.Address_To_Access_Conversions;
with System.Storage_Elements;
with System.Unsigned_Types;
-- Use maximum possible alignment, given the bit field size, since this
-- will result in the most efficient code possible for the field.
- type Cluster_Ref is access Cluster;
+ package AAC is new Address_To_Access_Conversions (Cluster);
+ -- We convert addresses to access values and dereference them instead of
+ -- directly using overlays in order to work around the implementation of
+ -- the RM 13.3(19) clause, which would pessimize the generated code.
type Rev_Cluster is new Cluster
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_Cluster_Ref is access Rev_Cluster;
+
+ package Rev_AAC is new Address_To_Access_Conversions (Rev_Cluster);
-- The following declarations are for the case where the address
-- passed to GetU_72 or SetU_72 is not guaranteed to be aligned.
type ClusterU is new Cluster;
for ClusterU'Alignment use 1;
- type ClusterU_Ref is access ClusterU;
+ package AACU is new Address_To_Access_Conversions (ClusterU);
type Rev_ClusterU is new ClusterU
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_ClusterU_Ref is access Rev_ClusterU;
+
+ package Rev_AACU is new Address_To_Access_Conversions (Rev_ClusterU);
------------
-- Get_72 --
N : Natural;
Rev_SSO : Boolean) return Bits_72
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
return
(if Rev_SSO then
N : Natural;
Rev_SSO : Boolean) return Bits_72
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : ClusterU_Ref with Address => A'Address, Import;
- RC : Rev_ClusterU_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AACU.Object_Pointer := AACU.To_Pointer (A);
+ RC : constant Rev_AACU.Object_Pointer := Rev_AACU.To_Pointer (A);
+
begin
return
(if Rev_SSO then
E : Bits_72;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
E : Bits_72;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : ClusterU_Ref with Address => A'Address, Import;
- RC : Rev_ClusterU_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AACU.Object_Pointer := AACU.To_Pointer (A);
+ RC : constant Rev_AACU.Object_Pointer := Rev_AACU.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
-- --
------------------------------------------------------------------------------
+with System.Address_To_Access_Conversions;
with System.Storage_Elements;
with System.Unsigned_Types;
-- Use maximum possible alignment, given the bit field size, since this
-- will result in the most efficient code possible for the field.
- type Cluster_Ref is access Cluster;
+ package AAC is new Address_To_Access_Conversions (Cluster);
+ -- We convert addresses to access values and dereference them instead of
+ -- directly using overlays in order to work around the implementation of
+ -- the RM 13.3(19) clause, which would pessimize the generated code.
type Rev_Cluster is new Cluster
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_Cluster_Ref is access Rev_Cluster;
+
+ package Rev_AAC is new Address_To_Access_Conversions (Rev_Cluster);
------------
-- Get_73 --
N : Natural;
Rev_SSO : Boolean) return Bits_73
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
return
(if Rev_SSO then
E : Bits_73;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
-- --
------------------------------------------------------------------------------
+with System.Address_To_Access_Conversions;
with System.Storage_Elements;
with System.Unsigned_Types;
-- Use maximum possible alignment, given the bit field size, since this
-- will result in the most efficient code possible for the field.
- type Cluster_Ref is access Cluster;
+ package AAC is new Address_To_Access_Conversions (Cluster);
+ -- We convert addresses to access values and dereference them instead of
+ -- directly using overlays in order to work around the implementation of
+ -- the RM 13.3(19) clause, which would pessimize the generated code.
type Rev_Cluster is new Cluster
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_Cluster_Ref is access Rev_Cluster;
+
+ package Rev_AAC is new Address_To_Access_Conversions (Rev_Cluster);
-- The following declarations are for the case where the address
-- passed to GetU_74 or SetU_74 is not guaranteed to be aligned.
type ClusterU is new Cluster;
for ClusterU'Alignment use 1;
- type ClusterU_Ref is access ClusterU;
+ package AACU is new Address_To_Access_Conversions (ClusterU);
type Rev_ClusterU is new ClusterU
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_ClusterU_Ref is access Rev_ClusterU;
+
+ package Rev_AACU is new Address_To_Access_Conversions (Rev_ClusterU);
------------
-- Get_74 --
N : Natural;
Rev_SSO : Boolean) return Bits_74
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
return
(if Rev_SSO then
N : Natural;
Rev_SSO : Boolean) return Bits_74
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : ClusterU_Ref with Address => A'Address, Import;
- RC : Rev_ClusterU_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AACU.Object_Pointer := AACU.To_Pointer (A);
+ RC : constant Rev_AACU.Object_Pointer := Rev_AACU.To_Pointer (A);
+
begin
return
(if Rev_SSO then
E : Bits_74;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
E : Bits_74;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : ClusterU_Ref with Address => A'Address, Import;
- RC : Rev_ClusterU_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AACU.Object_Pointer := AACU.To_Pointer (A);
+ RC : constant Rev_AACU.Object_Pointer := Rev_AACU.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
-- --
------------------------------------------------------------------------------
+with System.Address_To_Access_Conversions;
with System.Storage_Elements;
with System.Unsigned_Types;
-- Use maximum possible alignment, given the bit field size, since this
-- will result in the most efficient code possible for the field.
- type Cluster_Ref is access Cluster;
+ package AAC is new Address_To_Access_Conversions (Cluster);
+ -- We convert addresses to access values and dereference them instead of
+ -- directly using overlays in order to work around the implementation of
+ -- the RM 13.3(19) clause, which would pessimize the generated code.
type Rev_Cluster is new Cluster
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_Cluster_Ref is access Rev_Cluster;
+
+ package Rev_AAC is new Address_To_Access_Conversions (Rev_Cluster);
------------
-- Get_75 --
N : Natural;
Rev_SSO : Boolean) return Bits_75
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
return
(if Rev_SSO then
E : Bits_75;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
-- --
------------------------------------------------------------------------------
+with System.Address_To_Access_Conversions;
with System.Storage_Elements;
with System.Unsigned_Types;
-- Use maximum possible alignment, given the bit field size, since this
-- will result in the most efficient code possible for the field.
- type Cluster_Ref is access Cluster;
+ package AAC is new Address_To_Access_Conversions (Cluster);
+ -- We convert addresses to access values and dereference them instead of
+ -- directly using overlays in order to work around the implementation of
+ -- the RM 13.3(19) clause, which would pessimize the generated code.
type Rev_Cluster is new Cluster
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_Cluster_Ref is access Rev_Cluster;
+
+ package Rev_AAC is new Address_To_Access_Conversions (Rev_Cluster);
-- The following declarations are for the case where the address
-- passed to GetU_76 or SetU_76 is not guaranteed to be aligned.
type ClusterU is new Cluster;
for ClusterU'Alignment use 1;
- type ClusterU_Ref is access ClusterU;
+ package AACU is new Address_To_Access_Conversions (ClusterU);
type Rev_ClusterU is new ClusterU
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_ClusterU_Ref is access Rev_ClusterU;
+
+ package Rev_AACU is new Address_To_Access_Conversions (Rev_ClusterU);
------------
-- Get_76 --
N : Natural;
Rev_SSO : Boolean) return Bits_76
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
return
(if Rev_SSO then
N : Natural;
Rev_SSO : Boolean) return Bits_76
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : ClusterU_Ref with Address => A'Address, Import;
- RC : Rev_ClusterU_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AACU.Object_Pointer := AACU.To_Pointer (A);
+ RC : constant Rev_AACU.Object_Pointer := Rev_AACU.To_Pointer (A);
+
begin
return
(if Rev_SSO then
E : Bits_76;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
E : Bits_76;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : ClusterU_Ref with Address => A'Address, Import;
- RC : Rev_ClusterU_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AACU.Object_Pointer := AACU.To_Pointer (A);
+ RC : constant Rev_AACU.Object_Pointer := Rev_AACU.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
-- --
------------------------------------------------------------------------------
+with System.Address_To_Access_Conversions;
with System.Storage_Elements;
with System.Unsigned_Types;
-- Use maximum possible alignment, given the bit field size, since this
-- will result in the most efficient code possible for the field.
- type Cluster_Ref is access Cluster;
+ package AAC is new Address_To_Access_Conversions (Cluster);
+ -- We convert addresses to access values and dereference them instead of
+ -- directly using overlays in order to work around the implementation of
+ -- the RM 13.3(19) clause, which would pessimize the generated code.
type Rev_Cluster is new Cluster
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_Cluster_Ref is access Rev_Cluster;
+
+ package Rev_AAC is new Address_To_Access_Conversions (Rev_Cluster);
------------
-- Get_77 --
N : Natural;
Rev_SSO : Boolean) return Bits_77
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
return
(if Rev_SSO then
E : Bits_77;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
-- --
------------------------------------------------------------------------------
+with System.Address_To_Access_Conversions;
with System.Storage_Elements;
with System.Unsigned_Types;
-- Use maximum possible alignment, given the bit field size, since this
-- will result in the most efficient code possible for the field.
- type Cluster_Ref is access Cluster;
+ package AAC is new Address_To_Access_Conversions (Cluster);
+ -- We convert addresses to access values and dereference them instead of
+ -- directly using overlays in order to work around the implementation of
+ -- the RM 13.3(19) clause, which would pessimize the generated code.
type Rev_Cluster is new Cluster
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_Cluster_Ref is access Rev_Cluster;
+
+ package Rev_AAC is new Address_To_Access_Conversions (Rev_Cluster);
-- The following declarations are for the case where the address
-- passed to GetU_78 or SetU_78 is not guaranteed to be aligned.
type ClusterU is new Cluster;
for ClusterU'Alignment use 1;
- type ClusterU_Ref is access ClusterU;
+ package AACU is new Address_To_Access_Conversions (ClusterU);
type Rev_ClusterU is new ClusterU
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_ClusterU_Ref is access Rev_ClusterU;
+
+ package Rev_AACU is new Address_To_Access_Conversions (Rev_ClusterU);
------------
-- Get_78 --
N : Natural;
Rev_SSO : Boolean) return Bits_78
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
return
(if Rev_SSO then
N : Natural;
Rev_SSO : Boolean) return Bits_78
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : ClusterU_Ref with Address => A'Address, Import;
- RC : Rev_ClusterU_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AACU.Object_Pointer := AACU.To_Pointer (A);
+ RC : constant Rev_AACU.Object_Pointer := Rev_AACU.To_Pointer (A);
+
begin
return
(if Rev_SSO then
E : Bits_78;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
E : Bits_78;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : ClusterU_Ref with Address => A'Address, Import;
- RC : Rev_ClusterU_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AACU.Object_Pointer := AACU.To_Pointer (A);
+ RC : constant Rev_AACU.Object_Pointer := Rev_AACU.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
-- --
------------------------------------------------------------------------------
+with System.Address_To_Access_Conversions;
with System.Storage_Elements;
with System.Unsigned_Types;
-- Use maximum possible alignment, given the bit field size, since this
-- will result in the most efficient code possible for the field.
- type Cluster_Ref is access Cluster;
+ package AAC is new Address_To_Access_Conversions (Cluster);
+ -- We convert addresses to access values and dereference them instead of
+ -- directly using overlays in order to work around the implementation of
+ -- the RM 13.3(19) clause, which would pessimize the generated code.
type Rev_Cluster is new Cluster
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_Cluster_Ref is access Rev_Cluster;
+
+ package Rev_AAC is new Address_To_Access_Conversions (Rev_Cluster);
------------
-- Get_79 --
N : Natural;
Rev_SSO : Boolean) return Bits_79
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
return
(if Rev_SSO then
E : Bits_79;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
-- --
------------------------------------------------------------------------------
+with System.Address_To_Access_Conversions;
with System.Storage_Elements;
with System.Unsigned_Types;
-- Use maximum possible alignment, given the bit field size, since this
-- will result in the most efficient code possible for the field.
- type Cluster_Ref is access Cluster;
+ package AAC is new Address_To_Access_Conversions (Cluster);
+ -- We convert addresses to access values and dereference them instead of
+ -- directly using overlays in order to work around the implementation of
+ -- the RM 13.3(19) clause, which would pessimize the generated code.
type Rev_Cluster is new Cluster
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_Cluster_Ref is access Rev_Cluster;
+
+ package Rev_AAC is new Address_To_Access_Conversions (Rev_Cluster);
-- The following declarations are for the case where the address
-- passed to GetU_80 or SetU_80 is not guaranteed to be aligned.
type ClusterU is new Cluster;
for ClusterU'Alignment use 1;
- type ClusterU_Ref is access ClusterU;
+ package AACU is new Address_To_Access_Conversions (ClusterU);
type Rev_ClusterU is new ClusterU
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_ClusterU_Ref is access Rev_ClusterU;
+
+ package Rev_AACU is new Address_To_Access_Conversions (Rev_ClusterU);
------------
-- Get_80 --
N : Natural;
Rev_SSO : Boolean) return Bits_80
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
return
(if Rev_SSO then
N : Natural;
Rev_SSO : Boolean) return Bits_80
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : ClusterU_Ref with Address => A'Address, Import;
- RC : Rev_ClusterU_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AACU.Object_Pointer := AACU.To_Pointer (A);
+ RC : constant Rev_AACU.Object_Pointer := Rev_AACU.To_Pointer (A);
+
begin
return
(if Rev_SSO then
E : Bits_80;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
E : Bits_80;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : ClusterU_Ref with Address => A'Address, Import;
- RC : Rev_ClusterU_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AACU.Object_Pointer := AACU.To_Pointer (A);
+ RC : constant Rev_AACU.Object_Pointer := Rev_AACU.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
-- --
------------------------------------------------------------------------------
+with System.Address_To_Access_Conversions;
with System.Storage_Elements;
with System.Unsigned_Types;
-- Use maximum possible alignment, given the bit field size, since this
-- will result in the most efficient code possible for the field.
- type Cluster_Ref is access Cluster;
+ package AAC is new Address_To_Access_Conversions (Cluster);
+ -- We convert addresses to access values and dereference them instead of
+ -- directly using overlays in order to work around the implementation of
+ -- the RM 13.3(19) clause, which would pessimize the generated code.
type Rev_Cluster is new Cluster
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_Cluster_Ref is access Rev_Cluster;
+
+ package Rev_AAC is new Address_To_Access_Conversions (Rev_Cluster);
------------
-- Get_81 --
N : Natural;
Rev_SSO : Boolean) return Bits_81
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
return
(if Rev_SSO then
E : Bits_81;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
-- --
------------------------------------------------------------------------------
+with System.Address_To_Access_Conversions;
with System.Storage_Elements;
with System.Unsigned_Types;
-- Use maximum possible alignment, given the bit field size, since this
-- will result in the most efficient code possible for the field.
- type Cluster_Ref is access Cluster;
+ package AAC is new Address_To_Access_Conversions (Cluster);
+ -- We convert addresses to access values and dereference them instead of
+ -- directly using overlays in order to work around the implementation of
+ -- the RM 13.3(19) clause, which would pessimize the generated code.
type Rev_Cluster is new Cluster
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_Cluster_Ref is access Rev_Cluster;
+
+ package Rev_AAC is new Address_To_Access_Conversions (Rev_Cluster);
-- The following declarations are for the case where the address
-- passed to GetU_82 or SetU_82 is not guaranteed to be aligned.
type ClusterU is new Cluster;
for ClusterU'Alignment use 1;
- type ClusterU_Ref is access ClusterU;
+ package AACU is new Address_To_Access_Conversions (ClusterU);
type Rev_ClusterU is new ClusterU
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_ClusterU_Ref is access Rev_ClusterU;
+
+ package Rev_AACU is new Address_To_Access_Conversions (Rev_ClusterU);
------------
-- Get_82 --
N : Natural;
Rev_SSO : Boolean) return Bits_82
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
return
(if Rev_SSO then
N : Natural;
Rev_SSO : Boolean) return Bits_82
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : ClusterU_Ref with Address => A'Address, Import;
- RC : Rev_ClusterU_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AACU.Object_Pointer := AACU.To_Pointer (A);
+ RC : constant Rev_AACU.Object_Pointer := Rev_AACU.To_Pointer (A);
+
begin
return
(if Rev_SSO then
E : Bits_82;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
E : Bits_82;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : ClusterU_Ref with Address => A'Address, Import;
- RC : Rev_ClusterU_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AACU.Object_Pointer := AACU.To_Pointer (A);
+ RC : constant Rev_AACU.Object_Pointer := Rev_AACU.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
-- --
------------------------------------------------------------------------------
+with System.Address_To_Access_Conversions;
with System.Storage_Elements;
with System.Unsigned_Types;
-- Use maximum possible alignment, given the bit field size, since this
-- will result in the most efficient code possible for the field.
- type Cluster_Ref is access Cluster;
+ package AAC is new Address_To_Access_Conversions (Cluster);
+ -- We convert addresses to access values and dereference them instead of
+ -- directly using overlays in order to work around the implementation of
+ -- the RM 13.3(19) clause, which would pessimize the generated code.
type Rev_Cluster is new Cluster
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_Cluster_Ref is access Rev_Cluster;
+
+ package Rev_AAC is new Address_To_Access_Conversions (Rev_Cluster);
------------
-- Get_83 --
N : Natural;
Rev_SSO : Boolean) return Bits_83
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
return
(if Rev_SSO then
E : Bits_83;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
-- --
------------------------------------------------------------------------------
+with System.Address_To_Access_Conversions;
with System.Storage_Elements;
with System.Unsigned_Types;
-- Use maximum possible alignment, given the bit field size, since this
-- will result in the most efficient code possible for the field.
- type Cluster_Ref is access Cluster;
+ package AAC is new Address_To_Access_Conversions (Cluster);
+ -- We convert addresses to access values and dereference them instead of
+ -- directly using overlays in order to work around the implementation of
+ -- the RM 13.3(19) clause, which would pessimize the generated code.
type Rev_Cluster is new Cluster
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_Cluster_Ref is access Rev_Cluster;
+
+ package Rev_AAC is new Address_To_Access_Conversions (Rev_Cluster);
-- The following declarations are for the case where the address
-- passed to GetU_84 or SetU_84 is not guaranteed to be aligned.
type ClusterU is new Cluster;
for ClusterU'Alignment use 1;
- type ClusterU_Ref is access ClusterU;
+ package AACU is new Address_To_Access_Conversions (ClusterU);
type Rev_ClusterU is new ClusterU
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_ClusterU_Ref is access Rev_ClusterU;
+
+ package Rev_AACU is new Address_To_Access_Conversions (Rev_ClusterU);
------------
-- Get_84 --
N : Natural;
Rev_SSO : Boolean) return Bits_84
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
return
(if Rev_SSO then
N : Natural;
Rev_SSO : Boolean) return Bits_84
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : ClusterU_Ref with Address => A'Address, Import;
- RC : Rev_ClusterU_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AACU.Object_Pointer := AACU.To_Pointer (A);
+ RC : constant Rev_AACU.Object_Pointer := Rev_AACU.To_Pointer (A);
+
begin
return
(if Rev_SSO then
E : Bits_84;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
E : Bits_84;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : ClusterU_Ref with Address => A'Address, Import;
- RC : Rev_ClusterU_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AACU.Object_Pointer := AACU.To_Pointer (A);
+ RC : constant Rev_AACU.Object_Pointer := Rev_AACU.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
-- --
------------------------------------------------------------------------------
+with System.Address_To_Access_Conversions;
with System.Storage_Elements;
with System.Unsigned_Types;
-- Use maximum possible alignment, given the bit field size, since this
-- will result in the most efficient code possible for the field.
- type Cluster_Ref is access Cluster;
+ package AAC is new Address_To_Access_Conversions (Cluster);
+ -- We convert addresses to access values and dereference them instead of
+ -- directly using overlays in order to work around the implementation of
+ -- the RM 13.3(19) clause, which would pessimize the generated code.
type Rev_Cluster is new Cluster
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_Cluster_Ref is access Rev_Cluster;
+
+ package Rev_AAC is new Address_To_Access_Conversions (Rev_Cluster);
------------
-- Get_85 --
N : Natural;
Rev_SSO : Boolean) return Bits_85
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
return
(if Rev_SSO then
E : Bits_85;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
-- --
------------------------------------------------------------------------------
+with System.Address_To_Access_Conversions;
with System.Storage_Elements;
with System.Unsigned_Types;
-- Use maximum possible alignment, given the bit field size, since this
-- will result in the most efficient code possible for the field.
- type Cluster_Ref is access Cluster;
+ package AAC is new Address_To_Access_Conversions (Cluster);
+ -- We convert addresses to access values and dereference them instead of
+ -- directly using overlays in order to work around the implementation of
+ -- the RM 13.3(19) clause, which would pessimize the generated code.
type Rev_Cluster is new Cluster
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_Cluster_Ref is access Rev_Cluster;
+
+ package Rev_AAC is new Address_To_Access_Conversions (Rev_Cluster);
-- The following declarations are for the case where the address
-- passed to GetU_86 or SetU_86 is not guaranteed to be aligned.
type ClusterU is new Cluster;
for ClusterU'Alignment use 1;
- type ClusterU_Ref is access ClusterU;
+ package AACU is new Address_To_Access_Conversions (ClusterU);
type Rev_ClusterU is new ClusterU
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_ClusterU_Ref is access Rev_ClusterU;
+
+ package Rev_AACU is new Address_To_Access_Conversions (Rev_ClusterU);
------------
-- Get_86 --
N : Natural;
Rev_SSO : Boolean) return Bits_86
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
return
(if Rev_SSO then
N : Natural;
Rev_SSO : Boolean) return Bits_86
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : ClusterU_Ref with Address => A'Address, Import;
- RC : Rev_ClusterU_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AACU.Object_Pointer := AACU.To_Pointer (A);
+ RC : constant Rev_AACU.Object_Pointer := Rev_AACU.To_Pointer (A);
+
begin
return
(if Rev_SSO then
E : Bits_86;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
E : Bits_86;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : ClusterU_Ref with Address => A'Address, Import;
- RC : Rev_ClusterU_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AACU.Object_Pointer := AACU.To_Pointer (A);
+ RC : constant Rev_AACU.Object_Pointer := Rev_AACU.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
-- --
------------------------------------------------------------------------------
+with System.Address_To_Access_Conversions;
with System.Storage_Elements;
with System.Unsigned_Types;
-- Use maximum possible alignment, given the bit field size, since this
-- will result in the most efficient code possible for the field.
- type Cluster_Ref is access Cluster;
+ package AAC is new Address_To_Access_Conversions (Cluster);
+ -- We convert addresses to access values and dereference them instead of
+ -- directly using overlays in order to work around the implementation of
+ -- the RM 13.3(19) clause, which would pessimize the generated code.
type Rev_Cluster is new Cluster
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_Cluster_Ref is access Rev_Cluster;
+
+ package Rev_AAC is new Address_To_Access_Conversions (Rev_Cluster);
------------
-- Get_87 --
N : Natural;
Rev_SSO : Boolean) return Bits_87
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
return
(if Rev_SSO then
E : Bits_87;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
-- --
------------------------------------------------------------------------------
+with System.Address_To_Access_Conversions;
with System.Storage_Elements;
with System.Unsigned_Types;
-- Use maximum possible alignment, given the bit field size, since this
-- will result in the most efficient code possible for the field.
- type Cluster_Ref is access Cluster;
+ package AAC is new Address_To_Access_Conversions (Cluster);
+ -- We convert addresses to access values and dereference them instead of
+ -- directly using overlays in order to work around the implementation of
+ -- the RM 13.3(19) clause, which would pessimize the generated code.
type Rev_Cluster is new Cluster
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_Cluster_Ref is access Rev_Cluster;
+
+ package Rev_AAC is new Address_To_Access_Conversions (Rev_Cluster);
-- The following declarations are for the case where the address
-- passed to GetU_88 or SetU_88 is not guaranteed to be aligned.
type ClusterU is new Cluster;
for ClusterU'Alignment use 1;
- type ClusterU_Ref is access ClusterU;
+ package AACU is new Address_To_Access_Conversions (ClusterU);
type Rev_ClusterU is new ClusterU
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_ClusterU_Ref is access Rev_ClusterU;
+
+ package Rev_AACU is new Address_To_Access_Conversions (Rev_ClusterU);
------------
-- Get_88 --
N : Natural;
Rev_SSO : Boolean) return Bits_88
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
return
(if Rev_SSO then
N : Natural;
Rev_SSO : Boolean) return Bits_88
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : ClusterU_Ref with Address => A'Address, Import;
- RC : Rev_ClusterU_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AACU.Object_Pointer := AACU.To_Pointer (A);
+ RC : constant Rev_AACU.Object_Pointer := Rev_AACU.To_Pointer (A);
+
begin
return
(if Rev_SSO then
E : Bits_88;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
E : Bits_88;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : ClusterU_Ref with Address => A'Address, Import;
- RC : Rev_ClusterU_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AACU.Object_Pointer := AACU.To_Pointer (A);
+ RC : constant Rev_AACU.Object_Pointer := Rev_AACU.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
-- --
------------------------------------------------------------------------------
+with System.Address_To_Access_Conversions;
with System.Storage_Elements;
with System.Unsigned_Types;
-- Use maximum possible alignment, given the bit field size, since this
-- will result in the most efficient code possible for the field.
- type Cluster_Ref is access Cluster;
+ package AAC is new Address_To_Access_Conversions (Cluster);
+ -- We convert addresses to access values and dereference them instead of
+ -- directly using overlays in order to work around the implementation of
+ -- the RM 13.3(19) clause, which would pessimize the generated code.
type Rev_Cluster is new Cluster
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_Cluster_Ref is access Rev_Cluster;
+
+ package Rev_AAC is new Address_To_Access_Conversions (Rev_Cluster);
------------
-- Get_89 --
N : Natural;
Rev_SSO : Boolean) return Bits_89
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
return
(if Rev_SSO then
E : Bits_89;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
-- --
------------------------------------------------------------------------------
+with System.Address_To_Access_Conversions;
with System.Storage_Elements;
with System.Unsigned_Types;
-- Use maximum possible alignment, given the bit field size, since this
-- will result in the most efficient code possible for the field.
- type Cluster_Ref is access Cluster;
+ package AAC is new Address_To_Access_Conversions (Cluster);
+ -- We convert addresses to access values and dereference them instead of
+ -- directly using overlays in order to work around the implementation of
+ -- the RM 13.3(19) clause, which would pessimize the generated code.
type Rev_Cluster is new Cluster
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_Cluster_Ref is access Rev_Cluster;
+
+ package Rev_AAC is new Address_To_Access_Conversions (Rev_Cluster);
-- The following declarations are for the case where the address
-- passed to GetU_90 or SetU_90 is not guaranteed to be aligned.
type ClusterU is new Cluster;
for ClusterU'Alignment use 1;
- type ClusterU_Ref is access ClusterU;
+ package AACU is new Address_To_Access_Conversions (ClusterU);
type Rev_ClusterU is new ClusterU
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_ClusterU_Ref is access Rev_ClusterU;
+
+ package Rev_AACU is new Address_To_Access_Conversions (Rev_ClusterU);
------------
-- Get_90 --
N : Natural;
Rev_SSO : Boolean) return Bits_90
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
return
(if Rev_SSO then
N : Natural;
Rev_SSO : Boolean) return Bits_90
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : ClusterU_Ref with Address => A'Address, Import;
- RC : Rev_ClusterU_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AACU.Object_Pointer := AACU.To_Pointer (A);
+ RC : constant Rev_AACU.Object_Pointer := Rev_AACU.To_Pointer (A);
+
begin
return
(if Rev_SSO then
E : Bits_90;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
E : Bits_90;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : ClusterU_Ref with Address => A'Address, Import;
- RC : Rev_ClusterU_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AACU.Object_Pointer := AACU.To_Pointer (A);
+ RC : constant Rev_AACU.Object_Pointer := Rev_AACU.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
-- --
------------------------------------------------------------------------------
+with System.Address_To_Access_Conversions;
with System.Storage_Elements;
with System.Unsigned_Types;
-- Use maximum possible alignment, given the bit field size, since this
-- will result in the most efficient code possible for the field.
- type Cluster_Ref is access Cluster;
+ package AAC is new Address_To_Access_Conversions (Cluster);
+ -- We convert addresses to access values and dereference them instead of
+ -- directly using overlays in order to work around the implementation of
+ -- the RM 13.3(19) clause, which would pessimize the generated code.
type Rev_Cluster is new Cluster
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_Cluster_Ref is access Rev_Cluster;
+
+ package Rev_AAC is new Address_To_Access_Conversions (Rev_Cluster);
------------
-- Get_91 --
N : Natural;
Rev_SSO : Boolean) return Bits_91
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
return
(if Rev_SSO then
E : Bits_91;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
-- --
------------------------------------------------------------------------------
+with System.Address_To_Access_Conversions;
with System.Storage_Elements;
with System.Unsigned_Types;
-- Use maximum possible alignment, given the bit field size, since this
-- will result in the most efficient code possible for the field.
- type Cluster_Ref is access Cluster;
+ package AAC is new Address_To_Access_Conversions (Cluster);
+ -- We convert addresses to access values and dereference them instead of
+ -- directly using overlays in order to work around the implementation of
+ -- the RM 13.3(19) clause, which would pessimize the generated code.
type Rev_Cluster is new Cluster
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_Cluster_Ref is access Rev_Cluster;
+
+ package Rev_AAC is new Address_To_Access_Conversions (Rev_Cluster);
-- The following declarations are for the case where the address
-- passed to GetU_92 or SetU_92 is not guaranteed to be aligned.
type ClusterU is new Cluster;
for ClusterU'Alignment use 1;
- type ClusterU_Ref is access ClusterU;
+ package AACU is new Address_To_Access_Conversions (ClusterU);
type Rev_ClusterU is new ClusterU
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_ClusterU_Ref is access Rev_ClusterU;
+
+ package Rev_AACU is new Address_To_Access_Conversions (Rev_ClusterU);
------------
-- Get_92 --
N : Natural;
Rev_SSO : Boolean) return Bits_92
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
return
(if Rev_SSO then
N : Natural;
Rev_SSO : Boolean) return Bits_92
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : ClusterU_Ref with Address => A'Address, Import;
- RC : Rev_ClusterU_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AACU.Object_Pointer := AACU.To_Pointer (A);
+ RC : constant Rev_AACU.Object_Pointer := Rev_AACU.To_Pointer (A);
+
begin
return
(if Rev_SSO then
E : Bits_92;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
E : Bits_92;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : ClusterU_Ref with Address => A'Address, Import;
- RC : Rev_ClusterU_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AACU.Object_Pointer := AACU.To_Pointer (A);
+ RC : constant Rev_AACU.Object_Pointer := Rev_AACU.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
-- --
------------------------------------------------------------------------------
+with System.Address_To_Access_Conversions;
with System.Storage_Elements;
with System.Unsigned_Types;
-- Use maximum possible alignment, given the bit field size, since this
-- will result in the most efficient code possible for the field.
- type Cluster_Ref is access Cluster;
+ package AAC is new Address_To_Access_Conversions (Cluster);
+ -- We convert addresses to access values and dereference them instead of
+ -- directly using overlays in order to work around the implementation of
+ -- the RM 13.3(19) clause, which would pessimize the generated code.
type Rev_Cluster is new Cluster
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_Cluster_Ref is access Rev_Cluster;
+
+ package Rev_AAC is new Address_To_Access_Conversions (Rev_Cluster);
------------
-- Get_93 --
N : Natural;
Rev_SSO : Boolean) return Bits_93
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
return
(if Rev_SSO then
E : Bits_93;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
-- --
------------------------------------------------------------------------------
+with System.Address_To_Access_Conversions;
with System.Storage_Elements;
with System.Unsigned_Types;
-- Use maximum possible alignment, given the bit field size, since this
-- will result in the most efficient code possible for the field.
- type Cluster_Ref is access Cluster;
+ package AAC is new Address_To_Access_Conversions (Cluster);
+ -- We convert addresses to access values and dereference them instead of
+ -- directly using overlays in order to work around the implementation of
+ -- the RM 13.3(19) clause, which would pessimize the generated code.
type Rev_Cluster is new Cluster
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_Cluster_Ref is access Rev_Cluster;
+
+ package Rev_AAC is new Address_To_Access_Conversions (Rev_Cluster);
-- The following declarations are for the case where the address
-- passed to GetU_94 or SetU_94 is not guaranteed to be aligned.
type ClusterU is new Cluster;
for ClusterU'Alignment use 1;
- type ClusterU_Ref is access ClusterU;
+ package AACU is new Address_To_Access_Conversions (ClusterU);
type Rev_ClusterU is new ClusterU
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_ClusterU_Ref is access Rev_ClusterU;
+
+ package Rev_AACU is new Address_To_Access_Conversions (Rev_ClusterU);
------------
-- Get_94 --
N : Natural;
Rev_SSO : Boolean) return Bits_94
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
return
(if Rev_SSO then
N : Natural;
Rev_SSO : Boolean) return Bits_94
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : ClusterU_Ref with Address => A'Address, Import;
- RC : Rev_ClusterU_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AACU.Object_Pointer := AACU.To_Pointer (A);
+ RC : constant Rev_AACU.Object_Pointer := Rev_AACU.To_Pointer (A);
+
begin
return
(if Rev_SSO then
E : Bits_94;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
E : Bits_94;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : ClusterU_Ref with Address => A'Address, Import;
- RC : Rev_ClusterU_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AACU.Object_Pointer := AACU.To_Pointer (A);
+ RC : constant Rev_AACU.Object_Pointer := Rev_AACU.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
-- --
------------------------------------------------------------------------------
+with System.Address_To_Access_Conversions;
with System.Storage_Elements;
with System.Unsigned_Types;
-- Use maximum possible alignment, given the bit field size, since this
-- will result in the most efficient code possible for the field.
- type Cluster_Ref is access Cluster;
+ package AAC is new Address_To_Access_Conversions (Cluster);
+ -- We convert addresses to access values and dereference them instead of
+ -- directly using overlays in order to work around the implementation of
+ -- the RM 13.3(19) clause, which would pessimize the generated code.
type Rev_Cluster is new Cluster
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_Cluster_Ref is access Rev_Cluster;
+
+ package Rev_AAC is new Address_To_Access_Conversions (Rev_Cluster);
------------
-- Get_95 --
N : Natural;
Rev_SSO : Boolean) return Bits_95
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
return
(if Rev_SSO then
E : Bits_95;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
-- --
------------------------------------------------------------------------------
+with System.Address_To_Access_Conversions;
with System.Storage_Elements;
with System.Unsigned_Types;
-- Use maximum possible alignment, given the bit field size, since this
-- will result in the most efficient code possible for the field.
- type Cluster_Ref is access Cluster;
+ package AAC is new Address_To_Access_Conversions (Cluster);
+ -- We convert addresses to access values and dereference them instead of
+ -- directly using overlays in order to work around the implementation of
+ -- the RM 13.3(19) clause, which would pessimize the generated code.
type Rev_Cluster is new Cluster
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_Cluster_Ref is access Rev_Cluster;
+
+ package Rev_AAC is new Address_To_Access_Conversions (Rev_Cluster);
-- The following declarations are for the case where the address
-- passed to GetU_96 or SetU_96 is not guaranteed to be aligned.
type ClusterU is new Cluster;
for ClusterU'Alignment use 1;
- type ClusterU_Ref is access ClusterU;
+ package AACU is new Address_To_Access_Conversions (ClusterU);
type Rev_ClusterU is new ClusterU
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_ClusterU_Ref is access Rev_ClusterU;
+
+ package Rev_AACU is new Address_To_Access_Conversions (Rev_ClusterU);
------------
-- Get_96 --
N : Natural;
Rev_SSO : Boolean) return Bits_96
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
return
(if Rev_SSO then
N : Natural;
Rev_SSO : Boolean) return Bits_96
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : ClusterU_Ref with Address => A'Address, Import;
- RC : Rev_ClusterU_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AACU.Object_Pointer := AACU.To_Pointer (A);
+ RC : constant Rev_AACU.Object_Pointer := Rev_AACU.To_Pointer (A);
+
begin
return
(if Rev_SSO then
E : Bits_96;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
E : Bits_96;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : ClusterU_Ref with Address => A'Address, Import;
- RC : Rev_ClusterU_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AACU.Object_Pointer := AACU.To_Pointer (A);
+ RC : constant Rev_AACU.Object_Pointer := Rev_AACU.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
-- --
------------------------------------------------------------------------------
+with System.Address_To_Access_Conversions;
with System.Storage_Elements;
with System.Unsigned_Types;
-- Use maximum possible alignment, given the bit field size, since this
-- will result in the most efficient code possible for the field.
- type Cluster_Ref is access Cluster;
+ package AAC is new Address_To_Access_Conversions (Cluster);
+ -- We convert addresses to access values and dereference them instead of
+ -- directly using overlays in order to work around the implementation of
+ -- the RM 13.3(19) clause, which would pessimize the generated code.
type Rev_Cluster is new Cluster
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_Cluster_Ref is access Rev_Cluster;
+
+ package Rev_AAC is new Address_To_Access_Conversions (Rev_Cluster);
------------
-- Get_97 --
N : Natural;
Rev_SSO : Boolean) return Bits_97
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
return
(if Rev_SSO then
E : Bits_97;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
-- --
------------------------------------------------------------------------------
+with System.Address_To_Access_Conversions;
with System.Storage_Elements;
with System.Unsigned_Types;
-- Use maximum possible alignment, given the bit field size, since this
-- will result in the most efficient code possible for the field.
- type Cluster_Ref is access Cluster;
+ package AAC is new Address_To_Access_Conversions (Cluster);
+ -- We convert addresses to access values and dereference them instead of
+ -- directly using overlays in order to work around the implementation of
+ -- the RM 13.3(19) clause, which would pessimize the generated code.
type Rev_Cluster is new Cluster
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_Cluster_Ref is access Rev_Cluster;
+
+ package Rev_AAC is new Address_To_Access_Conversions (Rev_Cluster);
-- The following declarations are for the case where the address
-- passed to GetU_98 or SetU_98 is not guaranteed to be aligned.
type ClusterU is new Cluster;
for ClusterU'Alignment use 1;
- type ClusterU_Ref is access ClusterU;
+ package AACU is new Address_To_Access_Conversions (ClusterU);
type Rev_ClusterU is new ClusterU
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_ClusterU_Ref is access Rev_ClusterU;
+
+ package Rev_AACU is new Address_To_Access_Conversions (Rev_ClusterU);
------------
-- Get_98 --
N : Natural;
Rev_SSO : Boolean) return Bits_98
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
return
(if Rev_SSO then
N : Natural;
Rev_SSO : Boolean) return Bits_98
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : ClusterU_Ref with Address => A'Address, Import;
- RC : Rev_ClusterU_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AACU.Object_Pointer := AACU.To_Pointer (A);
+ RC : constant Rev_AACU.Object_Pointer := Rev_AACU.To_Pointer (A);
+
begin
return
(if Rev_SSO then
E : Bits_98;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
E : Bits_98;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : ClusterU_Ref with Address => A'Address, Import;
- RC : Rev_ClusterU_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AACU.Object_Pointer := AACU.To_Pointer (A);
+ RC : constant Rev_AACU.Object_Pointer := Rev_AACU.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
-- --
------------------------------------------------------------------------------
+with System.Address_To_Access_Conversions;
with System.Storage_Elements;
with System.Unsigned_Types;
-- Use maximum possible alignment, given the bit field size, since this
-- will result in the most efficient code possible for the field.
- type Cluster_Ref is access Cluster;
+ package AAC is new Address_To_Access_Conversions (Cluster);
+ -- We convert addresses to access values and dereference them instead of
+ -- directly using overlays in order to work around the implementation of
+ -- the RM 13.3(19) clause, which would pessimize the generated code.
type Rev_Cluster is new Cluster
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_Cluster_Ref is access Rev_Cluster;
+
+ package Rev_AAC is new Address_To_Access_Conversions (Rev_Cluster);
------------
-- Get_99 --
N : Natural;
Rev_SSO : Boolean) return Bits_99
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
return
(if Rev_SSO then
E : Bits_99;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
-- --
------------------------------------------------------------------------------
+with System.Address_To_Access_Conversions;
with System.Storage_Elements;
with System.Unsigned_Types;
-- Use maximum possible alignment, given the bit field size, since this
-- will result in the most efficient code possible for the field.
- type Cluster_Ref is access Cluster;
+ package AAC is new Address_To_Access_Conversions (Cluster);
+ -- We convert addresses to access values and dereference them instead of
+ -- directly using overlays in order to work around the implementation of
+ -- the RM 13.3(19) clause, which would pessimize the generated code.
type Rev_Cluster is new Cluster
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_Cluster_Ref is access Rev_Cluster;
+
+ package Rev_AAC is new Address_To_Access_Conversions (Rev_Cluster);
@even
-- The following declarations are for the case where the address
type ClusterU is new Cluster;
for ClusterU'Alignment use 1;
- type ClusterU_Ref is access ClusterU;
+ package AACU is new Address_To_Access_Conversions (ClusterU);
type Rev_ClusterU is new ClusterU
with Bit_Order => Reverse_Bit_Order,
Scalar_Storage_Order => Reverse_Bit_Order;
- type Rev_ClusterU_Ref is access Rev_ClusterU;
+
+ package Rev_AACU is new Address_To_Access_Conversions (Rev_ClusterU);
@/even
------------
N : Natural;
Rev_SSO : Boolean) return Bits_@@
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
return
(if Rev_SSO then
N : Natural;
Rev_SSO : Boolean) return Bits_@@
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : ClusterU_Ref with Address => A'Address, Import;
- RC : Rev_ClusterU_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AACU.Object_Pointer := AACU.To_Pointer (A);
+ RC : constant Rev_AACU.Object_Pointer := Rev_AACU.To_Pointer (A);
+
begin
return
(if Rev_SSO then
E : Bits_@@;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : Cluster_Ref with Address => A'Address, Import;
- RC : Rev_Cluster_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AAC.Object_Pointer := AAC.To_Pointer (A);
+ RC : constant Rev_AAC.Object_Pointer := Rev_AAC.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
E : Bits_@@;
Rev_SSO : Boolean)
is
- A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
- C : ClusterU_Ref with Address => A'Address, Import;
- RC : Rev_ClusterU_Ref with Address => A'Address, Import;
+ A : constant System.Address := Arr + Bits * Ofs (Uns (N) / 8);
+ C : constant AACU.Object_Pointer := AACU.To_Pointer (A);
+ RC : constant Rev_AACU.Object_Pointer := Rev_AACU.To_Pointer (A);
+
begin
if Rev_SSO then
case N07 (Uns (N) mod 8) is
projects / thirdparty / gcc.git / commitdiff
