blob: 13f381d77af8fe657fb51e5c7c3ec5781dddac61 [file] [log] [blame]
------------------------------------------------------------------------------
-- --
-- GNAT COMPILER COMPONENTS --
-- --
-- E I N F O --
-- --
-- B o d y --
-- --
-- Copyright (C) 1992-2019, Free Software Foundation, Inc. --
-- --
-- GNAT is free software; you can redistribute it and/or modify it under --
-- terms of the GNU General Public License as published by the Free Soft- --
-- ware Foundation; either version 3, or (at your option) any later ver- --
-- sion. GNAT is distributed in the hope that it will be useful, but WITH- --
-- OUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY --
-- or FITNESS FOR A PARTICULAR PURPOSE. --
-- --
-- As a special exception under Section 7 of GPL version 3, you are granted --
-- additional permissions described in the GCC Runtime Library Exception, --
-- version 3.1, as published by the Free Software Foundation. --
-- --
-- You should have received a copy of the GNU General Public License and --
-- a copy of the GCC Runtime Library Exception along with this program; --
-- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see --
-- <http://www.gnu.org/licenses/>. --
-- --
-- GNAT was originally developed by the GNAT team at New York University. --
-- Extensive contributions were provided by Ada Core Technologies Inc. --
-- --
------------------------------------------------------------------------------
pragma Style_Checks (All_Checks);
-- Turn off subprogram ordering, not used for this unit
with Atree; use Atree;
with Elists; use Elists;
with Namet; use Namet;
with Nlists; use Nlists;
with Output; use Output;
with Sinfo; use Sinfo;
with Stand; use Stand;
package body Einfo is
use Atree.Unchecked_Access;
-- This is one of the packages that is allowed direct untyped access to
-- the fields in a node, since it provides the next level abstraction
-- which incorporates appropriate checks.
----------------------------------------------
-- Usage of Fields in Defining Entity Nodes --
----------------------------------------------
-- Four of these fields are defined in Sinfo, since they in are the base
-- part of the node. The access routines for these four fields and the
-- corresponding set procedures are defined in Sinfo. These fields are
-- present in all entities. Note that Homonym is also in the base part of
-- the node, but has access routines that are more properly part of Einfo,
-- which is why they are defined here.
-- Chars Name1
-- Next_Entity Node2
-- Scope Node3
-- Etype Node5
-- Remaining fields are present only in extended nodes (i.e. entities).
-- The following fields are present in all entities
-- Homonym Node4
-- First_Rep_Item Node6
-- Freeze_Node Node7
-- Prev_Entity Node36
-- Associated_Entity Node37
-- The usage of other fields (and the entity kinds to which it applies)
-- depends on the particular field (see Einfo spec for details).
-- Associated_Node_For_Itype Node8
-- Dependent_Instances Elist8
-- Hiding_Loop_Variable Node8
-- Mechanism Uint8 (but returns Mechanism_Type)
-- Normalized_First_Bit Uint8
-- Refinement_Constituents Elist8
-- Return_Applies_To Node8
-- First_Exit_Statement Node8
-- Class_Wide_Type Node9
-- Current_Value Node9
-- Renaming_Map Uint9
-- Direct_Primitive_Operations Elist10
-- Discriminal_Link Node10
-- Float_Rep Uint10 (but returns Float_Rep_Kind)
-- Handler_Records List10
-- Normalized_Position_Max Uint10
-- Part_Of_Constituents Elist10
-- Block_Node Node11
-- Component_Bit_Offset Uint11
-- Full_View Node11
-- Entry_Component Node11
-- Enumeration_Pos Uint11
-- Generic_Homonym Node11
-- Part_Of_References Elist11
-- Protected_Body_Subprogram Node11
-- Barrier_Function Node12
-- Enumeration_Rep Uint12
-- Esize Uint12
-- Next_Inlined_Subprogram Node12
-- Component_Clause Node13
-- Elaboration_Entity Node13
-- Extra_Accessibility Node13
-- RM_Size Uint13
-- Alignment Uint14
-- Normalized_Position Uint14
-- Postconditions_Proc Node14
-- Discriminant_Number Uint15
-- DT_Position Uint15
-- DT_Entry_Count Uint15
-- Entry_Parameters_Type Node15
-- Extra_Formal Node15
-- Pending_Access_Types Elist15
-- Related_Instance Node15
-- Status_Flag_Or_Transient_Decl Node15
-- Access_Disp_Table Elist16
-- Body_References Elist16
-- Cloned_Subtype Node16
-- DTC_Entity Node16
-- Entry_Formal Node16
-- First_Private_Entity Node16
-- Lit_Strings Node16
-- Scale_Value Uint16
-- String_Literal_Length Uint16
-- Unset_Reference Node16
-- Actual_Subtype Node17
-- Digits_Value Uint17
-- Discriminal Node17
-- First_Entity Node17
-- First_Index Node17
-- First_Literal Node17
-- Master_Id Node17
-- Modulus Uint17
-- Prival Node17
-- Alias Node18
-- Corresponding_Concurrent_Type Node18
-- Corresponding_Protected_Entry Node18
-- Corresponding_Record_Type Node18
-- Delta_Value Ureal18
-- Enclosing_Scope Node18
-- Equivalent_Type Node18
-- Lit_Indexes Node18
-- Private_Dependents Elist18
-- Renamed_Entity Node18
-- Renamed_Object Node18
-- String_Literal_Low_Bound Node18
-- Body_Entity Node19
-- Corresponding_Discriminant Node19
-- Default_Aspect_Component_Value Node19
-- Default_Aspect_Value Node19
-- Entry_Bodies_Array Node19
-- Extra_Accessibility_Of_Result Node19
-- Non_Limited_View Node19
-- Parent_Subtype Node19
-- Receiving_Entry Node19
-- Size_Check_Code Node19
-- Spec_Entity Node19
-- Underlying_Full_View Node19
-- Component_Type Node20
-- Default_Value Node20
-- Directly_Designated_Type Node20
-- Discriminant_Checking_Func Node20
-- Discriminant_Default_Value Node20
-- Last_Entity Node20
-- Prival_Link Node20
-- Register_Exception_Call Node20
-- Scalar_Range Node20
-- Accept_Address Elist21
-- Corresponding_Record_Component Node21
-- Default_Expr_Function Node21
-- Discriminant_Constraint Elist21
-- Interface_Name Node21
-- Original_Array_Type Node21
-- Small_Value Ureal21
-- Associated_Storage_Pool Node22
-- Component_Size Uint22
-- Corresponding_Remote_Type Node22
-- Enumeration_Rep_Expr Node22
-- Original_Record_Component Node22
-- Protected_Formal Node22
-- Scope_Depth_Value Uint22
-- Shared_Var_Procs_Instance Node22
-- CR_Discriminant Node23
-- Entry_Cancel_Parameter Node23
-- Enum_Pos_To_Rep Node23
-- Extra_Constrained Node23
-- Finalization_Master Node23
-- Generic_Renamings Elist23
-- Inner_Instances Elist23
-- Limited_View Node23
-- Packed_Array_Impl_Type Node23
-- Protection_Object Node23
-- Stored_Constraint Elist23
-- Incomplete_Actuals Elist24
-- Related_Expression Node24
-- Subps_Index Uint24
-- Contract_Wrapper Node25
-- Debug_Renaming_Link Node25
-- DT_Offset_To_Top_Func Node25
-- Interface_Alias Node25
-- Interfaces Elist25
-- Related_Array_Object Node25
-- Static_Discrete_Predicate List25
-- Static_Real_Or_String_Predicate Node25
-- Task_Body_Procedure Node25
-- Dispatch_Table_Wrappers Elist26
-- Last_Assignment Node26
-- Overridden_Operation Node26
-- Package_Instantiation Node26
-- Storage_Size_Variable Node26
-- Current_Use_Clause Node27
-- Related_Type Node27
-- Wrapped_Entity Node27
-- Extra_Formals Node28
-- Finalizer Node28
-- Initialization_Statements Node28
-- Original_Access_Type Node28
-- Relative_Deadline_Variable Node28
-- Underlying_Record_View Node28
-- Anonymous_Masters Elist29
-- BIP_Initialization_Call Node29
-- Subprograms_For_Type Elist29
-- Access_Disp_Table_Elab_Flag Node30
-- Anonymous_Object Node30
-- Corresponding_Equality Node30
-- Hidden_In_Formal_Instance Elist30
-- Last_Aggregate_Assignment Node30
-- Static_Initialization Node30
-- Activation_Record_Component Node31
-- Derived_Type_Link Node31
-- Thunk_Entity Node31
-- Corresponding_Function Node32
-- Corresponding_Procedure Node32
-- Encapsulating_State Node32
-- No_Tagged_Streams_Pragma Node32
-- Linker_Section_Pragma Node33
-- Contract Node34
-- Anonymous_Designated_Type Node35
-- Entry_Max_Queue_Lengths_Array Node35
-- Import_Pragma Node35
-- Validated_Object Node38
-- Predicated_Parent Node38
-- Class_Wide_Clone Node38
-- Protected_Subprogram Node39
-- SPARK_Pragma Node40
-- Original_Protected_Subprogram Node41
-- SPARK_Aux_Pragma Node41
---------------------------------------------
-- Usage of Flags in Defining Entity Nodes --
---------------------------------------------
-- All flags are unique, there is no overlaying, so each flag is physically
-- present in every entity. However, for many of the flags, it only makes
-- sense for them to be set true for certain subsets of entity kinds. See
-- the spec of Einfo for further details.
-- Is_Inlined_Always Flag1
-- Is_Hidden_Non_Overridden_Subpgm Flag2
-- Has_Own_DIC Flag3
-- Is_Frozen Flag4
-- Has_Discriminants Flag5
-- Is_Dispatching_Operation Flag6
-- Is_Immediately_Visible Flag7
-- In_Use Flag8
-- Is_Potentially_Use_Visible Flag9
-- Is_Public Flag10
-- Is_Inlined Flag11
-- Is_Constrained Flag12
-- Is_Generic_Type Flag13
-- Depends_On_Private Flag14
-- Is_Aliased Flag15
-- Is_Volatile Flag16
-- Is_Internal Flag17
-- Has_Delayed_Freeze Flag18
-- Is_Abstract_Subprogram Flag19
-- Is_Concurrent_Record_Type Flag20
-- Has_Master_Entity Flag21
-- Needs_No_Actuals Flag22
-- Has_Storage_Size_Clause Flag23
-- Is_Imported Flag24
-- Is_Limited_Record Flag25
-- Has_Completion Flag26
-- Has_Pragma_Controlled Flag27
-- Is_Statically_Allocated Flag28
-- Has_Size_Clause Flag29
-- Has_Task Flag30
-- Checks_May_Be_Suppressed Flag31
-- Kill_Elaboration_Checks Flag32
-- Kill_Range_Checks Flag33
-- Has_Independent_Components Flag34
-- Is_Class_Wide_Equivalent_Type Flag35
-- Referenced_As_LHS Flag36
-- Is_Known_Non_Null Flag37
-- Can_Never_Be_Null Flag38
-- Has_Default_Aspect Flag39
-- Body_Needed_For_SAL Flag40
-- Treat_As_Volatile Flag41
-- Is_Controlled_Active Flag42
-- Has_Controlled_Component Flag43
-- Is_Pure Flag44
-- In_Private_Part Flag45
-- Has_Alignment_Clause Flag46
-- Has_Exit Flag47
-- In_Package_Body Flag48
-- Reachable Flag49
-- Delay_Subprogram_Descriptors Flag50
-- Is_Packed Flag51
-- Is_Entry_Formal Flag52
-- Is_Private_Descendant Flag53
-- Return_Present Flag54
-- Is_Tagged_Type Flag55
-- Has_Homonym Flag56
-- Is_Hidden Flag57
-- Non_Binary_Modulus Flag58
-- Is_Preelaborated Flag59
-- Is_Shared_Passive Flag60
-- Is_Remote_Types Flag61
-- Is_Remote_Call_Interface Flag62
-- Is_Character_Type Flag63
-- Is_Intrinsic_Subprogram Flag64
-- Has_Record_Rep_Clause Flag65
-- Has_Enumeration_Rep_Clause Flag66
-- Has_Small_Clause Flag67
-- Has_Component_Size_Clause Flag68
-- Is_Access_Constant Flag69
-- Is_First_Subtype Flag70
-- Has_Completion_In_Body Flag71
-- Has_Unknown_Discriminants Flag72
-- Is_Child_Unit Flag73
-- Is_CPP_Class Flag74
-- Has_Non_Standard_Rep Flag75
-- Is_Constructor Flag76
-- Static_Elaboration_Desired Flag77
-- Is_Tag Flag78
-- Has_All_Calls_Remote Flag79
-- Is_Constr_Subt_For_U_Nominal Flag80
-- Is_Asynchronous Flag81
-- Has_Gigi_Rep_Item Flag82
-- Has_Machine_Radix_Clause Flag83
-- Machine_Radix_10 Flag84
-- Is_Atomic Flag85
-- Has_Atomic_Components Flag86
-- Has_Volatile_Components Flag87
-- Discard_Names Flag88
-- Is_Interrupt_Handler Flag89
-- Returns_By_Ref Flag90
-- Is_Itype Flag91
-- Size_Known_At_Compile_Time Flag92
-- Reverse_Storage_Order Flag93
-- Is_Generic_Actual_Type Flag94
-- Uses_Sec_Stack Flag95
-- Warnings_Off Flag96
-- Is_Controlling_Formal Flag97
-- Has_Controlling_Result Flag98
-- Is_Exported Flag99
-- Has_Specified_Layout Flag100
-- Has_Nested_Block_With_Handler Flag101
-- Is_Called Flag102
-- Is_Completely_Hidden Flag103
-- Address_Taken Flag104
-- Suppress_Initialization Flag105
-- Is_Limited_Composite Flag106
-- Is_Private_Composite Flag107
-- Default_Expressions_Processed Flag108
-- Is_Non_Static_Subtype Flag109
-- Has_Out_Or_In_Out_Parameter Flag110
-- Is_Formal_Subprogram Flag111
-- Is_Renaming_Of_Object Flag112
-- No_Return Flag113
-- Delay_Cleanups Flag114
-- Never_Set_In_Source Flag115
-- Is_Visible_Lib_Unit Flag116
-- Is_Unchecked_Union Flag117
-- Is_For_Access_Subtype Flag118
-- Has_Convention_Pragma Flag119
-- Has_Primitive_Operations Flag120
-- Has_Pragma_Pack Flag121
-- Is_Bit_Packed_Array Flag122
-- Has_Unchecked_Union Flag123
-- Is_Eliminated Flag124
-- C_Pass_By_Copy Flag125
-- Is_Instantiated Flag126
-- Is_Valued_Procedure Flag127
-- (used for Component_Alignment) Flag128
-- (used for Component_Alignment) Flag129
-- Is_Generic_Instance Flag130
-- No_Pool_Assigned Flag131
-- Is_DIC_Procedure Flag132
-- Has_Inherited_DIC Flag133
-- Has_Aliased_Components Flag135
-- No_Strict_Aliasing Flag136
-- Is_Machine_Code_Subprogram Flag137
-- Is_Packed_Array_Impl_Type Flag138
-- Has_Biased_Representation Flag139
-- Has_Complex_Representation Flag140
-- Is_Constr_Subt_For_UN_Aliased Flag141
-- Has_Missing_Return Flag142
-- Has_Recursive_Call Flag143
-- Is_Unsigned_Type Flag144
-- Strict_Alignment Flag145
-- Is_Abstract_Type Flag146
-- Needs_Debug_Info Flag147
-- Is_Elaboration_Checks_OK_Id Flag148
-- Is_Compilation_Unit Flag149
-- Has_Pragma_Elaborate_Body Flag150
-- Has_Private_Ancestor Flag151
-- Entry_Accepted Flag152
-- Is_Obsolescent Flag153
-- Has_Per_Object_Constraint Flag154
-- Has_Private_Declaration Flag155
-- Referenced Flag156
-- Has_Pragma_Inline Flag157
-- Finalize_Storage_Only Flag158
-- From_Limited_With Flag159
-- Is_Package_Body_Entity Flag160
-- Has_Qualified_Name Flag161
-- Nonzero_Is_True Flag162
-- Is_True_Constant Flag163
-- Reverse_Bit_Order Flag164
-- Suppress_Style_Checks Flag165
-- Debug_Info_Off Flag166
-- Sec_Stack_Needed_For_Return Flag167
-- Materialize_Entity Flag168
-- Has_Pragma_Thread_Local_Storage Flag169
-- Is_Known_Valid Flag170
-- Is_Hidden_Open_Scope Flag171
-- Has_Object_Size_Clause Flag172
-- Has_Fully_Qualified_Name Flag173
-- Elaboration_Entity_Required Flag174
-- Has_Forward_Instantiation Flag175
-- Is_Discrim_SO_Function Flag176
-- Size_Depends_On_Discriminant Flag177
-- Is_Null_Init_Proc Flag178
-- Has_Pragma_Pure_Function Flag179
-- Has_Pragma_Unreferenced Flag180
-- Has_Contiguous_Rep Flag181
-- Has_Xref_Entry Flag182
-- Must_Be_On_Byte_Boundary Flag183
-- Has_Stream_Size_Clause Flag184
-- Is_Ada_2005_Only Flag185
-- Is_Interface Flag186
-- Has_Constrained_Partial_View Flag187
-- Uses_Lock_Free Flag188
-- Is_Pure_Unit_Access_Type Flag189
-- Has_Specified_Stream_Input Flag190
-- Has_Specified_Stream_Output Flag191
-- Has_Specified_Stream_Read Flag192
-- Has_Specified_Stream_Write Flag193
-- Is_Local_Anonymous_Access Flag194
-- Is_Primitive_Wrapper Flag195
-- Was_Hidden Flag196
-- Is_Limited_Interface Flag197
-- Has_Pragma_Ordered Flag198
-- Is_Ada_2012_Only Flag199
-- Has_Delayed_Aspects Flag200
-- Has_Pragma_No_Inline Flag201
-- Itype_Printed Flag202
-- Has_Pragma_Pure Flag203
-- Is_Known_Null Flag204
-- Low_Bound_Tested Flag205
-- Is_Visible_Formal Flag206
-- Known_To_Have_Preelab_Init Flag207
-- Must_Have_Preelab_Init Flag208
-- Is_Return_Object Flag209
-- Elaborate_Body_Desirable Flag210
-- Has_Static_Discriminants Flag211
-- Has_Pragma_Unreferenced_Objects Flag212
-- Requires_Overriding Flag213
-- Has_RACW Flag214
-- Is_Param_Block_Component_Type Flag215
-- Universal_Aliasing Flag216
-- Suppress_Value_Tracking_On_Call Flag217
-- Is_Primitive Flag218
-- Has_Initial_Value Flag219
-- Has_Dispatch_Table Flag220
-- Has_Pragma_Preelab_Init Flag221
-- Used_As_Generic_Actual Flag222
-- Is_Descendant_Of_Address Flag223
-- Is_Raised Flag224
-- Is_Thunk Flag225
-- Is_Only_Out_Parameter Flag226
-- Referenced_As_Out_Parameter Flag227
-- Has_Thunks Flag228
-- Can_Use_Internal_Rep Flag229
-- Has_Pragma_Inline_Always Flag230
-- Renamed_In_Spec Flag231
-- Has_Own_Invariants Flag232
-- Has_Pragma_Unmodified Flag233
-- Is_Dispatch_Table_Entity Flag234
-- Is_Trivial_Subprogram Flag235
-- Warnings_Off_Used Flag236
-- Warnings_Off_Used_Unmodified Flag237
-- Warnings_Off_Used_Unreferenced Flag238
-- No_Reordering Flag239
-- Has_Expanded_Contract Flag240
-- Optimize_Alignment_Space Flag241
-- Optimize_Alignment_Time Flag242
-- Overlays_Constant Flag243
-- Is_RACW_Stub_Type Flag244
-- Is_Private_Primitive Flag245
-- Is_Underlying_Record_View Flag246
-- OK_To_Rename Flag247
-- Has_Inheritable_Invariants Flag248
-- Is_Safe_To_Reevaluate Flag249
-- Has_Predicates Flag250
-- Has_Implicit_Dereference Flag251
-- Is_Finalized_Transient Flag252
-- Disable_Controlled Flag253
-- Is_Implementation_Defined Flag254
-- Is_Predicate_Function Flag255
-- Is_Predicate_Function_M Flag256
-- Is_Invariant_Procedure Flag257
-- Has_Dynamic_Predicate_Aspect Flag258
-- Has_Static_Predicate_Aspect Flag259
-- Has_Loop_Entry_Attributes Flag260
-- Has_Delayed_Rep_Aspects Flag261
-- May_Inherit_Delayed_Rep_Aspects Flag262
-- Has_Visible_Refinement Flag263
-- Is_Discriminant_Check_Function Flag264
-- SPARK_Pragma_Inherited Flag265
-- SPARK_Aux_Pragma_Inherited Flag266
-- Has_Shift_Operator Flag267
-- Is_Independent Flag268
-- Has_Static_Predicate Flag269
-- Stores_Attribute_Old_Prefix Flag270
-- Has_Protected Flag271
-- SSO_Set_Low_By_Default Flag272
-- SSO_Set_High_By_Default Flag273
-- Is_Generic_Actual_Subprogram Flag274
-- No_Predicate_On_Actual Flag275
-- No_Dynamic_Predicate_On_Actual Flag276
-- Is_Checked_Ghost_Entity Flag277
-- Is_Ignored_Ghost_Entity Flag278
-- Contains_Ignored_Ghost_Code Flag279
-- Partial_View_Has_Unknown_Discr Flag280
-- Is_Static_Type Flag281
-- Has_Nested_Subprogram Flag282
-- Is_Uplevel_Referenced_Entity Flag283
-- Is_Unimplemented Flag284
-- Is_Volatile_Full_Access Flag285
-- Is_Exception_Handler Flag286
-- Rewritten_For_C Flag287
-- Predicates_Ignored Flag288
-- Has_Timing_Event Flag289
-- Is_Class_Wide_Clone Flag290
-- Has_Inherited_Invariants Flag291
-- Is_Partial_Invariant_Procedure Flag292
-- Is_Actual_Subtype Flag293
-- Has_Pragma_Unused Flag294
-- Is_Ignored_Transient Flag295
-- Has_Partial_Visible_Refinement Flag296
-- Is_Entry_Wrapper Flag297
-- Is_Underlying_Full_View Flag298
-- Body_Needed_For_Inlining Flag299
-- Has_Private_Extension Flag300
-- Ignore_SPARK_Mode_Pragmas Flag301
-- Is_Initial_Condition_Procedure Flag302
-- Suppress_Elaboration_Warnings Flag303
-- Is_Elaboration_Warnings_OK_Id Flag304
-- Is_Activation_Record Flag305
-- Needs_Activation_Record Flag306
-- Is_Loop_Parameter Flag307
-- (unused) Flag308
-- (unused) Flag309
-- Note: Flag310-317 are defined in atree.ads/adb, but not yet in atree.h
-----------------------
-- Local subprograms --
-----------------------
function Has_Option
(State_Id : Entity_Id;
Option_Nam : Name_Id) return Boolean;
-- Determine whether abstract state State_Id has particular option denoted
-- by the name Option_Nam.
---------------
-- Float_Rep --
---------------
function Float_Rep (Id : E) return F is
pragma Assert (Is_Floating_Point_Type (Id));
begin
return F'Val (UI_To_Int (Uint10 (Base_Type (Id))));
end Float_Rep;
----------------
-- Has_Option --
----------------
function Has_Option
(State_Id : Entity_Id;
Option_Nam : Name_Id) return Boolean
is
Decl : constant Node_Id := Parent (State_Id);
Opt : Node_Id;
Opt_Nam : Node_Id;
begin
pragma Assert (Ekind (State_Id) = E_Abstract_State);
-- The declaration of abstract states with options appear as an
-- extension aggregate. If this is not the case, the option is not
-- available.
if Nkind (Decl) /= N_Extension_Aggregate then
return False;
end if;
-- Simple options
Opt := First (Expressions (Decl));
while Present (Opt) loop
if Nkind (Opt) = N_Identifier and then Chars (Opt) = Option_Nam then
return True;
end if;
Next (Opt);
end loop;
-- Complex options with various specifiers
Opt := First (Component_Associations (Decl));
while Present (Opt) loop
Opt_Nam := First (Choices (Opt));
if Nkind (Opt_Nam) = N_Identifier
and then Chars (Opt_Nam) = Option_Nam
then
return True;
end if;
Next (Opt);
end loop;
return False;
end Has_Option;
--------------------------------
-- Attribute Access Functions --
--------------------------------
function Abstract_States (Id : E) return L is
begin
pragma Assert (Ekind_In (Id, E_Generic_Package, E_Package));
return Elist25 (Id);
end Abstract_States;
function Accept_Address (Id : E) return L is
begin
return Elist21 (Id);
end Accept_Address;
function Access_Disp_Table (Id : E) return L is
begin
pragma Assert (Ekind_In (Id, E_Record_Subtype,
E_Record_Type,
E_Record_Type_With_Private));
return Elist16 (Implementation_Base_Type (Id));
end Access_Disp_Table;
function Access_Disp_Table_Elab_Flag (Id : E) return E is
begin
pragma Assert (Ekind_In (Id, E_Record_Subtype,
E_Record_Type,
E_Record_Type_With_Private));
return Node30 (Implementation_Base_Type (Id));
end Access_Disp_Table_Elab_Flag;
function Activation_Record_Component (Id : E) return E is
begin
pragma Assert (Ekind_In (Id, E_Constant,
E_In_Parameter,
E_In_Out_Parameter,
E_Loop_Parameter,
E_Out_Parameter,
E_Variable));
return Node31 (Id);
end Activation_Record_Component;
function Actual_Subtype (Id : E) return E is
begin
pragma Assert
(Ekind_In (Id, E_Constant, E_Variable, E_Generic_In_Out_Parameter)
or else Is_Formal (Id));
return Node17 (Id);
end Actual_Subtype;
function Address_Taken (Id : E) return B is
begin
return Flag104 (Id);
end Address_Taken;
function Alias (Id : E) return E is
begin
pragma Assert
(Is_Overloadable (Id) or else Ekind (Id) = E_Subprogram_Type);
return Node18 (Id);
end Alias;
function Alignment (Id : E) return U is
begin
pragma Assert (Is_Type (Id)
or else Is_Formal (Id)
or else Ekind_In (Id, E_Loop_Parameter,
E_Constant,
E_Exception,
E_Variable));
return Uint14 (Id);
end Alignment;
function Anonymous_Designated_Type (Id : E) return E is
begin
pragma Assert (Ekind (Id) = E_Variable);
return Node35 (Id);
end Anonymous_Designated_Type;
function Anonymous_Masters (Id : E) return L is
begin
pragma Assert (Ekind_In (Id, E_Function,
E_Package,
E_Procedure,
E_Subprogram_Body));
return Elist29 (Id);
end Anonymous_Masters;
function Anonymous_Object (Id : E) return E is
begin
pragma Assert (Ekind_In (Id, E_Protected_Type, E_Task_Type));
return Node30 (Id);
end Anonymous_Object;
function Associated_Entity (Id : E) return E is
begin
return Node37 (Id);
end Associated_Entity;
function Associated_Formal_Package (Id : E) return E is
begin
pragma Assert (Ekind (Id) = E_Package);
return Node12 (Id);
end Associated_Formal_Package;
function Associated_Node_For_Itype (Id : E) return N is
begin
return Node8 (Id);
end Associated_Node_For_Itype;
function Associated_Storage_Pool (Id : E) return E is
begin
pragma Assert (Is_Access_Type (Id));
return Node22 (Root_Type (Id));
end Associated_Storage_Pool;
function Barrier_Function (Id : E) return N is
begin
pragma Assert (Is_Entry (Id));
return Node12 (Id);
end Barrier_Function;
function Block_Node (Id : E) return N is
begin
pragma Assert (Ekind (Id) = E_Block);
return Node11 (Id);
end Block_Node;
function Body_Entity (Id : E) return E is
begin
pragma Assert (Ekind_In (Id, E_Package, E_Generic_Package));
return Node19 (Id);
end Body_Entity;
function Body_Needed_For_Inlining (Id : E) return B is
begin
pragma Assert (Ekind (Id) = E_Package);
return Flag299 (Id);
end Body_Needed_For_Inlining;
function Body_Needed_For_SAL (Id : E) return B is
begin
pragma Assert
(Ekind (Id) = E_Package
or else Is_Subprogram (Id)
or else Is_Generic_Unit (Id));
return Flag40 (Id);
end Body_Needed_For_SAL;
function Body_References (Id : E) return L is
begin
pragma Assert (Ekind (Id) = E_Abstract_State);
return Elist16 (Id);
end Body_References;
function BIP_Initialization_Call (Id : E) return N is
begin
pragma Assert (Ekind_In (Id, E_Constant, E_Variable));
return Node29 (Id);
end BIP_Initialization_Call;
function C_Pass_By_Copy (Id : E) return B is
begin
pragma Assert (Is_Record_Type (Id));
return Flag125 (Implementation_Base_Type (Id));
end C_Pass_By_Copy;
function Can_Never_Be_Null (Id : E) return B is
begin
return Flag38 (Id);
end Can_Never_Be_Null;
function Checks_May_Be_Suppressed (Id : E) return B is
begin
return Flag31 (Id);
end Checks_May_Be_Suppressed;
function Class_Wide_Clone (Id : E) return E is
begin
pragma Assert (Is_Subprogram (Id));
return Node38 (Id);
end Class_Wide_Clone;
function Class_Wide_Type (Id : E) return E is
begin
pragma Assert (Is_Type (Id));
return Node9 (Id);
end Class_Wide_Type;
function Cloned_Subtype (Id : E) return E is
begin
pragma Assert (Ekind_In (Id, E_Record_Subtype, E_Class_Wide_Subtype));
return Node16 (Id);
end Cloned_Subtype;
function Component_Bit_Offset (Id : E) return U is
begin
pragma Assert (Ekind_In (Id, E_Component, E_Discriminant));
return Uint11 (Id);
end Component_Bit_Offset;
function Component_Clause (Id : E) return N is
begin
pragma Assert (Ekind_In (Id, E_Component, E_Discriminant));
return Node13 (Id);
end Component_Clause;
function Component_Size (Id : E) return U is
begin
pragma Assert (Is_Array_Type (Id));
return Uint22 (Implementation_Base_Type (Id));
end Component_Size;
function Component_Type (Id : E) return E is
begin
pragma Assert (Is_Array_Type (Id));
return Node20 (Implementation_Base_Type (Id));
end Component_Type;
function Corresponding_Concurrent_Type (Id : E) return E is
begin
pragma Assert (Ekind (Id) = E_Record_Type);
return Node18 (Id);
end Corresponding_Concurrent_Type;
function Corresponding_Discriminant (Id : E) return E is
begin
pragma Assert (Ekind (Id) = E_Discriminant);
return Node19 (Id);
end Corresponding_Discriminant;
function Corresponding_Equality (Id : E) return E is
begin
pragma Assert
(Ekind (Id) = E_Function
and then not Comes_From_Source (Id)
and then Chars (Id) = Name_Op_Ne);
return Node30 (Id);
end Corresponding_Equality;
function Corresponding_Function (Id : E) return E is
begin
pragma Assert (Ekind (Id) = E_Procedure);
return Node32 (Id);
end Corresponding_Function;
function Corresponding_Procedure (Id : E) return E is
begin
pragma Assert (Ekind (Id) = E_Function);
return Node32 (Id);
end Corresponding_Procedure;
function Corresponding_Protected_Entry (Id : E) return E is
begin
pragma Assert (Ekind (Id) = E_Subprogram_Body);
return Node18 (Id);
end Corresponding_Protected_Entry;
function Corresponding_Record_Component (Id : E) return E is
begin
pragma Assert (Ekind_In (Id, E_Component, E_Discriminant));
return Node21 (Id);
end Corresponding_Record_Component;
function Corresponding_Record_Type (Id : E) return E is
begin
pragma Assert (Is_Concurrent_Type (Id));
return Node18 (Id);
end Corresponding_Record_Type;
function Corresponding_Remote_Type (Id : E) return E is
begin
return Node22 (Id);
end Corresponding_Remote_Type;
function Current_Use_Clause (Id : E) return E is
begin
pragma Assert (Ekind (Id) = E_Package or else Is_Type (Id));
return Node27 (Id);
end Current_Use_Clause;
function Current_Value (Id : E) return N is
begin
pragma Assert (Ekind (Id) in Object_Kind);
return Node9 (Id);
end Current_Value;
function CR_Discriminant (Id : E) return E is
begin
return Node23 (Id);
end CR_Discriminant;
function Debug_Info_Off (Id : E) return B is
begin
return Flag166 (Id);
end Debug_Info_Off;
function Debug_Renaming_Link (Id : E) return E is
begin
return Node25 (Id);
end Debug_Renaming_Link;
function Default_Aspect_Component_Value (Id : E) return N is
begin
pragma Assert (Is_Array_Type (Id));
return Node19 (Base_Type (Id));
end Default_Aspect_Component_Value;
function Default_Aspect_Value (Id : E) return N is
begin
pragma Assert (Is_Scalar_Type (Id));
return Node19 (Base_Type (Id));
end Default_Aspect_Value;
function Default_Expr_Function (Id : E) return E is
begin
pragma Assert (Is_Formal (Id));
return Node21 (Id);
end Default_Expr_Function;
function Default_Expressions_Processed (Id : E) return B is
begin
return Flag108 (Id);
end Default_Expressions_Processed;
function Default_Value (Id : E) return N is
begin
pragma Assert (Is_Formal (Id));
return Node20 (Id);
end Default_Value;
function Delay_Cleanups (Id : E) return B is
begin
return Flag114 (Id);
end Delay_Cleanups;
function Delay_Subprogram_Descriptors (Id : E) return B is
begin
return Flag50 (Id);
end Delay_Subprogram_Descriptors;
function Delta_Value (Id : E) return R is
begin
pragma Assert (Is_Fixed_Point_Type (Id));
return Ureal18 (Id);
end Delta_Value;
function Dependent_Instances (Id : E) return L is
begin
pragma Assert (Is_Generic_Instance (Id));
return Elist8 (Id);
end Dependent_Instances;
function Depends_On_Private (Id : E) return B is
begin
pragma Assert (Nkind (Id) in N_Entity);
return Flag14 (Id);
end Depends_On_Private;
function Derived_Type_Link (Id : E) return E is
begin
pragma Assert (Is_Type (Id));
return Node31 (Base_Type (Id));
end Derived_Type_Link;
function Digits_Value (Id : E) return U is
begin
pragma Assert
(Is_Floating_Point_Type (Id)
or else Is_Decimal_Fixed_Point_Type (Id));
return Uint17 (Id);
end Digits_Value;
function Direct_Primitive_Operations (Id : E) return L is
begin
pragma Assert (Is_Tagged_Type (Id));
return Elist10 (Id);
end Direct_Primitive_Operations;
function Directly_Designated_Type (Id : E) return E is
begin
pragma Assert (Is_Access_Type (Id));
return Node20 (Id);
end Directly_Designated_Type;
function Disable_Controlled (Id : E) return B is
begin
return Flag253 (Base_Type (Id));
end Disable_Controlled;
function Discard_Names (Id : E) return B is
begin
return Flag88 (Id);
end Discard_Names;
function Discriminal (Id : E) return E is
begin
pragma Assert (Ekind (Id) = E_Discriminant);
return Node17 (Id);
end Discriminal;
function Discriminal_Link (Id : E) return N is
begin
return Node10 (Id);
end Discriminal_Link;
function Discriminant_Checking_Func (Id : E) return E is
begin
pragma Assert (Ekind (Id) = E_Component);
return Node20 (Id);
end Discriminant_Checking_Func;
function Discriminant_Constraint (Id : E) return L is
begin
pragma Assert (Is_Composite_Type (Id) and then Has_Discriminants (Id));
return Elist21 (Id);
end Discriminant_Constraint;
function Discriminant_Default_Value (Id : E) return N is
begin
pragma Assert (Ekind (Id) = E_Discriminant);
return Node20 (Id);
end Discriminant_Default_Value;
function Discriminant_Number (Id : E) return U is
begin
pragma Assert (Ekind (Id) = E_Discriminant);
return Uint15 (Id);
end Discriminant_Number;
function Dispatch_Table_Wrappers (Id : E) return L is
begin
pragma Assert (Ekind_In (Id, E_Record_Type,
E_Record_Subtype));
return Elist26 (Implementation_Base_Type (Id));
end Dispatch_Table_Wrappers;
function DT_Entry_Count (Id : E) return U is
begin
pragma Assert (Ekind (Id) = E_Component and then Is_Tag (Id));
return Uint15 (Id);
end DT_Entry_Count;
function DT_Offset_To_Top_Func (Id : E) return E is
begin
pragma Assert (Ekind (Id) = E_Component and then Is_Tag (Id));
return Node25 (Id);
end DT_Offset_To_Top_Func;
function DT_Position (Id : E) return U is
begin
pragma Assert (Ekind_In (Id, E_Function, E_Procedure)
and then Present (DTC_Entity (Id)));
return Uint15 (Id);
end DT_Position;
function DTC_Entity (Id : E) return E is
begin
pragma Assert (Ekind_In (Id, E_Function, E_Procedure));
return Node16 (Id);
end DTC_Entity;
function Elaborate_Body_Desirable (Id : E) return B is
begin
pragma Assert (Ekind (Id) = E_Package);
return Flag210 (Id);
end Elaborate_Body_Desirable;
function Elaboration_Entity (Id : E) return E is
begin
pragma Assert
(Is_Subprogram (Id)
or else
Ekind_In (Id, E_Entry, E_Entry_Family, E_Package)
or else
Is_Generic_Unit (Id));
return Node13 (Id);
end Elaboration_Entity;
function Elaboration_Entity_Required (Id : E) return B is
begin
pragma Assert
(Is_Subprogram (Id)
or else
Ekind_In (Id, E_Entry, E_Entry_Family, E_Package)
or else
Is_Generic_Unit (Id));
return Flag174 (Id);
end Elaboration_Entity_Required;
function Encapsulating_State (Id : E) return N is
begin
pragma Assert (Ekind_In (Id, E_Abstract_State, E_Constant, E_Variable));
return Node32 (Id);
end Encapsulating_State;
function Enclosing_Scope (Id : E) return E is
begin
return Node18 (Id);
end Enclosing_Scope;
function Entry_Accepted (Id : E) return B is
begin
pragma Assert (Is_Entry (Id));
return Flag152 (Id);
end Entry_Accepted;
function Entry_Bodies_Array (Id : E) return E is
begin
return Node19 (Id);
end Entry_Bodies_Array;
function Entry_Cancel_Parameter (Id : E) return E is
begin
return Node23 (Id);
end Entry_Cancel_Parameter;
function Entry_Component (Id : E) return E is
begin
return Node11 (Id);
end Entry_Component;
function Entry_Formal (Id : E) return E is
begin
return Node16 (Id);
end Entry_Formal;
function Entry_Index_Constant (Id : E) return N is
begin
pragma Assert (Ekind (Id) = E_Entry_Index_Parameter);
return Node18 (Id);
end Entry_Index_Constant;
function Entry_Max_Queue_Lengths_Array (Id : E) return N is
begin
pragma Assert (Ekind (Id) = E_Protected_Type);
return Node35 (Id);
end Entry_Max_Queue_Lengths_Array;
function Contains_Ignored_Ghost_Code (Id : E) return B is
begin
pragma Assert
(Ekind_In (Id, E_Block,
E_Function,
E_Generic_Function,
E_Generic_Package,
E_Generic_Procedure,
E_Package,
E_Package_Body,
E_Procedure,
E_Subprogram_Body));
return Flag279 (Id);
end Contains_Ignored_Ghost_Code;
function Contract (Id : E) return N is
begin
pragma Assert
(Ekind_In (Id, E_Protected_Type, -- concurrent types
E_Task_Body,
E_Task_Type)
or else
Ekind_In (Id, E_Constant, -- objects
E_Variable)
or else
Ekind_In (Id, E_Entry, -- overloadable
E_Entry_Family,
E_Function,
E_Generic_Function,
E_Generic_Procedure,
E_Operator,
E_Procedure,
E_Subprogram_Body)
or else
Ekind_In (Id, E_Generic_Package, -- packages
E_Package,
E_Package_Body)
or else
Ekind (Id) = E_Void); -- special purpose
return Node34 (Id);
end Contract;
function Contract_Wrapper (Id : E) return E is
begin
pragma Assert (Ekind_In (Id, E_Entry, E_Entry_Family));
return Node25 (Id);
end Contract_Wrapper;
function Entry_Parameters_Type (Id : E) return E is
begin
return Node15 (Id);
end Entry_Parameters_Type;
function Enum_Pos_To_Rep (Id : E) return E is
begin
pragma Assert (Ekind (Id) = E_Enumeration_Type);
return Node23 (Id);
end Enum_Pos_To_Rep;
function Enumeration_Pos (Id : E) return Uint is
begin
pragma Assert (Ekind (Id) = E_Enumeration_Literal);
return Uint11 (Id);
end Enumeration_Pos;
function Enumeration_Rep (Id : E) return U is
begin
pragma Assert (Ekind (Id) = E_Enumeration_Literal);
return Uint12 (Id);
end Enumeration_Rep;
function Enumeration_Rep_Expr (Id : E) return N is
begin
pragma Assert (Ekind (Id) = E_Enumeration_Literal);
return Node22 (Id);
end Enumeration_Rep_Expr;
function Equivalent_Type (Id : E) return E is
begin
pragma Assert
(Ekind_In (Id, E_Class_Wide_Type,
E_Class_Wide_Subtype,
E_Access_Subprogram_Type,
E_Access_Protected_Subprogram_Type,
E_Anonymous_Access_Protected_Subprogram_Type,
E_Access_Subprogram_Type,
E_Exception_Type));
return Node18 (Id);
end Equivalent_Type;
function Esize (Id : E) return Uint is
begin
return Uint12 (Id);
end Esize;
function Extra_Accessibility (Id : E) return E is
begin
pragma Assert
(Is_Formal (Id) or else Ekind_In (Id, E_Variable, E_Constant));
return Node13 (Id);
end Extra_Accessibility;
function Extra_Accessibility_Of_Result (Id : E) return E is
begin
pragma Assert (Ekind_In (Id, E_Function, E_Operator, E_Subprogram_Type));
return Node19 (Id);
end Extra_Accessibility_Of_Result;
function Extra_Constrained (Id : E) return E is
begin
pragma Assert (Is_Formal (Id) or else Ekind (Id) = E_Variable);
return Node23 (Id);
end Extra_Constrained;
function Extra_Formal (Id : E) return E is
begin
return Node15 (Id);
end Extra_Formal;
function Extra_Formals (Id : E) return E is
begin
pragma Assert
(Is_Overloadable (Id)
or else Ekind_In (Id, E_Entry_Family,
E_Subprogram_Body,
E_Subprogram_Type));
return Node28 (Id);
end Extra_Formals;
function Can_Use_Internal_Rep (Id : E) return B is
begin
pragma Assert (Is_Access_Subprogram_Type (Base_Type (Id)));
return Flag229 (Base_Type (Id));
end Can_Use_Internal_Rep;
function Finalization_Master (Id : E) return E is
begin
pragma Assert (Is_Access_Type (Id));
return Node23 (Root_Type (Id));
end Finalization_Master;
function Finalize_Storage_Only (Id : E) return B is
begin
pragma Assert (Is_Type (Id));
return Flag158 (Base_Type (Id));
end Finalize_Storage_Only;
function Finalizer (Id : E) return E is
begin
pragma Assert (Ekind_In (Id, E_Package, E_Package_Body));
return Node28 (Id);
end Finalizer;
function First_Entity (Id : E) return E is
begin
return Node17 (Id);
end First_Entity;
function First_Exit_Statement (Id : E) return N is
begin
pragma Assert (Ekind (Id) = E_Loop);
return Node8 (Id);
end First_Exit_Statement;
function First_Index (Id : E) return N is
begin
pragma Assert (Is_Array_Type (Id));
return Node17 (Id);
end First_Index;
function First_Literal (Id : E) return E is
begin
pragma Assert (Is_Enumeration_Type (Id));
return Node17 (Id);
end First_Literal;
function First_Private_Entity (Id : E) return E is
begin
pragma Assert (Ekind_In (Id, E_Package, E_Generic_Package)
or else Ekind (Id) in Concurrent_Kind);
return Node16 (Id);
end First_Private_Entity;
function First_Rep_Item (Id : E) return E is
begin
return Node6 (Id);
end First_Rep_Item;
function Freeze_Node (Id : E) return N is
begin
return Node7 (Id);
end Freeze_Node;
function From_Limited_With (Id : E) return B is
begin
return Flag159 (Id);
end From_Limited_With;
function Full_View (Id : E) return E is
begin
pragma Assert (Is_Type (Id) or else Ekind (Id) = E_Constant);
return Node11 (Id);
end Full_View;
function Generic_Homonym (Id : E) return E is
begin
pragma Assert (Ekind (Id) = E_Generic_Package);
return Node11 (Id);
end Generic_Homonym;
function Generic_Renamings (Id : E) return L is
begin
return Elist23 (Id);
end Generic_Renamings;
function Handler_Records (Id : E) return S is
begin
return List10 (Id);
end Handler_Records;
function Has_Aliased_Components (Id : E) return B is
begin
return Flag135 (Implementation_Base_Type (Id));
end Has_Aliased_Components;
function Has_Alignment_Clause (Id : E) return B is
begin
return Flag46 (Id);
end Has_Alignment_Clause;
function Has_All_Calls_Remote (Id : E) return B is
begin
return Flag79 (Id);
end Has_All_Calls_Remote;
function Has_Atomic_Components (Id : E) return B is
begin
return Flag86 (Implementation_Base_Type (Id));
end Has_Atomic_Components;
function Has_Biased_Representation (Id : E) return B is
begin
return Flag139 (Id);
end Has_Biased_Representation;
function Has_Completion (Id : E) return B is
begin
return Flag26 (Id);
end Has_Completion;
function Has_Completion_In_Body (Id : E) return B is
begin
pragma Assert (Is_Type (Id));
return Flag71 (Id);
end Has_Completion_In_Body;
function Has_Complex_Representation (Id : E) return B is
begin
pragma Assert (Is_Record_Type (Id));
return Flag140 (Implementation_Base_Type (Id));
end Has_Complex_Representation;
function Has_Component_Size_Clause (Id : E) return B is
begin
pragma Assert (Is_Array_Type (Id));
return Flag68 (Implementation_Base_Type (Id));
end Has_Component_Size_Clause;
function Has_Constrained_Partial_View (Id : E) return B is
begin
pragma Assert (Is_Type (Id));
return Flag187 (Id);
end Has_Constrained_Partial_View;
function Has_Controlled_Component (Id : E) return B is
begin
return Flag43 (Base_Type (Id));
end Has_Controlled_Component;
function Has_Contiguous_Rep (Id : E) return B is
begin
return Flag181 (Id);
end Has_Contiguous_Rep;
function Has_Controlling_Result (Id : E) return B is
begin
return Flag98 (Id);
end Has_Controlling_Result;
function Has_Convention_Pragma (Id : E) return B is
begin
return Flag119 (Id);
end Has_Convention_Pragma;
function Has_Default_Aspect (Id : E) return B is
begin
return Flag39 (Base_Type (Id));
end Has_Default_Aspect;
function Has_Delayed_Aspects (Id : E) return B is
begin
pragma Assert (Nkind (Id) in N_Entity);
return Flag200 (Id);
end Has_Delayed_Aspects;
function Has_Delayed_Freeze (Id : E) return B is
begin
pragma Assert (Nkind (Id) in N_Entity);
return Flag18 (Id);
end Has_Delayed_Freeze;
function Has_Delayed_Rep_Aspects (Id : E) return B is
begin
pragma Assert (Nkind (Id) in N_Entity);
return Flag261 (Id);
end Has_Delayed_Rep_Aspects;
function Has_Discriminants (Id : E) return B is
begin
pragma Assert (Is_Type (Id));
return Flag5 (Id);
end Has_Discriminants;
function Has_Dispatch_Table (Id : E) return B is
begin
pragma Assert (Is_Tagged_Type (Id));
return Flag220 (Id);
end Has_Dispatch_Table;
function Has_Dynamic_Predicate_Aspect (Id : E) return B is
begin
pragma Assert (Is_Type (Id));
return Flag258 (Id);
end Has_Dynamic_Predicate_Aspect;
function Has_Enumeration_Rep_Clause (Id : E) return B is
begin
pragma Assert (Is_Enumeration_Type (Id));
return Flag66 (Id);
end Has_Enumeration_Rep_Clause;
function Has_Exit (Id : E) return B is
begin
return Flag47 (Id);
end Has_Exit;
function Has_Expanded_Contract (Id : E) return B is
begin
pragma Assert (Is_Subprogram (Id));
return Flag240 (Id);
end Has_Expanded_Contract;
function Has_Forward_Instantiation (Id : E) return B is
begin
return Flag175 (Id);
end Has_Forward_Instantiation;
function Has_Fully_Qualified_Name (Id : E) return B is
begin
return Flag173 (Id);
end Has_Fully_Qualified_Name;
function Has_Gigi_Rep_Item (Id : E) return B is
begin
return Flag82 (Id);
end Has_Gigi_Rep_Item;
function Has_Homonym (Id : E) return B is
begin
return Flag56 (Id);
end Has_Homonym;
function Has_Implicit_Dereference (Id : E) return B is
begin
return Flag251 (Id);
end Has_Implicit_Dereference;
function Has_Independent_Components (Id : E) return B is
begin
return Flag34 (Implementation_Base_Type (Id));
end Has_Independent_Components;
function Has_Inheritable_Invariants (Id : E) return B is
begin
pragma Assert (Is_Type (Id));
return Flag248 (Base_Type (Id));
end Has_Inheritable_Invariants;
function Has_Inherited_DIC (Id : E) return B is
begin
pragma Assert (Is_Type (Id));
return Flag133 (Base_Type (Id));
end Has_Inherited_DIC;
function Has_Inherited_Invariants (Id : E) return B is
begin
pragma Assert (Is_Type (Id));
return Flag291 (Base_Type (Id));
end Has_Inherited_Invariants;
function Has_Initial_Value (Id : E) return B is
begin
pragma Assert (Ekind (Id) = E_Variable or else Is_Formal (Id));
return Flag219 (Id);
end Has_Initial_Value;
function Has_Loop_Entry_Attributes (Id : E) return B is
begin
pragma Assert (Ekind (Id) = E_Loop);
return Flag260 (Id);
end Has_Loop_Entry_Attributes;
function Has_Machine_Radix_Clause (Id : E) return B is
begin
pragma Assert (Is_Decimal_Fixed_Point_Type (Id));
return Flag83 (Id);
end Has_Machine_Radix_Clause;
function Has_Master_Entity (Id : E) return B is
begin
return Flag21 (Id);
end Has_Master_Entity;
function Has_Missing_Return (Id : E) return B is
begin
pragma Assert (Ekind_In (Id, E_Function, E_Generic_Function));
return Flag142 (Id);
end Has_Missing_Return;
function Has_Nested_Block_With_Handler (Id : E) return B is
begin
return Flag101 (Id);
end Has_Nested_Block_With_Handler;
function Has_Nested_Subprogram (Id : E) return B is
begin
pragma Assert (Is_Subprogram (Id));
return Flag282 (Id);
end Has_Nested_Subprogram;
function Has_Non_Standard_Rep (Id : E) return B is
begin
return Flag75 (Implementation_Base_Type (Id));
end Has_Non_Standard_Rep;
function Has_Object_Size_Clause (Id : E) return B is
begin
pragma Assert (Is_Type (Id));
return Flag172 (Id);
end Has_Object_Size_Clause;
function Has_Out_Or_In_Out_Parameter (Id : E) return B is
begin
pragma Assert
(Ekind_In (Id, E_Entry, E_Entry_Family)
or else Is_Subprogram_Or_Generic_Subprogram (Id));
return Flag110 (Id);
end Has_Out_Or_In_Out_Parameter;
function Has_Own_DIC (Id : E) return B is
begin
pragma Assert (Is_Type (Id));
return Flag3 (Base_Type (Id));
end Has_Own_DIC;
function Has_Own_Invariants (Id : E) return B is
begin
pragma Assert (Is_Type (Id));
return Flag232 (Base_Type (Id));
end Has_Own_Invariants;
function Has_Partial_Visible_Refinement (Id : E) return B is
begin
pragma Assert (Ekind (Id) = E_Abstract_State);
return Flag296 (Id);
end Has_Partial_Visible_Refinement;
function Has_Per_Object_Constraint (Id : E) return B is
begin
return Flag154 (Id);
end Has_Per_Object_Constraint;
function Has_Pragma_Controlled (Id : E) return B is
begin
pragma Assert (Is_Access_Type (Id));
return Flag27 (Implementation_Base_Type (Id));
end Has_Pragma_Controlled;
function Has_Pragma_Elaborate_Body (Id : E) return B is
begin
return Flag150 (Id);
end Has_Pragma_Elaborate_Body;
function Has_Pragma_Inline (Id : E) return B is
begin
return Flag157 (Id);
end Has_Pragma_Inline;
function Has_Pragma_Inline_Always (Id : E) return B is
begin
return Flag230 (Id);
end Has_Pragma_Inline_Always;
function Has_Pragma_No_Inline (Id : E) return B is
begin
return Flag201 (Id);
end Has_Pragma_No_Inline;
function Has_Pragma_Ordered (Id : E) return B is
begin
pragma Assert (Is_Enumeration_Type (Id));
return Flag198 (Implementation_Base_Type (Id));
end Has_Pragma_Ordered;
function Has_Pragma_Pack (Id : E) return B is
begin
pragma Assert (Is_Record_Type (Id) or else Is_Array_Type (Id));
return Flag121 (Implementation_Base_Type (Id));
end Has_Pragma_Pack;
function Has_Pragma_Preelab_Init (Id : E) return B is
begin
return Flag221 (Id);
end Has_Pragma_Preelab_Init;
function Has_Pragma_Pure (Id : E) return B is
begin
return Flag203 (Id);
end Has_Pragma_Pure;
function Has_Pragma_Pure_Function (Id : E) return B is
begin
return Flag179 (Id);
end Has_Pragma_Pure_Function;
function Has_Pragma_Thread_Local_Storage (Id : E) return B is
begin
return Flag169 (Id);
end Has_Pragma_Thread_Local_Storage;
function Has_Pragma_Unmodified (Id : E) return B is
begin
return Flag233 (Id);
end Has_Pragma_Unmodified;
function Has_Pragma_Unreferenced (Id : E) return B is
begin
return Flag180 (Id);
end Has_Pragma_Unreferenced;
function Has_Pragma_Unreferenced_Objects (Id : E) return B is
begin
pragma Assert (Is_Type (Id));
return Flag212 (Id);
end Has_Pragma_Unreferenced_Objects;
function Has_Pragma_Unused (Id : E) return B is
begin
return Flag294 (Id);
end Has_Pragma_Unused;
function Has_Predicates (Id : E) return B is
begin
pragma Assert (Is_Type (Id));
return Flag250 (Id);
end Has_Predicates;
function Has_Primitive_Operations (Id : E) return B is
begin
pragma Assert (Is_Type (Id));
return Flag120 (Base_Type (Id));
end Has_Primitive_Operations;
function Has_Private_Ancestor (Id : E) return B is
begin
return Flag151 (Id);
end Has_Private_Ancestor;
function Has_Private_Declaration (Id : E) return B is
begin
return Flag155 (Id);
end Has_Private_Declaration;
function Has_Private_Extension (Id : E) return B is
begin
pragma Assert (Is_Tagged_Type (Id));
return Flag300 (Id);
end Has_Private_Extension;
function Has_Protected (Id : E) return B is
begin
return Flag271 (Base_Type (Id));
end Has_Protected;
function Has_Qualified_Name (Id : E) return B is
begin
return Flag161 (Id);
end Has_Qualified_Name;
function Has_RACW (Id : E) return B is
begin
pragma Assert (Ekind (Id) = E_Package);
return Flag214 (Id);
end Has_RACW;
function Has_Record_Rep_Clause (Id : E) return B is
begin
pragma Assert (Is_Record_Type (Id));
return Flag65 (Implementation_Base_Type (Id));
end Has_Record_Rep_Clause;
function Has_Recursive_Call (Id : E) return B is
begin
pragma Assert (Is_Subprogram (Id));
return Flag143 (Id);
end Has_Recursive_Call;
function Has_Shift_Operator (Id : E) return B is
begin
pragma Assert (Is_Integer_Type (Id));
return Flag267 (Base_Type (Id));
end Has_Shift_Operator;
function Has_Size_Clause (Id : E) return B is
begin
return Flag29 (Id);
end Has_Size_Clause;
function Has_Small_Clause (Id : E) return B is
begin
pragma Assert (Is_Ordinary_Fixed_Point_Type (Id));
return Flag67 (Id);
end Has_Small_Clause;
function Has_Specified_Layout (Id : E) return B is
begin
pragma Assert (Is_Type (Id));
return Flag100 (Implementation_Base_Type (Id));
end Has_Specified_Layout;
function Has_Specified_Stream_Input (Id : E) return B is
begin
pragma Assert (Is_Type (Id));
return Flag190 (Id);
end Has_Specified_Stream_Input;
function Has_Specified_Stream_Output (Id : E) return B is
begin
pragma Assert (Is_Type (Id));
return Flag191 (Id);
end Has_Specified_Stream_Output;
function Has_Specified_Stream_Read (Id : E) return B is
begin
pragma Assert (Is_Type (Id));
return Flag192 (Id);
end Has_Specified_Stream_Read;
function Has_Specified_Stream_Write (Id : E) return B is
begin
pragma Assert (Is_Type (Id));
return Flag193 (Id);
end Has_Specified_Stream_Write;
function Has_Static_Discriminants (Id : E) return B is
begin
pragma Assert (Is_Type (Id));
return Flag211 (Id);
end Has_Static_Discriminants;
function Has_Static_Predicate (Id : E) return B is
begin
pragma Assert (Is_Type (Id));
return Flag269 (Id);
end Has_Static_Predicate;
function Has_Static_Predicate_Aspect (Id : E) return B is
begin
pragma Assert (Is_Type (Id));
return Flag259 (Id);
end Has_Static_Predicate_Aspect;
function Has_Storage_Size_Clause (Id : E) return B is
begin
pragma Assert (Is_Access_Type (Id) or else Is_Task_Type (Id));
return Flag23 (Implementation_Base_Type (Id));
end Has_Storage_Size_Clause;
function Has_Stream_Size_Clause (Id : E) return B is
begin
return Flag184 (Id);
end Has_Stream_Size_Clause;
function Has_Task (Id : E) return B is
begin
return Flag30 (Base_Type (Id));
end Has_Task;
function Has_Thunks (Id : E) return B is
begin
return Flag228 (Id);
end Has_Thunks;
function Has_Timing_Event (Id : E) return B is
begin
return Flag289 (Base_Type (Id));
end Has_Timing_Event;
function Has_Unchecked_Union (Id : E) return B is
begin
return Flag123 (Base_Type (Id));
end Has_Unchecked_Union;
function Has_Unknown_Discriminants (Id : E) return B is
begin
pragma Assert (Is_Type (Id));
return Flag72 (Id);
end Has_Unknown_Discriminants;
function Has_Visible_Refinement (Id : E) return B is
begin
pragma Assert (Ekind (Id) = E_Abstract_State);
return Flag263 (Id);
end Has_Visible_Refinement;
function Has_Volatile_Components (Id : E) return B is
begin
return Flag87 (Implementation_Base_Type (Id));
end Has_Volatile_Components;
function Has_Xref_Entry (Id : E) return B is
begin
return Flag182 (Id);
end Has_Xref_Entry;
function Hiding_Loop_Variable (Id : E) return E is
begin
pragma Assert (Ekind (Id) = E_Variable);
return Node8 (Id);
end Hiding_Loop_Variable;
function Hidden_In_Formal_Instance (Id : E) return L is
begin
pragma Assert (Ekind (Id) = E_Package);
return Elist30 (Id);
end Hidden_In_Formal_Instance;
function Homonym (Id : E) return E is
begin
return Node4 (Id);
end Homonym;
function Ignore_SPARK_Mode_Pragmas (Id : E) return B is
begin
pragma Assert
(Ekind_In (Id, E_Protected_Body, -- concurrent types
E_Protected_Type,
E_Task_Body,
E_Task_Type)
or else
Ekind_In (Id, E_Entry, -- overloadable
E_Entry_Family,
E_Function,
E_Generic_Function,
E_Generic_Procedure,
E_Operator,
E_Procedure,
E_Subprogram_Body)
or else
Ekind_In (Id, E_Generic_Package, -- packages
E_Package,
E_Package_Body));
return Flag301 (Id);
end Ignore_SPARK_Mode_Pragmas;
function Import_Pragma (Id : E) return E is
begin
pragma Assert (Is_Subprogram (Id));
return Node35 (Id);
end Import_Pragma;
function Incomplete_Actuals (Id : E) return L is
begin
pragma Assert (Ekind (Id) = E_Package);
return Elist24 (Id);
end Incomplete_Actuals;
function Interface_Alias (Id : E) return E is
begin
pragma Assert (Is_Subprogram (Id));
return Node25 (Id);
end Interface_Alias;
function Interfaces (Id : E) return L is
begin
pragma Assert (Is_Record_Type (Id));
return Elist25 (Id);
end Interfaces;
function In_Package_Body (Id : E) return B is
begin
return Flag48 (Id);
end In_Package_Body;
function In_Private_Part (Id : E) return B is
begin
return Flag45 (Id);
end In_Private_Part;
function In_Use (Id : E) return B is
begin
pragma Assert (Nkind (Id) in N_Entity);
return Flag8 (Id);
end In_Use;
function Initialization_Statements (Id : E) return N is
begin
pragma Assert (Ekind_In (Id, E_Constant, E_Variable));
return Node28 (Id);
end Initialization_Statements;
function Inner_Instances (Id : E) return L is
begin
return Elist23 (Id);
end Inner_Instances;
function Interface_Name (Id : E) return N is
begin
return Node21 (Id);
end Interface_Name;
function Is_Abstract_Subprogram (Id : E) return B is
begin
pragma Assert (Is_Overloadable (Id));
return Flag19 (Id);
end Is_Abstract_Subprogram;
function Is_Abstract_Type (Id : E) return B is
begin
pragma Assert (Is_Type (Id));
return Flag146 (Id);
end Is_Abstract_Type;
function Is_Access_Constant (Id : E) return B is
begin
pragma Assert (Is_Access_Type (Id));
return Flag69 (Id);
end Is_Access_Constant;
function Is_Activation_Record (Id : E) return B is
begin
pragma Assert (Ekind (Id) = E_In_Parameter);
return Flag305 (Id);
end Is_Activation_Record;
function Is_Actual_Subtype (Id : E) return B is
begin
pragma Assert (Is_Type (Id));
return Flag293 (Id);
end Is_Actual_Subtype;
function Is_Ada_2005_Only (Id : E) return B is
begin
return Flag185 (Id);
end Is_Ada_2005_Only;
function Is_Ada_2012_Only (Id : E) return B is
begin
return Flag199 (Id);
end Is_Ada_2012_Only;
function Is_Aliased (Id : E) return B is
begin
pragma Assert (Nkind (Id) in N_Entity);
return Flag15 (Id);
end Is_Aliased;
function Is_Asynchronous (Id : E) return B is
begin
pragma Assert (Ekind (Id) = E_Procedure or else Is_Type (Id));
return Flag81 (Id);
end Is_Asynchronous;
function Is_Atomic (Id : E) return B is
begin
return Flag85 (Id);
end Is_Atomic;
function Is_Bit_Packed_Array (Id : E) return B is
begin
return Flag122 (Implementation_Base_Type (Id));
end Is_Bit_Packed_Array;
function Is_Called (Id : E) return B is
begin
pragma Assert (Ekind_In (Id, E_Procedure, E_Function));
return Flag102 (Id);
end Is_Called;
function Is_Character_Type (Id : E) return B is
begin
return Flag63 (Id);
end Is_Character_Type;
function Is_Checked_Ghost_Entity (Id : E) return B is
begin
-- Allow this attribute to appear on unanalyzed entities
pragma Assert (Nkind (Id) in N_Entity
or else Ekind (Id) = E_Void);
return Flag277 (Id);
end Is_Checked_Ghost_Entity;
function Is_Child_Unit (Id : E) return B is
begin
return Flag73 (Id);
end Is_Child_Unit;
function Is_Class_Wide_Clone (Id : E) return B is
begin
return Flag290 (Id);
end Is_Class_Wide_Clone;
function Is_Class_Wide_Equivalent_Type (Id : E) return B is
begin
return Flag35 (Id);
end Is_Class_Wide_Equivalent_Type;
function Is_Compilation_Unit (Id : E) return B is
begin
return Flag149 (Id);
end Is_Compilation_Unit;
function Is_Completely_Hidden (Id : E) return B is
begin
pragma Assert (Ekind (Id) = E_Discriminant);
return Flag103 (Id);
end Is_Completely_Hidden;
function Is_Constr_Subt_For_U_Nominal (Id : E) return B is
begin
return Flag80 (Id);
end Is_Constr_Subt_For_U_Nominal;
function Is_Constr_Subt_For_UN_Aliased (Id : E) return B is
begin
return Flag141 (Id);
end Is_Constr_Subt_For_UN_Aliased;
function Is_Constrained (Id : E) return B is
begin
pragma Assert (Nkind (Id) in N_Entity);
return Flag12 (Id);
end Is_Constrained;
function Is_Constructor (Id : E) return B is
begin
return Flag76 (Id);
end Is_Constructor;
function Is_Controlled_Active (Id : E) return B is
begin
return Flag42 (Base_Type (Id));
end Is_Controlled_Active;
function Is_Controlling_Formal (Id : E) return B is
begin
pragma Assert (Is_Formal (Id));
return Flag97 (Id);
end Is_Controlling_Formal;
function Is_CPP_Class (Id : E) return B is
begin
return Flag74 (Id);
end Is_CPP_Class;
function Is_DIC_Procedure (Id : E) return B is
begin
pragma Assert (Ekind_In (Id, E_Function, E_Procedure));
return Flag132 (Id);
end Is_DIC_Procedure;
function Is_Descendant_Of_Address (Id : E) return B is
begin
return Flag223 (Id);
end Is_Descendant_Of_Address;
function Is_Discrim_SO_Function (Id : E) return B is
begin
return Flag176 (Id);
end Is_Discrim_SO_Function;
function Is_Discriminant_Check_Function (Id : E) return B is
begin
return Flag264 (Id);
end Is_Discriminant_Check_Function;
function Is_Dispatch_Table_Entity (Id : E) return B is
begin
return Flag234 (Id);
end Is_Dispatch_Table_Entity;
function Is_Dispatching_Operation (Id : E) return B is
begin
pragma Assert (Nkind (Id) in N_Entity);
return Flag6 (Id);
end Is_Dispatching_Operation;
function Is_Elaboration_Checks_OK_Id (Id : E) return B is
begin
pragma Assert (Is_Elaboration_Target (Id));
return Flag148 (Id);
end Is_Elaboration_Checks_OK_Id;
function Is_Elaboration_Warnings_OK_Id (Id : E) return B is
begin
pragma Assert (Is_Elaboration_Target (Id) or else Ekind (Id) = E_Void);
return Flag304 (Id);
end Is_Elaboration_Warnings_OK_Id;
function Is_Eliminated (Id : E) return B is
begin
return Flag124 (Id);
end Is_Eliminated;
function Is_Entry_Formal (Id : E) return B is
begin
return Flag52 (Id);
end Is_Entry_Formal;
function Is_Entry_Wrapper (Id : E) return B is
begin
return Flag297 (Id);
end Is_Entry_Wrapper;
function Is_Exception_Handler (Id : E) return B is
begin
pragma Assert (Ekind (Id) = E_Block);
return Flag286 (Id);
end Is_Exception_Handler;
function Is_Exported (Id : E) return B is
begin
return Flag99 (Id);
end Is_Exported;
function Is_Finalized_Transient (Id : E) return B is
begin
pragma Assert (Ekind_In (Id, E_Constant, E_Loop_Parameter, E_Variable));
return Flag252 (Id);
end Is_Finalized_Transient;
function Is_First_Subtype (Id : E) return B is
begin
return Flag70 (Id);
end Is_First_Subtype;
function Is_For_Access_Subtype (Id : E) return B is
begin
pragma Assert (Ekind_In (Id, E_Record_Subtype, E_Private_Subtype));
return Flag118 (Id);
end Is_For_Access_Subtype;
function Is_Formal_Subprogram (Id : E) return B is
begin
return Flag111 (Id);
end Is_Formal_Subprogram;
function Is_Frozen (Id : E) return B is
begin
return Flag4 (Id);
end Is_Frozen;
function Is_Generic_Actual_Subprogram (Id : E) return B is
begin
pragma Assert (Ekind (Id) = E_Function or else Ekind (Id) = E_Procedure);
return Flag274 (Id);
end Is_Generic_Actual_Subprogram;
function Is_Generic_Actual_Type (Id : E) return B is
begin
pragma Assert (Is_Type (Id));
return Flag94 (Id);
end Is_Generic_Actual_Type;
function Is_Generic_Instance (Id : E) return B is
begin
return Flag130 (Id);
end Is_Generic_Instance;
function Is_Generic_Type (Id : E) return B is
begin
pragma Assert (Nkind (Id) in N_Entity);
return Flag13 (Id);
end Is_Generic_Type;
function Is_Hidden (Id : E) return B is
begin
return Flag57 (Id);
end Is_Hidden;
function Is_Hidden_Non_Overridden_Subpgm (Id : E) return B is
begin
return Flag2 (Id);
end Is_Hidden_Non_Overridden_Subpgm;
function Is_Hidden_Open_Scope (Id : E) return B is
begin
return Flag171 (Id);
end Is_Hidden_Open_Scope;
function Is_Ignored_Ghost_Entity (Id : E) return B is
begin
-- Allow this attribute to appear on unanalyzed entities
pragma Assert (Nkind (Id) in N_Entity
or else Ekind (Id) = E_Void);
return Flag278 (Id);
end Is_Ignored_Ghost_Entity;
function Is_Ignored_Transient (Id : E) return B is
begin
pragma Assert (Ekind_In (Id, E_Constant, E_Loop_Parameter, E_Variable));
return Flag295 (Id);
end Is_Ignored_Transient;
function Is_Immediately_Visible (Id : E) return B is
begin
pragma Assert (Nkind (Id) in N_Entity);
return Flag7 (Id);
end Is_Immediately_Visible;
function Is_Implementation_Defined (Id : E) return B is
begin
return Flag254 (Id);
end Is_Implementation_Defined;
function Is_Imported (Id : E) return B is
begin
return Flag24 (Id);
end Is_Imported;
function Is_Independent (Id : E) return B is
begin
return Flag268 (Id);
end Is_Independent;
function Is_Initial_Condition_Procedure (Id : E) return B is
begin
pragma Assert (Ekind_In (Id, E_Function, E_Procedure));
return Flag302 (Id);
end Is_Initial_Condition_Procedure;
function Is_Inlined (Id : E) return B is
begin
return Flag11 (Id);
end Is_Inlined;
function Is_Inlined_Always (Id : E) return B is
begin
pragma Assert (Ekind_In (Id, E_Function, E_Procedure));
return Flag1 (Id);
end Is_Inlined_Always;
function Is_Interface (Id : E) return B is
begin
return Flag186 (Id);
end Is_Interface;
function Is_Instantiated (Id : E) return B is
begin
return Flag126 (Id);
end Is_Instantiated;
function Is_Internal (Id : E) return B is
begin
pragma Assert (Nkind (Id) in N_Entity);
return Flag17 (Id);
end Is_Internal;
function Is_Interrupt_Handler (Id : E) return B is
begin
pragma Assert (Nkind (Id) in N_Entity);
return Flag89 (Id);
end Is_Interrupt_Handler;
function Is_Intrinsic_Subprogram (Id : E) return B is
begin
return Flag64 (Id);
end Is_Intrinsic_Subprogram;
function Is_Invariant_Procedure (Id : E) return B is
begin
pragma Assert (Ekind_In (Id, E_Function, E_Procedure));
return Flag257 (Id);
end Is_Invariant_Procedure;
function Is_Itype (Id : E) return B is
begin
return Flag91 (Id);
end Is_Itype;
function Is_Known_Non_Null (Id : E) return B is
begin
return Flag37 (Id);
end Is_Known_Non_Null;
function Is_Known_Null (Id : E) return B is
begin
return Flag204 (Id);
end Is_Known_Null;
function Is_Known_Valid (Id : E) return B is
begin
return Flag170 (Id);
end Is_Known_Valid;
function Is_Limited_Composite (Id : E) return B is
begin
return Flag106 (Id);
end Is_Limited_Composite;
function Is_Limited_Interface (Id : E) return B is
begin
return Flag197 (Id);
end Is_Limited_Interface;
function Is_Limited_Record (Id : E) return B is
begin
return Flag25 (Id);
end Is_Limited_Record;
function Is_Local_Anonymous_Access (Id : E) return B is
begin
pragma Assert (Is_Access_Type (Id));
return Flag194 (Id);
end Is_Local_Anonymous_Access;
function Is_Loop_Parameter (Id : E) return B is
begin
return Flag307 (Id);
end Is_Loop_Parameter;
function Is_Machine_Code_Subprogram (Id : E) return B is
begin
pragma Assert (Is_Subprogram (Id));
return Flag137 (Id);
end Is_Machine_Code_Subprogram;
function Is_Non_Static_Subtype (Id : E) return B is
begin
pragma Assert (Is_Type (Id));
return Flag109 (Id);
end Is_Non_Static_Subtype;
function Is_Null_Init_Proc (Id : E) return B is
begin
pragma Assert (Ekind (Id) = E_Procedure);
return Flag178 (Id);
end Is_Null_Init_Proc;
function Is_Obsolescent (Id : E) return B is
begin
return Flag153 (Id);
end Is_Obsolescent;
function Is_Only_Out_Parameter (Id : E) return B is
begin
pragma Assert (Is_Formal (Id));
return Flag226 (Id);
end Is_Only_Out_Parameter;
function Is_Package_Body_Entity (Id : E) return B is
begin
return Flag160 (Id);
end Is_Package_Body_Entity;
function Is_Packed (Id : E) return B is
begin
return Flag51 (Implementation_Base_Type (Id));
end Is_Packed;
function Is_Packed_Array_Impl_Type (Id : E) return B is
begin
return Flag138 (Id);
end Is_Packed_Array_Impl_Type;
function Is_Param_Block_Component_Type (Id : E) return B is
begin
pragma Assert (Is_Access_Type (Id));
return Flag215 (Base_Type (Id));
end Is_Param_Block_Component_Type;
function Is_Partial_Invariant_Procedure (Id : E) return B is
begin
pragma Assert (Ekind_In (Id, E_Function, E_Procedure));
return Flag292 (Id);
end Is_Partial_Invariant_Procedure;
function Is_Potentially_Use_Visible (Id : E) return B is
begin
pragma Assert (Nkind (Id) in N_Entity);
return Flag9 (Id);
end Is_Potentially_Use_Visible;
function Is_Predicate_Function (Id : E) return B is
begin
pragma Assert (Ekind_In (Id, E_Function, E_Procedure));
return Flag255 (Id);
end Is_Predicate_Function;
function Is_Predicate_Function_M (Id : E) return B is
begin
pragma Assert (Ekind_In (Id, E_Function, E_Procedure));
return Flag256 (Id);
end Is_Predicate_Function_M;
function Is_Preelaborated (Id : E) return B is
begin
return Flag59 (Id);
end Is_Preelaborated;
function Is_Primitive (Id : E) return B is
begin
pragma Assert
(Is_Overloadable (Id)
or else Ekind_In (Id, E_Generic_Function, E_Generic_Procedure));
return Flag218 (Id);
end Is_Primitive;
function Is_Primitive_Wrapper (Id : E) return B is
begin
pragma Assert (Ekind_In (Id, E_Function, E_Procedure));
return Flag195 (Id);
end Is_Primitive_Wrapper;
function Is_Private_Composite (Id : E) return B is
begin
pragma Assert (Is_Type (Id));
return Flag107 (Id);
end Is_Private_Composite;
function Is_Private_Descendant (Id : E) return B is
begin
return Flag53 (Id);
end Is_Private_Descendant;
function Is_Private_Primitive (Id : E) return B is
begin
pragma Assert (Ekind_In (Id, E_Function, E_Procedure));
return Flag245 (Id);
end Is_Private_Primitive;
function Is_Public (Id : E) return B is
begin
pragma Assert (Nkind (Id) in N_Entity);
return Flag10 (Id);
end Is_Public;
function Is_Pure (Id : E) return B is
begin
return Flag44 (Id);
end Is_Pure;
function Is_Pure_Unit_Access_Type (Id : E) return B is
begin
pragma Assert (Is_Access_Type (Id));
return Flag189 (Id);
end Is_Pure_Unit_Access_Type;
function Is_RACW_Stub_Type (Id : E) return B is
begin
pragma Assert (Is_Type (Id));
return Flag244 (Id);
end Is_RACW_Stub_Type;
function Is_Raised (Id : E) return B is
begin
pragma Assert (Ekind (Id) = E_Exception);
return Flag224 (Id);
end Is_Raised;
function Is_Remote_Call_Interface (Id : E) return B is
begin
return Flag62 (Id);
end Is_Remote_Call_Interface;
function Is_Remote_Types (Id : E) return B is
begin
return Flag61 (Id);
end Is_Remote_Types;
function Is_Renaming_Of_Object (Id : E) return B is
begin
return Flag112 (Id);
end Is_Renaming_Of_Object;
function Is_Return_Object (Id : E) return B is
begin
return Flag209 (Id);
end Is_Return_Object;
function Is_Safe_To_Reevaluate (Id : E) return B is
begin
return Flag249 (Id);
end Is_Safe_To_Reevaluate;
function Is_Shared_Passive (Id : E) return B is
begin
return Flag60 (Id);
end Is_Shared_Passive;
function Is_Static_Type (Id : E) return B is
begin
return Flag281 (Id);
end Is_Static_Type;
function Is_Statically_Allocated (Id : E) return B is
begin
return Flag28 (Id);
end Is_Statically_Allocated;
function Is_Tag (Id : E) return B is
begin
pragma Assert (Nkind (Id) in N_Entity);
return Flag78 (Id);
end Is_Tag;
function Is_Tagged_Type (Id : E) return B is
begin
return Flag55 (Id);
end Is_Tagged_Type;
function Is_Thunk (Id : E) return B is
begin
return Flag225 (Id);
end Is_Thunk;
function Is_Trivial_Subprogram (Id : E) return B is
begin
return Flag235 (Id);
end Is_Trivial_Subprogram;
function Is_True_Constant (Id : E) return B is
begin
return Flag163 (Id);
end Is_True_Constant;
function Is_Unchecked_Union (Id : E) return B is
begin
return Flag117 (Implementation_Base_Type (Id));
end Is_Unchecked_Union;
function Is_Underlying_Full_View (Id : E) return B is
begin
return Flag298 (Id);
end Is_Underlying_Full_View;
function Is_Underlying_Record_View (Id : E) return B is
begin
return Flag246 (Id);
end Is_Underlying_Record_View;
function Is_Unimplemented (Id : E) return B is
begin
return Flag284 (Id);
end Is_Unimplemented;
function Is_Unsigned_Type (Id : E) return B is
begin
pragma Assert (Is_Type (Id));
return Flag144 (Id);
end Is_Unsigned_Type;
function Is_Uplevel_Referenced_Entity (Id : E) return B is
begin
return Flag283 (Id);
end Is_Uplevel_Referenced_Entity;
function Is_Valued_Procedure (Id : E) return B is
begin
pragma Assert (Ekind (Id) = E_Procedure);
return Flag127 (Id);
end Is_Valued_Procedure;
function Is_Visible_Formal (Id : E) return B is
begin
return Flag206 (Id);
end Is_Visible_Formal;
function Is_Visible_Lib_Unit (Id : E) return B is
begin
return Flag116 (Id);
end Is_Visible_Lib_Unit;
function Is_Volatile (Id : E) return B is
begin
pragma Assert (Nkind (Id) in N_Entity);
if Is_Type (Id) then
return Flag16 (Base_Type (Id));
else
return Flag16 (Id);
end if;
end Is_Volatile;
function Is_Volatile_Full_Access (Id : E) return B is
begin
return Flag285 (Id);
end Is_Volatile_Full_Access;
function Itype_Printed (Id : E) return B is
begin
pragma Assert (Is_Itype (Id));
return Flag202 (Id);
end Itype_Printed;
function Kill_Elaboration_Checks (Id : E) return B is
begin
return Flag32 (Id);
end Kill_Elaboration_Checks;
function Kill_Range_Checks (Id : E) return B is
begin
return Flag33 (Id);
end Kill_Range_Checks;
function Known_To_Have_Preelab_Init (Id : E) return B is
begin
pragma Assert (Is_Type (Id));
return Flag207 (Id);
end Known_To_Have_Preelab_Init;
function Last_Aggregate_Assignment (Id : E) return N is
begin
pragma Assert (Ekind_In (Id, E_Constant, E_Variable));
return Node30 (Id);
end Last_Aggregate_Assignment;
function Last_Assignment (Id : E) return N is
begin
pragma Assert (Is_Assignable (Id));
return Node26 (Id);
end Last_Assignment;
function Last_Entity (Id : E) return E is
begin
return Node20 (Id);
end Last_Entity;
function Limited_View (Id : E) return E is
begin
pragma Assert (Ekind (Id) = E_Package);
return Node23 (Id);
end Limited_View;
function Linker_Section_Pragma (Id : E) return N is
begin
pragma Assert
(Is_Object (Id) or else Is_Subprogram (Id) or else Is_Type (Id));
return Node33 (Id);
end Linker_Section_Pragma;
function Lit_Indexes (Id : E) return E is
begin
pragma Assert (Is_Enumeration_Type (Id));
return Node18 (Id);
end Lit_Indexes;
function Lit_Strings (Id : E) return E is
begin
pragma Assert (Is_Enumeration_Type (Id));
return Node16 (Id);
end Lit_Strings;
function Low_Bound_Tested (Id : E) return B is
begin
return Flag205 (Id);
end Low_Bound_Tested;
function Machine_Radix_10 (Id : E) return B is
begin
pragma Assert (Is_Decimal_Fixed_Point_Type (Id));
return Flag84 (Id);
end Machine_Radix_10;
function Master_Id (Id : E) return E is
begin
pragma Assert (Is_Access_Type (Id));
return Node17 (Id);
end Master_Id;
function Materialize_Entity (Id : E) return B is
begin
return Flag168 (Id);
end Materialize_Entity;
function May_Inherit_Delayed_Rep_Aspects (Id : E) return B is
begin
return Flag262 (Id);
end May_Inherit_Delayed_Rep_Aspects;
function Mechanism (Id : E) return M is
begin
pragma Assert (Ekind (Id) = E_Function or else Is_Formal (Id));
return UI_To_Int (Uint8 (Id));
end Mechanism;
function Modulus (Id : E) return Uint is
begin
pragma Assert (Is_Modular_Integer_Type (Id));
return Uint17 (Base_Type (Id));
end Modulus;
function Must_Be_On_Byte_Boundary (Id : E) return B is
begin
pragma Assert (Is_Type (Id));
return Flag183 (Id);
end Must_Be_On_Byte_Boundary;
function Must_Have_Preelab_Init (Id : E) return B is
begin
pragma Assert (Is_Type (Id));
return Flag208 (Id);
end Must_Have_Preelab_Init;
function Needs_Activation_Record (Id : E) return B is
begin
return Flag306 (Id);
end Needs_Activation_Record;
function Needs_Debug_Info (Id : E) return B is
begin
return Flag147 (Id);
end Needs_Debug_Info;
function Needs_No_Actuals (Id : E) return B is
begin
pragma Assert
(Is_Overloadable (Id)
or else Ekind_In (Id, E_Subprogram_Type, E_Entry_Family));
return Flag22 (Id);
end Needs_No_Actuals;
function Never_Set_In_Source (Id : E) return B is
begin
return Flag115 (Id);
end Never_Set_In_Source;
function Next_Inlined_Subprogram (Id : E) return E is
begin
return Node12 (Id);
end Next_Inlined_Subprogram;
function No_Dynamic_Predicate_On_Actual (Id : E) return Boolean is
begin
pragma Assert (Is_Discrete_Type (Id));
return Flag276 (Id);
end No_Dynamic_Predicate_On_Actual;
function No_Pool_Assigned (Id : E) return B is
begin
pragma Assert (Is_Access_Type (Id));
return Flag131 (Root_Type (Id));
end No_Pool_Assigned;
function No_Predicate_On_Actual (Id : E) return Boolean is
begin
pragma Assert (Is_Discrete_Type (Id));
return Flag275 (Id);
end No_Predicate_On_Actual;
function No_Reordering (Id : E) return B is
begin
pragma Assert (Is_Record_Type (Id));
return Flag239 (Implementation_Base_Type (Id));
end No_Reordering;
function No_Return (Id : E) return B is
begin
return Flag113 (Id);
end No_Return;
function No_Strict_Aliasing (Id : E) return B is
begin
pragma Assert (Is_Access_Type (Id));
return Flag136 (Base_Type (Id));
end No_Strict_Aliasing;
function No_Tagged_Streams_Pragma (Id : E) return N is
begin
pragma Assert (Is_Tagged_Type (Id));
return Node32 (Id);
end No_Tagged_Streams_Pragma;
function Non_Binary_Modulus (Id : E) return B is
begin
pragma Assert (Is_Type (Id));
return Flag58 (Base_Type (Id));
end Non_Binary_Modulus;
function Non_Limited_View (Id : E) return E is
begin
pragma Assert
(Ekind (Id) in Incomplete_Kind
or else
Ekind (Id) in Class_Wide_Kind
or else
Ekind (Id) = E_Abstract_State);
return Node19 (Id);
end Non_Limited_View;
function Nonzero_Is_True (Id : E) return B is
begin
pragma Assert (Root_Type (Id) = Standard_Boolean);
return Flag162 (Base_Type (Id));
end Nonzero_Is_True;
function Normalized_First_Bit (Id : E) return U is
begin
pragma Assert (Ekind_In (Id, E_Component, E_Discriminant));
return Uint8 (Id);
end Normalized_First_Bit;
function Normalized_Position (Id : E) return U is
begin
pragma Assert (Ekind_In (Id, E_Component, E_Discriminant));
return Uint14 (Id);
end Normalized_Position;
function Normalized_Position_Max (Id : E) return U is
begin
pragma Assert (Ekind_In (Id, E_Component, E_Discriminant));
return Uint10 (Id);
end Normalized_Position_Max;
function OK_To_Rename (Id : E) return B is
begin
pragma Assert (Ekind (Id) = E_Variable);
return Flag247 (Id);
end OK_To_Rename;
function Optimize_Alignment_Space (Id : E) return B is
begin
pragma Assert
(Is_Type (Id) or else Ekind_In (Id, E_Constant, E_Variable));
return Flag241 (Id);
end Optimize_Alignment_Space;
function Optimize_Alignment_Time (Id : E) return B is
begin
pragma Assert
(Is_Type (Id) or else Ekind_In (Id, E_Constant, E_Variable));
return Flag242 (Id);
end Optimize_Alignment_Time;
function Original_Access_Type (Id : E) return E is
begin
pragma Assert (Ekind (Id) = E_Access_Subprogram_Type);
return Node28 (Id);
end Original_Access_Type;
function Original_Array_Type (Id : E) return E is
begin
pragma Assert (Is_Array_Type (Id) or else Is_Modular_Integer_Type (Id));
return Node21 (Id);
end Original_Array_Type;
function Original_Protected_Subprogram (Id : E) return N is
begin
return Node41 (Id);
end Original_Protected_Subprogram;
function Original_Record_Component (Id : E) return E is
begin
pragma Assert (Ekind_In (Id, E_Void, E_Component, E_Discriminant));
return Node22 (Id);
end Original_Record_Component;
function Overlays_Constant (Id : E) return B is
begin
return Flag243 (Id);
end Overlays_Constant;
function Overridden_Operation (Id : E) return E is
begin
pragma Assert (Is_Subprogram (Id) or else Is_Generic_Subprogram (Id));
return Node26 (Id);
end Overridden_Operation;
function Package_Instantiation (Id : E) return N is
begin
pragma Assert (Ekind_In (Id, E_Package, E_Generic_Package));
return Node26 (Id);
end Package_Instantiation;
function Packed_Array_Impl_Type (Id : E) return E is
begin
pragma Assert (Is_Array_Type (Id));
return Node23 (Id);
end Packed_Array_Impl_Type;
function Parent_Subtype (Id : E) return E is
begin
pragma Assert (Is_Record_Type (Id));
return Node19 (Base_Type (Id));
end Parent_Subtype;
function Part_Of_Constituents (Id : E) return L is
begin
pragma Assert (Ekind_In (Id, E_Abstract_State, E_Variable));
return Elist10 (Id);
end Part_Of_Constituents;
function Part_Of_References (Id : E) return L is
begin
pragma Assert (Ekind (Id) = E_Variable);
return Elist11 (Id);
end Part_Of_References;
function Partial_View_Has_Unknown_Discr (Id : E) return B is
begin
pragma Assert (Is_Type (Id));
return Flag280 (Id);
end Partial_View_Has_Unknown_Discr;
function Pending_Access_Types (Id : E) return L is
begin
pragma Assert (Is_Type (Id));
return Elist15 (Id);
end Pending_Access_Types;
function Postconditions_Proc (Id : E) return E is
begin
pragma Assert (Ekind_In (Id, E_Entry,
E_Entry_Family,
E_Function,
E_Procedure));
return Node14 (Id);
end Postconditions_Proc;
function Predicated_Parent (Id : E) return E is
begin
pragma Assert (Ekind_In (Id, E_Array_Subtype,
E_Record_Subtype,
E_Record_Subtype_With_Private));
return Node38 (Id);
end Predicated_Parent;
function Predicates_Ignored (Id : E) return B is
begin
pragma Assert (Is_Type (Id));
return Flag288 (Id);
end Predicates_Ignored;
function Prev_Entity (Id : E) return E is
begin
return Node36 (Id);
end Prev_Entity;
function Prival (Id : E) return E is
begin
pragma Assert (Is_Protected_Component (Id));
return Node17 (Id);
end Prival;
function Prival_Link (Id : E) return E is
begin
pragma Assert (Ekind_In (Id, E_Constant, E_Variable));
return Node20 (Id);
end Prival_Link;
function Private_Dependents (Id : E) return L is
begin
pragma Assert (Is_Incomplete_Or_Private_Type (Id));
return Elist18 (Id);
end Private_Dependents;
function Protected_Body_Subprogram (Id : E) return E is
begin
pragma Assert (Is_Subprogram (Id) or else Is_Entry (Id));
return Node11 (Id);
end Protected_Body_Subprogram;
function Protected_Formal (Id : E) return E is
begin
pragma Assert (Is_Formal (Id));
return Node22 (Id);
end Protected_Formal;
function Protected_Subprogram (Id : E) return N is
begin
pragma Assert (Ekind_In (Id, E_Function, E_Procedure));
return Node39 (Id);
end Protected_Subprogram;
function Protection_Object (Id : E) return E is
begin
pragma Assert (Ekind_In (Id, E_Entry,
E_Entry_Family,
E_Function,
E_Procedure));
return Node23 (Id);
end Protection_Object;
function Reachable (Id : E) return B is
begin
return Flag49 (Id);
end Reachable;
function Receiving_Entry (Id : E) return E is
begin
pragma Assert (Ekind (Id) = E_Procedure);
return Node19 (Id);
end Receiving_Entry;
function Referenced (Id : E) return B is
begin
return Flag156 (Id);
end Referenced;
function Referenced_As_LHS (Id : E) return B is
begin
return Flag36 (Id);
end Referenced_As_LHS;
function Referenced_As_Out_Parameter (Id : E) return B is
begin
return Flag227 (Id);
end Referenced_As_Out_Parameter;
function Refinement_Constituents (Id : E) return L is
begin
pragma Assert (Ekind (Id) = E_Abstract_State);
return Elist8 (Id);
end Refinement_Constituents;
function Register_Exception_Call (Id : E) return N is
begin
pragma Assert (Ekind (Id) = E_Exception);
return Node20 (Id);
end Register_Exception_Call;
function Related_Array_Object (Id : E) return E is
begin
pragma Assert (Is_Array_Type (Id));
return Node25 (Id);
end Related_Array_Object;
function Related_Expression (Id : E) return N is
begin
pragma Assert (Ekind (Id) in Type_Kind
or else Ekind_In (Id, E_Constant, E_Variable));
return Node24 (Id);
end Related_Expression;
function Related_Instance (Id : E) return E is
begin
pragma Assert (Ekind_In (Id, E_Package, E_Package_Body));
return Node15 (Id);
end Related_Instance;
function Related_Type (Id : E) return E is
begin
pragma Assert (Ekind_In (Id, E_Component, E_Constant, E_Variable));
return Node27 (Id);
end Related_Type;
function Relative_Deadline_Variable (Id : E) return E is
begin
pragma Assert (Is_Task_Type (Id));
return Node28 (Implementation_Base_Type (Id));
end Relative_Deadline_Variable;
function Renamed_Entity (Id : E) return N is
begin
return Node18 (Id);
end Renamed_Entity;
function Renamed_In_Spec (Id : E) return B is
begin
pragma Assert (Ekind (Id) = E_Package);
return Flag231 (Id);
end Renamed_In_Spec;
function Renamed_Object (Id : E) return N is
begin
return Node18 (Id);
end Renamed_Object;
function Renaming_Map (Id : E) return U is
begin
return Uint9 (Id);
end Renaming_Map;
function Requires_Overriding (Id : E) return B is
begin
pragma Assert (Is_Overloadable (Id));
return Flag213 (Id);
end Requires_Overriding;
function Return_Present (Id : E) return B is
begin
return Flag54 (Id);
end Return_Present;
function Return_Applies_To (Id : E) return N is
begin
return Node8 (Id);
end Return_Applies_To;
function Returns_By_Ref (Id : E) return B is
begin
return Flag90 (Id);
end Returns_By_Ref;
function Reverse_Bit_Order (Id : E) return B is
begin
pragma Assert (Is_Record_Type (Id));
return Flag164 (Base_Type (Id));
end Reverse_Bit_Order;
function Reverse_Storage_Order (Id : E) return B is
begin
pragma Assert (Is_Record_Type (Id) or else Is_Array_Type (Id));
return Flag93 (Base_Type (Id));
end Reverse_Storage_Order;
function Rewritten_For_C (Id : E) return B is
begin
pragma Assert (Ekind (Id) = E_Function);
return Flag287 (Id);
end Rewritten_For_C;
function RM_Size (Id : E) return U is
begin
pragma Assert (Is_Type (Id));
return Uint13 (Id);
end RM_Size;
function Scalar_Range (Id : E) return N is
begin
return Node20 (Id);
end Scalar_Range;
function Scale_Value (Id : E) return U is
begin
return Uint16 (Id);
end Scale_Value;
function Scope_Depth_Value (Id : E) return U is
begin
return Uint22 (Id);
end Scope_Depth_Value;
function Sec_Stack_Needed_For_Return (Id : E) return B is
begin
return Flag167 (Id);
end Sec_Stack_Needed_For_Return;
function Shared_Var_Procs_Instance (Id : E) return E is
begin
pragma Assert (Ekind (Id) = E_Variable);
return Node22 (Id);
end Shared_Var_Procs_Instance;
function Size_Check_Code (Id : E) return N is
begin
pragma Assert (Ekind_In (Id, E_Constant, E_Variable));
return Node19 (Id);
end Size_Check_Code;
function Size_Depends_On_Discriminant (Id : E) return B is
begin
return Flag177 (Id);
end Size_Depends_On_Discriminant;
function Size_Known_At_Compile_Time (Id : E) return B is
begin
return Flag92 (Id);
end Size_Known_At_Compile_Time;
function Small_Value (Id : E) return R is
begin
pragma Assert (Is_Fixed_Point_Type (Id));
return Ureal21 (Id);
end Small_Value;
function SPARK_Aux_Pragma (Id : E) return N is
begin
pragma Assert
(Ekind_In (Id, E_Protected_Type, -- concurrent types
E_Task_Type)
or else
Ekind_In (Id, E_Generic_Package, -- packages
E_Package,
E_Package_Body));
return Node41 (Id);
end SPARK_Aux_Pragma;
function SPARK_Aux_Pragma_Inherited (Id : E) return B is
begin
pragma Assert
(Ekind_In (Id, E_Protected_Type, -- concurrent types
E_Task_Type)
or else
Ekind_In (Id, E_Generic_Package, -- packages
E_Package,
E_Package_Body));
return Flag266 (Id);
end SPARK_Aux_Pragma_Inherited;
function SPARK_Pragma (Id : E) return N is
begin
pragma Assert
(Ekind_In (Id, E_Constant, -- objects
E_Variable)
or else
Ekind_In (Id, E_Abstract_State, -- overloadable
E_Entry,
E_Entry_Family,
E_Function,
E_Generic_Function,
E_Generic_Procedure,
E_Operator,
E_Procedure,
E_Subprogram_Body)
or else
Ekind_In (Id, E_Generic_Package, -- packages
E_Package,
E_Package_Body)
or else
Ekind (Id) = E_Void -- special purpose
or else
Ekind_In (Id, E_Protected_Body, -- types
E_Task_Body)
or else
Is_Type (Id));
return Node40 (Id);
end SPARK_Pragma;
function SPARK_Pragma_Inherited (Id : E) return B is
begin
pragma Assert
(Ekind_In (Id, E_Constant, -- objects
E_Variable)
or else
Ekind_In (Id, E_Abstract_State, -- overloadable
E_Entry,
E_Entry_Family,
E_Function,
E_Generic_Function,
E_Generic_Procedure,
E_Operator,
E_Procedure,
E_Subprogram_Body)
or else
Ekind_In (Id, E_Generic_Package, -- packages
E_Package,
E_Package_Body)
or else
Ekind (Id) = E_Void -- special purpose
or else
Ekind_In (Id, E_Protected_Body, -- types
E_Task_Body)
or else
Is_Type (Id));
return Flag265 (Id);
end SPARK_Pragma_Inherited;
function Spec_Entity (Id : E) return E is
begin
pragma Assert (Ekind (Id) = E_Package_Body or else Is_Formal (Id));
return Node19 (Id);
end Spec_Entity;
function SSO_Set_High_By_Default (Id : E) return B is
begin
pragma Assert (Is_Record_Type (Id) or else Is_Array_Type (Id));
return Flag273 (Base_Type (Id));
end SSO_Set_High_By_Default;
function SSO_Set_Low_By_Default (Id : E) return B is
begin
pragma Assert (Is_Record_Type (Id) or else Is_Array_Type (Id));
return Flag272 (Base_Type (Id));
end SSO_Set_Low_By_Default;
function Static_Discrete_Predicate (Id : E) return S is
begin
pragma Assert (Is_Discrete_Type (Id));
return List25 (Id);
end Static_Discrete_Predicate;
function Static_Real_Or_String_Predicate (Id : E) return N is
begin
pragma Assert (Is_Real_Type (Id) or else Is_String_Type (Id));
return Node25 (Id);
end Static_Real_Or_String_Predicate;
function Status_Flag_Or_Transient_Decl (Id : E) return N is
begin
pragma Assert (Ekind_In (Id, E_Constant,
E_Loop_Parameter,
E_Variable));
return Node15 (Id);
end Status_Flag_Or_Transient_Decl;
function Storage_Size_Variable (Id : E) return E is
begin
pragma Assert (Is_Access_Type (Id) or else Is_Task_Type (Id));
return Node26 (Implementation_Base_Type (Id));
end Storage_Size_Variable;
function Static_Elaboration_Desired (Id : E) return B is
begin
pragma Assert (Ekind (Id) = E_Package);
return Flag77 (Id);
end Static_Elaboration_Desired;
function Static_Initialization (Id : E) return N is
begin
pragma Assert
(Ekind (Id) = E_Procedure and then not Is_Dispatching_Operation (Id));
return Node30 (Id);
end Static_Initialization;
function Stored_Constraint (Id : E) return L is
begin
pragma Assert
(Is_Composite_Type (Id) and then not Is_Array_Type (Id));
return Elist23 (Id);
end Stored_Constraint;
function Stores_Attribute_Old_Prefix (Id : E) return B is
begin
return Flag270 (Id);
end Stores_Attribute_Old_Prefix;
function Strict_Alignment (Id : E) return B is
begin
return Flag145 (Implementation_Base_Type (Id));
end Strict_Alignment;
function String_Literal_Length (Id : E) return U is
begin
return Uint16 (Id);
end String_Literal_Length;
function String_Literal_Low_Bound (Id : E) return N is
begin
return Node18 (Id);
end String_Literal_Low_Bound;
function Subprograms_For_Type (Id : E) return L is
begin
pragma Assert (Is_Type (Id));
return Elist29 (Id);
end Subprograms_For_Type;
function Subps_Index (Id : E) return U is
begin
pragma Assert (Is_Subprogram (Id));
return Uint24 (Id);
end Subps_Index;
function Suppress_Elaboration_Warnings (Id : E) return B is
begin
return Flag303 (Id);
end Suppress_Elaboration_Warnings;
function Suppress_Initialization (Id : E) return B is
begin
pragma Assert (Is_Type (Id) or else Ekind (Id) = E_Variable);
return Flag105 (Id);
end Suppress_Initialization;
function Suppress_Style_Checks (Id : E) return B is
begin
return Flag165 (Id);
end Suppress_Style_Checks;
function Suppress_Value_Tracking_On_Call (Id : E) return B is
begin
return Flag217 (Id);
end Suppress_Value_Tracking_On_Call;
function Task_Body_Procedure (Id : E) return N is
begin
pragma Assert (Ekind (Id) in Task_Kind);
return Node25 (Id);
end Task_Body_Procedure;
function Thunk_Entity (Id : E) return E is
begin
pragma Assert (Ekind_In (Id, E_Function, E_Procedure)
and then Is_Thunk (Id));
return Node31 (Id);
end Thunk_Entity;
function Treat_As_Volatile (Id : E) return B is
begin
return Flag41 (Id);
end Treat_As_Volatile;
function Underlying_Full_View (Id : E) return E is
begin
pragma Assert (Ekind (Id) in Private_Kind);
return Node19 (Id);
end Underlying_Full_View;
function Underlying_Record_View (Id : E) return E is
begin
return Node28 (Id);
end Underlying_Record_View;
function Universal_Aliasing (Id : E) return B is
begin
pragma Assert (Is_Type (Id));
return Flag216 (Implementation_Base_Type (Id));
end Universal_Aliasing;
function Unset_Reference (Id : E) return N is
begin
return Node16 (Id);
end Unset_Reference;
function Used_As_Generic_Actual (Id : E) return B is
begin
return Flag222 (Id);
end Used_As_Generic_Actual;
function Uses_Lock_Free (Id : E) return B is
begin
pragma Assert (Is_Protected_Type (Id));
return Flag188 (Id);
end Uses_Lock_Free;
function Uses_Sec_Stack (Id : E) return B is
begin
return Flag95 (Id);
end Uses_Sec_Stack;
function Validated_Object (Id : E) return N is
begin
pragma Assert (Ekind (Id) = E_Variable);
return Node38 (Id);
end Validated_Object;
function Warnings_Off (Id : E) return B is
begin
return Flag96 (Id);
end Warnings_Off;
function Warnings_Off_Used (Id : E) return B is
begin
return Flag236 (Id);
end Warnings_Off_Used;
function Warnings_Off_Used_Unmodified (Id : E) return B is
begin
return Flag237 (Id);
end Warnings_Off_Used_Unmodified;
function Warnings_Off_Used_Unreferenced (Id : E) return B is
begin
return Flag238 (Id);
end Warnings_Off_Used_Unreferenced;
function Wrapped_Entity (Id : E) return E is
begin
pragma Assert (Ekind_In (Id, E_Function, E_Procedure)
and then Is_Primitive_Wrapper (Id));
return Node27 (Id);
end Wrapped_Entity;
function Was_Hidden (Id : E) return B is
begin
return Flag196 (Id);
end Was_Hidden;
------------------------------
-- Classification Functions --
------------------------------
function Is_Access_Type (Id : E) return B is
begin
return Ekind (Id) in Access_Kind;
end Is_Access_Type;
function Is_Access_Protected_Subprogram_Type (Id : E) return B is
begin
return Ekind (Id) in Access_Protected_Kind;
end Is_Access_Protected_Subprogram_Type;
function Is_Access_Subprogram_Type (Id : E) return B is
begin
return Ekind (Id) in Access_Subprogram_Kind;
end Is_Access_Subprogram_Type;
function Is_Aggregate_Type (Id : E) return B is
begin
return Ekind (Id) in Aggregate_Kind;
end Is_Aggregate_Type;
function Is_Anonymous_Access_Type (Id : E) return B is
begin
return Ekind (Id) in Anonymous_Access_Kind;
end Is_Anonymous_Access_Type;
function Is_Array_Type (Id : E) return B is
begin
return Ekind (Id) in Array_Kind;
end Is_Array_Type;
function Is_Assignable (Id : E) return B is
begin
return Ekind (Id) in Assignable_Kind;
end Is_Assignable;
function Is_Class_Wide_Type (Id : E) return B is
begin
return Ekind (Id) in Class_Wide_Kind;
end Is_Class_Wide_Type;
function Is_Composite_Type (Id : E) return B is
begin
return Ekind (Id) in Composite_Kind;
end Is_Composite_Type;
function Is_Concurrent_Body (Id : E) return B is
begin
return Ekind (Id) in Concurrent_Body_Kind;
end Is_Concurrent_Body;
function Is_Concurrent_Record_Type (Id : E) return B is
begin
return Flag20 (Id);
end Is_Concurrent_Record_Type;
function Is_Concurrent_Type (Id : E) return B is
begin
return Ekind (Id) in Concurrent_Kind;
end Is_Concurrent_Type;
function Is_Decimal_Fixed_Point_Type (Id : E) return B is
begin
return Ekind (Id) in Decimal_Fixed_Point_Kind;
end Is_Decimal_Fixed_Point_Type;
function Is_Digits_Type (Id : E) return B is
begin
return Ekind (Id) in Digits_Kind;
end Is_Digits_Type;
function Is_Discrete_Or_Fixed_Point_Type (Id : E) return B is
begin
return Ekind (Id) in Discrete_Or_Fixed_Point_Kind;
end Is_Discrete_Or_Fixed_Point_Type;
function Is_Discrete_Type (Id : E) return B is
begin
return Ekind (Id) in Discrete_Kind;
end Is_Discrete_Type;
function Is_Elementary_Type (Id : E) return B is
begin
return Ekind (Id) in Elementary_Kind;
end Is_Elementary_Type;
function Is_Entry (Id : E) return B is
begin
return Ekind (Id) in Entry_Kind;
end Is_Entry;
function Is_Enumeration_Type (Id : E) return B is
begin
return Ekind (Id) in Enumeration_Kind;
end Is_Enumeration_Type;
function Is_Fixed_Point_Type (Id : E) return B is
begin
return Ekind (Id) in Fixed_Point_Kind;
end Is_Fixed_Point_Type;
function Is_Floating_Point_Type (Id : E) return B is
begin
return Ekind (Id) in Float_Kind;
end Is_Floating_Point_Type;
function Is_Formal (Id : E) return B is
begin
return Ekind (Id) in Formal_Kind;
end Is_Formal;
function Is_Formal_Object (Id : E) return B is
begin
return Ekind (Id) in Formal_Object_Kind;
end Is_Formal_Object;
function Is_Generic_Subprogram (Id : E) return B is
begin
return Ekind (Id) in Generic_Subprogram_Kind;
end Is_Generic_Subprogram;
function Is_Generic_Unit (Id : E) return B is
begin
return Ekind (Id) in Generic_Unit_Kind;
end Is_Generic_Unit;
function Is_Ghost_Entity (Id : Entity_Id) return Boolean is
begin
return Is_Checked_Ghost_Entity (Id) or else Is_Ignored_Ghost_Entity (Id);
end Is_Ghost_Entity;
function Is_Incomplete_Or_Private_Type (Id : E) return B is
begin
return Ekind (Id) in Incomplete_Or_Private_Kind;
end Is_Incomplete_Or_Private_Type;
function Is_Incomplete_Type (Id : E) return B is
begin
return Ekind (Id) in Incomplete_Kind;
end Is_Incomplete_Type;
function Is_Integer_Type (Id : E) return B is
begin
return Ekind (Id) in Integer_Kind;
end Is_Integer_Type;
function Is_Modular_Integer_Type (Id : E) return B is
begin
return Ekind (Id) in Modular_Integer_Kind;
end Is_Modular_Integer_Type;
function Is_Named_Number (Id : E) return B is
begin
return Ekind (Id) in Named_Kind;
end Is_Named_Number;
function Is_Numeric_Type (Id : E) return B is
begin
return Ekind (Id) in Numeric_Kind;
end Is_Numeric_Type;
function Is_Object (Id : E) return B is
begin
return Ekind (Id) in Object_Kind;
end Is_Object;
function Is_Ordinary_Fixed_Point_Type (Id : E) return B is
begin
return Ekind (Id) in Ordinary_Fixed_Point_Kind;
end Is_Ordinary_Fixed_Point_Type;
function Is_Overloadable (Id : E) return B is
begin
return Ekind (Id) in Overloadable_Kind;
end Is_Overloadable;
function Is_Private_Type (Id : E) return B is
begin
return Ekind (Id) in Private_Kind;
end Is_Private_Type;
function Is_Protected_Type (Id : E) return B is
begin
return Ekind (Id) in Protected_Kind;
end Is_Protected_Type;
function Is_Real_Type (Id : E) return B is
begin
return Ekind (Id) in Real_Kind;
end Is_Real_Type;
function Is_Record_Type (Id : E) return B is
begin
return Ekind (Id) in Record_Kind;
end Is_Record_Type;
function Is_Scalar_Type (Id : E) return B is
begin
return Ekind (Id) in Scalar_Kind;
end Is_Scalar_Type;
function Is_Signed_Integer_Type (Id : E) return B is
begin
return Ekind (Id) in Signed_Integer_Kind;
end Is_Signed_Integer_Type;
function Is_Subprogram (Id : E) return B is
begin
return Ekind (Id) in Subprogram_Kind;
end Is_Subprogram;
function Is_Subprogram_Or_Entry (Id : E) return B is
begin
return Ekind (Id) in Subprogram_Kind
or else
Ekind (Id) in Entry_Kind;
end Is_Subprogram_Or_Entry;
function Is_Subprogram_Or_Generic_Subprogram (Id : E) return B is
begin
return Ekind (Id) in Subprogram_Kind
or else
Ekind (Id) in Generic_Subprogram_Kind;
end Is_Subprogram_Or_Generic_Subprogram;
function Is_Task_Type (Id : E) return B is
begin
return Ekind (Id) in Task_Kind;
end Is_Task_Type;
function Is_Type (Id : E) return B is
begin
return Ekind (Id) in Type_Kind;
end Is_Type;
------------------------------
-- Attribute Set Procedures --
------------------------------
-- Note: in many of these set procedures an "obvious" assertion is missing.
-- The reason for this is that in many cases, a field is set before the
-- Ekind field is set, so that the field is set when Ekind = E_Void. It
-- it is possible to add assertions that specifically include the E_Void
-- possibility, but in some cases, we just omit the assertions.
procedure Set_Abstract_States (Id : E; V : L) is
begin
pragma Assert (Ekind_In (Id, E_Generic_Package, E_Package));
Set_Elist25 (Id, V);
end Set_Abstract_States;
procedure Set_Accept_Address (Id : E; V : L) is
begin
Set_Elist21 (Id, V);
end Set_Accept_Address;
procedure Set_Access_Disp_Table (Id : E; V : L) is
begin
pragma Assert (Ekind (Id) = E_Record_Type
and then Id = Implementation_Base_Type (Id));
pragma Assert (V = No_Elist or else Is_Tagged_Type (Id));
Set_Elist16 (Id, V);
end Set_Access_Disp_Table;
procedure Set_Access_Disp_Table_Elab_Flag (Id : E; V : E) is
begin
pragma Assert (Ekind (Id) = E_Record_Type
and then Id = Implementation_Base_Type (Id));
pragma Assert (Is_Tagged_Type (Id));
Set_Node30 (Id, V);
end Set_Access_Disp_Table_Elab_Flag;
procedure Set_Anonymous_Designated_Type (Id : E; V : E) is
begin
pragma Assert (Ekind (Id) = E_Variable);
Set_Node35 (Id, V);
end Set_Anonymous_Designated_Type;
procedure Set_Anonymous_Masters (Id : E; V : L) is
begin
pragma Assert (Ekind_In (Id, E_Function,
E_Package,
E_Procedure,
E_Subprogram_Body));
Set_Elist29 (Id, V);
end Set_Anonymous_Masters;
procedure Set_Anonymous_Object (Id : E; V : E) is
begin
pragma Assert (Ekind_In (Id, E_Protected_Type, E_Task_Type));
Set_Node30 (Id, V);
end Set_Anonymous_Object;
procedure Set_Associated_Entity (Id : E; V : E) is
begin
Set_Node37 (Id, V);
end Set_Associated_Entity;
procedure Set_Associated_Formal_Package (Id : E; V : E) is
begin
Set_Node12 (Id, V);
end Set_Associated_Formal_Package;
procedure Set_Associated_Node_For_Itype (Id : E; V : E) is
begin
Set_Node8 (Id, V);
end Set_Associated_Node_For_Itype;
procedure Set_Associated_Storage_Pool (Id : E; V : E) is
begin
pragma Assert (Is_Access_Type (Id) and then Is_Base_Type (Id));
Set_Node22 (Id, V);
end Set_Associated_Storage_Pool;
procedure Set_Activation_Record_Component (Id : E; V : E) is
begin
pragma Assert (Ekind_In (Id, E_Constant,
E_In_Parameter,
E_In_Out_Parameter,
E_Loop_Parameter,
E_Out_Parameter,
E_Variable));
Set_Node31 (Id, V);
end Set_Activation_Record_Component;
procedure Set_Actual_Subtype (Id : E; V : E) is
begin
pragma Assert
(Ekind_In (Id, E_Constant, E_Variable, E_Generic_In_Out_Parameter)
or else Is_Formal (Id));
Set_Node17 (Id, V);
end Set_Actual_Subtype;
procedure Set_Address_Taken (Id : E; V : B := True) is
begin
Set_Flag104 (Id, V);
end Set_Address_Taken;
procedure Set_Alias (Id : E; V : E) is
begin
pragma Assert
(Is_Overloadable (Id) or else Ekind (Id) = E_Subprogram_Type);
Set_Node18 (Id, V);
end Set_Alias;
procedure Set_Alignment (Id : E; V : U) is
begin
pragma Assert (Is_Type (Id)
or else Is_Formal (Id)
or else Ekind_In (Id, E_Loop_Parameter,
E_Constant,
E_Exception,
E_Variable));
Set_Uint14 (Id, V);
end Set_Alignment;
procedure Set_Barrier_Function (Id : E; V : N) is
begin
pragma Assert (Is_Entry (Id));
Set_Node12 (Id, V);
end Set_Barrier_Function;
procedure Set_Block_Node (Id : E; V : N) is
begin
pragma Assert (Ekind (Id) = E_Block);
Set_Node11 (Id, V);
end Set_Block_Node;
procedure Set_Body_Entity (Id : E; V : E) is
begin
pragma Assert (Ekind_In (Id, E_Package, E_Generic_Package));
Set_Node19 (Id, V);
end Set_Body_Entity;
procedure Set_Body_Needed_For_Inlining (Id : E; V : B := True) is
begin
pragma Assert (Ekind (Id) = E_Package);
Set_Flag299 (Id, V);
end Set_Body_Needed_For_Inlining;
procedure Set_Body_Needed_For_SAL (Id : E; V : B := True) is
begin
pragma Assert
(Ekind (Id) = E_Package
or else Is_Subprogram (Id)
or else Is_Generic_Unit (Id));
Set_Flag40 (Id, V);
end Set_Body_Needed_For_SAL;
procedure Set_Body_References (Id : E; V : L) is
begin
pragma Assert (Ekind (Id) = E_Abstract_State);
Set_Elist16 (Id, V);
end Set_Body_References;
procedure Set_BIP_Initialization_Call (Id : E; V : N) is
begin
pragma Assert (Ekind_In (Id, E_Constant, E_Variable));
Set_Node29 (Id, V);
end Set_BIP_Initialization_Call;
procedure Set_C_Pass_By_Copy (Id : E; V : B := True) is
begin
pragma Assert (Is_Record_Type (Id) and then Is_Base_Type (Id));
Set_Flag125 (Id, V);
end Set_C_Pass_By_Copy;
procedure Set_Can_Never_Be_Null (Id : E; V : B := True) is
begin
Set_Flag38 (Id, V);
end Set_Can_Never_Be_Null;
procedure Set_Can_Use_Internal_Rep (Id : E; V : B := True) is
begin
pragma Assert
(Is_Access_Subprogram_Type (Id) and then Is_Base_Type (Id));
Set_Flag229 (Id, V);
end Set_Can_Use_Internal_Rep;
procedure Set_Checks_May_Be_Suppressed (Id : E; V : B := True) is
begin
Set_Flag31 (Id, V);
end Set_Checks_May_Be_Suppressed;
procedure Set_Class_Wide_Clone (Id : E; V : E) is
begin
pragma Assert (Is_Subprogram (Id));
Set_Node38 (Id, V);
end Set_Class_Wide_Clone;
procedure Set_Class_Wide_Type (Id : E; V : E) is
begin
pragma Assert (Is_Type (Id));
Set_Node9 (Id, V);
end Set_Class_Wide_Type;
procedure Set_Cloned_Subtype (Id : E; V : E) is
begin
pragma Assert (Ekind_In (Id, E_Record_Subtype, E_Class_Wide_Subtype));
Set_Node16 (Id, V);
end Set_Cloned_Subtype;
procedure Set_Component_Bit_Offset (Id : E; V : U) is
begin
pragma Assert (Ekind_In (Id, E_Component, E_Discriminant));
Set_Uint11 (Id, V);
end Set_Component_Bit_Offset;
procedure Set_Component_Clause (Id : E; V : N) is
begin
pragma Assert (Ekind_In (Id, E_Component, E_Discriminant));
Set_Node13 (Id, V);
end Set_Component_Clause;
procedure Set_Component_Size (Id : E; V : U) is
begin
pragma Assert (Is_Array_Type (Id) and then Is_Base_Type (Id));
Set_Uint22 (Id, V);
end Set_Component_Size;
procedure Set_Component_Type (Id : E; V : E) is
begin
pragma Assert (Is_Array_Type (Id) and then Is_Base_Type (Id));
Set_Node20 (Id, V);
end Set_Component_Type;
procedure Set_Contains_Ignored_Ghost_Code (Id : E; V : B := True) is
begin
pragma Assert
(Ekind_In (Id, E_Block,
E_Function,
E_Generic_Function,
E_Generic_Package,
E_Generic_Procedure,
E_Package,
E_Package_Body,
E_Procedure,
E_Subprogram_Body));
Set_Flag279 (Id, V);
end Set_Contains_Ignored_Ghost_Code;
procedure Set_Contract (Id : E; V : N) is
begin
pragma Assert
(Ekind_In (Id, E_Protected_Type, -- concurrent types
E_Task_Body,
E_Task_Type)
or else
Ekind_In (Id, E_Constant, -- objects
E_Variable)
or else
Ekind_In (Id, E_Entry, -- overloadable
E_Entry_Family,
E_Function,
E_Generic_Function,
E_Generic_Procedure,
E_Operator,
E_Procedure,
E_Subprogram_Body)
or else
Ekind_In (Id, E_Generic_Package, -- packages
E_Package,
E_Package_Body)
or else
Ekind (Id) = E_Void); -- special purpose
Set_Node34 (Id, V);
end Set_Contract;
procedure Set_Contract_Wrapper (Id : E; V : E) is
begin
pragma Assert (Ekind_In (Id, E_Entry, E_Entry_Family));
Set_Node25 (Id, V);
end Set_Contract_Wrapper;
procedure Set_Corresponding_Concurrent_Type (Id : E; V : E) is
begin
pragma Assert
(Ekind (Id) = E_Record_Type and then Is_Concurrent_Type (V));
Set_Node18 (Id, V);
end Set_Corresponding_Concurrent_Type;
procedure Set_Corresponding_Discriminant (Id : E; V : E) is
begin
pragma Assert (Ekind (Id) = E_Discriminant);
Set_Node19 (Id, V);
end Set_Corresponding_Discriminant;
procedure Set_Corresponding_Equality (Id : E; V : E) is
begin
pragma Assert
(Ekind (Id) = E_Function
and then not Comes_From_Source (Id)
and then Chars (Id) = Name_Op_Ne);
Set_Node30 (Id, V);
end Set_Corresponding_Equality;
procedure Set_Corresponding_Function (Id : E; V : E) is
begin
pragma Assert (Ekind (Id) = E_Procedure and then Rewritten_For_C (V));
Set_Node32 (Id, V);
end Set_Corresponding_Function;
procedure Set_Corresponding_Procedure (Id : E; V : E) is
begin
pragma Assert (Ekind (Id) = E_Function and then Rewritten_For_C (Id));
Set_Node32 (Id, V);
end Set_Corresponding_Procedure;
procedure Set_Corresponding_Protected_Entry (Id : E; V : E) is
begin
pragma Assert (Ekind_In (Id, E_Void, E_Subprogram_Body));
Set_Node18 (Id, V);
end Set_Corresponding_Protected_Entry;
procedure Set_Corresponding_Record_Component (Id : E; V : E) is
begin
pragma Assert (Ekind_In (Id, E_Component, E_Discriminant));
Set_Node21 (Id, V);
end Set_Corresponding_Record_Component;
procedure Set_Corresponding_Record_Type (Id : E; V : E) is
begin
pragma Assert (Is_Concurrent_Type (Id));
Set_Node18 (Id, V);
end Set_Corresponding_Record_Type;
procedure Set_Corresponding_Remote_Type (Id : E; V : E) is
begin
Set_Node22 (Id, V);
end Set_Corresponding_Remote_Type;
procedure Set_Current_Use_Clause (Id : E; V : E) is
begin
pragma Assert (Ekind (Id) = E_Package or else Is_Type (Id));
Set_Node27 (Id, V);
end Set_Current_Use_Clause;
procedure Set_Current_Value (Id : E; V : N) is
begin
pragma Assert (Ekind (Id) in Object_Kind or else Ekind (Id) = E_Void);
Set_Node9 (Id, V);
end Set_Current_Value;
procedure Set_CR_Discriminant (Id : E; V : E) is
begin
Set_Node23 (Id, V);
end Set_CR_Discriminant;
procedure Set_Debug_Info_Off (Id : E; V : B := True) is
begin
Set_Flag166 (Id, V);
end Set_Debug_Info_Off;
procedure Set_Debug_Renaming_Link (Id : E; V : E) is
begin
Set_Node25 (Id, V);
end Set_Debug_Renaming_Link;
procedure Set_Default_Aspect_Component_Value (Id : E; V : E) is
begin
pragma Assert (Is_Array_Type (Id) and then Is_Base_Type (Id));
Set_Node19 (Id, V);
end Set_Default_Aspect_Component_Value;
procedure Set_Default_Aspect_Value (Id : E; V : E) is
begin
pragma Assert (Is_Scalar_Type (Id) and then Is_Base_Type (Id));
Set_Node19 (Id, V);
end Set_Default_Aspect_Value;
procedure Set_Default_Expr_Function (Id : E; V : E) is
begin
pragma Assert (Is_Formal (Id));
Set_Node21 (Id, V);
end Set_Default_Expr_Function;
procedure Set_Default_Expressions_Processed (Id : E; V : B := True) is
begin
Set_Flag108 (Id, V);
end Set_Default_Expressions_Processed;
procedure Set_Default_Value (Id : E; V : N) is
begin
pragma Assert (Is_Formal (Id));
Set_Node20 (Id, V);
end Set_Default_Value;
procedure Set_Delay_Cleanups (Id : E; V : B := True) is
begin
pragma Assert
(Is_Subprogram (Id)
or else Is_Task_Type (Id)
or else Ekind (Id) = E_Block);
Set_Flag114 (Id, V);
end Set_Delay_Cleanups;
procedure Set_Delay_Subprogram_Descriptors (Id : E; V : B := True) is
begin
pragma Assert
(Is_Subprogram (Id) or else Ekind_In (Id, E_Package, E_Package_Body));
Set_Flag50 (Id, V);
end Set_Delay_Subprogram_Descriptors;
procedure Set_Delta_Value (Id : E; V : R) is
begin
pragma Assert (Is_Fixed_Point_Type (Id));
Set_Ureal18 (Id, V);
end Set_Delta_Value;
procedure Set_Dependent_Instances (Id : E; V : L) is
begin
pragma Assert (Is_Generic_Instance (Id));
Set_Elist8 (Id, V);
end Set_Dependent_Instances;
procedure Set_Depends_On_Private (Id : E; V : B := True) is
begin
pragma Assert (Nkind (Id) in N_Entity);
Set_Flag14 (Id, V);
end Set_Depends_On_Private;
procedure Set_Derived_Type_Link (Id : E; V : E) is
begin
pragma Assert (Is_Type (Id) and then Is_Base_Type (Id));
Set_Node31 (Id, V);
end Set_Derived_Type_Link;
procedure Set_Digits_Value (Id : E; V : U) is
begin
pragma Assert
(Is_Floating_Point_Type (Id)
or else Is_Decimal_Fixed_Point_Type (Id));
Set_Uint17 (Id, V);
end Set_Digits_Value;
procedure Set_Directly_Designated_Type (Id : E; V : E) is
begin
Set_Node20 (Id, V);
end Set_Directly_Designated_Type;
procedure Set_Disable_Controlled (Id : E; V : B := True) is
begin
pragma Assert (Is_Type (Id) and then Is_Base_Type (Id));
Set_Flag253 (Id, V);
end Set_Disable_Controlled;
procedure Set_Discard_Names (Id : E; V : B := True) is
begin
Set_Flag88 (Id, V);
end Set_Discard_Names;
procedure Set_Discriminal (Id : E; V : E) is
begin
pragma Assert (Ekind (Id) = E_Discriminant);
Set_Node17 (Id, V);
end Set_Discriminal;
procedure Set_Discriminal_Link (Id : E; V : E) is
begin
Set_Node10 (Id, V);
end Set_Discriminal_Link;
procedure Set_Discriminant_Checking_Func (Id : E; V : E) is
begin
pragma Assert (Ekind (Id) = E_Component);
Set_Node20 (Id, V);
end Set_Discriminant_Checking_Func;
procedure Set_Discriminant_Constraint (Id : E; V : L) is
begin
pragma Assert (Nkind (Id) in N_Entity);
Set_Elist21 (Id, V);
end Set_Discriminant_Constraint;
procedure Set_Discriminant_Default_Value (Id : E; V : N) is
begin
Set_Node20 (Id, V);
end Set_Discriminant_Default_Value;
procedure Set_Discriminant_Number (Id : E; V : U) is
begin
Set_Uint15 (Id, V);
end Set_Discriminant_Number;
procedure Set_Dispatch_Table_Wrappers (Id : E; V : L) is
begin
pragma Assert (Ekind (Id) = E_Record_Type
and then Id = Implementation_Base_Type (Id));
pragma Assert (V = No_Elist or else Is_Tagged_Type (Id));
Set_Elist26 (Id, V);
end Set_Dispatch_Table_Wrappers;
procedure Set_DT_Entry_Count (Id : E; V : U) is
begin
pragma Assert (Ekind (Id) = E_Component);
Set_Uint15 (Id, V);
end Set_DT_Entry_Count;
procedure Set_DT_Offset_To_Top_Func (Id : E; V : E) is
begin
pragma Assert (Ekind (Id) = E_Component and then Is_Tag (Id));
Set_Node25 (Id, V);
end Set_DT_Offset_To_Top_Func;
procedure Set_DT_Position (Id : E; V : U) is
begin
pragma Assert (Ekind_In (Id, E_Function, E_Procedure));
Set_Uint15 (Id, V);