|
145
|
1 ------------------------------------------------------------------------------
|
|
|
2 -- --
|
|
|
3 -- GNAT COMPILER COMPONENTS --
|
|
|
4 -- --
|
|
|
5 -- B I N D O . U N I T S --
|
|
|
6 -- --
|
|
|
7 -- S p e c --
|
|
|
8 -- --
|
|
|
9 -- Copyright (C) 2019, Free Software Foundation, Inc. --
|
|
|
10 -- --
|
|
|
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. --
|
|
|
20 -- --
|
|
|
21 -- GNAT was originally developed by the GNAT team at New York University. --
|
|
|
22 -- Extensive contributions were provided by Ada Core Technologies Inc. --
|
|
|
23 -- --
|
|
|
24 ------------------------------------------------------------------------------
|
|
|
25
|
|
|
26 -- For full architecture, see unit Bindo.
|
|
|
27
|
|
|
28 -- The following unit contains facilities to collect all elaborable units in
|
|
|
29 -- the bind and inspect their properties.
|
|
|
30
|
|
|
31 with GNAT; use GNAT;
|
|
|
32 with GNAT.Sets; use GNAT.Sets;
|
|
|
33
|
|
|
34 package Bindo.Units is
|
|
|
35
|
|
|
36 ---------------
|
|
|
37 -- Unit sets --
|
|
|
38 ---------------
|
|
|
39
|
|
|
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
|
|
|
43
|
|
|
44 package Unit_Sets is new Membership_Sets
|
|
|
45 (Element_Type => Unit_Id,
|
|
|
46 "=" => "=",
|
|
|
47 Hash => Hash_Unit);
|
|
|
48
|
|
|
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.
|
|
|
53
|
|
|
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
|
|
|
57
|
|
|
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
|
|
|
61
|
|
|
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
|
|
|
65
|
|
|
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
|
|
|
69
|
|
|
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
|
|
|
73
|
|
|
74 type Unit_Processor_Ptr is access procedure (U_Id : Unit_Id);
|
|
|
75
|
|
|
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
|
|
|
79
|
|
|
80 procedure For_Each_Unit (Processor : Unit_Processor_Ptr);
|
|
|
81 pragma Inline (For_Each_Unit);
|
|
|
82 -- Invoke Processor on each unit in the bind
|
|
|
83
|
|
|
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
|
|
|
87
|
|
|
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
|
|
|
92
|
|
|
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.
|
|
|
98
|
|
|
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
|
|
|
102 -- model.
|
|
|
103
|
|
|
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
|
|
|
107
|
|
|
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
|
|
|
111
|
|
|
112 function Name (U_Id : Unit_Id) return Unit_Name_Type;
|
|
|
113 pragma Inline (Name);
|
|
|
114 -- Obtain the name of unit U_Id
|
|
|
115
|
|
|
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.
|
|
|
120
|
|
|
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
|
|
|
124
|
|
|
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
|
|
|
128
|
|
|
129 function Number_Of_Units return Natural;
|
|
|
130 pragma Inline (Number_Of_Units);
|
|
|
131 -- Obtain the number of units in the bind
|
|
|
132
|
|
|
133 ---------------
|
|
|
134 -- Iterators --
|
|
|
135 ---------------
|
|
|
136
|
|
|
137 -- The following type represents an iterator over all units that need to be
|
|
|
138 -- elaborated.
|
|
|
139
|
|
|
140 type Elaborable_Units_Iterator is private;
|
|
|
141
|
|
|
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
|
|
|
145
|
|
|
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
|
|
|
149
|
|
|
150 procedure Next
|
|
|
151 (Iter : in out Elaborable_Units_Iterator;
|
|
|
152 U_Id : out Unit_Id);
|
|
|
153 pragma Inline (Next);
|
|
|
154 -- Return the current unit referenced by iterator Iter and advance to the
|
|
|
155 -- next available unit.
|
|
|
156
|
|
|
157 -----------------
|
|
|
158 -- Maintenance --
|
|
|
159 -----------------
|
|
|
160
|
|
|
161 procedure Finalize_Units;
|
|
|
162 pragma Inline (Finalize_Units);
|
|
|
163 -- Destroy the internal structures of this unit
|
|
|
164
|
|
|
165 procedure Initialize_Units;
|
|
|
166 pragma Inline (Initialize_Units);
|
|
|
167 -- Initialize the internal structures of this unit
|
|
|
168
|
|
|
169 private
|
|
|
170 type Elaborable_Units_Iterator is new Unit_Sets.Iterator;
|
|
|
171
|
|
|
172 end Bindo.Units;
|
