1 ------------------------------------------------------------------------------
3 -- GNAT COMPILER COMPONENTS --
5 -- B I N D O . U N I T S --
9 -- Copyright (C) 2019, Free Software Foundation, Inc. --
11 -- GNAT is free software; you can redistribute it and/or modify it under --
12 -- terms of the GNU General Public License as published by the Free Soft- --
13 -- ware Foundation; either version 3, or (at your option) any later ver- --
14 -- sion. GNAT is distributed in the hope that it will be useful, but WITH- --
15 -- OUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY --
16 -- or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License --
17 -- for more details. You should have received a copy of the GNU General --
18 -- Public License distributed with GNAT; see file COPYING3. If not, go to --
19 -- http://www.gnu.org/licenses for a complete copy of the license. --
21 -- GNAT was originally developed by the GNAT team at New York University. --
22 -- Extensive contributions were provided by Ada Core Technologies Inc. --
24 ------------------------------------------------------------------------------
26 -- For full architecture, see unit Bindo.
28 -- The following unit contains facilities to collect all elaborable units in
29 -- the bind and inspect their properties.
32 with GNAT
.Sets
; use GNAT
.Sets
;
34 package Bindo
.Units
is
40 function Hash_Unit
(U_Id
: Unit_Id
) return Bucket_Range_Type
;
41 pragma Inline
(Hash_Unit
);
42 -- Obtain the hash value of key U_Id
44 package Unit_Sets
is new Membership_Sets
45 (Element_Type
=> Unit_Id
,
49 procedure Collect_Elaborable_Units
;
50 pragma Inline
(Collect_Elaborable_Units
);
51 -- Gather all units in the bind that require elaboration. The units are
52 -- accessible via iterator Elaborable_Units_Iterator.
54 function Corresponding_Body
(U_Id
: Unit_Id
) return Unit_Id
;
55 pragma Inline
(Corresponding_Body
);
56 -- Return the body of a spec unit U_Id
58 function Corresponding_Spec
(U_Id
: Unit_Id
) return Unit_Id
;
59 pragma Inline
(Corresponding_Spec
);
60 -- Return the spec of a body unit U_Id
62 function Corresponding_Unit
(FNam
: File_Name_Type
) return Unit_Id
;
63 pragma Inline
(Corresponding_Unit
);
64 -- Obtain the unit which corresponds to name FNam
66 function Corresponding_Unit
(UNam
: Unit_Name_Type
) return Unit_Id
;
67 pragma Inline
(Corresponding_Unit
);
68 -- Obtain the unit which corresponds to name FNam
70 function File_Name
(U_Id
: Unit_Id
) return File_Name_Type
;
71 pragma Inline
(File_Name
);
72 -- Obtain the file name of unit U_Id
74 type Unit_Processor_Ptr
is access procedure (U_Id
: Unit_Id
);
76 procedure For_Each_Elaborable_Unit
(Processor
: Unit_Processor_Ptr
);
77 pragma Inline
(For_Each_Elaborable_Unit
);
78 -- Invoke Processor on each elaborable unit in the bind
80 procedure For_Each_Unit
(Processor
: Unit_Processor_Ptr
);
81 pragma Inline
(For_Each_Unit
);
82 -- Invoke Processor on each unit in the bind
84 function Has_No_Elaboration_Code
(U_Id
: Unit_Id
) return Boolean;
85 pragma Inline
(Has_No_Elaboration_Code
);
86 -- Determine whether unit U_Id lacks elaboration code
88 function Hash_Invocation_Signature
89 (IS_Id
: Invocation_Signature_Id
) return Bucket_Range_Type
;
90 pragma Inline
(Hash_Invocation_Signature
);
91 -- Obtain the hash value of key IS_Id
93 function Invocation_Graph_Encoding
94 (U_Id
: Unit_Id
) return Invocation_Graph_Encoding_Kind
;
95 pragma Inline
(Invocation_Graph_Encoding
);
96 -- Obtain the encoding format used to capture invocation constructs and
97 -- relations in the ALI file of unit U_Id.
99 function Is_Dynamically_Elaborated
(U_Id
: Unit_Id
) return Boolean;
100 pragma Inline
(Is_Dynamically_Elaborated
);
101 -- Determine whether unit U_Id was compiled using the dynamic elaboration
104 function Is_Internal_Unit
(U_Id
: Unit_Id
) return Boolean;
105 pragma Inline
(Is_Internal_Unit
);
106 -- Determine whether unit U_Id is internal
108 function Is_Predefined_Unit
(U_Id
: Unit_Id
) return Boolean;
109 pragma Inline
(Is_Predefined_Unit
);
110 -- Determine whether unit U_Id is predefined
112 function Name
(U_Id
: Unit_Id
) return Unit_Name_Type
;
113 pragma Inline
(Name
);
114 -- Obtain the name of unit U_Id
116 function Needs_Elaboration
(IS_Id
: Invocation_Signature_Id
) return Boolean;
117 pragma Inline
(Needs_Elaboration
);
118 -- Determine whether invocation signature IS_Id belongs to a construct that
119 -- appears in a unit which needs to be elaborated.
121 function Needs_Elaboration
(U_Id
: Unit_Id
) return Boolean;
122 pragma Inline
(Needs_Elaboration
);
123 -- Determine whether unit U_Id needs to be elaborated
125 function Number_Of_Elaborable_Units
return Natural;
126 pragma Inline
(Number_Of_Elaborable_Units
);
127 -- Obtain the number of units in the bind that need to be elaborated
129 function Number_Of_Units
return Natural;
130 pragma Inline
(Number_Of_Units
);
131 -- Obtain the number of units in the bind
137 -- The following type represents an iterator over all units that need to be
140 type Elaborable_Units_Iterator
is private;
142 function Has_Next
(Iter
: Elaborable_Units_Iterator
) return Boolean;
143 pragma Inline
(Has_Next
);
144 -- Determine whether iterator Iter has more units to examine
146 function Iterate_Elaborable_Units
return Elaborable_Units_Iterator
;
147 pragma Inline
(Iterate_Elaborable_Units
);
148 -- Obtain an iterator over all units that need to be elaborated
151 (Iter
: in out Elaborable_Units_Iterator
;
153 pragma Inline
(Next
);
154 -- Return the current unit referenced by iterator Iter and advance to the
155 -- next available unit.
161 procedure Finalize_Units
;
162 pragma Inline
(Finalize_Units
);
163 -- Destroy the internal structures of this unit
165 procedure Initialize_Units
;
166 pragma Inline
(Initialize_Units
);
167 -- Initialize the internal structures of this unit
170 type Elaborable_Units_Iterator
is new Unit_Sets
.Iterator
;