view gcc/ada/bindo-units.ads @ 158:494b0b89df80 default tip

...
author Shinji KONO <kono@ie.u-ryukyu.ac.jp>
date Mon, 25 May 2020 18:13:55 +0900
parents 1830386684a0
children
line wrap: on
line source

------------------------------------------------------------------------------
--                                                                          --
--                         GNAT COMPILER COMPONENTS                         --
--                                                                          --
--                          B I N D O . U N I T S                           --
--                                                                          --
--                                 S p e c                                  --
--                                                                          --
--             Copyright (C) 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.  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.      --
--                                                                          --
------------------------------------------------------------------------------

--  For full architecture, see unit Bindo.

--  The following unit contains facilities to collect all elaborable units in
--  the bind and inspect their properties.

with GNAT;      use GNAT;
with GNAT.Sets; use GNAT.Sets;

package Bindo.Units is

   ---------------
   -- Unit sets --
   ---------------

   function Hash_Unit (U_Id : Unit_Id) return Bucket_Range_Type;
   pragma Inline (Hash_Unit);
   --  Obtain the hash value of key U_Id

   package Unit_Sets is new Membership_Sets
     (Element_Type => Unit_Id,
      "="          => "=",
      Hash         => Hash_Unit);

   procedure Collect_Elaborable_Units;
   pragma Inline (Collect_Elaborable_Units);
   --  Gather all units in the bind that require elaboration. The units are
   --  accessible via iterator Elaborable_Units_Iterator.

   function Corresponding_Body (U_Id : Unit_Id) return Unit_Id;
   pragma Inline (Corresponding_Body);
   --  Return the body of a spec unit U_Id

   function Corresponding_Spec (U_Id : Unit_Id) return Unit_Id;
   pragma Inline (Corresponding_Spec);
   --  Return the spec of a body unit U_Id

   function Corresponding_Unit (FNam : File_Name_Type) return Unit_Id;
   pragma Inline (Corresponding_Unit);
   --  Obtain the unit which corresponds to name FNam

   function Corresponding_Unit (UNam : Unit_Name_Type) return Unit_Id;
   pragma Inline (Corresponding_Unit);
   --  Obtain the unit which corresponds to name FNam

   function File_Name (U_Id : Unit_Id) return File_Name_Type;
   pragma Inline (File_Name);
   --  Obtain the file name of unit U_Id

   type Unit_Processor_Ptr is access procedure (U_Id : Unit_Id);

   procedure For_Each_Elaborable_Unit (Processor : Unit_Processor_Ptr);
   pragma Inline (For_Each_Elaborable_Unit);
   --  Invoke Processor on each elaborable unit in the bind

   procedure For_Each_Unit (Processor : Unit_Processor_Ptr);
   pragma Inline (For_Each_Unit);
   --  Invoke Processor on each unit in the bind

   function Has_No_Elaboration_Code (U_Id : Unit_Id) return Boolean;
   pragma Inline (Has_No_Elaboration_Code);
   --  Determine whether unit U_Id lacks elaboration code

   function Hash_Invocation_Signature
     (IS_Id : Invocation_Signature_Id) return Bucket_Range_Type;
   pragma Inline (Hash_Invocation_Signature);
   --  Obtain the hash value of key IS_Id

   function Invocation_Graph_Encoding
     (U_Id : Unit_Id) return Invocation_Graph_Encoding_Kind;
   pragma Inline (Invocation_Graph_Encoding);
   --  Obtain the encoding format used to capture invocation constructs and
   --  relations in the ALI file of unit U_Id.

   function Is_Dynamically_Elaborated (U_Id : Unit_Id) return Boolean;
   pragma Inline (Is_Dynamically_Elaborated);
   --  Determine whether unit U_Id was compiled using the dynamic elaboration
   --  model.

   function Is_Internal_Unit (U_Id : Unit_Id) return Boolean;
   pragma Inline (Is_Internal_Unit);
   --  Determine whether unit U_Id is internal

   function Is_Predefined_Unit (U_Id : Unit_Id) return Boolean;
   pragma Inline (Is_Predefined_Unit);
   --  Determine whether unit U_Id is predefined

   function Name (U_Id : Unit_Id) return Unit_Name_Type;
   pragma Inline (Name);
   --  Obtain the name of unit U_Id

   function Needs_Elaboration (IS_Id : Invocation_Signature_Id) return Boolean;
   pragma Inline (Needs_Elaboration);
   --  Determine whether invocation signature IS_Id belongs to a construct that
   --  appears in a unit which needs to be elaborated.

   function Needs_Elaboration (U_Id : Unit_Id) return Boolean;
   pragma Inline (Needs_Elaboration);
   --  Determine whether unit U_Id needs to be elaborated

   function Number_Of_Elaborable_Units return Natural;
   pragma Inline (Number_Of_Elaborable_Units);
   --  Obtain the number of units in the bind that need to be elaborated

   function Number_Of_Units return Natural;
   pragma Inline (Number_Of_Units);
   --  Obtain the number of units in the bind

   ---------------
   -- Iterators --
   ---------------

   --  The following type represents an iterator over all units that need to be
   --  elaborated.

   type Elaborable_Units_Iterator is private;

   function Has_Next (Iter : Elaborable_Units_Iterator) return Boolean;
   pragma Inline (Has_Next);
   --  Determine whether iterator Iter has more units to examine

   function Iterate_Elaborable_Units return Elaborable_Units_Iterator;
   pragma Inline (Iterate_Elaborable_Units);
   --  Obtain an iterator over all units that need to be elaborated

   procedure Next
     (Iter : in out Elaborable_Units_Iterator;
      U_Id : out Unit_Id);
   pragma Inline (Next);
   --  Return the current unit referenced by iterator Iter and advance to the
   --  next available unit.

   -----------------
   -- Maintenance --
   -----------------

   procedure Finalize_Units;
   pragma Inline (Finalize_Units);
   --  Destroy the internal structures of this unit

   procedure Initialize_Units;
   pragma Inline (Initialize_Units);
   --  Initialize the internal structures of this unit

private
   type Elaborable_Units_Iterator is new Unit_Sets.Iterator;

end Bindo.Units;