mirror of
https://github.com/autc04/Retro68.git
synced 2024-06-25 21:29:51 +00:00
673 lines
32 KiB
Ada
673 lines
32 KiB
Ada
------------------------------------------------------------------------------
|
|
-- --
|
|
-- GNAT COMPILER COMPONENTS --
|
|
-- --
|
|
-- E I N F O . U T I L S --
|
|
-- --
|
|
-- S p e c --
|
|
-- --
|
|
-- Copyright (C) 2020-2022, 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. See the GNU General Public License --
|
|
-- for more details. You should have received a copy of the GNU General --
|
|
-- Public License distributed with GNAT; see file COPYING3. If not, go to --
|
|
-- http://www.gnu.org/licenses for a complete copy of the license. --
|
|
-- --
|
|
-- GNAT was originally developed by the GNAT team at New York University. --
|
|
-- Extensive contributions were provided by Ada Core Technologies Inc. --
|
|
-- --
|
|
------------------------------------------------------------------------------
|
|
|
|
with Einfo.Entities; use Einfo.Entities;
|
|
|
|
package Einfo.Utils is
|
|
|
|
-------------------------------------------
|
|
-- Aliases/Renamings of Renamed_Or_Alias --
|
|
-------------------------------------------
|
|
|
|
-- See the comment in einfo.ads, "Renaming and Aliasing", which is somewhat
|
|
-- incorrect. Each of the following calls [Set_]Renamed_Or_Alias. Alias and
|
|
-- Renamed_Entity are fields of nonobject Entity_Ids, and the value of the
|
|
-- field is Entity_Id. Alias is only for callable entities and subprogram
|
|
-- types. We sometimes call Set_Renamed_Entity and then expect Alias to
|
|
-- return the value set. Renamed_Object is a field of Entity_Ids that are
|
|
-- objects, and it returns an expression, because you can rename things
|
|
-- like "X.all(J).Y". Renamings of entries and subprograms can also be
|
|
-- expressions, but those use different mechanisms; the fields here are not
|
|
-- used.
|
|
|
|
function Alias (N : Entity_Id) return Entity_Id;
|
|
procedure Set_Alias (N : Entity_Id; Val : Entity_Id);
|
|
function Renamed_Entity (N : Entity_Id) return Entity_Id;
|
|
procedure Set_Renamed_Entity (N : Entity_Id; Val : Entity_Id);
|
|
function Renamed_Object (N : Entity_Id) return Node_Id;
|
|
procedure Set_Renamed_Object (N : Entity_Id; Val : Node_Id);
|
|
|
|
function Renamed_Entity_Or_Object (N : Entity_Id) return Node_Id;
|
|
-- This getter is used when we don't know statically whether we want to
|
|
-- call Renamed_Entity or Renamed_Object.
|
|
|
|
procedure Set_Renamed_Object_Of_Possibly_Void
|
|
(N : Entity_Id; Val : Node_Id);
|
|
-- Set_Renamed_Object doesn't allow Void; this is used in the rare cases
|
|
-- where we set the field of an entity that might be Void. It might be a
|
|
-- good idea to get rid of calls to this.
|
|
|
|
pragma Inline (Alias);
|
|
pragma Inline (Set_Alias);
|
|
pragma Inline (Renamed_Entity);
|
|
pragma Inline (Set_Renamed_Entity);
|
|
pragma Inline (Renamed_Object);
|
|
pragma Inline (Set_Renamed_Object);
|
|
pragma Inline (Renamed_Entity_Or_Object);
|
|
pragma Inline (Set_Renamed_Object_Of_Possibly_Void);
|
|
|
|
-------------------
|
|
-- Type Synonyms --
|
|
-------------------
|
|
|
|
-- The following type synonyms are used to tidy up the function and
|
|
-- procedure declarations that follow.
|
|
|
|
subtype B is Boolean;
|
|
subtype C is Component_Alignment_Kind;
|
|
subtype E is Entity_Id;
|
|
subtype F is Float_Rep_Kind;
|
|
subtype M is Mechanism_Type;
|
|
subtype N is Node_Id;
|
|
subtype U is Uint;
|
|
subtype R is Ureal;
|
|
subtype L is Elist_Id;
|
|
subtype S is List_Id;
|
|
|
|
-------------------------------
|
|
-- Classification Attributes --
|
|
-------------------------------
|
|
|
|
-- These functions provide a convenient functional notation for testing
|
|
-- whether an Ekind value belongs to a specified kind, for example the
|
|
-- function Is_Elementary_Type tests if its argument is in Elementary_Kind.
|
|
-- In some cases, the test is of an entity attribute (e.g. in the case of
|
|
-- Is_Generic_Type where the Ekind does not provide the needed
|
|
-- information).
|
|
|
|
function Is_Access_Object_Type (Id : E) return B;
|
|
function Is_Access_Type (Id : E) return B;
|
|
function Is_Access_Protected_Subprogram_Type (Id : E) return B;
|
|
function Is_Access_Subprogram_Type (Id : E) return B;
|
|
function Is_Aggregate_Type (Id : E) return B;
|
|
function Is_Anonymous_Access_Type (Id : E) return B;
|
|
function Is_Array_Type (Id : E) return B;
|
|
function Is_Assignable (Id : E) return B;
|
|
function Is_Class_Wide_Type (Id : E) return B;
|
|
function Is_Composite_Type (Id : E) return B;
|
|
function Is_Concurrent_Body (Id : E) return B;
|
|
function Is_Concurrent_Type (Id : E) return B;
|
|
function Is_Decimal_Fixed_Point_Type (Id : E) return B;
|
|
function Is_Digits_Type (Id : E) return B;
|
|
function Is_Discrete_Or_Fixed_Point_Type (Id : E) return B;
|
|
function Is_Discrete_Type (Id : E) return B;
|
|
function Is_Elementary_Type (Id : E) return B;
|
|
function Is_Entry (Id : E) return B;
|
|
function Is_Enumeration_Type (Id : E) return B;
|
|
function Is_Fixed_Point_Type (Id : E) return B;
|
|
function Is_Floating_Point_Type (Id : E) return B;
|
|
function Is_Formal (Id : E) return B;
|
|
function Is_Formal_Object (Id : E) return B;
|
|
function Is_Generic_Subprogram (Id : E) return B;
|
|
function Is_Generic_Unit (Id : E) return B;
|
|
function Is_Ghost_Entity (Id : E) return B;
|
|
function Is_Incomplete_Or_Private_Type (Id : E) return B;
|
|
function Is_Incomplete_Type (Id : E) return B;
|
|
function Is_Integer_Type (Id : E) return B;
|
|
function Is_Modular_Integer_Type (Id : E) return B;
|
|
function Is_Named_Access_Type (Id : E) return B;
|
|
function Is_Named_Number (Id : E) return B;
|
|
function Is_Numeric_Type (Id : E) return B;
|
|
function Is_Object (Id : E) return B;
|
|
function Is_Ordinary_Fixed_Point_Type (Id : E) return B;
|
|
function Is_Overloadable (Id : E) return B;
|
|
function Is_Private_Type (Id : E) return B;
|
|
function Is_Protected_Type (Id : E) return B;
|
|
function Is_Real_Type (Id : E) return B;
|
|
function Is_Record_Type (Id : E) return B;
|
|
function Is_Scalar_Type (Id : E) return B;
|
|
function Is_Signed_Integer_Type (Id : E) return B;
|
|
function Is_Subprogram (Id : E) return B;
|
|
function Is_Subprogram_Or_Entry (Id : E) return B;
|
|
function Is_Subprogram_Or_Generic_Subprogram (Id : E) return B;
|
|
function Is_Task_Type (Id : E) return B;
|
|
function Is_Type (Id : E) return B;
|
|
|
|
pragma Inline (Is_Access_Object_Type);
|
|
pragma Inline (Is_Access_Type);
|
|
pragma Inline (Is_Access_Protected_Subprogram_Type);
|
|
pragma Inline (Is_Access_Subprogram_Type);
|
|
pragma Inline (Is_Aggregate_Type);
|
|
pragma Inline (Is_Anonymous_Access_Type);
|
|
pragma Inline (Is_Array_Type);
|
|
pragma Inline (Is_Assignable);
|
|
pragma Inline (Is_Class_Wide_Type);
|
|
pragma Inline (Is_Composite_Type);
|
|
pragma Inline (Is_Concurrent_Body);
|
|
pragma Inline (Is_Concurrent_Type);
|
|
pragma Inline (Is_Decimal_Fixed_Point_Type);
|
|
pragma Inline (Is_Digits_Type);
|
|
pragma Inline (Is_Discrete_Type);
|
|
pragma Inline (Is_Elementary_Type);
|
|
pragma Inline (Is_Entry);
|
|
pragma Inline (Is_Enumeration_Type);
|
|
pragma Inline (Is_Fixed_Point_Type);
|
|
pragma Inline (Is_Floating_Point_Type);
|
|
pragma Inline (Is_Formal);
|
|
pragma Inline (Is_Formal_Object);
|
|
pragma Inline (Is_Generic_Subprogram);
|
|
pragma Inline (Is_Generic_Unit);
|
|
pragma Inline (Is_Ghost_Entity);
|
|
pragma Inline (Is_Incomplete_Or_Private_Type);
|
|
pragma Inline (Is_Incomplete_Type);
|
|
pragma Inline (Is_Integer_Type);
|
|
pragma Inline (Is_Modular_Integer_Type);
|
|
pragma Inline (Is_Named_Access_Type);
|
|
pragma Inline (Is_Named_Number);
|
|
pragma Inline (Is_Numeric_Type);
|
|
pragma Inline (Is_Object);
|
|
pragma Inline (Is_Ordinary_Fixed_Point_Type);
|
|
pragma Inline (Is_Overloadable);
|
|
pragma Inline (Is_Private_Type);
|
|
pragma Inline (Is_Protected_Type);
|
|
pragma Inline (Is_Real_Type);
|
|
pragma Inline (Is_Record_Type);
|
|
pragma Inline (Is_Scalar_Type);
|
|
pragma Inline (Is_Signed_Integer_Type);
|
|
pragma Inline (Is_Subprogram);
|
|
pragma Inline (Is_Subprogram_Or_Entry);
|
|
pragma Inline (Is_Subprogram_Or_Generic_Subprogram);
|
|
pragma Inline (Is_Task_Type);
|
|
pragma Inline (Is_Type);
|
|
|
|
-------------------------------------
|
|
-- Synthesized Attribute Functions --
|
|
-------------------------------------
|
|
|
|
-- The functions in this section synthesize attributes from the tree,
|
|
-- so they do not correspond to defined fields in the entity itself.
|
|
|
|
function Address_Clause (Id : E) return N;
|
|
function Aft_Value (Id : E) return U;
|
|
function Alignment_Clause (Id : E) return N;
|
|
function Base_Type (Id : E) return E;
|
|
function Declaration_Node (Id : E) return N;
|
|
function Designated_Type (Id : E) return E;
|
|
function Entry_Index_Type (Id : E) return E;
|
|
function First_Component (Id : E) return E;
|
|
function First_Component_Or_Discriminant (Id : E) return E;
|
|
function First_Formal (Id : E) return E;
|
|
function First_Formal_With_Extras (Id : E) return E;
|
|
|
|
function Float_Rep
|
|
(N : Entity_Id) return F with Inline, Pre =>
|
|
N in E_Void_Id
|
|
| Float_Kind_Id;
|
|
procedure Set_Float_Rep
|
|
(Ignore_N : Entity_Id; Ignore_Val : F) with Inline, Pre =>
|
|
Ignore_N in E_Void_Id
|
|
| Float_Kind_Id;
|
|
|
|
function Has_Attach_Handler (Id : E) return B;
|
|
function Has_DIC (Id : E) return B;
|
|
function Has_Entries (Id : E) return B;
|
|
function Has_Foreign_Convention (Id : E) return B;
|
|
function Has_Interrupt_Handler (Id : E) return B;
|
|
function Has_Invariants (Id : E) return B;
|
|
function Has_Limited_View (Id : E) return B;
|
|
function Has_Non_Limited_View (Id : E) return B;
|
|
function Has_Non_Null_Abstract_State (Id : E) return B;
|
|
function Has_Non_Null_Visible_Refinement (Id : E) return B;
|
|
function Has_Null_Abstract_State (Id : E) return B;
|
|
function Has_Null_Visible_Refinement (Id : E) return B;
|
|
function Implementation_Base_Type (Id : E) return E;
|
|
function Is_Base_Type (Id : E) return B;
|
|
-- Note that Is_Base_Type returns True for nontypes
|
|
function Is_Boolean_Type (Id : E) return B;
|
|
function Is_Constant_Object (Id : E) return B;
|
|
function Is_Controlled (Id : E) return B;
|
|
function Is_Discriminal (Id : E) return B;
|
|
function Is_Dynamic_Scope (Id : E) return B;
|
|
function Is_Elaboration_Target (Id : E) return B;
|
|
function Is_External_State (Id : E) return B;
|
|
function Is_Finalizer (Id : E) return B;
|
|
function Is_Full_Access (Id : E) return B;
|
|
function Is_Null_State (Id : E) return B;
|
|
function Is_Package_Or_Generic_Package (Id : E) return B;
|
|
function Is_Packed_Array (Id : E) return B;
|
|
function Is_Prival (Id : E) return B;
|
|
function Is_Protected_Component (Id : E) return B;
|
|
function Is_Protected_Interface (Id : E) return B;
|
|
function Is_Protected_Record_Type (Id : E) return B;
|
|
function Is_Relaxed_Initialization_State (Id : E) return B;
|
|
function Is_Standard_Character_Type (Id : E) return B;
|
|
function Is_Standard_String_Type (Id : E) return B;
|
|
function Is_String_Type (Id : E) return B;
|
|
function Is_Synchronized_Interface (Id : E) return B;
|
|
function Is_Synchronized_State (Id : E) return B;
|
|
function Is_Task_Interface (Id : E) return B;
|
|
function Is_Task_Record_Type (Id : E) return B;
|
|
function Is_Wrapper_Package (Id : E) return B;
|
|
function Last_Formal (Id : E) return E;
|
|
function Machine_Emax_Value (Id : E) return U;
|
|
function Machine_Emin_Value (Id : E) return U;
|
|
function Machine_Mantissa_Value (Id : E) return U;
|
|
function Machine_Radix_Value (Id : E) return U;
|
|
function Model_Emin_Value (Id : E) return U;
|
|
function Model_Epsilon_Value (Id : E) return R;
|
|
function Model_Mantissa_Value (Id : E) return U;
|
|
function Model_Small_Value (Id : E) return R;
|
|
function Next_Component (Id : E) return E;
|
|
function Next_Component_Or_Discriminant (Id : E) return E;
|
|
function Next_Discriminant (Id : E) return E;
|
|
function Next_Formal (Id : E) return E;
|
|
function Next_Formal_With_Extras (Id : E) return E;
|
|
function Next_Index (Id : N) return N;
|
|
function Next_Literal (Id : E) return E;
|
|
function Next_Stored_Discriminant (Id : E) return E;
|
|
function Number_Dimensions (Id : E) return Pos;
|
|
function Number_Entries (Id : E) return Nat;
|
|
function Number_Formals (Id : E) return Pos;
|
|
function Object_Size_Clause (Id : E) return N;
|
|
function Parameter_Mode (Id : E) return Formal_Kind;
|
|
function Partial_Refinement_Constituents (Id : E) return L;
|
|
function Primitive_Operations (Id : E) return L;
|
|
function Root_Type (Id : E) return E;
|
|
function Safe_Emax_Value (Id : E) return U;
|
|
function Safe_First_Value (Id : E) return R;
|
|
function Safe_Last_Value (Id : E) return R;
|
|
function Size_Clause (Id : E) return N;
|
|
function Stream_Size_Clause (Id : E) return N;
|
|
function Type_High_Bound (Id : E) return N;
|
|
function Type_Low_Bound (Id : E) return N;
|
|
function Underlying_Type (Id : E) return E;
|
|
|
|
function Scope_Depth (Id : E) return U;
|
|
function Scope_Depth_Set (Id : E) return B;
|
|
|
|
function Scope_Depth_Default_0 (Id : E) return U;
|
|
-- In rare cases, the Scope_Depth_Value (queried by Scope_Depth) is
|
|
-- not correctly set before querying it; this may be used instead of
|
|
-- Scope_Depth in such cases. It returns Uint_0 if the Scope_Depth_Value
|
|
-- has not been set. See documentation in Einfo.
|
|
|
|
pragma Inline (Address_Clause);
|
|
pragma Inline (Alignment_Clause);
|
|
pragma Inline (Base_Type);
|
|
pragma Inline (Has_Foreign_Convention);
|
|
pragma Inline (Has_Non_Limited_View);
|
|
pragma Inline (Is_Base_Type);
|
|
pragma Inline (Is_Boolean_Type);
|
|
pragma Inline (Is_Constant_Object);
|
|
pragma Inline (Is_Controlled);
|
|
pragma Inline (Is_Discriminal);
|
|
pragma Inline (Is_Finalizer);
|
|
pragma Inline (Is_Full_Access);
|
|
pragma Inline (Is_Null_State);
|
|
pragma Inline (Is_Package_Or_Generic_Package);
|
|
pragma Inline (Is_Packed_Array);
|
|
pragma Inline (Is_Prival);
|
|
pragma Inline (Is_Protected_Component);
|
|
pragma Inline (Is_Protected_Record_Type);
|
|
pragma Inline (Is_String_Type);
|
|
pragma Inline (Is_Task_Record_Type);
|
|
pragma Inline (Is_Wrapper_Package);
|
|
pragma Inline (Scope_Depth);
|
|
pragma Inline (Scope_Depth_Set);
|
|
pragma Inline (Size_Clause);
|
|
pragma Inline (Stream_Size_Clause);
|
|
pragma Inline (Type_High_Bound);
|
|
pragma Inline (Type_Low_Bound);
|
|
|
|
------------------------------------------
|
|
-- Type Representation Attribute Fields --
|
|
------------------------------------------
|
|
|
|
function Known_Alignment (E : Entity_Id) return B with Inline;
|
|
procedure Reinit_Alignment (Id : E) with Inline;
|
|
procedure Copy_Alignment (To, From : E);
|
|
|
|
function Known_Component_Bit_Offset (E : Entity_Id) return B with Inline;
|
|
function Known_Static_Component_Bit_Offset (E : Entity_Id) return B
|
|
with Inline;
|
|
|
|
function Known_Component_Size (E : Entity_Id) return B with Inline;
|
|
function Known_Static_Component_Size (E : Entity_Id) return B with Inline;
|
|
|
|
function Known_Esize (E : Entity_Id) return B with Inline;
|
|
function Known_Static_Esize (E : Entity_Id) return B with Inline;
|
|
procedure Reinit_Esize (Id : E) with Inline;
|
|
procedure Copy_Esize (To, From : E);
|
|
|
|
function Known_Normalized_First_Bit (E : Entity_Id) return B with Inline;
|
|
function Known_Static_Normalized_First_Bit (E : Entity_Id) return B
|
|
with Inline;
|
|
|
|
function Known_Normalized_Position (E : Entity_Id) return B with Inline;
|
|
function Known_Static_Normalized_Position (E : Entity_Id) return B
|
|
with Inline;
|
|
|
|
function Known_RM_Size (E : Entity_Id) return B with Inline;
|
|
function Known_Static_RM_Size (E : Entity_Id) return B with Inline;
|
|
procedure Reinit_RM_Size (Id : E) with Inline;
|
|
procedure Copy_RM_Size (To, From : E);
|
|
|
|
-- NOTE: "known" here does not mean "known at compile time". It means that
|
|
-- the compiler has computed the value of the field (either by default, or
|
|
-- by noting some representation clauses), and the field has not been
|
|
-- reinitialized.
|
|
--
|
|
-- We document the Esize functions here; the others above are analogous:
|
|
--
|
|
-- Known_Esize: True if Set_Esize has been called without a subsequent
|
|
-- Reinit_Esize.
|
|
--
|
|
-- Known_Static_Esize: True if Known_Esize and the Esize is known at
|
|
-- compile time. (We're not using "static" in the Ada RM sense here. We
|
|
-- are using it to mean "known at compile time".)
|
|
--
|
|
-- Reinit_Esize: Set the Esize field to its initial unknown state.
|
|
--
|
|
-- Copy_Esize: Copies the Esize from From to To; Known_Esize (From) may
|
|
-- be False, in which case Known_Esize (To) becomes False.
|
|
--
|
|
-- Esize: This is the normal automatically-generated getter for Esize,
|
|
-- declared elsewhere. Returns No_Uint if not Known_Esize.
|
|
--
|
|
-- Set_Esize: This is the normal automatically-generated setter for
|
|
-- Esize. After a call to this, Known_Esize is True. It is an error
|
|
-- to call this with a No_Uint value.
|
|
--
|
|
-- Normally, we call Set_Esize first, and then query Esize (and similarly
|
|
-- for other fields). However in some cases, we need to check Known_Esize
|
|
-- before calling Esize, because the code is written in such a way that we
|
|
-- don't know whether Set_Esize has already been called.
|
|
--
|
|
-- In two cases, Known_Static_Esize and Known_Static_RM_Size, there is one
|
|
-- more consideration, which is that we always return False for generic
|
|
-- types. Within a template, the size can look Known_Static, because of the
|
|
-- fake size values we put in template types, but they are not really
|
|
-- Known_Static and anyone testing if they are Known_Static within the
|
|
-- template should get False as a result to prevent incorrect assumptions.
|
|
|
|
---------------------------------------------------------
|
|
-- Procedures for setting multiple of the above fields --
|
|
---------------------------------------------------------
|
|
|
|
procedure Reinit_Component_Location (Id : E);
|
|
-- Initializes all fields describing the location of a component
|
|
-- (Normalized_Position, Component_Bit_Offset, Normalized_First_Bit,
|
|
-- Esize) to all be Unknown.
|
|
|
|
procedure Init_Size (Id : E; V : Int);
|
|
-- Initialize both the Esize and RM_Size fields of E to V
|
|
|
|
procedure Reinit_Size_Align (Id : E);
|
|
-- This procedure initializes both size fields and the alignment
|
|
-- field to all be Unknown.
|
|
|
|
procedure Reinit_Object_Size_Align (Id : E);
|
|
-- Same as Reinit_Size_Align except RM_Size field (which is only for types)
|
|
-- is unaffected.
|
|
|
|
---------------------------------------------------
|
|
-- Access to Subprograms in Subprograms_For_Type --
|
|
---------------------------------------------------
|
|
|
|
-- Now that we have variable-sized nodes, it might be possible to replace
|
|
-- the following with regular fields, and get rid of the flags used to mark
|
|
-- these kinds of subprograms.
|
|
|
|
function Is_Partial_DIC_Procedure (Id : E) return B;
|
|
|
|
function DIC_Procedure (Id : E) return E;
|
|
function Partial_DIC_Procedure (Id : E) return E;
|
|
function Invariant_Procedure (Id : E) return E;
|
|
function Partial_Invariant_Procedure (Id : E) return E;
|
|
function Predicate_Function (Id : E) return E;
|
|
function Predicate_Function_M (Id : E) return E;
|
|
|
|
procedure Set_DIC_Procedure (Id : E; V : E);
|
|
procedure Set_Partial_DIC_Procedure (Id : E; V : E);
|
|
procedure Set_Invariant_Procedure (Id : E; V : E);
|
|
procedure Set_Partial_Invariant_Procedure (Id : E; V : E);
|
|
procedure Set_Predicate_Function (Id : E; V : E);
|
|
procedure Set_Predicate_Function_M (Id : E; V : E);
|
|
|
|
---------------
|
|
-- Iterators --
|
|
---------------
|
|
|
|
-- The call to Next_xxx (obj) is equivalent to obj := Next_xxx (obj)
|
|
-- We define the set of Proc_Next_xxx routines simply for the purposes
|
|
-- of inlining them without necessarily inlining the function.
|
|
|
|
procedure Proc_Next_Component (N : in out Node_Id);
|
|
procedure Proc_Next_Component_Or_Discriminant (N : in out Node_Id);
|
|
procedure Proc_Next_Discriminant (N : in out Node_Id);
|
|
procedure Proc_Next_Formal (N : in out Node_Id);
|
|
procedure Proc_Next_Formal_With_Extras (N : in out Node_Id);
|
|
procedure Proc_Next_Index (N : in out Node_Id);
|
|
procedure Proc_Next_Inlined_Subprogram (N : in out Node_Id);
|
|
procedure Proc_Next_Literal (N : in out Node_Id);
|
|
procedure Proc_Next_Stored_Discriminant (N : in out Node_Id);
|
|
|
|
pragma Inline (Proc_Next_Component);
|
|
pragma Inline (Proc_Next_Component_Or_Discriminant);
|
|
pragma Inline (Proc_Next_Discriminant);
|
|
pragma Inline (Proc_Next_Formal);
|
|
pragma Inline (Proc_Next_Formal_With_Extras);
|
|
pragma Inline (Proc_Next_Index);
|
|
pragma Inline (Proc_Next_Inlined_Subprogram);
|
|
pragma Inline (Proc_Next_Literal);
|
|
pragma Inline (Proc_Next_Stored_Discriminant);
|
|
|
|
procedure Next_Component (N : in out Node_Id)
|
|
renames Proc_Next_Component;
|
|
|
|
procedure Next_Component_Or_Discriminant (N : in out Node_Id)
|
|
renames Proc_Next_Component_Or_Discriminant;
|
|
|
|
procedure Next_Discriminant (N : in out Node_Id)
|
|
renames Proc_Next_Discriminant;
|
|
|
|
procedure Next_Formal (N : in out Node_Id)
|
|
renames Proc_Next_Formal;
|
|
|
|
procedure Next_Formal_With_Extras (N : in out Node_Id)
|
|
renames Proc_Next_Formal_With_Extras;
|
|
|
|
procedure Next_Index (N : in out Node_Id)
|
|
renames Proc_Next_Index;
|
|
|
|
procedure Next_Inlined_Subprogram (N : in out Node_Id)
|
|
renames Proc_Next_Inlined_Subprogram;
|
|
|
|
procedure Next_Literal (N : in out Node_Id)
|
|
renames Proc_Next_Literal;
|
|
|
|
procedure Next_Stored_Discriminant (N : in out Node_Id)
|
|
renames Proc_Next_Stored_Discriminant;
|
|
|
|
---------------------------
|
|
-- Testing Warning Flags --
|
|
---------------------------
|
|
|
|
-- These routines are to be used rather than testing flags Warnings_Off,
|
|
-- Has_Pragma_Unmodified, Has_Pragma_Unreferenced. They deal with setting
|
|
-- the flags Warnings_Off_Used[_Unmodified|Unreferenced] for later access.
|
|
|
|
function Has_Warnings_Off (E : Entity_Id) return Boolean;
|
|
-- If Warnings_Off is set on E, then returns True and also sets the flag
|
|
-- Warnings_Off_Used on E. If Warnings_Off is not set on E, returns False
|
|
-- and has no side effect.
|
|
|
|
function Has_Unmodified (E : Entity_Id) return Boolean;
|
|
-- If flag Has_Pragma_Unmodified is set on E, returns True with no side
|
|
-- effects. Otherwise if Warnings_Off is set on E, returns True and also
|
|
-- sets the flag Warnings_Off_Used_Unmodified on E. If neither of the flags
|
|
-- Warnings_Off nor Has_Pragma_Unmodified is set, returns False with no
|
|
-- side effects.
|
|
|
|
function Has_Unreferenced (E : Entity_Id) return Boolean;
|
|
-- If flag Has_Pragma_Unreferenced is set on E, returns True with no side
|
|
-- effects. Otherwise if Warnings_Off is set on E, returns True and also
|
|
-- sets the flag Warnings_Off_Used_Unreferenced on E. If neither of the
|
|
-- flags Warnings_Off nor Has_Pragma_Unreferenced is set, returns False
|
|
-- with no side effects.
|
|
|
|
----------------------------------------------
|
|
-- Subprograms for Accessing Rep Item Chain --
|
|
----------------------------------------------
|
|
|
|
-- The First_Rep_Item field of every entity points to a linked list (linked
|
|
-- through Next_Rep_Item) of representation pragmas, attribute definition
|
|
-- clauses, representation clauses, and aspect specifications that apply to
|
|
-- the item. Note that in the case of types, it is assumed that any such
|
|
-- rep items for a base type also apply to all subtypes. This is achieved
|
|
-- by having the chain for subtypes link onto the chain for the base type,
|
|
-- so that new entries for the subtype are added at the start of the chain.
|
|
--
|
|
-- Note: aspect specification nodes are linked only when evaluation of the
|
|
-- expression is deferred to the freeze point. For further details see
|
|
-- Sem_Ch13.Analyze_Aspect_Specifications.
|
|
|
|
function Get_Attribute_Definition_Clause
|
|
(E : Entity_Id;
|
|
Id : Attribute_Id) return Node_Id;
|
|
-- Searches the Rep_Item chain for a given entity E, for an instance of an
|
|
-- attribute definition clause with the given attribute Id. If found, the
|
|
-- value returned is the N_Attribute_Definition_Clause node, otherwise
|
|
-- Empty is returned.
|
|
|
|
-- WARNING: There is a matching C declaration of this subprogram in fe.h
|
|
|
|
function Get_Pragma (E : Entity_Id; Id : Pragma_Id) return Node_Id;
|
|
-- Searches the Rep_Item chain of entity E, for an instance of a pragma
|
|
-- with the given pragma Id. If found, the value returned is the N_Pragma
|
|
-- node, otherwise Empty is returned. The following contract pragmas that
|
|
-- appear in N_Contract nodes are also handled by this routine:
|
|
-- Abstract_State
|
|
-- Async_Readers
|
|
-- Async_Writers
|
|
-- Attach_Handler
|
|
-- Constant_After_Elaboration
|
|
-- Contract_Cases
|
|
-- Depends
|
|
-- Effective_Reads
|
|
-- Effective_Writes
|
|
-- Global
|
|
-- Initial_Condition
|
|
-- Initializes
|
|
-- Interrupt_Handler
|
|
-- No_Caching
|
|
-- Part_Of
|
|
-- Precondition
|
|
-- Postcondition
|
|
-- Refined_Depends
|
|
-- Refined_Global
|
|
-- Refined_Post
|
|
-- Refined_State
|
|
-- Subprogram_Variant
|
|
-- Test_Case
|
|
-- Volatile_Function
|
|
|
|
function Get_Class_Wide_Pragma
|
|
(E : Entity_Id;
|
|
Id : Pragma_Id) return Node_Id;
|
|
-- Examine Rep_Item chain to locate a classwide pre- or postcondition of a
|
|
-- primitive operation. Returns Empty if not present.
|
|
|
|
function Get_Record_Representation_Clause (E : Entity_Id) return Node_Id;
|
|
-- Searches the Rep_Item chain for a given entity E, for a record
|
|
-- representation clause, and if found, returns it. Returns Empty
|
|
-- if no such clause is found.
|
|
|
|
function Present_In_Rep_Item (E : Entity_Id; N : Node_Id) return Boolean;
|
|
-- Return True if N is present in the Rep_Item chain for a given entity E
|
|
|
|
procedure Record_Rep_Item (E : Entity_Id; N : Node_Id);
|
|
-- N is the node for a representation pragma, representation clause, an
|
|
-- attribute definition clause, or an aspect specification that applies to
|
|
-- entity E. This procedure links the node N onto the Rep_Item chain for
|
|
-- entity E. Note that it is an error to call this procedure with E being
|
|
-- overloadable, and N being a pragma that applies to multiple overloadable
|
|
-- entities (Convention, Interface, Inline, Inline_Always, Import, Export,
|
|
-- External). This is not allowed even in the case where the entity is not
|
|
-- overloaded, since we can't rely on it being present in the overloaded
|
|
-- case, it is not useful to have it present in the non-overloaded case.
|
|
|
|
-------------------------------
|
|
-- Miscellaneous Subprograms --
|
|
-------------------------------
|
|
|
|
procedure Append_Entity (Id : Entity_Id; Scop : Entity_Id);
|
|
-- Add an entity to the list of entities declared in the scope Scop
|
|
|
|
function Get_Full_View (T : Entity_Id) return Entity_Id;
|
|
-- If T is an incomplete type and the full declaration has been seen, or
|
|
-- is the name of a class_wide type whose root is incomplete, return the
|
|
-- corresponding full declaration, else return T itself.
|
|
|
|
function Is_Entity_Name (N : Node_Id) return Boolean;
|
|
-- Test if the node N is the name of an entity (i.e. is an identifier,
|
|
-- expanded name, or an attribute reference that returns an entity).
|
|
|
|
-- WARNING: There is a matching C declaration of this subprogram in fe.h
|
|
|
|
procedure Link_Entities (First, Second : Entity_Id);
|
|
-- Link entities First and Second in one entity chain.
|
|
--
|
|
-- NOTE: No updates are done to the First_Entity and Last_Entity fields
|
|
-- of the scope.
|
|
|
|
procedure Remove_Entity (Id : Entity_Id);
|
|
-- Remove entity Id from the entity chain of its scope
|
|
|
|
function Subtype_Kind (K : Entity_Kind) return Entity_Kind;
|
|
-- Given an entity_kind K this function returns the entity_kind
|
|
-- corresponding to subtype kind of the type represented by K. For
|
|
-- example if K is E_Signed_Integer_Type then E_Signed_Integer_Subtype
|
|
-- is returned. If K is already a subtype kind it itself is returned. An
|
|
-- internal error is generated if no such correspondence exists for K.
|
|
|
|
procedure Unlink_Next_Entity (Id : Entity_Id);
|
|
-- Unchain entity Id's forward link within the entity chain of its scope
|
|
|
|
function Is_Volatile (Id : E) return B;
|
|
procedure Set_Is_Volatile (Id : E; V : B := True);
|
|
-- Call [Set_]Is_Volatile_Type/Is_Volatile_Object as appropriate for the
|
|
-- Ekind of Id.
|
|
|
|
function Convention
|
|
(N : Entity_Id) return Convention_Id renames Basic_Convention;
|
|
procedure Set_Convention (E : Entity_Id; Val : Convention_Id);
|
|
-- Same as Set_Basic_Convention, but with an extra check for access types.
|
|
-- In particular, if E is an access-to-subprogram type, and Val is a
|
|
-- foreign convention, then we set Can_Use_Internal_Rep to False on E.
|
|
-- Also, if the Etype of E is set and is an anonymous access type with
|
|
-- no convention set, this anonymous type inherits the convention of E.
|
|
|
|
pragma Inline (Is_Entity_Name);
|
|
|
|
----------------------------------
|
|
-- Debugging Output Subprograms --
|
|
----------------------------------
|
|
|
|
procedure Write_Entity_Info (Id : Entity_Id; Prefix : String);
|
|
-- A debugging procedure to write out information about an entity
|
|
|
|
end Einfo.Utils;
|