+2016-07-04 Gary Dismukes <dismukes@adacore.com>
+
+ * sem_type.adb, einfo.ads, freeze.adb, exp_ch6.adb: Minor reformatting
+ and typo fix.
+
2016-07-04 Hristian Kirtchev <kirtchev@adacore.com>
* sem_ch3.adb, sem_type.adb, sem_ch12.adb, xref_lib.adb,
-- Is_Bit_Packed_Array (Flag122) [implementation base type only]
-- Defined in all entities. This flag is set for a packed array type that
--- is bit packed (i.e. the component size is known by the front end and
+-- is bit-packed (i.e. the component size is known by the front end and
-- is in the range 1-7, 9-15, 17-31, or 33-63). Is_Packed is always set
-- if Is_Bit_Packed_Array is set, but it is possible for Is_Packed to be
-- set without Is_Bit_Packed_Array if the component size is not known by
-- out that the component size doesn't require packing, the Is_Packed
-- flag gets turned off.
--- In the bit packed array case (i.e. component size is known at compile
+-- In the bit-packed array case (i.e. component size is known at compile
-- time and is 1-7, 9-15, 17-31 or 33-63), Is_Bit_Packed_Array will be
-- set once the array type is frozen.
--
-- Is_Packed_Array_Impl_Type (Flag138)
-- Defined in all entities. This flag is set on the entity for the type
-- used to implement a packed array (either a modular type or a subtype
--- of Packed_Bytes{1,2,4} in the bit packed array case, a regular array
+-- of Packed_Bytes{1,2,4} in the bit-packed array case, a regular array
-- in the non-standard enumeration index case). It is set if and only
-- if the type appears in the Packed_Array_Impl_Type field of some other
-- entity. It is used by the back end to activate the special processing
-- Packed_Array_Impl_Type (Node23)
-- Defined in array types and subtypes, except for the string literal
-- subtype case, if the corresponding type is packed and implemented
--- specially (either bit packed or packed to eliminate holes in the
+-- specially (either bit-packed or packed to eliminate holes in the
-- non-contiguous enumeration index types). References the type used to
-- represent the packed array, which is either a modular type for short
--- static arrays or an array of System.Unsigned in the bit packed case,
+-- static arrays or an array of System.Unsigned in the bit-packed case,
-- or a regular array in the non-standard enumeration index case). Note
-- that in some situations (internal types and references to fields of
-- variant records), it is not always possible to construct this type in
then
Add_Call_By_Copy_Code;
- -- References to components of bit packed arrays are expanded
+ -- References to components of bit-packed arrays are expanded
-- at this point, rather than at the point of analysis of the
-- actuals, to handle the expansion of the assignment to
-- [in] out parameters.
then
Add_Simple_Call_By_Copy_Code;
- -- References to slices of bit packed arrays are expanded
+ -- References to slices of bit-packed arrays are expanded
elsif Is_Ref_To_Bit_Packed_Slice (Actual) then
Add_Call_By_Copy_Code;
-- Processing for IN parameters
else
- -- For IN parameters in the bit packed array case, we expand an
+ -- For IN parameters in the bit-packed array case, we expand an
-- indexed component (the circuit in Exp_Ch4 deliberately left
-- indexed components appearing as actuals untouched, so that
-- the special processing above for the OUT and IN OUT cases
Reset_Packed_Prefix;
Expand_Packed_Element_Reference (Actual);
- -- If we have a reference to a bit packed array, we copy it, since
+ -- If we have a reference to a bit-packed array, we copy it, since
-- the actual must be byte aligned.
-- Is this really necessary in all cases???
if Is_Bit_Packed_Array (Arr) then
- -- Check number of elements for bit packed arrays that come from
+ -- Check number of elements for bit-packed arrays that come from
-- source and have compile time known ranges. The bit-packed
-- arrays circuitry does not support arrays with more than
-- Integer'Last + 1 elements, and when this restriction is
-- If any of the index types was an enumeration type with a non-
-- standard rep clause, then we indicate that the array type is
- -- always packed (even if it is not bit packed).
+ -- always packed (even if it is not bit-packed).
if Non_Standard_Enum then
Set_Has_Non_Standard_Rep (Base_Type (Arr));
Set_Component_Alignment_If_Not_Set (Arr);
- -- If the array is packed and bit packed or packed to eliminate holes
+ -- If the array is packed and bit-packed or packed to eliminate holes
-- in the non-contiguous enumeration index types, we must create the
-- packed array type to be used to actually implement the type. This
-- is only needed for real array types (not for string literal types,
-- component clauses, where we must check the size. This is not done
-- till the freeze point since for fixed-point types, we do not know
-- the size until the type is frozen. Similar processing applies to
- -- bit packed arrays.
+ -- bit-packed arrays.
if Is_First_Subtype (Rec) then
Comp := First_Component (Rec);
Act1 := Left_Opnd (N);
Act2 := Right_Opnd (N);
- -- Use the type of tye second formal, so as to include
+ -- Use the type of the second formal, so as to include
-- exponentiation, where the exponent may be ambiguous and
-- the result non-universal.
projects / gcc.git / commitdiff