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
4 +/*--------------------------------------------------------------------------*/
6 +/* GNAT COMPILER COMPONENTS */
12 +/* Copyright (C) 1992-2004, Free Software Foundation, Inc. */
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. */
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. */
32 +/* GNAT was originally developed by the GNAT team at New York University. */
33 +/* Extensive contributions were provided by Ada Core Technologies Inc. */
35 +/*--------------------------------------------------------------------------*/
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
46 + #define N_Pragma_Argument_Association 9
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
56 + #define N_Op_Concat 19
57 + #define N_Op_Expon 20
58 + #define N_Op_Subtract 21
59 + #define N_Op_Divide 22
61 + #define N_Op_Multiply 24
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
78 + #define N_Op_Minus 41
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
87 + #define N_Indexed_Component 50
88 + #define N_Integer_Literal 51
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
101 + #define N_Real_Literal 64
102 + #define N_Reference 65
103 + #define N_Selected_Component 66
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
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,
257 + N_Op_Shift_Right_Arithmetic)
258 + SUBTYPE (N_Body_Stub, Node_Kind,
259 + N_Package_Body_Stub,
261 + SUBTYPE (N_Declaration, Node_Kind,
262 + N_Component_Declaration,
263 + N_Procedure_Specification)
264 + SUBTYPE (N_Direct_Name, Node_Kind,
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,
282 + SUBTYPE (N_Has_Entity, Node_Kind,
284 + N_Attribute_Reference)
285 + SUBTYPE (N_Has_Etype, Node_Kind,
287 + N_Subtype_Indication)
288 + SUBTYPE (N_Has_Treat_Fixed_As_Integer, Node_Kind,
291 + SUBTYPE (N_Later_Decl_Item, Node_Kind,
292 + N_Task_Type_Declaration,
293 + N_Generic_Subprogram_Declaration)
294 + SUBTYPE (N_Op, Node_Kind,
297 + SUBTYPE (N_Op_Boolean, Node_Kind,
300 + SUBTYPE (N_Op_Compare, Node_Kind,
303 + SUBTYPE (N_Op_Shift, Node_Kind,
305 + N_Op_Shift_Right_Arithmetic)
306 + SUBTYPE (N_Proper_Body, Node_Kind,
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,
317 + N_Attribute_Definition_Clause)
318 + SUBTYPE (N_Statement_Other_Than_Procedure_Call, Node_Kind,
321 + SUBTYPE (N_Has_Condition, Node_Kind,
323 + N_Terminate_Alternative)
324 + SUBTYPE (N_Subexpr, Node_Kind,
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,
333 + SUBTYPE (N_Unit_Body, Node_Kind,
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); }
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
854 +/*--------------------------------------------------------------------------*/
856 +/* GNAT COMPILER COMPONENTS */
862 +/* Copyright (C) 1992-2003 Free Software Foundation, Inc. */
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. */
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. */
882 +/* GNAT was originally developed by the GNAT team at New York University. */
883 +/* Extensive contributions were provided by Ada Core Technologies Inc. */
885 +/*--------------------------------------------------------------------------*/
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
947 + #define E_Entry_Family 60
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
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
963 + SUBTYPE (Access_Kind, Entity_Kind,
964 + E_Access_Type, E_Anonymous_Access_Type)
966 + SUBTYPE (Array_Kind, Entity_Kind,
967 + E_Array_Type, E_String_Literal_Subtype)
969 + SUBTYPE (Class_Wide_Kind, Entity_Kind,
970 + E_Class_Wide_Type, E_Class_Wide_Subtype)
972 + SUBTYPE (Composite_Kind, Entity_Kind,
973 + E_Array_Type, E_Protected_Subtype)
975 + SUBTYPE (Concurrent_Kind, Entity_Kind,
976 + E_Task_Type, E_Protected_Subtype)
978 + SUBTYPE (Concurrent_Body_Kind, Entity_Kind,
979 + E_Protected_Body, E_Task_Body)
981 + SUBTYPE (Decimal_Fixed_Point_Kind, Entity_Kind,
982 + E_Decimal_Fixed_Point_Type, E_Decimal_Fixed_Point_Subtype)
984 + SUBTYPE (Digits_Kind, Entity_Kind,
985 + E_Decimal_Fixed_Point_Type, E_Floating_Point_Subtype)
987 + SUBTYPE (Discrete_Kind, Entity_Kind,
988 + E_Enumeration_Type, E_Modular_Integer_Subtype)
990 + SUBTYPE (Discrete_Or_Fixed_Point_Kind, Entity_Kind,
991 + E_Enumeration_Type, E_Decimal_Fixed_Point_Subtype)
993 + SUBTYPE (Elementary_Kind, Entity_Kind,
994 + E_Enumeration_Type, E_Anonymous_Access_Type)
996 + SUBTYPE (Enumeration_Kind, Entity_Kind,
997 + E_Enumeration_Type, E_Enumeration_Subtype)
999 + SUBTYPE (Entry_Kind, Entity_Kind,
1000 + E_Entry, E_Entry_Family)
1002 + SUBTYPE (Fixed_Point_Kind, Entity_Kind,
1003 + E_Ordinary_Fixed_Point_Type, E_Decimal_Fixed_Point_Subtype)
1005 + SUBTYPE (Float_Kind, Entity_Kind,
1006 + E_Floating_Point_Type, E_Floating_Point_Subtype)
1008 + SUBTYPE (Formal_Kind, Entity_Kind,
1009 + E_In_Parameter, E_In_Out_Parameter)
1011 + SUBTYPE (Generic_Subprogram_Kind, Entity_Kind,
1012 + E_Generic_Function, E_Generic_Procedure)
1014 + SUBTYPE (Generic_Unit_Kind, Entity_Kind,
1015 + E_Generic_Function, E_Generic_Package)
1017 + SUBTYPE (Incomplete_Or_Private_Kind, Entity_Kind,
1018 + E_Record_Type_With_Private, E_Incomplete_Type)
1020 + SUBTYPE (Integer_Kind, Entity_Kind,
1021 + E_Signed_Integer_Type, E_Modular_Integer_Subtype)
1023 + SUBTYPE (Modular_Integer_Kind, Entity_Kind,
1024 + E_Modular_Integer_Type, E_Modular_Integer_Subtype)
1026 + SUBTYPE (Named_Kind, Entity_Kind,
1027 + E_Named_Integer, E_Named_Real)
1029 + SUBTYPE (Numeric_Kind, Entity_Kind,
1030 + E_Signed_Integer_Type, E_Floating_Point_Subtype)
1032 + SUBTYPE (Object_Kind, Entity_Kind,
1033 + E_Variable, E_Generic_In_Parameter)
1035 + SUBTYPE (Ordinary_Fixed_Point_Kind, Entity_Kind,
1036 + E_Ordinary_Fixed_Point_Type, E_Ordinary_Fixed_Point_Subtype)
1038 + SUBTYPE (Overloadable_Kind, Entity_Kind,
1039 + E_Enumeration_Literal, E_Entry)
1041 + SUBTYPE (Private_Kind, Entity_Kind,
1042 + E_Record_Type_With_Private, E_Limited_Private_Subtype)
1044 + SUBTYPE (Protected_Kind, Entity_Kind,
1045 + E_Protected_Type, E_Protected_Subtype)
1047 + SUBTYPE (Real_Kind, Entity_Kind,
1048 + E_Ordinary_Fixed_Point_Type, E_Floating_Point_Subtype)
1050 + SUBTYPE (Record_Kind, Entity_Kind,
1051 + E_Class_Wide_Type, E_Record_Subtype_With_Private)
1053 + SUBTYPE (Scalar_Kind, Entity_Kind,
1054 + E_Enumeration_Type, E_Floating_Point_Subtype)
1056 + SUBTYPE (String_Kind, Entity_Kind,
1057 + E_String_Type, E_String_Literal_Subtype)
1059 + SUBTYPE (Subprogram_Kind, Entity_Kind,
1060 + E_Function, E_Procedure)
1062 + SUBTYPE (Signed_Integer_Kind, Entity_Kind,
1063 + E_Signed_Integer_Type, E_Signed_Integer_Subtype)
1065 + SUBTYPE (Task_Kind, Entity_Kind,
1066 + E_Task_Type, E_Task_Subtype)
1068 + SUBTYPE (Type_Kind, Entity_Kind,
1069 + E_Enumeration_Type, E_Subprogram_Type)
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
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;
1084 + typedef Elist_Id L;
1085 + typedef List_Id S;
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);
1108 + #define Component_Alignment einfo__component_alignment
1109 + C Component_Alignment (E Id);
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);
1167 + #define Finalize_Storage_Only einfo__finalize_storage_only
1168 + B Finalize_Storage_Only (E Id);
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);
1205 + #define Has_Interrupt_Handler einfo__has_interrupt_handler
1206 + B Has_Interrupt_Handler (E Id);
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);
1314 + #define Is_Volatile einfo__is_volatile
1315 + B Is_Volatile (E Id);
1317 + #define Is_Wrapper_Package einfo__is_wrapper_package
1318 + B Is_Wrapper_Package (E Id);
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);
1439 + #define Address_Clause einfo__address_clause
1440 + N Address_Clause (E Id);
1442 + #define Alignment_Clause einfo__alignment_clause
1443 + N Alignment_Clause (E Id);
1445 + #define Ancestor_Subtype einfo__ancestor_subtype
1446 + E Ancestor_Subtype (E Id);
1448 + #define Base_Type einfo__base_type
1449 + E Base_Type (E Id);
1451 + #define Constant_Value einfo__constant_value
1452 + N Constant_Value (E Id);
1454 + #define Declaration_Node einfo__declaration_node
1455 + N Declaration_Node (E Id);
1457 + #define Designated_Type einfo__designated_type
1458 + E Designated_Type (E Id);
1460 + #define Enclosing_Dynamic_Scope einfo__enclosing_dynamic_scope
1461 + E Enclosing_Dynamic_Scope (E Id);
1463 + #define First_Component einfo__first_component
1464 + E First_Component (E Id);
1466 + #define First_Discriminant einfo__first_discriminant
1467 + E First_Discriminant (E Id);
1469 + #define First_Formal einfo__first_formal
1470 + E First_Formal (E Id);
1472 + #define First_Stored_Discriminant einfo__first_stored_discriminant
1473 + E First_Stored_Discriminant (E Id);
1475 + #define First_Subtype einfo__first_subtype
1476 + E First_Subtype (E Id);
1478 + #define Has_Attach_Handler einfo__has_attach_handler
1479 + B Has_Attach_Handler (E Id);
1481 + #define Has_Entries einfo__has_entries
1482 + B Has_Entries (E Id);
1484 + #define Has_Foreign_Convention einfo__has_foreign_convention
1485 + B Has_Foreign_Convention (E Id);
1487 + #define Has_Private_Ancestor einfo__has_private_ancestor
1488 + B Has_Private_Ancestor (E Id);
1490 + INLINE B Has_Private_Declaration (E Id);
1492 + #define Implementation_Base_Type einfo__implementation_base_type
1493 + E Implementation_Base_Type (E Id);
1495 + #define Is_Always_Inlined einfo__is_always_inlined
1496 + B Is_Always_Inlined (E Id);
1498 + #define Is_Boolean_Type einfo__is_boolean_type
1499 + B Is_Boolean_Type (E Id);
1501 + #define Is_By_Copy_Type einfo__is_by_copy_type
1502 + B Is_By_Copy_Type (E Id);
1504 + #define Is_By_Reference_Type einfo__is_by_reference_type
1505 + B Is_By_Reference_Type (E Id);
1507 + #define Is_Derived_Type einfo__is_derived_type
1508 + B Is_Derived_Type (E Id);
1510 + #define Is_Dynamic_Scope einfo__is_dynamic_scope
1511 + B Is_Dynamic_Scope (E Id);
1513 + #define Is_Indefinite_Subtype einfo__is_indefinite_subtype
1514 + B Is_Indefinite_Subtype (E Id);
1516 + #define Is_Limited_Type einfo__is_limited_type
1517 + B Is_Limited_Type (E Id);
1519 + #define Is_Package einfo__is_package
1520 + B Is_Package (E Id);
1522 + #define Is_Protected_Private einfo__is_protected_private
1523 + B Is_Protected_Private (E Id);
1525 + #define Is_Protected_Record_Type einfo__is_protected_record_type
1526 + B Is_Protected_Record_Type (E Id);
1528 + #define Is_Return_By_Reference_Type einfo__is_return_by_reference_type
1529 + B Is_Return_By_Reference_Type (E Id);
1531 + #define Is_String_Type einfo__is_string_type
1532 + B Is_String_Type (E Id);
1534 + #define Is_Task_Record_Type einfo__is_task_record_type
1535 + B Is_Task_Record_Type (E Id);
1537 + #define Next_Component einfo__next_component
1538 + E Next_Component (E Id);
1540 + #define Next_Discriminant einfo__next_discriminant
1541 + E Next_Discriminant (E Id);
1543 + #define Next_Formal einfo__next_formal
1544 + E Next_Formal (E Id);
1546 + #define Next_Formal_With_Extras einfo__next_formal_with_extras
1547 + E Next_Formal_With_Extras (E Id);
1549 + INLINE E Next_Literal (E Id);
1551 + #define Next_Stored_Discriminant einfo__next_stored_discriminant
1552 + E Next_Stored_Discriminant (E Id);
1554 + #define Number_Dimensions einfo__number_dimensions
1555 + Pos Number_Dimensions (E Id);
1557 + #define Number_Discriminants einfo__number_discriminants
1558 + Pos Number_Discriminants (E Id);
1560 + #define Number_Entries einfo__number_entries
1561 + Nat Number_Entries (E Id);
1563 + #define Number_Formals einfo__number_formals
1564 + Pos Number_Formals (E Id);
1566 + INLINE Formal_Kind Parameter_Mode (E Id);
1568 + #define Root_Type einfo__root_type
1569 + E Root_Type (E Id);
1571 + #define Scope_Depth_Set einfo__scope_depth_set
1572 + B Scope_Depth_Set (E Id);
1574 + #define Size_Clause einfo__size_clause
1575 + N Size_Clause (E Id);
1577 + #define Tag_Component einfo__tag_component
1578 + E Tag_Component (E Id);
1580 + #define Type_High_Bound einfo__type_high_bound
1581 + N Type_High_Bound (E Id);
1583 + #define Type_Low_Bound einfo__type_low_bound
1584 + N Type_Low_Bound (E Id);
1586 + #define Underlying_Type einfo__underlying_type
1587 + E Underlying_Type (E Id);
1589 + #define Known_Alignment einfo__known_alignment
1590 + B Known_Alignment (Entity_Id E);
1592 + #define Known_Component_Bit_Offset einfo__known_component_bit_offset
1593 + B Known_Component_Bit_Offset (Entity_Id E);
1595 + #define Known_Component_Size einfo__known_component_size
1596 + B Known_Component_Size (Entity_Id E);
1598 + #define Known_Esize einfo__known_esize
1599 + B Known_Esize (Entity_Id E);
1601 + #define Known_Normalized_First_Bit einfo__known_normalized_first_bit
1602 + B Known_Normalized_First_Bit (Entity_Id E);
1604 + #define Known_Normalized_Position einfo__known_normalized_position
1605 + B Known_Normalized_Position (Entity_Id E);
1607 + #define Known_Normalized_Position_Max einfo__known_normalized_position_max
1608 + B Known_Normalized_Position_Max (Entity_Id E);
1610 + #define Known_RM_Size einfo__known_rm_size
1611 + B Known_RM_Size (Entity_Id E);
1613 + #define Known_Static_Component_Bit_Offset einfo__known_static_component_bit_offset
1614 + B Known_Static_Component_Bit_Offset (Entity_Id E);
1616 + #define Known_Static_Component_Size einfo__known_static_component_size
1617 + B Known_Static_Component_Size (Entity_Id E);
1619 + #define Known_Static_Esize einfo__known_static_esize
1620 + B Known_Static_Esize (Entity_Id E);
1622 + #define Known_Static_Normalized_First_Bit einfo__known_static_normalized_first_bit
1623 + B Known_Static_Normalized_First_Bit (Entity_Id E);
1625 + #define Known_Static_Normalized_Position einfo__known_static_normalized_position
1626 + B Known_Static_Normalized_Position (Entity_Id E);
1628 + #define Known_Static_Normalized_Position_Max einfo__known_static_normalized_position_max
1629 + B Known_Static_Normalized_Position_Max (Entity_Id E);
1631 + #define Known_Static_RM_Size einfo__known_static_rm_size
1632 + B Known_Static_RM_Size (Entity_Id E);
1634 + #define Unknown_Alignment einfo__unknown_alignment
1635 + B Unknown_Alignment (Entity_Id E);
1637 + #define Unknown_Component_Bit_Offset einfo__unknown_component_bit_offset
1638 + B Unknown_Component_Bit_Offset (Entity_Id E);
1640 + #define Unknown_Component_Size einfo__unknown_component_size
1641 + B Unknown_Component_Size (Entity_Id E);
1643 + #define Unknown_Esize einfo__unknown_esize
1644 + B Unknown_Esize (Entity_Id E);
1646 + #define Unknown_Normalized_First_Bit einfo__unknown_normalized_first_bit
1647 + B Unknown_Normalized_First_Bit (Entity_Id E);
1649 + #define Unknown_Normalized_Position einfo__unknown_normalized_position
1650 + B Unknown_Normalized_Position (Entity_Id E);
1652 + #define Unknown_Normalized_Position_Max einfo__unknown_normalized_position_max
1653 + B Unknown_Normalized_Position_Max (Entity_Id E);
1655 + #define Unknown_RM_Size einfo__unknown_rm_size
1656 + B Unknown_RM_Size (Entity_Id E);
1659 + INLINE L Accept_Address (E Id)
1660 + { return Elist21 (Id); }
1662 + INLINE E Access_Disp_Table (E Id)
1663 + { return Node16 (Implementation_Base_Type (Id)); }
1665 + INLINE E Actual_Subtype (E Id)
1666 + { return Node17 (Id); }
1668 + INLINE B Address_Taken (E Id)
1669 + { return Flag104 (Id); }
1671 + INLINE E Alias (E Id)
1672 + { return Node18 (Id); }
1674 + INLINE U Alignment (E Id)
1675 + { return Uint14 (Id); }
1677 + INLINE E Associated_Final_Chain (E Id)
1678 + { return Node23 (Id); }
1680 + INLINE E Associated_Formal_Package (E Id)
1681 + { return Node12 (Id); }
1683 + INLINE N Associated_Node_For_Itype (E Id)
1684 + { return Node8 (Id); }
1686 + INLINE E Associated_Storage_Pool (E Id)
1687 + { return Node22 (Root_Type (Id)); }
1689 + INLINE N Barrier_Function (E Id)
1690 + { return Node12 (Id); }
1692 + INLINE N Block_Node (E Id)
1693 + { return Node11 (Id); }
1695 + INLINE E Body_Entity (E Id)
1696 + { return Node19 (Id); }
1698 + INLINE B Body_Needed_For_SAL (E Id)
1699 + { return Flag40 (Id); }
1701 + INLINE B C_Pass_By_Copy (E Id)
1702 + { return Flag125 (Implementation_Base_Type (Id)); }
1704 + INLINE B Can_Never_Be_Null (E Id)
1705 + { return Flag38 (Id); }
1707 + INLINE B Checks_May_Be_Suppressed (E Id)
1708 + { return Flag31 (Id); }
1710 + INLINE E Class_Wide_Type (E Id)
1711 + { return Node9 (Id); }
1713 + INLINE E Cloned_Subtype (E Id)
1714 + { return Node16 (Id); }
1716 + INLINE U Component_Bit_Offset (E Id)
1717 + { return Uint11 (Id); }
1719 + INLINE N Component_Clause (E Id)
1720 + { return Node13 (Id); }
1722 + INLINE U Component_Size (E Id)
1723 + { return Uint22 (Implementation_Base_Type (Id)); }
1725 + INLINE E Component_Type (E Id)
1726 + { return Node20 (Implementation_Base_Type (Id)); }
1728 + INLINE E Corresponding_Concurrent_Type (E Id)
1729 + { return Node18 (Id); }
1731 + INLINE E Corresponding_Discriminant (E Id)
1732 + { return Node19 (Id); }
1734 + INLINE E Corresponding_Equality (E Id)
1735 + { return Node13 (Id); }
1737 + INLINE E Corresponding_Record_Type (E Id)
1738 + { return Node18 (Id); }
1740 + INLINE E Corresponding_Remote_Type (E Id)
1741 + { return Node22 (Id); }
1743 + INLINE N Current_Value (E Id)
1744 + { return Node9 (Id); }
1746 + INLINE E CR_Discriminant (E Id)
1747 + { return Node23 (Id); }
1749 + INLINE B Debug_Info_Off (E Id)
1750 + { return Flag166 (Id); }
1752 + INLINE E Debug_Renaming_Link (E Id)
1753 + { return Node13 (Id); }
1755 + INLINE E Default_Expr_Function (E Id)
1756 + { return Node21 (Id); }
1758 + INLINE B Default_Expressions_Processed (E Id)
1759 + { return Flag108 (Id); }
1761 + INLINE N Default_Value (E Id)
1762 + { return Node20 (Id); }
1764 + INLINE B Delay_Cleanups (E Id)
1765 + { return Flag114 (Id); }
1767 + INLINE B Delay_Subprogram_Descriptors (E Id)
1768 + { return Flag50 (Id); }
1770 + INLINE R Delta_Value (E Id)
1771 + { return Ureal18 (Id); }
1773 + INLINE L Dependent_Instances (E Id)
1774 + { return Elist8 (Id); }
1776 + INLINE B Depends_On_Private (E Id)
1777 + { return Flag14 (Id); }
1779 + INLINE U Digits_Value (E Id)
1780 + { return Uint17 (Id); }
1782 + INLINE E Directly_Designated_Type (E Id)
1783 + { return Node20 (Id); }
1785 + INLINE B Discard_Names (E Id)
1786 + { return Flag88 (Id); }
1788 + INLINE E Discriminal (E Id)
1789 + { return Node17 (Id); }
1791 + INLINE N Discriminal_Link (E Id)
1792 + { return Node10 (Id); }
1794 + INLINE E Discriminant_Checking_Func (E Id)
1795 + { return Node20 (Id); }
1797 + INLINE L Discriminant_Constraint (E Id)
1798 + { return Elist21 (Id); }
1800 + INLINE N Discriminant_Default_Value (E Id)
1801 + { return Node20 (Id); }
1803 + INLINE U Discriminant_Number (E Id)
1804 + { return Uint15 (Id); }
1806 + INLINE U DT_Entry_Count (E Id)
1807 + { return Uint15 (Id); }
1809 + INLINE U DT_Position (E Id)
1810 + { return Uint15 (Id); }
1812 + INLINE E DTC_Entity (E Id)
1813 + { return Node16 (Id); }
1815 + INLINE B Elaborate_All_Desirable (E Id)
1816 + { return Flag146 (Id); }
1818 + INLINE E Elaboration_Entity (E Id)
1819 + { return Node13 (Id); }
1821 + INLINE B Elaboration_Entity_Required (E Id)
1822 + { return Flag174 (Id); }
1824 + INLINE E Enclosing_Scope (E Id)
1825 + { return Node18 (Id); }
1827 + INLINE B Entry_Accepted (E Id)
1828 + { return Flag152 (Id); }
1830 + INLINE E Entry_Bodies_Array (E Id)
1831 + { return Node15 (Id); }
1833 + INLINE E Entry_Cancel_Parameter (E Id)
1834 + { return Node23 (Id); }
1836 + INLINE E Entry_Component (E Id)
1837 + { return Node11 (Id); }
1839 + INLINE E Entry_Formal (E Id)
1840 + { return Node16 (Id); }
1842 + INLINE N Entry_Index_Constant (E Id)
1843 + { return Node18 (Id); }
1845 + INLINE E Entry_Parameters_Type (E Id)
1846 + { return Node15 (Id); }
1848 + INLINE E Enum_Pos_To_Rep (E Id)
1849 + { return Node23 (Id); }
1851 + INLINE Uint Enumeration_Pos (E Id)
1852 + { return Uint11 (Id); }
1854 + INLINE U Enumeration_Rep (E Id)
1855 + { return Uint12 (Id); }
1857 + INLINE N Enumeration_Rep_Expr (E Id)
1858 + { return Node22 (Id); }
1860 + INLINE E Equivalent_Type (E Id)
1861 + { return Node18 (Id); }
1863 + INLINE Uint Esize (E Id)
1864 + { return Uint12 (Id); }
1866 + INLINE Uint Exception_Code (E Id)
1867 + { return Uint22 (Id); }
1869 + INLINE E Extra_Accessibility (E Id)
1870 + { return Node13 (Id); }
1872 + INLINE E Extra_Constrained (E Id)
1873 + { return Node23 (Id); }
1875 + INLINE E Extra_Formal (E Id)
1876 + { return Node15 (Id); }
1878 + INLINE E Finalization_Chain_Entity (E Id)
1879 + { return Node19 (Id); }
1881 + INLINE E First_Entity (E Id)
1882 + { return Node17 (Id); }
1884 + INLINE N First_Index (E Id)
1885 + { return Node17 (Id); }
1887 + INLINE E First_Literal (E Id)
1888 + { return Node17 (Id); }
1890 + INLINE E First_Optional_Parameter (E Id)
1891 + { return Node14 (Id); }
1893 + INLINE E First_Private_Entity (E Id)
1894 + { return Node16 (Id); }
1896 + INLINE E First_Rep_Item (E Id)
1897 + { return Node6 (Id); }
1899 + INLINE N Freeze_Node (E Id)
1900 + { return Node7 (Id); }
1902 + INLINE B From_With_Type (E Id)
1903 + { return Flag159 (Id); }
1905 + INLINE E Full_View (E Id)
1906 + { return Node11 (Id); }
1908 + INLINE B Function_Returns_With_DSP (E Id)
1909 + { return Flag169 (Id); }
1911 + INLINE E Generic_Homonym (E Id)
1912 + { return Node11 (Id); }
1914 + INLINE L Generic_Renamings (E Id)
1915 + { return Elist23 (Id); }
1917 + INLINE S Handler_Records (E Id)
1918 + { return List10 (Id); }
1920 + INLINE B Has_Aliased_Components (E Id)
1921 + { return Flag135 (Implementation_Base_Type (Id)); }
1923 + INLINE B Has_Alignment_Clause (E Id)
1924 + { return Flag46 (Id); }
1926 + INLINE B Has_All_Calls_Remote (E Id)
1927 + { return Flag79 (Id); }
1929 + INLINE B Has_Atomic_Components (E Id)
1930 + { return Flag86 (Implementation_Base_Type (Id)); }
1932 + INLINE B Has_Biased_Representation (E Id)
1933 + { return Flag139 (Id); }
1935 + INLINE B Has_Completion (E Id)
1936 + { return Flag26 (Id); }
1938 + INLINE B Has_Completion_In_Body (E Id)
1939 + { return Flag71 (Id); }
1941 + INLINE B Has_Complex_Representation (E Id)
1942 + { return Flag140 (Implementation_Base_Type (Id)); }
1944 + INLINE B Has_Component_Size_Clause (E Id)
1945 + { return Flag68 (Implementation_Base_Type (Id)); }
1947 + INLINE B Has_Controlled_Component (E Id)
1948 + { return Flag43 (Base_Type (Id)); }
1950 + INLINE B Has_Contiguous_Rep (E Id)
1951 + { return Flag181 (Id); }
1953 + INLINE B Has_Controlling_Result (E Id)
1954 + { return Flag98 (Id); }
1956 + INLINE B Has_Convention_Pragma (E Id)
1957 + { return Flag119 (Id); }
1959 + INLINE B Has_Delayed_Freeze (E Id)
1960 + { return Flag18 (Id); }
1962 + INLINE B Has_Discriminants (E Id)
1963 + { return Flag5 (Id); }
1965 + INLINE B Has_Enumeration_Rep_Clause (E Id)
1966 + { return Flag66 (Id); }
1968 + INLINE B Has_Exit (E Id)
1969 + { return Flag47 (Id); }
1971 + INLINE B Has_External_Tag_Rep_Clause (E Id)
1972 + { return Flag110 (Id); }
1974 + INLINE B Has_Forward_Instantiation (E Id)
1975 + { return Flag175 (Id); }
1977 + INLINE B Has_Fully_Qualified_Name (E Id)
1978 + { return Flag173 (Id); }
1980 + INLINE B Has_Gigi_Rep_Item (E Id)
1981 + { return Flag82 (Id); }
1983 + INLINE B Has_Homonym (E Id)
1984 + { return Flag56 (Id); }
1986 + INLINE B Has_Machine_Radix_Clause (E Id)
1987 + { return Flag83 (Id); }
1989 + INLINE B Has_Master_Entity (E Id)
1990 + { return Flag21 (Id); }
1992 + INLINE B Has_Missing_Return (E Id)
1993 + { return Flag142 (Id); }
1995 + INLINE B Has_Nested_Block_With_Handler (E Id)
1996 + { return Flag101 (Id); }
1998 + INLINE B Has_Non_Standard_Rep (E Id)
1999 + { return Flag75 (Implementation_Base_Type (Id)); }
2001 + INLINE B Has_Object_Size_Clause (E Id)
2002 + { return Flag172 (Id); }
2004 + INLINE B Has_Per_Object_Constraint (E Id)
2005 + { return Flag154 (Id); }
2007 + INLINE B Has_Pragma_Controlled (E Id)
2008 + { return Flag27 (Implementation_Base_Type (Id)); }
2010 + INLINE B Has_Pragma_Elaborate_Body (E Id)
2011 + { return Flag150 (Id); }
2013 + INLINE B Has_Pragma_Inline (E Id)
2014 + { return Flag157 (Id); }
2016 + INLINE B Has_Pragma_Pack (E Id)
2017 + { return Flag121 (Implementation_Base_Type (Id)); }
2019 + INLINE B Has_Pragma_Pure_Function (E Id)
2020 + { return Flag179 (Id); }
2022 + INLINE B Has_Pragma_Unreferenced (E Id)
2023 + { return Flag180 (Id); }
2025 + INLINE B Has_Primitive_Operations (E Id)
2026 + { return Flag120 (Base_Type (Id)); }
2028 + INLINE B Has_Private_Declaration (E Id)
2029 + { return Flag155 (Id); }
2031 + INLINE B Has_Qualified_Name (E Id)
2032 + { return Flag161 (Id); }
2034 + INLINE B Has_Record_Rep_Clause (E Id)
2035 + { return Flag65 (Implementation_Base_Type (Id)); }
2037 + INLINE B Has_Recursive_Call (E Id)
2038 + { return Flag143 (Id); }
2040 + INLINE B Has_Size_Clause (E Id)
2041 + { return Flag29 (Id); }
2043 + INLINE B Has_Small_Clause (E Id)
2044 + { return Flag67 (Id); }
2046 + INLINE B Has_Specified_Layout (E Id)
2047 + { return Flag100 (Implementation_Base_Type (Id)); }
2049 + INLINE B Has_Storage_Size_Clause (E Id)
2050 + { return Flag23 (Implementation_Base_Type (Id)); }
2052 + INLINE B Has_Subprogram_Descriptor (E Id)
2053 + { return Flag93 (Id); }
2055 + INLINE B Has_Task (E Id)
2056 + { return Flag30 (Base_Type (Id)); }
2058 + INLINE B Has_Unchecked_Union (E Id)
2059 + { return Flag123 (Base_Type (Id)); }
2061 + INLINE B Has_Unknown_Discriminants (E Id)
2062 + { return Flag72 (Id); }
2064 + INLINE B Has_Volatile_Components (E Id)
2065 + { return Flag87 (Implementation_Base_Type (Id)); }
2067 + INLINE B Has_Xref_Entry (E Id)
2068 + { return Flag182 (Implementation_Base_Type (Id)); }
2070 + INLINE E Hiding_Loop_Variable (E Id)
2071 + { return Node8 (Id); }
2073 + INLINE E Homonym (E Id)
2074 + { return Node4 (Id); }
2076 + INLINE B In_Package_Body (E Id)
2077 + { return Flag48 (Id); }
2079 + INLINE B In_Private_Part (E Id)
2080 + { return Flag45 (Id); }
2082 + INLINE B In_Use (E Id)
2083 + { return Flag8 (Id); }
2085 + INLINE L Inner_Instances (E Id)
2086 + { return Elist23 (Id); }
2088 + INLINE N Interface_Name (E Id)
2089 + { return Node21 (Id); }
2091 + INLINE B Is_Abstract (E Id)
2092 + { return Flag19 (Id); }
2094 + INLINE B Is_Access_Constant (E Id)
2095 + { return Flag69 (Id); }
2097 + INLINE B Is_Aliased (E Id)
2098 + { return Flag15 (Id); }
2100 + INLINE B Is_AST_Entry (E Id)
2101 + { return Flag132 (Id); }
2103 + INLINE B Is_Asynchronous (E Id)
2104 + { return Flag81 (Id); }
2106 + INLINE B Is_Atomic (E Id)
2107 + { return Flag85 (Id); }
2109 + INLINE B Is_Bit_Packed_Array (E Id)
2110 + { return Flag122 (Implementation_Base_Type (Id)); }
2112 + INLINE B Is_Called (E Id)
2113 + { return Flag102 (Id); }
2115 + INLINE B Is_Character_Type (E Id)
2116 + { return Flag63 (Id); }
2118 + INLINE B Is_Child_Unit (E Id)
2119 + { return Flag73 (Id); }
2121 + INLINE B Is_Class_Wide_Equivalent_Type (E Id)
2122 + { return Flag35 (Id); }
2124 + INLINE B Is_Compilation_Unit (E Id)
2125 + { return Flag149 (Id); }
2127 + INLINE B Is_Completely_Hidden (E Id)
2128 + { return Flag103 (Id); }
2130 + INLINE B Is_Constr_Subt_For_U_Nominal (E Id)
2131 + { return Flag80 (Id); }
2133 + INLINE B Is_Constr_Subt_For_UN_Aliased (E Id)
2134 + { return Flag141 (Id); }
2136 + INLINE B Is_Constrained (E Id)
2137 + { return Flag12 (Id); }
2139 + INLINE B Is_Constructor (E Id)
2140 + { return Flag76 (Id); }
2142 + INLINE B Is_Controlled (E Id)
2143 + { return Flag42 (Base_Type (Id)); }
2145 + INLINE B Is_Controlling_Formal (E Id)
2146 + { return Flag97 (Id); }
2148 + INLINE B Is_CPP_Class (E Id)
2149 + { return Flag74 (Id); }
2151 + INLINE B Is_Discrim_SO_Function (E Id)
2152 + { return Flag176 (Id); }
2154 + INLINE B Is_Dispatching_Operation (E Id)
2155 + { return Flag6 (Id); }
2157 + INLINE B Is_Eliminated (E Id)
2158 + { return Flag124 (Id); }
2160 + INLINE B Is_Entry_Formal (E Id)
2161 + { return Flag52 (Id); }
2163 + INLINE B Is_Exported (E Id)
2164 + { return Flag99 (Id); }
2166 + INLINE B Is_First_Subtype (E Id)
2167 + { return Flag70 (Id); }
2169 + INLINE B Is_For_Access_Subtype (E Id)
2170 + { return Flag118 (Id); }
2172 + INLINE B Is_Formal_Subprogram (E Id)
2173 + { return Flag111 (Id); }
2175 + INLINE B Is_Frozen (E Id)
2176 + { return Flag4 (Id); }
2178 + INLINE B Is_Generic_Actual_Type (E Id)
2179 + { return Flag94 (Id); }
2181 + INLINE B Is_Generic_Instance (E Id)
2182 + { return Flag130 (Id); }
2184 + INLINE B Is_Generic_Type (E Id)
2185 + { return Flag13 (Id); }
2187 + INLINE B Is_Hidden (E Id)
2188 + { return Flag57 (Id); }
2190 + INLINE B Is_Hidden_Open_Scope (E Id)
2191 + { return Flag171 (Id); }
2193 + INLINE B Is_Immediately_Visible (E Id)
2194 + { return Flag7 (Id); }
2196 + INLINE B Is_Imported (E Id)
2197 + { return Flag24 (Id); }
2199 + INLINE B Is_Inlined (E Id)
2200 + { return Flag11 (Id); }
2202 + INLINE B Is_Instantiated (E Id)
2203 + { return Flag126 (Id); }
2205 + INLINE B Is_Internal (E Id)
2206 + { return Flag17 (Id); }
2208 + INLINE B Is_Interrupt_Handler (E Id)
2209 + { return Flag89 (Id); }
2211 + INLINE B Is_Intrinsic_Subprogram (E Id)
2212 + { return Flag64 (Id); }
2214 + INLINE B Is_Itype (E Id)
2215 + { return Flag91 (Id); }
2217 + INLINE B Is_Known_Non_Null (E Id)
2218 + { return Flag37 (Id); }
2220 + INLINE B Is_Known_Valid (E Id)
2221 + { return Flag170 (Id); }
2223 + INLINE B Is_Limited_Composite (E Id)
2224 + { return Flag106 (Id); }
2226 + INLINE B Is_Limited_Record (E Id)
2227 + { return Flag25 (Id); }
2229 + INLINE B Is_Machine_Code_Subprogram (E Id)
2230 + { return Flag137 (Id); }
2232 + INLINE B Is_Non_Static_Subtype (E Id)
2233 + { return Flag109 (Id); }
2235 + INLINE B Is_Null_Init_Proc (E Id)
2236 + { return Flag178 (Id); }
2238 + INLINE B Is_Optional_Parameter (E Id)
2239 + { return Flag134 (Id); }
2241 + INLINE B Is_Overriding_Operation (E Id)
2242 + { return Flag39 (Id); }
2244 + INLINE B Is_Package_Body_Entity (E Id)
2245 + { return Flag160 (Id); }
2247 + INLINE B Is_Packed (E Id)
2248 + { return Flag51 (Implementation_Base_Type (Id)); }
2250 + INLINE B Is_Packed_Array_Type (E Id)
2251 + { return Flag138 (Id); }
2253 + INLINE B Is_Potentially_Use_Visible (E Id)
2254 + { return Flag9 (Id); }
2256 + INLINE B Is_Preelaborated (E Id)
2257 + { return Flag59 (Id); }
2259 + INLINE B Is_Private_Composite (E Id)
2260 + { return Flag107 (Id); }
2262 + INLINE B Is_Private_Descendant (E Id)
2263 + { return Flag53 (Id); }
2265 + INLINE B Is_Psected (E Id)
2266 + { return Flag153 (Id); }
2268 + INLINE B Is_Public (E Id)
2269 + { return Flag10 (Id); }
2271 + INLINE B Is_Pure (E Id)
2272 + { return Flag44 (Id); }
2274 + INLINE B Is_Remote_Call_Interface (E Id)
2275 + { return Flag62 (Id); }
2277 + INLINE B Is_Remote_Types (E Id)
2278 + { return Flag61 (Id); }
2280 + INLINE B Is_Renaming_Of_Object (E Id)
2281 + { return Flag112 (Id); }
2283 + INLINE B Is_Shared_Passive (E Id)
2284 + { return Flag60 (Id); }
2286 + INLINE B Is_Statically_Allocated (E Id)
2287 + { return Flag28 (Id); }
2289 + INLINE B Is_Tag (E Id)
2290 + { return Flag78 (Id); }
2292 + INLINE B Is_Tagged_Type (E Id)
2293 + { return Flag55 (Id); }
2295 + INLINE B Is_Thread_Body (E Id)
2296 + { return Flag77 (Id); }
2298 + INLINE B Is_True_Constant (E Id)
2299 + { return Flag163 (Id); }
2301 + INLINE B Is_Unchecked_Union (E Id)
2302 + { return Flag117 (Id); }
2304 + INLINE B Is_Unsigned_Type (E Id)
2305 + { return Flag144 (Id); }
2307 + INLINE B Is_Valued_Procedure (E Id)
2308 + { return Flag127 (Id); }
2310 + INLINE B Is_Visible_Child_Unit (E Id)
2311 + { return Flag116 (Id); }
2313 + INLINE B Is_VMS_Exception (E Id)
2314 + { return Flag133 (Id); }
2316 + INLINE B Kill_Elaboration_Checks (E Id)
2317 + { return Flag32 (Id); }
2319 + INLINE B Kill_Range_Checks (E Id)
2320 + { return Flag33 (Id); }
2322 + INLINE B Kill_Tag_Checks (E Id)
2323 + { return Flag34 (Id); }
2325 + INLINE E Last_Entity (E Id)
2326 + { return Node20 (Id); }
2328 + INLINE L Limited_Views (E Id)
2329 + { return Elist23 (Id); }
2331 + INLINE E Lit_Indexes (E Id)
2332 + { return Node15 (Id); }
2334 + INLINE E Lit_Strings (E Id)
2335 + { return Node16 (Id); }
2337 + INLINE B Machine_Radix_10 (E Id)
2338 + { return Flag84 (Id); }
2340 + INLINE E Master_Id (E Id)
2341 + { return Node17 (Id); }
2343 + INLINE B Materialize_Entity (E Id)
2344 + { return Flag168 (Id); }
2346 + INLINE M Mechanism (E Id)
2347 + { return UI_To_Int (Uint8 (Id)); }
2349 + INLINE Uint Modulus (E Id)
2350 + { return Uint17 (Base_Type (Id)); }
2352 + INLINE B Needs_Debug_Info (E Id)
2353 + { return Flag147 (Id); }
2355 + INLINE B Needs_No_Actuals (E Id)
2356 + { return Flag22 (Id); }
2358 + INLINE B Never_Set_In_Source (E Id)
2359 + { return Flag115 (Id); }
2361 + INLINE E Next_Inlined_Subprogram (E Id)
2362 + { return Node12 (Id); }
2364 + INLINE B No_Pool_Assigned (E Id)
2365 + { return Flag131 (Root_Type (Id)); }
2367 + INLINE B No_Return (E Id)
2368 + { return Flag113 (Id); }
2370 + INLINE B Non_Binary_Modulus (E Id)
2371 + { return Flag58 (Base_Type (Id)); }
2373 + INLINE E Non_Limited_View (E Id)
2374 + { return Node17 (Id); }
2376 + INLINE B Nonzero_Is_True (E Id)
2377 + { return Flag162 (Base_Type (Id)); }
2379 + INLINE U Normalized_First_Bit (E Id)
2380 + { return Uint8 (Id); }
2382 + INLINE U Normalized_Position (E Id)
2383 + { return Uint14 (Id); }
2385 + INLINE U Normalized_Position_Max (E Id)
2386 + { return Uint10 (Id); }
2388 + INLINE E Object_Ref (E Id)
2389 + { return Node17 (Id); }
2391 + INLINE E Original_Array_Type (E Id)
2392 + { return Node21 (Id); }
2394 + INLINE E Original_Record_Component (E Id)
2395 + { return Node22 (Id); }
2397 + INLINE E Packed_Array_Type (E Id)
2398 + { return Node23 (Id); }
2400 + INLINE E Parent_Subtype (E Id)
2401 + { return Node19 (Id); }
2403 + INLINE L Primitive_Operations (E Id)
2404 + { return Elist15 (Id); }
2406 + INLINE E Prival (E Id)
2407 + { return Node17 (Id); }
2409 + INLINE L Privals_Chain (E Id)
2410 + { return Elist23 (Id); }
2412 + INLINE L Private_Dependents (E Id)
2413 + { return Elist18 (Id); }
2415 + INLINE N Private_View (E Id)
2416 + { return Node22 (Id); }
2418 + INLINE E Protected_Body_Subprogram (E Id)
2419 + { return Node11 (Id); }
2421 + INLINE E Protected_Formal (E Id)
2422 + { return Node22 (Id); }
2424 + INLINE N Protected_Operation (E Id)
2425 + { return Node23 (Id); }
2427 + INLINE B Reachable (E Id)
2428 + { return Flag49 (Id); }
2430 + INLINE B Referenced (E Id)
2431 + { return Flag156 (Id); }
2433 + INLINE B Referenced_As_LHS (E Id)
2434 + { return Flag36 (Id); }
2436 + INLINE N Referenced_Object (E Id)
2437 + { return Node10 (Id); }
2439 + INLINE N Register_Exception_Call (E Id)
2440 + { return Node20 (Id); }
2442 + INLINE E Related_Array_Object (E Id)
2443 + { return Node19 (Id); }
2445 + INLINE E Related_Instance (E Id)
2446 + { return Node15 (Id); }
2448 + INLINE N Renamed_Entity (E Id)
2449 + { return Node18 (Id); }
2451 + INLINE N Renamed_Object (E Id)
2452 + { return Node18 (Id); }
2454 + INLINE U Renaming_Map (E Id)
2455 + { return Uint9 (Id); }
2457 + INLINE B Return_Present (E Id)
2458 + { return Flag54 (Id); }
2460 + INLINE B Returns_By_Ref (E Id)
2461 + { return Flag90 (Id); }
2463 + INLINE B Reverse_Bit_Order (E Id)
2464 + { return Flag164 (Base_Type (Id)); }
2466 + INLINE U RM_Size (E Id)
2467 + { return Uint13 (Id); }
2469 + INLINE N Scalar_Range (E Id)
2470 + { return Node20 (Id); }
2472 + INLINE U Scale_Value (E Id)
2473 + { return Uint15 (Id); }
2475 + INLINE U Scope_Depth_Value (E Id)
2476 + { return Uint22 (Id); }
2478 + INLINE B Sec_Stack_Needed_For_Return (E Id)
2479 + { return Flag167 (Id); }
2481 + INLINE S Shadow_Entities (E Id)
2482 + { return List14 (Id); }
2484 + INLINE E Shared_Var_Assign_Proc (E Id)
2485 + { return Node22 (Id); }
2487 + INLINE E Shared_Var_Read_Proc (E Id)
2488 + { return Node15 (Id); }
2490 + INLINE N Size_Check_Code (E Id)
2491 + { return Node19 (Id); }
2493 + INLINE B Size_Depends_On_Discriminant (E Id)
2494 + { return Flag177 (Id); }
2496 + INLINE B Size_Known_At_Compile_Time (E Id)
2497 + { return Flag92 (Id); }
2499 + INLINE R Small_Value (E Id)
2500 + { return Ureal21 (Id); }
2502 + INLINE E Spec_Entity (E Id)
2503 + { return Node19 (Id); }
2505 + INLINE E Storage_Size_Variable (E Id)
2506 + { return Node15 (Implementation_Base_Type (Id)); }
2508 + INLINE L Stored_Constraint (E Id)
2509 + { return Elist23 (Id); }
2511 + INLINE B Strict_Alignment (E Id)
2512 + { return Flag145 (Implementation_Base_Type (Id)); }
2514 + INLINE U String_Literal_Length (E Id)
2515 + { return Uint16 (Id); }
2517 + INLINE N String_Literal_Low_Bound (E Id)
2518 + { return Node15 (Id); }
2520 + INLINE B Suppress_Elaboration_Warnings (E Id)
2521 + { return Flag148 (Id); }
2523 + INLINE B Suppress_Init_Proc (E Id)
2524 + { return Flag105 (Base_Type (Id)); }
2526 + INLINE B Suppress_Style_Checks (E Id)
2527 + { return Flag165 (Id); }
2529 + INLINE B Treat_As_Volatile (E Id)
2530 + { return Flag41 (Id); }
2532 + INLINE E Underlying_Full_View (E Id)
2533 + { return Node19 (Id); }
2535 + INLINE N Unset_Reference (E Id)
2536 + { return Node16 (Id); }
2538 + INLINE B Uses_Sec_Stack (E Id)
2539 + { return Flag95 (Id); }
2541 + INLINE B Vax_Float (E Id)
2542 + { return Flag151 (Base_Type (Id)); }
2544 + INLINE B Warnings_Off (E Id)
2545 + { return Flag96 (Id); }
2547 + INLINE B Is_Access_Type (E Id)
2548 + { return IN (Ekind (Id), Access_Kind); }
2550 + INLINE B Is_Array_Type (E Id)
2551 + { return IN (Ekind (Id), Array_Kind); }
2553 + INLINE B Is_Class_Wide_Type (E Id)
2554 + { return IN (Ekind (Id), Class_Wide_Kind); }
2556 + INLINE B Is_Composite_Type (E Id)
2557 + { return IN (Ekind (Id), Composite_Kind); }
2559 + INLINE B Is_Concurrent_Body (E Id)
2560 + { return IN (Ekind (Id), Concurrent_Body_Kind); }
2562 + INLINE B Is_Concurrent_Record_Type (E Id)
2563 + { return Flag20 (Id); }
2565 + INLINE B Is_Concurrent_Type (E Id)
2566 + { return IN (Ekind (Id), Concurrent_Kind); }
2568 + INLINE B Is_Decimal_Fixed_Point_Type (E Id)
2569 + { return IN (Ekind (Id), Decimal_Fixed_Point_Kind); }
2571 + INLINE B Is_Digits_Type (E Id)
2572 + { return IN (Ekind (Id), Digits_Kind); }
2574 + INLINE B Is_Discrete_Or_Fixed_Point_Type (E Id)
2575 + { return IN (Ekind (Id), Discrete_Or_Fixed_Point_Kind); }
2577 + INLINE B Is_Discrete_Type (E Id)
2578 + { return IN (Ekind (Id), Discrete_Kind); }
2580 + INLINE B Is_Elementary_Type (E Id)
2581 + { return IN (Ekind (Id), Elementary_Kind); }
2583 + INLINE B Is_Entry (E Id)
2584 + { return IN (Ekind (Id), Entry_Kind); }
2586 + INLINE B Is_Enumeration_Type (E Id)
2587 + { return IN (Ekind (Id), Enumeration_Kind); }
2589 + INLINE B Is_Fixed_Point_Type (E Id)
2590 + { return IN (Ekind (Id), Fixed_Point_Kind); }
2592 + INLINE B Is_Floating_Point_Type (E Id)
2593 + { return IN (Ekind (Id), Float_Kind); }
2595 + INLINE B Is_Formal (E Id)
2596 + { return IN (Ekind (Id), Formal_Kind); }
2598 + INLINE B Is_Generic_Subprogram (E Id)
2599 + { return IN (Ekind (Id), Generic_Subprogram_Kind); }
2601 + INLINE B Is_Generic_Unit (E Id)
2602 + { return IN (Ekind (Id), Generic_Unit_Kind); }
2604 + INLINE B Is_Incomplete_Or_Private_Type (E Id)
2605 + { return IN (Ekind (Id), Incomplete_Or_Private_Kind); }
2607 + INLINE B Is_Integer_Type (E Id)
2608 + { return IN (Ekind (Id), Integer_Kind); }
2610 + INLINE B Is_Modular_Integer_Type (E Id)
2611 + { return IN (Ekind (Id), Modular_Integer_Kind); }
2613 + INLINE B Is_Named_Number (E Id)
2614 + { return IN (Ekind (Id), Named_Kind); }
2616 + INLINE B Is_Numeric_Type (E Id)
2617 + { return IN (Ekind (Id), Numeric_Kind); }
2619 + INLINE B Is_Object (E Id)
2620 + { return IN (Ekind (Id), Object_Kind); }
2622 + INLINE B Is_Ordinary_Fixed_Point_Type (E Id)
2623 + { return IN (Ekind (Id), Ordinary_Fixed_Point_Kind); }
2625 + INLINE B Is_Overloadable (E Id)
2626 + { return IN (Ekind (Id), Overloadable_Kind); }
2628 + INLINE B Is_Private_Type (E Id)
2629 + { return IN (Ekind (Id), Private_Kind); }
2631 + INLINE B Is_Protected_Type (E Id)
2632 + { return IN (Ekind (Id), Protected_Kind); }
2634 + INLINE B Is_Real_Type (E Id)
2635 + { return IN (Ekind (Id), Real_Kind); }
2637 + INLINE B Is_Record_Type (E Id)
2638 + { return IN (Ekind (Id), Record_Kind); }
2640 + INLINE B Is_Scalar_Type (E Id)
2641 + { return IN (Ekind (Id), Scalar_Kind); }
2643 + INLINE B Is_Signed_Integer_Type (E Id)
2644 + { return IN (Ekind (Id), Signed_Integer_Kind); }
2646 + INLINE B Is_Subprogram (E Id)
2647 + { return IN (Ekind (Id), Subprogram_Kind); }
2649 + INLINE B Is_Task_Type (E Id)
2650 + { return IN (Ekind (Id), Task_Kind); }
2652 + INLINE B Is_Type (E Id)
2653 + { return IN (Ekind (Id), Type_Kind); }
2655 + INLINE N Entry_Index_Type (E Id)
2656 + { return Etype (Discrete_Subtype_Definition (Parent (Id))); }
2658 + INLINE Node_Id Next_Index (Node_Id Id)
2659 + { return Next (Id); }
2661 + INLINE E Next_Literal (E Id)
2662 + { return Next (Id); }
2664 + INLINE Formal_Kind Parameter_Mode (E Id)
2665 + { return Ekind (Id); }
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
2671 +------------------------------------------------------------------------------
2673 +-- GNAT COMPILER COMPONENTS --
2679 +-- Copyright (C) 1992-2003 Free Software Foundation, Inc. --
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. --
2692 +-- GNAT was originally developed by the GNAT team at New York University. --
2693 +-- Extensive contributions were provided by Ada Core Technologies Inc. --
2695 +------------------------------------------------------------------------------
2697 +pragma Style_Checks (All_Checks);
2698 +-- Turn off subprogram order checking, since the routines here are
2699 +-- generated automatically in order.
2702 +with Atree; use Atree;
2703 +with Sinfo; use Sinfo;
2704 +with Snames; use Snames;
2705 +with Stand; use Stand;
2707 +package body Nmake is
2709 + function Make_Unused_At_Start (Sloc : Source_Ptr)
2712 + N : constant Node_Id :=
2713 + New_Node (N_Unused_At_Start, Sloc);
2716 + end Make_Unused_At_Start;
2718 + function Make_Unused_At_End (Sloc : Source_Ptr)
2721 + N : constant Node_Id :=
2722 + New_Node (N_Unused_At_End, Sloc);
2725 + end Make_Unused_At_End;
2727 + function Make_Identifier (Sloc : Source_Ptr;
2731 + N : constant Node_Id :=
2732 + New_Node (N_Identifier, Sloc);
2734 + Set_Chars (N, Chars);
2736 + end Make_Identifier;
2738 + function Make_Integer_Literal (Sloc : Source_Ptr;
2742 + N : constant Node_Id :=
2743 + New_Node (N_Integer_Literal, Sloc);
2745 + Set_Intval (N, Intval);
2747 + end Make_Integer_Literal;
2749 + function Make_Real_Literal (Sloc : Source_Ptr;
2753 + N : constant Node_Id :=
2754 + New_Node (N_Real_Literal, Sloc);
2756 + Set_Realval (N, Realval);
2758 + end Make_Real_Literal;
2760 + function Make_Character_Literal (Sloc : Source_Ptr;
2762 + Char_Literal_Value : Char_Code)
2765 + N : constant Node_Id :=
2766 + New_Node (N_Character_Literal, Sloc);
2768 + Set_Chars (N, Chars);
2769 + Set_Char_Literal_Value (N, Char_Literal_Value);
2771 + end Make_Character_Literal;
2773 + function Make_String_Literal (Sloc : Source_Ptr;
2774 + Strval : String_Id)
2777 + N : constant Node_Id :=
2778 + New_Node (N_String_Literal, Sloc);
2780 + Set_Strval (N, Strval);
2782 + end Make_String_Literal;
2784 + function Make_Pragma (Sloc : Source_Ptr;
2786 + Pragma_Argument_Associations : List_Id := No_List;
2787 + Debug_Statement : Node_Id := Empty)
2790 + N : constant Node_Id :=
2791 + New_Node (N_Pragma, Sloc);
2793 + Set_Chars (N, Chars);
2794 + Set_Pragma_Argument_Associations
2795 + (N, Pragma_Argument_Associations);
2796 + Set_Debug_Statement (N, Debug_Statement);
2800 + function Make_Pragma_Argument_Association (Sloc : Source_Ptr;
2801 + Chars : Name_Id := No_Name;
2802 + Expression : Node_Id)
2805 + N : constant Node_Id :=
2806 + New_Node (N_Pragma_Argument_Association, Sloc);
2808 + Set_Chars (N, Chars);
2809 + Set_Expression (N, Expression);
2811 + end Make_Pragma_Argument_Association;
2813 + function Make_Defining_Identifier (Sloc : Source_Ptr;
2817 + N : constant Node_Id :=
2818 + New_Entity (N_Defining_Identifier, Sloc);
2820 + Set_Chars (N, Chars);
2822 + end Make_Defining_Identifier;
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)
2830 + N : constant Node_Id :=
2831 + New_Node (N_Full_Type_Declaration, Sloc);
2833 + Set_Defining_Identifier (N, Defining_Identifier);
2834 + Set_Discriminant_Specifications (N, Discriminant_Specifications);
2835 + Set_Type_Definition (N, Type_Definition);
2837 + end Make_Full_Type_Declaration;
2839 + function Make_Subtype_Declaration (Sloc : Source_Ptr;
2840 + Defining_Identifier : Node_Id;
2841 + Subtype_Indication : Node_Id)
2844 + N : constant Node_Id :=
2845 + New_Node (N_Subtype_Declaration, Sloc);
2847 + Set_Defining_Identifier (N, Defining_Identifier);
2848 + Set_Subtype_Indication (N, Subtype_Indication);
2850 + end Make_Subtype_Declaration;
2852 + function Make_Subtype_Indication (Sloc : Source_Ptr;
2853 + Subtype_Mark : Node_Id;
2854 + Constraint : Node_Id)
2857 + N : constant Node_Id :=
2858 + New_Node (N_Subtype_Indication, Sloc);
2860 + Set_Subtype_Mark (N, Subtype_Mark);
2861 + Set_Constraint (N, Constraint);
2863 + end Make_Subtype_Indication;
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)
2873 + N : constant Node_Id :=
2874 + New_Node (N_Object_Declaration, Sloc);
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);
2882 + end Make_Object_Declaration;
2884 + function Make_Number_Declaration (Sloc : Source_Ptr;
2885 + Defining_Identifier : Node_Id;
2886 + Expression : Node_Id)
2889 + N : constant Node_Id :=
2890 + New_Node (N_Number_Declaration, Sloc);
2892 + Set_Defining_Identifier (N, Defining_Identifier);
2893 + Set_Expression (N, Expression);
2895 + end Make_Number_Declaration;
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)
2903 + N : constant Node_Id :=
2904 + New_Node (N_Derived_Type_Definition, Sloc);
2906 + Set_Abstract_Present (N, Abstract_Present);
2907 + Set_Subtype_Indication (N, Subtype_Indication);
2908 + Set_Record_Extension_Part (N, Record_Extension_Part);
2910 + end Make_Derived_Type_Definition;
2912 + function Make_Range_Constraint (Sloc : Source_Ptr;
2913 + Range_Expression : Node_Id)
2916 + N : constant Node_Id :=
2917 + New_Node (N_Range_Constraint, Sloc);
2919 + Set_Range_Expression (N, Range_Expression);
2921 + end Make_Range_Constraint;
2923 + function Make_Range (Sloc : Source_Ptr;
2924 + Low_Bound : Node_Id;
2925 + High_Bound : Node_Id;
2926 + Includes_Infinities : Boolean := False)
2929 + N : constant Node_Id :=
2930 + New_Node (N_Range, Sloc);
2932 + Set_Low_Bound (N, Low_Bound);
2933 + Set_High_Bound (N, High_Bound);
2934 + Set_Includes_Infinities (N, Includes_Infinities);
2938 + function Make_Enumeration_Type_Definition (Sloc : Source_Ptr;
2939 + Literals : List_Id;
2940 + End_Label : Node_Id := Empty)
2943 + N : constant Node_Id :=
2944 + New_Node (N_Enumeration_Type_Definition, Sloc);
2946 + Set_Literals (N, Literals);
2947 + Set_End_Label (N, End_Label);
2949 + end Make_Enumeration_Type_Definition;
2951 + function Make_Defining_Character_Literal (Sloc : Source_Ptr;
2955 + N : constant Node_Id :=
2956 + New_Entity (N_Defining_Character_Literal, Sloc);
2958 + Set_Chars (N, Chars);
2960 + end Make_Defining_Character_Literal;
2962 + function Make_Signed_Integer_Type_Definition (Sloc : Source_Ptr;
2963 + Low_Bound : Node_Id;
2964 + High_Bound : Node_Id)
2967 + N : constant Node_Id :=
2968 + New_Node (N_Signed_Integer_Type_Definition, Sloc);
2970 + Set_Low_Bound (N, Low_Bound);
2971 + Set_High_Bound (N, High_Bound);
2973 + end Make_Signed_Integer_Type_Definition;
2975 + function Make_Modular_Type_Definition (Sloc : Source_Ptr;
2976 + Expression : Node_Id)
2979 + N : constant Node_Id :=
2980 + New_Node (N_Modular_Type_Definition, Sloc);
2982 + Set_Expression (N, Expression);
2984 + end Make_Modular_Type_Definition;
2986 + function Make_Floating_Point_Definition (Sloc : Source_Ptr;
2987 + Digits_Expression : Node_Id;
2988 + Real_Range_Specification : Node_Id := Empty)
2991 + N : constant Node_Id :=
2992 + New_Node (N_Floating_Point_Definition, Sloc);
2994 + Set_Digits_Expression (N, Digits_Expression);
2995 + Set_Real_Range_Specification (N, Real_Range_Specification);
2997 + end Make_Floating_Point_Definition;
2999 + function Make_Real_Range_Specification (Sloc : Source_Ptr;
3000 + Low_Bound : Node_Id;
3001 + High_Bound : Node_Id)
3004 + N : constant Node_Id :=
3005 + New_Node (N_Real_Range_Specification, Sloc);
3007 + Set_Low_Bound (N, Low_Bound);
3008 + Set_High_Bound (N, High_Bound);
3010 + end Make_Real_Range_Specification;
3012 + function Make_Ordinary_Fixed_Point_Definition (Sloc : Source_Ptr;
3013 + Delta_Expression : Node_Id;
3014 + Real_Range_Specification : Node_Id)
3017 + N : constant Node_Id :=
3018 + New_Node (N_Ordinary_Fixed_Point_Definition, Sloc);
3020 + Set_Delta_Expression (N, Delta_Expression);
3021 + Set_Real_Range_Specification (N, Real_Range_Specification);
3023 + end Make_Ordinary_Fixed_Point_Definition;
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)
3031 + N : constant Node_Id :=
3032 + New_Node (N_Decimal_Fixed_Point_Definition, Sloc);
3034 + Set_Delta_Expression (N, Delta_Expression);
3035 + Set_Digits_Expression (N, Digits_Expression);
3036 + Set_Real_Range_Specification (N, Real_Range_Specification);
3038 + end Make_Decimal_Fixed_Point_Definition;
3040 + function Make_Digits_Constraint (Sloc : Source_Ptr;
3041 + Digits_Expression : Node_Id;
3042 + Range_Constraint : Node_Id := Empty)
3045 + N : constant Node_Id :=
3046 + New_Node (N_Digits_Constraint, Sloc);
3048 + Set_Digits_Expression (N, Digits_Expression);
3049 + Set_Range_Constraint (N, Range_Constraint);
3051 + end Make_Digits_Constraint;
3053 + function Make_Unconstrained_Array_Definition (Sloc : Source_Ptr;
3054 + Subtype_Marks : List_Id;
3055 + Component_Definition : Node_Id)
3058 + N : constant Node_Id :=
3059 + New_Node (N_Unconstrained_Array_Definition, Sloc);
3061 + Set_Subtype_Marks (N, Subtype_Marks);
3062 + Set_Component_Definition (N, Component_Definition);
3064 + end Make_Unconstrained_Array_Definition;
3066 + function Make_Constrained_Array_Definition (Sloc : Source_Ptr;
3067 + Discrete_Subtype_Definitions : List_Id;
3068 + Component_Definition : Node_Id)
3071 + N : constant Node_Id :=
3072 + New_Node (N_Constrained_Array_Definition, Sloc);
3074 + Set_Discrete_Subtype_Definitions
3075 + (N, Discrete_Subtype_Definitions);
3076 + Set_Component_Definition (N, Component_Definition);
3078 + end Make_Constrained_Array_Definition;
3080 + function Make_Component_Definition (Sloc : Source_Ptr;
3081 + Aliased_Present : Boolean := False;
3082 + Subtype_Indication : Node_Id)
3085 + N : constant Node_Id :=
3086 + New_Node (N_Component_Definition, Sloc);
3088 + Set_Aliased_Present (N, Aliased_Present);
3089 + Set_Subtype_Indication (N, Subtype_Indication);
3091 + end Make_Component_Definition;
3093 + function Make_Discriminant_Specification (Sloc : Source_Ptr;
3094 + Defining_Identifier : Node_Id;
3095 + Discriminant_Type : Node_Id;
3096 + Expression : Node_Id := Empty)
3099 + N : constant Node_Id :=
3100 + New_Node (N_Discriminant_Specification, Sloc);
3102 + Set_Defining_Identifier (N, Defining_Identifier);
3103 + Set_Discriminant_Type (N, Discriminant_Type);
3104 + Set_Expression (N, Expression);
3106 + end Make_Discriminant_Specification;
3108 + function Make_Index_Or_Discriminant_Constraint (Sloc : Source_Ptr;
3109 + Constraints : List_Id)
3112 + N : constant Node_Id :=
3113 + New_Node (N_Index_Or_Discriminant_Constraint, Sloc);
3115 + Set_Constraints (N, Constraints);
3117 + end Make_Index_Or_Discriminant_Constraint;
3119 + function Make_Discriminant_Association (Sloc : Source_Ptr;
3120 + Selector_Names : List_Id;
3121 + Expression : Node_Id)
3124 + N : constant Node_Id :=
3125 + New_Node (N_Discriminant_Association, Sloc);
3127 + Set_Selector_Names (N, Selector_Names);
3128 + Set_Expression (N, Expression);
3130 + end Make_Discriminant_Association;
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)
3141 + N : constant Node_Id :=
3142 + New_Node (N_Record_Definition, Sloc);
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);
3151 + end Make_Record_Definition;
3153 + function Make_Component_List (Sloc : Source_Ptr;
3154 + Component_Items : List_Id;
3155 + Variant_Part : Node_Id := Empty;
3156 + Null_Present : Boolean := False)
3159 + N : constant Node_Id :=
3160 + New_Node (N_Component_List, Sloc);
3162 + Set_Component_Items (N, Component_Items);
3163 + Set_Variant_Part (N, Variant_Part);
3164 + Set_Null_Present (N, Null_Present);
3166 + end Make_Component_List;
3168 + function Make_Component_Declaration (Sloc : Source_Ptr;
3169 + Defining_Identifier : Node_Id;
3170 + Component_Definition : Node_Id;
3171 + Expression : Node_Id := Empty)
3174 + N : constant Node_Id :=
3175 + New_Node (N_Component_Declaration, Sloc);
3177 + Set_Defining_Identifier (N, Defining_Identifier);
3178 + Set_Component_Definition (N, Component_Definition);
3179 + Set_Expression (N, Expression);
3181 + end Make_Component_Declaration;
3183 + function Make_Variant_Part (Sloc : Source_Ptr;
3185 + Variants : List_Id)
3188 + N : constant Node_Id :=
3189 + New_Node (N_Variant_Part, Sloc);
3191 + Set_Name (N, Name);
3192 + Set_Variants (N, Variants);
3194 + end Make_Variant_Part;
3196 + function Make_Variant (Sloc : Source_Ptr;
3197 + Discrete_Choices : List_Id;
3198 + Component_List : Node_Id)
3201 + N : constant Node_Id :=
3202 + New_Node (N_Variant, Sloc);
3204 + Set_Discrete_Choices (N, Discrete_Choices);
3205 + Set_Component_List (N, Component_List);
3209 + function Make_Others_Choice (Sloc : Source_Ptr)
3212 + N : constant Node_Id :=
3213 + New_Node (N_Others_Choice, Sloc);
3216 + end Make_Others_Choice;
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)
3224 + N : constant Node_Id :=
3225 + New_Node (N_Access_To_Object_Definition, Sloc);
3227 + Set_All_Present (N, All_Present);
3228 + Set_Subtype_Indication (N, Subtype_Indication);
3229 + Set_Constant_Present (N, Constant_Present);
3231 + end Make_Access_To_Object_Definition;
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)
3239 + N : constant Node_Id :=
3240 + New_Node (N_Access_Function_Definition, Sloc);
3242 + Set_Protected_Present (N, Protected_Present);
3243 + Set_Parameter_Specifications (N, Parameter_Specifications);
3244 + Set_Subtype_Mark (N, Subtype_Mark);
3246 + end Make_Access_Function_Definition;
3248 + function Make_Access_Procedure_Definition (Sloc : Source_Ptr;
3249 + Protected_Present : Boolean := False;
3250 + Parameter_Specifications : List_Id := No_List)
3253 + N : constant Node_Id :=
3254 + New_Node (N_Access_Procedure_Definition, Sloc);
3256 + Set_Protected_Present (N, Protected_Present);
3257 + Set_Parameter_Specifications (N, Parameter_Specifications);
3259 + end Make_Access_Procedure_Definition;
3261 + function Make_Access_Definition (Sloc : Source_Ptr;
3262 + Subtype_Mark : Node_Id)
3265 + N : constant Node_Id :=
3266 + New_Node (N_Access_Definition, Sloc);
3268 + Set_Subtype_Mark (N, Subtype_Mark);
3270 + end Make_Access_Definition;
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)
3278 + N : constant Node_Id :=
3279 + New_Node (N_Incomplete_Type_Declaration, Sloc);
3281 + Set_Defining_Identifier (N, Defining_Identifier);
3282 + Set_Discriminant_Specifications (N, Discriminant_Specifications);
3283 + Set_Unknown_Discriminants_Present
3284 + (N, Unknown_Discriminants_Present);
3286 + end Make_Incomplete_Type_Declaration;
3288 + function Make_Explicit_Dereference (Sloc : Source_Ptr;
3292 + N : constant Node_Id :=
3293 + New_Node (N_Explicit_Dereference, Sloc);
3295 + Set_Prefix (N, Prefix);
3297 + end Make_Explicit_Dereference;
3299 + function Make_Indexed_Component (Sloc : Source_Ptr;
3301 + Expressions : List_Id)
3304 + N : constant Node_Id :=
3305 + New_Node (N_Indexed_Component, Sloc);
3307 + Set_Prefix (N, Prefix);
3308 + Set_Expressions (N, Expressions);
3310 + end Make_Indexed_Component;
3312 + function Make_Slice (Sloc : Source_Ptr;
3314 + Discrete_Range : Node_Id)
3317 + N : constant Node_Id :=
3318 + New_Node (N_Slice, Sloc);
3320 + Set_Prefix (N, Prefix);
3321 + Set_Discrete_Range (N, Discrete_Range);
3325 + function Make_Selected_Component (Sloc : Source_Ptr;
3327 + Selector_Name : Node_Id)
3330 + N : constant Node_Id :=
3331 + New_Node (N_Selected_Component, Sloc);
3333 + Set_Prefix (N, Prefix);
3334 + Set_Selector_Name (N, Selector_Name);
3336 + end Make_Selected_Component;
3338 + function Make_Attribute_Reference (Sloc : Source_Ptr;
3340 + Attribute_Name : Name_Id;
3341 + Expressions : List_Id := No_List;
3342 + Must_Be_Byte_Aligned : Boolean := False)
3345 + N : constant Node_Id :=
3346 + New_Node (N_Attribute_Reference, Sloc);
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);
3353 + end Make_Attribute_Reference;
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)
3361 + N : constant Node_Id :=
3362 + New_Node (N_Aggregate, Sloc);
3364 + Set_Expressions (N, Expressions);
3365 + Set_Component_Associations (N, Component_Associations);
3366 + Set_Null_Record_Present (N, Null_Record_Present);
3368 + end Make_Aggregate;
3370 + function Make_Component_Association (Sloc : Source_Ptr;
3371 + Choices : List_Id;
3372 + Expression : Node_Id;
3373 + Box_Present : Boolean := False)
3376 + N : constant Node_Id :=
3377 + New_Node (N_Component_Association, Sloc);
3379 + Set_Choices (N, Choices);
3380 + Set_Expression (N, Expression);
3381 + Set_Box_Present (N, Box_Present);
3383 + end Make_Component_Association;
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)
3392 + N : constant Node_Id :=
3393 + New_Node (N_Extension_Aggregate, Sloc);
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);
3400 + end Make_Extension_Aggregate;
3402 + function Make_Null (Sloc : Source_Ptr)
3405 + N : constant Node_Id :=
3406 + New_Node (N_Null, Sloc);
3411 + function Make_And_Then (Sloc : Source_Ptr;
3412 + Left_Opnd : Node_Id;
3413 + Right_Opnd : Node_Id)
3416 + N : constant Node_Id :=
3417 + New_Node (N_And_Then, Sloc);
3419 + Set_Left_Opnd (N, Left_Opnd);
3420 + Set_Right_Opnd (N, Right_Opnd);
3422 + end Make_And_Then;
3424 + function Make_Or_Else (Sloc : Source_Ptr;
3425 + Left_Opnd : Node_Id;
3426 + Right_Opnd : Node_Id)
3429 + N : constant Node_Id :=
3430 + New_Node (N_Or_Else, Sloc);
3432 + Set_Left_Opnd (N, Left_Opnd);
3433 + Set_Right_Opnd (N, Right_Opnd);
3437 + function Make_In (Sloc : Source_Ptr;
3438 + Left_Opnd : Node_Id;
3439 + Right_Opnd : Node_Id)
3442 + N : constant Node_Id :=
3443 + New_Node (N_In, Sloc);
3445 + Set_Left_Opnd (N, Left_Opnd);
3446 + Set_Right_Opnd (N, Right_Opnd);
3450 + function Make_Not_In (Sloc : Source_Ptr;
3451 + Left_Opnd : Node_Id;
3452 + Right_Opnd : Node_Id)
3455 + N : constant Node_Id :=
3456 + New_Node (N_Not_In, Sloc);
3458 + Set_Left_Opnd (N, Left_Opnd);
3459 + Set_Right_Opnd (N, Right_Opnd);
3463 + function Make_Op_And (Sloc : Source_Ptr;
3464 + Left_Opnd : Node_Id;
3465 + Right_Opnd : Node_Id)
3468 + N : constant Node_Id :=
3469 + New_Node (N_Op_And, Sloc);
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);
3478 + function Make_Op_Or (Sloc : Source_Ptr;
3479 + Left_Opnd : Node_Id;
3480 + Right_Opnd : Node_Id)
3483 + N : constant Node_Id :=
3484 + New_Node (N_Op_Or, Sloc);
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);
3493 + function Make_Op_Xor (Sloc : Source_Ptr;
3494 + Left_Opnd : Node_Id;
3495 + Right_Opnd : Node_Id)
3498 + N : constant Node_Id :=
3499 + New_Node (N_Op_Xor, Sloc);
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);
3508 + function Make_Op_Eq (Sloc : Source_Ptr;
3509 + Left_Opnd : Node_Id;
3510 + Right_Opnd : Node_Id)
3513 + N : constant Node_Id :=
3514 + New_Node (N_Op_Eq, Sloc);
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);
3523 + function Make_Op_Ne (Sloc : Source_Ptr;
3524 + Left_Opnd : Node_Id;
3525 + Right_Opnd : Node_Id)
3528 + N : constant Node_Id :=
3529 + New_Node (N_Op_Ne, Sloc);
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);
3538 + function Make_Op_Lt (Sloc : Source_Ptr;
3539 + Left_Opnd : Node_Id;
3540 + Right_Opnd : Node_Id)
3543 + N : constant Node_Id :=
3544 + New_Node (N_Op_Lt, Sloc);
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);
3553 + function Make_Op_Le (Sloc : Source_Ptr;
3554 + Left_Opnd : Node_Id;
3555 + Right_Opnd : Node_Id)
3558 + N : constant Node_Id :=
3559 + New_Node (N_Op_Le, Sloc);
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);
3568 + function Make_Op_Gt (Sloc : Source_Ptr;
3569 + Left_Opnd : Node_Id;
3570 + Right_Opnd : Node_Id)
3573 + N : constant Node_Id :=
3574 + New_Node (N_Op_Gt, Sloc);
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);
3583 + function Make_Op_Ge (Sloc : Source_Ptr;
3584 + Left_Opnd : Node_Id;
3585 + Right_Opnd : Node_Id)
3588 + N : constant Node_Id :=
3589 + New_Node (N_Op_Ge, Sloc);
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);
3598 + function Make_Op_Add (Sloc : Source_Ptr;
3599 + Left_Opnd : Node_Id;
3600 + Right_Opnd : Node_Id)
3603 + N : constant Node_Id :=
3604 + New_Node (N_Op_Add, Sloc);
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);
3613 + function Make_Op_Subtract (Sloc : Source_Ptr;
3614 + Left_Opnd : Node_Id;
3615 + Right_Opnd : Node_Id)
3618 + N : constant Node_Id :=
3619 + New_Node (N_Op_Subtract, Sloc);
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);
3626 + end Make_Op_Subtract;
3628 + function Make_Op_Concat (Sloc : Source_Ptr;
3629 + Left_Opnd : Node_Id;
3630 + Right_Opnd : Node_Id)
3633 + N : constant Node_Id :=
3634 + New_Node (N_Op_Concat, Sloc);
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);
3641 + end Make_Op_Concat;
3643 + function Make_Op_Multiply (Sloc : Source_Ptr;
3644 + Left_Opnd : Node_Id;
3645 + Right_Opnd : Node_Id)
3648 + N : constant Node_Id :=
3649 + New_Node (N_Op_Multiply, Sloc);
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);
3656 + end Make_Op_Multiply;
3658 + function Make_Op_Divide (Sloc : Source_Ptr;
3659 + Left_Opnd : Node_Id;
3660 + Right_Opnd : Node_Id)
3663 + N : constant Node_Id :=
3664 + New_Node (N_Op_Divide, Sloc);
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);
3671 + end Make_Op_Divide;
3673 + function Make_Op_Mod (Sloc : Source_Ptr;
3674 + Left_Opnd : Node_Id;
3675 + Right_Opnd : Node_Id)
3678 + N : constant Node_Id :=
3679 + New_Node (N_Op_Mod, Sloc);
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);
3688 + function Make_Op_Rem (Sloc : Source_Ptr;
3689 + Left_Opnd : Node_Id;
3690 + Right_Opnd : Node_Id)
3693 + N : constant Node_Id :=
3694 + New_Node (N_Op_Rem, Sloc);
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);
3703 + function Make_Op_Expon (Sloc : Source_Ptr;
3704 + Left_Opnd : Node_Id;
3705 + Right_Opnd : Node_Id)
3708 + N : constant Node_Id :=
3709 + New_Node (N_Op_Expon, Sloc);
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);
3716 + end Make_Op_Expon;
3718 + function Make_Op_Plus (Sloc : Source_Ptr;
3719 + Right_Opnd : Node_Id)
3722 + N : constant Node_Id :=
3723 + New_Node (N_Op_Plus, Sloc);
3725 + Set_Right_Opnd (N, Right_Opnd);
3726 + Set_Chars (N, Name_Op_Add);
3727 + Set_Entity (N, Standard_Op_Plus);
3731 + function Make_Op_Minus (Sloc : Source_Ptr;
3732 + Right_Opnd : Node_Id)
3735 + N : constant Node_Id :=
3736 + New_Node (N_Op_Minus, Sloc);
3738 + Set_Right_Opnd (N, Right_Opnd);
3739 + Set_Chars (N, Name_Op_Subtract);
3740 + Set_Entity (N, Standard_Op_Minus);
3742 + end Make_Op_Minus;
3744 + function Make_Op_Abs (Sloc : Source_Ptr;
3745 + Right_Opnd : Node_Id)
3748 + N : constant Node_Id :=
3749 + New_Node (N_Op_Abs, Sloc);
3751 + Set_Right_Opnd (N, Right_Opnd);
3752 + Set_Chars (N, Name_Op_Abs);
3753 + Set_Entity (N, Standard_Op_Abs);
3757 + function Make_Op_Not (Sloc : Source_Ptr;
3758 + Right_Opnd : Node_Id)
3761 + N : constant Node_Id :=
3762 + New_Node (N_Op_Not, Sloc);
3764 + Set_Right_Opnd (N, Right_Opnd);
3765 + Set_Chars (N, Name_Op_Not);
3766 + Set_Entity (N, Standard_Op_Not);
3770 + function Make_Type_Conversion (Sloc : Source_Ptr;
3771 + Subtype_Mark : Node_Id;
3772 + Expression : Node_Id)
3775 + N : constant Node_Id :=
3776 + New_Node (N_Type_Conversion, Sloc);
3778 + Set_Subtype_Mark (N, Subtype_Mark);
3779 + Set_Expression (N, Expression);
3781 + end Make_Type_Conversion;
3783 + function Make_Qualified_Expression (Sloc : Source_Ptr;
3784 + Subtype_Mark : Node_Id;
3785 + Expression : Node_Id)
3788 + N : constant Node_Id :=
3789 + New_Node (N_Qualified_Expression, Sloc);
3791 + Set_Subtype_Mark (N, Subtype_Mark);
3792 + Set_Expression (N, Expression);
3794 + end Make_Qualified_Expression;
3796 + function Make_Allocator (Sloc : Source_Ptr;
3797 + Expression : Node_Id)
3800 + N : constant Node_Id :=
3801 + New_Node (N_Allocator, Sloc);
3803 + Set_Expression (N, Expression);
3805 + end Make_Allocator;
3807 + function Make_Null_Statement (Sloc : Source_Ptr)
3810 + N : constant Node_Id :=
3811 + New_Node (N_Null_Statement, Sloc);
3814 + end Make_Null_Statement;
3816 + function Make_Label (Sloc : Source_Ptr;
3817 + Identifier : Node_Id)
3820 + N : constant Node_Id :=
3821 + New_Node (N_Label, Sloc);
3823 + Set_Identifier (N, Identifier);
3827 + function Make_Assignment_Statement (Sloc : Source_Ptr;
3829 + Expression : Node_Id)
3832 + N : constant Node_Id :=
3833 + New_Node (N_Assignment_Statement, Sloc);
3835 + Set_Name (N, Name);
3836 + Set_Expression (N, Expression);
3838 + end Make_Assignment_Statement;
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)
3848 + N : constant Node_Id :=
3849 + New_Node (N_If_Statement, Sloc);
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);
3857 + end Make_If_Statement;
3859 + function Make_Elsif_Part (Sloc : Source_Ptr;
3860 + Condition : Node_Id;
3861 + Then_Statements : List_Id)
3864 + N : constant Node_Id :=
3865 + New_Node (N_Elsif_Part, Sloc);
3867 + Set_Condition (N, Condition);
3868 + Set_Then_Statements (N, Then_Statements);
3870 + end Make_Elsif_Part;
3872 + function Make_Case_Statement (Sloc : Source_Ptr;
3873 + Expression : Node_Id;
3874 + Alternatives : List_Id;
3875 + End_Span : Uint := No_Uint)
3878 + N : constant Node_Id :=
3879 + New_Node (N_Case_Statement, Sloc);
3881 + Set_Expression (N, Expression);
3882 + Set_Alternatives (N, Alternatives);
3883 + Set_End_Span (N, End_Span);
3885 + end Make_Case_Statement;
3887 + function Make_Case_Statement_Alternative (Sloc : Source_Ptr;
3888 + Discrete_Choices : List_Id;
3889 + Statements : List_Id)
3892 + N : constant Node_Id :=
3893 + New_Node (N_Case_Statement_Alternative, Sloc);
3895 + Set_Discrete_Choices (N, Discrete_Choices);
3896 + Set_Statements (N, Statements);
3898 + end Make_Case_Statement_Alternative;
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)
3909 + N : constant Node_Id :=
3910 + New_Node (N_Loop_Statement, Sloc);
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);
3919 + end Make_Loop_Statement;
3921 + function Make_Iteration_Scheme (Sloc : Source_Ptr;
3922 + Condition : Node_Id := Empty;
3923 + Loop_Parameter_Specification : Node_Id := Empty)
3926 + N : constant Node_Id :=
3927 + New_Node (N_Iteration_Scheme, Sloc);
3929 + Set_Condition (N, Condition);
3930 + Set_Loop_Parameter_Specification
3931 + (N, Loop_Parameter_Specification);
3933 + end Make_Iteration_Scheme;
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)
3941 + N : constant Node_Id :=
3942 + New_Node (N_Loop_Parameter_Specification, Sloc);
3944 + Set_Defining_Identifier (N, Defining_Identifier);
3945 + Set_Reverse_Present (N, Reverse_Present);
3946 + Set_Discrete_Subtype_Definition (N, Discrete_Subtype_Definition);
3948 + end Make_Loop_Parameter_Specification;
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)
3959 + N : constant Node_Id :=
3960 + New_Node (N_Block_Statement, Sloc);
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);
3969 + end Make_Block_Statement;
3971 + function Make_Exit_Statement (Sloc : Source_Ptr;
3972 + Name : Node_Id := Empty;
3973 + Condition : Node_Id := Empty)
3976 + N : constant Node_Id :=
3977 + New_Node (N_Exit_Statement, Sloc);
3979 + Set_Name (N, Name);
3980 + Set_Condition (N, Condition);
3982 + end Make_Exit_Statement;
3984 + function Make_Goto_Statement (Sloc : Source_Ptr;
3988 + N : constant Node_Id :=
3989 + New_Node (N_Goto_Statement, Sloc);
3991 + Set_Name (N, Name);
3993 + end Make_Goto_Statement;
3995 + function Make_Subprogram_Declaration (Sloc : Source_Ptr;
3996 + Specification : Node_Id)
3999 + N : constant Node_Id :=
4000 + New_Node (N_Subprogram_Declaration, Sloc);
4002 + Set_Specification (N, Specification);
4004 + end Make_Subprogram_Declaration;
4006 + function Make_Abstract_Subprogram_Declaration (Sloc : Source_Ptr;
4007 + Specification : Node_Id)
4010 + N : constant Node_Id :=
4011 + New_Node (N_Abstract_Subprogram_Declaration, Sloc);
4013 + Set_Specification (N, Specification);
4015 + end Make_Abstract_Subprogram_Declaration;
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)
4023 + N : constant Node_Id :=
4024 + New_Node (N_Function_Specification, Sloc);
4026 + Set_Defining_Unit_Name (N, Defining_Unit_Name);
4027 + Set_Parameter_Specifications (N, Parameter_Specifications);
4028 + Set_Subtype_Mark (N, Subtype_Mark);
4030 + end Make_Function_Specification;
4032 + function Make_Procedure_Specification (Sloc : Source_Ptr;
4033 + Defining_Unit_Name : Node_Id;
4034 + Parameter_Specifications : List_Id := No_List)
4037 + N : constant Node_Id :=
4038 + New_Node (N_Procedure_Specification, Sloc);
4040 + Set_Defining_Unit_Name (N, Defining_Unit_Name);
4041 + Set_Parameter_Specifications (N, Parameter_Specifications);
4043 + end Make_Procedure_Specification;
4045 + function Make_Designator (Sloc : Source_Ptr;
4047 + Identifier : Node_Id)
4050 + N : constant Node_Id :=
4051 + New_Node (N_Designator, Sloc);
4053 + Set_Name (N, Name);
4054 + Set_Identifier (N, Identifier);
4056 + end Make_Designator;
4058 + function Make_Defining_Program_Unit_Name (Sloc : Source_Ptr;
4060 + Defining_Identifier : Node_Id)
4063 + N : constant Node_Id :=
4064 + New_Node (N_Defining_Program_Unit_Name, Sloc);
4066 + Set_Name (N, Name);
4067 + Set_Defining_Identifier (N, Defining_Identifier);
4069 + end Make_Defining_Program_Unit_Name;
4071 + function Make_Operator_Symbol (Sloc : Source_Ptr;
4073 + Strval : String_Id)
4076 + N : constant Node_Id :=
4077 + New_Node (N_Operator_Symbol, Sloc);
4079 + Set_Chars (N, Chars);
4080 + Set_Strval (N, Strval);
4082 + end Make_Operator_Symbol;
4084 + function Make_Defining_Operator_Symbol (Sloc : Source_Ptr;
4088 + N : constant Node_Id :=
4089 + New_Entity (N_Defining_Operator_Symbol, Sloc);
4091 + Set_Chars (N, Chars);
4093 + end Make_Defining_Operator_Symbol;
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)
4103 + N : constant Node_Id :=
4104 + New_Node (N_Parameter_Specification, Sloc);
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);
4112 + end Make_Parameter_Specification;
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)
4121 + N : constant Node_Id :=
4122 + New_Node (N_Subprogram_Body, Sloc);
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);
4129 + end Make_Subprogram_Body;
4131 + function Make_Procedure_Call_Statement (Sloc : Source_Ptr;
4133 + Parameter_Associations : List_Id := No_List)
4136 + N : constant Node_Id :=
4137 + New_Node (N_Procedure_Call_Statement, Sloc);
4139 + Set_Name (N, Name);
4140 + Set_Parameter_Associations (N, Parameter_Associations);
4142 + end Make_Procedure_Call_Statement;
4144 + function Make_Function_Call (Sloc : Source_Ptr;
4146 + Parameter_Associations : List_Id := No_List)
4149 + N : constant Node_Id :=
4150 + New_Node (N_Function_Call, Sloc);
4152 + Set_Name (N, Name);
4153 + Set_Parameter_Associations (N, Parameter_Associations);
4155 + end Make_Function_Call;
4157 + function Make_Parameter_Association (Sloc : Source_Ptr;
4158 + Selector_Name : Node_Id;
4159 + Explicit_Actual_Parameter : Node_Id)
4162 + N : constant Node_Id :=
4163 + New_Node (N_Parameter_Association, Sloc);
4165 + Set_Selector_Name (N, Selector_Name);
4166 + Set_Explicit_Actual_Parameter (N, Explicit_Actual_Parameter);
4168 + end Make_Parameter_Association;
4170 + function Make_Return_Statement (Sloc : Source_Ptr;
4171 + Expression : Node_Id := Empty)
4174 + N : constant Node_Id :=
4175 + New_Node (N_Return_Statement, Sloc);
4177 + Set_Expression (N, Expression);
4179 + end Make_Return_Statement;
4181 + function Make_Package_Declaration (Sloc : Source_Ptr;
4182 + Specification : Node_Id)
4185 + N : constant Node_Id :=
4186 + New_Node (N_Package_Declaration, Sloc);
4188 + Set_Specification (N, Specification);
4190 + end Make_Package_Declaration;
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)
4199 + N : constant Node_Id :=
4200 + New_Node (N_Package_Specification, Sloc);
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);
4207 + end Make_Package_Specification;
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)
4215 + N : constant Node_Id :=
4216 + New_Node (N_Package_Body, Sloc);
4218 + Set_Defining_Unit_Name (N, Defining_Unit_Name);
4219 + Set_Declarations (N, Declarations);
4220 + Set_Handled_Statement_Sequence (N, Handled_Statement_Sequence);
4222 + end Make_Package_Body;
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)
4233 + N : constant Node_Id :=
4234 + New_Node (N_Private_Type_Declaration, Sloc);
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);
4244 + end Make_Private_Type_Declaration;
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)
4254 + N : constant Node_Id :=
4255 + New_Node (N_Private_Extension_Declaration, Sloc);
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);
4264 + end Make_Private_Extension_Declaration;
4266 + function Make_Use_Package_Clause (Sloc : Source_Ptr;
4270 + N : constant Node_Id :=
4271 + New_Node (N_Use_Package_Clause, Sloc);
4273 + Set_Names (N, Names);
4275 + end Make_Use_Package_Clause;
4277 + function Make_Use_Type_Clause (Sloc : Source_Ptr;
4278 + Subtype_Marks : List_Id)
4281 + N : constant Node_Id :=
4282 + New_Node (N_Use_Type_Clause, Sloc);
4284 + Set_Subtype_Marks (N, Subtype_Marks);
4286 + end Make_Use_Type_Clause;
4288 + function Make_Object_Renaming_Declaration (Sloc : Source_Ptr;
4289 + Defining_Identifier : Node_Id;
4290 + Subtype_Mark : Node_Id;
4294 + N : constant Node_Id :=
4295 + New_Node (N_Object_Renaming_Declaration, Sloc);
4297 + Set_Defining_Identifier (N, Defining_Identifier);
4298 + Set_Subtype_Mark (N, Subtype_Mark);
4299 + Set_Name (N, Name);
4301 + end Make_Object_Renaming_Declaration;
4303 + function Make_Exception_Renaming_Declaration (Sloc : Source_Ptr;
4304 + Defining_Identifier : Node_Id;
4308 + N : constant Node_Id :=
4309 + New_Node (N_Exception_Renaming_Declaration, Sloc);
4311 + Set_Defining_Identifier (N, Defining_Identifier);
4312 + Set_Name (N, Name);
4314 + end Make_Exception_Renaming_Declaration;
4316 + function Make_Package_Renaming_Declaration (Sloc : Source_Ptr;
4317 + Defining_Unit_Name : Node_Id;
4321 + N : constant Node_Id :=
4322 + New_Node (N_Package_Renaming_Declaration, Sloc);
4324 + Set_Defining_Unit_Name (N, Defining_Unit_Name);
4325 + Set_Name (N, Name);
4327 + end Make_Package_Renaming_Declaration;
4329 + function Make_Subprogram_Renaming_Declaration (Sloc : Source_Ptr;
4330 + Specification : Node_Id;
4334 + N : constant Node_Id :=
4335 + New_Node (N_Subprogram_Renaming_Declaration, Sloc);
4337 + Set_Specification (N, Specification);
4338 + Set_Name (N, Name);
4340 + end Make_Subprogram_Renaming_Declaration;
4342 + function Make_Generic_Package_Renaming_Declaration (Sloc : Source_Ptr;
4343 + Defining_Unit_Name : Node_Id;
4347 + N : constant Node_Id :=
4348 + New_Node (N_Generic_Package_Renaming_Declaration, Sloc);
4350 + Set_Defining_Unit_Name (N, Defining_Unit_Name);
4351 + Set_Name (N, Name);
4353 + end Make_Generic_Package_Renaming_Declaration;
4355 + function Make_Generic_Procedure_Renaming_Declaration (Sloc : Source_Ptr;
4356 + Defining_Unit_Name : Node_Id;
4360 + N : constant Node_Id :=
4361 + New_Node (N_Generic_Procedure_Renaming_Declaration, Sloc);
4363 + Set_Defining_Unit_Name (N, Defining_Unit_Name);
4364 + Set_Name (N, Name);
4366 + end Make_Generic_Procedure_Renaming_Declaration;
4368 + function Make_Generic_Function_Renaming_Declaration (Sloc : Source_Ptr;
4369 + Defining_Unit_Name : Node_Id;
4373 + N : constant Node_Id :=
4374 + New_Node (N_Generic_Function_Renaming_Declaration, Sloc);
4376 + Set_Defining_Unit_Name (N, Defining_Unit_Name);
4377 + Set_Name (N, Name);
4379 + end Make_Generic_Function_Renaming_Declaration;
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)
4387 + N : constant Node_Id :=
4388 + New_Node (N_Task_Type_Declaration, Sloc);
4390 + Set_Defining_Identifier (N, Defining_Identifier);
4391 + Set_Discriminant_Specifications (N, Discriminant_Specifications);
4392 + Set_Task_Definition (N, Task_Definition);
4394 + end Make_Task_Type_Declaration;
4396 + function Make_Single_Task_Declaration (Sloc : Source_Ptr;
4397 + Defining_Identifier : Node_Id;
4398 + Task_Definition : Node_Id := Empty)
4401 + N : constant Node_Id :=
4402 + New_Node (N_Single_Task_Declaration, Sloc);
4404 + Set_Defining_Identifier (N, Defining_Identifier);
4405 + Set_Task_Definition (N, Task_Definition);
4407 + end Make_Single_Task_Declaration;
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)
4415 + N : constant Node_Id :=
4416 + New_Node (N_Task_Definition, Sloc);
4418 + Set_Visible_Declarations (N, Visible_Declarations);
4419 + Set_Private_Declarations (N, Private_Declarations);
4420 + Set_End_Label (N, End_Label);
4422 + end Make_Task_Definition;
4424 + function Make_Task_Body (Sloc : Source_Ptr;
4425 + Defining_Identifier : Node_Id;
4426 + Declarations : List_Id;
4427 + Handled_Statement_Sequence : Node_Id)
4430 + N : constant Node_Id :=
4431 + New_Node (N_Task_Body, Sloc);
4433 + Set_Defining_Identifier (N, Defining_Identifier);
4434 + Set_Declarations (N, Declarations);
4435 + Set_Handled_Statement_Sequence (N, Handled_Statement_Sequence);
4437 + end Make_Task_Body;
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)
4445 + N : constant Node_Id :=
4446 + New_Node (N_Protected_Type_Declaration, Sloc);
4448 + Set_Defining_Identifier (N, Defining_Identifier);
4449 + Set_Discriminant_Specifications (N, Discriminant_Specifications);
4450 + Set_Protected_Definition (N, Protected_Definition);
4452 + end Make_Protected_Type_Declaration;
4454 + function Make_Single_Protected_Declaration (Sloc : Source_Ptr;
4455 + Defining_Identifier : Node_Id;
4456 + Protected_Definition : Node_Id)
4459 + N : constant Node_Id :=
4460 + New_Node (N_Single_Protected_Declaration, Sloc);
4462 + Set_Defining_Identifier (N, Defining_Identifier);
4463 + Set_Protected_Definition (N, Protected_Definition);
4465 + end Make_Single_Protected_Declaration;
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)
4473 + N : constant Node_Id :=
4474 + New_Node (N_Protected_Definition, Sloc);
4476 + Set_Visible_Declarations (N, Visible_Declarations);
4477 + Set_Private_Declarations (N, Private_Declarations);
4478 + Set_End_Label (N, End_Label);
4480 + end Make_Protected_Definition;
4482 + function Make_Protected_Body (Sloc : Source_Ptr;
4483 + Defining_Identifier : Node_Id;
4484 + Declarations : List_Id;
4485 + End_Label : Node_Id)
4488 + N : constant Node_Id :=
4489 + New_Node (N_Protected_Body, Sloc);
4491 + Set_Defining_Identifier (N, Defining_Identifier);
4492 + Set_Declarations (N, Declarations);
4493 + Set_End_Label (N, End_Label);
4495 + end Make_Protected_Body;
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)
4503 + N : constant Node_Id :=
4504 + New_Node (N_Entry_Declaration, Sloc);
4506 + Set_Defining_Identifier (N, Defining_Identifier);
4507 + Set_Discrete_Subtype_Definition (N, Discrete_Subtype_Definition);
4508 + Set_Parameter_Specifications (N, Parameter_Specifications);
4510 + end Make_Entry_Declaration;
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)
4520 + N : constant Node_Id :=
4521 + New_Node (N_Accept_Statement, Sloc);
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);
4529 + end Make_Accept_Statement;
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)
4538 + N : constant Node_Id :=
4539 + New_Node (N_Entry_Body, Sloc);
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);
4546 + end Make_Entry_Body;
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)
4554 + N : constant Node_Id :=
4555 + New_Node (N_Entry_Body_Formal_Part, Sloc);
4557 + Set_Entry_Index_Specification (N, Entry_Index_Specification);
4558 + Set_Parameter_Specifications (N, Parameter_Specifications);
4559 + Set_Condition (N, Condition);
4561 + end Make_Entry_Body_Formal_Part;
4563 + function Make_Entry_Index_Specification (Sloc : Source_Ptr;
4564 + Defining_Identifier : Node_Id;
4565 + Discrete_Subtype_Definition : Node_Id)
4568 + N : constant Node_Id :=
4569 + New_Node (N_Entry_Index_Specification, Sloc);
4571 + Set_Defining_Identifier (N, Defining_Identifier);
4572 + Set_Discrete_Subtype_Definition (N, Discrete_Subtype_Definition);
4574 + end Make_Entry_Index_Specification;
4576 + function Make_Entry_Call_Statement (Sloc : Source_Ptr;
4578 + Parameter_Associations : List_Id := No_List)
4581 + N : constant Node_Id :=
4582 + New_Node (N_Entry_Call_Statement, Sloc);
4584 + Set_Name (N, Name);
4585 + Set_Parameter_Associations (N, Parameter_Associations);
4587 + end Make_Entry_Call_Statement;
4589 + function Make_Requeue_Statement (Sloc : Source_Ptr;
4591 + Abort_Present : Boolean := False)
4594 + N : constant Node_Id :=
4595 + New_Node (N_Requeue_Statement, Sloc);
4597 + Set_Name (N, Name);
4598 + Set_Abort_Present (N, Abort_Present);
4600 + end Make_Requeue_Statement;
4602 + function Make_Delay_Until_Statement (Sloc : Source_Ptr;
4603 + Expression : Node_Id)
4606 + N : constant Node_Id :=
4607 + New_Node (N_Delay_Until_Statement, Sloc);
4609 + Set_Expression (N, Expression);
4611 + end Make_Delay_Until_Statement;
4613 + function Make_Delay_Relative_Statement (Sloc : Source_Ptr;
4614 + Expression : Node_Id)
4617 + N : constant Node_Id :=
4618 + New_Node (N_Delay_Relative_Statement, Sloc);
4620 + Set_Expression (N, Expression);
4622 + end Make_Delay_Relative_Statement;
4624 + function Make_Selective_Accept (Sloc : Source_Ptr;
4625 + Select_Alternatives : List_Id;
4626 + Else_Statements : List_Id := No_List)
4629 + N : constant Node_Id :=
4630 + New_Node (N_Selective_Accept, Sloc);
4632 + Set_Select_Alternatives (N, Select_Alternatives);
4633 + Set_Else_Statements (N, Else_Statements);
4635 + end Make_Selective_Accept;
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)
4644 + N : constant Node_Id :=
4645 + New_Node (N_Accept_Alternative, Sloc);
4647 + Set_Accept_Statement (N, Accept_Statement);
4648 + Set_Condition (N, Condition);
4649 + Set_Statements (N, Statements);
4650 + Set_Pragmas_Before (N, Pragmas_Before);
4652 + end Make_Accept_Alternative;
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)
4661 + N : constant Node_Id :=
4662 + New_Node (N_Delay_Alternative, Sloc);
4664 + Set_Delay_Statement (N, Delay_Statement);
4665 + Set_Condition (N, Condition);
4666 + Set_Statements (N, Statements);
4667 + Set_Pragmas_Before (N, Pragmas_Before);
4669 + end Make_Delay_Alternative;
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)
4677 + N : constant Node_Id :=
4678 + New_Node (N_Terminate_Alternative, Sloc);
4680 + Set_Condition (N, Condition);
4681 + Set_Pragmas_Before (N, Pragmas_Before);
4682 + Set_Pragmas_After (N, Pragmas_After);
4684 + end Make_Terminate_Alternative;
4686 + function Make_Timed_Entry_Call (Sloc : Source_Ptr;
4687 + Entry_Call_Alternative : Node_Id;
4688 + Delay_Alternative : Node_Id)
4691 + N : constant Node_Id :=
4692 + New_Node (N_Timed_Entry_Call, Sloc);
4694 + Set_Entry_Call_Alternative (N, Entry_Call_Alternative);
4695 + Set_Delay_Alternative (N, Delay_Alternative);
4697 + end Make_Timed_Entry_Call;
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)
4705 + N : constant Node_Id :=
4706 + New_Node (N_Entry_Call_Alternative, Sloc);
4708 + Set_Entry_Call_Statement (N, Entry_Call_Statement);
4709 + Set_Statements (N, Statements);
4710 + Set_Pragmas_Before (N, Pragmas_Before);
4712 + end Make_Entry_Call_Alternative;
4714 + function Make_Conditional_Entry_Call (Sloc : Source_Ptr;
4715 + Entry_Call_Alternative : Node_Id;
4716 + Else_Statements : List_Id)
4719 + N : constant Node_Id :=
4720 + New_Node (N_Conditional_Entry_Call, Sloc);
4722 + Set_Entry_Call_Alternative (N, Entry_Call_Alternative);
4723 + Set_Else_Statements (N, Else_Statements);
4725 + end Make_Conditional_Entry_Call;
4727 + function Make_Asynchronous_Select (Sloc : Source_Ptr;
4728 + Triggering_Alternative : Node_Id;
4729 + Abortable_Part : Node_Id)
4732 + N : constant Node_Id :=
4733 + New_Node (N_Asynchronous_Select, Sloc);
4735 + Set_Triggering_Alternative (N, Triggering_Alternative);
4736 + Set_Abortable_Part (N, Abortable_Part);
4738 + end Make_Asynchronous_Select;
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)
4746 + N : constant Node_Id :=
4747 + New_Node (N_Triggering_Alternative, Sloc);
4749 + Set_Triggering_Statement (N, Triggering_Statement);
4750 + Set_Statements (N, Statements);
4751 + Set_Pragmas_Before (N, Pragmas_Before);
4753 + end Make_Triggering_Alternative;
4755 + function Make_Abortable_Part (Sloc : Source_Ptr;
4756 + Statements : List_Id)
4759 + N : constant Node_Id :=
4760 + New_Node (N_Abortable_Part, Sloc);
4762 + Set_Statements (N, Statements);
4764 + end Make_Abortable_Part;
4766 + function Make_Abort_Statement (Sloc : Source_Ptr;
4770 + N : constant Node_Id :=
4771 + New_Node (N_Abort_Statement, Sloc);
4773 + Set_Names (N, Names);
4775 + end Make_Abort_Statement;
4777 + function Make_Compilation_Unit (Sloc : Source_Ptr;
4778 + Context_Items : List_Id;
4779 + Private_Present : Boolean := False;
4781 + Aux_Decls_Node : Node_Id)
4784 + N : constant Node_Id :=
4785 + New_Node (N_Compilation_Unit, Sloc);
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);
4792 + end Make_Compilation_Unit;
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)
4801 + N : constant Node_Id :=
4802 + New_Node (N_Compilation_Unit_Aux, Sloc);
4804 + Set_Declarations (N, Declarations);
4805 + Set_Actions (N, Actions);
4806 + Set_Pragmas_After (N, Pragmas_After);
4807 + Set_Config_Pragmas (N, Config_Pragmas);
4809 + end Make_Compilation_Unit_Aux;
4811 + function Make_With_Clause (Sloc : Source_Ptr;
4813 + First_Name : Boolean := True;
4814 + Last_Name : Boolean := True;
4815 + Limited_Present : Boolean := False)
4818 + N : constant Node_Id :=
4819 + New_Node (N_With_Clause, Sloc);
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);
4826 + end Make_With_Clause;
4828 + function Make_With_Type_Clause (Sloc : Source_Ptr;
4830 + Tagged_Present : Boolean := False)
4833 + N : constant Node_Id :=
4834 + New_Node (N_With_Type_Clause, Sloc);
4836 + Set_Name (N, Name);
4837 + Set_Tagged_Present (N, Tagged_Present);
4839 + end Make_With_Type_Clause;
4841 + function Make_Subprogram_Body_Stub (Sloc : Source_Ptr;
4842 + Specification : Node_Id)
4845 + N : constant Node_Id :=
4846 + New_Node (N_Subprogram_Body_Stub, Sloc);
4848 + Set_Specification (N, Specification);
4850 + end Make_Subprogram_Body_Stub;
4852 + function Make_Package_Body_Stub (Sloc : Source_Ptr;
4853 + Defining_Identifier : Node_Id)
4856 + N : constant Node_Id :=
4857 + New_Node (N_Package_Body_Stub, Sloc);
4859 + Set_Defining_Identifier (N, Defining_Identifier);
4861 + end Make_Package_Body_Stub;
4863 + function Make_Task_Body_Stub (Sloc : Source_Ptr;
4864 + Defining_Identifier : Node_Id)
4867 + N : constant Node_Id :=
4868 + New_Node (N_Task_Body_Stub, Sloc);
4870 + Set_Defining_Identifier (N, Defining_Identifier);
4872 + end Make_Task_Body_Stub;
4874 + function Make_Protected_Body_Stub (Sloc : Source_Ptr;
4875 + Defining_Identifier : Node_Id)
4878 + N : constant Node_Id :=
4879 + New_Node (N_Protected_Body_Stub, Sloc);
4881 + Set_Defining_Identifier (N, Defining_Identifier);
4883 + end Make_Protected_Body_Stub;
4885 + function Make_Subunit (Sloc : Source_Ptr;
4887 + Proper_Body : Node_Id)
4890 + N : constant Node_Id :=
4891 + New_Node (N_Subunit, Sloc);
4893 + Set_Name (N, Name);
4894 + Set_Proper_Body (N, Proper_Body);
4898 + function Make_Exception_Declaration (Sloc : Source_Ptr;
4899 + Defining_Identifier : Node_Id)
4902 + N : constant Node_Id :=
4903 + New_Node (N_Exception_Declaration, Sloc);
4905 + Set_Defining_Identifier (N, Defining_Identifier);
4907 + end Make_Exception_Declaration;
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)
4916 + N : constant Node_Id :=
4917 + New_Node (N_Handled_Sequence_Of_Statements, Sloc);
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);
4924 + end Make_Handled_Sequence_Of_Statements;
4926 + function Make_Exception_Handler (Sloc : Source_Ptr;
4927 + Choice_Parameter : Node_Id := Empty;
4928 + Exception_Choices : List_Id;
4929 + Statements : List_Id)
4932 + N : constant Node_Id :=
4933 + New_Node (N_Exception_Handler, Sloc);
4935 + Set_Choice_Parameter (N, Choice_Parameter);
4936 + Set_Exception_Choices (N, Exception_Choices);
4937 + Set_Statements (N, Statements);
4939 + end Make_Exception_Handler;
4941 + function Make_Raise_Statement (Sloc : Source_Ptr;
4942 + Name : Node_Id := Empty)
4945 + N : constant Node_Id :=
4946 + New_Node (N_Raise_Statement, Sloc);
4948 + Set_Name (N, Name);
4950 + end Make_Raise_Statement;
4952 + function Make_Generic_Subprogram_Declaration (Sloc : Source_Ptr;
4953 + Specification : Node_Id;
4954 + Generic_Formal_Declarations : List_Id)
4957 + N : constant Node_Id :=
4958 + New_Node (N_Generic_Subprogram_Declaration, Sloc);
4960 + Set_Specification (N, Specification);
4961 + Set_Generic_Formal_Declarations (N, Generic_Formal_Declarations);
4963 + end Make_Generic_Subprogram_Declaration;
4965 + function Make_Generic_Package_Declaration (Sloc : Source_Ptr;
4966 + Specification : Node_Id;
4967 + Generic_Formal_Declarations : List_Id)
4970 + N : constant Node_Id :=
4971 + New_Node (N_Generic_Package_Declaration, Sloc);
4973 + Set_Specification (N, Specification);
4974 + Set_Generic_Formal_Declarations (N, Generic_Formal_Declarations);
4976 + end Make_Generic_Package_Declaration;
4978 + function Make_Package_Instantiation (Sloc : Source_Ptr;
4979 + Defining_Unit_Name : Node_Id;
4981 + Generic_Associations : List_Id := No_List)
4984 + N : constant Node_Id :=
4985 + New_Node (N_Package_Instantiation, Sloc);
4987 + Set_Defining_Unit_Name (N, Defining_Unit_Name);
4988 + Set_Name (N, Name);
4989 + Set_Generic_Associations (N, Generic_Associations);
4991 + end Make_Package_Instantiation;
4993 + function Make_Procedure_Instantiation (Sloc : Source_Ptr;
4994 + Defining_Unit_Name : Node_Id;
4996 + Generic_Associations : List_Id := No_List)
4999 + N : constant Node_Id :=
5000 + New_Node (N_Procedure_Instantiation, Sloc);
5002 + Set_Defining_Unit_Name (N, Defining_Unit_Name);
5003 + Set_Name (N, Name);
5004 + Set_Generic_Associations (N, Generic_Associations);
5006 + end Make_Procedure_Instantiation;
5008 + function Make_Function_Instantiation (Sloc : Source_Ptr;
5009 + Defining_Unit_Name : Node_Id;
5011 + Generic_Associations : List_Id := No_List)
5014 + N : constant Node_Id :=
5015 + New_Node (N_Function_Instantiation, Sloc);
5017 + Set_Defining_Unit_Name (N, Defining_Unit_Name);
5018 + Set_Name (N, Name);
5019 + Set_Generic_Associations (N, Generic_Associations);
5021 + end Make_Function_Instantiation;
5023 + function Make_Generic_Association (Sloc : Source_Ptr;
5024 + Selector_Name : Node_Id := Empty;
5025 + Explicit_Generic_Actual_Parameter : Node_Id)
5028 + N : constant Node_Id :=
5029 + New_Node (N_Generic_Association, Sloc);
5031 + Set_Selector_Name (N, Selector_Name);
5032 + Set_Explicit_Generic_Actual_Parameter
5033 + (N, Explicit_Generic_Actual_Parameter);
5035 + end Make_Generic_Association;
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)
5045 + N : constant Node_Id :=
5046 + New_Node (N_Formal_Object_Declaration, Sloc);
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);
5054 + end Make_Formal_Object_Declaration;
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)
5063 + N : constant Node_Id :=
5064 + New_Node (N_Formal_Type_Declaration, Sloc);
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);
5072 + end Make_Formal_Type_Declaration;
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)
5080 + N : constant Node_Id :=
5081 + New_Node (N_Formal_Private_Type_Definition, Sloc);
5083 + Set_Abstract_Present (N, Abstract_Present);
5084 + Set_Tagged_Present (N, Tagged_Present);
5085 + Set_Limited_Present (N, Limited_Present);
5087 + end Make_Formal_Private_Type_Definition;
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)
5095 + N : constant Node_Id :=
5096 + New_Node (N_Formal_Derived_Type_Definition, Sloc);
5098 + Set_Subtype_Mark (N, Subtype_Mark);
5099 + Set_Private_Present (N, Private_Present);
5100 + Set_Abstract_Present (N, Abstract_Present);
5102 + end Make_Formal_Derived_Type_Definition;
5104 + function Make_Formal_Discrete_Type_Definition (Sloc : Source_Ptr)
5107 + N : constant Node_Id :=
5108 + New_Node (N_Formal_Discrete_Type_Definition, Sloc);
5111 + end Make_Formal_Discrete_Type_Definition;
5113 + function Make_Formal_Signed_Integer_Type_Definition (Sloc : Source_Ptr)
5116 + N : constant Node_Id :=
5117 + New_Node (N_Formal_Signed_Integer_Type_Definition, Sloc);
5120 + end Make_Formal_Signed_Integer_Type_Definition;
5122 + function Make_Formal_Modular_Type_Definition (Sloc : Source_Ptr)
5125 + N : constant Node_Id :=
5126 + New_Node (N_Formal_Modular_Type_Definition, Sloc);
5129 + end Make_Formal_Modular_Type_Definition;
5131 + function Make_Formal_Floating_Point_Definition (Sloc : Source_Ptr)
5134 + N : constant Node_Id :=
5135 + New_Node (N_Formal_Floating_Point_Definition, Sloc);
5138 + end Make_Formal_Floating_Point_Definition;
5140 + function Make_Formal_Ordinary_Fixed_Point_Definition (Sloc : Source_Ptr)
5143 + N : constant Node_Id :=
5144 + New_Node (N_Formal_Ordinary_Fixed_Point_Definition, Sloc);
5147 + end Make_Formal_Ordinary_Fixed_Point_Definition;
5149 + function Make_Formal_Decimal_Fixed_Point_Definition (Sloc : Source_Ptr)
5152 + N : constant Node_Id :=
5153 + New_Node (N_Formal_Decimal_Fixed_Point_Definition, Sloc);
5156 + end Make_Formal_Decimal_Fixed_Point_Definition;
5158 + function Make_Formal_Subprogram_Declaration (Sloc : Source_Ptr;
5159 + Specification : Node_Id;
5160 + Default_Name : Node_Id := Empty;
5161 + Box_Present : Boolean := False)
5164 + N : constant Node_Id :=
5165 + New_Node (N_Formal_Subprogram_Declaration, Sloc);
5167 + Set_Specification (N, Specification);
5168 + Set_Default_Name (N, Default_Name);
5169 + Set_Box_Present (N, Box_Present);
5171 + end Make_Formal_Subprogram_Declaration;
5173 + function Make_Formal_Package_Declaration (Sloc : Source_Ptr;
5174 + Defining_Identifier : Node_Id;
5176 + Generic_Associations : List_Id := No_List;
5177 + Box_Present : Boolean := False)
5180 + N : constant Node_Id :=
5181 + New_Node (N_Formal_Package_Declaration, Sloc);
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);
5188 + end Make_Formal_Package_Declaration;
5190 + function Make_Attribute_Definition_Clause (Sloc : Source_Ptr;
5193 + Expression : Node_Id)
5196 + N : constant Node_Id :=
5197 + New_Node (N_Attribute_Definition_Clause, Sloc);
5199 + Set_Name (N, Name);
5200 + Set_Chars (N, Chars);
5201 + Set_Expression (N, Expression);
5203 + end Make_Attribute_Definition_Clause;
5205 + function Make_Enumeration_Representation_Clause (Sloc : Source_Ptr;
5206 + Identifier : Node_Id;
5207 + Array_Aggregate : Node_Id)
5210 + N : constant Node_Id :=
5211 + New_Node (N_Enumeration_Representation_Clause, Sloc);
5213 + Set_Identifier (N, Identifier);
5214 + Set_Array_Aggregate (N, Array_Aggregate);
5216 + end Make_Enumeration_Representation_Clause;
5218 + function Make_Record_Representation_Clause (Sloc : Source_Ptr;
5219 + Identifier : Node_Id;
5220 + Mod_Clause : Node_Id := Empty;
5221 + Component_Clauses : List_Id)
5224 + N : constant Node_Id :=
5225 + New_Node (N_Record_Representation_Clause, Sloc);
5227 + Set_Identifier (N, Identifier);
5228 + Set_Mod_Clause (N, Mod_Clause);
5229 + Set_Component_Clauses (N, Component_Clauses);
5231 + end Make_Record_Representation_Clause;
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)
5240 + N : constant Node_Id :=
5241 + New_Node (N_Component_Clause, Sloc);
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);
5248 + end Make_Component_Clause;
5250 + function Make_Code_Statement (Sloc : Source_Ptr;
5251 + Expression : Node_Id)
5254 + N : constant Node_Id :=
5255 + New_Node (N_Code_Statement, Sloc);
5257 + Set_Expression (N, Expression);
5259 + end Make_Code_Statement;
5261 + function Make_Op_Rotate_Left (Sloc : Source_Ptr;
5262 + Left_Opnd : Node_Id;
5263 + Right_Opnd : Node_Id)
5266 + N : constant Node_Id :=
5267 + New_Node (N_Op_Rotate_Left, Sloc);
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);
5274 + end Make_Op_Rotate_Left;
5276 + function Make_Op_Rotate_Right (Sloc : Source_Ptr;
5277 + Left_Opnd : Node_Id;
5278 + Right_Opnd : Node_Id)
5281 + N : constant Node_Id :=
5282 + New_Node (N_Op_Rotate_Right, Sloc);
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);
5289 + end Make_Op_Rotate_Right;
5291 + function Make_Op_Shift_Left (Sloc : Source_Ptr;
5292 + Left_Opnd : Node_Id;
5293 + Right_Opnd : Node_Id)
5296 + N : constant Node_Id :=
5297 + New_Node (N_Op_Shift_Left, Sloc);
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);
5304 + end Make_Op_Shift_Left;
5306 + function Make_Op_Shift_Right_Arithmetic (Sloc : Source_Ptr;
5307 + Left_Opnd : Node_Id;
5308 + Right_Opnd : Node_Id)
5311 + N : constant Node_Id :=
5312 + New_Node (N_Op_Shift_Right_Arithmetic, Sloc);
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);
5319 + end Make_Op_Shift_Right_Arithmetic;
5321 + function Make_Op_Shift_Right (Sloc : Source_Ptr;
5322 + Left_Opnd : Node_Id;
5323 + Right_Opnd : Node_Id)
5326 + N : constant Node_Id :=
5327 + New_Node (N_Op_Shift_Right, Sloc);
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);
5334 + end Make_Op_Shift_Right;
5336 + function Make_Delta_Constraint (Sloc : Source_Ptr;
5337 + Delta_Expression : Node_Id;
5338 + Range_Constraint : Node_Id := Empty)
5341 + N : constant Node_Id :=
5342 + New_Node (N_Delta_Constraint, Sloc);
5344 + Set_Delta_Expression (N, Delta_Expression);
5345 + Set_Range_Constraint (N, Range_Constraint);
5347 + end Make_Delta_Constraint;
5349 + function Make_At_Clause (Sloc : Source_Ptr;
5350 + Identifier : Node_Id;
5351 + Expression : Node_Id)
5354 + N : constant Node_Id :=
5355 + New_Node (N_At_Clause, Sloc);
5357 + Set_Identifier (N, Identifier);
5358 + Set_Expression (N, Expression);
5360 + end Make_At_Clause;
5362 + function Make_Mod_Clause (Sloc : Source_Ptr;
5363 + Expression : Node_Id;
5364 + Pragmas_Before : List_Id)
5367 + N : constant Node_Id :=
5368 + New_Node (N_Mod_Clause, Sloc);
5370 + Set_Expression (N, Expression);
5371 + Set_Pragmas_Before (N, Pragmas_Before);
5373 + end Make_Mod_Clause;
5375 + function Make_Conditional_Expression (Sloc : Source_Ptr;
5376 + Expressions : List_Id)
5379 + N : constant Node_Id :=
5380 + New_Node (N_Conditional_Expression, Sloc);
5382 + Set_Expressions (N, Expressions);
5384 + end Make_Conditional_Expression;
5386 + function Make_Expanded_Name (Sloc : Source_Ptr;
5389 + Selector_Name : Node_Id)
5392 + N : constant Node_Id :=
5393 + New_Node (N_Expanded_Name, Sloc);
5395 + Set_Chars (N, Chars);
5396 + Set_Prefix (N, Prefix);
5397 + Set_Selector_Name (N, Selector_Name);
5399 + end Make_Expanded_Name;
5401 + function Make_Free_Statement (Sloc : Source_Ptr;
5402 + Expression : Node_Id)
5405 + N : constant Node_Id :=
5406 + New_Node (N_Free_Statement, Sloc);
5408 + Set_Expression (N, Expression);
5410 + end Make_Free_Statement;
5412 + function Make_Freeze_Entity (Sloc : Source_Ptr;
5413 + Actions : List_Id := No_List)
5416 + N : constant Node_Id :=
5417 + New_Node (N_Freeze_Entity, Sloc);
5419 + Set_Actions (N, Actions);
5421 + end Make_Freeze_Entity;
5423 + function Make_Implicit_Label_Declaration (Sloc : Source_Ptr;
5424 + Defining_Identifier : Node_Id)
5427 + N : constant Node_Id :=
5428 + New_Node (N_Implicit_Label_Declaration, Sloc);
5430 + Set_Defining_Identifier (N, Defining_Identifier);
5432 + end Make_Implicit_Label_Declaration;
5434 + function Make_Itype_Reference (Sloc : Source_Ptr)
5437 + N : constant Node_Id :=
5438 + New_Node (N_Itype_Reference, Sloc);
5441 + end Make_Itype_Reference;
5443 + function Make_Raise_Constraint_Error (Sloc : Source_Ptr;
5444 + Condition : Node_Id := Empty;
5448 + N : constant Node_Id :=
5449 + New_Node (N_Raise_Constraint_Error, Sloc);
5451 + Set_Condition (N, Condition);
5452 + Set_Reason (N, Reason);
5454 + end Make_Raise_Constraint_Error;
5456 + function Make_Raise_Program_Error (Sloc : Source_Ptr;
5457 + Condition : Node_Id := Empty;
5461 + N : constant Node_Id :=
5462 + New_Node (N_Raise_Program_Error, Sloc);
5464 + Set_Condition (N, Condition);
5465 + Set_Reason (N, Reason);
5467 + end Make_Raise_Program_Error;
5469 + function Make_Raise_Storage_Error (Sloc : Source_Ptr;
5470 + Condition : Node_Id := Empty;
5474 + N : constant Node_Id :=
5475 + New_Node (N_Raise_Storage_Error, Sloc);
5477 + Set_Condition (N, Condition);
5478 + Set_Reason (N, Reason);
5480 + end Make_Raise_Storage_Error;
5482 + function Make_Reference (Sloc : Source_Ptr;
5486 + N : constant Node_Id :=
5487 + New_Node (N_Reference, Sloc);
5489 + Set_Prefix (N, Prefix);
5491 + end Make_Reference;
5493 + function Make_Subprogram_Info (Sloc : Source_Ptr;
5494 + Identifier : Node_Id)
5497 + N : constant Node_Id :=
5498 + New_Node (N_Subprogram_Info, Sloc);
5500 + Set_Identifier (N, Identifier);
5502 + end Make_Subprogram_Info;
5504 + function Make_Unchecked_Expression (Sloc : Source_Ptr;
5505 + Expression : Node_Id)
5508 + N : constant Node_Id :=
5509 + New_Node (N_Unchecked_Expression, Sloc);
5511 + Set_Expression (N, Expression);
5513 + end Make_Unchecked_Expression;
5515 + function Make_Unchecked_Type_Conversion (Sloc : Source_Ptr;
5516 + Subtype_Mark : Node_Id;
5517 + Expression : Node_Id)
5520 + N : constant Node_Id :=
5521 + New_Node (N_Unchecked_Type_Conversion, Sloc);
5523 + Set_Subtype_Mark (N, Subtype_Mark);
5524 + Set_Expression (N, Expression);
5526 + end Make_Unchecked_Type_Conversion;
5528 + function Make_Validate_Unchecked_Conversion (Sloc : Source_Ptr)
5531 + N : constant Node_Id :=
5532 + New_Node (N_Validate_Unchecked_Conversion, Sloc);
5535 + end Make_Validate_Unchecked_Conversion;
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
5541 +------------------------------------------------------------------------------
5543 +-- GNAT COMPILER COMPONENTS --
5549 +-- Copyright (C) 1992-2003 Free Software Foundation, Inc. --
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. --
5562 +-- GNAT was originally developed by the GNAT team at New York University. --
5563 +-- Extensive contributions were provided by Ada Core Technologies Inc. --
5565 +------------------------------------------------------------------------------
5567 +pragma Style_Checks (All_Checks);
5568 +-- Turn off subprogram order checking, since the routines here are
5569 +-- generated automatically in order.
5572 +with Nlists; use Nlists;
5573 +with Types; use Types;
5574 +with Uintp; use Uintp;
5575 +with Urealp; use Urealp;
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:
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]
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:
5595 +-- Comes_From_Source
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.
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."
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).
5611 + function Make_Unused_At_Start (Sloc : Source_Ptr)
5613 + pragma Inline (Make_Unused_At_Start);
5615 + function Make_Unused_At_End (Sloc : Source_Ptr)
5617 + pragma Inline (Make_Unused_At_End);
5619 + function Make_Identifier (Sloc : Source_Ptr;
5622 + pragma Inline (Make_Identifier);
5624 + function Make_Integer_Literal (Sloc : Source_Ptr;
5627 + pragma Inline (Make_Integer_Literal);
5629 + function Make_Real_Literal (Sloc : Source_Ptr;
5632 + pragma Inline (Make_Real_Literal);
5634 + function Make_Character_Literal (Sloc : Source_Ptr;
5636 + Char_Literal_Value : Char_Code)
5638 + pragma Inline (Make_Character_Literal);
5640 + function Make_String_Literal (Sloc : Source_Ptr;
5641 + Strval : String_Id)
5643 + pragma Inline (Make_String_Literal);
5645 + function Make_Pragma (Sloc : Source_Ptr;
5647 + Pragma_Argument_Associations : List_Id := No_List;
5648 + Debug_Statement : Node_Id := Empty)
5650 + pragma Inline (Make_Pragma);
5652 + function Make_Pragma_Argument_Association (Sloc : Source_Ptr;
5653 + Chars : Name_Id := No_Name;
5654 + Expression : Node_Id)
5656 + pragma Inline (Make_Pragma_Argument_Association);
5658 + function Make_Defining_Identifier (Sloc : Source_Ptr;
5661 + pragma Inline (Make_Defining_Identifier);
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)
5668 + pragma Inline (Make_Full_Type_Declaration);
5670 + function Make_Subtype_Declaration (Sloc : Source_Ptr;
5671 + Defining_Identifier : Node_Id;
5672 + Subtype_Indication : Node_Id)
5674 + pragma Inline (Make_Subtype_Declaration);
5676 + function Make_Subtype_Indication (Sloc : Source_Ptr;
5677 + Subtype_Mark : Node_Id;
5678 + Constraint : Node_Id)
5680 + pragma Inline (Make_Subtype_Indication);
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)
5689 + pragma Inline (Make_Object_Declaration);
5691 + function Make_Number_Declaration (Sloc : Source_Ptr;
5692 + Defining_Identifier : Node_Id;
5693 + Expression : Node_Id)
5695 + pragma Inline (Make_Number_Declaration);
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)
5702 + pragma Inline (Make_Derived_Type_Definition);
5704 + function Make_Range_Constraint (Sloc : Source_Ptr;
5705 + Range_Expression : Node_Id)
5707 + pragma Inline (Make_Range_Constraint);
5709 + function Make_Range (Sloc : Source_Ptr;
5710 + Low_Bound : Node_Id;
5711 + High_Bound : Node_Id;
5712 + Includes_Infinities : Boolean := False)
5714 + pragma Inline (Make_Range);
5716 + function Make_Enumeration_Type_Definition (Sloc : Source_Ptr;
5717 + Literals : List_Id;
5718 + End_Label : Node_Id := Empty)
5720 + pragma Inline (Make_Enumeration_Type_Definition);
5722 + function Make_Defining_Character_Literal (Sloc : Source_Ptr;
5725 + pragma Inline (Make_Defining_Character_Literal);
5727 + function Make_Signed_Integer_Type_Definition (Sloc : Source_Ptr;
5728 + Low_Bound : Node_Id;
5729 + High_Bound : Node_Id)
5731 + pragma Inline (Make_Signed_Integer_Type_Definition);
5733 + function Make_Modular_Type_Definition (Sloc : Source_Ptr;
5734 + Expression : Node_Id)
5736 + pragma Inline (Make_Modular_Type_Definition);
5738 + function Make_Floating_Point_Definition (Sloc : Source_Ptr;
5739 + Digits_Expression : Node_Id;
5740 + Real_Range_Specification : Node_Id := Empty)
5742 + pragma Inline (Make_Floating_Point_Definition);
5744 + function Make_Real_Range_Specification (Sloc : Source_Ptr;
5745 + Low_Bound : Node_Id;
5746 + High_Bound : Node_Id)
5748 + pragma Inline (Make_Real_Range_Specification);
5750 + function Make_Ordinary_Fixed_Point_Definition (Sloc : Source_Ptr;
5751 + Delta_Expression : Node_Id;
5752 + Real_Range_Specification : Node_Id)
5754 + pragma Inline (Make_Ordinary_Fixed_Point_Definition);
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)
5761 + pragma Inline (Make_Decimal_Fixed_Point_Definition);
5763 + function Make_Digits_Constraint (Sloc : Source_Ptr;
5764 + Digits_Expression : Node_Id;
5765 + Range_Constraint : Node_Id := Empty)
5767 + pragma Inline (Make_Digits_Constraint);
5769 + function Make_Unconstrained_Array_Definition (Sloc : Source_Ptr;
5770 + Subtype_Marks : List_Id;
5771 + Component_Definition : Node_Id)
5773 + pragma Inline (Make_Unconstrained_Array_Definition);
5775 + function Make_Constrained_Array_Definition (Sloc : Source_Ptr;
5776 + Discrete_Subtype_Definitions : List_Id;
5777 + Component_Definition : Node_Id)
5779 + pragma Inline (Make_Constrained_Array_Definition);
5781 + function Make_Component_Definition (Sloc : Source_Ptr;
5782 + Aliased_Present : Boolean := False;
5783 + Subtype_Indication : Node_Id)
5785 + pragma Inline (Make_Component_Definition);
5787 + function Make_Discriminant_Specification (Sloc : Source_Ptr;
5788 + Defining_Identifier : Node_Id;
5789 + Discriminant_Type : Node_Id;
5790 + Expression : Node_Id := Empty)
5792 + pragma Inline (Make_Discriminant_Specification);
5794 + function Make_Index_Or_Discriminant_Constraint (Sloc : Source_Ptr;
5795 + Constraints : List_Id)
5797 + pragma Inline (Make_Index_Or_Discriminant_Constraint);
5799 + function Make_Discriminant_Association (Sloc : Source_Ptr;
5800 + Selector_Names : List_Id;
5801 + Expression : Node_Id)
5803 + pragma Inline (Make_Discriminant_Association);
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)
5813 + pragma Inline (Make_Record_Definition);
5815 + function Make_Component_List (Sloc : Source_Ptr;
5816 + Component_Items : List_Id;
5817 + Variant_Part : Node_Id := Empty;
5818 + Null_Present : Boolean := False)
5820 + pragma Inline (Make_Component_List);
5822 + function Make_Component_Declaration (Sloc : Source_Ptr;
5823 + Defining_Identifier : Node_Id;
5824 + Component_Definition : Node_Id;
5825 + Expression : Node_Id := Empty)
5827 + pragma Inline (Make_Component_Declaration);
5829 + function Make_Variant_Part (Sloc : Source_Ptr;
5831 + Variants : List_Id)
5833 + pragma Inline (Make_Variant_Part);
5835 + function Make_Variant (Sloc : Source_Ptr;
5836 + Discrete_Choices : List_Id;
5837 + Component_List : Node_Id)
5839 + pragma Inline (Make_Variant);
5841 + function Make_Others_Choice (Sloc : Source_Ptr)
5843 + pragma Inline (Make_Others_Choice);
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)
5850 + pragma Inline (Make_Access_To_Object_Definition);
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)
5857 + pragma Inline (Make_Access_Function_Definition);
5859 + function Make_Access_Procedure_Definition (Sloc : Source_Ptr;
5860 + Protected_Present : Boolean := False;
5861 + Parameter_Specifications : List_Id := No_List)
5863 + pragma Inline (Make_Access_Procedure_Definition);
5865 + function Make_Access_Definition (Sloc : Source_Ptr;
5866 + Subtype_Mark : Node_Id)
5868 + pragma Inline (Make_Access_Definition);
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)
5875 + pragma Inline (Make_Incomplete_Type_Declaration);
5877 + function Make_Explicit_Dereference (Sloc : Source_Ptr;
5880 + pragma Inline (Make_Explicit_Dereference);
5882 + function Make_Indexed_Component (Sloc : Source_Ptr;
5884 + Expressions : List_Id)
5886 + pragma Inline (Make_Indexed_Component);
5888 + function Make_Slice (Sloc : Source_Ptr;
5890 + Discrete_Range : Node_Id)
5892 + pragma Inline (Make_Slice);
5894 + function Make_Selected_Component (Sloc : Source_Ptr;
5896 + Selector_Name : Node_Id)
5898 + pragma Inline (Make_Selected_Component);
5900 + function Make_Attribute_Reference (Sloc : Source_Ptr;
5902 + Attribute_Name : Name_Id;
5903 + Expressions : List_Id := No_List;
5904 + Must_Be_Byte_Aligned : Boolean := False)
5906 + pragma Inline (Make_Attribute_Reference);
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)
5913 + pragma Inline (Make_Aggregate);
5915 + function Make_Component_Association (Sloc : Source_Ptr;
5916 + Choices : List_Id;
5917 + Expression : Node_Id;
5918 + Box_Present : Boolean := False)
5920 + pragma Inline (Make_Component_Association);
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)
5928 + pragma Inline (Make_Extension_Aggregate);
5930 + function Make_Null (Sloc : Source_Ptr)
5932 + pragma Inline (Make_Null);
5934 + function Make_And_Then (Sloc : Source_Ptr;
5935 + Left_Opnd : Node_Id;
5936 + Right_Opnd : Node_Id)
5938 + pragma Inline (Make_And_Then);
5940 + function Make_Or_Else (Sloc : Source_Ptr;
5941 + Left_Opnd : Node_Id;
5942 + Right_Opnd : Node_Id)
5944 + pragma Inline (Make_Or_Else);
5946 + function Make_In (Sloc : Source_Ptr;
5947 + Left_Opnd : Node_Id;
5948 + Right_Opnd : Node_Id)
5950 + pragma Inline (Make_In);
5952 + function Make_Not_In (Sloc : Source_Ptr;
5953 + Left_Opnd : Node_Id;
5954 + Right_Opnd : Node_Id)
5956 + pragma Inline (Make_Not_In);
5958 + function Make_Op_And (Sloc : Source_Ptr;
5959 + Left_Opnd : Node_Id;
5960 + Right_Opnd : Node_Id)
5962 + pragma Inline (Make_Op_And);
5964 + function Make_Op_Or (Sloc : Source_Ptr;
5965 + Left_Opnd : Node_Id;
5966 + Right_Opnd : Node_Id)
5968 + pragma Inline (Make_Op_Or);
5970 + function Make_Op_Xor (Sloc : Source_Ptr;
5971 + Left_Opnd : Node_Id;
5972 + Right_Opnd : Node_Id)
5974 + pragma Inline (Make_Op_Xor);
5976 + function Make_Op_Eq (Sloc : Source_Ptr;
5977 + Left_Opnd : Node_Id;
5978 + Right_Opnd : Node_Id)
5980 + pragma Inline (Make_Op_Eq);
5982 + function Make_Op_Ne (Sloc : Source_Ptr;
5983 + Left_Opnd : Node_Id;
5984 + Right_Opnd : Node_Id)
5986 + pragma Inline (Make_Op_Ne);
5988 + function Make_Op_Lt (Sloc : Source_Ptr;
5989 + Left_Opnd : Node_Id;
5990 + Right_Opnd : Node_Id)
5992 + pragma Inline (Make_Op_Lt);
5994 + function Make_Op_Le (Sloc : Source_Ptr;
5995 + Left_Opnd : Node_Id;
5996 + Right_Opnd : Node_Id)
5998 + pragma Inline (Make_Op_Le);
6000 + function Make_Op_Gt (Sloc : Source_Ptr;
6001 + Left_Opnd : Node_Id;
6002 + Right_Opnd : Node_Id)
6004 + pragma Inline (Make_Op_Gt);
6006 + function Make_Op_Ge (Sloc : Source_Ptr;
6007 + Left_Opnd : Node_Id;
6008 + Right_Opnd : Node_Id)
6010 + pragma Inline (Make_Op_Ge);
6012 + function Make_Op_Add (Sloc : Source_Ptr;
6013 + Left_Opnd : Node_Id;
6014 + Right_Opnd : Node_Id)
6016 + pragma Inline (Make_Op_Add);
6018 + function Make_Op_Subtract (Sloc : Source_Ptr;
6019 + Left_Opnd : Node_Id;
6020 + Right_Opnd : Node_Id)
6022 + pragma Inline (Make_Op_Subtract);
6024 + function Make_Op_Concat (Sloc : Source_Ptr;
6025 + Left_Opnd : Node_Id;
6026 + Right_Opnd : Node_Id)
6028 + pragma Inline (Make_Op_Concat);
6030 + function Make_Op_Multiply (Sloc : Source_Ptr;
6031 + Left_Opnd : Node_Id;
6032 + Right_Opnd : Node_Id)
6034 + pragma Inline (Make_Op_Multiply);
6036 + function Make_Op_Divide (Sloc : Source_Ptr;
6037 + Left_Opnd : Node_Id;
6038 + Right_Opnd : Node_Id)
6040 + pragma Inline (Make_Op_Divide);
6042 + function Make_Op_Mod (Sloc : Source_Ptr;
6043 + Left_Opnd : Node_Id;
6044 + Right_Opnd : Node_Id)
6046 + pragma Inline (Make_Op_Mod);
6048 + function Make_Op_Rem (Sloc : Source_Ptr;
6049 + Left_Opnd : Node_Id;
6050 + Right_Opnd : Node_Id)
6052 + pragma Inline (Make_Op_Rem);
6054 + function Make_Op_Expon (Sloc : Source_Ptr;
6055 + Left_Opnd : Node_Id;
6056 + Right_Opnd : Node_Id)
6058 + pragma Inline (Make_Op_Expon);
6060 + function Make_Op_Plus (Sloc : Source_Ptr;
6061 + Right_Opnd : Node_Id)
6063 + pragma Inline (Make_Op_Plus);
6065 + function Make_Op_Minus (Sloc : Source_Ptr;
6066 + Right_Opnd : Node_Id)
6068 + pragma Inline (Make_Op_Minus);
6070 + function Make_Op_Abs (Sloc : Source_Ptr;
6071 + Right_Opnd : Node_Id)
6073 + pragma Inline (Make_Op_Abs);
6075 + function Make_Op_Not (Sloc : Source_Ptr;
6076 + Right_Opnd : Node_Id)
6078 + pragma Inline (Make_Op_Not);
6080 + function Make_Type_Conversion (Sloc : Source_Ptr;
6081 + Subtype_Mark : Node_Id;
6082 + Expression : Node_Id)
6084 + pragma Inline (Make_Type_Conversion);
6086 + function Make_Qualified_Expression (Sloc : Source_Ptr;
6087 + Subtype_Mark : Node_Id;
6088 + Expression : Node_Id)
6090 + pragma Inline (Make_Qualified_Expression);
6092 + function Make_Allocator (Sloc : Source_Ptr;
6093 + Expression : Node_Id)
6095 + pragma Inline (Make_Allocator);
6097 + function Make_Null_Statement (Sloc : Source_Ptr)
6099 + pragma Inline (Make_Null_Statement);
6101 + function Make_Label (Sloc : Source_Ptr;
6102 + Identifier : Node_Id)
6104 + pragma Inline (Make_Label);
6106 + function Make_Assignment_Statement (Sloc : Source_Ptr;
6108 + Expression : Node_Id)
6110 + pragma Inline (Make_Assignment_Statement);
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)
6119 + pragma Inline (Make_If_Statement);
6121 + function Make_Elsif_Part (Sloc : Source_Ptr;
6122 + Condition : Node_Id;
6123 + Then_Statements : List_Id)
6125 + pragma Inline (Make_Elsif_Part);
6127 + function Make_Case_Statement (Sloc : Source_Ptr;
6128 + Expression : Node_Id;
6129 + Alternatives : List_Id;
6130 + End_Span : Uint := No_Uint)
6132 + pragma Inline (Make_Case_Statement);
6134 + function Make_Case_Statement_Alternative (Sloc : Source_Ptr;
6135 + Discrete_Choices : List_Id;
6136 + Statements : List_Id)
6138 + pragma Inline (Make_Case_Statement_Alternative);
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)
6148 + pragma Inline (Make_Loop_Statement);
6150 + function Make_Iteration_Scheme (Sloc : Source_Ptr;
6151 + Condition : Node_Id := Empty;
6152 + Loop_Parameter_Specification : Node_Id := Empty)
6154 + pragma Inline (Make_Iteration_Scheme);
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)
6161 + pragma Inline (Make_Loop_Parameter_Specification);
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)
6171 + pragma Inline (Make_Block_Statement);
6173 + function Make_Exit_Statement (Sloc : Source_Ptr;
6174 + Name : Node_Id := Empty;
6175 + Condition : Node_Id := Empty)
6177 + pragma Inline (Make_Exit_Statement);
6179 + function Make_Goto_Statement (Sloc : Source_Ptr;
6182 + pragma Inline (Make_Goto_Statement);
6184 + function Make_Subprogram_Declaration (Sloc : Source_Ptr;
6185 + Specification : Node_Id)
6187 + pragma Inline (Make_Subprogram_Declaration);
6189 + function Make_Abstract_Subprogram_Declaration (Sloc : Source_Ptr;
6190 + Specification : Node_Id)
6192 + pragma Inline (Make_Abstract_Subprogram_Declaration);
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)
6199 + pragma Inline (Make_Function_Specification);
6201 + function Make_Procedure_Specification (Sloc : Source_Ptr;
6202 + Defining_Unit_Name : Node_Id;
6203 + Parameter_Specifications : List_Id := No_List)
6205 + pragma Inline (Make_Procedure_Specification);
6207 + function Make_Designator (Sloc : Source_Ptr;
6209 + Identifier : Node_Id)
6211 + pragma Inline (Make_Designator);
6213 + function Make_Defining_Program_Unit_Name (Sloc : Source_Ptr;
6215 + Defining_Identifier : Node_Id)
6217 + pragma Inline (Make_Defining_Program_Unit_Name);
6219 + function Make_Operator_Symbol (Sloc : Source_Ptr;
6221 + Strval : String_Id)
6223 + pragma Inline (Make_Operator_Symbol);
6225 + function Make_Defining_Operator_Symbol (Sloc : Source_Ptr;
6228 + pragma Inline (Make_Defining_Operator_Symbol);
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)
6237 + pragma Inline (Make_Parameter_Specification);
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)
6245 + pragma Inline (Make_Subprogram_Body);
6247 + function Make_Procedure_Call_Statement (Sloc : Source_Ptr;
6249 + Parameter_Associations : List_Id := No_List)
6251 + pragma Inline (Make_Procedure_Call_Statement);
6253 + function Make_Function_Call (Sloc : Source_Ptr;
6255 + Parameter_Associations : List_Id := No_List)
6257 + pragma Inline (Make_Function_Call);
6259 + function Make_Parameter_Association (Sloc : Source_Ptr;
6260 + Selector_Name : Node_Id;
6261 + Explicit_Actual_Parameter : Node_Id)
6263 + pragma Inline (Make_Parameter_Association);
6265 + function Make_Return_Statement (Sloc : Source_Ptr;
6266 + Expression : Node_Id := Empty)
6268 + pragma Inline (Make_Return_Statement);
6270 + function Make_Package_Declaration (Sloc : Source_Ptr;
6271 + Specification : Node_Id)
6273 + pragma Inline (Make_Package_Declaration);
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)
6281 + pragma Inline (Make_Package_Specification);
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)
6288 + pragma Inline (Make_Package_Body);
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)
6298 + pragma Inline (Make_Private_Type_Declaration);
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)
6307 + pragma Inline (Make_Private_Extension_Declaration);
6309 + function Make_Use_Package_Clause (Sloc : Source_Ptr;
6312 + pragma Inline (Make_Use_Package_Clause);
6314 + function Make_Use_Type_Clause (Sloc : Source_Ptr;
6315 + Subtype_Marks : List_Id)
6317 + pragma Inline (Make_Use_Type_Clause);
6319 + function Make_Object_Renaming_Declaration (Sloc : Source_Ptr;
6320 + Defining_Identifier : Node_Id;
6321 + Subtype_Mark : Node_Id;
6324 + pragma Inline (Make_Object_Renaming_Declaration);
6326 + function Make_Exception_Renaming_Declaration (Sloc : Source_Ptr;
6327 + Defining_Identifier : Node_Id;
6330 + pragma Inline (Make_Exception_Renaming_Declaration);
6332 + function Make_Package_Renaming_Declaration (Sloc : Source_Ptr;
6333 + Defining_Unit_Name : Node_Id;
6336 + pragma Inline (Make_Package_Renaming_Declaration);
6338 + function Make_Subprogram_Renaming_Declaration (Sloc : Source_Ptr;
6339 + Specification : Node_Id;
6342 + pragma Inline (Make_Subprogram_Renaming_Declaration);
6344 + function Make_Generic_Package_Renaming_Declaration (Sloc : Source_Ptr;
6345 + Defining_Unit_Name : Node_Id;
6348 + pragma Inline (Make_Generic_Package_Renaming_Declaration);
6350 + function Make_Generic_Procedure_Renaming_Declaration (Sloc : Source_Ptr;
6351 + Defining_Unit_Name : Node_Id;
6354 + pragma Inline (Make_Generic_Procedure_Renaming_Declaration);
6356 + function Make_Generic_Function_Renaming_Declaration (Sloc : Source_Ptr;
6357 + Defining_Unit_Name : Node_Id;
6360 + pragma Inline (Make_Generic_Function_Renaming_Declaration);
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)
6367 + pragma Inline (Make_Task_Type_Declaration);
6369 + function Make_Single_Task_Declaration (Sloc : Source_Ptr;
6370 + Defining_Identifier : Node_Id;
6371 + Task_Definition : Node_Id := Empty)
6373 + pragma Inline (Make_Single_Task_Declaration);
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)
6380 + pragma Inline (Make_Task_Definition);
6382 + function Make_Task_Body (Sloc : Source_Ptr;
6383 + Defining_Identifier : Node_Id;
6384 + Declarations : List_Id;
6385 + Handled_Statement_Sequence : Node_Id)
6387 + pragma Inline (Make_Task_Body);
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)
6394 + pragma Inline (Make_Protected_Type_Declaration);
6396 + function Make_Single_Protected_Declaration (Sloc : Source_Ptr;
6397 + Defining_Identifier : Node_Id;
6398 + Protected_Definition : Node_Id)
6400 + pragma Inline (Make_Single_Protected_Declaration);
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)
6407 + pragma Inline (Make_Protected_Definition);
6409 + function Make_Protected_Body (Sloc : Source_Ptr;
6410 + Defining_Identifier : Node_Id;
6411 + Declarations : List_Id;
6412 + End_Label : Node_Id)
6414 + pragma Inline (Make_Protected_Body);
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)
6421 + pragma Inline (Make_Entry_Declaration);
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)
6430 + pragma Inline (Make_Accept_Statement);
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)
6438 + pragma Inline (Make_Entry_Body);
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)
6445 + pragma Inline (Make_Entry_Body_Formal_Part);
6447 + function Make_Entry_Index_Specification (Sloc : Source_Ptr;
6448 + Defining_Identifier : Node_Id;
6449 + Discrete_Subtype_Definition : Node_Id)
6451 + pragma Inline (Make_Entry_Index_Specification);
6453 + function Make_Entry_Call_Statement (Sloc : Source_Ptr;
6455 + Parameter_Associations : List_Id := No_List)
6457 + pragma Inline (Make_Entry_Call_Statement);
6459 + function Make_Requeue_Statement (Sloc : Source_Ptr;
6461 + Abort_Present : Boolean := False)
6463 + pragma Inline (Make_Requeue_Statement);
6465 + function Make_Delay_Until_Statement (Sloc : Source_Ptr;
6466 + Expression : Node_Id)
6468 + pragma Inline (Make_Delay_Until_Statement);
6470 + function Make_Delay_Relative_Statement (Sloc : Source_Ptr;
6471 + Expression : Node_Id)
6473 + pragma Inline (Make_Delay_Relative_Statement);
6475 + function Make_Selective_Accept (Sloc : Source_Ptr;
6476 + Select_Alternatives : List_Id;
6477 + Else_Statements : List_Id := No_List)
6479 + pragma Inline (Make_Selective_Accept);
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)
6487 + pragma Inline (Make_Accept_Alternative);
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)
6495 + pragma Inline (Make_Delay_Alternative);
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)
6502 + pragma Inline (Make_Terminate_Alternative);
6504 + function Make_Timed_Entry_Call (Sloc : Source_Ptr;
6505 + Entry_Call_Alternative : Node_Id;
6506 + Delay_Alternative : Node_Id)
6508 + pragma Inline (Make_Timed_Entry_Call);
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)
6515 + pragma Inline (Make_Entry_Call_Alternative);
6517 + function Make_Conditional_Entry_Call (Sloc : Source_Ptr;
6518 + Entry_Call_Alternative : Node_Id;
6519 + Else_Statements : List_Id)
6521 + pragma Inline (Make_Conditional_Entry_Call);
6523 + function Make_Asynchronous_Select (Sloc : Source_Ptr;
6524 + Triggering_Alternative : Node_Id;
6525 + Abortable_Part : Node_Id)
6527 + pragma Inline (Make_Asynchronous_Select);
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)
6534 + pragma Inline (Make_Triggering_Alternative);
6536 + function Make_Abortable_Part (Sloc : Source_Ptr;
6537 + Statements : List_Id)
6539 + pragma Inline (Make_Abortable_Part);
6541 + function Make_Abort_Statement (Sloc : Source_Ptr;
6544 + pragma Inline (Make_Abort_Statement);
6546 + function Make_Compilation_Unit (Sloc : Source_Ptr;
6547 + Context_Items : List_Id;
6548 + Private_Present : Boolean := False;
6550 + Aux_Decls_Node : Node_Id)
6552 + pragma Inline (Make_Compilation_Unit);
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)
6560 + pragma Inline (Make_Compilation_Unit_Aux);
6562 + function Make_With_Clause (Sloc : Source_Ptr;
6564 + First_Name : Boolean := True;
6565 + Last_Name : Boolean := True;
6566 + Limited_Present : Boolean := False)
6568 + pragma Inline (Make_With_Clause);
6570 + function Make_With_Type_Clause (Sloc : Source_Ptr;
6572 + Tagged_Present : Boolean := False)
6574 + pragma Inline (Make_With_Type_Clause);
6576 + function Make_Subprogram_Body_Stub (Sloc : Source_Ptr;
6577 + Specification : Node_Id)
6579 + pragma Inline (Make_Subprogram_Body_Stub);
6581 + function Make_Package_Body_Stub (Sloc : Source_Ptr;
6582 + Defining_Identifier : Node_Id)
6584 + pragma Inline (Make_Package_Body_Stub);
6586 + function Make_Task_Body_Stub (Sloc : Source_Ptr;
6587 + Defining_Identifier : Node_Id)
6589 + pragma Inline (Make_Task_Body_Stub);
6591 + function Make_Protected_Body_Stub (Sloc : Source_Ptr;
6592 + Defining_Identifier : Node_Id)
6594 + pragma Inline (Make_Protected_Body_Stub);
6596 + function Make_Subunit (Sloc : Source_Ptr;
6598 + Proper_Body : Node_Id)
6600 + pragma Inline (Make_Subunit);
6602 + function Make_Exception_Declaration (Sloc : Source_Ptr;
6603 + Defining_Identifier : Node_Id)
6605 + pragma Inline (Make_Exception_Declaration);
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)
6613 + pragma Inline (Make_Handled_Sequence_Of_Statements);
6615 + function Make_Exception_Handler (Sloc : Source_Ptr;
6616 + Choice_Parameter : Node_Id := Empty;
6617 + Exception_Choices : List_Id;
6618 + Statements : List_Id)
6620 + pragma Inline (Make_Exception_Handler);
6622 + function Make_Raise_Statement (Sloc : Source_Ptr;
6623 + Name : Node_Id := Empty)
6625 + pragma Inline (Make_Raise_Statement);
6627 + function Make_Generic_Subprogram_Declaration (Sloc : Source_Ptr;
6628 + Specification : Node_Id;
6629 + Generic_Formal_Declarations : List_Id)
6631 + pragma Inline (Make_Generic_Subprogram_Declaration);
6633 + function Make_Generic_Package_Declaration (Sloc : Source_Ptr;
6634 + Specification : Node_Id;
6635 + Generic_Formal_Declarations : List_Id)
6637 + pragma Inline (Make_Generic_Package_Declaration);
6639 + function Make_Package_Instantiation (Sloc : Source_Ptr;
6640 + Defining_Unit_Name : Node_Id;
6642 + Generic_Associations : List_Id := No_List)
6644 + pragma Inline (Make_Package_Instantiation);
6646 + function Make_Procedure_Instantiation (Sloc : Source_Ptr;
6647 + Defining_Unit_Name : Node_Id;
6649 + Generic_Associations : List_Id := No_List)
6651 + pragma Inline (Make_Procedure_Instantiation);
6653 + function Make_Function_Instantiation (Sloc : Source_Ptr;
6654 + Defining_Unit_Name : Node_Id;
6656 + Generic_Associations : List_Id := No_List)
6658 + pragma Inline (Make_Function_Instantiation);
6660 + function Make_Generic_Association (Sloc : Source_Ptr;
6661 + Selector_Name : Node_Id := Empty;
6662 + Explicit_Generic_Actual_Parameter : Node_Id)
6664 + pragma Inline (Make_Generic_Association);
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)
6673 + pragma Inline (Make_Formal_Object_Declaration);
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)
6681 + pragma Inline (Make_Formal_Type_Declaration);
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)
6688 + pragma Inline (Make_Formal_Private_Type_Definition);
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)
6695 + pragma Inline (Make_Formal_Derived_Type_Definition);
6697 + function Make_Formal_Discrete_Type_Definition (Sloc : Source_Ptr)
6699 + pragma Inline (Make_Formal_Discrete_Type_Definition);
6701 + function Make_Formal_Signed_Integer_Type_Definition (Sloc : Source_Ptr)
6703 + pragma Inline (Make_Formal_Signed_Integer_Type_Definition);
6705 + function Make_Formal_Modular_Type_Definition (Sloc : Source_Ptr)
6707 + pragma Inline (Make_Formal_Modular_Type_Definition);
6709 + function Make_Formal_Floating_Point_Definition (Sloc : Source_Ptr)
6711 + pragma Inline (Make_Formal_Floating_Point_Definition);
6713 + function Make_Formal_Ordinary_Fixed_Point_Definition (Sloc : Source_Ptr)
6715 + pragma Inline (Make_Formal_Ordinary_Fixed_Point_Definition);
6717 + function Make_Formal_Decimal_Fixed_Point_Definition (Sloc : Source_Ptr)
6719 + pragma Inline (Make_Formal_Decimal_Fixed_Point_Definition);
6721 + function Make_Formal_Subprogram_Declaration (Sloc : Source_Ptr;
6722 + Specification : Node_Id;
6723 + Default_Name : Node_Id := Empty;
6724 + Box_Present : Boolean := False)
6726 + pragma Inline (Make_Formal_Subprogram_Declaration);
6728 + function Make_Formal_Package_Declaration (Sloc : Source_Ptr;
6729 + Defining_Identifier : Node_Id;
6731 + Generic_Associations : List_Id := No_List;
6732 + Box_Present : Boolean := False)
6734 + pragma Inline (Make_Formal_Package_Declaration);
6736 + function Make_Attribute_Definition_Clause (Sloc : Source_Ptr;
6739 + Expression : Node_Id)
6741 + pragma Inline (Make_Attribute_Definition_Clause);
6743 + function Make_Enumeration_Representation_Clause (Sloc : Source_Ptr;
6744 + Identifier : Node_Id;
6745 + Array_Aggregate : Node_Id)
6747 + pragma Inline (Make_Enumeration_Representation_Clause);
6749 + function Make_Record_Representation_Clause (Sloc : Source_Ptr;
6750 + Identifier : Node_Id;
6751 + Mod_Clause : Node_Id := Empty;
6752 + Component_Clauses : List_Id)
6754 + pragma Inline (Make_Record_Representation_Clause);
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)
6762 + pragma Inline (Make_Component_Clause);
6764 + function Make_Code_Statement (Sloc : Source_Ptr;
6765 + Expression : Node_Id)
6767 + pragma Inline (Make_Code_Statement);
6769 + function Make_Op_Rotate_Left (Sloc : Source_Ptr;
6770 + Left_Opnd : Node_Id;
6771 + Right_Opnd : Node_Id)
6773 + pragma Inline (Make_Op_Rotate_Left);
6775 + function Make_Op_Rotate_Right (Sloc : Source_Ptr;
6776 + Left_Opnd : Node_Id;
6777 + Right_Opnd : Node_Id)
6779 + pragma Inline (Make_Op_Rotate_Right);
6781 + function Make_Op_Shift_Left (Sloc : Source_Ptr;
6782 + Left_Opnd : Node_Id;
6783 + Right_Opnd : Node_Id)
6785 + pragma Inline (Make_Op_Shift_Left);
6787 + function Make_Op_Shift_Right_Arithmetic (Sloc : Source_Ptr;
6788 + Left_Opnd : Node_Id;
6789 + Right_Opnd : Node_Id)
6791 + pragma Inline (Make_Op_Shift_Right_Arithmetic);
6793 + function Make_Op_Shift_Right (Sloc : Source_Ptr;
6794 + Left_Opnd : Node_Id;
6795 + Right_Opnd : Node_Id)
6797 + pragma Inline (Make_Op_Shift_Right);
6799 + function Make_Delta_Constraint (Sloc : Source_Ptr;
6800 + Delta_Expression : Node_Id;
6801 + Range_Constraint : Node_Id := Empty)
6803 + pragma Inline (Make_Delta_Constraint);
6805 + function Make_At_Clause (Sloc : Source_Ptr;
6806 + Identifier : Node_Id;
6807 + Expression : Node_Id)
6809 + pragma Inline (Make_At_Clause);
6811 + function Make_Mod_Clause (Sloc : Source_Ptr;
6812 + Expression : Node_Id;
6813 + Pragmas_Before : List_Id)
6815 + pragma Inline (Make_Mod_Clause);
6817 + function Make_Conditional_Expression (Sloc : Source_Ptr;
6818 + Expressions : List_Id)
6820 + pragma Inline (Make_Conditional_Expression);
6822 + function Make_Expanded_Name (Sloc : Source_Ptr;
6825 + Selector_Name : Node_Id)
6827 + pragma Inline (Make_Expanded_Name);
6829 + function Make_Free_Statement (Sloc : Source_Ptr;
6830 + Expression : Node_Id)
6832 + pragma Inline (Make_Free_Statement);
6834 + function Make_Freeze_Entity (Sloc : Source_Ptr;
6835 + Actions : List_Id := No_List)
6837 + pragma Inline (Make_Freeze_Entity);
6839 + function Make_Implicit_Label_Declaration (Sloc : Source_Ptr;
6840 + Defining_Identifier : Node_Id)
6842 + pragma Inline (Make_Implicit_Label_Declaration);
6844 + function Make_Itype_Reference (Sloc : Source_Ptr)
6846 + pragma Inline (Make_Itype_Reference);
6848 + function Make_Raise_Constraint_Error (Sloc : Source_Ptr;
6849 + Condition : Node_Id := Empty;
6852 + pragma Inline (Make_Raise_Constraint_Error);
6854 + function Make_Raise_Program_Error (Sloc : Source_Ptr;
6855 + Condition : Node_Id := Empty;
6858 + pragma Inline (Make_Raise_Program_Error);
6860 + function Make_Raise_Storage_Error (Sloc : Source_Ptr;
6861 + Condition : Node_Id := Empty;
6864 + pragma Inline (Make_Raise_Storage_Error);
6866 + function Make_Reference (Sloc : Source_Ptr;
6869 + pragma Inline (Make_Reference);
6871 + function Make_Subprogram_Info (Sloc : Source_Ptr;
6872 + Identifier : Node_Id)
6874 + pragma Inline (Make_Subprogram_Info);
6876 + function Make_Unchecked_Expression (Sloc : Source_Ptr;
6877 + Expression : Node_Id)
6879 + pragma Inline (Make_Unchecked_Expression);
6881 + function Make_Unchecked_Type_Conversion (Sloc : Source_Ptr;
6882 + Subtype_Mark : Node_Id;
6883 + Expression : Node_Id)
6885 + pragma Inline (Make_Unchecked_Type_Conversion);
6887 + function Make_Validate_Unchecked_Conversion (Sloc : Source_Ptr)
6889 + pragma Inline (Make_Validate_Unchecked_Conversion);
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
6895 +------------------------------------------------------------------------------
6897 +-- GNAT COMPILER COMPONENTS --
6899 +-- T R E E P R S --
6903 +-- Copyright (C) 1992-2003 Free Software Foundation, Inc. --
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. --
6916 +-- GNAT was originally developed by the GNAT team at New York University. --
6917 +-- Extensive contributions were provided by Ada Core Technologies Inc. --
6919 +------------------------------------------------------------------------------
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.
6927 +with Sinfo; use Sinfo;
6931 + --------------------------------
6932 + -- String Data for Node Print --
6933 + --------------------------------
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.
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.
6946 + subtype Fchar is Character range '#' .. '9';
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#)
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:
6979 + -- Cannot_Be_Constant
6981 + -- Comes_From_Source
6984 + -- Is_Controlling_Actual
6986 + -- Is_Static_Expression
6988 + -- Must_Check_Expr
6989 + -- Must_Not_Freeze
6990 + -- No_Overflow_Expr
6992 + -- Raises_Constraint_Error
6995 + Pchars : constant String :=
6996 + -- Unused_At_Start
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" &
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" &
7013 + "$Pragma_Argument_Associations%Debug_Statement&Next_Rep_Item" &
7014 + -- Pragma_Argument_Association
7018 + -- Defining_Character_Literal
7019 + "$Next_Entity%Scope" &
7020 + -- Defining_Identifier
7021 + "$Next_Entity%Scope" &
7022 + -- Defining_Operator_Symbol
7023 + "$Next_Entity%Scope" &
7025 + "%Prefix$Selector_Name&Entity&Associated_Node4Redundant_Use2Has_Privat" &
7028 + "&Entity&Associated_Node$Original_Discriminant4Redundant_Use2Has_Priva" &
7030 + -- Operator_Symbol
7031 + "%Strval&Entity&Associated_Node2Has_Private_View" &
7032 + -- Character_Literal
7033 + "$Char_Literal_Value&Entity&Associated_Node2Has_Private_View" &
7037 + "4Is_Component_Left_Opnd5Is_Component_Right_Opnd" &
7039 + "4Is_Power_Of_2_For_Shift" &
7043 + "5Treat_Fixed_As_Integer4Do_Division_Check9Rounded_Result" &
7045 + "5Treat_Fixed_As_Integer4Do_Division_Check" &
7047 + "5Treat_Fixed_As_Integer9Rounded_Result" &
7049 + "5Treat_Fixed_As_Integer4Do_Division_Check" &
7051 + "+Do_Length_Check" &
7065 + "+Do_Length_Check" &
7067 + "+Do_Length_Check" &
7069 + "+Shift_Count_OK" &
7070 + -- Op_Rotate_Right
7071 + "+Shift_Count_OK" &
7073 + "+Shift_Count_OK" &
7075 + "+Shift_Count_OK" &
7076 + -- Op_Shift_Right_Arithmetic
7077 + "+Shift_Count_OK" &
7086 + -- Attribute_Reference
7087 + "%Prefix$Attribute_Name#Expressions&Entity&Associated_Node8Do_Overflow" &
7088 + "_Check4Redundant_Use+OK_For_Stream5Must_Be_Byte_Aligned" &
7091 + -- Conditional_Expression
7092 + "#Expressions$Then_Actions%Else_Actions" &
7093 + -- Explicit_Dereference
7096 + "$Name%Parameter_Associations&First_Named_Actual#Controlling_Argument4" &
7097 + "Do_Tag_Check5No_Elaboration_Check8Parameter_List_Truncated9ABE_Is_" &
7101 + -- Indexed_Component
7102 + "%Prefix#Expressions" &
7103 + -- Integer_Literal
7104 + "$Original_Entity%Intval4Print_In_Hex" &
7111 + -- Procedure_Call_Statement
7112 + "$Name%Parameter_Associations&First_Named_Actual#Controlling_Argument4" &
7113 + "Do_Tag_Check5No_Elaboration_Check8Parameter_List_Truncated9ABE_Is_" &
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" &
7124 + "#Expressions$Component_Associations8Null_Record_Present%Aggregate_Bou" &
7125 + "nds&Associated_Node+Static_Processing_OK9Compile_Time_Known_Aggreg" &
7126 + "ate2Expansion_Delayed" &
7128 + "%Expression#Storage_Pool&Procedure_To_Call4No_Initialization8Do_Stora" &
7130 + -- Extension_Aggregate
7131 + "%Ancestor_Part&Associated_Node#Expressions$Component_Associations8Nul" &
7132 + "l_Record_Present2Expansion_Delayed" &
7134 + "#Low_Bound$High_Bound2Includes_Infinities" &
7136 + "$Original_Entity%Realval&Corresponding_Integer_Value2Is_Machine_Numbe" &
7140 + -- Selected_Component
7141 + "%Prefix$Selector_Name&Associated_Node4Do_Discriminant_Check2Is_In_Dis" &
7142 + "criminant_Check" &
7144 + "%Prefix&Discrete_Range" &
7146 + "%Strval2Has_Wide_Character" &
7147 + -- Subprogram_Info
7149 + -- Type_Conversion
7150 + "&Subtype_Mark%Expression4Do_Tag_Check+Do_Length_Check8Do_Overflow_Che" &
7151 + "ck2Float_Truncate9Rounded_Result5Conversion_OK" &
7152 + -- Unchecked_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" &
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" &
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" &
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" &
7201 + -- Entry_Index_Specification
7202 + "#Defining_Identifier&Discrete_Subtype_Definition" &
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" &
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" &
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" &
7238 + "#Defining_Identifier$Declarations&End_Label'Corresponding_Spec4Was_Or" &
7241 + "#Defining_Identifier$Declarations&Handled_Statement_Sequence,Is_Task_" &
7242 + "Master%Activation_Chain_Entity'Corresponding_Spec4Was_Originally_S" &
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_" &
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" &
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
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" &
7294 + "%Expression&Alternatives'End_Span" &
7297 + -- Conditional_Entry_Call
7298 + "#Entry_Call_Alternative&Else_Statements" &
7299 + -- Delay_Relative_Statement
7301 + -- Delay_Until_Statement
7303 + -- Entry_Call_Statement
7304 + "$Name%Parameter_Associations&First_Named_Actual" &
7306 + "%Expression#Storage_Pool&Procedure_To_Call" &
7308 + "$Name2Exception_Junk" &
7310 + "#Identifier$Iteration_Scheme%Statements&End_Label6Has_Created_Identif" &
7311 + "ier7Is_Null_Loop" &
7314 + -- Raise_Statement
7316 + -- Requeue_Statement
7317 + "$Name6Abort_Present" &
7318 + -- Return_Statement
7319 + "%Expression#Storage_Pool&Procedure_To_Call4Do_Tag_Check$Return_Type,B" &
7321 + -- Selective_Accept
7322 + "#Select_Alternatives&Else_Statements" &
7323 + -- Timed_Entry_Call
7324 + "#Entry_Call_Alternative&Delay_Alternative" &
7326 + "$Name#Condition" &
7328 + "#Condition$Then_Statements%Elsif_Parts&Else_Statements'End_Span" &
7329 + -- Accept_Alternative
7330 + "$Accept_Statement#Condition%Statements&Pragmas_Before'Accept_Handler_" &
7332 + -- Delay_Alternative
7333 + "$Delay_Statement#Condition%Statements&Pragmas_Before" &
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" &
7344 + -- Abstract_Subprogram_Declaration
7345 + "#Specification" &
7346 + -- Access_Definition
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" &
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" &
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" &
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" &
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
7395 + -- Formal_Derived_Type_Definition
7396 + "&Subtype_Mark6Private_Present+Abstract_Present" &
7397 + -- Formal_Discrete_Type_Definition
7399 + -- Formal_Floating_Point_Definition
7401 + -- Formal_Modular_Type_Definition
7403 + -- Formal_Ordinary_Fixed_Point_Definition
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
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
7421 + -- Itype_Reference
7424 + "#Identifier2Exception_Junk" &
7425 + -- Modular_Type_Definition
7427 + -- Number_Declaration
7428 + "#Defining_Identifier%Expression,More_Ids-Prev_Ids" &
7429 + -- Ordinary_Fixed_Point_Definition
7430 + "%Delta_Expression&Real_Range_Specification" &
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" &
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" &
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" &
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" &
7468 + "&Discrete_Choices#Component_List$Enclosing_Variant%Present_Expr'Dchec" &
7471 + "$Name#Variants" &
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" &
7477 + -- With_Type_Clause
7478 + "$Name6Tagged_Present" &
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,
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,
7493 + N_Pragma_Argument_Association => 312,
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,
7503 + N_Op_Concat => 634,
7504 + N_Op_Expon => 681,
7505 + N_Op_Subtract => 705,
7506 + N_Op_Divide => 705,
7508 + N_Op_Multiply => 802,
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,
7525 + N_Op_Minus => 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,
7534 + N_Indexed_Component => 1323,
7535 + N_Integer_Literal => 1342,
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,
7548 + N_Real_Literal => 1980,
7549 + N_Reference => 2050,
7550 + N_Selected_Component => 2057,
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,
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);
projects / packages / gcc3.4.git / blob