* config/alpha/alpha.c, config/alpha/alpha.md,
[official-gcc.git] / gcc / ada / tbuild.ads
blob4ffedaf7c8d31f18a5234cd32a899aeb310631dc
1 ------------------------------------------------------------------------------
2 -- --
3 -- GNAT COMPILER COMPONENTS --
4 -- --
5 -- T B U I L D --
6 -- --
7 -- S p e c --
8 -- --
9 -- Copyright (C) 1992-2005, 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 2, 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 COPYING. If not, write --
19 -- to the Free Software Foundation, 51 Franklin Street, Fifth Floor, --
20 -- Boston, MA 02110-1301, USA. --
21 -- --
22 -- GNAT was originally developed by the GNAT team at New York University. --
23 -- Extensive contributions were provided by Ada Core Technologies Inc. --
24 -- --
25 ------------------------------------------------------------------------------
27 -- This package contains various utility procedures to assist in
28 -- building specific types of tree nodes.
30 with Types; use Types;
32 package Tbuild is
34 function Checks_Off (N : Node_Id) return Node_Id;
35 pragma Inline (Checks_Off);
36 -- Returns an N_Unchecked_Expression node whose expression is the given
37 -- argument. The results is a subexpression identical to the argument,
38 -- except that it will be analyzed and resolved with checks off.
40 function Convert_To (Typ : Entity_Id; Expr : Node_Id) return Node_Id;
41 -- Returns an expression that represents the result of a checked convert
42 -- of expression Exp to type T. If the base type of Exp is T, then no
43 -- conversion is required, and Exp is returned unchanged. Otherwise an
44 -- N_Type_Conversion node is constructed to convert the expression.
45 -- If an N_Type_Conversion node is required, Relocate_Node is used on
46 -- Exp. This means that it is safe to replace a node by a Convert_To
47 -- of itself to some other type.
49 procedure Discard_Node (N : Node_Or_Entity_Id);
50 pragma Inline (Discard_Node);
51 -- This is a dummy procedure that simply returns and does nothing.
52 -- It is used when a function returning a Node_Id value is called
53 -- for its side effect (e.g. a call to Make to construct a node)
54 -- but the Node_Id value is not required.
56 procedure Discard_List (L : List_Id);
57 pragma Inline (Discard_List);
58 -- This is a dummy procedure that simply returns and does nothing.
59 -- It is used when a function returning a Node_Id value is called
60 -- for its side effect (e.g. a call to the pareser to parse a list
61 -- of compilation units), but the List_Id value is not required.
63 function Make_Byte_Aligned_Attribute_Reference
64 (Sloc : Source_Ptr;
65 Prefix : Node_Id;
66 Attribute_Name : Name_Id) return Node_Id;
67 pragma Inline (Make_Byte_Aligned_Attribute_Reference);
68 -- Like the standard Make_Attribute_Reference but the special flag
69 -- Must_Be_Byte_Aligned is set in the attribute reference node. The
70 -- Attribute_Name must be Name_Address or Name_Unrestricted_Access.
72 function Make_DT_Access
73 (Loc : Source_Ptr; Rec : Node_Id; Typ : Entity_Id) return Node_Id;
74 -- Create an access to the Dispatch Table by using the Tag field
75 -- of a tagged record : Acc_Dt (Rec.tag).all
77 function Make_Implicit_If_Statement
78 (Node : Node_Id;
79 Condition : Node_Id;
80 Then_Statements : List_Id;
81 Elsif_Parts : List_Id := No_List;
82 Else_Statements : List_Id := No_List) return Node_Id;
83 pragma Inline (Make_Implicit_If_Statement);
84 -- This function makes an N_If_Statement node whose fields are filled
85 -- in with the indicated values (see Sinfo), and whose Sloc field is
86 -- is set to Sloc (Node). The effect is identical to calling function
87 -- Nmake.Make_If_Statement except that there is a check for restriction
88 -- No_Implicit_Conditionals, and if this restriction is being violated,
89 -- an error message is posted on Node.
91 function Make_Implicit_Label_Declaration
92 (Loc : Source_Ptr;
93 Defining_Identifier : Node_Id;
94 Label_Construct : Node_Id) return Node_Id;
95 -- Used to contruct an implicit label declaration node, including setting
96 -- the proper Label_Construct field (since Label_Construct is a semantic
97 -- field, the normal call to Make_Implicit_Label_Declaration does not
98 -- set this field).
100 function Make_Implicit_Loop_Statement
101 (Node : Node_Id;
102 Statements : List_Id;
103 Identifier : Node_Id := Empty;
104 Iteration_Scheme : Node_Id := Empty;
105 Has_Created_Identifier : Boolean := False;
106 End_Label : Node_Id := Empty) return Node_Id;
107 -- This function makes an N_Loop_Statement node whose fields are filled
108 -- in with the indicated values (see Sinfo), and whose Sloc field is
109 -- is set to Sloc (Node). The effect is identical to calling function
110 -- Nmake.Make_Loop_Statement except that there is a check for restrictions
111 -- No_Implicit_Loops and No_Implicit_Conditionals (the first applying in
112 -- all cases, and the second only for while loops), and if one of these
113 -- restrictions is being violated, an error message is posted on Node.
115 function Make_Integer_Literal
116 (Loc : Source_Ptr;
117 Intval : Int) return Node_Id;
118 pragma Inline (Make_Integer_Literal);
119 -- A convenient form of Make_Integer_Literal taking Int instead of Uint
121 function Make_Linker_Section_Pragma
122 (Ent : Entity_Id;
123 Loc : Source_Ptr;
124 Sec : String) return Node_Id;
125 -- Construct a Linker_Section pragma for entity Ent, using string Sec as
126 -- the section name. Loc is the Sloc value to use in building the pragma.
128 function Make_Raise_Constraint_Error
129 (Sloc : Source_Ptr;
130 Condition : Node_Id := Empty;
131 Reason : RT_Exception_Code) return Node_Id;
132 pragma Inline (Make_Raise_Constraint_Error);
133 -- A convenient form of Make_Raise_Constraint_Error where the Reason
134 -- is given simply as an enumeration value, rather than a Uint code.
136 function Make_Raise_Program_Error
137 (Sloc : Source_Ptr;
138 Condition : Node_Id := Empty;
139 Reason : RT_Exception_Code) return Node_Id;
140 pragma Inline (Make_Raise_Program_Error);
141 -- A convenient form of Make_Raise_Program_Error where the Reason
142 -- is given simply as an enumeration value, rather than a Uint code.
144 function Make_Raise_Storage_Error
145 (Sloc : Source_Ptr;
146 Condition : Node_Id := Empty;
147 Reason : RT_Exception_Code) return Node_Id;
148 pragma Inline (Make_Raise_Storage_Error);
149 -- A convenient form of Make_Raise_Storage_Error where the Reason
150 -- is given simply as an enumeration value, rather than a Uint code.
152 function Make_String_Literal
153 (Sloc : Source_Ptr;
154 Strval : String) return Node_Id;
155 -- A convenient form of Make_String_Literal, where the string value
156 -- is given as a normal string instead of a String_Id value.
158 function Make_Unsuppress_Block
159 (Loc : Source_Ptr;
160 Check : Name_Id;
161 Stmts : List_Id) return Node_Id;
162 -- Build a block with a pragma Suppress on 'Check'. Stmts is the
163 -- statements list that needs protection against the check
165 function New_Constraint_Error (Loc : Source_Ptr) return Node_Id;
166 -- This function builds a tree corresponding to the Ada statement
167 -- "raise Constraint_Error" and returns the root of this tree,
168 -- the N_Raise_Statement node.
170 function New_External_Name
171 (Related_Id : Name_Id;
172 Suffix : Character := ' ';
173 Suffix_Index : Int := 0;
174 Prefix : Character := ' ') return Name_Id;
175 function New_External_Name
176 (Related_Id : Name_Id;
177 Suffix : String;
178 Suffix_Index : Int := 0;
179 Prefix : Character := ' ') return Name_Id;
180 -- Builds a new entry in the names table of the form:
182 -- [Prefix &] Related_Id [& Suffix] [& Suffix_Index]
184 -- Prefix is prepended only if Prefix is non-blank (in which case it
185 -- must be an upper case letter other than O,Q,U,W (which are used for
186 -- identifier encoding, see Namet), and T is reserved for use by implicit
187 -- types. and X is reserved for use by debug type encoding (see package
188 -- Exp_Dbug). Note: the reason that Prefix is last is that it is almost
189 -- always omitted. The notable case of Prefix being non-null is when
190 -- it is 'T' for an implicit type.
192 -- Suffix_Index'Image is appended only if the value of Suffix_Index is
193 -- positive, or if Suffix_Index is negative 1, then a unique serialized
194 -- suffix is added. If Suffix_Index is zero, then no index is appended.
196 -- Suffix is also a single upper case letter other than O,Q,U,W,X and is a
197 -- required parameter (T is permitted). The constructed name is stored
198 -- using Find_Name so that it can be located using a subsequent Find_Name
199 -- operation (i.e. it is properly hashed into the names table). The upper
200 -- case letter given as the Suffix argument ensures that the name does
201 -- not clash with any Ada identifier name. These generated names are
202 -- permitted, but not required, to be made public by setting the flag
203 -- Is_Public in the associated entity.
205 function New_External_Name
206 (Suffix : Character;
207 Suffix_Index : Nat) return Name_Id;
208 -- Builds a new entry in the names table of the form
209 -- Suffix & Suffix_Index'Image
210 -- where Suffix is a single upper case letter other than O,Q,U,W,X and is
211 -- a required parameter (T is permitted). The constructed name is stored
212 -- using Find_Name so that it can be located using a subsequent Find_Name
213 -- operation (i.e. it is properly hashed into the names table). The upper
214 -- case letter given as the Suffix argument ensures that the name does
215 -- not clash with any Ada identifier name. These generated names are
216 -- permitted, but not required, to be made public by setting the flag
217 -- Is_Public in the associated entity.
219 function New_Internal_Name (Id_Char : Character) return Name_Id;
220 -- Id_Char is an upper case letter other than O,Q,U,W (which are reserved
221 -- for identifier encoding (see Namet package for details) and X which is
222 -- used for debug encoding (see Exp_Dbug). The letter T is permitted, but
223 -- is reserved by convention for the case of internally generated types.
224 -- The result of the call is a new generated unique name of the form XyyyU
225 -- where X is Id_Char, yyy is a unique serial number, and U is either a
226 -- lower case s or b indicating if the current unit is a spec or a body.
228 -- The name is entered into the names table using Name_Enter rather than
229 -- Name_Find, because there can never be a need to locate the entry using
230 -- the Name_Find procedure later on. Names created by New_Internal_Name
231 -- are guaranteed to be consistent from one compilation to another (i.e.
232 -- if the identical unit is compiled with a semantically consistent set
233 -- of sources, the numbers will be consistent. This means that it is fine
234 -- to use these as public symbols.
236 function New_Occurrence_Of
237 (Def_Id : Entity_Id;
238 Loc : Source_Ptr) return Node_Id;
239 -- New_Occurrence_Of creates an N_Identifier node which is an
240 -- occurrence of the defining identifier which is passed as its
241 -- argument. The Entity and Etype of the result are set from
242 -- the given defining identifier as follows: Entity is simply
243 -- a copy of Def_Id. Etype is a copy of Def_Id for types, and
244 -- a copy of the Etype of Def_Id for other entities.
246 function New_Reference_To
247 (Def_Id : Entity_Id;
248 Loc : Source_Ptr) return Node_Id;
249 -- This is like New_Occurrence_Of, but it does not set the Etype field.
250 -- It is used from the expander, where Etype fields are generally not set,
251 -- since they are set when the expanded tree is reanalyzed.
253 function New_Suffixed_Name
254 (Related_Id : Name_Id;
255 Suffix : String) return Name_Id;
256 -- This function is used to create special suffixed names used by the
257 -- debugger. Suffix is a string of upper case letters, used to construct
258 -- the required name. For instance, the special type used to record the
259 -- fixed-point small is called typ_SMALL where typ is the name of the
260 -- fixed-point type (as passed in Related_Id), and Suffix is "SMALL".
262 function OK_Convert_To (Typ : Entity_Id; Expr : Node_Id) return Node_Id;
263 -- Like Convert_To, except that a conversion node is always generated,
264 -- and the Conversion_OK flag is set on this conversion node.
266 function Unchecked_Convert_To
267 (Typ : Entity_Id;
268 Expr : Node_Id) return Node_Id;
269 -- Like Convert_To, but if a conversion is actually needed, constructs
270 -- an N_Unchecked_Type_Conversion node to do the required conversion.
272 end Tbuild;