]> git.pld-linux.org Git - packages/gcc3.4.git/blame - gcc3.4-ada-bootstrap.patch
projects / packages / gcc3.4.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
- utf8ized by spec_utf8.
[packages/gcc3.4.git] / gcc3.4-ada-bootstrap.patch
CommitLineData
8a43a6d0 1--- gcc-3.4.0/obj-amd64-pld-linux/gcc/ada/sinfo.h.orig 1970-01-01 01:00:00.000000000 +0100
2+++ gcc-3.4.0/obj-amd64-pld-linux/gcc/ada/sinfo.h 2004-06-02 00:54:16.000000000 +0200
3@@ -0,0 +1,847 @@
4+/*--------------------------------------------------------------------------*/
5+/* */
6+/* GNAT COMPILER COMPONENTS */
7+/* */
8+/* S I N F O */
9+/* */
10+/* C Header File */
11+/* */
12+/* Copyright (C) 1992-2004, Free Software Foundation, Inc. */
13+/* */
14+/* GNAT is free software; you can redistribute it and/or modify it under */
15+/* terms of the GNU General Public License as published by the Free Soft- */
16+/* ware Foundation; either version 2, or (at your option) any later ver- */
17+/* sion. GNAT is distributed in the hope that it will be useful, but WITH- */
18+/* OUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY */
19+/* or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License */
20+/* for more details. You should have received a copy of the GNU General */
21+/* Public License distributed with GNAT; see file COPYING. If not, write */
22+/* to the Free Software Foundation, 59 Temple Place - Suite 330, Boston, */
23+/* MA 02111-1307, USA. */
24+/* */
25+/* As a special exception, if other files instantiate generics from this */
26+/* unit, or you link this unit with other files to produce an executable, */
27+/* this unit does not by itself cause the resulting executable to be */
28+/* covered by the GNU General Public License. This exception does not */
29+/* however invalidate any other reasons why the executable file might be */
30+/* covered by the GNU Public License. */
31+/* */
32+/* GNAT was originally developed by the GNAT team at New York University. */
33+/* Extensive contributions were provided by Ada Core Technologies Inc. */
34+/* */
35+/*--------------------------------------------------------------------------*/
36+
37+ #define N_Unused_At_Start 0
38+ #define N_At_Clause 1
39+ #define N_Component_Clause 2
40+ #define N_Enumeration_Representation_Clause 3
41+ #define N_Mod_Clause 4
42+ #define N_Record_Representation_Clause 5
43+ #define N_Attribute_Definition_Clause 6
44+ #define N_Empty 7
45+ #define N_Pragma 8
46+ #define N_Pragma_Argument_Association 9
47+ #define N_Error 10
48+ #define N_Defining_Character_Literal 11
49+ #define N_Defining_Identifier 12
50+ #define N_Defining_Operator_Symbol 13
51+ #define N_Expanded_Name 14
52+ #define N_Identifier 15
53+ #define N_Operator_Symbol 16
54+ #define N_Character_Literal 17
55+ #define N_Op_Add 18
56+ #define N_Op_Concat 19
57+ #define N_Op_Expon 20
58+ #define N_Op_Subtract 21
59+ #define N_Op_Divide 22
60+ #define N_Op_Mod 23
61+ #define N_Op_Multiply 24
62+ #define N_Op_Rem 25
63+ #define N_Op_And 26
64+ #define N_Op_Eq 27
65+ #define N_Op_Ge 28
66+ #define N_Op_Gt 29
67+ #define N_Op_Le 30
68+ #define N_Op_Lt 31
69+ #define N_Op_Ne 32
70+ #define N_Op_Or 33
71+ #define N_Op_Xor 34
72+ #define N_Op_Rotate_Left 35
73+ #define N_Op_Rotate_Right 36
74+ #define N_Op_Shift_Left 37
75+ #define N_Op_Shift_Right 38
76+ #define N_Op_Shift_Right_Arithmetic 39
77+ #define N_Op_Abs 40
78+ #define N_Op_Minus 41
79+ #define N_Op_Not 42
80+ #define N_Op_Plus 43
81+ #define N_Attribute_Reference 44
82+ #define N_And_Then 45
83+ #define N_Conditional_Expression 46
84+ #define N_Explicit_Dereference 47
85+ #define N_Function_Call 48
86+ #define N_In 49
87+ #define N_Indexed_Component 50
88+ #define N_Integer_Literal 51
89+ #define N_Not_In 52
90+ #define N_Null 53
91+ #define N_Or_Else 54
92+ #define N_Procedure_Call_Statement 55
93+ #define N_Qualified_Expression 56
94+ #define N_Raise_Constraint_Error 57
95+ #define N_Raise_Program_Error 58
96+ #define N_Raise_Storage_Error 59
97+ #define N_Aggregate 60
98+ #define N_Allocator 61
99+ #define N_Extension_Aggregate 62
100+ #define N_Range 63
101+ #define N_Real_Literal 64
102+ #define N_Reference 65
103+ #define N_Selected_Component 66
104+ #define N_Slice 67
105+ #define N_String_Literal 68
106+ #define N_Subprogram_Info 69
107+ #define N_Type_Conversion 70
108+ #define N_Unchecked_Expression 71
109+ #define N_Unchecked_Type_Conversion 72
110+ #define N_Subtype_Indication 73
111+ #define N_Component_Declaration 74
112+ #define N_Entry_Declaration 75
113+ #define N_Formal_Object_Declaration 76
114+ #define N_Formal_Type_Declaration 77
115+ #define N_Full_Type_Declaration 78
116+ #define N_Incomplete_Type_Declaration 79
117+ #define N_Loop_Parameter_Specification 80
118+ #define N_Object_Declaration 81
119+ #define N_Protected_Type_Declaration 82
120+ #define N_Private_Extension_Declaration 83
121+ #define N_Private_Type_Declaration 84
122+ #define N_Subtype_Declaration 85
123+ #define N_Function_Specification 86
124+ #define N_Procedure_Specification 87
125+ #define N_Entry_Index_Specification 88
126+ #define N_Freeze_Entity 89
127+ #define N_Access_Function_Definition 90
128+ #define N_Access_Procedure_Definition 91
129+ #define N_Task_Type_Declaration 92
130+ #define N_Package_Body_Stub 93
131+ #define N_Protected_Body_Stub 94
132+ #define N_Subprogram_Body_Stub 95
133+ #define N_Task_Body_Stub 96
134+ #define N_Function_Instantiation 97
135+ #define N_Package_Instantiation 98
136+ #define N_Procedure_Instantiation 99
137+ #define N_Package_Body 100
138+ #define N_Subprogram_Body 101
139+ #define N_Protected_Body 102
140+ #define N_Task_Body 103
141+ #define N_Implicit_Label_Declaration 104
142+ #define N_Package_Declaration 105
143+ #define N_Single_Task_Declaration 106
144+ #define N_Subprogram_Declaration 107
145+ #define N_Use_Package_Clause 108
146+ #define N_Generic_Package_Declaration 109
147+ #define N_Generic_Subprogram_Declaration 110
148+ #define N_Constrained_Array_Definition 111
149+ #define N_Unconstrained_Array_Definition 112
150+ #define N_Exception_Renaming_Declaration 113
151+ #define N_Object_Renaming_Declaration 114
152+ #define N_Package_Renaming_Declaration 115
153+ #define N_Subprogram_Renaming_Declaration 116
154+ #define N_Generic_Function_Renaming_Declaration 117
155+ #define N_Generic_Package_Renaming_Declaration 118
156+ #define N_Generic_Procedure_Renaming_Declaration 119
157+ #define N_Abort_Statement 120
158+ #define N_Accept_Statement 121
159+ #define N_Assignment_Statement 122
160+ #define N_Asynchronous_Select 123
161+ #define N_Block_Statement 124
162+ #define N_Case_Statement 125
163+ #define N_Code_Statement 126
164+ #define N_Conditional_Entry_Call 127
165+ #define N_Delay_Relative_Statement 128
166+ #define N_Delay_Until_Statement 129
167+ #define N_Entry_Call_Statement 130
168+ #define N_Free_Statement 131
169+ #define N_Goto_Statement 132
170+ #define N_Loop_Statement 133
171+ #define N_Null_Statement 134
172+ #define N_Raise_Statement 135
173+ #define N_Requeue_Statement 136
174+ #define N_Return_Statement 137
175+ #define N_Selective_Accept 138
176+ #define N_Timed_Entry_Call 139
177+ #define N_Exit_Statement 140
178+ #define N_If_Statement 141
179+ #define N_Accept_Alternative 142
180+ #define N_Delay_Alternative 143
181+ #define N_Elsif_Part 144
182+ #define N_Entry_Body_Formal_Part 145
183+ #define N_Iteration_Scheme 146
184+ #define N_Terminate_Alternative 147
185+ #define N_Abortable_Part 148
186+ #define N_Abstract_Subprogram_Declaration 149
187+ #define N_Access_Definition 150
188+ #define N_Access_To_Object_Definition 151
189+ #define N_Case_Statement_Alternative 152
190+ #define N_Compilation_Unit 153
191+ #define N_Compilation_Unit_Aux 154
192+ #define N_Component_Association 155
193+ #define N_Component_Definition 156
194+ #define N_Component_List 157
195+ #define N_Derived_Type_Definition 158
196+ #define N_Decimal_Fixed_Point_Definition 159
197+ #define N_Defining_Program_Unit_Name 160
198+ #define N_Delta_Constraint 161
199+ #define N_Designator 162
200+ #define N_Digits_Constraint 163
201+ #define N_Discriminant_Association 164
202+ #define N_Discriminant_Specification 165
203+ #define N_Enumeration_Type_Definition 166
204+ #define N_Entry_Body 167
205+ #define N_Entry_Call_Alternative 168
206+ #define N_Exception_Declaration 169
207+ #define N_Exception_Handler 170
208+ #define N_Floating_Point_Definition 171
209+ #define N_Formal_Decimal_Fixed_Point_Definition 172
210+ #define N_Formal_Derived_Type_Definition 173
211+ #define N_Formal_Discrete_Type_Definition 174
212+ #define N_Formal_Floating_Point_Definition 175
213+ #define N_Formal_Modular_Type_Definition 176
214+ #define N_Formal_Ordinary_Fixed_Point_Definition 177
215+ #define N_Formal_Package_Declaration 178
216+ #define N_Formal_Private_Type_Definition 179
217+ #define N_Formal_Signed_Integer_Type_Definition 180
218+ #define N_Formal_Subprogram_Declaration 181
219+ #define N_Generic_Association 182
220+ #define N_Handled_Sequence_Of_Statements 183
221+ #define N_Index_Or_Discriminant_Constraint 184
222+ #define N_Itype_Reference 185
223+ #define N_Label 186
224+ #define N_Modular_Type_Definition 187
225+ #define N_Number_Declaration 188
226+ #define N_Ordinary_Fixed_Point_Definition 189
227+ #define N_Others_Choice 190
228+ #define N_Package_Specification 191
229+ #define N_Parameter_Association 192
230+ #define N_Parameter_Specification 193
231+ #define N_Protected_Definition 194
232+ #define N_Range_Constraint 195
233+ #define N_Real_Range_Specification 196
234+ #define N_Record_Definition 197
235+ #define N_Signed_Integer_Type_Definition 198
236+ #define N_Single_Protected_Declaration 199
237+ #define N_Subunit 200
238+ #define N_Task_Definition 201
239+ #define N_Triggering_Alternative 202
240+ #define N_Use_Type_Clause 203
241+ #define N_Validate_Unchecked_Conversion 204
242+ #define N_Variant 205
243+ #define N_Variant_Part 206
244+ #define N_With_Clause 207
245+ #define N_With_Type_Clause 208
246+ #define N_Unused_At_End 209
247+
248+ #define Number_Node_Kinds 210
249+ SUBTYPE (N_Access_To_Subprogram_Definition, Node_Kind,
250+ N_Access_Function_Definition,
251+ N_Access_Procedure_Definition)
252+ SUBTYPE (N_Array_Type_Definition, Node_Kind,
253+ N_Constrained_Array_Definition,
254+ N_Unconstrained_Array_Definition)
255+ SUBTYPE (N_Binary_Op, Node_Kind,
256+ N_Op_Add,
257+ N_Op_Shift_Right_Arithmetic)
258+ SUBTYPE (N_Body_Stub, Node_Kind,
259+ N_Package_Body_Stub,
260+ N_Task_Body_Stub)
261+ SUBTYPE (N_Declaration, Node_Kind,
262+ N_Component_Declaration,
263+ N_Procedure_Specification)
264+ SUBTYPE (N_Direct_Name, Node_Kind,
265+ N_Identifier,
266+ N_Character_Literal)
267+ SUBTYPE (N_Entity, Node_Kind,
268+ N_Defining_Character_Literal,
269+ N_Defining_Operator_Symbol)
270+ SUBTYPE (N_Generic_Declaration, Node_Kind,
271+ N_Generic_Package_Declaration,
272+ N_Generic_Subprogram_Declaration)
273+ SUBTYPE (N_Generic_Instantiation, Node_Kind,
274+ N_Function_Instantiation,
275+ N_Procedure_Instantiation)
276+ SUBTYPE (N_Generic_Renaming_Declaration, Node_Kind,
277+ N_Generic_Function_Renaming_Declaration,
278+ N_Generic_Procedure_Renaming_Declaration)
279+ SUBTYPE (N_Has_Chars, Node_Kind,
280+ N_Attribute_Definition_Clause,
281+ N_Op_Plus)
282+ SUBTYPE (N_Has_Entity, Node_Kind,
283+ N_Expanded_Name,
284+ N_Attribute_Reference)
285+ SUBTYPE (N_Has_Etype, Node_Kind,
286+ N_Error,
287+ N_Subtype_Indication)
288+ SUBTYPE (N_Has_Treat_Fixed_As_Integer, Node_Kind,
289+ N_Op_Divide,
290+ N_Op_Rem)
291+ SUBTYPE (N_Later_Decl_Item, Node_Kind,
292+ N_Task_Type_Declaration,
293+ N_Generic_Subprogram_Declaration)
294+ SUBTYPE (N_Op, Node_Kind,
295+ N_Op_Add,
296+ N_Op_Plus)
297+ SUBTYPE (N_Op_Boolean, Node_Kind,
298+ N_Op_And,
299+ N_Op_Xor)
300+ SUBTYPE (N_Op_Compare, Node_Kind,
301+ N_Op_Eq,
302+ N_Op_Ne)
303+ SUBTYPE (N_Op_Shift, Node_Kind,
304+ N_Op_Rotate_Left,
305+ N_Op_Shift_Right_Arithmetic)
306+ SUBTYPE (N_Proper_Body, Node_Kind,
307+ N_Package_Body,
308+ N_Task_Body)
309+ SUBTYPE (N_Raise_xxx_Error, Node_Kind,
310+ N_Raise_Constraint_Error,
311+ N_Raise_Storage_Error)
312+ SUBTYPE (N_Renaming_Declaration, Node_Kind,
313+ N_Exception_Renaming_Declaration,
314+ N_Generic_Procedure_Renaming_Declaration)
315+ SUBTYPE (N_Representation_Clause, Node_Kind,
316+ N_At_Clause,
317+ N_Attribute_Definition_Clause)
318+ SUBTYPE (N_Statement_Other_Than_Procedure_Call, Node_Kind,
319+ N_Abort_Statement,
320+ N_If_Statement)
321+ SUBTYPE (N_Has_Condition, Node_Kind,
322+ N_Exit_Statement,
323+ N_Terminate_Alternative)
324+ SUBTYPE (N_Subexpr, Node_Kind,
325+ N_Expanded_Name,
326+ N_Unchecked_Type_Conversion)
327+ SUBTYPE (N_Subprogram_Specification, Node_Kind,
328+ N_Function_Specification,
329+ N_Procedure_Specification)
330+ SUBTYPE (N_Unary_Op, Node_Kind,
331+ N_Op_Abs,
332+ N_Op_Plus)
333+ SUBTYPE (N_Unit_Body, Node_Kind,
334+ N_Package_Body,
335+ N_Subprogram_Body)
336+ INLINE Boolean ABE_Is_Certain (Node_Id N)
337+ { return Flag18 (N); }
338+ INLINE Boolean Abort_Present (Node_Id N)
339+ { return Flag15 (N); }
340+ INLINE Node_Id Abortable_Part (Node_Id N)
341+ { return Node2 (N); }
342+ INLINE Boolean Abstract_Present (Node_Id N)
343+ { return Flag4 (N); }
344+ INLINE List_Id Accept_Handler_Records (Node_Id N)
345+ { return List5 (N); }
346+ INLINE Node_Id Accept_Statement (Node_Id N)
347+ { return Node2 (N); }
348+ INLINE Elist_Id Access_Types_To_Process (Node_Id N)
349+ { return Elist2 (N); }
350+ INLINE List_Id Actions (Node_Id N)
351+ { return List1 (N); }
352+ INLINE Node_Id Activation_Chain_Entity (Node_Id N)
353+ { return Node3 (N); }
354+ INLINE Boolean Acts_As_Spec (Node_Id N)
355+ { return Flag4 (N); }
356+ INLINE Node_Id Aggregate_Bounds (Node_Id N)
357+ { return Node3 (N); }
358+ INLINE Boolean Aliased_Present (Node_Id N)
359+ { return Flag4 (N); }
360+ INLINE Boolean All_Others (Node_Id N)
361+ { return Flag11 (N); }
362+ INLINE Boolean All_Present (Node_Id N)
363+ { return Flag15 (N); }
364+ INLINE List_Id Alternatives (Node_Id N)
365+ { return List4 (N); }
366+ INLINE Node_Id Ancestor_Part (Node_Id N)
367+ { return Node3 (N); }
368+ INLINE Node_Id Array_Aggregate (Node_Id N)
369+ { return Node3 (N); }
370+ INLINE Boolean Assignment_OK (Node_Id N)
371+ { return Flag15 (N); }
372+ INLINE Node_Id Associated_Node (Node_Id N)
373+ { return Node4 (N); }
374+ INLINE Node_Id At_End_Proc (Node_Id N)
375+ { return Node1 (N); }
376+ INLINE Name_Id Attribute_Name (Node_Id N)
377+ { return Name2 (N); }
378+ INLINE Node_Id Aux_Decls_Node (Node_Id N)
379+ { return Node5 (N); }
380+ INLINE Boolean Backwards_OK (Node_Id N)
381+ { return Flag6 (N); }
382+ INLINE Boolean Bad_Is_Detected (Node_Id N)
383+ { return Flag15 (N); }
384+ INLINE Boolean By_Ref (Node_Id N)
385+ { return Flag5 (N); }
386+ INLINE Boolean Body_Required (Node_Id N)
387+ { return Flag13 (N); }
388+ INLINE Node_Id Body_To_Inline (Node_Id N)
389+ { return Node3 (N); }
390+ INLINE Boolean Box_Present (Node_Id N)
391+ { return Flag15 (N); }
392+ INLINE Char_Code Char_Literal_Value (Node_Id N)
393+ { return Char_Code2 (N); }
394+ INLINE Name_Id Chars (Node_Id N)
395+ { return Name1 (N); }
396+ INLINE Boolean Check_Address_Alignment (Node_Id N)
397+ { return Flag11 (N); }
398+ INLINE Node_Id Choice_Parameter (Node_Id N)
399+ { return Node2 (N); }
400+ INLINE List_Id Choices (Node_Id N)
401+ { return List1 (N); }
402+ INLINE Boolean Compile_Time_Known_Aggregate (Node_Id N)
403+ { return Flag18 (N); }
404+ INLINE List_Id Component_Associations (Node_Id N)
405+ { return List2 (N); }
406+ INLINE List_Id Component_Clauses (Node_Id N)
407+ { return List3 (N); }
408+ INLINE Node_Id Component_Definition (Node_Id N)
409+ { return Node4 (N); }
410+ INLINE List_Id Component_Items (Node_Id N)
411+ { return List3 (N); }
412+ INLINE Node_Id Component_List (Node_Id N)
413+ { return Node1 (N); }
414+ INLINE Node_Id Component_Name (Node_Id N)
415+ { return Node1 (N); }
416+ INLINE Node_Id Condition (Node_Id N)
417+ { return Node1 (N); }
418+ INLINE List_Id Condition_Actions (Node_Id N)
419+ { return List3 (N); }
420+ INLINE List_Id Config_Pragmas (Node_Id N)
421+ { return List4 (N); }
422+ INLINE Boolean Constant_Present (Node_Id N)
423+ { return Flag17 (N); }
424+ INLINE Node_Id Constraint (Node_Id N)
425+ { return Node3 (N); }
426+ INLINE List_Id Constraints (Node_Id N)
427+ { return List1 (N); }
428+ INLINE Boolean Context_Installed (Node_Id N)
429+ { return Flag13 (N); }
430+ INLINE List_Id Context_Items (Node_Id N)
431+ { return List1 (N); }
432+ INLINE Node_Id Controlling_Argument (Node_Id N)
433+ { return Node1 (N); }
434+ INLINE Boolean Conversion_OK (Node_Id N)
435+ { return Flag14 (N); }
436+ INLINE Node_Id Corresponding_Body (Node_Id N)
437+ { return Node5 (N); }
438+ INLINE Node_Id Corresponding_Generic_Association (Node_Id N)
439+ { return Node5 (N); }
440+ INLINE Uint Corresponding_Integer_Value (Node_Id N)
441+ { return Uint4 (N); }
442+ INLINE Node_Id Corresponding_Spec (Node_Id N)
443+ { return Node5 (N); }
444+ INLINE Node_Id Corresponding_Stub (Node_Id N)
445+ { return Node3 (N); }
446+ INLINE Entity_Id Dcheck_Function (Node_Id N)
447+ { return Node5 (N); }
448+ INLINE Node_Id Debug_Statement (Node_Id N)
449+ { return Node3 (N); }
450+ INLINE List_Id Declarations (Node_Id N)
451+ { return List2 (N); }
452+ INLINE Node_Id Default_Expression (Node_Id N)
453+ { return Node5 (N); }
454+ INLINE Node_Id Default_Name (Node_Id N)
455+ { return Node2 (N); }
456+ INLINE Entity_Id Defining_Identifier (Node_Id N)
457+ { return Node1 (N); }
458+ INLINE Node_Id Defining_Unit_Name (Node_Id N)
459+ { return Node1 (N); }
460+ INLINE Node_Id Delay_Alternative (Node_Id N)
461+ { return Node4 (N); }
462+ INLINE Boolean Delay_Finalize_Attach (Node_Id N)
463+ { return Flag14 (N); }
464+ INLINE Node_Id Delay_Statement (Node_Id N)
465+ { return Node2 (N); }
466+ INLINE Node_Id Delta_Expression (Node_Id N)
467+ { return Node3 (N); }
468+ INLINE Node_Id Digits_Expression (Node_Id N)
469+ { return Node2 (N); }
470+ INLINE Boolean Discr_Check_Funcs_Built (Node_Id N)
471+ { return Flag11 (N); }
472+ INLINE List_Id Discrete_Choices (Node_Id N)
473+ { return List4 (N); }
474+ INLINE Node_Id Discrete_Range (Node_Id N)
475+ { return Node4 (N); }
476+ INLINE Node_Id Discrete_Subtype_Definition (Node_Id N)
477+ { return Node4 (N); }
478+ INLINE List_Id Discrete_Subtype_Definitions (Node_Id N)
479+ { return List2 (N); }
480+ INLINE List_Id Discriminant_Specifications (Node_Id N)
481+ { return List4 (N); }
482+ INLINE Node_Id Discriminant_Type (Node_Id N)
483+ { return Node5 (N); }
484+ INLINE Boolean Do_Accessibility_Check (Node_Id N)
485+ { return Flag13 (N); }
486+ INLINE Boolean Do_Discriminant_Check (Node_Id N)
487+ { return Flag13 (N); }
488+ INLINE Boolean Do_Division_Check (Node_Id N)
489+ { return Flag13 (N); }
490+ INLINE Boolean Do_Length_Check (Node_Id N)
491+ { return Flag4 (N); }
492+ INLINE Boolean Do_Overflow_Check (Node_Id N)
493+ { return Flag17 (N); }
494+ INLINE Boolean Do_Range_Check (Node_Id N)
495+ { return Flag9 (N); }
496+ INLINE Boolean Do_Storage_Check (Node_Id N)
497+ { return Flag17 (N); }
498+ INLINE Boolean Do_Tag_Check (Node_Id N)
499+ { return Flag13 (N); }
500+ INLINE Boolean Elaborate_All_Present (Node_Id N)
501+ { return Flag15 (N); }
502+ INLINE Boolean Elaborate_Present (Node_Id N)
503+ { return Flag4 (N); }
504+ INLINE Node_Id Elaboration_Boolean (Node_Id N)
505+ { return Node2 (N); }
506+ INLINE List_Id Else_Actions (Node_Id N)
507+ { return List3 (N); }
508+ INLINE List_Id Else_Statements (Node_Id N)
509+ { return List4 (N); }
510+ INLINE List_Id Elsif_Parts (Node_Id N)
511+ { return List3 (N); }
512+ INLINE Node_Id Enclosing_Variant (Node_Id N)
513+ { return Node2 (N); }
514+ INLINE Node_Id End_Label (Node_Id N)
515+ { return Node4 (N); }
516+ INLINE Uint End_Span (Node_Id N)
517+ { return Uint5 (N); }
518+ INLINE Node_Id Entity (Node_Id N)
519+ { return Node4 (N); }
520+ INLINE Node_Id Entity_Or_Associated_Node (Node_Id N)
521+ { return Node4 (N); }
522+ INLINE Node_Id Entry_Body_Formal_Part (Node_Id N)
523+ { return Node5 (N); }
524+ INLINE Node_Id Entry_Call_Alternative (Node_Id N)
525+ { return Node1 (N); }
526+ INLINE Node_Id Entry_Call_Statement (Node_Id N)
527+ { return Node1 (N); }
528+ INLINE Node_Id Entry_Direct_Name (Node_Id N)
529+ { return Node1 (N); }
530+ INLINE Node_Id Entry_Index (Node_Id N)
531+ { return Node5 (N); }
532+ INLINE Node_Id Entry_Index_Specification (Node_Id N)
533+ { return Node4 (N); }
534+ INLINE Node_Id Etype (Node_Id N)
535+ { return Node5 (N); }
536+ INLINE List_Id Exception_Choices (Node_Id N)
537+ { return List4 (N); }
538+ INLINE List_Id Exception_Handlers (Node_Id N)
539+ { return List5 (N); }
540+ INLINE Boolean Exception_Junk (Node_Id N)
541+ { return Flag11 (N); }
542+ INLINE Node_Id Explicit_Actual_Parameter (Node_Id N)
543+ { return Node3 (N); }
544+ INLINE Boolean Expansion_Delayed (Node_Id N)
545+ { return Flag11 (N); }
546+ INLINE Node_Id Explicit_Generic_Actual_Parameter (Node_Id N)
547+ { return Node1 (N); }
548+ INLINE Node_Id Expression (Node_Id N)
549+ { return Node3 (N); }
550+ INLINE List_Id Expressions (Node_Id N)
551+ { return List1 (N); }
552+ INLINE Node_Id First_Bit (Node_Id N)
553+ { return Node3 (N); }
554+ INLINE Entity_Id First_Inlined_Subprogram (Node_Id N)
555+ { return Node3 (N); }
556+ INLINE Boolean First_Name (Node_Id N)
557+ { return Flag5 (N); }
558+ INLINE Node_Id First_Named_Actual (Node_Id N)
559+ { return Node4 (N); }
560+ INLINE Node_Id First_Real_Statement (Node_Id N)
561+ { return Node2 (N); }
562+ INLINE Entity_Id First_Subtype_Link (Node_Id N)
563+ { return Node5 (N); }
564+ INLINE Boolean Float_Truncate (Node_Id N)
565+ { return Flag11 (N); }
566+ INLINE Node_Id Formal_Type_Definition (Node_Id N)
567+ { return Node3 (N); }
568+ INLINE Boolean Forwards_OK (Node_Id N)
569+ { return Flag5 (N); }
570+ INLINE Boolean From_At_Mod (Node_Id N)
571+ { return Flag4 (N); }
572+ INLINE List_Id Generic_Associations (Node_Id N)
573+ { return List3 (N); }
574+ INLINE List_Id Generic_Formal_Declarations (Node_Id N)
575+ { return List2 (N); }
576+ INLINE Node_Id Generic_Parent (Node_Id N)
577+ { return Node5 (N); }
578+ INLINE Node_Id Generic_Parent_Type (Node_Id N)
579+ { return Node4 (N); }
580+ INLINE Node_Id Handled_Statement_Sequence (Node_Id N)
581+ { return Node4 (N); }
582+ INLINE Node_Id Handler_List_Entry (Node_Id N)
583+ { return Node2 (N); }
584+ INLINE Boolean Has_Created_Identifier (Node_Id N)
585+ { return Flag15 (N); }
586+ INLINE Boolean Has_Dynamic_Length_Check (Node_Id N)
587+ { return Flag10 (N); }
588+ INLINE Boolean Has_Dynamic_Range_Check (Node_Id N)
589+ { return Flag12 (N); }
590+ INLINE Boolean Has_No_Elaboration_Code (Node_Id N)
591+ { return Flag17 (N); }
592+ INLINE Boolean Has_Priority_Pragma (Node_Id N)
593+ { return Flag6 (N); }
594+ INLINE Boolean Has_Private_View (Node_Id N)
595+ { return Flag11 (N); }
596+ INLINE Boolean Has_Storage_Size_Pragma (Node_Id N)
597+ { return Flag5 (N); }
598+ INLINE Boolean Has_Task_Info_Pragma (Node_Id N)
599+ { return Flag7 (N); }
600+ INLINE Boolean Has_Task_Name_Pragma (Node_Id N)
601+ { return Flag8 (N); }
602+ INLINE Boolean Has_Wide_Character (Node_Id N)
603+ { return Flag11 (N); }
604+ INLINE Elist_Id Hidden_By_Use_Clause (Node_Id N)
605+ { return Elist4 (N); }
606+ INLINE Node_Id High_Bound (Node_Id N)
607+ { return Node2 (N); }
608+ INLINE Node_Id Identifier (Node_Id N)
609+ { return Node1 (N); }
610+ INLINE Boolean Implicit_With (Node_Id N)
611+ { return Flag16 (N); }
612+ INLINE Boolean In_Present (Node_Id N)
613+ { return Flag15 (N); }
614+ INLINE Boolean Includes_Infinities (Node_Id N)
615+ { return Flag11 (N); }
616+ INLINE Node_Id Instance_Spec (Node_Id N)
617+ { return Node5 (N); }
618+ INLINE Uint Intval (Node_Id N)
619+ { return Uint3 (N); }
620+ INLINE Boolean Is_Asynchronous_Call_Block (Node_Id N)
621+ { return Flag7 (N); }
622+ INLINE Boolean Is_Component_Left_Opnd (Node_Id N)
623+ { return Flag13 (N); }
624+ INLINE Boolean Is_Component_Right_Opnd (Node_Id N)
625+ { return Flag14 (N); }
626+ INLINE Boolean Is_Controlling_Actual (Node_Id N)
627+ { return Flag16 (N); }
628+ INLINE Boolean Is_In_Discriminant_Check (Node_Id N)
629+ { return Flag11 (N); }
630+ INLINE Boolean Is_Machine_Number (Node_Id N)
631+ { return Flag11 (N); }
632+ INLINE Boolean Is_Null_Loop (Node_Id N)
633+ { return Flag16 (N); }
634+ INLINE Boolean Is_Overloaded (Node_Id N)
635+ { return Flag5 (N); }
636+ INLINE Boolean Is_Power_Of_2_For_Shift (Node_Id N)
637+ { return Flag13 (N); }
638+ INLINE Boolean Is_Protected_Subprogram_Body (Node_Id N)
639+ { return Flag7 (N); }
640+ INLINE Boolean Is_Static_Expression (Node_Id N)
641+ { return Flag6 (N); }
642+ INLINE Boolean Is_Subprogram_Descriptor (Node_Id N)
643+ { return Flag16 (N); }
644+ INLINE Boolean Is_Task_Allocation_Block (Node_Id N)
645+ { return Flag6 (N); }
646+ INLINE Boolean Is_Task_Master (Node_Id N)
647+ { return Flag5 (N); }
648+ INLINE Node_Id Iteration_Scheme (Node_Id N)
649+ { return Node2 (N); }
650+ INLINE Entity_Id Itype (Node_Id N)
651+ { return Node1 (N); }
652+ INLINE Boolean Kill_Range_Check (Node_Id N)
653+ { return Flag11 (N); }
654+ INLINE Node_Id Label_Construct (Node_Id N)
655+ { return Node2 (N); }
656+ INLINE Node_Id Left_Opnd (Node_Id N)
657+ { return Node2 (N); }
658+ INLINE Node_Id Last_Bit (Node_Id N)
659+ { return Node4 (N); }
660+ INLINE Boolean Last_Name (Node_Id N)
661+ { return Flag6 (N); }
662+ INLINE Node_Id Library_Unit (Node_Id N)
663+ { return Node4 (N); }
664+ INLINE Boolean Limited_View_Installed (Node_Id N)
665+ { return Flag18 (N); }
666+ INLINE Boolean Limited_Present (Node_Id N)
667+ { return Flag17 (N); }
668+ INLINE List_Id Literals (Node_Id N)
669+ { return List1 (N); }
670+ INLINE List_Id Loop_Actions (Node_Id N)
671+ { return List2 (N); }
672+ INLINE Node_Id Loop_Parameter_Specification (Node_Id N)
673+ { return Node4 (N); }
674+ INLINE Node_Id Low_Bound (Node_Id N)
675+ { return Node1 (N); }
676+ INLINE Node_Id Mod_Clause (Node_Id N)
677+ { return Node2 (N); }
678+ INLINE Boolean More_Ids (Node_Id N)
679+ { return Flag5 (N); }
680+ INLINE Boolean Must_Be_Byte_Aligned (Node_Id N)
681+ { return Flag14 (N); }
682+ INLINE Boolean Must_Not_Freeze (Node_Id N)
683+ { return Flag8 (N); }
684+ INLINE Node_Id Name (Node_Id N)
685+ { return Node2 (N); }
686+ INLINE List_Id Names (Node_Id N)
687+ { return List2 (N); }
688+ INLINE Node_Id Next_Entity (Node_Id N)
689+ { return Node2 (N); }
690+ INLINE Node_Id Next_Named_Actual (Node_Id N)
691+ { return Node4 (N); }
692+ INLINE Node_Id Next_Rep_Item (Node_Id N)
693+ { return Node4 (N); }
694+ INLINE Node_Id Next_Use_Clause (Node_Id N)
695+ { return Node3 (N); }
696+ INLINE Boolean No_Ctrl_Actions (Node_Id N)
697+ { return Flag7 (N); }
698+ INLINE Boolean No_Elaboration_Check (Node_Id N)
699+ { return Flag14 (N); }
700+ INLINE Boolean No_Entities_Ref_In_Spec (Node_Id N)
701+ { return Flag8 (N); }
702+ INLINE Boolean No_Initialization (Node_Id N)
703+ { return Flag13 (N); }
704+ INLINE Boolean No_Truncation (Node_Id N)
705+ { return Flag17 (N); }
706+ INLINE Boolean Null_Present (Node_Id N)
707+ { return Flag13 (N); }
708+ INLINE Boolean Null_Record_Present (Node_Id N)
709+ { return Flag17 (N); }
710+ INLINE Node_Id Object_Definition (Node_Id N)
711+ { return Node4 (N); }
712+ INLINE Boolean OK_For_Stream (Node_Id N)
713+ { return Flag4 (N); }
714+ INLINE Node_Id Original_Discriminant (Node_Id N)
715+ { return Node2 (N); }
716+ INLINE Entity_Id Original_Entity (Node_Id N)
717+ { return Node2 (N); }
718+ INLINE List_Id Others_Discrete_Choices (Node_Id N)
719+ { return List1 (N); }
720+ INLINE Boolean Out_Present (Node_Id N)
721+ { return Flag17 (N); }
722+ INLINE List_Id Parameter_Associations (Node_Id N)
723+ { return List3 (N); }
724+ INLINE Boolean Parameter_List_Truncated (Node_Id N)
725+ { return Flag17 (N); }
726+ INLINE List_Id Parameter_Specifications (Node_Id N)
727+ { return List3 (N); }
728+ INLINE Node_Id Parameter_Type (Node_Id N)
729+ { return Node2 (N); }
730+ INLINE Node_Id Parent_Spec (Node_Id N)
731+ { return Node4 (N); }
732+ INLINE Node_Id Position (Node_Id N)
733+ { return Node2 (N); }
734+ INLINE List_Id Pragma_Argument_Associations (Node_Id N)
735+ { return List2 (N); }
736+ INLINE List_Id Pragmas_After (Node_Id N)
737+ { return List5 (N); }
738+ INLINE List_Id Pragmas_Before (Node_Id N)
739+ { return List4 (N); }
740+ INLINE Node_Id Prefix (Node_Id N)
741+ { return Node3 (N); }
742+ INLINE Uint Present_Expr (Node_Id N)
743+ { return Uint3 (N); }
744+ INLINE Boolean Prev_Ids (Node_Id N)
745+ { return Flag6 (N); }
746+ INLINE Boolean Print_In_Hex (Node_Id N)
747+ { return Flag13 (N); }
748+ INLINE List_Id Private_Declarations (Node_Id N)
749+ { return List3 (N); }
750+ INLINE Boolean Private_Present (Node_Id N)
751+ { return Flag15 (N); }
752+ INLINE Node_Id Procedure_To_Call (Node_Id N)
753+ { return Node4 (N); }
754+ INLINE Node_Id Proper_Body (Node_Id N)
755+ { return Node1 (N); }
756+ INLINE Node_Id Protected_Definition (Node_Id N)
757+ { return Node3 (N); }
758+ INLINE Boolean Protected_Present (Node_Id N)
759+ { return Flag15 (N); }
760+ INLINE Boolean Raises_Constraint_Error (Node_Id N)
761+ { return Flag7 (N); }
762+ INLINE Node_Id Range_Constraint (Node_Id N)
763+ { return Node4 (N); }
764+ INLINE Node_Id Range_Expression (Node_Id N)
765+ { return Node4 (N); }
766+ INLINE Node_Id Real_Range_Specification (Node_Id N)
767+ { return Node4 (N); }
768+ INLINE Ureal Realval (Node_Id N)
769+ { return Ureal3 (N); }
770+ INLINE Uint Reason (Node_Id N)
771+ { return Uint3 (N); }
772+ INLINE Node_Id Record_Extension_Part (Node_Id N)
773+ { return Node3 (N); }
774+ INLINE Boolean Redundant_Use (Node_Id N)
775+ { return Flag13 (N); }
776+ INLINE Node_Id Return_Type (Node_Id N)
777+ { return Node2 (N); }
778+ INLINE Boolean Reverse_Present (Node_Id N)
779+ { return Flag15 (N); }
780+ INLINE Node_Id Right_Opnd (Node_Id N)
781+ { return Node3 (N); }
782+ INLINE Boolean Rounded_Result (Node_Id N)
783+ { return Flag18 (N); }
784+ INLINE Node_Id Scope (Node_Id N)
785+ { return Node3 (N); }
786+ INLINE List_Id Select_Alternatives (Node_Id N)
787+ { return List1 (N); }
788+ INLINE Node_Id Selector_Name (Node_Id N)
789+ { return Node2 (N); }
790+ INLINE List_Id Selector_Names (Node_Id N)
791+ { return List1 (N); }
792+ INLINE Boolean Shift_Count_OK (Node_Id N)
793+ { return Flag4 (N); }
794+ INLINE Entity_Id Source_Type (Node_Id N)
795+ { return Node1 (N); }
796+ INLINE Node_Id Specification (Node_Id N)
797+ { return Node1 (N); }
798+ INLINE List_Id Statements (Node_Id N)
799+ { return List3 (N); }
800+ INLINE Boolean Static_Processing_OK (Node_Id N)
801+ { return Flag4 (N); }
802+ INLINE Node_Id Storage_Pool (Node_Id N)
803+ { return Node1 (N); }
804+ INLINE String_Id Strval (Node_Id N)
805+ { return Str3 (N); }
806+ INLINE Node_Id Subtype_Indication (Node_Id N)
807+ { return Node5 (N); }
808+ INLINE Node_Id Subtype_Mark (Node_Id N)
809+ { return Node4 (N); }
810+ INLINE List_Id Subtype_Marks (Node_Id N)
811+ { return List2 (N); }
812+ INLINE Boolean Tagged_Present (Node_Id N)
813+ { return Flag15 (N); }
814+ INLINE Entity_Id Target_Type (Node_Id N)
815+ { return Node2 (N); }
816+ INLINE Entity_Id Task_Body_Procedure (Node_Id N)
817+ { return Node2 (N); }
818+ INLINE Node_Id Task_Definition (Node_Id N)
819+ { return Node3 (N); }
820+ INLINE List_Id Then_Actions (Node_Id N)
821+ { return List2 (N); }
822+ INLINE List_Id Then_Statements (Node_Id N)
823+ { return List2 (N); }
824+ INLINE Boolean Treat_Fixed_As_Integer (Node_Id N)
825+ { return Flag14 (N); }
826+ INLINE Node_Id Triggering_Alternative (Node_Id N)
827+ { return Node1 (N); }
828+ INLINE Node_Id Triggering_Statement (Node_Id N)
829+ { return Node1 (N); }
830+ INLINE Elist_Id TSS_Elist (Node_Id N)
831+ { return Elist3 (N); }
832+ INLINE Node_Id Type_Definition (Node_Id N)
833+ { return Node3 (N); }
834+ INLINE Node_Id Unit (Node_Id N)
835+ { return Node2 (N); }
836+ INLINE Boolean Unknown_Discriminants_Present (Node_Id N)
837+ { return Flag13 (N); }
838+ INLINE Boolean Unreferenced_In_Spec (Node_Id N)
839+ { return Flag7 (N); }
840+ INLINE Node_Id Variant_Part (Node_Id N)
841+ { return Node4 (N); }
842+ INLINE List_Id Variants (Node_Id N)
843+ { return List1 (N); }
844+ INLINE List_Id Visible_Declarations (Node_Id N)
845+ { return List2 (N); }
846+ INLINE Boolean Was_Originally_Stub (Node_Id N)
847+ { return Flag13 (N); }
848+ INLINE Boolean Zero_Cost_Handling (Node_Id N)
849+ { return Flag5 (N); }
850+
851--- gcc-3.4.0/obj-amd64-pld-linux/gcc/ada/einfo.h.orig 1970-01-01 01:00:00.000000000 +0100
852+++ gcc-3.4.0/obj-amd64-pld-linux/gcc/ada/einfo.h 2004-06-02 00:54:19.000000000 +0200
853@@ -0,0 +1,1814 @@
854+/*--------------------------------------------------------------------------*/
855+/* */
856+/* GNAT COMPILER COMPONENTS */
857+/* */
858+/* E I N F O */
859+/* */
860+/* C Header File */
861+/* */
862+/* Copyright (C) 1992-2003 Free Software Foundation, Inc. */
863+/* */
864+/* GNAT is free software; you can redistribute it and/or modify it under */
865+/* terms of the GNU General Public License as published by the Free Soft- */
866+/* ware Foundation; either version 2, or (at your option) any later ver- */
867+/* sion. GNAT is distributed in the hope that it will be useful, but WITH- */
868+/* OUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY */
869+/* or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License */
870+/* for more details. You should have received a copy of the GNU General */
871+/* Public License distributed with GNAT; see file COPYING. If not, write */
872+/* to the Free Software Foundation, 59 Temple Place - Suite 330, Boston, */
873+/* MA 02111-1307, USA. */
874+/* */
875+/* As a special exception, if other files instantiate generics from this */
876+/* unit, or you link this unit with other files to produce an executable, */
877+/* this unit does not by itself cause the resulting executable to be */
878+/* covered by the GNU General Public License. This exception does not */
879+/* however invalidate any other reasons why the executable file might be */
880+/* covered by the GNU Public License. */
881+/* */
882+/* GNAT was originally developed by the GNAT team at New York University. */
883+/* Extensive contributions were provided by Ada Core Technologies Inc. */
884+/* */
885+/*--------------------------------------------------------------------------*/
886+
887+ #define E_Void 0
888+ #define E_Variable 1
889+ #define E_Component 2
890+ #define E_Constant 3
891+ #define E_Discriminant 4
892+ #define E_Loop_Parameter 5
893+ #define E_In_Parameter 6
894+ #define E_Out_Parameter 7
895+ #define E_In_Out_Parameter 8
896+ #define E_Generic_In_Out_Parameter 9
897+ #define E_Generic_In_Parameter 10
898+ #define E_Named_Integer 11
899+ #define E_Named_Real 12
900+ #define E_Enumeration_Type 13
901+ #define E_Enumeration_Subtype 14
902+ #define E_Signed_Integer_Type 15
903+ #define E_Signed_Integer_Subtype 16
904+ #define E_Modular_Integer_Type 17
905+ #define E_Modular_Integer_Subtype 18
906+ #define E_Ordinary_Fixed_Point_Type 19
907+ #define E_Ordinary_Fixed_Point_Subtype 20
908+ #define E_Decimal_Fixed_Point_Type 21
909+ #define E_Decimal_Fixed_Point_Subtype 22
910+ #define E_Floating_Point_Type 23
911+ #define E_Floating_Point_Subtype 24
912+ #define E_Access_Type 25
913+ #define E_Access_Subtype 26
914+ #define E_Access_Attribute_Type 27
915+ #define E_Allocator_Type 28
916+ #define E_General_Access_Type 29
917+ #define E_Access_Subprogram_Type 30
918+ #define E_Access_Protected_Subprogram_Type 31
919+ #define E_Anonymous_Access_Type 32
920+ #define E_Array_Type 33
921+ #define E_Array_Subtype 34
922+ #define E_String_Type 35
923+ #define E_String_Subtype 36
924+ #define E_String_Literal_Subtype 37
925+ #define E_Class_Wide_Type 38
926+ #define E_Class_Wide_Subtype 39
927+ #define E_Record_Type 40
928+ #define E_Record_Subtype 41
929+ #define E_Record_Type_With_Private 42
930+ #define E_Record_Subtype_With_Private 43
931+ #define E_Private_Type 44
932+ #define E_Private_Subtype 45
933+ #define E_Limited_Private_Type 46
934+ #define E_Limited_Private_Subtype 47
935+ #define E_Incomplete_Type 48
936+ #define E_Task_Type 49
937+ #define E_Task_Subtype 50
938+ #define E_Protected_Type 51
939+ #define E_Protected_Subtype 52
940+ #define E_Exception_Type 53
941+ #define E_Subprogram_Type 54
942+ #define E_Enumeration_Literal 55
943+ #define E_Function 56
944+ #define E_Operator 57
945+ #define E_Procedure 58
946+ #define E_Entry 59
947+ #define E_Entry_Family 60
948+ #define E_Block 61
949+ #define E_Entry_Index_Parameter 62
950+ #define E_Exception 63
951+ #define E_Generic_Function 64
952+ #define E_Generic_Procedure 65
953+ #define E_Generic_Package 66
954+ #define E_Label 67
955+ #define E_Loop 68
956+ #define E_Package 69
957+ #define E_Package_Body 70
958+ #define E_Protected_Object 71
959+ #define E_Protected_Body 72
960+ #define E_Task_Body 73
961+ #define E_Subprogram_Body 74
962+
963+ SUBTYPE (Access_Kind, Entity_Kind,
964+ E_Access_Type, E_Anonymous_Access_Type)
965+
966+ SUBTYPE (Array_Kind, Entity_Kind,
967+ E_Array_Type, E_String_Literal_Subtype)
968+
969+ SUBTYPE (Class_Wide_Kind, Entity_Kind,
970+ E_Class_Wide_Type, E_Class_Wide_Subtype)
971+
972+ SUBTYPE (Composite_Kind, Entity_Kind,
973+ E_Array_Type, E_Protected_Subtype)
974+
975+ SUBTYPE (Concurrent_Kind, Entity_Kind,
976+ E_Task_Type, E_Protected_Subtype)
977+
978+ SUBTYPE (Concurrent_Body_Kind, Entity_Kind,
979+ E_Protected_Body, E_Task_Body)
980+
981+ SUBTYPE (Decimal_Fixed_Point_Kind, Entity_Kind,
982+ E_Decimal_Fixed_Point_Type, E_Decimal_Fixed_Point_Subtype)
983+
984+ SUBTYPE (Digits_Kind, Entity_Kind,
985+ E_Decimal_Fixed_Point_Type, E_Floating_Point_Subtype)
986+
987+ SUBTYPE (Discrete_Kind, Entity_Kind,
988+ E_Enumeration_Type, E_Modular_Integer_Subtype)
989+
990+ SUBTYPE (Discrete_Or_Fixed_Point_Kind, Entity_Kind,
991+ E_Enumeration_Type, E_Decimal_Fixed_Point_Subtype)
992+
993+ SUBTYPE (Elementary_Kind, Entity_Kind,
994+ E_Enumeration_Type, E_Anonymous_Access_Type)
995+
996+ SUBTYPE (Enumeration_Kind, Entity_Kind,
997+ E_Enumeration_Type, E_Enumeration_Subtype)
998+
999+ SUBTYPE (Entry_Kind, Entity_Kind,
1000+ E_Entry, E_Entry_Family)
1001+
1002+ SUBTYPE (Fixed_Point_Kind, Entity_Kind,
1003+ E_Ordinary_Fixed_Point_Type, E_Decimal_Fixed_Point_Subtype)
1004+
1005+ SUBTYPE (Float_Kind, Entity_Kind,
1006+ E_Floating_Point_Type, E_Floating_Point_Subtype)
1007+
1008+ SUBTYPE (Formal_Kind, Entity_Kind,
1009+ E_In_Parameter, E_In_Out_Parameter)
1010+
1011+ SUBTYPE (Generic_Subprogram_Kind, Entity_Kind,
1012+ E_Generic_Function, E_Generic_Procedure)
1013+
1014+ SUBTYPE (Generic_Unit_Kind, Entity_Kind,
1015+ E_Generic_Function, E_Generic_Package)
1016+
1017+ SUBTYPE (Incomplete_Or_Private_Kind, Entity_Kind,
1018+ E_Record_Type_With_Private, E_Incomplete_Type)
1019+
1020+ SUBTYPE (Integer_Kind, Entity_Kind,
1021+ E_Signed_Integer_Type, E_Modular_Integer_Subtype)
1022+
1023+ SUBTYPE (Modular_Integer_Kind, Entity_Kind,
1024+ E_Modular_Integer_Type, E_Modular_Integer_Subtype)
1025+
1026+ SUBTYPE (Named_Kind, Entity_Kind,
1027+ E_Named_Integer, E_Named_Real)
1028+
1029+ SUBTYPE (Numeric_Kind, Entity_Kind,
1030+ E_Signed_Integer_Type, E_Floating_Point_Subtype)
1031+
1032+ SUBTYPE (Object_Kind, Entity_Kind,
1033+ E_Variable, E_Generic_In_Parameter)
1034+
1035+ SUBTYPE (Ordinary_Fixed_Point_Kind, Entity_Kind,
1036+ E_Ordinary_Fixed_Point_Type, E_Ordinary_Fixed_Point_Subtype)
1037+
1038+ SUBTYPE (Overloadable_Kind, Entity_Kind,
1039+ E_Enumeration_Literal, E_Entry)
1040+
1041+ SUBTYPE (Private_Kind, Entity_Kind,
1042+ E_Record_Type_With_Private, E_Limited_Private_Subtype)
1043+
1044+ SUBTYPE (Protected_Kind, Entity_Kind,
1045+ E_Protected_Type, E_Protected_Subtype)
1046+
1047+ SUBTYPE (Real_Kind, Entity_Kind,
1048+ E_Ordinary_Fixed_Point_Type, E_Floating_Point_Subtype)
1049+
1050+ SUBTYPE (Record_Kind, Entity_Kind,
1051+ E_Class_Wide_Type, E_Record_Subtype_With_Private)
1052+
1053+ SUBTYPE (Scalar_Kind, Entity_Kind,
1054+ E_Enumeration_Type, E_Floating_Point_Subtype)
1055+
1056+ SUBTYPE (String_Kind, Entity_Kind,
1057+ E_String_Type, E_String_Literal_Subtype)
1058+
1059+ SUBTYPE (Subprogram_Kind, Entity_Kind,
1060+ E_Function, E_Procedure)
1061+
1062+ SUBTYPE (Signed_Integer_Kind, Entity_Kind,
1063+ E_Signed_Integer_Type, E_Signed_Integer_Subtype)
1064+
1065+ SUBTYPE (Task_Kind, Entity_Kind,
1066+ E_Task_Type, E_Task_Subtype)
1067+
1068+ SUBTYPE (Type_Kind, Entity_Kind,
1069+ E_Enumeration_Type, E_Subprogram_Type)
1070+
1071+ typedef char Component_Alignment_Kind;
1072+ #define Calign_Default 0
1073+ #define Calign_Component_Size 1
1074+ #define Calign_Component_Size_4 2
1075+ #define Calign_Storage_Unit 3
1076+
1077+ typedef Boolean B;
1078+ typedef Component_Alignment_Kind C;
1079+ typedef Entity_Id E;
1080+ typedef Mechanism_Type M;
1081+ typedef Node_Id N;
1082+ typedef Uint U;
1083+ typedef Ureal R;
1084+ typedef Elist_Id L;
1085+ typedef List_Id S;
1086+
1087+ INLINE L Accept_Address (E Id);
1088+ INLINE E Access_Disp_Table (E Id);
1089+ INLINE E Actual_Subtype (E Id);
1090+ INLINE B Address_Taken (E Id);
1091+ INLINE E Alias (E Id);
1092+ INLINE U Alignment (E Id);
1093+ INLINE E Associated_Final_Chain (E Id);
1094+ INLINE E Associated_Formal_Package (E Id);
1095+ INLINE N Associated_Node_For_Itype (E Id);
1096+ INLINE E Associated_Storage_Pool (E Id);
1097+ INLINE N Barrier_Function (E Id);
1098+ INLINE N Block_Node (E Id);
1099+ INLINE E Body_Entity (E Id);
1100+ INLINE B Body_Needed_For_SAL (E Id);
1101+ INLINE E CR_Discriminant (E Id);
1102+ INLINE B C_Pass_By_Copy (E Id);
1103+ INLINE B Can_Never_Be_Null (E Id);
1104+ INLINE B Checks_May_Be_Suppressed (E Id);
1105+ INLINE E Class_Wide_Type (E Id);
1106+ INLINE E Cloned_Subtype (E Id);
1107+
1108+ #define Component_Alignment einfo__component_alignment
1109+ C Component_Alignment (E Id);
1110+
1111+ INLINE N Component_Clause (E Id);
1112+ INLINE U Component_Bit_Offset (E Id);
1113+ INLINE U Component_Size (E Id);
1114+ INLINE E Component_Type (E Id);
1115+ INLINE E Corresponding_Concurrent_Type (E Id);
1116+ INLINE E Corresponding_Discriminant (E Id);
1117+ INLINE E Corresponding_Equality (E Id);
1118+ INLINE E Corresponding_Record_Type (E Id);
1119+ INLINE E Corresponding_Remote_Type (E Id);
1120+ INLINE N Current_Value (E Id);
1121+ INLINE B Debug_Info_Off (E Id);
1122+ INLINE E Debug_Renaming_Link (E Id);
1123+ INLINE E DTC_Entity (E Id);
1124+ INLINE U DT_Entry_Count (E Id);
1125+ INLINE U DT_Position (E Id);
1126+ INLINE E Default_Expr_Function (E Id);
1127+ INLINE B Default_Expressions_Processed (E Id);
1128+ INLINE N Default_Value (E Id);
1129+ INLINE B Delay_Cleanups (E Id);
1130+ INLINE B Delay_Subprogram_Descriptors (E Id);
1131+ INLINE R Delta_Value (E Id);
1132+ INLINE L Dependent_Instances (E Id);
1133+ INLINE B Depends_On_Private (E Id);
1134+ INLINE U Digits_Value (E Id);
1135+ INLINE E Directly_Designated_Type (E Id);
1136+ INLINE B Discard_Names (E Id);
1137+ INLINE E Discriminal (E Id);
1138+ INLINE E Discriminal_Link (E Id);
1139+ INLINE E Discriminant_Checking_Func (E Id);
1140+ INLINE L Discriminant_Constraint (E Id);
1141+ INLINE N Discriminant_Default_Value (E Id);
1142+ INLINE U Discriminant_Number (E Id);
1143+ INLINE B Elaborate_All_Desirable (E Id);
1144+ INLINE E Elaboration_Entity (E Id);
1145+ INLINE B Elaboration_Entity_Required (E Id);
1146+ INLINE E Enclosing_Scope (E Id);
1147+ INLINE B Entry_Accepted (E Id);
1148+ INLINE E Entry_Bodies_Array (E Id);
1149+ INLINE E Entry_Cancel_Parameter (E Id);
1150+ INLINE E Entry_Component (E Id);
1151+ INLINE E Entry_Formal (E Id);
1152+ INLINE E Entry_Index_Constant (E Id);
1153+ INLINE E Entry_Index_Type (E Id);
1154+ INLINE E Entry_Parameters_Type (E Id);
1155+ INLINE E Enum_Pos_To_Rep (E Id);
1156+ INLINE U Enumeration_Pos (E Id);
1157+ INLINE U Enumeration_Rep (E Id);
1158+ INLINE N Enumeration_Rep_Expr (E Id);
1159+ INLINE E Equivalent_Type (E Id);
1160+ INLINE U Esize (E Id);
1161+ INLINE U Exception_Code (E Id);
1162+ INLINE E Extra_Accessibility (E Id);
1163+ INLINE E Extra_Constrained (E Id);
1164+ INLINE E Extra_Formal (E Id);
1165+ INLINE E Finalization_Chain_Entity (E Id);
1166+
1167+ #define Finalize_Storage_Only einfo__finalize_storage_only
1168+ B Finalize_Storage_Only (E Id);
1169+
1170+ INLINE E First_Entity (E Id);
1171+ INLINE N First_Index (E Id);
1172+ INLINE E First_Literal (E Id);
1173+ INLINE E First_Optional_Parameter (E Id);
1174+ INLINE E First_Private_Entity (E Id);
1175+ INLINE N First_Rep_Item (E Id);
1176+ INLINE N Freeze_Node (E Id);
1177+ INLINE B From_With_Type (E Id);
1178+ INLINE E Full_View (E Id);
1179+ INLINE B Function_Returns_With_DSP (E Id);
1180+ INLINE E Generic_Homonym (E Id);
1181+ INLINE L Generic_Renamings (E Id);
1182+ INLINE S Handler_Records (E Id);
1183+ INLINE B Has_Aliased_Components (E Id);
1184+ INLINE B Has_Alignment_Clause (E Id);
1185+ INLINE B Has_All_Calls_Remote (E Id);
1186+ INLINE B Has_Atomic_Components (E Id);
1187+ INLINE B Has_Biased_Representation (E Id);
1188+ INLINE B Has_Completion (E Id);
1189+ INLINE B Has_Completion_In_Body (E Id);
1190+ INLINE B Has_Complex_Representation (E Id);
1191+ INLINE B Has_Component_Size_Clause (E Id);
1192+ INLINE B Has_Contiguous_Rep (E Id);
1193+ INLINE B Has_Controlled_Component (E Id);
1194+ INLINE B Has_Controlling_Result (E Id);
1195+ INLINE B Has_Convention_Pragma (E Id);
1196+ INLINE B Has_Delayed_Freeze (E Id);
1197+ INLINE B Has_Discriminants (E Id);
1198+ INLINE B Has_Enumeration_Rep_Clause (E Id);
1199+ INLINE B Has_Exit (E Id);
1200+ INLINE B Has_External_Tag_Rep_Clause (E Id);
1201+ INLINE B Has_Fully_Qualified_Name (E Id);
1202+ INLINE B Has_Gigi_Rep_Item (E Id);
1203+ INLINE B Has_Homonym (E Id);
1204+
1205+ #define Has_Interrupt_Handler einfo__has_interrupt_handler
1206+ B Has_Interrupt_Handler (E Id);
1207+
1208+ INLINE B Has_Machine_Radix_Clause (E Id);
1209+ INLINE B Has_Master_Entity (E Id);
1210+ INLINE B Has_Missing_Return (E Id);
1211+ INLINE B Has_Nested_Block_With_Handler (E Id);
1212+ INLINE B Has_Forward_Instantiation (E Id);
1213+ INLINE B Has_Non_Standard_Rep (E Id);
1214+ INLINE B Has_Object_Size_Clause (E Id);
1215+ INLINE B Has_Per_Object_Constraint (E Id);
1216+ INLINE B Has_Pragma_Controlled (E Id);
1217+ INLINE B Has_Pragma_Elaborate_Body (E Id);
1218+ INLINE B Has_Pragma_Inline (E Id);
1219+ INLINE B Has_Pragma_Pack (E Id);
1220+ INLINE B Has_Pragma_Pure_Function (E Id);
1221+ INLINE B Has_Pragma_Unreferenced (E Id);
1222+ INLINE B Has_Primitive_Operations (E Id);
1223+ INLINE B Has_Qualified_Name (E Id);
1224+ INLINE B Has_Record_Rep_Clause (E Id);
1225+ INLINE B Has_Recursive_Call (E Id);
1226+ INLINE B Has_Size_Clause (E Id);
1227+ INLINE B Has_Small_Clause (E Id);
1228+ INLINE B Has_Specified_Layout (E Id);
1229+ INLINE B Has_Storage_Size_Clause (E Id);
1230+ INLINE B Has_Subprogram_Descriptor (E Id);
1231+ INLINE B Has_Task (E Id);
1232+ INLINE B Has_Unchecked_Union (E Id);
1233+ INLINE B Has_Unknown_Discriminants (E Id);
1234+ INLINE B Has_Volatile_Components (E Id);
1235+ INLINE B Has_Xref_Entry (E Id);
1236+ INLINE E Hiding_Loop_Variable (E Id);
1237+ INLINE E Homonym (E Id);
1238+ INLINE B In_Package_Body (E Id);
1239+ INLINE B In_Private_Part (E Id);
1240+ INLINE B In_Use (E Id);
1241+ INLINE L Inner_Instances (E Id);
1242+ INLINE N Interface_Name (E Id);
1243+ INLINE B Is_AST_Entry (E Id);
1244+ INLINE B Is_Abstract (E Id);
1245+ INLINE B Is_Access_Constant (E Id);
1246+ INLINE B Is_Aliased (E Id);
1247+ INLINE B Is_Asynchronous (E Id);
1248+ INLINE B Is_Atomic (E Id);
1249+ INLINE B Is_Bit_Packed_Array (E Id);
1250+ INLINE B Is_CPP_Class (E Id);
1251+ INLINE B Is_Called (E Id);
1252+ INLINE B Is_Character_Type (E Id);
1253+ INLINE B Is_Child_Unit (E Id);
1254+ INLINE B Is_Class_Wide_Equivalent_Type (E Id);
1255+ INLINE B Is_Compilation_Unit (E Id);
1256+ INLINE B Is_Completely_Hidden (E Id);
1257+ INLINE B Is_Constr_Subt_For_UN_Aliased (E Id);
1258+ INLINE B Is_Constr_Subt_For_U_Nominal (E Id);
1259+ INLINE B Is_Constrained (E Id);
1260+ INLINE B Is_Constructor (E Id);
1261+ INLINE B Is_Controlled (E Id);
1262+ INLINE B Is_Controlling_Formal (E Id);
1263+ INLINE B Is_Discrim_SO_Function (E Id);
1264+ INLINE B Is_Dispatching_Operation (E Id);
1265+ INLINE B Is_Eliminated (E Id);
1266+ INLINE B Is_Entry_Formal (E Id);
1267+ INLINE B Is_Exported (E Id);
1268+ INLINE B Is_First_Subtype (E Id);
1269+ INLINE B Is_For_Access_Subtype (E Id);
1270+ INLINE B Is_Frozen (E Id);
1271+ INLINE B Is_Generic_Instance (E Id);
1272+ INLINE B Is_Hidden (E Id);
1273+ INLINE B Is_Hidden_Open_Scope (E Id);
1274+ INLINE B Is_Immediately_Visible (E Id);
1275+ INLINE B Is_Imported (E Id);
1276+ INLINE B Is_Inlined (E Id);
1277+ INLINE B Is_Instantiated (E Id);
1278+ INLINE B Is_Internal (E Id);
1279+ INLINE B Is_Interrupt_Handler (E Id);
1280+ INLINE B Is_Intrinsic_Subprogram (E Id);
1281+ INLINE B Is_Itype (E Id);
1282+ INLINE B Is_Known_Non_Null (E Id);
1283+ INLINE B Is_Known_Valid (E Id);
1284+ INLINE B Is_Limited_Composite (E Id);
1285+ INLINE B Is_Machine_Code_Subprogram (E Id);
1286+ INLINE B Is_Non_Static_Subtype (E Id);
1287+ INLINE B Is_Null_Init_Proc (E Id);
1288+ INLINE B Is_Optional_Parameter (E Id);
1289+ INLINE B Is_Package_Body_Entity (E Id);
1290+ INLINE B Is_Packed (E Id);
1291+ INLINE B Is_Packed_Array_Type (E Id);
1292+ INLINE B Is_Potentially_Use_Visible (E Id);
1293+ INLINE B Is_Preelaborated (E Id);
1294+ INLINE B Is_Private_Composite (E Id);
1295+ INLINE B Is_Private_Descendant (E Id);
1296+ INLINE B Is_Psected (E Id);
1297+ INLINE B Is_Public (E Id);
1298+ INLINE B Is_Pure (E Id);
1299+ INLINE B Is_Remote_Call_Interface (E Id);
1300+ INLINE B Is_Remote_Types (E Id);
1301+ INLINE B Is_Renaming_Of_Object (E Id);
1302+ INLINE B Is_Shared_Passive (E Id);
1303+ INLINE B Is_Statically_Allocated (E Id);
1304+ INLINE B Is_Tag (E Id);
1305+ INLINE B Is_Tagged_Type (E Id);
1306+ INLINE B Is_Thread_Body (E Id);
1307+ INLINE B Is_True_Constant (E Id);
1308+ INLINE B Is_Unchecked_Union (E Id);
1309+ INLINE B Is_Unsigned_Type (E Id);
1310+ INLINE B Is_VMS_Exception (E Id);
1311+ INLINE B Is_Valued_Procedure (E Id);
1312+ INLINE B Is_Visible_Child_Unit (E Id);
1313+
1314+ #define Is_Volatile einfo__is_volatile
1315+ B Is_Volatile (E Id);
1316+
1317+ #define Is_Wrapper_Package einfo__is_wrapper_package
1318+ B Is_Wrapper_Package (E Id);
1319+
1320+ INLINE B Kill_Elaboration_Checks (E Id);
1321+ INLINE B Kill_Range_Checks (E Id);
1322+ INLINE B Kill_Tag_Checks (E Id);
1323+ INLINE E Last_Entity (E Id);
1324+ INLINE L Limited_Views (E Id);
1325+ INLINE E Lit_Indexes (E Id);
1326+ INLINE E Lit_Strings (E Id);
1327+ INLINE B Machine_Radix_10 (E Id);
1328+ INLINE E Master_Id (E Id);
1329+ INLINE B Materialize_Entity (E Id);
1330+ INLINE M Mechanism (E Id);
1331+ INLINE U Modulus (E Id);
1332+ INLINE B Needs_Debug_Info (E Id);
1333+ INLINE B Needs_No_Actuals (E Id);
1334+ INLINE B Never_Set_In_Source (E Id);
1335+ INLINE E Next_Inlined_Subprogram (E Id);
1336+ INLINE B No_Pool_Assigned (E Id);
1337+ INLINE B No_Return (E Id);
1338+ INLINE B Non_Binary_Modulus (E Id);
1339+ INLINE E Non_Limited_View (E Id);
1340+ INLINE B Nonzero_Is_True (E Id);
1341+ INLINE U Normalized_First_Bit (E Id);
1342+ INLINE U Normalized_Position (E Id);
1343+ INLINE U Normalized_Position_Max (E Id);
1344+ INLINE E Object_Ref (E Id);
1345+ INLINE E Original_Array_Type (E Id);
1346+ INLINE E Original_Record_Component (E Id);
1347+ INLINE E Packed_Array_Type (E Id);
1348+ INLINE E Parent_Subtype (E Id);
1349+ INLINE L Primitive_Operations (E Id);
1350+ INLINE E Prival (E Id);
1351+ INLINE L Privals_Chain (E Id);
1352+ INLINE L Private_Dependents (E Id);
1353+ INLINE N Private_View (E Id);
1354+ INLINE E Protected_Body_Subprogram (E Id);
1355+ INLINE E Protected_Formal (E Id);
1356+ INLINE E Protected_Operation (E Id);
1357+ INLINE U RM_Size (E Id);
1358+ INLINE B Reachable (E Id);
1359+ INLINE B Referenced (E Id);
1360+ INLINE B Referenced_As_LHS (E Id);
1361+ INLINE N Referenced_Object (E Id);
1362+ INLINE N Register_Exception_Call (E Id);
1363+ INLINE E Related_Array_Object (E Id);
1364+ INLINE E Related_Instance (E Id);
1365+ INLINE N Renamed_Entity (E Id);
1366+ INLINE N Renamed_Object (E Id);
1367+ INLINE U Renaming_Map (E Id);
1368+ INLINE B Return_Present (E Id);
1369+ INLINE B Returns_By_Ref (E Id);
1370+ INLINE B Reverse_Bit_Order (E Id);
1371+ INLINE N Scalar_Range (E Id);
1372+ INLINE U Scale_Value (E Id);
1373+ INLINE U Scope_Depth_Value (E Id);
1374+ INLINE B Sec_Stack_Needed_For_Return (E Id);
1375+ INLINE S Shadow_Entities (E Id);
1376+ INLINE E Shared_Var_Assign_Proc (E Id);
1377+ INLINE E Shared_Var_Read_Proc (E Id);
1378+ INLINE N Size_Check_Code (E Id);
1379+ INLINE B Size_Known_At_Compile_Time (E Id);
1380+ INLINE B Size_Depends_On_Discriminant (E Id);
1381+ INLINE R Small_Value (E Id);
1382+ INLINE E Spec_Entity (E Id);
1383+ INLINE E Storage_Size_Variable (E Id);
1384+ INLINE L Stored_Constraint (E Id);
1385+ INLINE B Strict_Alignment (E Id);
1386+ INLINE U String_Literal_Length (E Id);
1387+ INLINE N String_Literal_Low_Bound (E Id);
1388+ INLINE B Suppress_Elaboration_Warnings (E Id);
1389+ INLINE B Suppress_Init_Proc (E Id);
1390+ INLINE B Suppress_Style_Checks (E Id);
1391+ INLINE B Treat_As_Volatile (E Id);
1392+ INLINE E Underlying_Full_View (E Id);
1393+ INLINE N Unset_Reference (E Id);
1394+ INLINE B Uses_Sec_Stack (E Id);
1395+ INLINE B Vax_Float (E Id);
1396+ INLINE B Warnings_Off (E Id);
1397+ INLINE B Is_Access_Type (E Id);
1398+ INLINE B Is_Array_Type (E Id);
1399+ INLINE B Is_Class_Wide_Type (E Id);
1400+ INLINE B Is_Composite_Type (E Id);
1401+ INLINE B Is_Concurrent_Body (E Id);
1402+ INLINE B Is_Concurrent_Record_Type (E Id);
1403+ INLINE B Is_Concurrent_Type (E Id);
1404+ INLINE B Is_Decimal_Fixed_Point_Type (E Id);
1405+ INLINE B Is_Digits_Type (E Id);
1406+ INLINE B Is_Discrete_Or_Fixed_Point_Type (E Id);
1407+ INLINE B Is_Discrete_Type (E Id);
1408+ INLINE B Is_Elementary_Type (E Id);
1409+ INLINE B Is_Entry (E Id);
1410+ INLINE B Is_Enumeration_Type (E Id);
1411+ INLINE B Is_Fixed_Point_Type (E Id);
1412+ INLINE B Is_Floating_Point_Type (E Id);
1413+ INLINE B Is_Formal (E Id);
1414+ INLINE B Is_Formal_Subprogram (E Id);
1415+ INLINE B Is_Generic_Actual_Type (E Id);
1416+ INLINE B Is_Generic_Unit (E Id);
1417+ INLINE B Is_Generic_Type (E Id);
1418+ INLINE B Is_Generic_Subprogram (E Id);
1419+ INLINE B Is_Incomplete_Or_Private_Type (E Id);
1420+ INLINE B Is_Integer_Type (E Id);
1421+ INLINE B Is_Limited_Record (E Id);
1422+ INLINE B Is_Modular_Integer_Type (E Id);
1423+ INLINE B Is_Named_Number (E Id);
1424+ INLINE B Is_Numeric_Type (E Id);
1425+ INLINE B Is_Object (E Id);
1426+ INLINE B Is_Ordinary_Fixed_Point_Type (E Id);
1427+ INLINE B Is_Overloadable (E Id);
1428+ INLINE B Is_Overriding_Operation (E Id);
1429+ INLINE B Is_Private_Type (E Id);
1430+ INLINE B Is_Protected_Type (E Id);
1431+ INLINE B Is_Real_Type (E Id);
1432+ INLINE B Is_Record_Type (E Id);
1433+ INLINE B Is_Scalar_Type (E Id);
1434+ INLINE B Is_Signed_Integer_Type (E Id);
1435+ INLINE B Is_Subprogram (E Id);
1436+ INLINE B Is_Task_Type (E Id);
1437+ INLINE B Is_Type (E Id);
1438+
1439+ #define Address_Clause einfo__address_clause
1440+ N Address_Clause (E Id);
1441+
1442+ #define Alignment_Clause einfo__alignment_clause
1443+ N Alignment_Clause (E Id);
1444+
1445+ #define Ancestor_Subtype einfo__ancestor_subtype
1446+ E Ancestor_Subtype (E Id);
1447+
1448+ #define Base_Type einfo__base_type
1449+ E Base_Type (E Id);
1450+
1451+ #define Constant_Value einfo__constant_value
1452+ N Constant_Value (E Id);
1453+
1454+ #define Declaration_Node einfo__declaration_node
1455+ N Declaration_Node (E Id);
1456+
1457+ #define Designated_Type einfo__designated_type
1458+ E Designated_Type (E Id);
1459+
1460+ #define Enclosing_Dynamic_Scope einfo__enclosing_dynamic_scope
1461+ E Enclosing_Dynamic_Scope (E Id);
1462+
1463+ #define First_Component einfo__first_component
1464+ E First_Component (E Id);
1465+
1466+ #define First_Discriminant einfo__first_discriminant
1467+ E First_Discriminant (E Id);
1468+
1469+ #define First_Formal einfo__first_formal
1470+ E First_Formal (E Id);
1471+
1472+ #define First_Stored_Discriminant einfo__first_stored_discriminant
1473+ E First_Stored_Discriminant (E Id);
1474+
1475+ #define First_Subtype einfo__first_subtype
1476+ E First_Subtype (E Id);
1477+
1478+ #define Has_Attach_Handler einfo__has_attach_handler
1479+ B Has_Attach_Handler (E Id);
1480+
1481+ #define Has_Entries einfo__has_entries
1482+ B Has_Entries (E Id);
1483+
1484+ #define Has_Foreign_Convention einfo__has_foreign_convention
1485+ B Has_Foreign_Convention (E Id);
1486+
1487+ #define Has_Private_Ancestor einfo__has_private_ancestor
1488+ B Has_Private_Ancestor (E Id);
1489+
1490+ INLINE B Has_Private_Declaration (E Id);
1491+
1492+ #define Implementation_Base_Type einfo__implementation_base_type
1493+ E Implementation_Base_Type (E Id);
1494+
1495+ #define Is_Always_Inlined einfo__is_always_inlined
1496+ B Is_Always_Inlined (E Id);
1497+
1498+ #define Is_Boolean_Type einfo__is_boolean_type
1499+ B Is_Boolean_Type (E Id);
1500+
1501+ #define Is_By_Copy_Type einfo__is_by_copy_type
1502+ B Is_By_Copy_Type (E Id);
1503+
1504+ #define Is_By_Reference_Type einfo__is_by_reference_type
1505+ B Is_By_Reference_Type (E Id);
1506+
1507+ #define Is_Derived_Type einfo__is_derived_type
1508+ B Is_Derived_Type (E Id);
1509+
1510+ #define Is_Dynamic_Scope einfo__is_dynamic_scope
1511+ B Is_Dynamic_Scope (E Id);
1512+
1513+ #define Is_Indefinite_Subtype einfo__is_indefinite_subtype
1514+ B Is_Indefinite_Subtype (E Id);
1515+
1516+ #define Is_Limited_Type einfo__is_limited_type
1517+ B Is_Limited_Type (E Id);
1518+
1519+ #define Is_Package einfo__is_package
1520+ B Is_Package (E Id);
1521+
1522+ #define Is_Protected_Private einfo__is_protected_private
1523+ B Is_Protected_Private (E Id);
1524+
1525+ #define Is_Protected_Record_Type einfo__is_protected_record_type
1526+ B Is_Protected_Record_Type (E Id);
1527+
1528+ #define Is_Return_By_Reference_Type einfo__is_return_by_reference_type
1529+ B Is_Return_By_Reference_Type (E Id);
1530+
1531+ #define Is_String_Type einfo__is_string_type
1532+ B Is_String_Type (E Id);
1533+
1534+ #define Is_Task_Record_Type einfo__is_task_record_type
1535+ B Is_Task_Record_Type (E Id);
1536+
1537+ #define Next_Component einfo__next_component
1538+ E Next_Component (E Id);
1539+
1540+ #define Next_Discriminant einfo__next_discriminant
1541+ E Next_Discriminant (E Id);
1542+
1543+ #define Next_Formal einfo__next_formal
1544+ E Next_Formal (E Id);
1545+
1546+ #define Next_Formal_With_Extras einfo__next_formal_with_extras
1547+ E Next_Formal_With_Extras (E Id);
1548+
1549+ INLINE E Next_Literal (E Id);
1550+
1551+ #define Next_Stored_Discriminant einfo__next_stored_discriminant
1552+ E Next_Stored_Discriminant (E Id);
1553+
1554+ #define Number_Dimensions einfo__number_dimensions
1555+ Pos Number_Dimensions (E Id);
1556+
1557+ #define Number_Discriminants einfo__number_discriminants
1558+ Pos Number_Discriminants (E Id);
1559+
1560+ #define Number_Entries einfo__number_entries
1561+ Nat Number_Entries (E Id);
1562+
1563+ #define Number_Formals einfo__number_formals
1564+ Pos Number_Formals (E Id);
1565+
1566+ INLINE Formal_Kind Parameter_Mode (E Id);
1567+
1568+ #define Root_Type einfo__root_type
1569+ E Root_Type (E Id);
1570+
1571+ #define Scope_Depth_Set einfo__scope_depth_set
1572+ B Scope_Depth_Set (E Id);
1573+
1574+ #define Size_Clause einfo__size_clause
1575+ N Size_Clause (E Id);
1576+
1577+ #define Tag_Component einfo__tag_component
1578+ E Tag_Component (E Id);
1579+
1580+ #define Type_High_Bound einfo__type_high_bound
1581+ N Type_High_Bound (E Id);
1582+
1583+ #define Type_Low_Bound einfo__type_low_bound
1584+ N Type_Low_Bound (E Id);
1585+
1586+ #define Underlying_Type einfo__underlying_type
1587+ E Underlying_Type (E Id);
1588+
1589+ #define Known_Alignment einfo__known_alignment
1590+ B Known_Alignment (Entity_Id E);
1591+
1592+ #define Known_Component_Bit_Offset einfo__known_component_bit_offset
1593+ B Known_Component_Bit_Offset (Entity_Id E);
1594+
1595+ #define Known_Component_Size einfo__known_component_size
1596+ B Known_Component_Size (Entity_Id E);
1597+
1598+ #define Known_Esize einfo__known_esize
1599+ B Known_Esize (Entity_Id E);
1600+
1601+ #define Known_Normalized_First_Bit einfo__known_normalized_first_bit
1602+ B Known_Normalized_First_Bit (Entity_Id E);
1603+
1604+ #define Known_Normalized_Position einfo__known_normalized_position
1605+ B Known_Normalized_Position (Entity_Id E);
1606+
1607+ #define Known_Normalized_Position_Max einfo__known_normalized_position_max
1608+ B Known_Normalized_Position_Max (Entity_Id E);
1609+
1610+ #define Known_RM_Size einfo__known_rm_size
1611+ B Known_RM_Size (Entity_Id E);
1612+
1613+ #define Known_Static_Component_Bit_Offset einfo__known_static_component_bit_offset
1614+ B Known_Static_Component_Bit_Offset (Entity_Id E);
1615+
1616+ #define Known_Static_Component_Size einfo__known_static_component_size
1617+ B Known_Static_Component_Size (Entity_Id E);
1618+
1619+ #define Known_Static_Esize einfo__known_static_esize
1620+ B Known_Static_Esize (Entity_Id E);
1621+
1622+ #define Known_Static_Normalized_First_Bit einfo__known_static_normalized_first_bit
1623+ B Known_Static_Normalized_First_Bit (Entity_Id E);
1624+
1625+ #define Known_Static_Normalized_Position einfo__known_static_normalized_position
1626+ B Known_Static_Normalized_Position (Entity_Id E);
1627+
1628+ #define Known_Static_Normalized_Position_Max einfo__known_static_normalized_position_max
1629+ B Known_Static_Normalized_Position_Max (Entity_Id E);
1630+
1631+ #define Known_Static_RM_Size einfo__known_static_rm_size
1632+ B Known_Static_RM_Size (Entity_Id E);
1633+
1634+ #define Unknown_Alignment einfo__unknown_alignment
1635+ B Unknown_Alignment (Entity_Id E);
1636+
1637+ #define Unknown_Component_Bit_Offset einfo__unknown_component_bit_offset
1638+ B Unknown_Component_Bit_Offset (Entity_Id E);
1639+
1640+ #define Unknown_Component_Size einfo__unknown_component_size
1641+ B Unknown_Component_Size (Entity_Id E);
1642+
1643+ #define Unknown_Esize einfo__unknown_esize
1644+ B Unknown_Esize (Entity_Id E);
1645+
1646+ #define Unknown_Normalized_First_Bit einfo__unknown_normalized_first_bit
1647+ B Unknown_Normalized_First_Bit (Entity_Id E);
1648+
1649+ #define Unknown_Normalized_Position einfo__unknown_normalized_position
1650+ B Unknown_Normalized_Position (Entity_Id E);
1651+
1652+ #define Unknown_Normalized_Position_Max einfo__unknown_normalized_position_max
1653+ B Unknown_Normalized_Position_Max (Entity_Id E);
1654+
1655+ #define Unknown_RM_Size einfo__unknown_rm_size
1656+ B Unknown_RM_Size (Entity_Id E);
1657+
1658+
1659+ INLINE L Accept_Address (E Id)
1660+ { return Elist21 (Id); }
1661+
1662+ INLINE E Access_Disp_Table (E Id)
1663+ { return Node16 (Implementation_Base_Type (Id)); }
1664+
1665+ INLINE E Actual_Subtype (E Id)
1666+ { return Node17 (Id); }
1667+
1668+ INLINE B Address_Taken (E Id)
1669+ { return Flag104 (Id); }
1670+
1671+ INLINE E Alias (E Id)
1672+ { return Node18 (Id); }
1673+
1674+ INLINE U Alignment (E Id)
1675+ { return Uint14 (Id); }
1676+
1677+ INLINE E Associated_Final_Chain (E Id)
1678+ { return Node23 (Id); }
1679+
1680+ INLINE E Associated_Formal_Package (E Id)
1681+ { return Node12 (Id); }
1682+
1683+ INLINE N Associated_Node_For_Itype (E Id)
1684+ { return Node8 (Id); }
1685+
1686+ INLINE E Associated_Storage_Pool (E Id)
1687+ { return Node22 (Root_Type (Id)); }
1688+
1689+ INLINE N Barrier_Function (E Id)
1690+ { return Node12 (Id); }
1691+
1692+ INLINE N Block_Node (E Id)
1693+ { return Node11 (Id); }
1694+
1695+ INLINE E Body_Entity (E Id)
1696+ { return Node19 (Id); }
1697+
1698+ INLINE B Body_Needed_For_SAL (E Id)
1699+ { return Flag40 (Id); }
1700+
1701+ INLINE B C_Pass_By_Copy (E Id)
1702+ { return Flag125 (Implementation_Base_Type (Id)); }
1703+
1704+ INLINE B Can_Never_Be_Null (E Id)
1705+ { return Flag38 (Id); }
1706+
1707+ INLINE B Checks_May_Be_Suppressed (E Id)
1708+ { return Flag31 (Id); }
1709+
1710+ INLINE E Class_Wide_Type (E Id)
1711+ { return Node9 (Id); }
1712+
1713+ INLINE E Cloned_Subtype (E Id)
1714+ { return Node16 (Id); }
1715+
1716+ INLINE U Component_Bit_Offset (E Id)
1717+ { return Uint11 (Id); }
1718+
1719+ INLINE N Component_Clause (E Id)
1720+ { return Node13 (Id); }
1721+
1722+ INLINE U Component_Size (E Id)
1723+ { return Uint22 (Implementation_Base_Type (Id)); }
1724+
1725+ INLINE E Component_Type (E Id)
1726+ { return Node20 (Implementation_Base_Type (Id)); }
1727+
1728+ INLINE E Corresponding_Concurrent_Type (E Id)
1729+ { return Node18 (Id); }
1730+
1731+ INLINE E Corresponding_Discriminant (E Id)
1732+ { return Node19 (Id); }
1733+
1734+ INLINE E Corresponding_Equality (E Id)
1735+ { return Node13 (Id); }
1736+
1737+ INLINE E Corresponding_Record_Type (E Id)
1738+ { return Node18 (Id); }
1739+
1740+ INLINE E Corresponding_Remote_Type (E Id)
1741+ { return Node22 (Id); }
1742+
1743+ INLINE N Current_Value (E Id)
1744+ { return Node9 (Id); }
1745+
1746+ INLINE E CR_Discriminant (E Id)
1747+ { return Node23 (Id); }
1748+
1749+ INLINE B Debug_Info_Off (E Id)
1750+ { return Flag166 (Id); }
1751+
1752+ INLINE E Debug_Renaming_Link (E Id)
1753+ { return Node13 (Id); }
1754+
1755+ INLINE E Default_Expr_Function (E Id)
1756+ { return Node21 (Id); }
1757+
1758+ INLINE B Default_Expressions_Processed (E Id)
1759+ { return Flag108 (Id); }
1760+
1761+ INLINE N Default_Value (E Id)
1762+ { return Node20 (Id); }
1763+
1764+ INLINE B Delay_Cleanups (E Id)
1765+ { return Flag114 (Id); }
1766+
1767+ INLINE B Delay_Subprogram_Descriptors (E Id)
1768+ { return Flag50 (Id); }
1769+
1770+ INLINE R Delta_Value (E Id)
1771+ { return Ureal18 (Id); }
1772+
1773+ INLINE L Dependent_Instances (E Id)
1774+ { return Elist8 (Id); }
1775+
1776+ INLINE B Depends_On_Private (E Id)
1777+ { return Flag14 (Id); }
1778+
1779+ INLINE U Digits_Value (E Id)
1780+ { return Uint17 (Id); }
1781+
1782+ INLINE E Directly_Designated_Type (E Id)
1783+ { return Node20 (Id); }
1784+
1785+ INLINE B Discard_Names (E Id)
1786+ { return Flag88 (Id); }
1787+
1788+ INLINE E Discriminal (E Id)
1789+ { return Node17 (Id); }
1790+
1791+ INLINE N Discriminal_Link (E Id)
1792+ { return Node10 (Id); }
1793+
1794+ INLINE E Discriminant_Checking_Func (E Id)
1795+ { return Node20 (Id); }
1796+
1797+ INLINE L Discriminant_Constraint (E Id)
1798+ { return Elist21 (Id); }
1799+
1800+ INLINE N Discriminant_Default_Value (E Id)
1801+ { return Node20 (Id); }
1802+
1803+ INLINE U Discriminant_Number (E Id)
1804+ { return Uint15 (Id); }
1805+
1806+ INLINE U DT_Entry_Count (E Id)
1807+ { return Uint15 (Id); }
1808+
1809+ INLINE U DT_Position (E Id)
1810+ { return Uint15 (Id); }
1811+
1812+ INLINE E DTC_Entity (E Id)
1813+ { return Node16 (Id); }
1814+
1815+ INLINE B Elaborate_All_Desirable (E Id)
1816+ { return Flag146 (Id); }
1817+
1818+ INLINE E Elaboration_Entity (E Id)
1819+ { return Node13 (Id); }
1820+
1821+ INLINE B Elaboration_Entity_Required (E Id)
1822+ { return Flag174 (Id); }
1823+
1824+ INLINE E Enclosing_Scope (E Id)
1825+ { return Node18 (Id); }
1826+
1827+ INLINE B Entry_Accepted (E Id)
1828+ { return Flag152 (Id); }
1829+
1830+ INLINE E Entry_Bodies_Array (E Id)
1831+ { return Node15 (Id); }
1832+
1833+ INLINE E Entry_Cancel_Parameter (E Id)
1834+ { return Node23 (Id); }
1835+
1836+ INLINE E Entry_Component (E Id)
1837+ { return Node11 (Id); }
1838+
1839+ INLINE E Entry_Formal (E Id)
1840+ { return Node16 (Id); }
1841+
1842+ INLINE N Entry_Index_Constant (E Id)
1843+ { return Node18 (Id); }
1844+
1845+ INLINE E Entry_Parameters_Type (E Id)
1846+ { return Node15 (Id); }
1847+
1848+ INLINE E Enum_Pos_To_Rep (E Id)
1849+ { return Node23 (Id); }
1850+
1851+ INLINE Uint Enumeration_Pos (E Id)
1852+ { return Uint11 (Id); }
1853+
1854+ INLINE U Enumeration_Rep (E Id)
1855+ { return Uint12 (Id); }
1856+
1857+ INLINE N Enumeration_Rep_Expr (E Id)
1858+ { return Node22 (Id); }
1859+
1860+ INLINE E Equivalent_Type (E Id)
1861+ { return Node18 (Id); }
1862+
1863+ INLINE Uint Esize (E Id)
1864+ { return Uint12 (Id); }
1865+
1866+ INLINE Uint Exception_Code (E Id)
1867+ { return Uint22 (Id); }
1868+
1869+ INLINE E Extra_Accessibility (E Id)
1870+ { return Node13 (Id); }
1871+
1872+ INLINE E Extra_Constrained (E Id)
1873+ { return Node23 (Id); }
1874+
1875+ INLINE E Extra_Formal (E Id)
1876+ { return Node15 (Id); }
1877+
1878+ INLINE E Finalization_Chain_Entity (E Id)
1879+ { return Node19 (Id); }
1880+
1881+ INLINE E First_Entity (E Id)
1882+ { return Node17 (Id); }
1883+
1884+ INLINE N First_Index (E Id)
1885+ { return Node17 (Id); }
1886+
1887+ INLINE E First_Literal (E Id)
1888+ { return Node17 (Id); }
1889+
1890+ INLINE E First_Optional_Parameter (E Id)
1891+ { return Node14 (Id); }
1892+
1893+ INLINE E First_Private_Entity (E Id)
1894+ { return Node16 (Id); }
1895+
1896+ INLINE E First_Rep_Item (E Id)
1897+ { return Node6 (Id); }
1898+
1899+ INLINE N Freeze_Node (E Id)
1900+ { return Node7 (Id); }
1901+
1902+ INLINE B From_With_Type (E Id)
1903+ { return Flag159 (Id); }
1904+
1905+ INLINE E Full_View (E Id)
1906+ { return Node11 (Id); }
1907+
1908+ INLINE B Function_Returns_With_DSP (E Id)
1909+ { return Flag169 (Id); }
1910+
1911+ INLINE E Generic_Homonym (E Id)
1912+ { return Node11 (Id); }
1913+
1914+ INLINE L Generic_Renamings (E Id)
1915+ { return Elist23 (Id); }
1916+
1917+ INLINE S Handler_Records (E Id)
1918+ { return List10 (Id); }
1919+
1920+ INLINE B Has_Aliased_Components (E Id)
1921+ { return Flag135 (Implementation_Base_Type (Id)); }
1922+
1923+ INLINE B Has_Alignment_Clause (E Id)
1924+ { return Flag46 (Id); }
1925+
1926+ INLINE B Has_All_Calls_Remote (E Id)
1927+ { return Flag79 (Id); }
1928+
1929+ INLINE B Has_Atomic_Components (E Id)
1930+ { return Flag86 (Implementation_Base_Type (Id)); }
1931+
1932+ INLINE B Has_Biased_Representation (E Id)
1933+ { return Flag139 (Id); }
1934+
1935+ INLINE B Has_Completion (E Id)
1936+ { return Flag26 (Id); }
1937+
1938+ INLINE B Has_Completion_In_Body (E Id)
1939+ { return Flag71 (Id); }
1940+
1941+ INLINE B Has_Complex_Representation (E Id)
1942+ { return Flag140 (Implementation_Base_Type (Id)); }
1943+
1944+ INLINE B Has_Component_Size_Clause (E Id)
1945+ { return Flag68 (Implementation_Base_Type (Id)); }
1946+
1947+ INLINE B Has_Controlled_Component (E Id)
1948+ { return Flag43 (Base_Type (Id)); }
1949+
1950+ INLINE B Has_Contiguous_Rep (E Id)
1951+ { return Flag181 (Id); }
1952+
1953+ INLINE B Has_Controlling_Result (E Id)
1954+ { return Flag98 (Id); }
1955+
1956+ INLINE B Has_Convention_Pragma (E Id)
1957+ { return Flag119 (Id); }
1958+
1959+ INLINE B Has_Delayed_Freeze (E Id)
1960+ { return Flag18 (Id); }
1961+
1962+ INLINE B Has_Discriminants (E Id)
1963+ { return Flag5 (Id); }
1964+
1965+ INLINE B Has_Enumeration_Rep_Clause (E Id)
1966+ { return Flag66 (Id); }
1967+
1968+ INLINE B Has_Exit (E Id)
1969+ { return Flag47 (Id); }
1970+
1971+ INLINE B Has_External_Tag_Rep_Clause (E Id)
1972+ { return Flag110 (Id); }
1973+
1974+ INLINE B Has_Forward_Instantiation (E Id)
1975+ { return Flag175 (Id); }
1976+
1977+ INLINE B Has_Fully_Qualified_Name (E Id)
1978+ { return Flag173 (Id); }
1979+
1980+ INLINE B Has_Gigi_Rep_Item (E Id)
1981+ { return Flag82 (Id); }
1982+
1983+ INLINE B Has_Homonym (E Id)
1984+ { return Flag56 (Id); }
1985+
1986+ INLINE B Has_Machine_Radix_Clause (E Id)
1987+ { return Flag83 (Id); }
1988+
1989+ INLINE B Has_Master_Entity (E Id)
1990+ { return Flag21 (Id); }
1991+
1992+ INLINE B Has_Missing_Return (E Id)
1993+ { return Flag142 (Id); }
1994+
1995+ INLINE B Has_Nested_Block_With_Handler (E Id)
1996+ { return Flag101 (Id); }
1997+
1998+ INLINE B Has_Non_Standard_Rep (E Id)
1999+ { return Flag75 (Implementation_Base_Type (Id)); }
2000+
2001+ INLINE B Has_Object_Size_Clause (E Id)
2002+ { return Flag172 (Id); }
2003+
2004+ INLINE B Has_Per_Object_Constraint (E Id)
2005+ { return Flag154 (Id); }
2006+
2007+ INLINE B Has_Pragma_Controlled (E Id)
2008+ { return Flag27 (Implementation_Base_Type (Id)); }
2009+
2010+ INLINE B Has_Pragma_Elaborate_Body (E Id)
2011+ { return Flag150 (Id); }
2012+
2013+ INLINE B Has_Pragma_Inline (E Id)
2014+ { return Flag157 (Id); }
2015+
2016+ INLINE B Has_Pragma_Pack (E Id)
2017+ { return Flag121 (Implementation_Base_Type (Id)); }
2018+
2019+ INLINE B Has_Pragma_Pure_Function (E Id)
2020+ { return Flag179 (Id); }
2021+
2022+ INLINE B Has_Pragma_Unreferenced (E Id)
2023+ { return Flag180 (Id); }
2024+
2025+ INLINE B Has_Primitive_Operations (E Id)
2026+ { return Flag120 (Base_Type (Id)); }
2027+
2028+ INLINE B Has_Private_Declaration (E Id)
2029+ { return Flag155 (Id); }
2030+
2031+ INLINE B Has_Qualified_Name (E Id)
2032+ { return Flag161 (Id); }
2033+
2034+ INLINE B Has_Record_Rep_Clause (E Id)
2035+ { return Flag65 (Implementation_Base_Type (Id)); }
2036+
2037+ INLINE B Has_Recursive_Call (E Id)
2038+ { return Flag143 (Id); }
2039+
2040+ INLINE B Has_Size_Clause (E Id)
2041+ { return Flag29 (Id); }
2042+
2043+ INLINE B Has_Small_Clause (E Id)
2044+ { return Flag67 (Id); }
2045+
2046+ INLINE B Has_Specified_Layout (E Id)
2047+ { return Flag100 (Implementation_Base_Type (Id)); }
2048+
2049+ INLINE B Has_Storage_Size_Clause (E Id)
2050+ { return Flag23 (Implementation_Base_Type (Id)); }
2051+
2052+ INLINE B Has_Subprogram_Descriptor (E Id)
2053+ { return Flag93 (Id); }
2054+
2055+ INLINE B Has_Task (E Id)
2056+ { return Flag30 (Base_Type (Id)); }
2057+
2058+ INLINE B Has_Unchecked_Union (E Id)
2059+ { return Flag123 (Base_Type (Id)); }
2060+
2061+ INLINE B Has_Unknown_Discriminants (E Id)
2062+ { return Flag72 (Id); }
2063+
2064+ INLINE B Has_Volatile_Components (E Id)
2065+ { return Flag87 (Implementation_Base_Type (Id)); }
2066+
2067+ INLINE B Has_Xref_Entry (E Id)
2068+ { return Flag182 (Implementation_Base_Type (Id)); }
2069+
2070+ INLINE E Hiding_Loop_Variable (E Id)
2071+ { return Node8 (Id); }
2072+
2073+ INLINE E Homonym (E Id)
2074+ { return Node4 (Id); }
2075+
2076+ INLINE B In_Package_Body (E Id)
2077+ { return Flag48 (Id); }
2078+
2079+ INLINE B In_Private_Part (E Id)
2080+ { return Flag45 (Id); }
2081+
2082+ INLINE B In_Use (E Id)
2083+ { return Flag8 (Id); }
2084+
2085+ INLINE L Inner_Instances (E Id)
2086+ { return Elist23 (Id); }
2087+
2088+ INLINE N Interface_Name (E Id)
2089+ { return Node21 (Id); }
2090+
2091+ INLINE B Is_Abstract (E Id)
2092+ { return Flag19 (Id); }
2093+
2094+ INLINE B Is_Access_Constant (E Id)
2095+ { return Flag69 (Id); }
2096+
2097+ INLINE B Is_Aliased (E Id)
2098+ { return Flag15 (Id); }
2099+
2100+ INLINE B Is_AST_Entry (E Id)
2101+ { return Flag132 (Id); }
2102+
2103+ INLINE B Is_Asynchronous (E Id)
2104+ { return Flag81 (Id); }
2105+
2106+ INLINE B Is_Atomic (E Id)
2107+ { return Flag85 (Id); }
2108+
2109+ INLINE B Is_Bit_Packed_Array (E Id)
2110+ { return Flag122 (Implementation_Base_Type (Id)); }
2111+
2112+ INLINE B Is_Called (E Id)
2113+ { return Flag102 (Id); }
2114+
2115+ INLINE B Is_Character_Type (E Id)
2116+ { return Flag63 (Id); }
2117+
2118+ INLINE B Is_Child_Unit (E Id)
2119+ { return Flag73 (Id); }
2120+
2121+ INLINE B Is_Class_Wide_Equivalent_Type (E Id)
2122+ { return Flag35 (Id); }
2123+
2124+ INLINE B Is_Compilation_Unit (E Id)
2125+ { return Flag149 (Id); }
2126+
2127+ INLINE B Is_Completely_Hidden (E Id)
2128+ { return Flag103 (Id); }
2129+
2130+ INLINE B Is_Constr_Subt_For_U_Nominal (E Id)
2131+ { return Flag80 (Id); }
2132+
2133+ INLINE B Is_Constr_Subt_For_UN_Aliased (E Id)
2134+ { return Flag141 (Id); }
2135+
2136+ INLINE B Is_Constrained (E Id)
2137+ { return Flag12 (Id); }
2138+
2139+ INLINE B Is_Constructor (E Id)
2140+ { return Flag76 (Id); }
2141+
2142+ INLINE B Is_Controlled (E Id)
2143+ { return Flag42 (Base_Type (Id)); }
2144+
2145+ INLINE B Is_Controlling_Formal (E Id)
2146+ { return Flag97 (Id); }
2147+
2148+ INLINE B Is_CPP_Class (E Id)
2149+ { return Flag74 (Id); }
2150+
2151+ INLINE B Is_Discrim_SO_Function (E Id)
2152+ { return Flag176 (Id); }
2153+
2154+ INLINE B Is_Dispatching_Operation (E Id)
2155+ { return Flag6 (Id); }
2156+
2157+ INLINE B Is_Eliminated (E Id)
2158+ { return Flag124 (Id); }
2159+
2160+ INLINE B Is_Entry_Formal (E Id)
2161+ { return Flag52 (Id); }
2162+
2163+ INLINE B Is_Exported (E Id)
2164+ { return Flag99 (Id); }
2165+
2166+ INLINE B Is_First_Subtype (E Id)
2167+ { return Flag70 (Id); }
2168+
2169+ INLINE B Is_For_Access_Subtype (E Id)
2170+ { return Flag118 (Id); }
2171+
2172+ INLINE B Is_Formal_Subprogram (E Id)
2173+ { return Flag111 (Id); }
2174+
2175+ INLINE B Is_Frozen (E Id)
2176+ { return Flag4 (Id); }
2177+
2178+ INLINE B Is_Generic_Actual_Type (E Id)
2179+ { return Flag94 (Id); }
2180+
2181+ INLINE B Is_Generic_Instance (E Id)
2182+ { return Flag130 (Id); }
2183+
2184+ INLINE B Is_Generic_Type (E Id)
2185+ { return Flag13 (Id); }
2186+
2187+ INLINE B Is_Hidden (E Id)
2188+ { return Flag57 (Id); }
2189+
2190+ INLINE B Is_Hidden_Open_Scope (E Id)
2191+ { return Flag171 (Id); }
2192+
2193+ INLINE B Is_Immediately_Visible (E Id)
2194+ { return Flag7 (Id); }
2195+
2196+ INLINE B Is_Imported (E Id)
2197+ { return Flag24 (Id); }
2198+
2199+ INLINE B Is_Inlined (E Id)
2200+ { return Flag11 (Id); }
2201+
2202+ INLINE B Is_Instantiated (E Id)
2203+ { return Flag126 (Id); }
2204+
2205+ INLINE B Is_Internal (E Id)
2206+ { return Flag17 (Id); }
2207+
2208+ INLINE B Is_Interrupt_Handler (E Id)
2209+ { return Flag89 (Id); }
2210+
2211+ INLINE B Is_Intrinsic_Subprogram (E Id)
2212+ { return Flag64 (Id); }
2213+
2214+ INLINE B Is_Itype (E Id)
2215+ { return Flag91 (Id); }
2216+
2217+ INLINE B Is_Known_Non_Null (E Id)
2218+ { return Flag37 (Id); }
2219+
2220+ INLINE B Is_Known_Valid (E Id)
2221+ { return Flag170 (Id); }
2222+
2223+ INLINE B Is_Limited_Composite (E Id)
2224+ { return Flag106 (Id); }
2225+
2226+ INLINE B Is_Limited_Record (E Id)
2227+ { return Flag25 (Id); }
2228+
2229+ INLINE B Is_Machine_Code_Subprogram (E Id)
2230+ { return Flag137 (Id); }
2231+
2232+ INLINE B Is_Non_Static_Subtype (E Id)
2233+ { return Flag109 (Id); }
2234+
2235+ INLINE B Is_Null_Init_Proc (E Id)
2236+ { return Flag178 (Id); }
2237+
2238+ INLINE B Is_Optional_Parameter (E Id)
2239+ { return Flag134 (Id); }
2240+
2241+ INLINE B Is_Overriding_Operation (E Id)
2242+ { return Flag39 (Id); }
2243+
2244+ INLINE B Is_Package_Body_Entity (E Id)
2245+ { return Flag160 (Id); }
2246+
2247+ INLINE B Is_Packed (E Id)
2248+ { return Flag51 (Implementation_Base_Type (Id)); }
2249+
2250+ INLINE B Is_Packed_Array_Type (E Id)
2251+ { return Flag138 (Id); }
2252+
2253+ INLINE B Is_Potentially_Use_Visible (E Id)
2254+ { return Flag9 (Id); }
2255+
2256+ INLINE B Is_Preelaborated (E Id)
2257+ { return Flag59 (Id); }
2258+
2259+ INLINE B Is_Private_Composite (E Id)
2260+ { return Flag107 (Id); }
2261+
2262+ INLINE B Is_Private_Descendant (E Id)
2263+ { return Flag53 (Id); }
2264+
2265+ INLINE B Is_Psected (E Id)
2266+ { return Flag153 (Id); }
2267+
2268+ INLINE B Is_Public (E Id)
2269+ { return Flag10 (Id); }
2270+
2271+ INLINE B Is_Pure (E Id)
2272+ { return Flag44 (Id); }
2273+
2274+ INLINE B Is_Remote_Call_Interface (E Id)
2275+ { return Flag62 (Id); }
2276+
2277+ INLINE B Is_Remote_Types (E Id)
2278+ { return Flag61 (Id); }
2279+
2280+ INLINE B Is_Renaming_Of_Object (E Id)
2281+ { return Flag112 (Id); }
2282+
2283+ INLINE B Is_Shared_Passive (E Id)
2284+ { return Flag60 (Id); }
2285+
2286+ INLINE B Is_Statically_Allocated (E Id)
2287+ { return Flag28 (Id); }
2288+
2289+ INLINE B Is_Tag (E Id)
2290+ { return Flag78 (Id); }
2291+
2292+ INLINE B Is_Tagged_Type (E Id)
2293+ { return Flag55 (Id); }
2294+
2295+ INLINE B Is_Thread_Body (E Id)
2296+ { return Flag77 (Id); }
2297+
2298+ INLINE B Is_True_Constant (E Id)
2299+ { return Flag163 (Id); }
2300+
2301+ INLINE B Is_Unchecked_Union (E Id)
2302+ { return Flag117 (Id); }
2303+
2304+ INLINE B Is_Unsigned_Type (E Id)
2305+ { return Flag144 (Id); }
2306+
2307+ INLINE B Is_Valued_Procedure (E Id)
2308+ { return Flag127 (Id); }
2309+
2310+ INLINE B Is_Visible_Child_Unit (E Id)
2311+ { return Flag116 (Id); }
2312+
2313+ INLINE B Is_VMS_Exception (E Id)
2314+ { return Flag133 (Id); }
2315+
2316+ INLINE B Kill_Elaboration_Checks (E Id)
2317+ { return Flag32 (Id); }
2318+
2319+ INLINE B Kill_Range_Checks (E Id)
2320+ { return Flag33 (Id); }
2321+
2322+ INLINE B Kill_Tag_Checks (E Id)
2323+ { return Flag34 (Id); }
2324+
2325+ INLINE E Last_Entity (E Id)
2326+ { return Node20 (Id); }
2327+
2328+ INLINE L Limited_Views (E Id)
2329+ { return Elist23 (Id); }
2330+
2331+ INLINE E Lit_Indexes (E Id)
2332+ { return Node15 (Id); }
2333+
2334+ INLINE E Lit_Strings (E Id)
2335+ { return Node16 (Id); }
2336+
2337+ INLINE B Machine_Radix_10 (E Id)
2338+ { return Flag84 (Id); }
2339+
2340+ INLINE E Master_Id (E Id)
2341+ { return Node17 (Id); }
2342+
2343+ INLINE B Materialize_Entity (E Id)
2344+ { return Flag168 (Id); }
2345+
2346+ INLINE M Mechanism (E Id)
2347+ { return UI_To_Int (Uint8 (Id)); }
2348+
2349+ INLINE Uint Modulus (E Id)
2350+ { return Uint17 (Base_Type (Id)); }
2351+
2352+ INLINE B Needs_Debug_Info (E Id)
2353+ { return Flag147 (Id); }
2354+
2355+ INLINE B Needs_No_Actuals (E Id)
2356+ { return Flag22 (Id); }
2357+
2358+ INLINE B Never_Set_In_Source (E Id)
2359+ { return Flag115 (Id); }
2360+
2361+ INLINE E Next_Inlined_Subprogram (E Id)
2362+ { return Node12 (Id); }
2363+
2364+ INLINE B No_Pool_Assigned (E Id)
2365+ { return Flag131 (Root_Type (Id)); }
2366+
2367+ INLINE B No_Return (E Id)
2368+ { return Flag113 (Id); }
2369+
2370+ INLINE B Non_Binary_Modulus (E Id)
2371+ { return Flag58 (Base_Type (Id)); }
2372+
2373+ INLINE E Non_Limited_View (E Id)
2374+ { return Node17 (Id); }
2375+
2376+ INLINE B Nonzero_Is_True (E Id)
2377+ { return Flag162 (Base_Type (Id)); }
2378+
2379+ INLINE U Normalized_First_Bit (E Id)
2380+ { return Uint8 (Id); }
2381+
2382+ INLINE U Normalized_Position (E Id)
2383+ { return Uint14 (Id); }
2384+
2385+ INLINE U Normalized_Position_Max (E Id)
2386+ { return Uint10 (Id); }
2387+
2388+ INLINE E Object_Ref (E Id)
2389+ { return Node17 (Id); }
2390+
2391+ INLINE E Original_Array_Type (E Id)
2392+ { return Node21 (Id); }
2393+
2394+ INLINE E Original_Record_Component (E Id)
2395+ { return Node22 (Id); }
2396+
2397+ INLINE E Packed_Array_Type (E Id)
2398+ { return Node23 (Id); }
2399+
2400+ INLINE E Parent_Subtype (E Id)
2401+ { return Node19 (Id); }
2402+
2403+ INLINE L Primitive_Operations (E Id)
2404+ { return Elist15 (Id); }
2405+
2406+ INLINE E Prival (E Id)
2407+ { return Node17 (Id); }
2408+
2409+ INLINE L Privals_Chain (E Id)
2410+ { return Elist23 (Id); }
2411+
2412+ INLINE L Private_Dependents (E Id)
2413+ { return Elist18 (Id); }
2414+
2415+ INLINE N Private_View (E Id)
2416+ { return Node22 (Id); }
2417+
2418+ INLINE E Protected_Body_Subprogram (E Id)
2419+ { return Node11 (Id); }
2420+
2421+ INLINE E Protected_Formal (E Id)
2422+ { return Node22 (Id); }
2423+
2424+ INLINE N Protected_Operation (E Id)
2425+ { return Node23 (Id); }
2426+
2427+ INLINE B Reachable (E Id)
2428+ { return Flag49 (Id); }
2429+
2430+ INLINE B Referenced (E Id)
2431+ { return Flag156 (Id); }
2432+
2433+ INLINE B Referenced_As_LHS (E Id)
2434+ { return Flag36 (Id); }
2435+
2436+ INLINE N Referenced_Object (E Id)
2437+ { return Node10 (Id); }
2438+
2439+ INLINE N Register_Exception_Call (E Id)
2440+ { return Node20 (Id); }
2441+
2442+ INLINE E Related_Array_Object (E Id)
2443+ { return Node19 (Id); }
2444+
2445+ INLINE E Related_Instance (E Id)
2446+ { return Node15 (Id); }
2447+
2448+ INLINE N Renamed_Entity (E Id)
2449+ { return Node18 (Id); }
2450+
2451+ INLINE N Renamed_Object (E Id)
2452+ { return Node18 (Id); }
2453+
2454+ INLINE U Renaming_Map (E Id)
2455+ { return Uint9 (Id); }
2456+
2457+ INLINE B Return_Present (E Id)
2458+ { return Flag54 (Id); }
2459+
2460+ INLINE B Returns_By_Ref (E Id)
2461+ { return Flag90 (Id); }
2462+
2463+ INLINE B Reverse_Bit_Order (E Id)
2464+ { return Flag164 (Base_Type (Id)); }
2465+
2466+ INLINE U RM_Size (E Id)
2467+ { return Uint13 (Id); }
2468+
2469+ INLINE N Scalar_Range (E Id)
2470+ { return Node20 (Id); }
2471+
2472+ INLINE U Scale_Value (E Id)
2473+ { return Uint15 (Id); }
2474+
2475+ INLINE U Scope_Depth_Value (E Id)
2476+ { return Uint22 (Id); }
2477+
2478+ INLINE B Sec_Stack_Needed_For_Return (E Id)
2479+ { return Flag167 (Id); }
2480+
2481+ INLINE S Shadow_Entities (E Id)
2482+ { return List14 (Id); }
2483+
2484+ INLINE E Shared_Var_Assign_Proc (E Id)
2485+ { return Node22 (Id); }
2486+
2487+ INLINE E Shared_Var_Read_Proc (E Id)
2488+ { return Node15 (Id); }
2489+
2490+ INLINE N Size_Check_Code (E Id)
2491+ { return Node19 (Id); }
2492+
2493+ INLINE B Size_Depends_On_Discriminant (E Id)
2494+ { return Flag177 (Id); }
2495+
2496+ INLINE B Size_Known_At_Compile_Time (E Id)
2497+ { return Flag92 (Id); }
2498+
2499+ INLINE R Small_Value (E Id)
2500+ { return Ureal21 (Id); }
2501+
2502+ INLINE E Spec_Entity (E Id)
2503+ { return Node19 (Id); }
2504+
2505+ INLINE E Storage_Size_Variable (E Id)
2506+ { return Node15 (Implementation_Base_Type (Id)); }
2507+
2508+ INLINE L Stored_Constraint (E Id)
2509+ { return Elist23 (Id); }
2510+
2511+ INLINE B Strict_Alignment (E Id)
2512+ { return Flag145 (Implementation_Base_Type (Id)); }
2513+
2514+ INLINE U String_Literal_Length (E Id)
2515+ { return Uint16 (Id); }
2516+
2517+ INLINE N String_Literal_Low_Bound (E Id)
2518+ { return Node15 (Id); }
2519+
2520+ INLINE B Suppress_Elaboration_Warnings (E Id)
2521+ { return Flag148 (Id); }
2522+
2523+ INLINE B Suppress_Init_Proc (E Id)
2524+ { return Flag105 (Base_Type (Id)); }
2525+
2526+ INLINE B Suppress_Style_Checks (E Id)
2527+ { return Flag165 (Id); }
2528+
2529+ INLINE B Treat_As_Volatile (E Id)
2530+ { return Flag41 (Id); }
2531+
2532+ INLINE E Underlying_Full_View (E Id)
2533+ { return Node19 (Id); }
2534+
2535+ INLINE N Unset_Reference (E Id)
2536+ { return Node16 (Id); }
2537+
2538+ INLINE B Uses_Sec_Stack (E Id)
2539+ { return Flag95 (Id); }
2540+
2541+ INLINE B Vax_Float (E Id)
2542+ { return Flag151 (Base_Type (Id)); }
2543+
2544+ INLINE B Warnings_Off (E Id)
2545+ { return Flag96 (Id); }
2546+
2547+ INLINE B Is_Access_Type (E Id)
2548+ { return IN (Ekind (Id), Access_Kind); }
2549+
2550+ INLINE B Is_Array_Type (E Id)
2551+ { return IN (Ekind (Id), Array_Kind); }
2552+
2553+ INLINE B Is_Class_Wide_Type (E Id)
2554+ { return IN (Ekind (Id), Class_Wide_Kind); }
2555+
2556+ INLINE B Is_Composite_Type (E Id)
2557+ { return IN (Ekind (Id), Composite_Kind); }
2558+
2559+ INLINE B Is_Concurrent_Body (E Id)
2560+ { return IN (Ekind (Id), Concurrent_Body_Kind); }
2561+
2562+ INLINE B Is_Concurrent_Record_Type (E Id)
2563+ { return Flag20 (Id); }
2564+
2565+ INLINE B Is_Concurrent_Type (E Id)
2566+ { return IN (Ekind (Id), Concurrent_Kind); }
2567+
2568+ INLINE B Is_Decimal_Fixed_Point_Type (E Id)
2569+ { return IN (Ekind (Id), Decimal_Fixed_Point_Kind); }
2570+
2571+ INLINE B Is_Digits_Type (E Id)
2572+ { return IN (Ekind (Id), Digits_Kind); }
2573+
2574+ INLINE B Is_Discrete_Or_Fixed_Point_Type (E Id)
2575+ { return IN (Ekind (Id), Discrete_Or_Fixed_Point_Kind); }
2576+
2577+ INLINE B Is_Discrete_Type (E Id)
2578+ { return IN (Ekind (Id), Discrete_Kind); }
2579+
2580+ INLINE B Is_Elementary_Type (E Id)
2581+ { return IN (Ekind (Id), Elementary_Kind); }
2582+
2583+ INLINE B Is_Entry (E Id)
2584+ { return IN (Ekind (Id), Entry_Kind); }
2585+
2586+ INLINE B Is_Enumeration_Type (E Id)
2587+ { return IN (Ekind (Id), Enumeration_Kind); }
2588+
2589+ INLINE B Is_Fixed_Point_Type (E Id)
2590+ { return IN (Ekind (Id), Fixed_Point_Kind); }
2591+
2592+ INLINE B Is_Floating_Point_Type (E Id)
2593+ { return IN (Ekind (Id), Float_Kind); }
2594+
2595+ INLINE B Is_Formal (E Id)
2596+ { return IN (Ekind (Id), Formal_Kind); }
2597+
2598+ INLINE B Is_Generic_Subprogram (E Id)
2599+ { return IN (Ekind (Id), Generic_Subprogram_Kind); }
2600+
2601+ INLINE B Is_Generic_Unit (E Id)
2602+ { return IN (Ekind (Id), Generic_Unit_Kind); }
2603+
2604+ INLINE B Is_Incomplete_Or_Private_Type (E Id)
2605+ { return IN (Ekind (Id), Incomplete_Or_Private_Kind); }
2606+
2607+ INLINE B Is_Integer_Type (E Id)
2608+ { return IN (Ekind (Id), Integer_Kind); }
2609+
2610+ INLINE B Is_Modular_Integer_Type (E Id)
2611+ { return IN (Ekind (Id), Modular_Integer_Kind); }
2612+
2613+ INLINE B Is_Named_Number (E Id)
2614+ { return IN (Ekind (Id), Named_Kind); }
2615+
2616+ INLINE B Is_Numeric_Type (E Id)
2617+ { return IN (Ekind (Id), Numeric_Kind); }
2618+
2619+ INLINE B Is_Object (E Id)
2620+ { return IN (Ekind (Id), Object_Kind); }
2621+
2622+ INLINE B Is_Ordinary_Fixed_Point_Type (E Id)
2623+ { return IN (Ekind (Id), Ordinary_Fixed_Point_Kind); }
2624+
2625+ INLINE B Is_Overloadable (E Id)
2626+ { return IN (Ekind (Id), Overloadable_Kind); }
2627+
2628+ INLINE B Is_Private_Type (E Id)
2629+ { return IN (Ekind (Id), Private_Kind); }
2630+
2631+ INLINE B Is_Protected_Type (E Id)
2632+ { return IN (Ekind (Id), Protected_Kind); }
2633+
2634+ INLINE B Is_Real_Type (E Id)
2635+ { return IN (Ekind (Id), Real_Kind); }
2636+
2637+ INLINE B Is_Record_Type (E Id)
2638+ { return IN (Ekind (Id), Record_Kind); }
2639+
2640+ INLINE B Is_Scalar_Type (E Id)
2641+ { return IN (Ekind (Id), Scalar_Kind); }
2642+
2643+ INLINE B Is_Signed_Integer_Type (E Id)
2644+ { return IN (Ekind (Id), Signed_Integer_Kind); }
2645+
2646+ INLINE B Is_Subprogram (E Id)
2647+ { return IN (Ekind (Id), Subprogram_Kind); }
2648+
2649+ INLINE B Is_Task_Type (E Id)
2650+ { return IN (Ekind (Id), Task_Kind); }
2651+
2652+ INLINE B Is_Type (E Id)
2653+ { return IN (Ekind (Id), Type_Kind); }
2654+
2655+ INLINE N Entry_Index_Type (E Id)
2656+ { return Etype (Discrete_Subtype_Definition (Parent (Id))); }
2657+
2658+ INLINE Node_Id Next_Index (Node_Id Id)
2659+ { return Next (Id); }
2660+
2661+ INLINE E Next_Literal (E Id)
2662+ { return Next (Id); }
2663+
2664+ INLINE Formal_Kind Parameter_Mode (E Id)
2665+ { return Ekind (Id); }
2666+
2667+/* End of einfo.h (C version of Einfo package specification) */
2668--- gcc-3.4.0/obj-amd64-pld-linux/gcc/ada/nmake.adb.orig 1970-01-01 01:00:00.000000000 +0100
2669+++ gcc-3.4.0/obj-amd64-pld-linux/gcc/ada/nmake.adb 2004-06-02 00:52:35.000000000 +0200
2670@@ -0,0 +1,2867 @@
2671+------------------------------------------------------------------------------
2672+-- --
2673+-- GNAT COMPILER COMPONENTS --
2674+-- --
2675+-- N M A K E --
2676+-- --
2677+-- B o d y --
2678+-- --
2679+-- Copyright (C) 1992-2003 Free Software Foundation, Inc. --
2680+-- --
2681+-- GNAT is free software; you can redistribute it and/or modify it under --
2682+-- terms of the GNU General Public License as published by the Free Soft- --
2683+-- ware Foundation; either version 2, or (at your option) any later ver- --
2684+-- sion. GNAT is distributed in the hope that it will be useful, but WITH- --
2685+-- OUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY --
2686+-- or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License --
2687+-- for more details. You should have received a copy of the GNU General --
2688+-- Public License distributed with GNAT; see file COPYING. If not, write --
2689+-- to the Free Software Foundation, 59 Temple Place - Suite 330, Boston, --
2690+-- MA 02111-1307, USA. --
2691+-- --
2692+-- GNAT was originally developed by the GNAT team at New York University. --
2693+-- Extensive contributions were provided by Ada Core Technologies Inc. --
2694+-- --
2695+------------------------------------------------------------------------------
2696+
2697+pragma Style_Checks (All_Checks);
2698+-- Turn off subprogram order checking, since the routines here are
2699+-- generated automatically in order.
2700+
2701+
2702+with Atree; use Atree;
2703+with Sinfo; use Sinfo;
2704+with Snames; use Snames;
2705+with Stand; use Stand;
2706+
2707+package body Nmake is
2708+
2709+ function Make_Unused_At_Start (Sloc : Source_Ptr)
2710+ return Node_Id
2711+ is
2712+ N : constant Node_Id :=
2713+ New_Node (N_Unused_At_Start, Sloc);
2714+ begin
2715+ return N;
2716+ end Make_Unused_At_Start;
2717+
2718+ function Make_Unused_At_End (Sloc : Source_Ptr)
2719+ return Node_Id
2720+ is
2721+ N : constant Node_Id :=
2722+ New_Node (N_Unused_At_End, Sloc);
2723+ begin
2724+ return N;
2725+ end Make_Unused_At_End;
2726+
2727+ function Make_Identifier (Sloc : Source_Ptr;
2728+ Chars : Name_Id)
2729+ return Node_Id
2730+ is
2731+ N : constant Node_Id :=
2732+ New_Node (N_Identifier, Sloc);
2733+ begin
2734+ Set_Chars (N, Chars);
2735+ return N;
2736+ end Make_Identifier;
2737+
2738+ function Make_Integer_Literal (Sloc : Source_Ptr;
2739+ Intval : Uint)
2740+ return Node_Id
2741+ is
2742+ N : constant Node_Id :=
2743+ New_Node (N_Integer_Literal, Sloc);
2744+ begin
2745+ Set_Intval (N, Intval);
2746+ return N;
2747+ end Make_Integer_Literal;
2748+
2749+ function Make_Real_Literal (Sloc : Source_Ptr;
2750+ Realval : Ureal)
2751+ return Node_Id
2752+ is
2753+ N : constant Node_Id :=
2754+ New_Node (N_Real_Literal, Sloc);
2755+ begin
2756+ Set_Realval (N, Realval);
2757+ return N;
2758+ end Make_Real_Literal;
2759+
2760+ function Make_Character_Literal (Sloc : Source_Ptr;
2761+ Chars : Name_Id;
2762+ Char_Literal_Value : Char_Code)
2763+ return Node_Id
2764+ is
2765+ N : constant Node_Id :=
2766+ New_Node (N_Character_Literal, Sloc);
2767+ begin
2768+ Set_Chars (N, Chars);
2769+ Set_Char_Literal_Value (N, Char_Literal_Value);
2770+ return N;
2771+ end Make_Character_Literal;
2772+
2773+ function Make_String_Literal (Sloc : Source_Ptr;
2774+ Strval : String_Id)
2775+ return Node_Id
2776+ is
2777+ N : constant Node_Id :=
2778+ New_Node (N_String_Literal, Sloc);
2779+ begin
2780+ Set_Strval (N, Strval);
2781+ return N;
2782+ end Make_String_Literal;
2783+
2784+ function Make_Pragma (Sloc : Source_Ptr;
2785+ Chars : Name_Id;
2786+ Pragma_Argument_Associations : List_Id := No_List;
2787+ Debug_Statement : Node_Id := Empty)
2788+ return Node_Id
2789+ is
2790+ N : constant Node_Id :=
2791+ New_Node (N_Pragma, Sloc);
2792+ begin
2793+ Set_Chars (N, Chars);
2794+ Set_Pragma_Argument_Associations
2795+ (N, Pragma_Argument_Associations);
2796+ Set_Debug_Statement (N, Debug_Statement);
2797+ return N;
2798+ end Make_Pragma;
2799+
2800+ function Make_Pragma_Argument_Association (Sloc : Source_Ptr;
2801+ Chars : Name_Id := No_Name;
2802+ Expression : Node_Id)
2803+ return Node_Id
2804+ is
2805+ N : constant Node_Id :=
2806+ New_Node (N_Pragma_Argument_Association, Sloc);
2807+ begin
2808+ Set_Chars (N, Chars);
2809+ Set_Expression (N, Expression);
2810+ return N;
2811+ end Make_Pragma_Argument_Association;
2812+
2813+ function Make_Defining_Identifier (Sloc : Source_Ptr;
2814+ Chars : Name_Id)
2815+ return Node_Id
2816+ is
2817+ N : constant Node_Id :=
2818+ New_Entity (N_Defining_Identifier, Sloc);
2819+ begin
2820+ Set_Chars (N, Chars);
2821+ return N;
2822+ end Make_Defining_Identifier;
2823+
2824+ function Make_Full_Type_Declaration (Sloc : Source_Ptr;
2825+ Defining_Identifier : Node_Id;
2826+ Discriminant_Specifications : List_Id := No_List;
2827+ Type_Definition : Node_Id)
2828+ return Node_Id
2829+ is
2830+ N : constant Node_Id :=
2831+ New_Node (N_Full_Type_Declaration, Sloc);
2832+ begin
2833+ Set_Defining_Identifier (N, Defining_Identifier);
2834+ Set_Discriminant_Specifications (N, Discriminant_Specifications);
2835+ Set_Type_Definition (N, Type_Definition);
2836+ return N;
2837+ end Make_Full_Type_Declaration;
2838+
2839+ function Make_Subtype_Declaration (Sloc : Source_Ptr;
2840+ Defining_Identifier : Node_Id;
2841+ Subtype_Indication : Node_Id)
2842+ return Node_Id
2843+ is
2844+ N : constant Node_Id :=
2845+ New_Node (N_Subtype_Declaration, Sloc);
2846+ begin
2847+ Set_Defining_Identifier (N, Defining_Identifier);
2848+ Set_Subtype_Indication (N, Subtype_Indication);
2849+ return N;
2850+ end Make_Subtype_Declaration;
2851+
2852+ function Make_Subtype_Indication (Sloc : Source_Ptr;
2853+ Subtype_Mark : Node_Id;
2854+ Constraint : Node_Id)
2855+ return Node_Id
2856+ is
2857+ N : constant Node_Id :=
2858+ New_Node (N_Subtype_Indication, Sloc);
2859+ begin
2860+ Set_Subtype_Mark (N, Subtype_Mark);
2861+ Set_Constraint (N, Constraint);
2862+ return N;
2863+ end Make_Subtype_Indication;
2864+
2865+ function Make_Object_Declaration (Sloc : Source_Ptr;
2866+ Defining_Identifier : Node_Id;
2867+ Aliased_Present : Boolean := False;
2868+ Constant_Present : Boolean := False;
2869+ Object_Definition : Node_Id;
2870+ Expression : Node_Id := Empty)
2871+ return Node_Id
2872+ is
2873+ N : constant Node_Id :=
2874+ New_Node (N_Object_Declaration, Sloc);
2875+ begin
2876+ Set_Defining_Identifier (N, Defining_Identifier);
2877+ Set_Aliased_Present (N, Aliased_Present);
2878+ Set_Constant_Present (N, Constant_Present);
2879+ Set_Object_Definition (N, Object_Definition);
2880+ Set_Expression (N, Expression);
2881+ return N;
2882+ end Make_Object_Declaration;
2883+
2884+ function Make_Number_Declaration (Sloc : Source_Ptr;
2885+ Defining_Identifier : Node_Id;
2886+ Expression : Node_Id)
2887+ return Node_Id
2888+ is
2889+ N : constant Node_Id :=
2890+ New_Node (N_Number_Declaration, Sloc);
2891+ begin
2892+ Set_Defining_Identifier (N, Defining_Identifier);
2893+ Set_Expression (N, Expression);
2894+ return N;
2895+ end Make_Number_Declaration;
2896+
2897+ function Make_Derived_Type_Definition (Sloc : Source_Ptr;
2898+ Abstract_Present : Boolean := False;
2899+ Subtype_Indication : Node_Id;
2900+ Record_Extension_Part : Node_Id := Empty)
2901+ return Node_Id
2902+ is
2903+ N : constant Node_Id :=
2904+ New_Node (N_Derived_Type_Definition, Sloc);
2905+ begin
2906+ Set_Abstract_Present (N, Abstract_Present);
2907+ Set_Subtype_Indication (N, Subtype_Indication);
2908+ Set_Record_Extension_Part (N, Record_Extension_Part);
2909+ return N;
2910+ end Make_Derived_Type_Definition;
2911+
2912+ function Make_Range_Constraint (Sloc : Source_Ptr;
2913+ Range_Expression : Node_Id)
2914+ return Node_Id
2915+ is
2916+ N : constant Node_Id :=
2917+ New_Node (N_Range_Constraint, Sloc);
2918+ begin
2919+ Set_Range_Expression (N, Range_Expression);
2920+ return N;
2921+ end Make_Range_Constraint;
2922+
2923+ function Make_Range (Sloc : Source_Ptr;
2924+ Low_Bound : Node_Id;
2925+ High_Bound : Node_Id;
2926+ Includes_Infinities : Boolean := False)
2927+ return Node_Id
2928+ is
2929+ N : constant Node_Id :=
2930+ New_Node (N_Range, Sloc);
2931+ begin
2932+ Set_Low_Bound (N, Low_Bound);
2933+ Set_High_Bound (N, High_Bound);
2934+ Set_Includes_Infinities (N, Includes_Infinities);
2935+ return N;
2936+ end Make_Range;
2937+
2938+ function Make_Enumeration_Type_Definition (Sloc : Source_Ptr;
2939+ Literals : List_Id;
2940+ End_Label : Node_Id := Empty)
2941+ return Node_Id
2942+ is
2943+ N : constant Node_Id :=
2944+ New_Node (N_Enumeration_Type_Definition, Sloc);
2945+ begin
2946+ Set_Literals (N, Literals);
2947+ Set_End_Label (N, End_Label);
2948+ return N;
2949+ end Make_Enumeration_Type_Definition;
2950+
2951+ function Make_Defining_Character_Literal (Sloc : Source_Ptr;
2952+ Chars : Name_Id)
2953+ return Node_Id
2954+ is
2955+ N : constant Node_Id :=
2956+ New_Entity (N_Defining_Character_Literal, Sloc);
2957+ begin
2958+ Set_Chars (N, Chars);
2959+ return N;
2960+ end Make_Defining_Character_Literal;
2961+
2962+ function Make_Signed_Integer_Type_Definition (Sloc : Source_Ptr;
2963+ Low_Bound : Node_Id;
2964+ High_Bound : Node_Id)
2965+ return Node_Id
2966+ is
2967+ N : constant Node_Id :=
2968+ New_Node (N_Signed_Integer_Type_Definition, Sloc);
2969+ begin
2970+ Set_Low_Bound (N, Low_Bound);
2971+ Set_High_Bound (N, High_Bound);
2972+ return N;
2973+ end Make_Signed_Integer_Type_Definition;
2974+
2975+ function Make_Modular_Type_Definition (Sloc : Source_Ptr;
2976+ Expression : Node_Id)
2977+ return Node_Id
2978+ is
2979+ N : constant Node_Id :=
2980+ New_Node (N_Modular_Type_Definition, Sloc);
2981+ begin
2982+ Set_Expression (N, Expression);
2983+ return N;
2984+ end Make_Modular_Type_Definition;
2985+
2986+ function Make_Floating_Point_Definition (Sloc : Source_Ptr;
2987+ Digits_Expression : Node_Id;
2988+ Real_Range_Specification : Node_Id := Empty)
2989+ return Node_Id
2990+ is
2991+ N : constant Node_Id :=
2992+ New_Node (N_Floating_Point_Definition, Sloc);
2993+ begin
2994+ Set_Digits_Expression (N, Digits_Expression);
2995+ Set_Real_Range_Specification (N, Real_Range_Specification);
2996+ return N;
2997+ end Make_Floating_Point_Definition;
2998+
2999+ function Make_Real_Range_Specification (Sloc : Source_Ptr;
3000+ Low_Bound : Node_Id;
3001+ High_Bound : Node_Id)
3002+ return Node_Id
3003+ is
3004+ N : constant Node_Id :=
3005+ New_Node (N_Real_Range_Specification, Sloc);
3006+ begin
3007+ Set_Low_Bound (N, Low_Bound);
3008+ Set_High_Bound (N, High_Bound);
3009+ return N;
3010+ end Make_Real_Range_Specification;
3011+
3012+ function Make_Ordinary_Fixed_Point_Definition (Sloc : Source_Ptr;
3013+ Delta_Expression : Node_Id;
3014+ Real_Range_Specification : Node_Id)
3015+ return Node_Id
3016+ is
3017+ N : constant Node_Id :=
3018+ New_Node (N_Ordinary_Fixed_Point_Definition, Sloc);
3019+ begin
3020+ Set_Delta_Expression (N, Delta_Expression);
3021+ Set_Real_Range_Specification (N, Real_Range_Specification);
3022+ return N;
3023+ end Make_Ordinary_Fixed_Point_Definition;
3024+
3025+ function Make_Decimal_Fixed_Point_Definition (Sloc : Source_Ptr;
3026+ Delta_Expression : Node_Id;
3027+ Digits_Expression : Node_Id;
3028+ Real_Range_Specification : Node_Id := Empty)
3029+ return Node_Id
3030+ is
3031+ N : constant Node_Id :=
3032+ New_Node (N_Decimal_Fixed_Point_Definition, Sloc);
3033+ begin
3034+ Set_Delta_Expression (N, Delta_Expression);
3035+ Set_Digits_Expression (N, Digits_Expression);
3036+ Set_Real_Range_Specification (N, Real_Range_Specification);
3037+ return N;
3038+ end Make_Decimal_Fixed_Point_Definition;
3039+
3040+ function Make_Digits_Constraint (Sloc : Source_Ptr;
3041+ Digits_Expression : Node_Id;
3042+ Range_Constraint : Node_Id := Empty)
3043+ return Node_Id
3044+ is
3045+ N : constant Node_Id :=
3046+ New_Node (N_Digits_Constraint, Sloc);
3047+ begin
3048+ Set_Digits_Expression (N, Digits_Expression);
3049+ Set_Range_Constraint (N, Range_Constraint);
3050+ return N;
3051+ end Make_Digits_Constraint;
3052+
3053+ function Make_Unconstrained_Array_Definition (Sloc : Source_Ptr;
3054+ Subtype_Marks : List_Id;
3055+ Component_Definition : Node_Id)
3056+ return Node_Id
3057+ is
3058+ N : constant Node_Id :=
3059+ New_Node (N_Unconstrained_Array_Definition, Sloc);
3060+ begin
3061+ Set_Subtype_Marks (N, Subtype_Marks);
3062+ Set_Component_Definition (N, Component_Definition);
3063+ return N;
3064+ end Make_Unconstrained_Array_Definition;
3065+
3066+ function Make_Constrained_Array_Definition (Sloc : Source_Ptr;
3067+ Discrete_Subtype_Definitions : List_Id;
3068+ Component_Definition : Node_Id)
3069+ return Node_Id
3070+ is
3071+ N : constant Node_Id :=
3072+ New_Node (N_Constrained_Array_Definition, Sloc);
3073+ begin
3074+ Set_Discrete_Subtype_Definitions
3075+ (N, Discrete_Subtype_Definitions);
3076+ Set_Component_Definition (N, Component_Definition);
3077+ return N;
3078+ end Make_Constrained_Array_Definition;
3079+
3080+ function Make_Component_Definition (Sloc : Source_Ptr;
3081+ Aliased_Present : Boolean := False;
3082+ Subtype_Indication : Node_Id)
3083+ return Node_Id
3084+ is
3085+ N : constant Node_Id :=
3086+ New_Node (N_Component_Definition, Sloc);
3087+ begin
3088+ Set_Aliased_Present (N, Aliased_Present);
3089+ Set_Subtype_Indication (N, Subtype_Indication);
3090+ return N;
3091+ end Make_Component_Definition;
3092+
3093+ function Make_Discriminant_Specification (Sloc : Source_Ptr;
3094+ Defining_Identifier : Node_Id;
3095+ Discriminant_Type : Node_Id;
3096+ Expression : Node_Id := Empty)
3097+ return Node_Id
3098+ is
3099+ N : constant Node_Id :=
3100+ New_Node (N_Discriminant_Specification, Sloc);
3101+ begin
3102+ Set_Defining_Identifier (N, Defining_Identifier);
3103+ Set_Discriminant_Type (N, Discriminant_Type);
3104+ Set_Expression (N, Expression);
3105+ return N;
3106+ end Make_Discriminant_Specification;
3107+
3108+ function Make_Index_Or_Discriminant_Constraint (Sloc : Source_Ptr;
3109+ Constraints : List_Id)
3110+ return Node_Id
3111+ is
3112+ N : constant Node_Id :=
3113+ New_Node (N_Index_Or_Discriminant_Constraint, Sloc);
3114+ begin
3115+ Set_Constraints (N, Constraints);
3116+ return N;
3117+ end Make_Index_Or_Discriminant_Constraint;
3118+
3119+ function Make_Discriminant_Association (Sloc : Source_Ptr;
3120+ Selector_Names : List_Id;
3121+ Expression : Node_Id)
3122+ return Node_Id
3123+ is
3124+ N : constant Node_Id :=
3125+ New_Node (N_Discriminant_Association, Sloc);
3126+ begin
3127+ Set_Selector_Names (N, Selector_Names);
3128+ Set_Expression (N, Expression);
3129+ return N;
3130+ end Make_Discriminant_Association;
3131+
3132+ function Make_Record_Definition (Sloc : Source_Ptr;
3133+ End_Label : Node_Id := Empty;
3134+ Abstract_Present : Boolean := False;
3135+ Tagged_Present : Boolean := False;
3136+ Limited_Present : Boolean := False;
3137+ Component_List : Node_Id;
3138+ Null_Present : Boolean := False)
3139+ return Node_Id
3140+ is
3141+ N : constant Node_Id :=
3142+ New_Node (N_Record_Definition, Sloc);
3143+ begin
3144+ Set_End_Label (N, End_Label);
3145+ Set_Abstract_Present (N, Abstract_Present);
3146+ Set_Tagged_Present (N, Tagged_Present);
3147+ Set_Limited_Present (N, Limited_Present);
3148+ Set_Component_List (N, Component_List);
3149+ Set_Null_Present (N, Null_Present);
3150+ return N;
3151+ end Make_Record_Definition;
3152+
3153+ function Make_Component_List (Sloc : Source_Ptr;
3154+ Component_Items : List_Id;
3155+ Variant_Part : Node_Id := Empty;
3156+ Null_Present : Boolean := False)
3157+ return Node_Id
3158+ is
3159+ N : constant Node_Id :=
3160+ New_Node (N_Component_List, Sloc);
3161+ begin
3162+ Set_Component_Items (N, Component_Items);
3163+ Set_Variant_Part (N, Variant_Part);
3164+ Set_Null_Present (N, Null_Present);
3165+ return N;
3166+ end Make_Component_List;
3167+
3168+ function Make_Component_Declaration (Sloc : Source_Ptr;
3169+ Defining_Identifier : Node_Id;
3170+ Component_Definition : Node_Id;
3171+ Expression : Node_Id := Empty)
3172+ return Node_Id
3173+ is
3174+ N : constant Node_Id :=
3175+ New_Node (N_Component_Declaration, Sloc);
3176+ begin
3177+ Set_Defining_Identifier (N, Defining_Identifier);
3178+ Set_Component_Definition (N, Component_Definition);
3179+ Set_Expression (N, Expression);
3180+ return N;
3181+ end Make_Component_Declaration;
3182+
3183+ function Make_Variant_Part (Sloc : Source_Ptr;
3184+ Name : Node_Id;
3185+ Variants : List_Id)
3186+ return Node_Id
3187+ is
3188+ N : constant Node_Id :=
3189+ New_Node (N_Variant_Part, Sloc);
3190+ begin
3191+ Set_Name (N, Name);
3192+ Set_Variants (N, Variants);
3193+ return N;
3194+ end Make_Variant_Part;
3195+
3196+ function Make_Variant (Sloc : Source_Ptr;
3197+ Discrete_Choices : List_Id;
3198+ Component_List : Node_Id)
3199+ return Node_Id
3200+ is
3201+ N : constant Node_Id :=
3202+ New_Node (N_Variant, Sloc);
3203+ begin
3204+ Set_Discrete_Choices (N, Discrete_Choices);
3205+ Set_Component_List (N, Component_List);
3206+ return N;
3207+ end Make_Variant;
3208+
3209+ function Make_Others_Choice (Sloc : Source_Ptr)
3210+ return Node_Id
3211+ is
3212+ N : constant Node_Id :=
3213+ New_Node (N_Others_Choice, Sloc);
3214+ begin
3215+ return N;
3216+ end Make_Others_Choice;
3217+
3218+ function Make_Access_To_Object_Definition (Sloc : Source_Ptr;
3219+ All_Present : Boolean := False;
3220+ Subtype_Indication : Node_Id;
3221+ Constant_Present : Boolean := False)
3222+ return Node_Id
3223+ is
3224+ N : constant Node_Id :=
3225+ New_Node (N_Access_To_Object_Definition, Sloc);
3226+ begin
3227+ Set_All_Present (N, All_Present);
3228+ Set_Subtype_Indication (N, Subtype_Indication);
3229+ Set_Constant_Present (N, Constant_Present);
3230+ return N;
3231+ end Make_Access_To_Object_Definition;
3232+
3233+ function Make_Access_Function_Definition (Sloc : Source_Ptr;
3234+ Protected_Present : Boolean := False;
3235+ Parameter_Specifications : List_Id := No_List;
3236+ Subtype_Mark : Node_Id)
3237+ return Node_Id
3238+ is
3239+ N : constant Node_Id :=
3240+ New_Node (N_Access_Function_Definition, Sloc);
3241+ begin
3242+ Set_Protected_Present (N, Protected_Present);
3243+ Set_Parameter_Specifications (N, Parameter_Specifications);
3244+ Set_Subtype_Mark (N, Subtype_Mark);
3245+ return N;
3246+ end Make_Access_Function_Definition;
3247+
3248+ function Make_Access_Procedure_Definition (Sloc : Source_Ptr;
3249+ Protected_Present : Boolean := False;
3250+ Parameter_Specifications : List_Id := No_List)
3251+ return Node_Id
3252+ is
3253+ N : constant Node_Id :=
3254+ New_Node (N_Access_Procedure_Definition, Sloc);
3255+ begin
3256+ Set_Protected_Present (N, Protected_Present);
3257+ Set_Parameter_Specifications (N, Parameter_Specifications);
3258+ return N;
3259+ end Make_Access_Procedure_Definition;
3260+
3261+ function Make_Access_Definition (Sloc : Source_Ptr;
3262+ Subtype_Mark : Node_Id)
3263+ return Node_Id
3264+ is
3265+ N : constant Node_Id :=
3266+ New_Node (N_Access_Definition, Sloc);
3267+ begin
3268+ Set_Subtype_Mark (N, Subtype_Mark);
3269+ return N;
3270+ end Make_Access_Definition;
3271+
3272+ function Make_Incomplete_Type_Declaration (Sloc : Source_Ptr;
3273+ Defining_Identifier : Node_Id;
3274+ Discriminant_Specifications : List_Id := No_List;
3275+ Unknown_Discriminants_Present : Boolean := False)
3276+ return Node_Id
3277+ is
3278+ N : constant Node_Id :=
3279+ New_Node (N_Incomplete_Type_Declaration, Sloc);
3280+ begin
3281+ Set_Defining_Identifier (N, Defining_Identifier);
3282+ Set_Discriminant_Specifications (N, Discriminant_Specifications);
3283+ Set_Unknown_Discriminants_Present
3284+ (N, Unknown_Discriminants_Present);
3285+ return N;
3286+ end Make_Incomplete_Type_Declaration;
3287+
3288+ function Make_Explicit_Dereference (Sloc : Source_Ptr;
3289+ Prefix : Node_Id)
3290+ return Node_Id
3291+ is
3292+ N : constant Node_Id :=
3293+ New_Node (N_Explicit_Dereference, Sloc);
3294+ begin
3295+ Set_Prefix (N, Prefix);
3296+ return N;
3297+ end Make_Explicit_Dereference;
3298+
3299+ function Make_Indexed_Component (Sloc : Source_Ptr;
3300+ Prefix : Node_Id;
3301+ Expressions : List_Id)
3302+ return Node_Id
3303+ is
3304+ N : constant Node_Id :=
3305+ New_Node (N_Indexed_Component, Sloc);
3306+ begin
3307+ Set_Prefix (N, Prefix);
3308+ Set_Expressions (N, Expressions);
3309+ return N;
3310+ end Make_Indexed_Component;
3311+
3312+ function Make_Slice (Sloc : Source_Ptr;
3313+ Prefix : Node_Id;
3314+ Discrete_Range : Node_Id)
3315+ return Node_Id
3316+ is
3317+ N : constant Node_Id :=
3318+ New_Node (N_Slice, Sloc);
3319+ begin
3320+ Set_Prefix (N, Prefix);
3321+ Set_Discrete_Range (N, Discrete_Range);
3322+ return N;
3323+ end Make_Slice;
3324+
3325+ function Make_Selected_Component (Sloc : Source_Ptr;
3326+ Prefix : Node_Id;
3327+ Selector_Name : Node_Id)
3328+ return Node_Id
3329+ is
3330+ N : constant Node_Id :=
3331+ New_Node (N_Selected_Component, Sloc);
3332+ begin
3333+ Set_Prefix (N, Prefix);
3334+ Set_Selector_Name (N, Selector_Name);
3335+ return N;
3336+ end Make_Selected_Component;
3337+
3338+ function Make_Attribute_Reference (Sloc : Source_Ptr;
3339+ Prefix : Node_Id;
3340+ Attribute_Name : Name_Id;
3341+ Expressions : List_Id := No_List;
3342+ Must_Be_Byte_Aligned : Boolean := False)
3343+ return Node_Id
3344+ is
3345+ N : constant Node_Id :=
3346+ New_Node (N_Attribute_Reference, Sloc);
3347+ begin
3348+ Set_Prefix (N, Prefix);
3349+ Set_Attribute_Name (N, Attribute_Name);
3350+ Set_Expressions (N, Expressions);
3351+ Set_Must_Be_Byte_Aligned (N, Must_Be_Byte_Aligned);
3352+ return N;
3353+ end Make_Attribute_Reference;
3354+
3355+ function Make_Aggregate (Sloc : Source_Ptr;
3356+ Expressions : List_Id := No_List;
3357+ Component_Associations : List_Id := No_List;
3358+ Null_Record_Present : Boolean := False)
3359+ return Node_Id
3360+ is
3361+ N : constant Node_Id :=
3362+ New_Node (N_Aggregate, Sloc);
3363+ begin
3364+ Set_Expressions (N, Expressions);
3365+ Set_Component_Associations (N, Component_Associations);
3366+ Set_Null_Record_Present (N, Null_Record_Present);
3367+ return N;
3368+ end Make_Aggregate;
3369+
3370+ function Make_Component_Association (Sloc : Source_Ptr;
3371+ Choices : List_Id;
3372+ Expression : Node_Id;
3373+ Box_Present : Boolean := False)
3374+ return Node_Id
3375+ is
3376+ N : constant Node_Id :=
3377+ New_Node (N_Component_Association, Sloc);
3378+ begin
3379+ Set_Choices (N, Choices);
3380+ Set_Expression (N, Expression);
3381+ Set_Box_Present (N, Box_Present);
3382+ return N;
3383+ end Make_Component_Association;
3384+
3385+ function Make_Extension_Aggregate (Sloc : Source_Ptr;
3386+ Ancestor_Part : Node_Id;
3387+ Expressions : List_Id := No_List;
3388+ Component_Associations : List_Id := No_List;
3389+ Null_Record_Present : Boolean := False)
3390+ return Node_Id
3391+ is
3392+ N : constant Node_Id :=
3393+ New_Node (N_Extension_Aggregate, Sloc);
3394+ begin
3395+ Set_Ancestor_Part (N, Ancestor_Part);
3396+ Set_Expressions (N, Expressions);
3397+ Set_Component_Associations (N, Component_Associations);
3398+ Set_Null_Record_Present (N, Null_Record_Present);
3399+ return N;
3400+ end Make_Extension_Aggregate;
3401+
3402+ function Make_Null (Sloc : Source_Ptr)
3403+ return Node_Id
3404+ is
3405+ N : constant Node_Id :=
3406+ New_Node (N_Null, Sloc);
3407+ begin
3408+ return N;
3409+ end Make_Null;
3410+
3411+ function Make_And_Then (Sloc : Source_Ptr;
3412+ Left_Opnd : Node_Id;
3413+ Right_Opnd : Node_Id)
3414+ return Node_Id
3415+ is
3416+ N : constant Node_Id :=
3417+ New_Node (N_And_Then, Sloc);
3418+ begin
3419+ Set_Left_Opnd (N, Left_Opnd);
3420+ Set_Right_Opnd (N, Right_Opnd);
3421+ return N;
3422+ end Make_And_Then;
3423+
3424+ function Make_Or_Else (Sloc : Source_Ptr;
3425+ Left_Opnd : Node_Id;
3426+ Right_Opnd : Node_Id)
3427+ return Node_Id
3428+ is
3429+ N : constant Node_Id :=
3430+ New_Node (N_Or_Else, Sloc);
3431+ begin
3432+ Set_Left_Opnd (N, Left_Opnd);
3433+ Set_Right_Opnd (N, Right_Opnd);
3434+ return N;
3435+ end Make_Or_Else;
3436+
3437+ function Make_In (Sloc : Source_Ptr;
3438+ Left_Opnd : Node_Id;
3439+ Right_Opnd : Node_Id)
3440+ return Node_Id
3441+ is
3442+ N : constant Node_Id :=
3443+ New_Node (N_In, Sloc);
3444+ begin
3445+ Set_Left_Opnd (N, Left_Opnd);
3446+ Set_Right_Opnd (N, Right_Opnd);
3447+ return N;
3448+ end Make_In;
3449+
3450+ function Make_Not_In (Sloc : Source_Ptr;
3451+ Left_Opnd : Node_Id;
3452+ Right_Opnd : Node_Id)
3453+ return Node_Id
3454+ is
3455+ N : constant Node_Id :=
3456+ New_Node (N_Not_In, Sloc);
3457+ begin
3458+ Set_Left_Opnd (N, Left_Opnd);
3459+ Set_Right_Opnd (N, Right_Opnd);
3460+ return N;
3461+ end Make_Not_In;
3462+
3463+ function Make_Op_And (Sloc : Source_Ptr;
3464+ Left_Opnd : Node_Id;
3465+ Right_Opnd : Node_Id)
3466+ return Node_Id
3467+ is
3468+ N : constant Node_Id :=
3469+ New_Node (N_Op_And, Sloc);
3470+ begin
3471+ Set_Left_Opnd (N, Left_Opnd);
3472+ Set_Right_Opnd (N, Right_Opnd);
3473+ Set_Chars (N, Name_Op_And);
3474+ Set_Entity (N, Standard_Op_And);
3475+ return N;
3476+ end Make_Op_And;
3477+
3478+ function Make_Op_Or (Sloc : Source_Ptr;
3479+ Left_Opnd : Node_Id;
3480+ Right_Opnd : Node_Id)
3481+ return Node_Id
3482+ is
3483+ N : constant Node_Id :=
3484+ New_Node (N_Op_Or, Sloc);
3485+ begin
3486+ Set_Left_Opnd (N, Left_Opnd);
3487+ Set_Right_Opnd (N, Right_Opnd);
3488+ Set_Chars (N, Name_Op_Or);
3489+ Set_Entity (N, Standard_Op_Or);
3490+ return N;
3491+ end Make_Op_Or;
3492+
3493+ function Make_Op_Xor (Sloc : Source_Ptr;
3494+ Left_Opnd : Node_Id;
3495+ Right_Opnd : Node_Id)
3496+ return Node_Id
3497+ is
3498+ N : constant Node_Id :=
3499+ New_Node (N_Op_Xor, Sloc);
3500+ begin
3501+ Set_Left_Opnd (N, Left_Opnd);
3502+ Set_Right_Opnd (N, Right_Opnd);
3503+ Set_Chars (N, Name_Op_Xor);
3504+ Set_Entity (N, Standard_Op_Xor);
3505+ return N;
3506+ end Make_Op_Xor;
3507+
3508+ function Make_Op_Eq (Sloc : Source_Ptr;
3509+ Left_Opnd : Node_Id;
3510+ Right_Opnd : Node_Id)
3511+ return Node_Id
3512+ is
3513+ N : constant Node_Id :=
3514+ New_Node (N_Op_Eq, Sloc);
3515+ begin
3516+ Set_Left_Opnd (N, Left_Opnd);
3517+ Set_Right_Opnd (N, Right_Opnd);
3518+ Set_Chars (N, Name_Op_Eq);
3519+ Set_Entity (N, Standard_Op_Eq);
3520+ return N;
3521+ end Make_Op_Eq;
3522+
3523+ function Make_Op_Ne (Sloc : Source_Ptr;
3524+ Left_Opnd : Node_Id;
3525+ Right_Opnd : Node_Id)
3526+ return Node_Id
3527+ is
3528+ N : constant Node_Id :=
3529+ New_Node (N_Op_Ne, Sloc);
3530+ begin
3531+ Set_Left_Opnd (N, Left_Opnd);
3532+ Set_Right_Opnd (N, Right_Opnd);
3533+ Set_Chars (N, Name_Op_Ne);
3534+ Set_Entity (N, Standard_Op_Ne);
3535+ return N;
3536+ end Make_Op_Ne;
3537+
3538+ function Make_Op_Lt (Sloc : Source_Ptr;
3539+ Left_Opnd : Node_Id;
3540+ Right_Opnd : Node_Id)
3541+ return Node_Id
3542+ is
3543+ N : constant Node_Id :=
3544+ New_Node (N_Op_Lt, Sloc);
3545+ begin
3546+ Set_Left_Opnd (N, Left_Opnd);
3547+ Set_Right_Opnd (N, Right_Opnd);
3548+ Set_Chars (N, Name_Op_Lt);
3549+ Set_Entity (N, Standard_Op_Lt);
3550+ return N;
3551+ end Make_Op_Lt;
3552+
3553+ function Make_Op_Le (Sloc : Source_Ptr;
3554+ Left_Opnd : Node_Id;
3555+ Right_Opnd : Node_Id)
3556+ return Node_Id
3557+ is
3558+ N : constant Node_Id :=
3559+ New_Node (N_Op_Le, Sloc);
3560+ begin
3561+ Set_Left_Opnd (N, Left_Opnd);
3562+ Set_Right_Opnd (N, Right_Opnd);
3563+ Set_Chars (N, Name_Op_Le);
3564+ Set_Entity (N, Standard_Op_Le);
3565+ return N;
3566+ end Make_Op_Le;
3567+
3568+ function Make_Op_Gt (Sloc : Source_Ptr;
3569+ Left_Opnd : Node_Id;
3570+ Right_Opnd : Node_Id)
3571+ return Node_Id
3572+ is
3573+ N : constant Node_Id :=
3574+ New_Node (N_Op_Gt, Sloc);
3575+ begin
3576+ Set_Left_Opnd (N, Left_Opnd);
3577+ Set_Right_Opnd (N, Right_Opnd);
3578+ Set_Chars (N, Name_Op_Gt);
3579+ Set_Entity (N, Standard_Op_Gt);
3580+ return N;
3581+ end Make_Op_Gt;
3582+
3583+ function Make_Op_Ge (Sloc : Source_Ptr;
3584+ Left_Opnd : Node_Id;
3585+ Right_Opnd : Node_Id)
3586+ return Node_Id
3587+ is
3588+ N : constant Node_Id :=
3589+ New_Node (N_Op_Ge, Sloc);
3590+ begin
3591+ Set_Left_Opnd (N, Left_Opnd);
3592+ Set_Right_Opnd (N, Right_Opnd);
3593+ Set_Chars (N, Name_Op_Ge);
3594+ Set_Entity (N, Standard_Op_Ge);
3595+ return N;
3596+ end Make_Op_Ge;
3597+
3598+ function Make_Op_Add (Sloc : Source_Ptr;
3599+ Left_Opnd : Node_Id;
3600+ Right_Opnd : Node_Id)
3601+ return Node_Id
3602+ is
3603+ N : constant Node_Id :=
3604+ New_Node (N_Op_Add, Sloc);
3605+ begin
3606+ Set_Left_Opnd (N, Left_Opnd);
3607+ Set_Right_Opnd (N, Right_Opnd);
3608+ Set_Chars (N, Name_Op_Add);
3609+ Set_Entity (N, Standard_Op_Add);
3610+ return N;
3611+ end Make_Op_Add;
3612+
3613+ function Make_Op_Subtract (Sloc : Source_Ptr;
3614+ Left_Opnd : Node_Id;
3615+ Right_Opnd : Node_Id)
3616+ return Node_Id
3617+ is
3618+ N : constant Node_Id :=
3619+ New_Node (N_Op_Subtract, Sloc);
3620+ begin
3621+ Set_Left_Opnd (N, Left_Opnd);
3622+ Set_Right_Opnd (N, Right_Opnd);
3623+ Set_Chars (N, Name_Op_Subtract);
3624+ Set_Entity (N, Standard_Op_Subtract);
3625+ return N;
3626+ end Make_Op_Subtract;
3627+
3628+ function Make_Op_Concat (Sloc : Source_Ptr;
3629+ Left_Opnd : Node_Id;
3630+ Right_Opnd : Node_Id)
3631+ return Node_Id
3632+ is
3633+ N : constant Node_Id :=
3634+ New_Node (N_Op_Concat, Sloc);
3635+ begin
3636+ Set_Left_Opnd (N, Left_Opnd);
3637+ Set_Right_Opnd (N, Right_Opnd);
3638+ Set_Chars (N, Name_Op_Concat);
3639+ Set_Entity (N, Standard_Op_Concat);
3640+ return N;
3641+ end Make_Op_Concat;
3642+
3643+ function Make_Op_Multiply (Sloc : Source_Ptr;
3644+ Left_Opnd : Node_Id;
3645+ Right_Opnd : Node_Id)
3646+ return Node_Id
3647+ is
3648+ N : constant Node_Id :=
3649+ New_Node (N_Op_Multiply, Sloc);
3650+ begin
3651+ Set_Left_Opnd (N, Left_Opnd);
3652+ Set_Right_Opnd (N, Right_Opnd);
3653+ Set_Chars (N, Name_Op_Multiply);
3654+ Set_Entity (N, Standard_Op_Multiply);
3655+ return N;
3656+ end Make_Op_Multiply;
3657+
3658+ function Make_Op_Divide (Sloc : Source_Ptr;
3659+ Left_Opnd : Node_Id;
3660+ Right_Opnd : Node_Id)
3661+ return Node_Id
3662+ is
3663+ N : constant Node_Id :=
3664+ New_Node (N_Op_Divide, Sloc);
3665+ begin
3666+ Set_Left_Opnd (N, Left_Opnd);
3667+ Set_Right_Opnd (N, Right_Opnd);
3668+ Set_Chars (N, Name_Op_Divide);
3669+ Set_Entity (N, Standard_Op_Divide);
3670+ return N;
3671+ end Make_Op_Divide;
3672+
3673+ function Make_Op_Mod (Sloc : Source_Ptr;
3674+ Left_Opnd : Node_Id;
3675+ Right_Opnd : Node_Id)
3676+ return Node_Id
3677+ is
3678+ N : constant Node_Id :=
3679+ New_Node (N_Op_Mod, Sloc);
3680+ begin
3681+ Set_Left_Opnd (N, Left_Opnd);
3682+ Set_Right_Opnd (N, Right_Opnd);
3683+ Set_Chars (N, Name_Op_Mod);
3684+ Set_Entity (N, Standard_Op_Mod);
3685+ return N;
3686+ end Make_Op_Mod;
3687+
3688+ function Make_Op_Rem (Sloc : Source_Ptr;
3689+ Left_Opnd : Node_Id;
3690+ Right_Opnd : Node_Id)
3691+ return Node_Id
3692+ is
3693+ N : constant Node_Id :=
3694+ New_Node (N_Op_Rem, Sloc);
3695+ begin
3696+ Set_Left_Opnd (N, Left_Opnd);
3697+ Set_Right_Opnd (N, Right_Opnd);
3698+ Set_Chars (N, Name_Op_Rem);
3699+ Set_Entity (N, Standard_Op_Rem);
3700+ return N;
3701+ end Make_Op_Rem;
3702+
3703+ function Make_Op_Expon (Sloc : Source_Ptr;
3704+ Left_Opnd : Node_Id;
3705+ Right_Opnd : Node_Id)
3706+ return Node_Id
3707+ is
3708+ N : constant Node_Id :=
3709+ New_Node (N_Op_Expon, Sloc);
3710+ begin
3711+ Set_Left_Opnd (N, Left_Opnd);
3712+ Set_Right_Opnd (N, Right_Opnd);
3713+ Set_Chars (N, Name_Op_Expon);
3714+ Set_Entity (N, Standard_Op_Expon);
3715+ return N;
3716+ end Make_Op_Expon;
3717+
3718+ function Make_Op_Plus (Sloc : Source_Ptr;
3719+ Right_Opnd : Node_Id)
3720+ return Node_Id
3721+ is
3722+ N : constant Node_Id :=
3723+ New_Node (N_Op_Plus, Sloc);
3724+ begin
3725+ Set_Right_Opnd (N, Right_Opnd);
3726+ Set_Chars (N, Name_Op_Add);
3727+ Set_Entity (N, Standard_Op_Plus);
3728+ return N;
3729+ end Make_Op_Plus;
3730+
3731+ function Make_Op_Minus (Sloc : Source_Ptr;
3732+ Right_Opnd : Node_Id)
3733+ return Node_Id
3734+ is
3735+ N : constant Node_Id :=
3736+ New_Node (N_Op_Minus, Sloc);
3737+ begin
3738+ Set_Right_Opnd (N, Right_Opnd);
3739+ Set_Chars (N, Name_Op_Subtract);
3740+ Set_Entity (N, Standard_Op_Minus);
3741+ return N;
3742+ end Make_Op_Minus;
3743+
3744+ function Make_Op_Abs (Sloc : Source_Ptr;
3745+ Right_Opnd : Node_Id)
3746+ return Node_Id
3747+ is
3748+ N : constant Node_Id :=
3749+ New_Node (N_Op_Abs, Sloc);
3750+ begin
3751+ Set_Right_Opnd (N, Right_Opnd);
3752+ Set_Chars (N, Name_Op_Abs);
3753+ Set_Entity (N, Standard_Op_Abs);
3754+ return N;
3755+ end Make_Op_Abs;
3756+
3757+ function Make_Op_Not (Sloc : Source_Ptr;
3758+ Right_Opnd : Node_Id)
3759+ return Node_Id
3760+ is
3761+ N : constant Node_Id :=
3762+ New_Node (N_Op_Not, Sloc);
3763+ begin
3764+ Set_Right_Opnd (N, Right_Opnd);
3765+ Set_Chars (N, Name_Op_Not);
3766+ Set_Entity (N, Standard_Op_Not);
3767+ return N;
3768+ end Make_Op_Not;
3769+
3770+ function Make_Type_Conversion (Sloc : Source_Ptr;
3771+ Subtype_Mark : Node_Id;
3772+ Expression : Node_Id)
3773+ return Node_Id
3774+ is
3775+ N : constant Node_Id :=
3776+ New_Node (N_Type_Conversion, Sloc);
3777+ begin
3778+ Set_Subtype_Mark (N, Subtype_Mark);
3779+ Set_Expression (N, Expression);
3780+ return N;
3781+ end Make_Type_Conversion;
3782+
3783+ function Make_Qualified_Expression (Sloc : Source_Ptr;
3784+ Subtype_Mark : Node_Id;
3785+ Expression : Node_Id)
3786+ return Node_Id
3787+ is
3788+ N : constant Node_Id :=
3789+ New_Node (N_Qualified_Expression, Sloc);
3790+ begin
3791+ Set_Subtype_Mark (N, Subtype_Mark);
3792+ Set_Expression (N, Expression);
3793+ return N;
3794+ end Make_Qualified_Expression;
3795+
3796+ function Make_Allocator (Sloc : Source_Ptr;
3797+ Expression : Node_Id)
3798+ return Node_Id
3799+ is
3800+ N : constant Node_Id :=
3801+ New_Node (N_Allocator, Sloc);
3802+ begin
3803+ Set_Expression (N, Expression);
3804+ return N;
3805+ end Make_Allocator;
3806+
3807+ function Make_Null_Statement (Sloc : Source_Ptr)
3808+ return Node_Id
3809+ is
3810+ N : constant Node_Id :=
3811+ New_Node (N_Null_Statement, Sloc);
3812+ begin
3813+ return N;
3814+ end Make_Null_Statement;
3815+
3816+ function Make_Label (Sloc : Source_Ptr;
3817+ Identifier : Node_Id)
3818+ return Node_Id
3819+ is
3820+ N : constant Node_Id :=
3821+ New_Node (N_Label, Sloc);
3822+ begin
3823+ Set_Identifier (N, Identifier);
3824+ return N;
3825+ end Make_Label;
3826+
3827+ function Make_Assignment_Statement (Sloc : Source_Ptr;
3828+ Name : Node_Id;
3829+ Expression : Node_Id)
3830+ return Node_Id
3831+ is
3832+ N : constant Node_Id :=
3833+ New_Node (N_Assignment_Statement, Sloc);
3834+ begin
3835+ Set_Name (N, Name);
3836+ Set_Expression (N, Expression);
3837+ return N;
3838+ end Make_Assignment_Statement;
3839+
3840+ function Make_If_Statement (Sloc : Source_Ptr;
3841+ Condition : Node_Id;
3842+ Then_Statements : List_Id;
3843+ Elsif_Parts : List_Id := No_List;
3844+ Else_Statements : List_Id := No_List;
3845+ End_Span : Uint := No_Uint)
3846+ return Node_Id
3847+ is
3848+ N : constant Node_Id :=
3849+ New_Node (N_If_Statement, Sloc);
3850+ begin
3851+ Set_Condition (N, Condition);
3852+ Set_Then_Statements (N, Then_Statements);
3853+ Set_Elsif_Parts (N, Elsif_Parts);
3854+ Set_Else_Statements (N, Else_Statements);
3855+ Set_End_Span (N, End_Span);
3856+ return N;
3857+ end Make_If_Statement;
3858+
3859+ function Make_Elsif_Part (Sloc : Source_Ptr;
3860+ Condition : Node_Id;
3861+ Then_Statements : List_Id)
3862+ return Node_Id
3863+ is
3864+ N : constant Node_Id :=
3865+ New_Node (N_Elsif_Part, Sloc);
3866+ begin
3867+ Set_Condition (N, Condition);
3868+ Set_Then_Statements (N, Then_Statements);
3869+ return N;
3870+ end Make_Elsif_Part;
3871+
3872+ function Make_Case_Statement (Sloc : Source_Ptr;
3873+ Expression : Node_Id;
3874+ Alternatives : List_Id;
3875+ End_Span : Uint := No_Uint)
3876+ return Node_Id
3877+ is
3878+ N : constant Node_Id :=
3879+ New_Node (N_Case_Statement, Sloc);
3880+ begin
3881+ Set_Expression (N, Expression);
3882+ Set_Alternatives (N, Alternatives);
3883+ Set_End_Span (N, End_Span);
3884+ return N;
3885+ end Make_Case_Statement;
3886+
3887+ function Make_Case_Statement_Alternative (Sloc : Source_Ptr;
3888+ Discrete_Choices : List_Id;
3889+ Statements : List_Id)
3890+ return Node_Id
3891+ is
3892+ N : constant Node_Id :=
3893+ New_Node (N_Case_Statement_Alternative, Sloc);
3894+ begin
3895+ Set_Discrete_Choices (N, Discrete_Choices);
3896+ Set_Statements (N, Statements);
3897+ return N;
3898+ end Make_Case_Statement_Alternative;
3899+
3900+ function Make_Loop_Statement (Sloc : Source_Ptr;
3901+ Identifier : Node_Id := Empty;
3902+ Iteration_Scheme : Node_Id := Empty;
3903+ Statements : List_Id;
3904+ End_Label : Node_Id;
3905+ Has_Created_Identifier : Boolean := False;
3906+ Is_Null_Loop : Boolean := False)
3907+ return Node_Id
3908+ is
3909+ N : constant Node_Id :=
3910+ New_Node (N_Loop_Statement, Sloc);
3911+ begin
3912+ Set_Identifier (N, Identifier);
3913+ Set_Iteration_Scheme (N, Iteration_Scheme);
3914+ Set_Statements (N, Statements);
3915+ Set_End_Label (N, End_Label);
3916+ Set_Has_Created_Identifier (N, Has_Created_Identifier);
3917+ Set_Is_Null_Loop (N, Is_Null_Loop);
3918+ return N;
3919+ end Make_Loop_Statement;
3920+
3921+ function Make_Iteration_Scheme (Sloc : Source_Ptr;
3922+ Condition : Node_Id := Empty;
3923+ Loop_Parameter_Specification : Node_Id := Empty)
3924+ return Node_Id
3925+ is
3926+ N : constant Node_Id :=
3927+ New_Node (N_Iteration_Scheme, Sloc);
3928+ begin
3929+ Set_Condition (N, Condition);
3930+ Set_Loop_Parameter_Specification
3931+ (N, Loop_Parameter_Specification);
3932+ return N;
3933+ end Make_Iteration_Scheme;
3934+
3935+ function Make_Loop_Parameter_Specification (Sloc : Source_Ptr;
3936+ Defining_Identifier : Node_Id;
3937+ Reverse_Present : Boolean := False;
3938+ Discrete_Subtype_Definition : Node_Id)
3939+ return Node_Id
3940+ is
3941+ N : constant Node_Id :=
3942+ New_Node (N_Loop_Parameter_Specification, Sloc);
3943+ begin
3944+ Set_Defining_Identifier (N, Defining_Identifier);
3945+ Set_Reverse_Present (N, Reverse_Present);
3946+ Set_Discrete_Subtype_Definition (N, Discrete_Subtype_Definition);
3947+ return N;
3948+ end Make_Loop_Parameter_Specification;
3949+
3950+ function Make_Block_Statement (Sloc : Source_Ptr;
3951+ Identifier : Node_Id := Empty;
3952+ Declarations : List_Id := No_List;
3953+ Handled_Statement_Sequence : Node_Id;
3954+ Has_Created_Identifier : Boolean := False;
3955+ Is_Task_Allocation_Block : Boolean := False;
3956+ Is_Asynchronous_Call_Block : Boolean := False)
3957+ return Node_Id
3958+ is
3959+ N : constant Node_Id :=
3960+ New_Node (N_Block_Statement, Sloc);
3961+ begin
3962+ Set_Identifier (N, Identifier);
3963+ Set_Declarations (N, Declarations);
3964+ Set_Handled_Statement_Sequence (N, Handled_Statement_Sequence);
3965+ Set_Has_Created_Identifier (N, Has_Created_Identifier);
3966+ Set_Is_Task_Allocation_Block (N, Is_Task_Allocation_Block);
3967+ Set_Is_Asynchronous_Call_Block (N, Is_Asynchronous_Call_Block);
3968+ return N;
3969+ end Make_Block_Statement;
3970+
3971+ function Make_Exit_Statement (Sloc : Source_Ptr;
3972+ Name : Node_Id := Empty;
3973+ Condition : Node_Id := Empty)
3974+ return Node_Id
3975+ is
3976+ N : constant Node_Id :=
3977+ New_Node (N_Exit_Statement, Sloc);
3978+ begin
3979+ Set_Name (N, Name);
3980+ Set_Condition (N, Condition);
3981+ return N;
3982+ end Make_Exit_Statement;
3983+
3984+ function Make_Goto_Statement (Sloc : Source_Ptr;
3985+ Name : Node_Id)
3986+ return Node_Id
3987+ is
3988+ N : constant Node_Id :=
3989+ New_Node (N_Goto_Statement, Sloc);
3990+ begin
3991+ Set_Name (N, Name);
3992+ return N;
3993+ end Make_Goto_Statement;
3994+
3995+ function Make_Subprogram_Declaration (Sloc : Source_Ptr;
3996+ Specification : Node_Id)
3997+ return Node_Id
3998+ is
3999+ N : constant Node_Id :=
4000+ New_Node (N_Subprogram_Declaration, Sloc);
4001+ begin
4002+ Set_Specification (N, Specification);
4003+ return N;
4004+ end Make_Subprogram_Declaration;
4005+
4006+ function Make_Abstract_Subprogram_Declaration (Sloc : Source_Ptr;
4007+ Specification : Node_Id)
4008+ return Node_Id
4009+ is
4010+ N : constant Node_Id :=
4011+ New_Node (N_Abstract_Subprogram_Declaration, Sloc);
4012+ begin
4013+ Set_Specification (N, Specification);
4014+ return N;
4015+ end Make_Abstract_Subprogram_Declaration;
4016+
4017+ function Make_Function_Specification (Sloc : Source_Ptr;
4018+ Defining_Unit_Name : Node_Id;
4019+ Parameter_Specifications : List_Id := No_List;
4020+ Subtype_Mark : Node_Id)
4021+ return Node_Id
4022+ is
4023+ N : constant Node_Id :=
4024+ New_Node (N_Function_Specification, Sloc);
4025+ begin
4026+ Set_Defining_Unit_Name (N, Defining_Unit_Name);
4027+ Set_Parameter_Specifications (N, Parameter_Specifications);
4028+ Set_Subtype_Mark (N, Subtype_Mark);
4029+ return N;
4030+ end Make_Function_Specification;
4031+
4032+ function Make_Procedure_Specification (Sloc : Source_Ptr;
4033+ Defining_Unit_Name : Node_Id;
4034+ Parameter_Specifications : List_Id := No_List)
4035+ return Node_Id
4036+ is
4037+ N : constant Node_Id :=
4038+ New_Node (N_Procedure_Specification, Sloc);
4039+ begin
4040+ Set_Defining_Unit_Name (N, Defining_Unit_Name);
4041+ Set_Parameter_Specifications (N, Parameter_Specifications);
4042+ return N;
4043+ end Make_Procedure_Specification;
4044+
4045+ function Make_Designator (Sloc : Source_Ptr;
4046+ Name : Node_Id;
4047+ Identifier : Node_Id)
4048+ return Node_Id
4049+ is
4050+ N : constant Node_Id :=
4051+ New_Node (N_Designator, Sloc);
4052+ begin
4053+ Set_Name (N, Name);
4054+ Set_Identifier (N, Identifier);
4055+ return N;
4056+ end Make_Designator;
4057+
4058+ function Make_Defining_Program_Unit_Name (Sloc : Source_Ptr;
4059+ Name : Node_Id;
4060+ Defining_Identifier : Node_Id)
4061+ return Node_Id
4062+ is
4063+ N : constant Node_Id :=
4064+ New_Node (N_Defining_Program_Unit_Name, Sloc);
4065+ begin
4066+ Set_Name (N, Name);
4067+ Set_Defining_Identifier (N, Defining_Identifier);
4068+ return N;
4069+ end Make_Defining_Program_Unit_Name;
4070+
4071+ function Make_Operator_Symbol (Sloc : Source_Ptr;
4072+ Chars : Name_Id;
4073+ Strval : String_Id)
4074+ return Node_Id
4075+ is
4076+ N : constant Node_Id :=
4077+ New_Node (N_Operator_Symbol, Sloc);
4078+ begin
4079+ Set_Chars (N, Chars);
4080+ Set_Strval (N, Strval);
4081+ return N;
4082+ end Make_Operator_Symbol;
4083+
4084+ function Make_Defining_Operator_Symbol (Sloc : Source_Ptr;
4085+ Chars : Name_Id)
4086+ return Node_Id
4087+ is
4088+ N : constant Node_Id :=
4089+ New_Entity (N_Defining_Operator_Symbol, Sloc);
4090+ begin
4091+ Set_Chars (N, Chars);
4092+ return N;
4093+ end Make_Defining_Operator_Symbol;
4094+
4095+ function Make_Parameter_Specification (Sloc : Source_Ptr;
4096+ Defining_Identifier : Node_Id;
4097+ In_Present : Boolean := False;
4098+ Out_Present : Boolean := False;
4099+ Parameter_Type : Node_Id;
4100+ Expression : Node_Id := Empty)
4101+ return Node_Id
4102+ is
4103+ N : constant Node_Id :=
4104+ New_Node (N_Parameter_Specification, Sloc);
4105+ begin
4106+ Set_Defining_Identifier (N, Defining_Identifier);
4107+ Set_In_Present (N, In_Present);
4108+ Set_Out_Present (N, Out_Present);
4109+ Set_Parameter_Type (N, Parameter_Type);
4110+ Set_Expression (N, Expression);
4111+ return N;
4112+ end Make_Parameter_Specification;
4113+
4114+ function Make_Subprogram_Body (Sloc : Source_Ptr;
4115+ Specification : Node_Id;
4116+ Declarations : List_Id;
4117+ Handled_Statement_Sequence : Node_Id;
4118+ Bad_Is_Detected : Boolean := False)
4119+ return Node_Id
4120+ is
4121+ N : constant Node_Id :=
4122+ New_Node (N_Subprogram_Body, Sloc);
4123+ begin
4124+ Set_Specification (N, Specification);
4125+ Set_Declarations (N, Declarations);
4126+ Set_Handled_Statement_Sequence (N, Handled_Statement_Sequence);
4127+ Set_Bad_Is_Detected (N, Bad_Is_Detected);
4128+ return N;
4129+ end Make_Subprogram_Body;
4130+
4131+ function Make_Procedure_Call_Statement (Sloc : Source_Ptr;
4132+ Name : Node_Id;
4133+ Parameter_Associations : List_Id := No_List)
4134+ return Node_Id
4135+ is
4136+ N : constant Node_Id :=
4137+ New_Node (N_Procedure_Call_Statement, Sloc);
4138+ begin
4139+ Set_Name (N, Name);
4140+ Set_Parameter_Associations (N, Parameter_Associations);
4141+ return N;
4142+ end Make_Procedure_Call_Statement;
4143+
4144+ function Make_Function_Call (Sloc : Source_Ptr;
4145+ Name : Node_Id;
4146+ Parameter_Associations : List_Id := No_List)
4147+ return Node_Id
4148+ is
4149+ N : constant Node_Id :=
4150+ New_Node (N_Function_Call, Sloc);
4151+ begin
4152+ Set_Name (N, Name);
4153+ Set_Parameter_Associations (N, Parameter_Associations);
4154+ return N;
4155+ end Make_Function_Call;
4156+
4157+ function Make_Parameter_Association (Sloc : Source_Ptr;
4158+ Selector_Name : Node_Id;
4159+ Explicit_Actual_Parameter : Node_Id)
4160+ return Node_Id
4161+ is
4162+ N : constant Node_Id :=
4163+ New_Node (N_Parameter_Association, Sloc);
4164+ begin
4165+ Set_Selector_Name (N, Selector_Name);
4166+ Set_Explicit_Actual_Parameter (N, Explicit_Actual_Parameter);
4167+ return N;
4168+ end Make_Parameter_Association;
4169+
4170+ function Make_Return_Statement (Sloc : Source_Ptr;
4171+ Expression : Node_Id := Empty)
4172+ return Node_Id
4173+ is
4174+ N : constant Node_Id :=
4175+ New_Node (N_Return_Statement, Sloc);
4176+ begin
4177+ Set_Expression (N, Expression);
4178+ return N;
4179+ end Make_Return_Statement;
4180+
4181+ function Make_Package_Declaration (Sloc : Source_Ptr;
4182+ Specification : Node_Id)
4183+ return Node_Id
4184+ is
4185+ N : constant Node_Id :=
4186+ New_Node (N_Package_Declaration, Sloc);
4187+ begin
4188+ Set_Specification (N, Specification);
4189+ return N;
4190+ end Make_Package_Declaration;
4191+
4192+ function Make_Package_Specification (Sloc : Source_Ptr;
4193+ Defining_Unit_Name : Node_Id;
4194+ Visible_Declarations : List_Id;
4195+ Private_Declarations : List_Id := No_List;
4196+ End_Label : Node_Id)
4197+ return Node_Id
4198+ is
4199+ N : constant Node_Id :=
4200+ New_Node (N_Package_Specification, Sloc);
4201+ begin
4202+ Set_Defining_Unit_Name (N, Defining_Unit_Name);
4203+ Set_Visible_Declarations (N, Visible_Declarations);
4204+ Set_Private_Declarations (N, Private_Declarations);
4205+ Set_End_Label (N, End_Label);
4206+ return N;
4207+ end Make_Package_Specification;
4208+
4209+ function Make_Package_Body (Sloc : Source_Ptr;
4210+ Defining_Unit_Name : Node_Id;
4211+ Declarations : List_Id;
4212+ Handled_Statement_Sequence : Node_Id := Empty)
4213+ return Node_Id
4214+ is
4215+ N : constant Node_Id :=
4216+ New_Node (N_Package_Body, Sloc);
4217+ begin
4218+ Set_Defining_Unit_Name (N, Defining_Unit_Name);
4219+ Set_Declarations (N, Declarations);
4220+ Set_Handled_Statement_Sequence (N, Handled_Statement_Sequence);
4221+ return N;
4222+ end Make_Package_Body;
4223+
4224+ function Make_Private_Type_Declaration (Sloc : Source_Ptr;
4225+ Defining_Identifier : Node_Id;
4226+ Discriminant_Specifications : List_Id := No_List;
4227+ Unknown_Discriminants_Present : Boolean := False;
4228+ Abstract_Present : Boolean := False;
4229+ Tagged_Present : Boolean := False;
4230+ Limited_Present : Boolean := False)
4231+ return Node_Id
4232+ is
4233+ N : constant Node_Id :=
4234+ New_Node (N_Private_Type_Declaration, Sloc);
4235+ begin
4236+ Set_Defining_Identifier (N, Defining_Identifier);
4237+ Set_Discriminant_Specifications (N, Discriminant_Specifications);
4238+ Set_Unknown_Discriminants_Present
4239+ (N, Unknown_Discriminants_Present);
4240+ Set_Abstract_Present (N, Abstract_Present);
4241+ Set_Tagged_Present (N, Tagged_Present);
4242+ Set_Limited_Present (N, Limited_Present);
4243+ return N;
4244+ end Make_Private_Type_Declaration;
4245+
4246+ function Make_Private_Extension_Declaration (Sloc : Source_Ptr;
4247+ Defining_Identifier : Node_Id;
4248+ Discriminant_Specifications : List_Id := No_List;
4249+ Unknown_Discriminants_Present : Boolean := False;
4250+ Abstract_Present : Boolean := False;
4251+ Subtype_Indication : Node_Id)
4252+ return Node_Id
4253+ is
4254+ N : constant Node_Id :=
4255+ New_Node (N_Private_Extension_Declaration, Sloc);
4256+ begin
4257+ Set_Defining_Identifier (N, Defining_Identifier);
4258+ Set_Discriminant_Specifications (N, Discriminant_Specifications);
4259+ Set_Unknown_Discriminants_Present
4260+ (N, Unknown_Discriminants_Present);
4261+ Set_Abstract_Present (N, Abstract_Present);
4262+ Set_Subtype_Indication (N, Subtype_Indication);
4263+ return N;
4264+ end Make_Private_Extension_Declaration;
4265+
4266+ function Make_Use_Package_Clause (Sloc : Source_Ptr;
4267+ Names : List_Id)
4268+ return Node_Id
4269+ is
4270+ N : constant Node_Id :=
4271+ New_Node (N_Use_Package_Clause, Sloc);
4272+ begin
4273+ Set_Names (N, Names);
4274+ return N;
4275+ end Make_Use_Package_Clause;
4276+
4277+ function Make_Use_Type_Clause (Sloc : Source_Ptr;
4278+ Subtype_Marks : List_Id)
4279+ return Node_Id
4280+ is
4281+ N : constant Node_Id :=
4282+ New_Node (N_Use_Type_Clause, Sloc);
4283+ begin
4284+ Set_Subtype_Marks (N, Subtype_Marks);
4285+ return N;
4286+ end Make_Use_Type_Clause;
4287+
4288+ function Make_Object_Renaming_Declaration (Sloc : Source_Ptr;
4289+ Defining_Identifier : Node_Id;
4290+ Subtype_Mark : Node_Id;
4291+ Name : Node_Id)
4292+ return Node_Id
4293+ is
4294+ N : constant Node_Id :=
4295+ New_Node (N_Object_Renaming_Declaration, Sloc);
4296+ begin
4297+ Set_Defining_Identifier (N, Defining_Identifier);
4298+ Set_Subtype_Mark (N, Subtype_Mark);
4299+ Set_Name (N, Name);
4300+ return N;
4301+ end Make_Object_Renaming_Declaration;
4302+
4303+ function Make_Exception_Renaming_Declaration (Sloc : Source_Ptr;
4304+ Defining_Identifier : Node_Id;
4305+ Name : Node_Id)
4306+ return Node_Id
4307+ is
4308+ N : constant Node_Id :=
4309+ New_Node (N_Exception_Renaming_Declaration, Sloc);
4310+ begin
4311+ Set_Defining_Identifier (N, Defining_Identifier);
4312+ Set_Name (N, Name);
4313+ return N;
4314+ end Make_Exception_Renaming_Declaration;
4315+
4316+ function Make_Package_Renaming_Declaration (Sloc : Source_Ptr;
4317+ Defining_Unit_Name : Node_Id;
4318+ Name : Node_Id)
4319+ return Node_Id
4320+ is
4321+ N : constant Node_Id :=
4322+ New_Node (N_Package_Renaming_Declaration, Sloc);
4323+ begin
4324+ Set_Defining_Unit_Name (N, Defining_Unit_Name);
4325+ Set_Name (N, Name);
4326+ return N;
4327+ end Make_Package_Renaming_Declaration;
4328+
4329+ function Make_Subprogram_Renaming_Declaration (Sloc : Source_Ptr;
4330+ Specification : Node_Id;
4331+ Name : Node_Id)
4332+ return Node_Id
4333+ is
4334+ N : constant Node_Id :=
4335+ New_Node (N_Subprogram_Renaming_Declaration, Sloc);
4336+ begin
4337+ Set_Specification (N, Specification);
4338+ Set_Name (N, Name);
4339+ return N;
4340+ end Make_Subprogram_Renaming_Declaration;
4341+
4342+ function Make_Generic_Package_Renaming_Declaration (Sloc : Source_Ptr;
4343+ Defining_Unit_Name : Node_Id;
4344+ Name : Node_Id)
4345+ return Node_Id
4346+ is
4347+ N : constant Node_Id :=
4348+ New_Node (N_Generic_Package_Renaming_Declaration, Sloc);
4349+ begin
4350+ Set_Defining_Unit_Name (N, Defining_Unit_Name);
4351+ Set_Name (N, Name);
4352+ return N;
4353+ end Make_Generic_Package_Renaming_Declaration;
4354+
4355+ function Make_Generic_Procedure_Renaming_Declaration (Sloc : Source_Ptr;
4356+ Defining_Unit_Name : Node_Id;
4357+ Name : Node_Id)
4358+ return Node_Id
4359+ is
4360+ N : constant Node_Id :=
4361+ New_Node (N_Generic_Procedure_Renaming_Declaration, Sloc);
4362+ begin
4363+ Set_Defining_Unit_Name (N, Defining_Unit_Name);
4364+ Set_Name (N, Name);
4365+ return N;
4366+ end Make_Generic_Procedure_Renaming_Declaration;
4367+
4368+ function Make_Generic_Function_Renaming_Declaration (Sloc : Source_Ptr;
4369+ Defining_Unit_Name : Node_Id;
4370+ Name : Node_Id)
4371+ return Node_Id
4372+ is
4373+ N : constant Node_Id :=
4374+ New_Node (N_Generic_Function_Renaming_Declaration, Sloc);
4375+ begin
4376+ Set_Defining_Unit_Name (N, Defining_Unit_Name);
4377+ Set_Name (N, Name);
4378+ return N;
4379+ end Make_Generic_Function_Renaming_Declaration;
4380+
4381+ function Make_Task_Type_Declaration (Sloc : Source_Ptr;
4382+ Defining_Identifier : Node_Id;
4383+ Discriminant_Specifications : List_Id := No_List;
4384+ Task_Definition : Node_Id := Empty)
4385+ return Node_Id
4386+ is
4387+ N : constant Node_Id :=
4388+ New_Node (N_Task_Type_Declaration, Sloc);
4389+ begin
4390+ Set_Defining_Identifier (N, Defining_Identifier);
4391+ Set_Discriminant_Specifications (N, Discriminant_Specifications);
4392+ Set_Task_Definition (N, Task_Definition);
4393+ return N;
4394+ end Make_Task_Type_Declaration;
4395+
4396+ function Make_Single_Task_Declaration (Sloc : Source_Ptr;
4397+ Defining_Identifier : Node_Id;
4398+ Task_Definition : Node_Id := Empty)
4399+ return Node_Id
4400+ is
4401+ N : constant Node_Id :=
4402+ New_Node (N_Single_Task_Declaration, Sloc);
4403+ begin
4404+ Set_Defining_Identifier (N, Defining_Identifier);
4405+ Set_Task_Definition (N, Task_Definition);
4406+ return N;
4407+ end Make_Single_Task_Declaration;
4408+
4409+ function Make_Task_Definition (Sloc : Source_Ptr;
4410+ Visible_Declarations : List_Id;
4411+ Private_Declarations : List_Id := No_List;
4412+ End_Label : Node_Id)
4413+ return Node_Id
4414+ is
4415+ N : constant Node_Id :=
4416+ New_Node (N_Task_Definition, Sloc);
4417+ begin
4418+ Set_Visible_Declarations (N, Visible_Declarations);
4419+ Set_Private_Declarations (N, Private_Declarations);
4420+ Set_End_Label (N, End_Label);
4421+ return N;
4422+ end Make_Task_Definition;
4423+
4424+ function Make_Task_Body (Sloc : Source_Ptr;
4425+ Defining_Identifier : Node_Id;
4426+ Declarations : List_Id;
4427+ Handled_Statement_Sequence : Node_Id)
4428+ return Node_Id
4429+ is
4430+ N : constant Node_Id :=
4431+ New_Node (N_Task_Body, Sloc);
4432+ begin
4433+ Set_Defining_Identifier (N, Defining_Identifier);
4434+ Set_Declarations (N, Declarations);
4435+ Set_Handled_Statement_Sequence (N, Handled_Statement_Sequence);
4436+ return N;
4437+ end Make_Task_Body;
4438+
4439+ function Make_Protected_Type_Declaration (Sloc : Source_Ptr;
4440+ Defining_Identifier : Node_Id;
4441+ Discriminant_Specifications : List_Id := No_List;
4442+ Protected_Definition : Node_Id)
4443+ return Node_Id
4444+ is
4445+ N : constant Node_Id :=
4446+ New_Node (N_Protected_Type_Declaration, Sloc);
4447+ begin
4448+ Set_Defining_Identifier (N, Defining_Identifier);
4449+ Set_Discriminant_Specifications (N, Discriminant_Specifications);
4450+ Set_Protected_Definition (N, Protected_Definition);
4451+ return N;
4452+ end Make_Protected_Type_Declaration;
4453+
4454+ function Make_Single_Protected_Declaration (Sloc : Source_Ptr;
4455+ Defining_Identifier : Node_Id;
4456+ Protected_Definition : Node_Id)
4457+ return Node_Id
4458+ is
4459+ N : constant Node_Id :=
4460+ New_Node (N_Single_Protected_Declaration, Sloc);
4461+ begin
4462+ Set_Defining_Identifier (N, Defining_Identifier);
4463+ Set_Protected_Definition (N, Protected_Definition);
4464+ return N;
4465+ end Make_Single_Protected_Declaration;
4466+
4467+ function Make_Protected_Definition (Sloc : Source_Ptr;
4468+ Visible_Declarations : List_Id;
4469+ Private_Declarations : List_Id := No_List;
4470+ End_Label : Node_Id)
4471+ return Node_Id
4472+ is
4473+ N : constant Node_Id :=
4474+ New_Node (N_Protected_Definition, Sloc);
4475+ begin
4476+ Set_Visible_Declarations (N, Visible_Declarations);
4477+ Set_Private_Declarations (N, Private_Declarations);
4478+ Set_End_Label (N, End_Label);
4479+ return N;
4480+ end Make_Protected_Definition;
4481+
4482+ function Make_Protected_Body (Sloc : Source_Ptr;
4483+ Defining_Identifier : Node_Id;
4484+ Declarations : List_Id;
4485+ End_Label : Node_Id)
4486+ return Node_Id
4487+ is
4488+ N : constant Node_Id :=
4489+ New_Node (N_Protected_Body, Sloc);
4490+ begin
4491+ Set_Defining_Identifier (N, Defining_Identifier);
4492+ Set_Declarations (N, Declarations);
4493+ Set_End_Label (N, End_Label);
4494+ return N;
4495+ end Make_Protected_Body;
4496+
4497+ function Make_Entry_Declaration (Sloc : Source_Ptr;
4498+ Defining_Identifier : Node_Id;
4499+ Discrete_Subtype_Definition : Node_Id := Empty;
4500+ Parameter_Specifications : List_Id := No_List)
4501+ return Node_Id
4502+ is
4503+ N : constant Node_Id :=
4504+ New_Node (N_Entry_Declaration, Sloc);
4505+ begin
4506+ Set_Defining_Identifier (N, Defining_Identifier);
4507+ Set_Discrete_Subtype_Definition (N, Discrete_Subtype_Definition);
4508+ Set_Parameter_Specifications (N, Parameter_Specifications);
4509+ return N;
4510+ end Make_Entry_Declaration;
4511+
4512+ function Make_Accept_Statement (Sloc : Source_Ptr;
4513+ Entry_Direct_Name : Node_Id;
4514+ Entry_Index : Node_Id := Empty;
4515+ Parameter_Specifications : List_Id := No_List;
4516+ Handled_Statement_Sequence : Node_Id;
4517+ Declarations : List_Id := No_List)
4518+ return Node_Id
4519+ is
4520+ N : constant Node_Id :=
4521+ New_Node (N_Accept_Statement, Sloc);
4522+ begin
4523+ Set_Entry_Direct_Name (N, Entry_Direct_Name);
4524+ Set_Entry_Index (N, Entry_Index);
4525+ Set_Parameter_Specifications (N, Parameter_Specifications);
4526+ Set_Handled_Statement_Sequence (N, Handled_Statement_Sequence);
4527+ Set_Declarations (N, Declarations);
4528+ return N;
4529+ end Make_Accept_Statement;
4530+
4531+ function Make_Entry_Body (Sloc : Source_Ptr;
4532+ Defining_Identifier : Node_Id;
4533+ Entry_Body_Formal_Part : Node_Id;
4534+ Declarations : List_Id;
4535+ Handled_Statement_Sequence : Node_Id)
4536+ return Node_Id
4537+ is
4538+ N : constant Node_Id :=
4539+ New_Node (N_Entry_Body, Sloc);
4540+ begin
4541+ Set_Defining_Identifier (N, Defining_Identifier);
4542+ Set_Entry_Body_Formal_Part (N, Entry_Body_Formal_Part);
4543+ Set_Declarations (N, Declarations);
4544+ Set_Handled_Statement_Sequence (N, Handled_Statement_Sequence);
4545+ return N;
4546+ end Make_Entry_Body;
4547+
4548+ function Make_Entry_Body_Formal_Part (Sloc : Source_Ptr;
4549+ Entry_Index_Specification : Node_Id := Empty;
4550+ Parameter_Specifications : List_Id := No_List;
4551+ Condition : Node_Id)
4552+ return Node_Id
4553+ is
4554+ N : constant Node_Id :=
4555+ New_Node (N_Entry_Body_Formal_Part, Sloc);
4556+ begin
4557+ Set_Entry_Index_Specification (N, Entry_Index_Specification);
4558+ Set_Parameter_Specifications (N, Parameter_Specifications);
4559+ Set_Condition (N, Condition);
4560+ return N;
4561+ end Make_Entry_Body_Formal_Part;
4562+
4563+ function Make_Entry_Index_Specification (Sloc : Source_Ptr;
4564+ Defining_Identifier : Node_Id;
4565+ Discrete_Subtype_Definition : Node_Id)
4566+ return Node_Id
4567+ is
4568+ N : constant Node_Id :=
4569+ New_Node (N_Entry_Index_Specification, Sloc);
4570+ begin
4571+ Set_Defining_Identifier (N, Defining_Identifier);
4572+ Set_Discrete_Subtype_Definition (N, Discrete_Subtype_Definition);
4573+ return N;
4574+ end Make_Entry_Index_Specification;
4575+
4576+ function Make_Entry_Call_Statement (Sloc : Source_Ptr;
4577+ Name : Node_Id;
4578+ Parameter_Associations : List_Id := No_List)
4579+ return Node_Id
4580+ is
4581+ N : constant Node_Id :=
4582+ New_Node (N_Entry_Call_Statement, Sloc);
4583+ begin
4584+ Set_Name (N, Name);
4585+ Set_Parameter_Associations (N, Parameter_Associations);
4586+ return N;
4587+ end Make_Entry_Call_Statement;
4588+
4589+ function Make_Requeue_Statement (Sloc : Source_Ptr;
4590+ Name : Node_Id;
4591+ Abort_Present : Boolean := False)
4592+ return Node_Id
4593+ is
4594+ N : constant Node_Id :=
4595+ New_Node (N_Requeue_Statement, Sloc);
4596+ begin
4597+ Set_Name (N, Name);
4598+ Set_Abort_Present (N, Abort_Present);
4599+ return N;
4600+ end Make_Requeue_Statement;
4601+
4602+ function Make_Delay_Until_Statement (Sloc : Source_Ptr;
4603+ Expression : Node_Id)
4604+ return Node_Id
4605+ is
4606+ N : constant Node_Id :=
4607+ New_Node (N_Delay_Until_Statement, Sloc);
4608+ begin
4609+ Set_Expression (N, Expression);
4610+ return N;
4611+ end Make_Delay_Until_Statement;
4612+
4613+ function Make_Delay_Relative_Statement (Sloc : Source_Ptr;
4614+ Expression : Node_Id)
4615+ return Node_Id
4616+ is
4617+ N : constant Node_Id :=
4618+ New_Node (N_Delay_Relative_Statement, Sloc);
4619+ begin
4620+ Set_Expression (N, Expression);
4621+ return N;
4622+ end Make_Delay_Relative_Statement;
4623+
4624+ function Make_Selective_Accept (Sloc : Source_Ptr;
4625+ Select_Alternatives : List_Id;
4626+ Else_Statements : List_Id := No_List)
4627+ return Node_Id
4628+ is
4629+ N : constant Node_Id :=
4630+ New_Node (N_Selective_Accept, Sloc);
4631+ begin
4632+ Set_Select_Alternatives (N, Select_Alternatives);
4633+ Set_Else_Statements (N, Else_Statements);
4634+ return N;
4635+ end Make_Selective_Accept;
4636+
4637+ function Make_Accept_Alternative (Sloc : Source_Ptr;
4638+ Accept_Statement : Node_Id;
4639+ Condition : Node_Id := Empty;
4640+ Statements : List_Id := Empty_List;
4641+ Pragmas_Before : List_Id := No_List)
4642+ return Node_Id
4643+ is
4644+ N : constant Node_Id :=
4645+ New_Node (N_Accept_Alternative, Sloc);
4646+ begin
4647+ Set_Accept_Statement (N, Accept_Statement);
4648+ Set_Condition (N, Condition);
4649+ Set_Statements (N, Statements);
4650+ Set_Pragmas_Before (N, Pragmas_Before);
4651+ return N;
4652+ end Make_Accept_Alternative;
4653+
4654+ function Make_Delay_Alternative (Sloc : Source_Ptr;
4655+ Delay_Statement : Node_Id;
4656+ Condition : Node_Id := Empty;
4657+ Statements : List_Id := Empty_List;
4658+ Pragmas_Before : List_Id := No_List)
4659+ return Node_Id
4660+ is
4661+ N : constant Node_Id :=
4662+ New_Node (N_Delay_Alternative, Sloc);
4663+ begin
4664+ Set_Delay_Statement (N, Delay_Statement);
4665+ Set_Condition (N, Condition);
4666+ Set_Statements (N, Statements);
4667+ Set_Pragmas_Before (N, Pragmas_Before);
4668+ return N;
4669+ end Make_Delay_Alternative;
4670+
4671+ function Make_Terminate_Alternative (Sloc : Source_Ptr;
4672+ Condition : Node_Id := Empty;
4673+ Pragmas_Before : List_Id := No_List;
4674+ Pragmas_After : List_Id := No_List)
4675+ return Node_Id
4676+ is
4677+ N : constant Node_Id :=
4678+ New_Node (N_Terminate_Alternative, Sloc);
4679+ begin
4680+ Set_Condition (N, Condition);
4681+ Set_Pragmas_Before (N, Pragmas_Before);
4682+ Set_Pragmas_After (N, Pragmas_After);
4683+ return N;
4684+ end Make_Terminate_Alternative;
4685+
4686+ function Make_Timed_Entry_Call (Sloc : Source_Ptr;
4687+ Entry_Call_Alternative : Node_Id;
4688+ Delay_Alternative : Node_Id)
4689+ return Node_Id
4690+ is
4691+ N : constant Node_Id :=
4692+ New_Node (N_Timed_Entry_Call, Sloc);
4693+ begin
4694+ Set_Entry_Call_Alternative (N, Entry_Call_Alternative);
4695+ Set_Delay_Alternative (N, Delay_Alternative);
4696+ return N;
4697+ end Make_Timed_Entry_Call;
4698+
4699+ function Make_Entry_Call_Alternative (Sloc : Source_Ptr;
4700+ Entry_Call_Statement : Node_Id;
4701+ Statements : List_Id := Empty_List;
4702+ Pragmas_Before : List_Id := No_List)
4703+ return Node_Id
4704+ is
4705+ N : constant Node_Id :=
4706+ New_Node (N_Entry_Call_Alternative, Sloc);
4707+ begin
4708+ Set_Entry_Call_Statement (N, Entry_Call_Statement);
4709+ Set_Statements (N, Statements);
4710+ Set_Pragmas_Before (N, Pragmas_Before);
4711+ return N;
4712+ end Make_Entry_Call_Alternative;
4713+
4714+ function Make_Conditional_Entry_Call (Sloc : Source_Ptr;
4715+ Entry_Call_Alternative : Node_Id;
4716+ Else_Statements : List_Id)
4717+ return Node_Id
4718+ is
4719+ N : constant Node_Id :=
4720+ New_Node (N_Conditional_Entry_Call, Sloc);
4721+ begin
4722+ Set_Entry_Call_Alternative (N, Entry_Call_Alternative);
4723+ Set_Else_Statements (N, Else_Statements);
4724+ return N;
4725+ end Make_Conditional_Entry_Call;
4726+
4727+ function Make_Asynchronous_Select (Sloc : Source_Ptr;
4728+ Triggering_Alternative : Node_Id;
4729+ Abortable_Part : Node_Id)
4730+ return Node_Id
4731+ is
4732+ N : constant Node_Id :=
4733+ New_Node (N_Asynchronous_Select, Sloc);
4734+ begin
4735+ Set_Triggering_Alternative (N, Triggering_Alternative);
4736+ Set_Abortable_Part (N, Abortable_Part);
4737+ return N;
4738+ end Make_Asynchronous_Select;
4739+
4740+ function Make_Triggering_Alternative (Sloc : Source_Ptr;
4741+ Triggering_Statement : Node_Id;
4742+ Statements : List_Id := Empty_List;
4743+ Pragmas_Before : List_Id := No_List)
4744+ return Node_Id
4745+ is
4746+ N : constant Node_Id :=
4747+ New_Node (N_Triggering_Alternative, Sloc);
4748+ begin
4749+ Set_Triggering_Statement (N, Triggering_Statement);
4750+ Set_Statements (N, Statements);
4751+ Set_Pragmas_Before (N, Pragmas_Before);
4752+ return N;
4753+ end Make_Triggering_Alternative;
4754+
4755+ function Make_Abortable_Part (Sloc : Source_Ptr;
4756+ Statements : List_Id)
4757+ return Node_Id
4758+ is
4759+ N : constant Node_Id :=
4760+ New_Node (N_Abortable_Part, Sloc);
4761+ begin
4762+ Set_Statements (N, Statements);
4763+ return N;
4764+ end Make_Abortable_Part;
4765+
4766+ function Make_Abort_Statement (Sloc : Source_Ptr;
4767+ Names : List_Id)
4768+ return Node_Id
4769+ is
4770+ N : constant Node_Id :=
4771+ New_Node (N_Abort_Statement, Sloc);
4772+ begin
4773+ Set_Names (N, Names);
4774+ return N;
4775+ end Make_Abort_Statement;
4776+
4777+ function Make_Compilation_Unit (Sloc : Source_Ptr;
4778+ Context_Items : List_Id;
4779+ Private_Present : Boolean := False;
4780+ Unit : Node_Id;
4781+ Aux_Decls_Node : Node_Id)
4782+ return Node_Id
4783+ is
4784+ N : constant Node_Id :=
4785+ New_Node (N_Compilation_Unit, Sloc);
4786+ begin
4787+ Set_Context_Items (N, Context_Items);
4788+ Set_Private_Present (N, Private_Present);
4789+ Set_Unit (N, Unit);
4790+ Set_Aux_Decls_Node (N, Aux_Decls_Node);
4791+ return N;
4792+ end Make_Compilation_Unit;
4793+
4794+ function Make_Compilation_Unit_Aux (Sloc : Source_Ptr;
4795+ Declarations : List_Id := No_List;
4796+ Actions : List_Id := No_List;
4797+ Pragmas_After : List_Id := No_List;
4798+ Config_Pragmas : List_Id := Empty_List)
4799+ return Node_Id
4800+ is
4801+ N : constant Node_Id :=
4802+ New_Node (N_Compilation_Unit_Aux, Sloc);
4803+ begin
4804+ Set_Declarations (N, Declarations);
4805+ Set_Actions (N, Actions);
4806+ Set_Pragmas_After (N, Pragmas_After);
4807+ Set_Config_Pragmas (N, Config_Pragmas);
4808+ return N;
4809+ end Make_Compilation_Unit_Aux;
4810+
4811+ function Make_With_Clause (Sloc : Source_Ptr;
4812+ Name : Node_Id;
4813+ First_Name : Boolean := True;
4814+ Last_Name : Boolean := True;
4815+ Limited_Present : Boolean := False)
4816+ return Node_Id
4817+ is
4818+ N : constant Node_Id :=
4819+ New_Node (N_With_Clause, Sloc);
4820+ begin
4821+ Set_Name (N, Name);
4822+ Set_First_Name (N, First_Name);
4823+ Set_Last_Name (N, Last_Name);
4824+ Set_Limited_Present (N, Limited_Present);
4825+ return N;
4826+ end Make_With_Clause;
4827+
4828+ function Make_With_Type_Clause (Sloc : Source_Ptr;
4829+ Name : Node_Id;
4830+ Tagged_Present : Boolean := False)
4831+ return Node_Id
4832+ is
4833+ N : constant Node_Id :=
4834+ New_Node (N_With_Type_Clause, Sloc);
4835+ begin
4836+ Set_Name (N, Name);
4837+ Set_Tagged_Present (N, Tagged_Present);
4838+ return N;
4839+ end Make_With_Type_Clause;
4840+
4841+ function Make_Subprogram_Body_Stub (Sloc : Source_Ptr;
4842+ Specification : Node_Id)
4843+ return Node_Id
4844+ is
4845+ N : constant Node_Id :=
4846+ New_Node (N_Subprogram_Body_Stub, Sloc);
4847+ begin
4848+ Set_Specification (N, Specification);
4849+ return N;
4850+ end Make_Subprogram_Body_Stub;
4851+
4852+ function Make_Package_Body_Stub (Sloc : Source_Ptr;
4853+ Defining_Identifier : Node_Id)
4854+ return Node_Id
4855+ is
4856+ N : constant Node_Id :=
4857+ New_Node (N_Package_Body_Stub, Sloc);
4858+ begin
4859+ Set_Defining_Identifier (N, Defining_Identifier);
4860+ return N;
4861+ end Make_Package_Body_Stub;
4862+
4863+ function Make_Task_Body_Stub (Sloc : Source_Ptr;
4864+ Defining_Identifier : Node_Id)
4865+ return Node_Id
4866+ is
4867+ N : constant Node_Id :=
4868+ New_Node (N_Task_Body_Stub, Sloc);
4869+ begin
4870+ Set_Defining_Identifier (N, Defining_Identifier);
4871+ return N;
4872+ end Make_Task_Body_Stub;
4873+
4874+ function Make_Protected_Body_Stub (Sloc : Source_Ptr;
4875+ Defining_Identifier : Node_Id)
4876+ return Node_Id
4877+ is
4878+ N : constant Node_Id :=
4879+ New_Node (N_Protected_Body_Stub, Sloc);
4880+ begin
4881+ Set_Defining_Identifier (N, Defining_Identifier);
4882+ return N;
4883+ end Make_Protected_Body_Stub;
4884+
4885+ function Make_Subunit (Sloc : Source_Ptr;
4886+ Name : Node_Id;
4887+ Proper_Body : Node_Id)
4888+ return Node_Id
4889+ is
4890+ N : constant Node_Id :=
4891+ New_Node (N_Subunit, Sloc);
4892+ begin
4893+ Set_Name (N, Name);
4894+ Set_Proper_Body (N, Proper_Body);
4895+ return N;
4896+ end Make_Subunit;
4897+
4898+ function Make_Exception_Declaration (Sloc : Source_Ptr;
4899+ Defining_Identifier : Node_Id)
4900+ return Node_Id
4901+ is
4902+ N : constant Node_Id :=
4903+ New_Node (N_Exception_Declaration, Sloc);
4904+ begin
4905+ Set_Defining_Identifier (N, Defining_Identifier);
4906+ return N;
4907+ end Make_Exception_Declaration;
4908+
4909+ function Make_Handled_Sequence_Of_Statements (Sloc : Source_Ptr;
4910+ Statements : List_Id;
4911+ End_Label : Node_Id := Empty;
4912+ Exception_Handlers : List_Id := No_List;
4913+ At_End_Proc : Node_Id := Empty)
4914+ return Node_Id
4915+ is
4916+ N : constant Node_Id :=
4917+ New_Node (N_Handled_Sequence_Of_Statements, Sloc);
4918+ begin
4919+ Set_Statements (N, Statements);
4920+ Set_End_Label (N, End_Label);
4921+ Set_Exception_Handlers (N, Exception_Handlers);
4922+ Set_At_End_Proc (N, At_End_Proc);
4923+ return N;
4924+ end Make_Handled_Sequence_Of_Statements;
4925+
4926+ function Make_Exception_Handler (Sloc : Source_Ptr;
4927+ Choice_Parameter : Node_Id := Empty;
4928+ Exception_Choices : List_Id;
4929+ Statements : List_Id)
4930+ return Node_Id
4931+ is
4932+ N : constant Node_Id :=
4933+ New_Node (N_Exception_Handler, Sloc);
4934+ begin
4935+ Set_Choice_Parameter (N, Choice_Parameter);
4936+ Set_Exception_Choices (N, Exception_Choices);
4937+ Set_Statements (N, Statements);
4938+ return N;
4939+ end Make_Exception_Handler;
4940+
4941+ function Make_Raise_Statement (Sloc : Source_Ptr;
4942+ Name : Node_Id := Empty)
4943+ return Node_Id
4944+ is
4945+ N : constant Node_Id :=
4946+ New_Node (N_Raise_Statement, Sloc);
4947+ begin
4948+ Set_Name (N, Name);
4949+ return N;
4950+ end Make_Raise_Statement;
4951+
4952+ function Make_Generic_Subprogram_Declaration (Sloc : Source_Ptr;
4953+ Specification : Node_Id;
4954+ Generic_Formal_Declarations : List_Id)
4955+ return Node_Id
4956+ is
4957+ N : constant Node_Id :=
4958+ New_Node (N_Generic_Subprogram_Declaration, Sloc);
4959+ begin
4960+ Set_Specification (N, Specification);
4961+ Set_Generic_Formal_Declarations (N, Generic_Formal_Declarations);
4962+ return N;
4963+ end Make_Generic_Subprogram_Declaration;
4964+
4965+ function Make_Generic_Package_Declaration (Sloc : Source_Ptr;
4966+ Specification : Node_Id;
4967+ Generic_Formal_Declarations : List_Id)
4968+ return Node_Id
4969+ is
4970+ N : constant Node_Id :=
4971+ New_Node (N_Generic_Package_Declaration, Sloc);
4972+ begin
4973+ Set_Specification (N, Specification);
4974+ Set_Generic_Formal_Declarations (N, Generic_Formal_Declarations);
4975+ return N;
4976+ end Make_Generic_Package_Declaration;
4977+
4978+ function Make_Package_Instantiation (Sloc : Source_Ptr;
4979+ Defining_Unit_Name : Node_Id;
4980+ Name : Node_Id;
4981+ Generic_Associations : List_Id := No_List)
4982+ return Node_Id
4983+ is
4984+ N : constant Node_Id :=
4985+ New_Node (N_Package_Instantiation, Sloc);
4986+ begin
4987+ Set_Defining_Unit_Name (N, Defining_Unit_Name);
4988+ Set_Name (N, Name);
4989+ Set_Generic_Associations (N, Generic_Associations);
4990+ return N;
4991+ end Make_Package_Instantiation;
4992+
4993+ function Make_Procedure_Instantiation (Sloc : Source_Ptr;
4994+ Defining_Unit_Name : Node_Id;
4995+ Name : Node_Id;
4996+ Generic_Associations : List_Id := No_List)
4997+ return Node_Id
4998+ is
4999+ N : constant Node_Id :=
5000+ New_Node (N_Procedure_Instantiation, Sloc);
5001+ begin
5002+ Set_Defining_Unit_Name (N, Defining_Unit_Name);
5003+ Set_Name (N, Name);
5004+ Set_Generic_Associations (N, Generic_Associations);
5005+ return N;
5006+ end Make_Procedure_Instantiation;
5007+
5008+ function Make_Function_Instantiation (Sloc : Source_Ptr;
5009+ Defining_Unit_Name : Node_Id;
5010+ Name : Node_Id;
5011+ Generic_Associations : List_Id := No_List)
5012+ return Node_Id
5013+ is
5014+ N : constant Node_Id :=
5015+ New_Node (N_Function_Instantiation, Sloc);
5016+ begin
5017+ Set_Defining_Unit_Name (N, Defining_Unit_Name);
5018+ Set_Name (N, Name);
5019+ Set_Generic_Associations (N, Generic_Associations);
5020+ return N;
5021+ end Make_Function_Instantiation;
5022+
5023+ function Make_Generic_Association (Sloc : Source_Ptr;
5024+ Selector_Name : Node_Id := Empty;
5025+ Explicit_Generic_Actual_Parameter : Node_Id)
5026+ return Node_Id
5027+ is
5028+ N : constant Node_Id :=
5029+ New_Node (N_Generic_Association, Sloc);
5030+ begin
5031+ Set_Selector_Name (N, Selector_Name);
5032+ Set_Explicit_Generic_Actual_Parameter
5033+ (N, Explicit_Generic_Actual_Parameter);
5034+ return N;
5035+ end Make_Generic_Association;
5036+
5037+ function Make_Formal_Object_Declaration (Sloc : Source_Ptr;
5038+ Defining_Identifier : Node_Id;
5039+ In_Present : Boolean := False;
5040+ Out_Present : Boolean := False;
5041+ Subtype_Mark : Node_Id;
5042+ Expression : Node_Id := Empty)
5043+ return Node_Id
5044+ is
5045+ N : constant Node_Id :=
5046+ New_Node (N_Formal_Object_Declaration, Sloc);
5047+ begin
5048+ Set_Defining_Identifier (N, Defining_Identifier);
5049+ Set_In_Present (N, In_Present);
5050+ Set_Out_Present (N, Out_Present);
5051+ Set_Subtype_Mark (N, Subtype_Mark);
5052+ Set_Expression (N, Expression);
5053+ return N;
5054+ end Make_Formal_Object_Declaration;
5055+
5056+ function Make_Formal_Type_Declaration (Sloc : Source_Ptr;
5057+ Defining_Identifier : Node_Id;
5058+ Formal_Type_Definition : Node_Id;
5059+ Discriminant_Specifications : List_Id := No_List;
5060+ Unknown_Discriminants_Present : Boolean := False)
5061+ return Node_Id
5062+ is
5063+ N : constant Node_Id :=
5064+ New_Node (N_Formal_Type_Declaration, Sloc);
5065+ begin
5066+ Set_Defining_Identifier (N, Defining_Identifier);
5067+ Set_Formal_Type_Definition (N, Formal_Type_Definition);
5068+ Set_Discriminant_Specifications (N, Discriminant_Specifications);
5069+ Set_Unknown_Discriminants_Present
5070+ (N, Unknown_Discriminants_Present);
5071+ return N;
5072+ end Make_Formal_Type_Declaration;
5073+
5074+ function Make_Formal_Private_Type_Definition (Sloc : Source_Ptr;
5075+ Abstract_Present : Boolean := False;
5076+ Tagged_Present : Boolean := False;
5077+ Limited_Present : Boolean := False)
5078+ return Node_Id
5079+ is
5080+ N : constant Node_Id :=
5081+ New_Node (N_Formal_Private_Type_Definition, Sloc);
5082+ begin
5083+ Set_Abstract_Present (N, Abstract_Present);
5084+ Set_Tagged_Present (N, Tagged_Present);
5085+ Set_Limited_Present (N, Limited_Present);
5086+ return N;
5087+ end Make_Formal_Private_Type_Definition;
5088+
5089+ function Make_Formal_Derived_Type_Definition (Sloc : Source_Ptr;
5090+ Subtype_Mark : Node_Id;
5091+ Private_Present : Boolean := False;
5092+ Abstract_Present : Boolean := False)
5093+ return Node_Id
5094+ is
5095+ N : constant Node_Id :=
5096+ New_Node (N_Formal_Derived_Type_Definition, Sloc);
5097+ begin
5098+ Set_Subtype_Mark (N, Subtype_Mark);
5099+ Set_Private_Present (N, Private_Present);
5100+ Set_Abstract_Present (N, Abstract_Present);
5101+ return N;
5102+ end Make_Formal_Derived_Type_Definition;
5103+
5104+ function Make_Formal_Discrete_Type_Definition (Sloc : Source_Ptr)
5105+ return Node_Id
5106+ is
5107+ N : constant Node_Id :=
5108+ New_Node (N_Formal_Discrete_Type_Definition, Sloc);
5109+ begin
5110+ return N;
5111+ end Make_Formal_Discrete_Type_Definition;
5112+
5113+ function Make_Formal_Signed_Integer_Type_Definition (Sloc : Source_Ptr)
5114+ return Node_Id
5115+ is
5116+ N : constant Node_Id :=
5117+ New_Node (N_Formal_Signed_Integer_Type_Definition, Sloc);
5118+ begin
5119+ return N;
5120+ end Make_Formal_Signed_Integer_Type_Definition;
5121+
5122+ function Make_Formal_Modular_Type_Definition (Sloc : Source_Ptr)
5123+ return Node_Id
5124+ is
5125+ N : constant Node_Id :=
5126+ New_Node (N_Formal_Modular_Type_Definition, Sloc);
5127+ begin
5128+ return N;
5129+ end Make_Formal_Modular_Type_Definition;
5130+
5131+ function Make_Formal_Floating_Point_Definition (Sloc : Source_Ptr)
5132+ return Node_Id
5133+ is
5134+ N : constant Node_Id :=
5135+ New_Node (N_Formal_Floating_Point_Definition, Sloc);
5136+ begin
5137+ return N;
5138+ end Make_Formal_Floating_Point_Definition;
5139+
5140+ function Make_Formal_Ordinary_Fixed_Point_Definition (Sloc : Source_Ptr)
5141+ return Node_Id
5142+ is
5143+ N : constant Node_Id :=
5144+ New_Node (N_Formal_Ordinary_Fixed_Point_Definition, Sloc);
5145+ begin
5146+ return N;
5147+ end Make_Formal_Ordinary_Fixed_Point_Definition;
5148+
5149+ function Make_Formal_Decimal_Fixed_Point_Definition (Sloc : Source_Ptr)
5150+ return Node_Id
5151+ is
5152+ N : constant Node_Id :=
5153+ New_Node (N_Formal_Decimal_Fixed_Point_Definition, Sloc);
5154+ begin
5155+ return N;
5156+ end Make_Formal_Decimal_Fixed_Point_Definition;
5157+
5158+ function Make_Formal_Subprogram_Declaration (Sloc : Source_Ptr;
5159+ Specification : Node_Id;
5160+ Default_Name : Node_Id := Empty;
5161+ Box_Present : Boolean := False)
5162+ return Node_Id
5163+ is
5164+ N : constant Node_Id :=
5165+ New_Node (N_Formal_Subprogram_Declaration, Sloc);
5166+ begin
5167+ Set_Specification (N, Specification);
5168+ Set_Default_Name (N, Default_Name);
5169+ Set_Box_Present (N, Box_Present);
5170+ return N;
5171+ end Make_Formal_Subprogram_Declaration;
5172+
5173+ function Make_Formal_Package_Declaration (Sloc : Source_Ptr;
5174+ Defining_Identifier : Node_Id;
5175+ Name : Node_Id;
5176+ Generic_Associations : List_Id := No_List;
5177+ Box_Present : Boolean := False)
5178+ return Node_Id
5179+ is
5180+ N : constant Node_Id :=
5181+ New_Node (N_Formal_Package_Declaration, Sloc);
5182+ begin
5183+ Set_Defining_Identifier (N, Defining_Identifier);
5184+ Set_Name (N, Name);
5185+ Set_Generic_Associations (N, Generic_Associations);
5186+ Set_Box_Present (N, Box_Present);
5187+ return N;
5188+ end Make_Formal_Package_Declaration;
5189+
5190+ function Make_Attribute_Definition_Clause (Sloc : Source_Ptr;
5191+ Name : Node_Id;
5192+ Chars : Name_Id;
5193+ Expression : Node_Id)
5194+ return Node_Id
5195+ is
5196+ N : constant Node_Id :=
5197+ New_Node (N_Attribute_Definition_Clause, Sloc);
5198+ begin
5199+ Set_Name (N, Name);
5200+ Set_Chars (N, Chars);
5201+ Set_Expression (N, Expression);
5202+ return N;
5203+ end Make_Attribute_Definition_Clause;
5204+
5205+ function Make_Enumeration_Representation_Clause (Sloc : Source_Ptr;
5206+ Identifier : Node_Id;
5207+ Array_Aggregate : Node_Id)
5208+ return Node_Id
5209+ is
5210+ N : constant Node_Id :=
5211+ New_Node (N_Enumeration_Representation_Clause, Sloc);
5212+ begin
5213+ Set_Identifier (N, Identifier);
5214+ Set_Array_Aggregate (N, Array_Aggregate);
5215+ return N;
5216+ end Make_Enumeration_Representation_Clause;
5217+
5218+ function Make_Record_Representation_Clause (Sloc : Source_Ptr;
5219+ Identifier : Node_Id;
5220+ Mod_Clause : Node_Id := Empty;
5221+ Component_Clauses : List_Id)
5222+ return Node_Id
5223+ is
5224+ N : constant Node_Id :=
5225+ New_Node (N_Record_Representation_Clause, Sloc);
5226+ begin
5227+ Set_Identifier (N, Identifier);
5228+ Set_Mod_Clause (N, Mod_Clause);
5229+ Set_Component_Clauses (N, Component_Clauses);
5230+ return N;
5231+ end Make_Record_Representation_Clause;
5232+
5233+ function Make_Component_Clause (Sloc : Source_Ptr;
5234+ Component_Name : Node_Id;
5235+ Position : Node_Id;
5236+ First_Bit : Node_Id;
5237+ Last_Bit : Node_Id)
5238+ return Node_Id
5239+ is
5240+ N : constant Node_Id :=
5241+ New_Node (N_Component_Clause, Sloc);
5242+ begin
5243+ Set_Component_Name (N, Component_Name);
5244+ Set_Position (N, Position);
5245+ Set_First_Bit (N, First_Bit);
5246+ Set_Last_Bit (N, Last_Bit);
5247+ return N;
5248+ end Make_Component_Clause;
5249+
5250+ function Make_Code_Statement (Sloc : Source_Ptr;
5251+ Expression : Node_Id)
5252+ return Node_Id
5253+ is
5254+ N : constant Node_Id :=
5255+ New_Node (N_Code_Statement, Sloc);
5256+ begin
5257+ Set_Expression (N, Expression);
5258+ return N;
5259+ end Make_Code_Statement;
5260+
5261+ function Make_Op_Rotate_Left (Sloc : Source_Ptr;
5262+ Left_Opnd : Node_Id;
5263+ Right_Opnd : Node_Id)
5264+ return Node_Id
5265+ is
5266+ N : constant Node_Id :=
5267+ New_Node (N_Op_Rotate_Left, Sloc);
5268+ begin
5269+ Set_Left_Opnd (N, Left_Opnd);
5270+ Set_Right_Opnd (N, Right_Opnd);
5271+ Set_Chars (N, Name_Rotate_Left);
5272+ Set_Entity (N, Standard_Op_Rotate_Left);
5273+ return N;
5274+ end Make_Op_Rotate_Left;
5275+
5276+ function Make_Op_Rotate_Right (Sloc : Source_Ptr;
5277+ Left_Opnd : Node_Id;
5278+ Right_Opnd : Node_Id)
5279+ return Node_Id
5280+ is
5281+ N : constant Node_Id :=
5282+ New_Node (N_Op_Rotate_Right, Sloc);
5283+ begin
5284+ Set_Left_Opnd (N, Left_Opnd);
5285+ Set_Right_Opnd (N, Right_Opnd);
5286+ Set_Chars (N, Name_Rotate_Right);
5287+ Set_Entity (N, Standard_Op_Rotate_Right);
5288+ return N;
5289+ end Make_Op_Rotate_Right;
5290+
5291+ function Make_Op_Shift_Left (Sloc : Source_Ptr;
5292+ Left_Opnd : Node_Id;
5293+ Right_Opnd : Node_Id)
5294+ return Node_Id
5295+ is
5296+ N : constant Node_Id :=
5297+ New_Node (N_Op_Shift_Left, Sloc);
5298+ begin
5299+ Set_Left_Opnd (N, Left_Opnd);
5300+ Set_Right_Opnd (N, Right_Opnd);
5301+ Set_Chars (N, Name_Shift_Left);
5302+ Set_Entity (N, Standard_Op_Shift_Left);
5303+ return N;
5304+ end Make_Op_Shift_Left;
5305+
5306+ function Make_Op_Shift_Right_Arithmetic (Sloc : Source_Ptr;
5307+ Left_Opnd : Node_Id;
5308+ Right_Opnd : Node_Id)
5309+ return Node_Id
5310+ is
5311+ N : constant Node_Id :=
5312+ New_Node (N_Op_Shift_Right_Arithmetic, Sloc);
5313+ begin
5314+ Set_Left_Opnd (N, Left_Opnd);
5315+ Set_Right_Opnd (N, Right_Opnd);
5316+ Set_Chars (N, Name_Shift_Right_Arithmetic);
5317+ Set_Entity (N, Standard_Op_Shift_Right_Arithmetic);
5318+ return N;
5319+ end Make_Op_Shift_Right_Arithmetic;
5320+
5321+ function Make_Op_Shift_Right (Sloc : Source_Ptr;
5322+ Left_Opnd : Node_Id;
5323+ Right_Opnd : Node_Id)
5324+ return Node_Id
5325+ is
5326+ N : constant Node_Id :=
5327+ New_Node (N_Op_Shift_Right, Sloc);
5328+ begin
5329+ Set_Left_Opnd (N, Left_Opnd);
5330+ Set_Right_Opnd (N, Right_Opnd);
5331+ Set_Chars (N, Name_Shift_Right);
5332+ Set_Entity (N, Standard_Op_Shift_Right);
5333+ return N;
5334+ end Make_Op_Shift_Right;
5335+
5336+ function Make_Delta_Constraint (Sloc : Source_Ptr;
5337+ Delta_Expression : Node_Id;
5338+ Range_Constraint : Node_Id := Empty)
5339+ return Node_Id
5340+ is
5341+ N : constant Node_Id :=
5342+ New_Node (N_Delta_Constraint, Sloc);
5343+ begin
5344+ Set_Delta_Expression (N, Delta_Expression);
5345+ Set_Range_Constraint (N, Range_Constraint);
5346+ return N;
5347+ end Make_Delta_Constraint;
5348+
5349+ function Make_At_Clause (Sloc : Source_Ptr;
5350+ Identifier : Node_Id;
5351+ Expression : Node_Id)
5352+ return Node_Id
5353+ is
5354+ N : constant Node_Id :=
5355+ New_Node (N_At_Clause, Sloc);
5356+ begin
5357+ Set_Identifier (N, Identifier);
5358+ Set_Expression (N, Expression);
5359+ return N;
5360+ end Make_At_Clause;
5361+
5362+ function Make_Mod_Clause (Sloc : Source_Ptr;
5363+ Expression : Node_Id;
5364+ Pragmas_Before : List_Id)
5365+ return Node_Id
5366+ is
5367+ N : constant Node_Id :=
5368+ New_Node (N_Mod_Clause, Sloc);
5369+ begin
5370+ Set_Expression (N, Expression);
5371+ Set_Pragmas_Before (N, Pragmas_Before);
5372+ return N;
5373+ end Make_Mod_Clause;
5374+
5375+ function Make_Conditional_Expression (Sloc : Source_Ptr;
5376+ Expressions : List_Id)
5377+ return Node_Id
5378+ is
5379+ N : constant Node_Id :=
5380+ New_Node (N_Conditional_Expression, Sloc);
5381+ begin
5382+ Set_Expressions (N, Expressions);
5383+ return N;
5384+ end Make_Conditional_Expression;
5385+
5386+ function Make_Expanded_Name (Sloc : Source_Ptr;
5387+ Chars : Name_Id;
5388+ Prefix : Node_Id;
5389+ Selector_Name : Node_Id)
5390+ return Node_Id
5391+ is
5392+ N : constant Node_Id :=
5393+ New_Node (N_Expanded_Name, Sloc);
5394+ begin
5395+ Set_Chars (N, Chars);
5396+ Set_Prefix (N, Prefix);
5397+ Set_Selector_Name (N, Selector_Name);
5398+ return N;
5399+ end Make_Expanded_Name;
5400+
5401+ function Make_Free_Statement (Sloc : Source_Ptr;
5402+ Expression : Node_Id)
5403+ return Node_Id
5404+ is
5405+ N : constant Node_Id :=
5406+ New_Node (N_Free_Statement, Sloc);
5407+ begin
5408+ Set_Expression (N, Expression);
5409+ return N;
5410+ end Make_Free_Statement;
5411+
5412+ function Make_Freeze_Entity (Sloc : Source_Ptr;
5413+ Actions : List_Id := No_List)
5414+ return Node_Id
5415+ is
5416+ N : constant Node_Id :=
5417+ New_Node (N_Freeze_Entity, Sloc);
5418+ begin
5419+ Set_Actions (N, Actions);
5420+ return N;
5421+ end Make_Freeze_Entity;
5422+
5423+ function Make_Implicit_Label_Declaration (Sloc : Source_Ptr;
5424+ Defining_Identifier : Node_Id)
5425+ return Node_Id
5426+ is
5427+ N : constant Node_Id :=
5428+ New_Node (N_Implicit_Label_Declaration, Sloc);
5429+ begin
5430+ Set_Defining_Identifier (N, Defining_Identifier);
5431+ return N;
5432+ end Make_Implicit_Label_Declaration;
5433+
5434+ function Make_Itype_Reference (Sloc : Source_Ptr)
5435+ return Node_Id
5436+ is
5437+ N : constant Node_Id :=
5438+ New_Node (N_Itype_Reference, Sloc);
5439+ begin
5440+ return N;
5441+ end Make_Itype_Reference;
5442+
5443+ function Make_Raise_Constraint_Error (Sloc : Source_Ptr;
5444+ Condition : Node_Id := Empty;
5445+ Reason : Uint)
5446+ return Node_Id
5447+ is
5448+ N : constant Node_Id :=
5449+ New_Node (N_Raise_Constraint_Error, Sloc);
5450+ begin
5451+ Set_Condition (N, Condition);
5452+ Set_Reason (N, Reason);
5453+ return N;
5454+ end Make_Raise_Constraint_Error;
5455+
5456+ function Make_Raise_Program_Error (Sloc : Source_Ptr;
5457+ Condition : Node_Id := Empty;
5458+ Reason : Uint)
5459+ return Node_Id
5460+ is
5461+ N : constant Node_Id :=
5462+ New_Node (N_Raise_Program_Error, Sloc);
5463+ begin
5464+ Set_Condition (N, Condition);
5465+ Set_Reason (N, Reason);
5466+ return N;
5467+ end Make_Raise_Program_Error;
5468+
5469+ function Make_Raise_Storage_Error (Sloc : Source_Ptr;
5470+ Condition : Node_Id := Empty;
5471+ Reason : Uint)
5472+ return Node_Id
5473+ is
5474+ N : constant Node_Id :=
5475+ New_Node (N_Raise_Storage_Error, Sloc);
5476+ begin
5477+ Set_Condition (N, Condition);
5478+ Set_Reason (N, Reason);
5479+ return N;
5480+ end Make_Raise_Storage_Error;
5481+
5482+ function Make_Reference (Sloc : Source_Ptr;
5483+ Prefix : Node_Id)
5484+ return Node_Id
5485+ is
5486+ N : constant Node_Id :=
5487+ New_Node (N_Reference, Sloc);
5488+ begin
5489+ Set_Prefix (N, Prefix);
5490+ return N;
5491+ end Make_Reference;
5492+
5493+ function Make_Subprogram_Info (Sloc : Source_Ptr;
5494+ Identifier : Node_Id)
5495+ return Node_Id
5496+ is
5497+ N : constant Node_Id :=
5498+ New_Node (N_Subprogram_Info, Sloc);
5499+ begin
5500+ Set_Identifier (N, Identifier);
5501+ return N;
5502+ end Make_Subprogram_Info;
5503+
5504+ function Make_Unchecked_Expression (Sloc : Source_Ptr;
5505+ Expression : Node_Id)
5506+ return Node_Id
5507+ is
5508+ N : constant Node_Id :=
5509+ New_Node (N_Unchecked_Expression, Sloc);
5510+ begin
5511+ Set_Expression (N, Expression);
5512+ return N;
5513+ end Make_Unchecked_Expression;
5514+
5515+ function Make_Unchecked_Type_Conversion (Sloc : Source_Ptr;
5516+ Subtype_Mark : Node_Id;
5517+ Expression : Node_Id)
5518+ return Node_Id
5519+ is
5520+ N : constant Node_Id :=
5521+ New_Node (N_Unchecked_Type_Conversion, Sloc);
5522+ begin
5523+ Set_Subtype_Mark (N, Subtype_Mark);
5524+ Set_Expression (N, Expression);
5525+ return N;
5526+ end Make_Unchecked_Type_Conversion;
5527+
5528+ function Make_Validate_Unchecked_Conversion (Sloc : Source_Ptr)
5529+ return Node_Id
5530+ is
5531+ N : constant Node_Id :=
5532+ New_Node (N_Validate_Unchecked_Conversion, Sloc);
5533+ begin
5534+ return N;
5535+ end Make_Validate_Unchecked_Conversion;
5536+
5537+end Nmake;
5538--- gcc-3.4.0/obj-amd64-pld-linux/gcc/ada/nmake.ads.orig 1970-01-01 01:00:00.000000000 +0100
5539+++ gcc-3.4.0/obj-amd64-pld-linux/gcc/ada/nmake.ads 2004-06-02 00:52:35.000000000 +0200
5540@@ -0,0 +1,1351 @@
5541+------------------------------------------------------------------------------
5542+-- --
5543+-- GNAT COMPILER COMPONENTS --
5544+-- --
5545+-- N M A K E --
5546+-- --
5547+-- S p e c --
5548+-- --
5549+-- Copyright (C) 1992-2003 Free Software Foundation, Inc. --
5550+-- --
5551+-- GNAT is free software; you can redistribute it and/or modify it under --
5552+-- terms of the GNU General Public License as published by the Free Soft- --
5553+-- ware Foundation; either version 2, or (at your option) any later ver- --
5554+-- sion. GNAT is distributed in the hope that it will be useful, but WITH- --
5555+-- OUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY --
5556+-- or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License --
5557+-- for more details. You should have received a copy of the GNU General --
5558+-- Public License distributed with GNAT; see file COPYING. If not, write --
5559+-- to the Free Software Foundation, 59 Temple Place - Suite 330, Boston, --
5560+-- MA 02111-1307, USA. --
5561+-- --
5562+-- GNAT was originally developed by the GNAT team at New York University. --
5563+-- Extensive contributions were provided by Ada Core Technologies Inc. --
5564+-- --
5565+------------------------------------------------------------------------------
5566+
5567+pragma Style_Checks (All_Checks);
5568+-- Turn off subprogram order checking, since the routines here are
5569+-- generated automatically in order.
5570+
5571+
5572+with Nlists; use Nlists;
5573+with Types; use Types;
5574+with Uintp; use Uintp;
5575+with Urealp; use Urealp;
5576+
5577+package Nmake is
5578+
5579+-- This package contains a set of routines used to construct tree nodes
5580+-- using a functional style. There is one routine for each node type defined
5581+-- in Sinfo with the general interface:
5582+
5583+-- function Make_xxx (Sloc : Source_Ptr,
5584+-- Field_Name_1 : Field_Name_1_Type [:= default]
5585+-- Field_Name_2 : Field_Name_2_Type [:= default]
5586+-- ...)
5587+-- return Node_Id
5588+
5589+-- Only syntactic fields are included (i.e. fields marked as "-Sem" or "-Lib"
5590+-- in the Sinfo spec are excluded). In addition, the following four syntactic
5591+-- fields are excluded:
5592+
5593+-- Prev_Ids
5594+-- More_Ids
5595+-- Comes_From_Source
5596+-- Paren_Count
5597+
5598+-- since they are very rarely set in expanded code. If they need to be set,
5599+-- to other than the default values (False, False, False, zero), then the
5600+-- appropriate Set_xxx procedures must be used on the returned value.
5601+
5602+-- Default values are provided only for flag fields (where the default is
5603+-- False), and for optional fields. An optional field is one where the
5604+-- comment line describing the field contains the string "(set to xxx if".
5605+-- For such fields, a default value of xxx is provided."
5606+
5607+-- Warning: since calls to Make_xxx routines are normal function calls, the
5608+-- arguments can be evaluated in any order. This means that at most one such
5609+-- argument can have side effects (e.g. be a call to a parse routine).
5610+
5611+ function Make_Unused_At_Start (Sloc : Source_Ptr)
5612+ return Node_Id;
5613+ pragma Inline (Make_Unused_At_Start);
5614+
5615+ function Make_Unused_At_End (Sloc : Source_Ptr)
5616+ return Node_Id;
5617+ pragma Inline (Make_Unused_At_End);
5618+
5619+ function Make_Identifier (Sloc : Source_Ptr;
5620+ Chars : Name_Id)
5621+ return Node_Id;
5622+ pragma Inline (Make_Identifier);
5623+
5624+ function Make_Integer_Literal (Sloc : Source_Ptr;
5625+ Intval : Uint)
5626+ return Node_Id;
5627+ pragma Inline (Make_Integer_Literal);
5628+
5629+ function Make_Real_Literal (Sloc : Source_Ptr;
5630+ Realval : Ureal)
5631+ return Node_Id;
5632+ pragma Inline (Make_Real_Literal);
5633+
5634+ function Make_Character_Literal (Sloc : Source_Ptr;
5635+ Chars : Name_Id;
5636+ Char_Literal_Value : Char_Code)
5637+ return Node_Id;
5638+ pragma Inline (Make_Character_Literal);
5639+
5640+ function Make_String_Literal (Sloc : Source_Ptr;
5641+ Strval : String_Id)
5642+ return Node_Id;
5643+ pragma Inline (Make_String_Literal);
5644+
5645+ function Make_Pragma (Sloc : Source_Ptr;
5646+ Chars : Name_Id;
5647+ Pragma_Argument_Associations : List_Id := No_List;
5648+ Debug_Statement : Node_Id := Empty)
5649+ return Node_Id;
5650+ pragma Inline (Make_Pragma);
5651+
5652+ function Make_Pragma_Argument_Association (Sloc : Source_Ptr;
5653+ Chars : Name_Id := No_Name;
5654+ Expression : Node_Id)
5655+ return Node_Id;
5656+ pragma Inline (Make_Pragma_Argument_Association);
5657+
5658+ function Make_Defining_Identifier (Sloc : Source_Ptr;
5659+ Chars : Name_Id)
5660+ return Node_Id;
5661+ pragma Inline (Make_Defining_Identifier);
5662+
5663+ function Make_Full_Type_Declaration (Sloc : Source_Ptr;
5664+ Defining_Identifier : Node_Id;
5665+ Discriminant_Specifications : List_Id := No_List;
5666+ Type_Definition : Node_Id)
5667+ return Node_Id;
5668+ pragma Inline (Make_Full_Type_Declaration);
5669+
5670+ function Make_Subtype_Declaration (Sloc : Source_Ptr;
5671+ Defining_Identifier : Node_Id;
5672+ Subtype_Indication : Node_Id)
5673+ return Node_Id;
5674+ pragma Inline (Make_Subtype_Declaration);
5675+
5676+ function Make_Subtype_Indication (Sloc : Source_Ptr;
5677+ Subtype_Mark : Node_Id;
5678+ Constraint : Node_Id)
5679+ return Node_Id;
5680+ pragma Inline (Make_Subtype_Indication);
5681+
5682+ function Make_Object_Declaration (Sloc : Source_Ptr;
5683+ Defining_Identifier : Node_Id;
5684+ Aliased_Present : Boolean := False;
5685+ Constant_Present : Boolean := False;
5686+ Object_Definition : Node_Id;
5687+ Expression : Node_Id := Empty)
5688+ return Node_Id;
5689+ pragma Inline (Make_Object_Declaration);
5690+
5691+ function Make_Number_Declaration (Sloc : Source_Ptr;
5692+ Defining_Identifier : Node_Id;
5693+ Expression : Node_Id)
5694+ return Node_Id;
5695+ pragma Inline (Make_Number_Declaration);
5696+
5697+ function Make_Derived_Type_Definition (Sloc : Source_Ptr;
5698+ Abstract_Present : Boolean := False;
5699+ Subtype_Indication : Node_Id;
5700+ Record_Extension_Part : Node_Id := Empty)
5701+ return Node_Id;
5702+ pragma Inline (Make_Derived_Type_Definition);
5703+
5704+ function Make_Range_Constraint (Sloc : Source_Ptr;
5705+ Range_Expression : Node_Id)
5706+ return Node_Id;
5707+ pragma Inline (Make_Range_Constraint);
5708+
5709+ function Make_Range (Sloc : Source_Ptr;
5710+ Low_Bound : Node_Id;
5711+ High_Bound : Node_Id;
5712+ Includes_Infinities : Boolean := False)
5713+ return Node_Id;
5714+ pragma Inline (Make_Range);
5715+
5716+ function Make_Enumeration_Type_Definition (Sloc : Source_Ptr;
5717+ Literals : List_Id;
5718+ End_Label : Node_Id := Empty)
5719+ return Node_Id;
5720+ pragma Inline (Make_Enumeration_Type_Definition);
5721+
5722+ function Make_Defining_Character_Literal (Sloc : Source_Ptr;
5723+ Chars : Name_Id)
5724+ return Node_Id;
5725+ pragma Inline (Make_Defining_Character_Literal);
5726+
5727+ function Make_Signed_Integer_Type_Definition (Sloc : Source_Ptr;
5728+ Low_Bound : Node_Id;
5729+ High_Bound : Node_Id)
5730+ return Node_Id;
5731+ pragma Inline (Make_Signed_Integer_Type_Definition);
5732+
5733+ function Make_Modular_Type_Definition (Sloc : Source_Ptr;
5734+ Expression : Node_Id)
5735+ return Node_Id;
5736+ pragma Inline (Make_Modular_Type_Definition);
5737+
5738+ function Make_Floating_Point_Definition (Sloc : Source_Ptr;
5739+ Digits_Expression : Node_Id;
5740+ Real_Range_Specification : Node_Id := Empty)
5741+ return Node_Id;
5742+ pragma Inline (Make_Floating_Point_Definition);
5743+
5744+ function Make_Real_Range_Specification (Sloc : Source_Ptr;
5745+ Low_Bound : Node_Id;
5746+ High_Bound : Node_Id)
5747+ return Node_Id;
5748+ pragma Inline (Make_Real_Range_Specification);
5749+
5750+ function Make_Ordinary_Fixed_Point_Definition (Sloc : Source_Ptr;
5751+ Delta_Expression : Node_Id;
5752+ Real_Range_Specification : Node_Id)
5753+ return Node_Id;
5754+ pragma Inline (Make_Ordinary_Fixed_Point_Definition);
5755+
5756+ function Make_Decimal_Fixed_Point_Definition (Sloc : Source_Ptr;
5757+ Delta_Expression : Node_Id;
5758+ Digits_Expression : Node_Id;
5759+ Real_Range_Specification : Node_Id := Empty)
5760+ return Node_Id;
5761+ pragma Inline (Make_Decimal_Fixed_Point_Definition);
5762+
5763+ function Make_Digits_Constraint (Sloc : Source_Ptr;
5764+ Digits_Expression : Node_Id;
5765+ Range_Constraint : Node_Id := Empty)
5766+ return Node_Id;
5767+ pragma Inline (Make_Digits_Constraint);
5768+
5769+ function Make_Unconstrained_Array_Definition (Sloc : Source_Ptr;
5770+ Subtype_Marks : List_Id;
5771+ Component_Definition : Node_Id)
5772+ return Node_Id;
5773+ pragma Inline (Make_Unconstrained_Array_Definition);
5774+
5775+ function Make_Constrained_Array_Definition (Sloc : Source_Ptr;
5776+ Discrete_Subtype_Definitions : List_Id;
5777+ Component_Definition : Node_Id)
5778+ return Node_Id;
5779+ pragma Inline (Make_Constrained_Array_Definition);
5780+
5781+ function Make_Component_Definition (Sloc : Source_Ptr;
5782+ Aliased_Present : Boolean := False;
5783+ Subtype_Indication : Node_Id)
5784+ return Node_Id;
5785+ pragma Inline (Make_Component_Definition);
5786+
5787+ function Make_Discriminant_Specification (Sloc : Source_Ptr;
5788+ Defining_Identifier : Node_Id;
5789+ Discriminant_Type : Node_Id;
5790+ Expression : Node_Id := Empty)
5791+ return Node_Id;
5792+ pragma Inline (Make_Discriminant_Specification);
5793+
5794+ function Make_Index_Or_Discriminant_Constraint (Sloc : Source_Ptr;
5795+ Constraints : List_Id)
5796+ return Node_Id;
5797+ pragma Inline (Make_Index_Or_Discriminant_Constraint);
5798+
5799+ function Make_Discriminant_Association (Sloc : Source_Ptr;
5800+ Selector_Names : List_Id;
5801+ Expression : Node_Id)
5802+ return Node_Id;
5803+ pragma Inline (Make_Discriminant_Association);
5804+
5805+ function Make_Record_Definition (Sloc : Source_Ptr;
5806+ End_Label : Node_Id := Empty;
5807+ Abstract_Present : Boolean := False;
5808+ Tagged_Present : Boolean := False;
5809+ Limited_Present : Boolean := False;
5810+ Component_List : Node_Id;
5811+ Null_Present : Boolean := False)
5812+ return Node_Id;
5813+ pragma Inline (Make_Record_Definition);
5814+
5815+ function Make_Component_List (Sloc : Source_Ptr;
5816+ Component_Items : List_Id;
5817+ Variant_Part : Node_Id := Empty;
5818+ Null_Present : Boolean := False)
5819+ return Node_Id;
5820+ pragma Inline (Make_Component_List);
5821+
5822+ function Make_Component_Declaration (Sloc : Source_Ptr;
5823+ Defining_Identifier : Node_Id;
5824+ Component_Definition : Node_Id;
5825+ Expression : Node_Id := Empty)
5826+ return Node_Id;
5827+ pragma Inline (Make_Component_Declaration);
5828+
5829+ function Make_Variant_Part (Sloc : Source_Ptr;
5830+ Name : Node_Id;
5831+ Variants : List_Id)
5832+ return Node_Id;
5833+ pragma Inline (Make_Variant_Part);
5834+
5835+ function Make_Variant (Sloc : Source_Ptr;
5836+ Discrete_Choices : List_Id;
5837+ Component_List : Node_Id)
5838+ return Node_Id;
5839+ pragma Inline (Make_Variant);
5840+
5841+ function Make_Others_Choice (Sloc : Source_Ptr)
5842+ return Node_Id;
5843+ pragma Inline (Make_Others_Choice);
5844+
5845+ function Make_Access_To_Object_Definition (Sloc : Source_Ptr;
5846+ All_Present : Boolean := False;
5847+ Subtype_Indication : Node_Id;
5848+ Constant_Present : Boolean := False)
5849+ return Node_Id;
5850+ pragma Inline (Make_Access_To_Object_Definition);
5851+
5852+ function Make_Access_Function_Definition (Sloc : Source_Ptr;
5853+ Protected_Present : Boolean := False;
5854+ Parameter_Specifications : List_Id := No_List;
5855+ Subtype_Mark : Node_Id)
5856+ return Node_Id;
5857+ pragma Inline (Make_Access_Function_Definition);
5858+
5859+ function Make_Access_Procedure_Definition (Sloc : Source_Ptr;
5860+ Protected_Present : Boolean := False;
5861+ Parameter_Specifications : List_Id := No_List)
5862+ return Node_Id;
5863+ pragma Inline (Make_Access_Procedure_Definition);
5864+
5865+ function Make_Access_Definition (Sloc : Source_Ptr;
5866+ Subtype_Mark : Node_Id)
5867+ return Node_Id;
5868+ pragma Inline (Make_Access_Definition);
5869+
5870+ function Make_Incomplete_Type_Declaration (Sloc : Source_Ptr;
5871+ Defining_Identifier : Node_Id;
5872+ Discriminant_Specifications : List_Id := No_List;
5873+ Unknown_Discriminants_Present : Boolean := False)
5874+ return Node_Id;
5875+ pragma Inline (Make_Incomplete_Type_Declaration);
5876+
5877+ function Make_Explicit_Dereference (Sloc : Source_Ptr;
5878+ Prefix : Node_Id)
5879+ return Node_Id;
5880+ pragma Inline (Make_Explicit_Dereference);
5881+
5882+ function Make_Indexed_Component (Sloc : Source_Ptr;
5883+ Prefix : Node_Id;
5884+ Expressions : List_Id)
5885+ return Node_Id;
5886+ pragma Inline (Make_Indexed_Component);
5887+
5888+ function Make_Slice (Sloc : Source_Ptr;
5889+ Prefix : Node_Id;
5890+ Discrete_Range : Node_Id)
5891+ return Node_Id;
5892+ pragma Inline (Make_Slice);
5893+
5894+ function Make_Selected_Component (Sloc : Source_Ptr;
5895+ Prefix : Node_Id;
5896+ Selector_Name : Node_Id)
5897+ return Node_Id;
5898+ pragma Inline (Make_Selected_Component);
5899+
5900+ function Make_Attribute_Reference (Sloc : Source_Ptr;
5901+ Prefix : Node_Id;
5902+ Attribute_Name : Name_Id;
5903+ Expressions : List_Id := No_List;
5904+ Must_Be_Byte_Aligned : Boolean := False)
5905+ return Node_Id;
5906+ pragma Inline (Make_Attribute_Reference);
5907+
5908+ function Make_Aggregate (Sloc : Source_Ptr;
5909+ Expressions : List_Id := No_List;
5910+ Component_Associations : List_Id := No_List;
5911+ Null_Record_Present : Boolean := False)
5912+ return Node_Id;
5913+ pragma Inline (Make_Aggregate);
5914+
5915+ function Make_Component_Association (Sloc : Source_Ptr;
5916+ Choices : List_Id;
5917+ Expression : Node_Id;
5918+ Box_Present : Boolean := False)
5919+ return Node_Id;
5920+ pragma Inline (Make_Component_Association);
5921+
5922+ function Make_Extension_Aggregate (Sloc : Source_Ptr;
5923+ Ancestor_Part : Node_Id;
5924+ Expressions : List_Id := No_List;
5925+ Component_Associations : List_Id := No_List;
5926+ Null_Record_Present : Boolean := False)
5927+ return Node_Id;
5928+ pragma Inline (Make_Extension_Aggregate);
5929+
5930+ function Make_Null (Sloc : Source_Ptr)
5931+ return Node_Id;
5932+ pragma Inline (Make_Null);
5933+
5934+ function Make_And_Then (Sloc : Source_Ptr;
5935+ Left_Opnd : Node_Id;
5936+ Right_Opnd : Node_Id)
5937+ return Node_Id;
5938+ pragma Inline (Make_And_Then);
5939+
5940+ function Make_Or_Else (Sloc : Source_Ptr;
5941+ Left_Opnd : Node_Id;
5942+ Right_Opnd : Node_Id)
5943+ return Node_Id;
5944+ pragma Inline (Make_Or_Else);
5945+
5946+ function Make_In (Sloc : Source_Ptr;
5947+ Left_Opnd : Node_Id;
5948+ Right_Opnd : Node_Id)
5949+ return Node_Id;
5950+ pragma Inline (Make_In);
5951+
5952+ function Make_Not_In (Sloc : Source_Ptr;
5953+ Left_Opnd : Node_Id;
5954+ Right_Opnd : Node_Id)
5955+ return Node_Id;
5956+ pragma Inline (Make_Not_In);
5957+
5958+ function Make_Op_And (Sloc : Source_Ptr;
5959+ Left_Opnd : Node_Id;
5960+ Right_Opnd : Node_Id)
5961+ return Node_Id;
5962+ pragma Inline (Make_Op_And);
5963+
5964+ function Make_Op_Or (Sloc : Source_Ptr;
5965+ Left_Opnd : Node_Id;
5966+ Right_Opnd : Node_Id)
5967+ return Node_Id;
5968+ pragma Inline (Make_Op_Or);
5969+
5970+ function Make_Op_Xor (Sloc : Source_Ptr;
5971+ Left_Opnd : Node_Id;
5972+ Right_Opnd : Node_Id)
5973+ return Node_Id;
5974+ pragma Inline (Make_Op_Xor);
5975+
5976+ function Make_Op_Eq (Sloc : Source_Ptr;
5977+ Left_Opnd : Node_Id;
5978+ Right_Opnd : Node_Id)
5979+ return Node_Id;
5980+ pragma Inline (Make_Op_Eq);
5981+
5982+ function Make_Op_Ne (Sloc : Source_Ptr;
5983+ Left_Opnd : Node_Id;
5984+ Right_Opnd : Node_Id)
5985+ return Node_Id;
5986+ pragma Inline (Make_Op_Ne);
5987+
5988+ function Make_Op_Lt (Sloc : Source_Ptr;
5989+ Left_Opnd : Node_Id;
5990+ Right_Opnd : Node_Id)
5991+ return Node_Id;
5992+ pragma Inline (Make_Op_Lt);
5993+
5994+ function Make_Op_Le (Sloc : Source_Ptr;
5995+ Left_Opnd : Node_Id;
5996+ Right_Opnd : Node_Id)
5997+ return Node_Id;
5998+ pragma Inline (Make_Op_Le);
5999+
6000+ function Make_Op_Gt (Sloc : Source_Ptr;
6001+ Left_Opnd : Node_Id;
6002+ Right_Opnd : Node_Id)
6003+ return Node_Id;
6004+ pragma Inline (Make_Op_Gt);
6005+
6006+ function Make_Op_Ge (Sloc : Source_Ptr;
6007+ Left_Opnd : Node_Id;
6008+ Right_Opnd : Node_Id)
6009+ return Node_Id;
6010+ pragma Inline (Make_Op_Ge);
6011+
6012+ function Make_Op_Add (Sloc : Source_Ptr;
6013+ Left_Opnd : Node_Id;
6014+ Right_Opnd : Node_Id)
6015+ return Node_Id;
6016+ pragma Inline (Make_Op_Add);
6017+
6018+ function Make_Op_Subtract (Sloc : Source_Ptr;
6019+ Left_Opnd : Node_Id;
6020+ Right_Opnd : Node_Id)
6021+ return Node_Id;
6022+ pragma Inline (Make_Op_Subtract);
6023+
6024+ function Make_Op_Concat (Sloc : Source_Ptr;
6025+ Left_Opnd : Node_Id;
6026+ Right_Opnd : Node_Id)
6027+ return Node_Id;
6028+ pragma Inline (Make_Op_Concat);
6029+
6030+ function Make_Op_Multiply (Sloc : Source_Ptr;
6031+ Left_Opnd : Node_Id;
6032+ Right_Opnd : Node_Id)
6033+ return Node_Id;
6034+ pragma Inline (Make_Op_Multiply);
6035+
6036+ function Make_Op_Divide (Sloc : Source_Ptr;
6037+ Left_Opnd : Node_Id;
6038+ Right_Opnd : Node_Id)
6039+ return Node_Id;
6040+ pragma Inline (Make_Op_Divide);
6041+
6042+ function Make_Op_Mod (Sloc : Source_Ptr;
6043+ Left_Opnd : Node_Id;
6044+ Right_Opnd : Node_Id)
6045+ return Node_Id;
6046+ pragma Inline (Make_Op_Mod);
6047+
6048+ function Make_Op_Rem (Sloc : Source_Ptr;
6049+ Left_Opnd : Node_Id;
6050+ Right_Opnd : Node_Id)
6051+ return Node_Id;
6052+ pragma Inline (Make_Op_Rem);
6053+
6054+ function Make_Op_Expon (Sloc : Source_Ptr;
6055+ Left_Opnd : Node_Id;
6056+ Right_Opnd : Node_Id)
6057+ return Node_Id;
6058+ pragma Inline (Make_Op_Expon);
6059+
6060+ function Make_Op_Plus (Sloc : Source_Ptr;
6061+ Right_Opnd : Node_Id)
6062+ return Node_Id;
6063+ pragma Inline (Make_Op_Plus);
6064+
6065+ function Make_Op_Minus (Sloc : Source_Ptr;
6066+ Right_Opnd : Node_Id)
6067+ return Node_Id;
6068+ pragma Inline (Make_Op_Minus);
6069+
6070+ function Make_Op_Abs (Sloc : Source_Ptr;
6071+ Right_Opnd : Node_Id)
6072+ return Node_Id;
6073+ pragma Inline (Make_Op_Abs);
6074+
6075+ function Make_Op_Not (Sloc : Source_Ptr;
6076+ Right_Opnd : Node_Id)
6077+ return Node_Id;
6078+ pragma Inline (Make_Op_Not);
6079+
6080+ function Make_Type_Conversion (Sloc : Source_Ptr;
6081+ Subtype_Mark : Node_Id;
6082+ Expression : Node_Id)
6083+ return Node_Id;
6084+ pragma Inline (Make_Type_Conversion);
6085+
6086+ function Make_Qualified_Expression (Sloc : Source_Ptr;
6087+ Subtype_Mark : Node_Id;
6088+ Expression : Node_Id)
6089+ return Node_Id;
6090+ pragma Inline (Make_Qualified_Expression);
6091+
6092+ function Make_Allocator (Sloc : Source_Ptr;
6093+ Expression : Node_Id)
6094+ return Node_Id;
6095+ pragma Inline (Make_Allocator);
6096+
6097+ function Make_Null_Statement (Sloc : Source_Ptr)
6098+ return Node_Id;
6099+ pragma Inline (Make_Null_Statement);
6100+
6101+ function Make_Label (Sloc : Source_Ptr;
6102+ Identifier : Node_Id)
6103+ return Node_Id;
6104+ pragma Inline (Make_Label);
6105+
6106+ function Make_Assignment_Statement (Sloc : Source_Ptr;
6107+ Name : Node_Id;
6108+ Expression : Node_Id)
6109+ return Node_Id;
6110+ pragma Inline (Make_Assignment_Statement);
6111+
6112+ function Make_If_Statement (Sloc : Source_Ptr;
6113+ Condition : Node_Id;
6114+ Then_Statements : List_Id;
6115+ Elsif_Parts : List_Id := No_List;
6116+ Else_Statements : List_Id := No_List;
6117+ End_Span : Uint := No_Uint)
6118+ return Node_Id;
6119+ pragma Inline (Make_If_Statement);
6120+
6121+ function Make_Elsif_Part (Sloc : Source_Ptr;
6122+ Condition : Node_Id;
6123+ Then_Statements : List_Id)
6124+ return Node_Id;
6125+ pragma Inline (Make_Elsif_Part);
6126+
6127+ function Make_Case_Statement (Sloc : Source_Ptr;
6128+ Expression : Node_Id;
6129+ Alternatives : List_Id;
6130+ End_Span : Uint := No_Uint)
6131+ return Node_Id;
6132+ pragma Inline (Make_Case_Statement);
6133+
6134+ function Make_Case_Statement_Alternative (Sloc : Source_Ptr;
6135+ Discrete_Choices : List_Id;
6136+ Statements : List_Id)
6137+ return Node_Id;
6138+ pragma Inline (Make_Case_Statement_Alternative);
6139+
6140+ function Make_Loop_Statement (Sloc : Source_Ptr;
6141+ Identifier : Node_Id := Empty;
6142+ Iteration_Scheme : Node_Id := Empty;
6143+ Statements : List_Id;
6144+ End_Label : Node_Id;
6145+ Has_Created_Identifier : Boolean := False;
6146+ Is_Null_Loop : Boolean := False)
6147+ return Node_Id;
6148+ pragma Inline (Make_Loop_Statement);
6149+
6150+ function Make_Iteration_Scheme (Sloc : Source_Ptr;
6151+ Condition : Node_Id := Empty;
6152+ Loop_Parameter_Specification : Node_Id := Empty)
6153+ return Node_Id;
6154+ pragma Inline (Make_Iteration_Scheme);
6155+
6156+ function Make_Loop_Parameter_Specification (Sloc : Source_Ptr;
6157+ Defining_Identifier : Node_Id;
6158+ Reverse_Present : Boolean := False;
6159+ Discrete_Subtype_Definition : Node_Id)
6160+ return Node_Id;
6161+ pragma Inline (Make_Loop_Parameter_Specification);
6162+
6163+ function Make_Block_Statement (Sloc : Source_Ptr;
6164+ Identifier : Node_Id := Empty;
6165+ Declarations : List_Id := No_List;
6166+ Handled_Statement_Sequence : Node_Id;
6167+ Has_Created_Identifier : Boolean := False;
6168+ Is_Task_Allocation_Block : Boolean := False;
6169+ Is_Asynchronous_Call_Block : Boolean := False)
6170+ return Node_Id;
6171+ pragma Inline (Make_Block_Statement);
6172+
6173+ function Make_Exit_Statement (Sloc : Source_Ptr;
6174+ Name : Node_Id := Empty;
6175+ Condition : Node_Id := Empty)
6176+ return Node_Id;
6177+ pragma Inline (Make_Exit_Statement);
6178+
6179+ function Make_Goto_Statement (Sloc : Source_Ptr;
6180+ Name : Node_Id)
6181+ return Node_Id;
6182+ pragma Inline (Make_Goto_Statement);
6183+
6184+ function Make_Subprogram_Declaration (Sloc : Source_Ptr;
6185+ Specification : Node_Id)
6186+ return Node_Id;
6187+ pragma Inline (Make_Subprogram_Declaration);
6188+
6189+ function Make_Abstract_Subprogram_Declaration (Sloc : Source_Ptr;
6190+ Specification : Node_Id)
6191+ return Node_Id;
6192+ pragma Inline (Make_Abstract_Subprogram_Declaration);
6193+
6194+ function Make_Function_Specification (Sloc : Source_Ptr;
6195+ Defining_Unit_Name : Node_Id;
6196+ Parameter_Specifications : List_Id := No_List;
6197+ Subtype_Mark : Node_Id)
6198+ return Node_Id;
6199+ pragma Inline (Make_Function_Specification);
6200+
6201+ function Make_Procedure_Specification (Sloc : Source_Ptr;
6202+ Defining_Unit_Name : Node_Id;
6203+ Parameter_Specifications : List_Id := No_List)
6204+ return Node_Id;
6205+ pragma Inline (Make_Procedure_Specification);
6206+
6207+ function Make_Designator (Sloc : Source_Ptr;
6208+ Name : Node_Id;
6209+ Identifier : Node_Id)
6210+ return Node_Id;
6211+ pragma Inline (Make_Designator);
6212+
6213+ function Make_Defining_Program_Unit_Name (Sloc : Source_Ptr;
6214+ Name : Node_Id;
6215+ Defining_Identifier : Node_Id)
6216+ return Node_Id;
6217+ pragma Inline (Make_Defining_Program_Unit_Name);
6218+
6219+ function Make_Operator_Symbol (Sloc : Source_Ptr;
6220+ Chars : Name_Id;
6221+ Strval : String_Id)
6222+ return Node_Id;
6223+ pragma Inline (Make_Operator_Symbol);
6224+
6225+ function Make_Defining_Operator_Symbol (Sloc : Source_Ptr;
6226+ Chars : Name_Id)
6227+ return Node_Id;
6228+ pragma Inline (Make_Defining_Operator_Symbol);
6229+
6230+ function Make_Parameter_Specification (Sloc : Source_Ptr;
6231+ Defining_Identifier : Node_Id;
6232+ In_Present : Boolean := False;
6233+ Out_Present : Boolean := False;
6234+ Parameter_Type : Node_Id;
6235+ Expression : Node_Id := Empty)
6236+ return Node_Id;
6237+ pragma Inline (Make_Parameter_Specification);
6238+
6239+ function Make_Subprogram_Body (Sloc : Source_Ptr;
6240+ Specification : Node_Id;
6241+ Declarations : List_Id;
6242+ Handled_Statement_Sequence : Node_Id;
6243+ Bad_Is_Detected : Boolean := False)
6244+ return Node_Id;
6245+ pragma Inline (Make_Subprogram_Body);
6246+
6247+ function Make_Procedure_Call_Statement (Sloc : Source_Ptr;
6248+ Name : Node_Id;
6249+ Parameter_Associations : List_Id := No_List)
6250+ return Node_Id;
6251+ pragma Inline (Make_Procedure_Call_Statement);
6252+
6253+ function Make_Function_Call (Sloc : Source_Ptr;
6254+ Name : Node_Id;
6255+ Parameter_Associations : List_Id := No_List)
6256+ return Node_Id;
6257+ pragma Inline (Make_Function_Call);
6258+
6259+ function Make_Parameter_Association (Sloc : Source_Ptr;
6260+ Selector_Name : Node_Id;
6261+ Explicit_Actual_Parameter : Node_Id)
6262+ return Node_Id;
6263+ pragma Inline (Make_Parameter_Association);
6264+
6265+ function Make_Return_Statement (Sloc : Source_Ptr;
6266+ Expression : Node_Id := Empty)
6267+ return Node_Id;
6268+ pragma Inline (Make_Return_Statement);
6269+
6270+ function Make_Package_Declaration (Sloc : Source_Ptr;
6271+ Specification : Node_Id)
6272+ return Node_Id;
6273+ pragma Inline (Make_Package_Declaration);
6274+
6275+ function Make_Package_Specification (Sloc : Source_Ptr;
6276+ Defining_Unit_Name : Node_Id;
6277+ Visible_Declarations : List_Id;
6278+ Private_Declarations : List_Id := No_List;
6279+ End_Label : Node_Id)
6280+ return Node_Id;
6281+ pragma Inline (Make_Package_Specification);
6282+
6283+ function Make_Package_Body (Sloc : Source_Ptr;
6284+ Defining_Unit_Name : Node_Id;
6285+ Declarations : List_Id;
6286+ Handled_Statement_Sequence : Node_Id := Empty)
6287+ return Node_Id;
6288+ pragma Inline (Make_Package_Body);
6289+
6290+ function Make_Private_Type_Declaration (Sloc : Source_Ptr;
6291+ Defining_Identifier : Node_Id;
6292+ Discriminant_Specifications : List_Id := No_List;
6293+ Unknown_Discriminants_Present : Boolean := False;
6294+ Abstract_Present : Boolean := False;
6295+ Tagged_Present : Boolean := False;
6296+ Limited_Present : Boolean := False)
6297+ return Node_Id;
6298+ pragma Inline (Make_Private_Type_Declaration);
6299+
6300+ function Make_Private_Extension_Declaration (Sloc : Source_Ptr;
6301+ Defining_Identifier : Node_Id;
6302+ Discriminant_Specifications : List_Id := No_List;
6303+ Unknown_Discriminants_Present : Boolean := False;
6304+ Abstract_Present : Boolean := False;
6305+ Subtype_Indication : Node_Id)
6306+ return Node_Id;
6307+ pragma Inline (Make_Private_Extension_Declaration);
6308+
6309+ function Make_Use_Package_Clause (Sloc : Source_Ptr;
6310+ Names : List_Id)
6311+ return Node_Id;
6312+ pragma Inline (Make_Use_Package_Clause);
6313+
6314+ function Make_Use_Type_Clause (Sloc : Source_Ptr;
6315+ Subtype_Marks : List_Id)
6316+ return Node_Id;
6317+ pragma Inline (Make_Use_Type_Clause);
6318+
6319+ function Make_Object_Renaming_Declaration (Sloc : Source_Ptr;
6320+ Defining_Identifier : Node_Id;
6321+ Subtype_Mark : Node_Id;
6322+ Name : Node_Id)
6323+ return Node_Id;
6324+ pragma Inline (Make_Object_Renaming_Declaration);
6325+
6326+ function Make_Exception_Renaming_Declaration (Sloc : Source_Ptr;
6327+ Defining_Identifier : Node_Id;
6328+ Name : Node_Id)
6329+ return Node_Id;
6330+ pragma Inline (Make_Exception_Renaming_Declaration);
6331+
6332+ function Make_Package_Renaming_Declaration (Sloc : Source_Ptr;
6333+ Defining_Unit_Name : Node_Id;
6334+ Name : Node_Id)
6335+ return Node_Id;
6336+ pragma Inline (Make_Package_Renaming_Declaration);
6337+
6338+ function Make_Subprogram_Renaming_Declaration (Sloc : Source_Ptr;
6339+ Specification : Node_Id;
6340+ Name : Node_Id)
6341+ return Node_Id;
6342+ pragma Inline (Make_Subprogram_Renaming_Declaration);
6343+
6344+ function Make_Generic_Package_Renaming_Declaration (Sloc : Source_Ptr;
6345+ Defining_Unit_Name : Node_Id;
6346+ Name : Node_Id)
6347+ return Node_Id;
6348+ pragma Inline (Make_Generic_Package_Renaming_Declaration);
6349+
6350+ function Make_Generic_Procedure_Renaming_Declaration (Sloc : Source_Ptr;
6351+ Defining_Unit_Name : Node_Id;
6352+ Name : Node_Id)
6353+ return Node_Id;
6354+ pragma Inline (Make_Generic_Procedure_Renaming_Declaration);
6355+
6356+ function Make_Generic_Function_Renaming_Declaration (Sloc : Source_Ptr;
6357+ Defining_Unit_Name : Node_Id;
6358+ Name : Node_Id)
6359+ return Node_Id;
6360+ pragma Inline (Make_Generic_Function_Renaming_Declaration);
6361+
6362+ function Make_Task_Type_Declaration (Sloc : Source_Ptr;
6363+ Defining_Identifier : Node_Id;
6364+ Discriminant_Specifications : List_Id := No_List;
6365+ Task_Definition : Node_Id := Empty)
6366+ return Node_Id;
6367+ pragma Inline (Make_Task_Type_Declaration);
6368+
6369+ function Make_Single_Task_Declaration (Sloc : Source_Ptr;
6370+ Defining_Identifier : Node_Id;
6371+ Task_Definition : Node_Id := Empty)
6372+ return Node_Id;
6373+ pragma Inline (Make_Single_Task_Declaration);
6374+
6375+ function Make_Task_Definition (Sloc : Source_Ptr;
6376+ Visible_Declarations : List_Id;
6377+ Private_Declarations : List_Id := No_List;
6378+ End_Label : Node_Id)
6379+ return Node_Id;
6380+ pragma Inline (Make_Task_Definition);
6381+
6382+ function Make_Task_Body (Sloc : Source_Ptr;
6383+ Defining_Identifier : Node_Id;
6384+ Declarations : List_Id;
6385+ Handled_Statement_Sequence : Node_Id)
6386+ return Node_Id;
6387+ pragma Inline (Make_Task_Body);
6388+
6389+ function Make_Protected_Type_Declaration (Sloc : Source_Ptr;
6390+ Defining_Identifier : Node_Id;
6391+ Discriminant_Specifications : List_Id := No_List;
6392+ Protected_Definition : Node_Id)
6393+ return Node_Id;
6394+ pragma Inline (Make_Protected_Type_Declaration);
6395+
6396+ function Make_Single_Protected_Declaration (Sloc : Source_Ptr;
6397+ Defining_Identifier : Node_Id;
6398+ Protected_Definition : Node_Id)
6399+ return Node_Id;
6400+ pragma Inline (Make_Single_Protected_Declaration);
6401+
6402+ function Make_Protected_Definition (Sloc : Source_Ptr;
6403+ Visible_Declarations : List_Id;
6404+ Private_Declarations : List_Id := No_List;
6405+ End_Label : Node_Id)
6406+ return Node_Id;
6407+ pragma Inline (Make_Protected_Definition);
6408+
6409+ function Make_Protected_Body (Sloc : Source_Ptr;
6410+ Defining_Identifier : Node_Id;
6411+ Declarations : List_Id;
6412+ End_Label : Node_Id)
6413+ return Node_Id;
6414+ pragma Inline (Make_Protected_Body);
6415+
6416+ function Make_Entry_Declaration (Sloc : Source_Ptr;
6417+ Defining_Identifier : Node_Id;
6418+ Discrete_Subtype_Definition : Node_Id := Empty;
6419+ Parameter_Specifications : List_Id := No_List)
6420+ return Node_Id;
6421+ pragma Inline (Make_Entry_Declaration);
6422+
6423+ function Make_Accept_Statement (Sloc : Source_Ptr;
6424+ Entry_Direct_Name : Node_Id;
6425+ Entry_Index : Node_Id := Empty;
6426+ Parameter_Specifications : List_Id := No_List;
6427+ Handled_Statement_Sequence : Node_Id;
6428+ Declarations : List_Id := No_List)
6429+ return Node_Id;
6430+ pragma Inline (Make_Accept_Statement);
6431+
6432+ function Make_Entry_Body (Sloc : Source_Ptr;
6433+ Defining_Identifier : Node_Id;
6434+ Entry_Body_Formal_Part : Node_Id;
6435+ Declarations : List_Id;
6436+ Handled_Statement_Sequence : Node_Id)
6437+ return Node_Id;
6438+ pragma Inline (Make_Entry_Body);
6439+
6440+ function Make_Entry_Body_Formal_Part (Sloc : Source_Ptr;
6441+ Entry_Index_Specification : Node_Id := Empty;
6442+ Parameter_Specifications : List_Id := No_List;
6443+ Condition : Node_Id)
6444+ return Node_Id;
6445+ pragma Inline (Make_Entry_Body_Formal_Part);
6446+
6447+ function Make_Entry_Index_Specification (Sloc : Source_Ptr;
6448+ Defining_Identifier : Node_Id;
6449+ Discrete_Subtype_Definition : Node_Id)
6450+ return Node_Id;
6451+ pragma Inline (Make_Entry_Index_Specification);
6452+
6453+ function Make_Entry_Call_Statement (Sloc : Source_Ptr;
6454+ Name : Node_Id;
6455+ Parameter_Associations : List_Id := No_List)
6456+ return Node_Id;
6457+ pragma Inline (Make_Entry_Call_Statement);
6458+
6459+ function Make_Requeue_Statement (Sloc : Source_Ptr;
6460+ Name : Node_Id;
6461+ Abort_Present : Boolean := False)
6462+ return Node_Id;
6463+ pragma Inline (Make_Requeue_Statement);
6464+
6465+ function Make_Delay_Until_Statement (Sloc : Source_Ptr;
6466+ Expression : Node_Id)
6467+ return Node_Id;
6468+ pragma Inline (Make_Delay_Until_Statement);
6469+
6470+ function Make_Delay_Relative_Statement (Sloc : Source_Ptr;
6471+ Expression : Node_Id)
6472+ return Node_Id;
6473+ pragma Inline (Make_Delay_Relative_Statement);
6474+
6475+ function Make_Selective_Accept (Sloc : Source_Ptr;
6476+ Select_Alternatives : List_Id;
6477+ Else_Statements : List_Id := No_List)
6478+ return Node_Id;
6479+ pragma Inline (Make_Selective_Accept);
6480+
6481+ function Make_Accept_Alternative (Sloc : Source_Ptr;
6482+ Accept_Statement : Node_Id;
6483+ Condition : Node_Id := Empty;
6484+ Statements : List_Id := Empty_List;
6485+ Pragmas_Before : List_Id := No_List)
6486+ return Node_Id;
6487+ pragma Inline (Make_Accept_Alternative);
6488+
6489+ function Make_Delay_Alternative (Sloc : Source_Ptr;
6490+ Delay_Statement : Node_Id;
6491+ Condition : Node_Id := Empty;
6492+ Statements : List_Id := Empty_List;
6493+ Pragmas_Before : List_Id := No_List)
6494+ return Node_Id;
6495+ pragma Inline (Make_Delay_Alternative);
6496+
6497+ function Make_Terminate_Alternative (Sloc : Source_Ptr;
6498+ Condition : Node_Id := Empty;
6499+ Pragmas_Before : List_Id := No_List;
6500+ Pragmas_After : List_Id := No_List)
6501+ return Node_Id;
6502+ pragma Inline (Make_Terminate_Alternative);
6503+
6504+ function Make_Timed_Entry_Call (Sloc : Source_Ptr;
6505+ Entry_Call_Alternative : Node_Id;
6506+ Delay_Alternative : Node_Id)
6507+ return Node_Id;
6508+ pragma Inline (Make_Timed_Entry_Call);
6509+
6510+ function Make_Entry_Call_Alternative (Sloc : Source_Ptr;
6511+ Entry_Call_Statement : Node_Id;
6512+ Statements : List_Id := Empty_List;
6513+ Pragmas_Before : List_Id := No_List)
6514+ return Node_Id;
6515+ pragma Inline (Make_Entry_Call_Alternative);
6516+
6517+ function Make_Conditional_Entry_Call (Sloc : Source_Ptr;
6518+ Entry_Call_Alternative : Node_Id;
6519+ Else_Statements : List_Id)
6520+ return Node_Id;
6521+ pragma Inline (Make_Conditional_Entry_Call);
6522+
6523+ function Make_Asynchronous_Select (Sloc : Source_Ptr;
6524+ Triggering_Alternative : Node_Id;
6525+ Abortable_Part : Node_Id)
6526+ return Node_Id;
6527+ pragma Inline (Make_Asynchronous_Select);
6528+
6529+ function Make_Triggering_Alternative (Sloc : Source_Ptr;
6530+ Triggering_Statement : Node_Id;
6531+ Statements : List_Id := Empty_List;
6532+ Pragmas_Before : List_Id := No_List)
6533+ return Node_Id;
6534+ pragma Inline (Make_Triggering_Alternative);
6535+
6536+ function Make_Abortable_Part (Sloc : Source_Ptr;
6537+ Statements : List_Id)
6538+ return Node_Id;
6539+ pragma Inline (Make_Abortable_Part);
6540+
6541+ function Make_Abort_Statement (Sloc : Source_Ptr;
6542+ Names : List_Id)
6543+ return Node_Id;
6544+ pragma Inline (Make_Abort_Statement);
6545+
6546+ function Make_Compilation_Unit (Sloc : Source_Ptr;
6547+ Context_Items : List_Id;
6548+ Private_Present : Boolean := False;
6549+ Unit : Node_Id;
6550+ Aux_Decls_Node : Node_Id)
6551+ return Node_Id;
6552+ pragma Inline (Make_Compilation_Unit);
6553+
6554+ function Make_Compilation_Unit_Aux (Sloc : Source_Ptr;
6555+ Declarations : List_Id := No_List;
6556+ Actions : List_Id := No_List;
6557+ Pragmas_After : List_Id := No_List;
6558+ Config_Pragmas : List_Id := Empty_List)
6559+ return Node_Id;
6560+ pragma Inline (Make_Compilation_Unit_Aux);
6561+
6562+ function Make_With_Clause (Sloc : Source_Ptr;
6563+ Name : Node_Id;
6564+ First_Name : Boolean := True;
6565+ Last_Name : Boolean := True;
6566+ Limited_Present : Boolean := False)
6567+ return Node_Id;
6568+ pragma Inline (Make_With_Clause);
6569+
6570+ function Make_With_Type_Clause (Sloc : Source_Ptr;
6571+ Name : Node_Id;
6572+ Tagged_Present : Boolean := False)
6573+ return Node_Id;
6574+ pragma Inline (Make_With_Type_Clause);
6575+
6576+ function Make_Subprogram_Body_Stub (Sloc : Source_Ptr;
6577+ Specification : Node_Id)
6578+ return Node_Id;
6579+ pragma Inline (Make_Subprogram_Body_Stub);
6580+
6581+ function Make_Package_Body_Stub (Sloc : Source_Ptr;
6582+ Defining_Identifier : Node_Id)
6583+ return Node_Id;
6584+ pragma Inline (Make_Package_Body_Stub);
6585+
6586+ function Make_Task_Body_Stub (Sloc : Source_Ptr;
6587+ Defining_Identifier : Node_Id)
6588+ return Node_Id;
6589+ pragma Inline (Make_Task_Body_Stub);
6590+
6591+ function Make_Protected_Body_Stub (Sloc : Source_Ptr;
6592+ Defining_Identifier : Node_Id)
6593+ return Node_Id;
6594+ pragma Inline (Make_Protected_Body_Stub);
6595+
6596+ function Make_Subunit (Sloc : Source_Ptr;
6597+ Name : Node_Id;
6598+ Proper_Body : Node_Id)
6599+ return Node_Id;
6600+ pragma Inline (Make_Subunit);
6601+
6602+ function Make_Exception_Declaration (Sloc : Source_Ptr;
6603+ Defining_Identifier : Node_Id)
6604+ return Node_Id;
6605+ pragma Inline (Make_Exception_Declaration);
6606+
6607+ function Make_Handled_Sequence_Of_Statements (Sloc : Source_Ptr;
6608+ Statements : List_Id;
6609+ End_Label : Node_Id := Empty;
6610+ Exception_Handlers : List_Id := No_List;
6611+ At_End_Proc : Node_Id := Empty)
6612+ return Node_Id;
6613+ pragma Inline (Make_Handled_Sequence_Of_Statements);
6614+
6615+ function Make_Exception_Handler (Sloc : Source_Ptr;
6616+ Choice_Parameter : Node_Id := Empty;
6617+ Exception_Choices : List_Id;
6618+ Statements : List_Id)
6619+ return Node_Id;
6620+ pragma Inline (Make_Exception_Handler);
6621+
6622+ function Make_Raise_Statement (Sloc : Source_Ptr;
6623+ Name : Node_Id := Empty)
6624+ return Node_Id;
6625+ pragma Inline (Make_Raise_Statement);
6626+
6627+ function Make_Generic_Subprogram_Declaration (Sloc : Source_Ptr;
6628+ Specification : Node_Id;
6629+ Generic_Formal_Declarations : List_Id)
6630+ return Node_Id;
6631+ pragma Inline (Make_Generic_Subprogram_Declaration);
6632+
6633+ function Make_Generic_Package_Declaration (Sloc : Source_Ptr;
6634+ Specification : Node_Id;
6635+ Generic_Formal_Declarations : List_Id)
6636+ return Node_Id;
6637+ pragma Inline (Make_Generic_Package_Declaration);
6638+
6639+ function Make_Package_Instantiation (Sloc : Source_Ptr;
6640+ Defining_Unit_Name : Node_Id;
6641+ Name : Node_Id;
6642+ Generic_Associations : List_Id := No_List)
6643+ return Node_Id;
6644+ pragma Inline (Make_Package_Instantiation);
6645+
6646+ function Make_Procedure_Instantiation (Sloc : Source_Ptr;
6647+ Defining_Unit_Name : Node_Id;
6648+ Name : Node_Id;
6649+ Generic_Associations : List_Id := No_List)
6650+ return Node_Id;
6651+ pragma Inline (Make_Procedure_Instantiation);
6652+
6653+ function Make_Function_Instantiation (Sloc : Source_Ptr;
6654+ Defining_Unit_Name : Node_Id;
6655+ Name : Node_Id;
6656+ Generic_Associations : List_Id := No_List)
6657+ return Node_Id;
6658+ pragma Inline (Make_Function_Instantiation);
6659+
6660+ function Make_Generic_Association (Sloc : Source_Ptr;
6661+ Selector_Name : Node_Id := Empty;
6662+ Explicit_Generic_Actual_Parameter : Node_Id)
6663+ return Node_Id;
6664+ pragma Inline (Make_Generic_Association);
6665+
6666+ function Make_Formal_Object_Declaration (Sloc : Source_Ptr;
6667+ Defining_Identifier : Node_Id;
6668+ In_Present : Boolean := False;
6669+ Out_Present : Boolean := False;
6670+ Subtype_Mark : Node_Id;
6671+ Expression : Node_Id := Empty)
6672+ return Node_Id;
6673+ pragma Inline (Make_Formal_Object_Declaration);
6674+
6675+ function Make_Formal_Type_Declaration (Sloc : Source_Ptr;
6676+ Defining_Identifier : Node_Id;
6677+ Formal_Type_Definition : Node_Id;
6678+ Discriminant_Specifications : List_Id := No_List;
6679+ Unknown_Discriminants_Present : Boolean := False)
6680+ return Node_Id;
6681+ pragma Inline (Make_Formal_Type_Declaration);
6682+
6683+ function Make_Formal_Private_Type_Definition (Sloc : Source_Ptr;
6684+ Abstract_Present : Boolean := False;
6685+ Tagged_Present : Boolean := False;
6686+ Limited_Present : Boolean := False)
6687+ return Node_Id;
6688+ pragma Inline (Make_Formal_Private_Type_Definition);
6689+
6690+ function Make_Formal_Derived_Type_Definition (Sloc : Source_Ptr;
6691+ Subtype_Mark : Node_Id;
6692+ Private_Present : Boolean := False;
6693+ Abstract_Present : Boolean := False)
6694+ return Node_Id;
6695+ pragma Inline (Make_Formal_Derived_Type_Definition);
6696+
6697+ function Make_Formal_Discrete_Type_Definition (Sloc : Source_Ptr)
6698+ return Node_Id;
6699+ pragma Inline (Make_Formal_Discrete_Type_Definition);
6700+
6701+ function Make_Formal_Signed_Integer_Type_Definition (Sloc : Source_Ptr)
6702+ return Node_Id;
6703+ pragma Inline (Make_Formal_Signed_Integer_Type_Definition);
6704+
6705+ function Make_Formal_Modular_Type_Definition (Sloc : Source_Ptr)
6706+ return Node_Id;
6707+ pragma Inline (Make_Formal_Modular_Type_Definition);
6708+
6709+ function Make_Formal_Floating_Point_Definition (Sloc : Source_Ptr)
6710+ return Node_Id;
6711+ pragma Inline (Make_Formal_Floating_Point_Definition);
6712+
6713+ function Make_Formal_Ordinary_Fixed_Point_Definition (Sloc : Source_Ptr)
6714+ return Node_Id;
6715+ pragma Inline (Make_Formal_Ordinary_Fixed_Point_Definition);
6716+
6717+ function Make_Formal_Decimal_Fixed_Point_Definition (Sloc : Source_Ptr)
6718+ return Node_Id;
6719+ pragma Inline (Make_Formal_Decimal_Fixed_Point_Definition);
6720+
6721+ function Make_Formal_Subprogram_Declaration (Sloc : Source_Ptr;
6722+ Specification : Node_Id;
6723+ Default_Name : Node_Id := Empty;
6724+ Box_Present : Boolean := False)
6725+ return Node_Id;
6726+ pragma Inline (Make_Formal_Subprogram_Declaration);
6727+
6728+ function Make_Formal_Package_Declaration (Sloc : Source_Ptr;
6729+ Defining_Identifier : Node_Id;
6730+ Name : Node_Id;
6731+ Generic_Associations : List_Id := No_List;
6732+ Box_Present : Boolean := False)
6733+ return Node_Id;
6734+ pragma Inline (Make_Formal_Package_Declaration);
6735+
6736+ function Make_Attribute_Definition_Clause (Sloc : Source_Ptr;
6737+ Name : Node_Id;
6738+ Chars : Name_Id;
6739+ Expression : Node_Id)
6740+ return Node_Id;
6741+ pragma Inline (Make_Attribute_Definition_Clause);
6742+
6743+ function Make_Enumeration_Representation_Clause (Sloc : Source_Ptr;
6744+ Identifier : Node_Id;
6745+ Array_Aggregate : Node_Id)
6746+ return Node_Id;
6747+ pragma Inline (Make_Enumeration_Representation_Clause);
6748+
6749+ function Make_Record_Representation_Clause (Sloc : Source_Ptr;
6750+ Identifier : Node_Id;
6751+ Mod_Clause : Node_Id := Empty;
6752+ Component_Clauses : List_Id)
6753+ return Node_Id;
6754+ pragma Inline (Make_Record_Representation_Clause);
6755+
6756+ function Make_Component_Clause (Sloc : Source_Ptr;
6757+ Component_Name : Node_Id;
6758+ Position : Node_Id;
6759+ First_Bit : Node_Id;
6760+ Last_Bit : Node_Id)
6761+ return Node_Id;
6762+ pragma Inline (Make_Component_Clause);
6763+
6764+ function Make_Code_Statement (Sloc : Source_Ptr;
6765+ Expression : Node_Id)
6766+ return Node_Id;
6767+ pragma Inline (Make_Code_Statement);
6768+
6769+ function Make_Op_Rotate_Left (Sloc : Source_Ptr;
6770+ Left_Opnd : Node_Id;
6771+ Right_Opnd : Node_Id)
6772+ return Node_Id;
6773+ pragma Inline (Make_Op_Rotate_Left);
6774+
6775+ function Make_Op_Rotate_Right (Sloc : Source_Ptr;
6776+ Left_Opnd : Node_Id;
6777+ Right_Opnd : Node_Id)
6778+ return Node_Id;
6779+ pragma Inline (Make_Op_Rotate_Right);
6780+
6781+ function Make_Op_Shift_Left (Sloc : Source_Ptr;
6782+ Left_Opnd : Node_Id;
6783+ Right_Opnd : Node_Id)
6784+ return Node_Id;
6785+ pragma Inline (Make_Op_Shift_Left);
6786+
6787+ function Make_Op_Shift_Right_Arithmetic (Sloc : Source_Ptr;
6788+ Left_Opnd : Node_Id;
6789+ Right_Opnd : Node_Id)
6790+ return Node_Id;
6791+ pragma Inline (Make_Op_Shift_Right_Arithmetic);
6792+
6793+ function Make_Op_Shift_Right (Sloc : Source_Ptr;
6794+ Left_Opnd : Node_Id;
6795+ Right_Opnd : Node_Id)
6796+ return Node_Id;
6797+ pragma Inline (Make_Op_Shift_Right);
6798+
6799+ function Make_Delta_Constraint (Sloc : Source_Ptr;
6800+ Delta_Expression : Node_Id;
6801+ Range_Constraint : Node_Id := Empty)
6802+ return Node_Id;
6803+ pragma Inline (Make_Delta_Constraint);
6804+
6805+ function Make_At_Clause (Sloc : Source_Ptr;
6806+ Identifier : Node_Id;
6807+ Expression : Node_Id)
6808+ return Node_Id;
6809+ pragma Inline (Make_At_Clause);
6810+
6811+ function Make_Mod_Clause (Sloc : Source_Ptr;
6812+ Expression : Node_Id;
6813+ Pragmas_Before : List_Id)
6814+ return Node_Id;
6815+ pragma Inline (Make_Mod_Clause);
6816+
6817+ function Make_Conditional_Expression (Sloc : Source_Ptr;
6818+ Expressions : List_Id)
6819+ return Node_Id;
6820+ pragma Inline (Make_Conditional_Expression);
6821+
6822+ function Make_Expanded_Name (Sloc : Source_Ptr;
6823+ Chars : Name_Id;
6824+ Prefix : Node_Id;
6825+ Selector_Name : Node_Id)
6826+ return Node_Id;
6827+ pragma Inline (Make_Expanded_Name);
6828+
6829+ function Make_Free_Statement (Sloc : Source_Ptr;
6830+ Expression : Node_Id)
6831+ return Node_Id;
6832+ pragma Inline (Make_Free_Statement);
6833+
6834+ function Make_Freeze_Entity (Sloc : Source_Ptr;
6835+ Actions : List_Id := No_List)
6836+ return Node_Id;
6837+ pragma Inline (Make_Freeze_Entity);
6838+
6839+ function Make_Implicit_Label_Declaration (Sloc : Source_Ptr;
6840+ Defining_Identifier : Node_Id)
6841+ return Node_Id;
6842+ pragma Inline (Make_Implicit_Label_Declaration);
6843+
6844+ function Make_Itype_Reference (Sloc : Source_Ptr)
6845+ return Node_Id;
6846+ pragma Inline (Make_Itype_Reference);
6847+
6848+ function Make_Raise_Constraint_Error (Sloc : Source_Ptr;
6849+ Condition : Node_Id := Empty;
6850+ Reason : Uint)
6851+ return Node_Id;
6852+ pragma Inline (Make_Raise_Constraint_Error);
6853+
6854+ function Make_Raise_Program_Error (Sloc : Source_Ptr;
6855+ Condition : Node_Id := Empty;
6856+ Reason : Uint)
6857+ return Node_Id;
6858+ pragma Inline (Make_Raise_Program_Error);
6859+
6860+ function Make_Raise_Storage_Error (Sloc : Source_Ptr;
6861+ Condition : Node_Id := Empty;
6862+ Reason : Uint)
6863+ return Node_Id;
6864+ pragma Inline (Make_Raise_Storage_Error);
6865+
6866+ function Make_Reference (Sloc : Source_Ptr;
6867+ Prefix : Node_Id)
6868+ return Node_Id;
6869+ pragma Inline (Make_Reference);
6870+
6871+ function Make_Subprogram_Info (Sloc : Source_Ptr;
6872+ Identifier : Node_Id)
6873+ return Node_Id;
6874+ pragma Inline (Make_Subprogram_Info);
6875+
6876+ function Make_Unchecked_Expression (Sloc : Source_Ptr;
6877+ Expression : Node_Id)
6878+ return Node_Id;
6879+ pragma Inline (Make_Unchecked_Expression);
6880+
6881+ function Make_Unchecked_Type_Conversion (Sloc : Source_Ptr;
6882+ Subtype_Mark : Node_Id;
6883+ Expression : Node_Id)
6884+ return Node_Id;
6885+ pragma Inline (Make_Unchecked_Type_Conversion);
6886+
6887+ function Make_Validate_Unchecked_Conversion (Sloc : Source_Ptr)
6888+ return Node_Id;
6889+ pragma Inline (Make_Validate_Unchecked_Conversion);
6890+
6891+end Nmake;
6892--- gcc-3.4.0/obj-amd64-pld-linux/gcc/ada/treeprs.ads.orig 1970-01-01 01:00:00.000000000 +0100
6893+++ gcc-3.4.0/obj-amd64-pld-linux/gcc/ada/treeprs.ads 2004-06-02 00:54:11.000000000 +0200
6894@@ -0,0 +1,801 @@
6895+------------------------------------------------------------------------------
6896+-- --
6897+-- GNAT COMPILER COMPONENTS --
6898+-- --
6899+-- T R E E P R S --
6900+-- --
6901+-- S p e c --
6902+-- --
6903+-- Copyright (C) 1992-2003 Free Software Foundation, Inc. --
6904+-- --
6905+-- GNAT is free software; you can redistribute it and/or modify it under --
6906+-- terms of the GNU General Public License as published by the Free Soft- --
6907+-- ware Foundation; either version 2, or (at your option) any later ver- --
6908+-- sion. GNAT is distributed in the hope that it will be useful, but WITH- --
6909+-- OUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY --
6910+-- or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License --
6911+-- for more details. You should have received a copy of the GNU General --
6912+-- Public License distributed with GNAT; see file COPYING. If not, write --
6913+-- to the Free Software Foundation, 59 Temple Place - Suite 330, Boston, --
6914+-- MA 02111-1307, USA. --
6915+-- --
6916+-- GNAT was originally developed by the GNAT team at New York University. --
6917+-- Extensive contributions were provided by Ada Core Technologies Inc. --
6918+-- --
6919+------------------------------------------------------------------------------
6920+
6921+
6922+-- This package contains the declaration of the string used by the Tree_Print
6923+-- package. It must be updated whenever the arrangements of the field names
6924+-- in package Sinfo is changed. The utility program XTREEPRS is used to
6925+-- do this update correctly using the template treeprs.adt as input.
6926+
6927+with Sinfo; use Sinfo;
6928+
6929+package Treeprs is
6930+
6931+ --------------------------------
6932+ -- String Data for Node Print --
6933+ --------------------------------
6934+
6935+ -- String data for print out. The Pchars array is a long string with the
6936+ -- the entry for each node type consisting of a single blank, followed by
6937+ -- a series of entries, one for each Op or Flag field used for the node.
6938+ -- Each entry has a single character which identifies the field, followed
6939+ -- by the synonym name. The starting location for a given node type is
6940+ -- found from the corresponding entry in the Pchars_Pos_Array.
6941+
6942+ -- The following characters identify the field. These are characters
6943+ -- which could never occur in a field name, so they also mark the
6944+ -- end of the previous name.
6945+
6946+ subtype Fchar is Character range '#' .. '9';
6947+
6948+ F_Field1 : constant Fchar := '#'; -- Character'Val (16#23#)
6949+ F_Field2 : constant Fchar := '$'; -- Character'Val (16#24#)
6950+ F_Field3 : constant Fchar := '%'; -- Character'Val (16#25#)
6951+ F_Field4 : constant Fchar := '&'; -- Character'Val (16#26#)
6952+ F_Field5 : constant Fchar := '''; -- Character'Val (16#27#)
6953+ F_Flag1 : constant Fchar := '('; -- Character'Val (16#28#)
6954+ F_Flag2 : constant Fchar := ')'; -- Character'Val (16#29#)
6955+ F_Flag3 : constant Fchar := '*'; -- Character'Val (16#2A#)
6956+ F_Flag4 : constant Fchar := '+'; -- Character'Val (16#2B#)
6957+ F_Flag5 : constant Fchar := ','; -- Character'Val (16#2C#)
6958+ F_Flag6 : constant Fchar := '-'; -- Character'Val (16#2D#)
6959+ F_Flag7 : constant Fchar := '.'; -- Character'Val (16#2E#)
6960+ F_Flag8 : constant Fchar := '/'; -- Character'Val (16#2F#)
6961+ F_Flag9 : constant Fchar := '0'; -- Character'Val (16#30#)
6962+ F_Flag10 : constant Fchar := '1'; -- Character'Val (16#31#)
6963+ F_Flag11 : constant Fchar := '2'; -- Character'Val (16#32#)
6964+ F_Flag12 : constant Fchar := '3'; -- Character'Val (16#33#)
6965+ F_Flag13 : constant Fchar := '4'; -- Character'Val (16#34#)
6966+ F_Flag14 : constant Fchar := '5'; -- Character'Val (16#35#)
6967+ F_Flag15 : constant Fchar := '6'; -- Character'Val (16#36#)
6968+ F_Flag16 : constant Fchar := '7'; -- Character'Val (16#37#)
6969+ F_Flag17 : constant Fchar := '8'; -- Character'Val (16#38#)
6970+ F_Flag18 : constant Fchar := '9'; -- Character'Val (16#39#)
6971+
6972+ -- Note this table does not include entity field and flags whose access
6973+ -- functions are in Einfo (these are handled by the Print_Entity_Info
6974+ -- procedure in Treepr, which uses the routines in Einfo to get the
6975+ -- proper symbolic information). In addition, the following fields are
6976+ -- handled by Treepr, and do not appear in the Pchars array:
6977+
6978+ -- Analyzed
6979+ -- Cannot_Be_Constant
6980+ -- Chars
6981+ -- Comes_From_Source
6982+ -- Error_Posted
6983+ -- Etype
6984+ -- Is_Controlling_Actual
6985+ -- Is_Overloaded
6986+ -- Is_Static_Expression
6987+ -- Left_Opnd
6988+ -- Must_Check_Expr
6989+ -- Must_Not_Freeze
6990+ -- No_Overflow_Expr
6991+ -- Paren_Count
6992+ -- Raises_Constraint_Error
6993+ -- Right_Opnd
6994+
6995+ Pchars : constant String :=
6996+ -- Unused_At_Start
6997+ "" &
6998+ -- At_Clause
6999+ "#Identifier%Expression" &
7000+ -- Component_Clause
7001+ "#Component_Name$Position%First_Bit&Last_Bit" &
7002+ -- Enumeration_Representation_Clause
7003+ "#Identifier%Array_Aggregate&Next_Rep_Item" &
7004+ -- Mod_Clause
7005+ "%Expression&Pragmas_Before" &
7006+ -- Record_Representation_Clause
7007+ "#Identifier$Mod_Clause%Component_Clauses&Next_Rep_Item" &
7008+ -- Attribute_Definition_Clause
7009+ "$Name%Expression&Next_Rep_Item+From_At_Mod2Check_Address_Alignment" &
7010+ -- Empty
7011+ "" &
7012+ -- Pragma
7013+ "$Pragma_Argument_Associations%Debug_Statement&Next_Rep_Item" &
7014+ -- Pragma_Argument_Association
7015+ "%Expression" &
7016+ -- Error
7017+ "" &
7018+ -- Defining_Character_Literal
7019+ "$Next_Entity%Scope" &
7020+ -- Defining_Identifier
7021+ "$Next_Entity%Scope" &
7022+ -- Defining_Operator_Symbol
7023+ "$Next_Entity%Scope" &
7024+ -- Expanded_Name
7025+ "%Prefix$Selector_Name&Entity&Associated_Node4Redundant_Use2Has_Privat" &
7026+ "e_View" &
7027+ -- Identifier
7028+ "&Entity&Associated_Node$Original_Discriminant4Redundant_Use2Has_Priva" &
7029+ "te_View" &
7030+ -- Operator_Symbol
7031+ "%Strval&Entity&Associated_Node2Has_Private_View" &
7032+ -- Character_Literal
7033+ "$Char_Literal_Value&Entity&Associated_Node2Has_Private_View" &
7034+ -- Op_Add
7035+ "" &
7036+ -- Op_Concat
7037+ "4Is_Component_Left_Opnd5Is_Component_Right_Opnd" &
7038+ -- Op_Expon
7039+ "4Is_Power_Of_2_For_Shift" &
7040+ -- Op_Subtract
7041+ "" &
7042+ -- Op_Divide
7043+ "5Treat_Fixed_As_Integer4Do_Division_Check9Rounded_Result" &
7044+ -- Op_Mod
7045+ "5Treat_Fixed_As_Integer4Do_Division_Check" &
7046+ -- Op_Multiply
7047+ "5Treat_Fixed_As_Integer9Rounded_Result" &
7048+ -- Op_Rem
7049+ "5Treat_Fixed_As_Integer4Do_Division_Check" &
7050+ -- Op_And
7051+ "+Do_Length_Check" &
7052+ -- Op_Eq
7053+ "" &
7054+ -- Op_Ge
7055+ "" &
7056+ -- Op_Gt
7057+ "" &
7058+ -- Op_Le
7059+ "" &
7060+ -- Op_Lt
7061+ "" &
7062+ -- Op_Ne
7063+ "" &
7064+ -- Op_Or
7065+ "+Do_Length_Check" &
7066+ -- Op_Xor
7067+ "+Do_Length_Check" &
7068+ -- Op_Rotate_Left
7069+ "+Shift_Count_OK" &
7070+ -- Op_Rotate_Right
7071+ "+Shift_Count_OK" &
7072+ -- Op_Shift_Left
7073+ "+Shift_Count_OK" &
7074+ -- Op_Shift_Right
7075+ "+Shift_Count_OK" &
7076+ -- Op_Shift_Right_Arithmetic
7077+ "+Shift_Count_OK" &
7078+ -- Op_Abs
7079+ "" &
7080+ -- Op_Minus
7081+ "" &
7082+ -- Op_Not
7083+ "" &
7084+ -- Op_Plus
7085+ "" &
7086+ -- Attribute_Reference
7087+ "%Prefix$Attribute_Name#Expressions&Entity&Associated_Node8Do_Overflow" &
7088+ "_Check4Redundant_Use+OK_For_Stream5Must_Be_Byte_Aligned" &
7089+ -- And_Then
7090+ "#Actions" &
7091+ -- Conditional_Expression
7092+ "#Expressions$Then_Actions%Else_Actions" &
7093+ -- Explicit_Dereference
7094+ "%Prefix" &
7095+ -- Function_Call
7096+ "$Name%Parameter_Associations&First_Named_Actual#Controlling_Argument4" &
7097+ "Do_Tag_Check5No_Elaboration_Check8Parameter_List_Truncated9ABE_Is_" &
7098+ "Certain" &
7099+ -- In
7100+ "" &
7101+ -- Indexed_Component
7102+ "%Prefix#Expressions" &
7103+ -- Integer_Literal
7104+ "$Original_Entity%Intval4Print_In_Hex" &
7105+ -- Not_In
7106+ "" &
7107+ -- Null
7108+ "" &
7109+ -- Or_Else
7110+ "#Actions" &
7111+ -- Procedure_Call_Statement
7112+ "$Name%Parameter_Associations&First_Named_Actual#Controlling_Argument4" &
7113+ "Do_Tag_Check5No_Elaboration_Check8Parameter_List_Truncated9ABE_Is_" &
7114+ "Certain" &
7115+ -- Qualified_Expression
7116+ "&Subtype_Mark%Expression" &
7117+ -- Raise_Constraint_Error
7118+ "#Condition%Reason" &
7119+ -- Raise_Program_Error
7120+ "#Condition%Reason" &
7121+ -- Raise_Storage_Error
7122+ "#Condition%Reason" &
7123+ -- Aggregate
7124+ "#Expressions$Component_Associations8Null_Record_Present%Aggregate_Bou" &
7125+ "nds&Associated_Node+Static_Processing_OK9Compile_Time_Known_Aggreg" &
7126+ "ate2Expansion_Delayed" &
7127+ -- Allocator
7128+ "%Expression#Storage_Pool&Procedure_To_Call4No_Initialization8Do_Stora" &
7129+ "ge_Check" &
7130+ -- Extension_Aggregate
7131+ "%Ancestor_Part&Associated_Node#Expressions$Component_Associations8Nul" &
7132+ "l_Record_Present2Expansion_Delayed" &
7133+ -- Range
7134+ "#Low_Bound$High_Bound2Includes_Infinities" &
7135+ -- Real_Literal
7136+ "$Original_Entity%Realval&Corresponding_Integer_Value2Is_Machine_Numbe" &
7137+ "r" &
7138+ -- Reference
7139+ "%Prefix" &
7140+ -- Selected_Component
7141+ "%Prefix$Selector_Name&Associated_Node4Do_Discriminant_Check2Is_In_Dis" &
7142+ "criminant_Check" &
7143+ -- Slice
7144+ "%Prefix&Discrete_Range" &
7145+ -- String_Literal
7146+ "%Strval2Has_Wide_Character" &
7147+ -- Subprogram_Info
7148+ "#Identifier" &
7149+ -- Type_Conversion
7150+ "&Subtype_Mark%Expression4Do_Tag_Check+Do_Length_Check8Do_Overflow_Che" &
7151+ "ck2Float_Truncate9Rounded_Result5Conversion_OK" &
7152+ -- Unchecked_Expression
7153+ "%Expression" &
7154+ -- Unchecked_Type_Conversion
7155+ "&Subtype_Mark%Expression2Kill_Range_Check8No_Truncation" &
7156+ -- Subtype_Indication
7157+ "&Subtype_Mark%Constraint/Must_Not_Freeze" &
7158+ -- Component_Declaration
7159+ "#Defining_Identifier&Component_Definition%Expression,More_Ids-Prev_Id" &
7160+ "s" &
7161+ -- Entry_Declaration
7162+ "#Defining_Identifier&Discrete_Subtype_Definition%Parameter_Specificat" &
7163+ "ions'Corresponding_Body" &
7164+ -- Formal_Object_Declaration
7165+ "#Defining_Identifier6In_Present8Out_Present&Subtype_Mark%Expression,M" &
7166+ "ore_Ids-Prev_Ids" &
7167+ -- Formal_Type_Declaration
7168+ "#Defining_Identifier%Formal_Type_Definition&Discriminant_Specificatio" &
7169+ "ns4Unknown_Discriminants_Present" &
7170+ -- Full_Type_Declaration
7171+ "#Defining_Identifier&Discriminant_Specifications%Type_Definition2Disc" &
7172+ "r_Check_Funcs_Built" &
7173+ -- Incomplete_Type_Declaration
7174+ "#Defining_Identifier&Discriminant_Specifications4Unknown_Discriminant" &
7175+ "s_Present" &
7176+ -- Loop_Parameter_Specification
7177+ "#Defining_Identifier6Reverse_Present&Discrete_Subtype_Definition" &
7178+ -- Object_Declaration
7179+ "#Defining_Identifier+Aliased_Present8Constant_Present&Object_Definiti" &
7180+ "on%Expression$Handler_List_Entry'Corresponding_Generic_Association" &
7181+ ",More_Ids-Prev_Ids4No_Initialization6Assignment_OK2Exception_Junk5" &
7182+ "Delay_Finalize_Attach7Is_Subprogram_Descriptor" &
7183+ -- Protected_Type_Declaration
7184+ "#Defining_Identifier&Discriminant_Specifications%Protected_Definition" &
7185+ "'Corresponding_Body" &
7186+ -- Private_Extension_Declaration
7187+ "#Defining_Identifier&Discriminant_Specifications4Unknown_Discriminant" &
7188+ "s_Present+Abstract_Present'Subtype_Indication" &
7189+ -- Private_Type_Declaration
7190+ "#Defining_Identifier&Discriminant_Specifications4Unknown_Discriminant" &
7191+ "s_Present+Abstract_Present6Tagged_Present8Limited_Present" &
7192+ -- Subtype_Declaration
7193+ "#Defining_Identifier'Subtype_Indication&Generic_Parent_Type2Exception" &
7194+ "_Junk" &
7195+ -- Function_Specification
7196+ "#Defining_Unit_Name$Elaboration_Boolean%Parameter_Specifications&Subt" &
7197+ "ype_Mark'Generic_Parent" &
7198+ -- Procedure_Specification
7199+ "#Defining_Unit_Name$Elaboration_Boolean%Parameter_Specifications'Gene" &
7200+ "ric_Parent" &
7201+ -- Entry_Index_Specification
7202+ "#Defining_Identifier&Discrete_Subtype_Definition" &
7203+ -- Freeze_Entity
7204+ "&Entity$Access_Types_To_Process%TSS_Elist#Actions'First_Subtype_Link" &
7205+ -- Access_Function_Definition
7206+ "6Protected_Present%Parameter_Specifications&Subtype_Mark" &
7207+ -- Access_Procedure_Definition
7208+ "6Protected_Present%Parameter_Specifications" &
7209+ -- Task_Type_Declaration
7210+ "#Defining_Identifier$Task_Body_Procedure&Discriminant_Specifications%" &
7211+ "Task_Definition'Corresponding_Body" &
7212+ -- Package_Body_Stub
7213+ "#Defining_Identifier&Library_Unit'Corresponding_Body" &
7214+ -- Protected_Body_Stub
7215+ "#Defining_Identifier&Library_Unit'Corresponding_Body" &
7216+ -- Subprogram_Body_Stub
7217+ "#Specification&Library_Unit'Corresponding_Body" &
7218+ -- Task_Body_Stub
7219+ "#Defining_Identifier&Library_Unit'Corresponding_Body" &
7220+ -- Function_Instantiation
7221+ "#Defining_Unit_Name$Name%Generic_Associations&Parent_Spec'Instance_Sp" &
7222+ "ec9ABE_Is_Certain" &
7223+ -- Package_Instantiation
7224+ "#Defining_Unit_Name$Name%Generic_Associations&Parent_Spec'Instance_Sp" &
7225+ "ec9ABE_Is_Certain" &
7226+ -- Procedure_Instantiation
7227+ "#Defining_Unit_Name$Name&Parent_Spec%Generic_Associations'Instance_Sp" &
7228+ "ec9ABE_Is_Certain" &
7229+ -- Package_Body
7230+ "#Defining_Unit_Name$Declarations&Handled_Statement_Sequence'Correspon" &
7231+ "ding_Spec4Was_Originally_Stub" &
7232+ -- Subprogram_Body
7233+ "#Specification$Declarations&Handled_Statement_Sequence%Activation_Cha" &
7234+ "in_Entity'Corresponding_Spec+Acts_As_Spec6Bad_Is_Detected8Do_Stora" &
7235+ "ge_Check-Has_Priority_Pragma.Is_Protected_Subprogram_Body,Is_Task_" &
7236+ "Master4Was_Originally_Stub" &
7237+ -- Protected_Body
7238+ "#Defining_Identifier$Declarations&End_Label'Corresponding_Spec4Was_Or" &
7239+ "iginally_Stub" &
7240+ -- Task_Body
7241+ "#Defining_Identifier$Declarations&Handled_Statement_Sequence,Is_Task_" &
7242+ "Master%Activation_Chain_Entity'Corresponding_Spec4Was_Originally_S" &
7243+ "tub" &
7244+ -- Implicit_Label_Declaration
7245+ "#Defining_Identifier$Label_Construct" &
7246+ -- Package_Declaration
7247+ "#Specification'Corresponding_Body&Parent_Spec%Activation_Chain_Entity" &
7248+ -- Single_Task_Declaration
7249+ "#Defining_Identifier%Task_Definition" &
7250+ -- Subprogram_Declaration
7251+ "#Specification%Body_To_Inline'Corresponding_Body&Parent_Spec" &
7252+ -- Use_Package_Clause
7253+ "$Names%Next_Use_Clause&Hidden_By_Use_Clause" &
7254+ -- Generic_Package_Declaration
7255+ "#Specification'Corresponding_Body$Generic_Formal_Declarations&Parent_" &
7256+ "Spec%Activation_Chain_Entity" &
7257+ -- Generic_Subprogram_Declaration
7258+ "#Specification'Corresponding_Body$Generic_Formal_Declarations&Parent_" &
7259+ "Spec" &
7260+ -- Constrained_Array_Definition
7261+ "$Discrete_Subtype_Definitions&Component_Definition" &
7262+ -- Unconstrained_Array_Definition
7263+ "$Subtype_Marks&Component_Definition" &
7264+ -- Exception_Renaming_Declaration
7265+ "#Defining_Identifier$Name" &
7266+ -- Object_Renaming_Declaration
7267+ "#Defining_Identifier&Subtype_Mark$Name'Corresponding_Generic_Associat" &
7268+ "ion" &
7269+ -- Package_Renaming_Declaration
7270+ "#Defining_Unit_Name$Name&Parent_Spec" &
7271+ -- Subprogram_Renaming_Declaration
7272+ "#Specification$Name&Parent_Spec'Corresponding_Spec" &
7273+ -- Generic_Function_Renaming_Declaration
7274+ "#Defining_Unit_Name$Name&Parent_Spec" &
7275+ -- Generic_Package_Renaming_Declaration
7276+ "#Defining_Unit_Name$Name&Parent_Spec" &
7277+ -- Generic_Procedure_Renaming_Declaration
7278+ "#Defining_Unit_Name$Name&Parent_Spec" &
7279+ -- Abort_Statement
7280+ "$Names" &
7281+ -- Accept_Statement
7282+ "#Entry_Direct_Name'Entry_Index%Parameter_Specifications&Handled_State" &
7283+ "ment_Sequence$Declarations" &
7284+ -- Assignment_Statement
7285+ "$Name%Expression4Do_Tag_Check+Do_Length_Check,Forwards_OK-Backwards_O" &
7286+ "K.No_Ctrl_Actions" &
7287+ -- Asynchronous_Select
7288+ "#Triggering_Alternative$Abortable_Part" &
7289+ -- Block_Statement
7290+ "#Identifier$Declarations&Handled_Statement_Sequence,Is_Task_Master%Ac" &
7291+ "tivation_Chain_Entity6Has_Created_Identifier-Is_Task_Allocation_Bl" &
7292+ "ock.Is_Asynchronous_Call_Block" &
7293+ -- Case_Statement
7294+ "%Expression&Alternatives'End_Span" &
7295+ -- Code_Statement
7296+ "%Expression" &
7297+ -- Conditional_Entry_Call
7298+ "#Entry_Call_Alternative&Else_Statements" &
7299+ -- Delay_Relative_Statement
7300+ "%Expression" &
7301+ -- Delay_Until_Statement
7302+ "%Expression" &
7303+ -- Entry_Call_Statement
7304+ "$Name%Parameter_Associations&First_Named_Actual" &
7305+ -- Free_Statement
7306+ "%Expression#Storage_Pool&Procedure_To_Call" &
7307+ -- Goto_Statement
7308+ "$Name2Exception_Junk" &
7309+ -- Loop_Statement
7310+ "#Identifier$Iteration_Scheme%Statements&End_Label6Has_Created_Identif" &
7311+ "ier7Is_Null_Loop" &
7312+ -- Null_Statement
7313+ "" &
7314+ -- Raise_Statement
7315+ "$Name" &
7316+ -- Requeue_Statement
7317+ "$Name6Abort_Present" &
7318+ -- Return_Statement
7319+ "%Expression#Storage_Pool&Procedure_To_Call4Do_Tag_Check$Return_Type,B" &
7320+ "y_Ref" &
7321+ -- Selective_Accept
7322+ "#Select_Alternatives&Else_Statements" &
7323+ -- Timed_Entry_Call
7324+ "#Entry_Call_Alternative&Delay_Alternative" &
7325+ -- Exit_Statement
7326+ "$Name#Condition" &
7327+ -- If_Statement
7328+ "#Condition$Then_Statements%Elsif_Parts&Else_Statements'End_Span" &
7329+ -- Accept_Alternative
7330+ "$Accept_Statement#Condition%Statements&Pragmas_Before'Accept_Handler_" &
7331+ "Records" &
7332+ -- Delay_Alternative
7333+ "$Delay_Statement#Condition%Statements&Pragmas_Before" &
7334+ -- Elsif_Part
7335+ "#Condition$Then_Statements%Condition_Actions" &
7336+ -- Entry_Body_Formal_Part
7337+ "&Entry_Index_Specification%Parameter_Specifications#Condition" &
7338+ -- Iteration_Scheme
7339+ "#Condition%Condition_Actions&Loop_Parameter_Specification" &
7340+ -- Terminate_Alternative
7341+ "#Condition&Pragmas_Before'Pragmas_After" &
7342+ -- Abortable_Part
7343+ "%Statements" &
7344+ -- Abstract_Subprogram_Declaration
7345+ "#Specification" &
7346+ -- Access_Definition
7347+ "&Subtype_Mark" &
7348+ -- Access_To_Object_Definition
7349+ "6All_Present'Subtype_Indication8Constant_Present" &
7350+ -- Case_Statement_Alternative
7351+ "&Discrete_Choices%Statements" &
7352+ -- Compilation_Unit
7353+ "&Library_Unit#Context_Items6Private_Present$Unit'Aux_Decls_Node8Has_N" &
7354+ "o_Elaboration_Code4Body_Required+Acts_As_Spec%First_Inlined_Subpro" &
7355+ "gram" &
7356+ -- Compilation_Unit_Aux
7357+ "$Declarations#Actions'Pragmas_After&Config_Pragmas" &
7358+ -- Component_Association
7359+ "#Choices$Loop_Actions%Expression6Box_Present" &
7360+ -- Component_Definition
7361+ "+Aliased_Present'Subtype_Indication" &
7362+ -- Component_List
7363+ "%Component_Items&Variant_Part4Null_Present" &
7364+ -- Derived_Type_Definition
7365+ "+Abstract_Present'Subtype_Indication%Record_Extension_Part" &
7366+ -- Decimal_Fixed_Point_Definition
7367+ "%Delta_Expression$Digits_Expression&Real_Range_Specification" &
7368+ -- Defining_Program_Unit_Name
7369+ "$Name#Defining_Identifier" &
7370+ -- Delta_Constraint
7371+ "%Delta_Expression&Range_Constraint" &
7372+ -- Designator
7373+ "$Name#Identifier" &
7374+ -- Digits_Constraint
7375+ "$Digits_Expression&Range_Constraint" &
7376+ -- Discriminant_Association
7377+ "#Selector_Names%Expression" &
7378+ -- Discriminant_Specification
7379+ "#Defining_Identifier'Discriminant_Type%Expression,More_Ids-Prev_Ids" &
7380+ -- Enumeration_Type_Definition
7381+ "#Literals&End_Label" &
7382+ -- Entry_Body
7383+ "#Defining_Identifier'Entry_Body_Formal_Part$Declarations&Handled_Stat" &
7384+ "ement_Sequence%Activation_Chain_Entity" &
7385+ -- Entry_Call_Alternative
7386+ "#Entry_Call_Statement%Statements&Pragmas_Before" &
7387+ -- Exception_Declaration
7388+ "#Defining_Identifier%Expression,More_Ids-Prev_Ids" &
7389+ -- Exception_Handler
7390+ "$Choice_Parameter&Exception_Choices%Statements,Zero_Cost_Handling" &
7391+ -- Floating_Point_Definition
7392+ "$Digits_Expression&Real_Range_Specification" &
7393+ -- Formal_Decimal_Fixed_Point_Definition
7394+ "" &
7395+ -- Formal_Derived_Type_Definition
7396+ "&Subtype_Mark6Private_Present+Abstract_Present" &
7397+ -- Formal_Discrete_Type_Definition
7398+ "" &
7399+ -- Formal_Floating_Point_Definition
7400+ "" &
7401+ -- Formal_Modular_Type_Definition
7402+ "" &
7403+ -- Formal_Ordinary_Fixed_Point_Definition
7404+ "" &
7405+ -- Formal_Package_Declaration
7406+ "#Defining_Identifier$Name%Generic_Associations6Box_Present'Instance_S" &
7407+ "pec9ABE_Is_Certain" &
7408+ -- Formal_Private_Type_Definition
7409+ "+Abstract_Present6Tagged_Present8Limited_Present" &
7410+ -- Formal_Signed_Integer_Type_Definition
7411+ "" &
7412+ -- Formal_Subprogram_Declaration
7413+ "#Specification$Default_Name6Box_Present" &
7414+ -- Generic_Association
7415+ "$Selector_Name#Explicit_Generic_Actual_Parameter" &
7416+ -- Handled_Sequence_Of_Statements
7417+ "%Statements&End_Label'Exception_Handlers#At_End_Proc$First_Real_State" &
7418+ "ment,Zero_Cost_Handling" &
7419+ -- Index_Or_Discriminant_Constraint
7420+ "#Constraints" &
7421+ -- Itype_Reference
7422+ "#Itype" &
7423+ -- Label
7424+ "#Identifier2Exception_Junk" &
7425+ -- Modular_Type_Definition
7426+ "%Expression" &
7427+ -- Number_Declaration
7428+ "#Defining_Identifier%Expression,More_Ids-Prev_Ids" &
7429+ -- Ordinary_Fixed_Point_Definition
7430+ "%Delta_Expression&Real_Range_Specification" &
7431+ -- Others_Choice
7432+ "#Others_Discrete_Choices2All_Others" &
7433+ -- Package_Specification
7434+ "#Defining_Unit_Name$Visible_Declarations%Private_Declarations&End_Lab" &
7435+ "el'Generic_Parent9Limited_View_Installed" &
7436+ -- Parameter_Association
7437+ "$Selector_Name%Explicit_Actual_Parameter&Next_Named_Actual" &
7438+ -- Parameter_Specification
7439+ "#Defining_Identifier6In_Present8Out_Present$Parameter_Type%Expression" &
7440+ "4Do_Accessibility_Check,More_Ids-Prev_Ids'Default_Expression" &
7441+ -- Protected_Definition
7442+ "$Visible_Declarations%Private_Declarations&End_Label-Has_Priority_Pra" &
7443+ "gma" &
7444+ -- Range_Constraint
7445+ "&Range_Expression" &
7446+ -- Real_Range_Specification
7447+ "#Low_Bound$High_Bound" &
7448+ -- Record_Definition
7449+ "&End_Label+Abstract_Present6Tagged_Present8Limited_Present#Component_" &
7450+ "List4Null_Present" &
7451+ -- Signed_Integer_Type_Definition
7452+ "#Low_Bound$High_Bound" &
7453+ -- Single_Protected_Declaration
7454+ "#Defining_Identifier%Protected_Definition" &
7455+ -- Subunit
7456+ "$Name#Proper_Body%Corresponding_Stub" &
7457+ -- Task_Definition
7458+ "$Visible_Declarations%Private_Declarations&End_Label-Has_Priority_Pra" &
7459+ "gma,Has_Storage_Size_Pragma.Has_Task_Info_Pragma/Has_Task_Name_Pra" &
7460+ "gma" &
7461+ -- Triggering_Alternative
7462+ "#Triggering_Statement%Statements&Pragmas_Before" &
7463+ -- Use_Type_Clause
7464+ "$Subtype_Marks%Next_Use_Clause&Hidden_By_Use_Clause" &
7465+ -- Validate_Unchecked_Conversion
7466+ "#Source_Type$Target_Type" &
7467+ -- Variant
7468+ "&Discrete_Choices#Component_List$Enclosing_Variant%Present_Expr'Dchec" &
7469+ "k_Function" &
7470+ -- Variant_Part
7471+ "$Name#Variants" &
7472+ -- With_Clause
7473+ "$Name&Library_Unit'Corresponding_Spec,First_Name-Last_Name4Context_In" &
7474+ "stalled+Elaborate_Present6Elaborate_All_Present7Implicit_With8Limi" &
7475+ "ted_Present9Limited_View_Installed.Unreferenced_In_Spec/No_Entitie" &
7476+ "s_Ref_In_Spec" &
7477+ -- With_Type_Clause
7478+ "$Name6Tagged_Present" &
7479+ -- Unused_At_End
7480+ "";
7481+
7482+ type Pchar_Pos_Array is array (Node_Kind) of Positive;
7483+ Pchar_Pos : constant Pchar_Pos_Array := Pchar_Pos_Array'(
7484+ N_Unused_At_Start => 1,
7485+ N_At_Clause => 1,
7486+ N_Component_Clause => 23,
7487+ N_Enumeration_Representation_Clause => 66,
7488+ N_Mod_Clause => 107,
7489+ N_Record_Representation_Clause => 133,
7490+ N_Attribute_Definition_Clause => 187,
7491+ N_Empty => 253,
7492+ N_Pragma => 253,
7493+ N_Pragma_Argument_Association => 312,
7494+ N_Error => 323,
7495+ N_Defining_Character_Literal => 323,
7496+ N_Defining_Identifier => 341,
7497+ N_Defining_Operator_Symbol => 359,
7498+ N_Expanded_Name => 377,
7499+ N_Identifier => 452,
7500+ N_Operator_Symbol => 528,
7501+ N_Character_Literal => 575,
7502+ N_Op_Add => 634,
7503+ N_Op_Concat => 634,
7504+ N_Op_Expon => 681,
7505+ N_Op_Subtract => 705,
7506+ N_Op_Divide => 705,
7507+ N_Op_Mod => 761,
7508+ N_Op_Multiply => 802,
7509+ N_Op_Rem => 840,
7510+ N_Op_And => 881,
7511+ N_Op_Eq => 897,
7512+ N_Op_Ge => 897,
7513+ N_Op_Gt => 897,
7514+ N_Op_Le => 897,
7515+ N_Op_Lt => 897,
7516+ N_Op_Ne => 897,
7517+ N_Op_Or => 897,
7518+ N_Op_Xor => 913,
7519+ N_Op_Rotate_Left => 929,
7520+ N_Op_Rotate_Right => 944,
7521+ N_Op_Shift_Left => 959,
7522+ N_Op_Shift_Right => 974,
7523+ N_Op_Shift_Right_Arithmetic => 989,
7524+ N_Op_Abs => 1004,
7525+ N_Op_Minus => 1004,
7526+ N_Op_Not => 1004,
7527+ N_Op_Plus => 1004,
7528+ N_Attribute_Reference => 1004,
7529+ N_And_Then => 1128,
7530+ N_Conditional_Expression => 1136,
7531+ N_Explicit_Dereference => 1174,
7532+ N_Function_Call => 1181,
7533+ N_In => 1323,
7534+ N_Indexed_Component => 1323,
7535+ N_Integer_Literal => 1342,
7536+ N_Not_In => 1378,
7537+ N_Null => 1378,
7538+ N_Or_Else => 1378,
7539+ N_Procedure_Call_Statement => 1386,
7540+ N_Qualified_Expression => 1528,
7541+ N_Raise_Constraint_Error => 1552,
7542+ N_Raise_Program_Error => 1569,
7543+ N_Raise_Storage_Error => 1586,
7544+ N_Aggregate => 1603,
7545+ N_Allocator => 1759,
7546+ N_Extension_Aggregate => 1836,
7547+ N_Range => 1939,
7548+ N_Real_Literal => 1980,
7549+ N_Reference => 2050,
7550+ N_Selected_Component => 2057,
7551+ N_Slice => 2141,
7552+ N_String_Literal => 2163,
7553+ N_Subprogram_Info => 2189,
7554+ N_Type_Conversion => 2200,
7555+ N_Unchecked_Expression => 2315,
7556+ N_Unchecked_Type_Conversion => 2326,
7557+ N_Subtype_Indication => 2381,
7558+ N_Component_Declaration => 2421,
7559+ N_Entry_Declaration => 2491,
7560+ N_Formal_Object_Declaration => 2583,
7561+ N_Formal_Type_Declaration => 2668,
7562+ N_Full_Type_Declaration => 2769,
7563+ N_Incomplete_Type_Declaration => 2857,
7564+ N_Loop_Parameter_Specification => 2935,
7565+ N_Object_Declaration => 2999,
7566+ N_Protected_Type_Declaration => 3246,
7567+ N_Private_Extension_Declaration => 3334,
7568+ N_Private_Type_Declaration => 3448,
7569+ N_Subtype_Declaration => 3574,
7570+ N_Function_Specification => 3648,
7571+ N_Procedure_Specification => 3740,
7572+ N_Entry_Index_Specification => 3819,
7573+ N_Freeze_Entity => 3867,
7574+ N_Access_Function_Definition => 3935,
7575+ N_Access_Procedure_Definition => 3991,
7576+ N_Task_Type_Declaration => 4034,
7577+ N_Package_Body_Stub => 4137,
7578+ N_Protected_Body_Stub => 4189,
7579+ N_Subprogram_Body_Stub => 4241,
7580+ N_Task_Body_Stub => 4287,
7581+ N_Function_Instantiation => 4339,
7582+ N_Package_Instantiation => 4425,
7583+ N_Procedure_Instantiation => 4511,
7584+ N_Package_Body => 4597,
7585+ N_Subprogram_Body => 4695,
7586+ N_Protected_Body => 4922,
7587+ N_Task_Body => 5004,
7588+ N_Implicit_Label_Declaration => 5142,
7589+ N_Package_Declaration => 5178,
7590+ N_Single_Task_Declaration => 5247,
7591+ N_Subprogram_Declaration => 5283,
7592+ N_Use_Package_Clause => 5343,
7593+ N_Generic_Package_Declaration => 5386,
7594+ N_Generic_Subprogram_Declaration => 5483,
7595+ N_Constrained_Array_Definition => 5556,
7596+ N_Unconstrained_Array_Definition => 5606,
7597+ N_Exception_Renaming_Declaration => 5641,
7598+ N_Object_Renaming_Declaration => 5666,
7599+ N_Package_Renaming_Declaration => 5738,
7600+ N_Subprogram_Renaming_Declaration => 5774,
7601+ N_Generic_Function_Renaming_Declaration => 5824,
7602+ N_Generic_Package_Renaming_Declaration => 5860,
7603+ N_Generic_Procedure_Renaming_Declaration => 5896,
7604+ N_Abort_Statement => 5932,
7605+ N_Accept_Statement => 5938,
7606+ N_Assignment_Statement => 6033,
7607+ N_Asynchronous_Select => 6119,
7608+ N_Block_Statement => 6157,
7609+ N_Case_Statement => 6322,
7610+ N_Code_Statement => 6355,
7611+ N_Conditional_Entry_Call => 6366,
7612+ N_Delay_Relative_Statement => 6405,
7613+ N_Delay_Until_Statement => 6416,
7614+ N_Entry_Call_Statement => 6427,
7615+ N_Free_Statement => 6474,
7616+ N_Goto_Statement => 6516,
7617+ N_Loop_Statement => 6536,
7618+ N_Null_Statement => 6621,
7619+ N_Raise_Statement => 6621,
7620+ N_Requeue_Statement => 6626,
7621+ N_Return_Statement => 6645,
7622+ N_Selective_Accept => 6719,
7623+ N_Timed_Entry_Call => 6755,
7624+ N_Exit_Statement => 6796,
7625+ N_If_Statement => 6811,
7626+ N_Accept_Alternative => 6874,
7627+ N_Delay_Alternative => 6950,
7628+ N_Elsif_Part => 7002,
7629+ N_Entry_Body_Formal_Part => 7046,
7630+ N_Iteration_Scheme => 7107,
7631+ N_Terminate_Alternative => 7164,
7632+ N_Abortable_Part => 7203,
7633+ N_Abstract_Subprogram_Declaration => 7214,
7634+ N_Access_Definition => 7228,
7635+ N_Access_To_Object_Definition => 7241,
7636+ N_Case_Statement_Alternative => 7289,
7637+ N_Compilation_Unit => 7317,
7638+ N_Compilation_Unit_Aux => 7456,
7639+ N_Component_Association => 7506,
7640+ N_Component_Definition => 7550,
7641+ N_Component_List => 7585,
7642+ N_Derived_Type_Definition => 7627,
7643+ N_Decimal_Fixed_Point_Definition => 7685,
7644+ N_Defining_Program_Unit_Name => 7745,
7645+ N_Delta_Constraint => 7770,
7646+ N_Designator => 7804,
7647+ N_Digits_Constraint => 7820,
7648+ N_Discriminant_Association => 7855,
7649+ N_Discriminant_Specification => 7881,
7650+ N_Enumeration_Type_Definition => 7948,
7651+ N_Entry_Body => 7967,
7652+ N_Entry_Call_Alternative => 8074,
7653+ N_Exception_Declaration => 8121,
7654+ N_Exception_Handler => 8170,
7655+ N_Floating_Point_Definition => 8235,
7656+ N_Formal_Decimal_Fixed_Point_Definition => 8278,
7657+ N_Formal_Derived_Type_Definition => 8278,
7658+ N_Formal_Discrete_Type_Definition => 8324,
7659+ N_Formal_Floating_Point_Definition => 8324,
7660+ N_Formal_Modular_Type_Definition => 8324,
7661+ N_Formal_Ordinary_Fixed_Point_Definition => 8324,
7662+ N_Formal_Package_Declaration => 8324,
7663+ N_Formal_Private_Type_Definition => 8411,
7664+ N_Formal_Signed_Integer_Type_Definition => 8459,
7665+ N_Formal_Subprogram_Declaration => 8459,
7666+ N_Generic_Association => 8498,
7667+ N_Handled_Sequence_Of_Statements => 8546,
7668+ N_Index_Or_Discriminant_Constraint => 8638,
7669+ N_Itype_Reference => 8650,
7670+ N_Label => 8656,
7671+ N_Modular_Type_Definition => 8682,
7672+ N_Number_Declaration => 8693,
7673+ N_Ordinary_Fixed_Point_Definition => 8742,
7674+ N_Others_Choice => 8784,
7675+ N_Package_Specification => 8819,
7676+ N_Parameter_Association => 8928,
7677+ N_Parameter_Specification => 8986,
7678+ N_Protected_Definition => 9115,
7679+ N_Range_Constraint => 9187,
7680+ N_Real_Range_Specification => 9204,
7681+ N_Record_Definition => 9225,
7682+ N_Signed_Integer_Type_Definition => 9311,
7683+ N_Single_Protected_Declaration => 9332,
7684+ N_Subunit => 9373,
7685+ N_Task_Definition => 9409,
7686+ N_Triggering_Alternative => 9547,
7687+ N_Use_Type_Clause => 9594,
7688+ N_Validate_Unchecked_Conversion => 9645,
7689+ N_Variant => 9669,
7690+ N_Variant_Part => 9748,
7691+ N_With_Clause => 9762,
7692+ N_With_Type_Clause => 9976,
7693+ N_Unused_At_End => 9996);
7694+
7695+end Treeprs;
GNU Compiler Collection: the C compiler and shared files
This page took 1.249909 seconds and 4 git commands to generate.