OpenCores
URL https://opencores.org/ocsvn/scarts/scarts/trunk

Subversion Repositories scarts

[/] [scarts/] [trunk/] [toolchain/] [scarts-gcc/] [gcc-4.1.1/] [gcc/] [ada/] [sinfo.adb] - Blame information for rev 16

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 12 jlechner 
------------------------------------------------------------------------------
2 
--                                                                          --
3 
--                         GNAT COMPILER COMPONENTS                         --
4 
--                                                                          --
5 
--                                S I N F O                                 --
6 
--                                                                          --
7 
--                                 B o d y                                  --
8 
--                                                                          --
9 
--          Copyright (C) 1992-2005, Free Software Foundation, Inc.         --
10 
--                                                                          --
11 
-- GNAT is free software;  you can  redistribute it  and/or modify it under --
12 
-- terms of the  GNU General Public License as published  by the Free Soft- --
13 
-- ware  Foundation;  either version 2,  or (at your option) any later ver- --
14 
-- sion.  GNAT is distributed in the hope that it will be useful, but WITH- --
15 
-- OUT ANY WARRANTY;  without even the  implied warranty of MERCHANTABILITY --
16 
-- or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License --
17 
-- for  more details.  You should have  received  a copy of the GNU General --
18 
-- Public License  distributed with GNAT;  see file COPYING.  If not, write --
19 
-- to  the  Free Software Foundation,  51  Franklin  Street,  Fifth  Floor, --
20 
-- Boston, MA 02110-1301, USA.                                              --
21 
--                                                                          --
22 
-- As a special exception,  if other files  instantiate  generics from this --
23 
-- unit, or you link  this unit with other files  to produce an executable, --
24 
-- this  unit  does not  by itself cause  the resulting  executable  to  be --
25 
-- covered  by the  GNU  General  Public  License.  This exception does not --
26 
-- however invalidate  any other reasons why  the executable file  might be --
27 
-- covered by the  GNU Public License.                                      --
28 
--                                                                          --
29 
-- GNAT was originally developed  by the GNAT team at  New York University. --
30 
-- Extensive contributions were provided by Ada Core Technologies Inc.      --
31 
--                                                                          --
32 
------------------------------------------------------------------------------
33 
 
34 
pragma Style_Checks (All_Checks);
35 
--  No subprogram ordering check, due to logical grouping
36 
 
37 
with Atree; use Atree;
38 
 
39 
package body Sinfo is
40 
 
41 
   use Atree.Unchecked_Access;
42 
   --  This package is one of the few packages which is allowed to make direct
43 
   --  references to tree nodes (since it is in the business of providing a
44 
   --  higher level of tree access which other clients are expected to use and
45 
   --  which implements checks).
46 
 
47 
   use Atree_Private_Part;
48 
   --  The only reason that we ask for direct access to the private part of
49 
   --  the tree package is so that we can directly reference the Nkind field
50 
   --  of nodes table entries. We do this since it helps the efficiency of
51 
   --  the Sinfo debugging checks considerably (note that when we are checking
52 
   --  Nkind values, we don't need to check for a valid node reference, because
53 
   --  we will check that anyway when we reference the field).
54 
 
55 
   NT : Nodes.Table_Ptr renames Nodes.Table;
56 
   --  A short hand abbreviation, useful for the debugging checks
57 
 
58 
   ----------------------------
59 
   -- Field Access Functions --
60 
   ----------------------------
61 
 
62 
   function ABE_Is_Certain
63 
      (N : Node_Id) return Boolean is
64 
   begin
65 
      pragma Assert (False
66 
        or else NT (N).Nkind = N_Formal_Package_Declaration
67 
        or else NT (N).Nkind = N_Function_Call
68 
        or else NT (N).Nkind = N_Function_Instantiation
69 
        or else NT (N).Nkind = N_Package_Instantiation
70 
        or else NT (N).Nkind = N_Procedure_Call_Statement
71 
        or else NT (N).Nkind = N_Procedure_Instantiation);
72 
      return Flag18 (N);
73 
   end ABE_Is_Certain;
74 
 
75 
   function Abort_Present
76 
      (N : Node_Id) return Boolean is
77 
   begin
78 
      pragma Assert (False
79 
        or else NT (N).Nkind = N_Requeue_Statement);
80 
      return Flag15 (N);
81 
   end Abort_Present;
82 
 
83 
   function Abortable_Part
84 
      (N : Node_Id) return Node_Id is
85 
   begin
86 
      pragma Assert (False
87 
        or else NT (N).Nkind = N_Asynchronous_Select);
88 
      return Node2 (N);
89 
   end Abortable_Part;
90 
 
91 
   function Abstract_Present
92 
      (N : Node_Id) return Boolean is
93 
   begin
94 
      pragma Assert (False
95 
        or else NT (N).Nkind = N_Derived_Type_Definition
96 
        or else NT (N).Nkind = N_Formal_Derived_Type_Definition
97 
        or else NT (N).Nkind = N_Formal_Private_Type_Definition
98 
        or else NT (N).Nkind = N_Private_Extension_Declaration
99 
        or else NT (N).Nkind = N_Private_Type_Declaration
100 
        or else NT (N).Nkind = N_Record_Definition);
101 
      return Flag4 (N);
102 
   end Abstract_Present;
103 
 
104 
   function Accept_Handler_Records
105 
      (N : Node_Id) return List_Id is
106 
   begin
107 
      pragma Assert (False
108 
        or else NT (N).Nkind = N_Accept_Alternative);
109 
      return List5 (N);
110 
   end Accept_Handler_Records;
111 
 
112 
   function Accept_Statement
113 
      (N : Node_Id) return Node_Id is
114 
   begin
115 
      pragma Assert (False
116 
        or else NT (N).Nkind = N_Accept_Alternative);
117 
      return Node2 (N);
118 
   end Accept_Statement;
119 
 
120 
   function Access_Definition
121 
     (N : Node_Id) return Node_Id is
122 
   begin
123 
      pragma Assert (False
124 
        or else NT (N).Nkind = N_Component_Definition
125 
        or else NT (N).Nkind = N_Object_Renaming_Declaration);
126 
      return Node3 (N);
127 
   end Access_Definition;
128 
 
129 
   function Access_To_Subprogram_Definition
130 
     (N : Node_Id) return Node_Id is
131 
   begin
132 
      pragma Assert (False
133 
        or else NT (N).Nkind = N_Access_Definition);
134 
      return Node3 (N);
135 
   end Access_To_Subprogram_Definition;
136 
 
137 
   function Access_Types_To_Process
138 
      (N : Node_Id) return Elist_Id is
139 
   begin
140 
      pragma Assert (False
141 
        or else NT (N).Nkind = N_Freeze_Entity);
142 
      return Elist2 (N);
143 
   end Access_Types_To_Process;
144 
 
145 
   function Actions
146 
      (N : Node_Id) return List_Id is
147 
   begin
148 
      pragma Assert (False
149 
        or else NT (N).Nkind = N_And_Then
150 
        or else NT (N).Nkind = N_Compilation_Unit_Aux
151 
        or else NT (N).Nkind = N_Freeze_Entity
152 
        or else NT (N).Nkind = N_Or_Else);
153 
      return List1 (N);
154 
   end Actions;
155 
 
156 
   function Activation_Chain_Entity
157 
      (N : Node_Id) return Node_Id is
158 
   begin
159 
      pragma Assert (False
160 
        or else NT (N).Nkind = N_Block_Statement
161 
        or else NT (N).Nkind = N_Entry_Body
162 
        or else NT (N).Nkind = N_Generic_Package_Declaration
163 
        or else NT (N).Nkind = N_Package_Declaration
164 
        or else NT (N).Nkind = N_Subprogram_Body
165 
        or else NT (N).Nkind = N_Task_Body);
166 
      return Node3 (N);
167 
   end Activation_Chain_Entity;
168 
 
169 
   function Acts_As_Spec
170 
      (N : Node_Id) return Boolean is
171 
   begin
172 
      pragma Assert (False
173 
        or else NT (N).Nkind = N_Compilation_Unit
174 
        or else NT (N).Nkind = N_Subprogram_Body);
175 
      return Flag4 (N);
176 
   end Acts_As_Spec;
177 
 
178 
   function Actual_Designated_Subtype
179 
     (N : Node_Id) return Node_Id is
180 
   begin
181 
      pragma Assert (False
182 
        or else NT (N).Nkind = N_Explicit_Dereference
183 
        or else NT (N).Nkind = N_Free_Statement);
184 
      return Node2 (N);
185 
   end Actual_Designated_Subtype;
186 
 
187 
   function Aggregate_Bounds
188 
      (N : Node_Id) return Node_Id is
189 
   begin
190 
      pragma Assert (False
191 
        or else NT (N).Nkind = N_Aggregate);
192 
      return Node3 (N);
193 
   end Aggregate_Bounds;
194 
 
195 
   function Aliased_Present
196 
      (N : Node_Id) return Boolean is
197 
   begin
198 
      pragma Assert (False
199 
        or else NT (N).Nkind = N_Component_Definition
200 
        or else NT (N).Nkind = N_Object_Declaration);
201 
      return Flag4 (N);
202 
   end Aliased_Present;
203 
 
204 
   function All_Others
205 
      (N : Node_Id) return Boolean is
206 
   begin
207 
      pragma Assert (False
208 
        or else NT (N).Nkind = N_Others_Choice);
209 
      return Flag11 (N);
210 
   end All_Others;
211 
 
212 
   function All_Present
213 
      (N : Node_Id) return Boolean is
214 
   begin
215 
      pragma Assert (False
216 
        or else NT (N).Nkind = N_Access_Definition
217 
        or else NT (N).Nkind = N_Access_To_Object_Definition);
218 
      return Flag15 (N);
219 
   end All_Present;
220 
 
221 
   function Alternatives
222 
      (N : Node_Id) return List_Id is
223 
   begin
224 
      pragma Assert (False
225 
        or else NT (N).Nkind = N_Case_Statement);
226 
      return List4 (N);
227 
   end Alternatives;
228 
 
229 
   function Ancestor_Part
230 
      (N : Node_Id) return Node_Id is
231 
   begin
232 
      pragma Assert (False
233 
        or else NT (N).Nkind = N_Extension_Aggregate);
234 
      return Node3 (N);
235 
   end Ancestor_Part;
236 
 
237 
   function Array_Aggregate
238 
      (N : Node_Id) return Node_Id is
239 
   begin
240 
      pragma Assert (False
241 
        or else NT (N).Nkind = N_Enumeration_Representation_Clause);
242 
      return Node3 (N);
243 
   end Array_Aggregate;
244 
 
245 
   function Assignment_OK
246 
      (N : Node_Id) return Boolean is
247 
   begin
248 
      pragma Assert (False
249 
        or else NT (N).Nkind = N_Object_Declaration
250 
        or else NT (N).Nkind in N_Subexpr);
251 
      return Flag15 (N);
252 
   end Assignment_OK;
253 
 
254 
   function Associated_Node
255 
      (N : Node_Id) return Node_Id is
256 
   begin
257 
      pragma Assert (False
258 
        or else NT (N).Nkind in N_Has_Entity
259 
        or else NT (N).Nkind = N_Aggregate
260 
        or else NT (N).Nkind = N_Extension_Aggregate
261 
        or else NT (N).Nkind = N_Selected_Component);
262 
      return Node4 (N);
263 
   end Associated_Node;
264 
 
265 
   function At_End_Proc
266 
      (N : Node_Id) return Node_Id is
267 
   begin
268 
      pragma Assert (False
269 
        or else NT (N).Nkind = N_Handled_Sequence_Of_Statements);
270 
      return Node1 (N);
271 
   end At_End_Proc;
272 
 
273 
   function Attribute_Name
274 
      (N : Node_Id) return Name_Id is
275 
   begin
276 
      pragma Assert (False
277 
        or else NT (N).Nkind = N_Attribute_Reference);
278 
      return Name2 (N);
279 
   end Attribute_Name;
280 
 
281 
   function Aux_Decls_Node
282 
      (N : Node_Id) return Node_Id is
283 
   begin
284 
      pragma Assert (False
285 
        or else NT (N).Nkind = N_Compilation_Unit);
286 
      return Node5 (N);
287 
   end Aux_Decls_Node;
288 
 
289 
   function Backwards_OK
290 
      (N : Node_Id) return Boolean is
291 
   begin
292 
      pragma Assert (False
293 
        or else NT (N).Nkind = N_Assignment_Statement);
294 
      return Flag6 (N);
295 
   end Backwards_OK;
296 
 
297 
   function Bad_Is_Detected
298 
      (N : Node_Id) return Boolean is
299 
   begin
300 
      pragma Assert (False
301 
        or else NT (N).Nkind = N_Subprogram_Body);
302 
      return Flag15 (N);
303 
   end Bad_Is_Detected;
304 
 
305 
   function Body_Required
306 
      (N : Node_Id) return Boolean is
307 
   begin
308 
      pragma Assert (False
309 
        or else NT (N).Nkind = N_Compilation_Unit);
310 
      return Flag13 (N);
311 
   end Body_Required;
312 
 
313 
   function Body_To_Inline
314 
      (N : Node_Id) return Node_Id is
315 
   begin
316 
      pragma Assert (False
317 
        or else NT (N).Nkind = N_Subprogram_Declaration);
318 
      return Node3 (N);
319 
   end Body_To_Inline;
320 
 
321 
   function Box_Present
322 
      (N : Node_Id) return Boolean is
323 
   begin
324 
      pragma Assert (False
325 
        or else NT (N).Nkind = N_Component_Association
326 
        or else NT (N).Nkind = N_Formal_Abstract_Subprogram_Declaration
327 
        or else NT (N).Nkind = N_Formal_Concrete_Subprogram_Declaration
328 
        or else NT (N).Nkind = N_Formal_Package_Declaration);
329 
      return Flag15 (N);
330 
   end Box_Present;
331 
 
332 
   function By_Ref
333 
      (N : Node_Id) return Boolean is
334 
   begin
335 
      pragma Assert (False
336 
        or else NT (N).Nkind = N_Return_Statement);
337 
      return Flag5 (N);
338 
   end By_Ref;
339 
 
340 
   function Char_Literal_Value
341 
      (N : Node_Id) return Uint is
342 
   begin
343 
      pragma Assert (False
344 
        or else NT (N).Nkind = N_Character_Literal);
345 
      return Uint2 (N);
346 
   end Char_Literal_Value;
347 
 
348 
   function Chars
349 
      (N : Node_Id) return Name_Id is
350 
   begin
351 
      pragma Assert (False
352 
        or else NT (N).Nkind in N_Has_Chars);
353 
      return Name1 (N);
354 
   end Chars;
355 
 
356 
   function Check_Address_Alignment
357 
      (N : Node_Id) return Boolean is
358 
   begin
359 
      pragma Assert (False
360 
          or else NT (N).Nkind = N_Attribute_Definition_Clause);
361 
      return Flag11 (N);
362 
   end Check_Address_Alignment;
363 
 
364 
   function Choice_Parameter
365 
      (N : Node_Id) return Node_Id is
366 
   begin
367 
      pragma Assert (False
368 
        or else NT (N).Nkind = N_Exception_Handler);
369 
      return Node2 (N);
370 
   end Choice_Parameter;
371 
 
372 
   function Choices
373 
      (N : Node_Id) return List_Id is
374 
   begin
375 
      pragma Assert (False
376 
        or else NT (N).Nkind = N_Component_Association);
377 
      return List1 (N);
378 
   end Choices;
379 
 
380 
   function Compile_Time_Known_Aggregate
381 
      (N : Node_Id) return Boolean is
382 
   begin
383 
      pragma Assert (False
384 
        or else NT (N).Nkind = N_Aggregate);
385 
      return Flag18 (N);
386 
   end Compile_Time_Known_Aggregate;
387 
 
388 
   function Component_Associations
389 
      (N : Node_Id) return List_Id is
390 
   begin
391 
      pragma Assert (False
392 
        or else NT (N).Nkind = N_Aggregate
393 
        or else NT (N).Nkind = N_Extension_Aggregate);
394 
      return List2 (N);
395 
   end Component_Associations;
396 
 
397 
   function Component_Clauses
398 
      (N : Node_Id) return List_Id is
399 
   begin
400 
      pragma Assert (False
401 
        or else NT (N).Nkind = N_Record_Representation_Clause);
402 
      return List3 (N);
403 
   end Component_Clauses;
404 
 
405 
   function Component_Definition
406 
      (N : Node_Id) return Node_Id is
407 
   begin
408 
      pragma Assert (False
409 
        or else NT (N).Nkind = N_Component_Declaration
410 
        or else NT (N).Nkind = N_Constrained_Array_Definition
411 
        or else NT (N).Nkind = N_Unconstrained_Array_Definition);
412 
      return Node4 (N);
413 
   end Component_Definition;
414 
 
415 
   function Component_Items
416 
      (N : Node_Id) return List_Id is
417 
   begin
418 
      pragma Assert (False
419 
        or else NT (N).Nkind = N_Component_List);
420 
      return List3 (N);
421 
   end Component_Items;
422 
 
423 
   function Component_List
424 
      (N : Node_Id) return Node_Id is
425 
   begin
426 
      pragma Assert (False
427 
        or else NT (N).Nkind = N_Record_Definition
428 
        or else NT (N).Nkind = N_Variant);
429 
      return Node1 (N);
430 
   end Component_List;
431 
 
432 
   function Component_Name
433 
      (N : Node_Id) return Node_Id is
434 
   begin
435 
      pragma Assert (False
436 
        or else NT (N).Nkind = N_Component_Clause);
437 
      return Node1 (N);
438 
   end Component_Name;
439 
 
440 
   function Condition
441 
      (N : Node_Id) return Node_Id is
442 
   begin
443 
      pragma Assert (False
444 
        or else NT (N).Nkind = N_Accept_Alternative
445 
        or else NT (N).Nkind = N_Delay_Alternative
446 
        or else NT (N).Nkind = N_Elsif_Part
447 
        or else NT (N).Nkind = N_Entry_Body_Formal_Part
448 
        or else NT (N).Nkind = N_Exit_Statement
449 
        or else NT (N).Nkind = N_If_Statement
450 
        or else NT (N).Nkind = N_Iteration_Scheme
451 
        or else NT (N).Nkind = N_Raise_Constraint_Error
452 
        or else NT (N).Nkind = N_Raise_Program_Error
453 
        or else NT (N).Nkind = N_Raise_Storage_Error
454 
        or else NT (N).Nkind = N_Terminate_Alternative);
455 
      return Node1 (N);
456 
   end Condition;
457 
 
458 
   function Condition_Actions
459 
      (N : Node_Id) return List_Id is
460 
   begin
461 
      pragma Assert (False
462 
        or else NT (N).Nkind = N_Elsif_Part
463 
        or else NT (N).Nkind = N_Iteration_Scheme);
464 
      return List3 (N);
465 
   end Condition_Actions;
466 
 
467 
   function Config_Pragmas
468 
      (N : Node_Id) return List_Id is
469 
   begin
470 
      pragma Assert (False
471 
        or else NT (N).Nkind = N_Compilation_Unit_Aux);
472 
      return List4 (N);
473 
   end Config_Pragmas;
474 
 
475 
   function Constant_Present
476 
      (N : Node_Id) return Boolean is
477 
   begin
478 
      pragma Assert (False
479 
        or else NT (N).Nkind = N_Access_Definition
480 
        or else NT (N).Nkind = N_Access_To_Object_Definition
481 
        or else NT (N).Nkind = N_Object_Declaration);
482 
      return Flag17 (N);
483 
   end Constant_Present;
484 
 
485 
   function Constraint
486 
      (N : Node_Id) return Node_Id is
487 
   begin
488 
      pragma Assert (False
489 
        or else NT (N).Nkind = N_Subtype_Indication);
490 
      return Node3 (N);
491 
   end Constraint;
492 
 
493 
   function Constraints
494 
      (N : Node_Id) return List_Id is
495 
   begin
496 
      pragma Assert (False
497 
        or else NT (N).Nkind = N_Index_Or_Discriminant_Constraint);
498 
      return List1 (N);
499 
   end Constraints;
500 
 
501 
   function Context_Installed
502 
      (N : Node_Id) return Boolean is
503 
   begin
504 
      pragma Assert (False
505 
        or else NT (N).Nkind = N_With_Clause);
506 
      return Flag13 (N);
507 
   end Context_Installed;
508 
 
509 
   function Context_Items
510 
      (N : Node_Id) return List_Id is
511 
   begin
512 
      pragma Assert (False
513 
        or else NT (N).Nkind = N_Compilation_Unit);
514 
      return List1 (N);
515 
   end Context_Items;
516 
 
517 
   function Controlling_Argument
518 
      (N : Node_Id) return Node_Id is
519 
   begin
520 
      pragma Assert (False
521 
        or else NT (N).Nkind = N_Function_Call
522 
        or else NT (N).Nkind = N_Procedure_Call_Statement);
523 
      return Node1 (N);
524 
   end Controlling_Argument;
525 
 
526 
   function Conversion_OK
527 
      (N : Node_Id) return Boolean is
528 
   begin
529 
      pragma Assert (False
530 
        or else NT (N).Nkind = N_Type_Conversion);
531 
      return Flag14 (N);
532 
   end Conversion_OK;
533 
 
534 
   function Corresponding_Body
535 
      (N : Node_Id) return Node_Id is
536 
   begin
537 
      pragma Assert (False
538 
        or else NT (N).Nkind = N_Entry_Declaration
539 
        or else NT (N).Nkind = N_Generic_Package_Declaration
540 
        or else NT (N).Nkind = N_Generic_Subprogram_Declaration
541 
        or else NT (N).Nkind = N_Package_Body_Stub
542 
        or else NT (N).Nkind = N_Package_Declaration
543 
        or else NT (N).Nkind = N_Protected_Body_Stub
544 
        or else NT (N).Nkind = N_Protected_Type_Declaration
545 
        or else NT (N).Nkind = N_Subprogram_Body_Stub
546 
        or else NT (N).Nkind = N_Subprogram_Declaration
547 
        or else NT (N).Nkind = N_Task_Body_Stub
548 
        or else NT (N).Nkind = N_Task_Type_Declaration);
549 
      return Node5 (N);
550 
   end Corresponding_Body;
551 
 
552 
   function Corresponding_Formal_Spec
553 
      (N : Node_Id) return Node_Id is
554 
   begin
555 
      pragma Assert (False
556 
        or else NT (N).Nkind = N_Subprogram_Renaming_Declaration);
557 
      return Node3 (N);
558 
   end Corresponding_Formal_Spec;
559 
 
560 
   function Corresponding_Generic_Association
561 
      (N : Node_Id) return Node_Id is
562 
   begin
563 
      pragma Assert (False
564 
        or else NT (N).Nkind = N_Object_Declaration
565 
        or else NT (N).Nkind = N_Object_Renaming_Declaration);
566 
      return Node5 (N);
567 
   end Corresponding_Generic_Association;
568 
 
569 
   function Corresponding_Integer_Value
570 
      (N : Node_Id) return Uint is
571 
   begin
572 
      pragma Assert (False
573 
        or else NT (N).Nkind = N_Real_Literal);
574 
      return Uint4 (N);
575 
   end Corresponding_Integer_Value;
576 
 
577 
   function Corresponding_Spec
578 
      (N : Node_Id) return Node_Id is
579 
   begin
580 
      pragma Assert (False
581 
        or else NT (N).Nkind = N_Package_Body
582 
        or else NT (N).Nkind = N_Protected_Body
583 
        or else NT (N).Nkind = N_Subprogram_Body
584 
        or else NT (N).Nkind = N_Subprogram_Renaming_Declaration
585 
        or else NT (N).Nkind = N_Task_Body
586 
        or else NT (N).Nkind = N_With_Clause);
587 
      return Node5 (N);
588 
   end Corresponding_Spec;
589 
 
590 
   function Corresponding_Stub
591 
      (N : Node_Id) return Node_Id is
592 
   begin
593 
      pragma Assert (False
594 
        or else NT (N).Nkind = N_Subunit);
595 
      return Node3 (N);
596 
   end Corresponding_Stub;
597 
 
598 
   function Dcheck_Function
599 
      (N : Node_Id) return Entity_Id is
600 
   begin
601 
      pragma Assert (False
602 
        or else NT (N).Nkind = N_Variant);
603 
      return Node5 (N);
604 
   end Dcheck_Function;
605 
 
606 
   function Debug_Statement
607 
      (N : Node_Id) return Node_Id is
608 
   begin
609 
      pragma Assert (False
610 
        or else NT (N).Nkind = N_Pragma);
611 
      return Node3 (N);
612 
   end Debug_Statement;
613 
 
614 
   function Declarations
615 
      (N : Node_Id) return List_Id is
616 
   begin
617 
      pragma Assert (False
618 
        or else NT (N).Nkind = N_Accept_Statement
619 
        or else NT (N).Nkind = N_Block_Statement
620 
        or else NT (N).Nkind = N_Compilation_Unit_Aux
621 
        or else NT (N).Nkind = N_Entry_Body
622 
        or else NT (N).Nkind = N_Package_Body
623 
        or else NT (N).Nkind = N_Protected_Body
624 
        or else NT (N).Nkind = N_Subprogram_Body
625 
        or else NT (N).Nkind = N_Task_Body);
626 
      return List2 (N);
627 
   end Declarations;
628 
 
629 
   function Default_Expression
630 
      (N : Node_Id) return Node_Id is
631 
   begin
632 
      pragma Assert (False
633 
        or else NT (N).Nkind = N_Parameter_Specification);
634 
      return Node5 (N);
635 
   end Default_Expression;
636 
 
637 
   function Default_Name
638 
      (N : Node_Id) return Node_Id is
639 
   begin
640 
      pragma Assert (False
641 
        or else NT (N).Nkind = N_Formal_Abstract_Subprogram_Declaration
642 
        or else NT (N).Nkind = N_Formal_Concrete_Subprogram_Declaration);
643 
      return Node2 (N);
644 
   end Default_Name;
645 
 
646 
   function Defining_Identifier
647 
      (N : Node_Id) return Entity_Id is
648 
   begin
649 
      pragma Assert (False
650 
        or else NT (N).Nkind = N_Component_Declaration
651 
        or else NT (N).Nkind = N_Defining_Program_Unit_Name
652 
        or else NT (N).Nkind = N_Discriminant_Specification
653 
        or else NT (N).Nkind = N_Entry_Body
654 
        or else NT (N).Nkind = N_Entry_Declaration
655 
        or else NT (N).Nkind = N_Entry_Index_Specification
656 
        or else NT (N).Nkind = N_Exception_Declaration
657 
        or else NT (N).Nkind = N_Exception_Renaming_Declaration
658 
        or else NT (N).Nkind = N_Formal_Object_Declaration
659 
        or else NT (N).Nkind = N_Formal_Package_Declaration
660 
        or else NT (N).Nkind = N_Formal_Type_Declaration
661 
        or else NT (N).Nkind = N_Full_Type_Declaration
662 
        or else NT (N).Nkind = N_Implicit_Label_Declaration
663 
        or else NT (N).Nkind = N_Incomplete_Type_Declaration
664 
        or else NT (N).Nkind = N_Loop_Parameter_Specification
665 
        or else NT (N).Nkind = N_Number_Declaration
666 
        or else NT (N).Nkind = N_Object_Declaration
667 
        or else NT (N).Nkind = N_Object_Renaming_Declaration
668 
        or else NT (N).Nkind = N_Package_Body_Stub
669 
        or else NT (N).Nkind = N_Parameter_Specification
670 
        or else NT (N).Nkind = N_Private_Extension_Declaration
671 
        or else NT (N).Nkind = N_Private_Type_Declaration
672 
        or else NT (N).Nkind = N_Protected_Body
673 
        or else NT (N).Nkind = N_Protected_Body_Stub
674 
        or else NT (N).Nkind = N_Protected_Type_Declaration
675 
        or else NT (N).Nkind = N_Single_Protected_Declaration
676 
        or else NT (N).Nkind = N_Single_Task_Declaration
677 
        or else NT (N).Nkind = N_Subtype_Declaration
678 
        or else NT (N).Nkind = N_Task_Body
679 
        or else NT (N).Nkind = N_Task_Body_Stub
680 
        or else NT (N).Nkind = N_Task_Type_Declaration);
681 
      return Node1 (N);
682 
   end Defining_Identifier;
683 
 
684 
   function Defining_Unit_Name
685 
      (N : Node_Id) return Node_Id is
686 
   begin
687 
      pragma Assert (False
688 
        or else NT (N).Nkind = N_Function_Instantiation
689 
        or else NT (N).Nkind = N_Function_Specification
690 
        or else NT (N).Nkind = N_Generic_Function_Renaming_Declaration
691 
        or else NT (N).Nkind = N_Generic_Package_Renaming_Declaration
692 
        or else NT (N).Nkind = N_Generic_Procedure_Renaming_Declaration
693 
        or else NT (N).Nkind = N_Package_Body
694 
        or else NT (N).Nkind = N_Package_Instantiation
695 
        or else NT (N).Nkind = N_Package_Renaming_Declaration
696 
        or else NT (N).Nkind = N_Package_Specification
697 
        or else NT (N).Nkind = N_Procedure_Instantiation
698 
        or else NT (N).Nkind = N_Procedure_Specification);
699 
      return Node1 (N);
700 
   end Defining_Unit_Name;
701 
 
702 
   function Delay_Alternative
703 
      (N : Node_Id) return Node_Id is
704 
   begin
705 
      pragma Assert (False
706 
        or else NT (N).Nkind = N_Timed_Entry_Call);
707 
      return Node4 (N);
708 
   end Delay_Alternative;
709 
 
710 
   function Delay_Finalize_Attach
711 
      (N : Node_Id) return Boolean is
712 
   begin
713 
      pragma Assert (False
714 
        or else NT (N).Nkind = N_Object_Declaration);
715 
      return Flag14 (N);
716 
   end Delay_Finalize_Attach;
717 
 
718 
   function Delay_Statement
719 
      (N : Node_Id) return Node_Id is
720 
   begin
721 
      pragma Assert (False
722 
        or else NT (N).Nkind = N_Delay_Alternative);
723 
      return Node2 (N);
724 
   end Delay_Statement;
725 
 
726 
   function Delta_Expression
727 
      (N : Node_Id) return Node_Id is
728 
   begin
729 
      pragma Assert (False
730 
        or else NT (N).Nkind = N_Decimal_Fixed_Point_Definition
731 
        or else NT (N).Nkind = N_Delta_Constraint
732 
        or else NT (N).Nkind = N_Ordinary_Fixed_Point_Definition);
733 
      return Node3 (N);
734 
   end Delta_Expression;
735 
 
736 
   function Digits_Expression
737 
      (N : Node_Id) return Node_Id is
738 
   begin
739 
      pragma Assert (False
740 
        or else NT (N).Nkind = N_Decimal_Fixed_Point_Definition
741 
        or else NT (N).Nkind = N_Digits_Constraint
742 
        or else NT (N).Nkind = N_Floating_Point_Definition);
743 
      return Node2 (N);
744 
   end Digits_Expression;
745 
 
746 
   function Discr_Check_Funcs_Built
747 
      (N : Node_Id) return Boolean is
748 
   begin
749 
      pragma Assert (False
750 
        or else NT (N).Nkind = N_Full_Type_Declaration);
751 
      return Flag11 (N);
752 
   end Discr_Check_Funcs_Built;
753 
 
754 
   function Discrete_Choices
755 
      (N : Node_Id) return List_Id is
756 
   begin
757 
      pragma Assert (False
758 
        or else NT (N).Nkind = N_Case_Statement_Alternative
759 
        or else NT (N).Nkind = N_Variant);
760 
      return List4 (N);
761 
   end Discrete_Choices;
762 
 
763 
   function Discrete_Range
764 
      (N : Node_Id) return Node_Id is
765 
   begin
766 
      pragma Assert (False
767 
        or else NT (N).Nkind = N_Slice);
768 
      return Node4 (N);
769 
   end Discrete_Range;
770 
 
771 
   function Discrete_Subtype_Definition
772 
      (N : Node_Id) return Node_Id is
773 
   begin
774 
      pragma Assert (False
775 
        or else NT (N).Nkind = N_Entry_Declaration
776 
        or else NT (N).Nkind = N_Entry_Index_Specification
777 
        or else NT (N).Nkind = N_Loop_Parameter_Specification);
778 
      return Node4 (N);
779 
   end Discrete_Subtype_Definition;
780 
 
781 
   function Discrete_Subtype_Definitions
782 
      (N : Node_Id) return List_Id is
783 
   begin
784 
      pragma Assert (False
785 
        or else NT (N).Nkind = N_Constrained_Array_Definition);
786 
      return List2 (N);
787 
   end Discrete_Subtype_Definitions;
788 
 
789 
   function Discriminant_Specifications
790 
      (N : Node_Id) return List_Id is
791 
   begin
792 
      pragma Assert (False
793 
        or else NT (N).Nkind = N_Formal_Type_Declaration
794 
        or else NT (N).Nkind = N_Full_Type_Declaration
795 
        or else NT (N).Nkind = N_Incomplete_Type_Declaration
796 
        or else NT (N).Nkind = N_Private_Extension_Declaration
797 
        or else NT (N).Nkind = N_Private_Type_Declaration
798 
        or else NT (N).Nkind = N_Protected_Type_Declaration
799 
        or else NT (N).Nkind = N_Task_Type_Declaration);
800 
      return List4 (N);
801 
   end Discriminant_Specifications;
802 
 
803 
   function Discriminant_Type
804 
      (N : Node_Id) return Node_Id is
805 
   begin
806 
      pragma Assert (False
807 
        or else NT (N).Nkind = N_Discriminant_Specification);
808 
      return Node5 (N);
809 
   end Discriminant_Type;
810 
 
811 
   function Do_Accessibility_Check
812 
      (N : Node_Id) return Boolean is
813 
   begin
814 
      pragma Assert (False
815 
        or else NT (N).Nkind = N_Parameter_Specification);
816 
      return Flag13 (N);
817 
   end Do_Accessibility_Check;
818 
 
819 
   function Do_Discriminant_Check
820 
      (N : Node_Id) return Boolean is
821 
   begin
822 
      pragma Assert (False
823 
        or else NT (N).Nkind = N_Selected_Component);
824 
      return Flag13 (N);
825 
   end Do_Discriminant_Check;
826 
 
827 
   function Do_Division_Check
828 
      (N : Node_Id) return Boolean is
829 
   begin
830 
      pragma Assert (False
831 
        or else NT (N).Nkind = N_Op_Divide
832 
        or else NT (N).Nkind = N_Op_Mod
833 
        or else NT (N).Nkind = N_Op_Rem);
834 
      return Flag13 (N);
835 
   end Do_Division_Check;
836 
 
837 
   function Do_Length_Check
838 
      (N : Node_Id) return Boolean is
839 
   begin
840 
      pragma Assert (False
841 
        or else NT (N).Nkind = N_Assignment_Statement
842 
        or else NT (N).Nkind = N_Op_And
843 
        or else NT (N).Nkind = N_Op_Or
844 
        or else NT (N).Nkind = N_Op_Xor
845 
        or else NT (N).Nkind = N_Type_Conversion);
846 
      return Flag4 (N);
847 
   end Do_Length_Check;
848 
 
849 
   function Do_Overflow_Check
850 
      (N : Node_Id) return Boolean is
851 
   begin
852 
      pragma Assert (False
853 
        or else NT (N).Nkind in N_Op
854 
        or else NT (N).Nkind = N_Attribute_Reference
855 
        or else NT (N).Nkind = N_Type_Conversion);
856 
      return Flag17 (N);
857 
   end Do_Overflow_Check;
858 
 
859 
   function Do_Range_Check
860 
      (N : Node_Id) return Boolean is
861 
   begin
862 
      pragma Assert (False
863 
        or else NT (N).Nkind in N_Subexpr);
864 
      return Flag9 (N);
865 
   end Do_Range_Check;
866 
 
867 
   function Do_Storage_Check
868 
      (N : Node_Id) return Boolean is
869 
   begin
870 
      pragma Assert (False
871 
        or else NT (N).Nkind = N_Allocator
872 
        or else NT (N).Nkind = N_Subprogram_Body);
873 
      return Flag17 (N);
874 
   end Do_Storage_Check;
875 
 
876 
   function Do_Tag_Check
877 
      (N : Node_Id) return Boolean is
878 
   begin
879 
      pragma Assert (False
880 
        or else NT (N).Nkind = N_Assignment_Statement
881 
        or else NT (N).Nkind = N_Function_Call
882 
        or else NT (N).Nkind = N_Procedure_Call_Statement
883 
        or else NT (N).Nkind = N_Return_Statement
884 
        or else NT (N).Nkind = N_Type_Conversion);
885 
      return Flag13 (N);
886 
   end Do_Tag_Check;
887 
 
888 
   function Elaborate_All_Desirable
889 
      (N : Node_Id) return Boolean is
890 
   begin
891 
      pragma Assert (False
892 
        or else NT (N).Nkind = N_With_Clause);
893 
      return Flag9 (N);
894 
   end Elaborate_All_Desirable;
895 
 
896 
   function Elaborate_All_Present
897 
      (N : Node_Id) return Boolean is
898 
   begin
899 
      pragma Assert (False
900 
        or else NT (N).Nkind = N_With_Clause);
901 
      return Flag14 (N);
902 
   end Elaborate_All_Present;
903 
 
904 
   function Elaborate_Desirable
905 
      (N : Node_Id) return Boolean is
906 
   begin
907 
      pragma Assert (False
908 
        or else NT (N).Nkind = N_With_Clause);
909 
      return Flag11 (N);
910 
   end Elaborate_Desirable;
911 
 
912 
   function Elaborate_Present
913 
      (N : Node_Id) return Boolean is
914 
   begin
915 
      pragma Assert (False
916 
        or else NT (N).Nkind = N_With_Clause);
917 
      return Flag4 (N);
918 
   end Elaborate_Present;
919 
 
920 
   function Elaboration_Boolean
921 
      (N : Node_Id) return Node_Id is
922 
   begin
923 
      pragma Assert (False
924 
        or else NT (N).Nkind = N_Function_Specification
925 
        or else NT (N).Nkind = N_Procedure_Specification);
926 
      return Node2 (N);
927 
   end Elaboration_Boolean;
928 
 
929 
   function Else_Actions
930 
      (N : Node_Id) return List_Id is
931 
   begin
932 
      pragma Assert (False
933 
        or else NT (N).Nkind = N_Conditional_Expression);
934 
      return List3 (N);
935 
   end Else_Actions;
936 
 
937 
   function Else_Statements
938 
      (N : Node_Id) return List_Id is
939 
   begin
940 
      pragma Assert (False
941 
        or else NT (N).Nkind = N_Conditional_Entry_Call
942 
        or else NT (N).Nkind = N_If_Statement
943 
        or else NT (N).Nkind = N_Selective_Accept);
944 
      return List4 (N);
945 
   end Else_Statements;
946 
 
947 
   function Elsif_Parts
948 
      (N : Node_Id) return List_Id is
949 
   begin
950 
      pragma Assert (False
951 
        or else NT (N).Nkind = N_If_Statement);
952 
      return List3 (N);
953 
   end Elsif_Parts;
954 
 
955 
   function Enclosing_Variant
956 
      (N : Node_Id) return Node_Id is
957 
   begin
958 
      pragma Assert (False
959 
        or else NT (N).Nkind = N_Variant);
960 
      return Node2 (N);
961 
   end Enclosing_Variant;
962 
 
963 
   function End_Label
964 
      (N : Node_Id) return Node_Id is
965 
   begin
966 
      pragma Assert (False
967 
        or else NT (N).Nkind = N_Enumeration_Type_Definition
968 
        or else NT (N).Nkind = N_Handled_Sequence_Of_Statements
969 
        or else NT (N).Nkind = N_Loop_Statement
970 
        or else NT (N).Nkind = N_Package_Specification
971 
        or else NT (N).Nkind = N_Protected_Body
972 
        or else NT (N).Nkind = N_Protected_Definition
973 
        or else NT (N).Nkind = N_Record_Definition
974 
        or else NT (N).Nkind = N_Task_Definition);
975 
      return Node4 (N);
976 
   end End_Label;
977 
 
978 
   function End_Span
979 
      (N : Node_Id) return Uint is
980 
   begin
981 
      pragma Assert (False
982 
        or else NT (N).Nkind = N_Case_Statement
983 
        or else NT (N).Nkind = N_If_Statement);
984 
      return Uint5 (N);
985 
   end End_Span;
986 
 
987 
   function Entity
988 
      (N : Node_Id) return Node_Id is
989 
   begin
990 
      pragma Assert (False
991 
        or else NT (N).Nkind in N_Has_Entity
992 
        or else NT (N).Nkind = N_Freeze_Entity);
993 
      return Node4 (N);
994 
   end Entity;
995 
 
996 
   function Entity_Or_Associated_Node
997 
      (N : Node_Id) return Node_Id is
998 
   begin
999 
      pragma Assert (False
1000 
        or else NT (N).Nkind in N_Has_Entity
1001 
        or else NT (N).Nkind = N_Freeze_Entity);
1002 
      return Node4 (N);
1003 
   end Entity_Or_Associated_Node;
1004 
 
1005 
   function Entry_Body_Formal_Part
1006 
      (N : Node_Id) return Node_Id is
1007 
   begin
1008 
      pragma Assert (False
1009 
        or else NT (N).Nkind = N_Entry_Body);
1010 
      return Node5 (N);
1011 
   end Entry_Body_Formal_Part;
1012 
 
1013 
   function Entry_Call_Alternative
1014 
      (N : Node_Id) return Node_Id is
1015 
   begin
1016 
      pragma Assert (False
1017 
        or else NT (N).Nkind = N_Conditional_Entry_Call
1018 
        or else NT (N).Nkind = N_Timed_Entry_Call);
1019 
      return Node1 (N);
1020 
   end Entry_Call_Alternative;
1021 
 
1022 
   function Entry_Call_Statement
1023 
      (N : Node_Id) return Node_Id is
1024 
   begin
1025 
      pragma Assert (False
1026 
        or else NT (N).Nkind = N_Entry_Call_Alternative);
1027 
      return Node1 (N);
1028 
   end Entry_Call_Statement;
1029 
 
1030 
   function Entry_Direct_Name
1031 
      (N : Node_Id) return Node_Id is
1032 
   begin
1033 
      pragma Assert (False
1034 
        or else NT (N).Nkind = N_Accept_Statement);
1035 
      return Node1 (N);
1036 
   end Entry_Direct_Name;
1037 
 
1038 
   function Entry_Index
1039 
      (N : Node_Id) return Node_Id is
1040 
   begin
1041 
      pragma Assert (False
1042 
        or else NT (N).Nkind = N_Accept_Statement);
1043 
      return Node5 (N);
1044 
   end Entry_Index;
1045 
 
1046 
   function Entry_Index_Specification
1047 
      (N : Node_Id) return Node_Id is
1048 
   begin
1049 
      pragma Assert (False
1050 
        or else NT (N).Nkind = N_Entry_Body_Formal_Part);
1051 
      return Node4 (N);
1052 
   end Entry_Index_Specification;
1053 
 
1054 
   function Etype
1055 
      (N : Node_Id) return Node_Id is
1056 
   begin
1057 
      pragma Assert (False
1058 
        or else NT (N).Nkind in N_Has_Etype);
1059 
      return Node5 (N);
1060 
   end Etype;
1061 
 
1062 
   function Exception_Choices
1063 
      (N : Node_Id) return List_Id is
1064 
   begin
1065 
      pragma Assert (False
1066 
        or else NT (N).Nkind = N_Exception_Handler);
1067 
      return List4 (N);
1068 
   end Exception_Choices;
1069 
 
1070 
   function Exception_Handlers
1071 
      (N : Node_Id) return List_Id is
1072 
   begin
1073 
      pragma Assert (False
1074 
        or else NT (N).Nkind = N_Handled_Sequence_Of_Statements);
1075 
      return List5 (N);
1076 
   end Exception_Handlers;
1077 
 
1078 
   function Exception_Junk
1079 
     (N : Node_Id) return Boolean is
1080 
   begin
1081 
      pragma Assert (False
1082 
        or else NT (N).Nkind = N_Goto_Statement
1083 
        or else NT (N).Nkind = N_Label
1084 
        or else NT (N).Nkind = N_Object_Declaration
1085 
        or else NT (N).Nkind = N_Subtype_Declaration);
1086 
      return Flag7 (N);
1087 
   end Exception_Junk;
1088 
 
1089 
   function Expansion_Delayed
1090 
     (N : Node_Id) return Boolean is
1091 
   begin
1092 
      pragma Assert (False
1093 
        or else NT (N).Nkind = N_Aggregate
1094 
        or else NT (N).Nkind = N_Extension_Aggregate);
1095 
      return Flag11 (N);
1096 
   end Expansion_Delayed;
1097 
 
1098 
   function Explicit_Actual_Parameter
1099 
      (N : Node_Id) return Node_Id is
1100 
   begin
1101 
      pragma Assert (False
1102 
        or else NT (N).Nkind = N_Parameter_Association);
1103 
      return Node3 (N);
1104 
   end Explicit_Actual_Parameter;
1105 
 
1106 
   function Explicit_Generic_Actual_Parameter
1107 
      (N : Node_Id) return Node_Id is
1108 
   begin
1109 
      pragma Assert (False
1110 
        or else NT (N).Nkind = N_Generic_Association);
1111 
      return Node1 (N);
1112 
   end Explicit_Generic_Actual_Parameter;
1113 
 
1114 
   function Expression
1115 
      (N : Node_Id) return Node_Id is
1116 
   begin
1117 
      pragma Assert (False
1118 
        or else NT (N).Nkind = N_Allocator
1119 
        or else NT (N).Nkind = N_Assignment_Statement
1120 
        or else NT (N).Nkind = N_At_Clause
1121 
        or else NT (N).Nkind = N_Attribute_Definition_Clause
1122 
        or else NT (N).Nkind = N_Case_Statement
1123 
        or else NT (N).Nkind = N_Code_Statement
1124 
        or else NT (N).Nkind = N_Component_Association
1125 
        or else NT (N).Nkind = N_Component_Declaration
1126 
        or else NT (N).Nkind = N_Delay_Relative_Statement
1127 
        or else NT (N).Nkind = N_Delay_Until_Statement
1128 
        or else NT (N).Nkind = N_Discriminant_Association
1129 
        or else NT (N).Nkind = N_Discriminant_Specification
1130 
        or else NT (N).Nkind = N_Exception_Declaration
1131 
        or else NT (N).Nkind = N_Formal_Object_Declaration
1132 
        or else NT (N).Nkind = N_Free_Statement
1133 
        or else NT (N).Nkind = N_Mod_Clause
1134 
        or else NT (N).Nkind = N_Modular_Type_Definition
1135 
        or else NT (N).Nkind = N_Number_Declaration
1136 
        or else NT (N).Nkind = N_Object_Declaration
1137 
        or else NT (N).Nkind = N_Parameter_Specification
1138 
        or else NT (N).Nkind = N_Pragma_Argument_Association
1139 
        or else NT (N).Nkind = N_Qualified_Expression
1140 
        or else NT (N).Nkind = N_Raise_Statement
1141 
        or else NT (N).Nkind = N_Return_Statement
1142 
        or else NT (N).Nkind = N_Type_Conversion
1143 
        or else NT (N).Nkind = N_Unchecked_Expression
1144 
        or else NT (N).Nkind = N_Unchecked_Type_Conversion);
1145 
      return Node3 (N);
1146 
   end Expression;
1147 
 
1148 
   function Expressions
1149 
      (N : Node_Id) return List_Id is
1150 
   begin
1151 
      pragma Assert (False
1152 
        or else NT (N).Nkind = N_Aggregate
1153 
        or else NT (N).Nkind = N_Attribute_Reference
1154 
        or else NT (N).Nkind = N_Conditional_Expression
1155 
        or else NT (N).Nkind = N_Extension_Aggregate
1156 
        or else NT (N).Nkind = N_Indexed_Component);
1157 
      return List1 (N);
1158 
   end Expressions;
1159 
 
1160 
   function First_Bit
1161 
      (N : Node_Id) return Node_Id is
1162 
   begin
1163 
      pragma Assert (False
1164 
        or else NT (N).Nkind = N_Component_Clause);
1165 
      return Node3 (N);
1166 
   end First_Bit;
1167 
 
1168 
   function First_Inlined_Subprogram
1169 
      (N : Node_Id) return Entity_Id is
1170 
   begin
1171 
      pragma Assert (False
1172 
        or else NT (N).Nkind = N_Compilation_Unit);
1173 
      return Node3 (N);
1174 
   end First_Inlined_Subprogram;
1175 
 
1176 
   function First_Name
1177 
      (N : Node_Id) return Boolean is
1178 
   begin
1179 
      pragma Assert (False
1180 
        or else NT (N).Nkind = N_With_Clause);
1181 
      return Flag5 (N);
1182 
   end First_Name;
1183 
 
1184 
   function First_Named_Actual
1185 
      (N : Node_Id) return Node_Id is
1186 
   begin
1187 
      pragma Assert (False
1188 
        or else NT (N).Nkind = N_Entry_Call_Statement
1189 
        or else NT (N).Nkind = N_Function_Call
1190 
        or else NT (N).Nkind = N_Procedure_Call_Statement);
1191 
      return Node4 (N);
1192 
   end First_Named_Actual;
1193 
 
1194 
   function First_Real_Statement
1195 
      (N : Node_Id) return Node_Id is
1196 
   begin
1197 
      pragma Assert (False
1198 
        or else NT (N).Nkind = N_Handled_Sequence_Of_Statements);
1199 
      return Node2 (N);
1200 
   end First_Real_Statement;
1201 
 
1202 
   function First_Subtype_Link
1203 
      (N : Node_Id) return Entity_Id is
1204 
   begin
1205 
      pragma Assert (False
1206 
        or else NT (N).Nkind = N_Freeze_Entity);
1207 
      return Node5 (N);
1208 
   end First_Subtype_Link;
1209 
 
1210 
   function Float_Truncate
1211 
      (N : Node_Id) return Boolean is
1212 
   begin
1213 
      pragma Assert (False
1214 
        or else NT (N).Nkind = N_Type_Conversion);
1215 
      return Flag11 (N);
1216 
   end Float_Truncate;
1217 
 
1218 
   function Formal_Type_Definition
1219 
      (N : Node_Id) return Node_Id is
1220 
   begin
1221 
      pragma Assert (False
1222 
        or else NT (N).Nkind = N_Formal_Type_Declaration);
1223 
      return Node3 (N);
1224 
   end Formal_Type_Definition;
1225 
 
1226 
   function Forwards_OK
1227 
      (N : Node_Id) return Boolean is
1228 
   begin
1229 
      pragma Assert (False
1230 
        or else NT (N).Nkind = N_Assignment_Statement);
1231 
      return Flag5 (N);
1232 
   end Forwards_OK;
1233 
 
1234 
   function From_At_Mod
1235 
      (N : Node_Id) return Boolean is
1236 
   begin
1237 
      pragma Assert (False
1238 
        or else NT (N).Nkind = N_Attribute_Definition_Clause);
1239 
      return Flag4 (N);
1240 
   end From_At_Mod;
1241 
 
1242 
   function From_Default
1243 
      (N : Node_Id) return Boolean is
1244 
   begin
1245 
      pragma Assert (False
1246 
        or else NT (N).Nkind = N_Subprogram_Renaming_Declaration);
1247 
      return Flag6 (N);
1248 
   end From_Default;
1249 
 
1250 
   function Generic_Associations
1251 
      (N : Node_Id) return List_Id is
1252 
   begin
1253 
      pragma Assert (False
1254 
        or else NT (N).Nkind = N_Formal_Package_Declaration
1255 
        or else NT (N).Nkind = N_Function_Instantiation
1256 
        or else NT (N).Nkind = N_Package_Instantiation
1257 
        or else NT (N).Nkind = N_Procedure_Instantiation);
1258 
      return List3 (N);
1259 
   end Generic_Associations;
1260 
 
1261 
   function Generic_Formal_Declarations
1262 
      (N : Node_Id) return List_Id is
1263 
   begin
1264 
      pragma Assert (False
1265 
        or else NT (N).Nkind = N_Generic_Package_Declaration
1266 
        or else NT (N).Nkind = N_Generic_Subprogram_Declaration);
1267 
      return List2 (N);
1268 
   end Generic_Formal_Declarations;
1269 
 
1270 
   function Generic_Parent
1271 
      (N : Node_Id) return Node_Id is
1272 
   begin
1273 
      pragma Assert (False
1274 
        or else NT (N).Nkind = N_Function_Specification
1275 
        or else NT (N).Nkind = N_Package_Specification
1276 
        or else NT (N).Nkind = N_Procedure_Specification);
1277 
      return Node5 (N);
1278 
   end Generic_Parent;
1279 
 
1280 
   function Generic_Parent_Type
1281 
      (N : Node_Id) return Node_Id is
1282 
   begin
1283 
      pragma Assert (False
1284 
        or else NT (N).Nkind = N_Subtype_Declaration);
1285 
      return Node4 (N);
1286 
   end Generic_Parent_Type;
1287 
 
1288 
   function Handled_Statement_Sequence
1289 
      (N : Node_Id) return Node_Id is
1290 
   begin
1291 
      pragma Assert (False
1292 
        or else NT (N).Nkind = N_Accept_Statement
1293 
        or else NT (N).Nkind = N_Block_Statement
1294 
        or else NT (N).Nkind = N_Entry_Body
1295 
        or else NT (N).Nkind = N_Package_Body
1296 
        or else NT (N).Nkind = N_Subprogram_Body
1297 
        or else NT (N).Nkind = N_Task_Body);
1298 
      return Node4 (N);
1299 
   end Handled_Statement_Sequence;
1300 
 
1301 
   function Handler_List_Entry
1302 
      (N : Node_Id) return Node_Id is
1303 
   begin
1304 
      pragma Assert (False
1305 
        or else NT (N).Nkind = N_Object_Declaration);
1306 
      return Node2 (N);
1307 
   end Handler_List_Entry;
1308 
 
1309 
   function Has_Created_Identifier
1310 
      (N : Node_Id) return Boolean is
1311 
   begin
1312 
      pragma Assert (False
1313 
        or else NT (N).Nkind = N_Block_Statement
1314 
        or else NT (N).Nkind = N_Loop_Statement);
1315 
      return Flag15 (N);
1316 
   end Has_Created_Identifier;
1317 
 
1318 
   function Has_Dynamic_Length_Check
1319 
      (N : Node_Id) return Boolean is
1320 
   begin
1321 
      return Flag10 (N);
1322 
   end Has_Dynamic_Length_Check;
1323 
 
1324 
   function Has_Dynamic_Range_Check
1325 
      (N : Node_Id) return Boolean is
1326 
   begin
1327 
      return Flag12 (N);
1328 
   end Has_Dynamic_Range_Check;
1329 
 
1330 
   function Has_No_Elaboration_Code
1331 
      (N : Node_Id) return Boolean is
1332 
   begin
1333 
      pragma Assert (False
1334 
        or else NT (N).Nkind = N_Compilation_Unit);
1335 
      return Flag17 (N);
1336 
   end Has_No_Elaboration_Code;
1337 
 
1338 
   function Has_Priority_Pragma
1339 
      (N : Node_Id) return Boolean is
1340 
   begin
1341 
      pragma Assert (False
1342 
        or else NT (N).Nkind = N_Protected_Definition
1343 
        or else NT (N).Nkind = N_Subprogram_Body
1344 
        or else NT (N).Nkind = N_Task_Definition);
1345 
      return Flag6 (N);
1346 
   end Has_Priority_Pragma;
1347 
 
1348 
   function Has_Private_View
1349 
      (N : Node_Id) return Boolean is
1350 
   begin
1351 
      pragma Assert (False
1352 
       or else NT (N).Nkind in N_Op
1353 
       or else NT (N).Nkind = N_Character_Literal
1354 
       or else NT (N).Nkind = N_Expanded_Name
1355 
       or else NT (N).Nkind = N_Identifier
1356 
       or else NT (N).Nkind = N_Operator_Symbol);
1357 
      return Flag11 (N);
1358 
   end Has_Private_View;
1359 
 
1360 
   function Has_Storage_Size_Pragma
1361 
      (N : Node_Id) return Boolean is
1362 
   begin
1363 
      pragma Assert (False
1364 
        or else NT (N).Nkind = N_Task_Definition);
1365 
      return Flag5 (N);
1366 
   end Has_Storage_Size_Pragma;
1367 
 
1368 
   function Has_Task_Info_Pragma
1369 
      (N : Node_Id) return Boolean is
1370 
   begin
1371 
      pragma Assert (False
1372 
        or else NT (N).Nkind = N_Task_Definition);
1373 
      return Flag7 (N);
1374 
   end Has_Task_Info_Pragma;
1375 
 
1376 
   function Has_Task_Name_Pragma
1377 
      (N : Node_Id) return Boolean is
1378 
   begin
1379 
      pragma Assert (False
1380 
        or else NT (N).Nkind = N_Task_Definition);
1381 
      return Flag8 (N);
1382 
   end Has_Task_Name_Pragma;
1383 
 
1384 
   function Has_Wide_Character
1385 
      (N : Node_Id) return Boolean is
1386 
   begin
1387 
      pragma Assert (False
1388 
        or else NT (N).Nkind = N_String_Literal);
1389 
      return Flag11 (N);
1390 
   end Has_Wide_Character;
1391 
 
1392 
   function Hidden_By_Use_Clause
1393 
     (N : Node_Id) return Elist_Id is
1394 
   begin
1395 
      pragma Assert (False
1396 
        or else NT (N).Nkind = N_Use_Package_Clause
1397 
        or else NT (N).Nkind = N_Use_Type_Clause);
1398 
      return Elist4 (N);
1399 
   end Hidden_By_Use_Clause;
1400 
 
1401 
   function High_Bound
1402 
      (N : Node_Id) return Node_Id is
1403 
   begin
1404 
      pragma Assert (False
1405 
        or else NT (N).Nkind = N_Range
1406 
        or else NT (N).Nkind = N_Real_Range_Specification
1407 
        or else NT (N).Nkind = N_Signed_Integer_Type_Definition);
1408 
      return Node2 (N);
1409 
   end High_Bound;
1410 
 
1411 
   function Identifier
1412 
      (N : Node_Id) return Node_Id is
1413 
   begin
1414 
      pragma Assert (False
1415 
        or else NT (N).Nkind = N_At_Clause
1416 
        or else NT (N).Nkind = N_Block_Statement
1417 
        or else NT (N).Nkind = N_Designator
1418 
        or else NT (N).Nkind = N_Enumeration_Representation_Clause
1419 
        or else NT (N).Nkind = N_Label
1420 
        or else NT (N).Nkind = N_Loop_Statement
1421 
        or else NT (N).Nkind = N_Record_Representation_Clause
1422 
        or else NT (N).Nkind = N_Subprogram_Info);
1423 
      return Node1 (N);
1424 
   end Identifier;
1425 
 
1426 
   function Implicit_With
1427 
      (N : Node_Id) return Boolean is
1428 
   begin
1429 
      pragma Assert (False
1430 
        or else NT (N).Nkind = N_With_Clause);
1431 
      return Flag16 (N);
1432 
   end Implicit_With;
1433 
 
1434 
   function Interface_List
1435 
      (N : Node_Id) return List_Id is
1436 
   begin
1437 
      pragma Assert (False
1438 
        or else NT (N).Nkind = N_Derived_Type_Definition
1439 
        or else NT (N).Nkind = N_Formal_Derived_Type_Definition
1440 
        or else NT (N).Nkind = N_Private_Extension_Declaration
1441 
        or else NT (N).Nkind = N_Protected_Type_Declaration
1442 
        or else NT (N).Nkind = N_Record_Definition
1443 
        or else NT (N).Nkind = N_Single_Protected_Declaration
1444 
        or else NT (N).Nkind = N_Single_Task_Declaration
1445 
        or else NT (N).Nkind = N_Task_Type_Declaration);
1446 
      return List2 (N);
1447 
   end Interface_List;
1448 
 
1449 
   function Interface_Present
1450 
      (N : Node_Id) return Boolean is
1451 
   begin
1452 
      pragma Assert (False
1453 
        or else NT (N).Nkind = N_Derived_Type_Definition
1454 
        or else NT (N).Nkind = N_Record_Definition);
1455 
      return Flag16 (N);
1456 
   end Interface_Present;
1457 
 
1458 
   function In_Present
1459 
      (N : Node_Id) return Boolean is
1460 
   begin
1461 
      pragma Assert (False
1462 
        or else NT (N).Nkind = N_Formal_Object_Declaration
1463 
        or else NT (N).Nkind = N_Parameter_Specification);
1464 
      return Flag15 (N);
1465 
   end In_Present;
1466 
 
1467 
   function Includes_Infinities
1468 
      (N : Node_Id) return Boolean is
1469 
   begin
1470 
      pragma Assert (False
1471 
        or else NT (N).Nkind = N_Range);
1472 
      return Flag11 (N);
1473 
   end Includes_Infinities;
1474 
 
1475 
   function Instance_Spec
1476 
      (N : Node_Id) return Node_Id is
1477 
   begin
1478 
      pragma Assert (False
1479 
        or else NT (N).Nkind = N_Formal_Package_Declaration
1480 
        or else NT (N).Nkind = N_Function_Instantiation
1481 
        or else NT (N).Nkind = N_Package_Instantiation
1482 
        or else NT (N).Nkind = N_Procedure_Instantiation);
1483 
      return Node5 (N);
1484 
   end Instance_Spec;
1485 
 
1486 
   function Intval
1487 
      (N : Node_Id) return Uint is
1488 
   begin
1489 
      pragma Assert (False
1490 
        or else NT (N).Nkind = N_Integer_Literal);
1491 
      return Uint3 (N);
1492 
   end Intval;
1493 
 
1494 
   function Is_Asynchronous_Call_Block
1495 
      (N : Node_Id) return Boolean is
1496 
   begin
1497 
      pragma Assert (False
1498 
        or else NT (N).Nkind = N_Block_Statement);
1499 
      return Flag7 (N);
1500 
   end Is_Asynchronous_Call_Block;
1501 
 
1502 
   function Is_Component_Left_Opnd
1503 
      (N : Node_Id) return Boolean is
1504 
   begin
1505 
      pragma Assert (False
1506 
        or else NT (N).Nkind = N_Op_Concat);
1507 
      return Flag13 (N);
1508 
   end Is_Component_Left_Opnd;
1509 
 
1510 
   function Is_Component_Right_Opnd
1511 
      (N : Node_Id) return Boolean is
1512 
   begin
1513 
      pragma Assert (False
1514 
        or else NT (N).Nkind = N_Op_Concat);
1515 
      return Flag14 (N);
1516 
   end Is_Component_Right_Opnd;
1517 
 
1518 
   function Is_Controlling_Actual
1519 
      (N : Node_Id) return Boolean is
1520 
   begin
1521 
      pragma Assert (False
1522 
        or else NT (N).Nkind in N_Subexpr);
1523 
      return Flag16 (N);
1524 
   end Is_Controlling_Actual;
1525 
 
1526 
   function Is_In_Discriminant_Check
1527 
      (N : Node_Id) return Boolean is
1528 
   begin
1529 
      pragma Assert (False
1530 
        or else NT (N).Nkind = N_Selected_Component);
1531 
      return Flag11 (N);
1532 
   end Is_In_Discriminant_Check;
1533 
 
1534 
   function Is_Machine_Number
1535 
      (N : Node_Id) return Boolean is
1536 
   begin
1537 
      pragma Assert (False
1538 
        or else NT (N).Nkind = N_Real_Literal);
1539 
      return Flag11 (N);
1540 
   end Is_Machine_Number;
1541 
 
1542 
   function Is_Null_Loop
1543 
      (N : Node_Id) return Boolean is
1544 
   begin
1545 
      pragma Assert (False
1546 
        or else NT (N).Nkind = N_Loop_Statement);
1547 
      return Flag16 (N);
1548 
   end Is_Null_Loop;
1549 
 
1550 
   function Is_Overloaded
1551 
      (N : Node_Id) return Boolean is
1552 
   begin
1553 
      pragma Assert (False
1554 
        or else NT (N).Nkind in N_Subexpr);
1555 
      return Flag5 (N);
1556 
   end Is_Overloaded;
1557 
 
1558 
   function Is_Power_Of_2_For_Shift
1559 
      (N : Node_Id) return Boolean is
1560 
   begin
1561 
      pragma Assert (False
1562 
        or else NT (N).Nkind = N_Op_Expon);
1563 
      return Flag13 (N);
1564 
   end Is_Power_Of_2_For_Shift;
1565 
 
1566 
   function Is_Protected_Subprogram_Body
1567 
      (N : Node_Id) return Boolean is
1568 
   begin
1569 
      pragma Assert (False
1570 
        or else NT (N).Nkind = N_Subprogram_Body);
1571 
      return Flag7 (N);
1572 
   end Is_Protected_Subprogram_Body;
1573 
 
1574 
   function Is_Static_Expression
1575 
      (N : Node_Id) return Boolean is
1576 
   begin
1577 
      pragma Assert (False
1578 
        or else NT (N).Nkind in N_Subexpr);
1579 
      return Flag6 (N);
1580 
   end Is_Static_Expression;
1581 
 
1582 
   function Is_Subprogram_Descriptor
1583 
      (N : Node_Id) return Boolean is
1584 
   begin
1585 
      pragma Assert (False
1586 
        or else NT (N).Nkind = N_Object_Declaration);
1587 
      return Flag16 (N);
1588 
   end Is_Subprogram_Descriptor;
1589 
 
1590 
   function Is_Task_Allocation_Block
1591 
      (N : Node_Id) return Boolean is
1592 
   begin
1593 
      pragma Assert (False
1594 
        or else NT (N).Nkind = N_Block_Statement);
1595 
      return Flag6 (N);
1596 
   end Is_Task_Allocation_Block;
1597 
 
1598 
   function Is_Task_Master
1599 
      (N : Node_Id) return Boolean is
1600 
   begin
1601 
      pragma Assert (False
1602 
        or else NT (N).Nkind = N_Block_Statement
1603 
        or else NT (N).Nkind = N_Subprogram_Body
1604 
        or else NT (N).Nkind = N_Task_Body);
1605 
      return Flag5 (N);
1606 
   end Is_Task_Master;
1607 
 
1608 
   function Iteration_Scheme
1609 
      (N : Node_Id) return Node_Id is
1610 
   begin
1611 
      pragma Assert (False
1612 
        or else NT (N).Nkind = N_Loop_Statement);
1613 
      return Node2 (N);
1614 
   end Iteration_Scheme;
1615 
 
1616 
   function Itype
1617 
      (N : Node_Id) return Node_Id is
1618 
   begin
1619 
      pragma Assert (False
1620 
      or else NT (N).Nkind = N_Itype_Reference);
1621 
      return Node1 (N);
1622 
   end Itype;
1623 
 
1624 
   function Kill_Range_Check
1625 
      (N : Node_Id) return Boolean is
1626 
   begin
1627 
      pragma Assert (False
1628 
        or else NT (N).Nkind = N_Unchecked_Type_Conversion);
1629 
      return Flag11 (N);
1630 
   end Kill_Range_Check;
1631 
 
1632 
   function Label_Construct
1633 
      (N : Node_Id) return Node_Id is
1634 
   begin
1635 
      pragma Assert (False
1636 
        or else NT (N).Nkind = N_Implicit_Label_Declaration);
1637 
      return Node2 (N);
1638 
   end Label_Construct;
1639 
 
1640 
   function Last_Bit
1641 
      (N : Node_Id) return Node_Id is
1642 
   begin
1643 
      pragma Assert (False
1644 
        or else NT (N).Nkind = N_Component_Clause);
1645 
      return Node4 (N);
1646 
   end Last_Bit;
1647 
 
1648 
   function Last_Name
1649 
      (N : Node_Id) return Boolean is
1650 
   begin
1651 
      pragma Assert (False
1652 
        or else NT (N).Nkind = N_With_Clause);
1653 
      return Flag6 (N);
1654 
   end Last_Name;
1655 
 
1656 
   function Left_Opnd
1657 
      (N : Node_Id) return Node_Id is
1658 
   begin
1659 
      pragma Assert (False
1660 
        or else NT (N).Nkind = N_And_Then
1661 
        or else NT (N).Nkind = N_In
1662 
        or else NT (N).Nkind = N_Not_In
1663 
        or else NT (N).Nkind = N_Or_Else
1664 
        or else NT (N).Nkind in N_Binary_Op);
1665 
      return Node2 (N);
1666 
   end Left_Opnd;
1667 
 
1668 
   function Library_Unit
1669 
      (N : Node_Id) return Node_Id is
1670 
   begin
1671 
      pragma Assert (False
1672 
        or else NT (N).Nkind = N_Compilation_Unit
1673 
        or else NT (N).Nkind = N_Package_Body_Stub
1674 
        or else NT (N).Nkind = N_Protected_Body_Stub
1675 
        or else NT (N).Nkind = N_Subprogram_Body_Stub
1676 
        or else NT (N).Nkind = N_Task_Body_Stub
1677 
        or else NT (N).Nkind = N_With_Clause);
1678 
      return Node4 (N);
1679 
   end Library_Unit;
1680 
 
1681 
   function Limited_View_Installed
1682 
      (N : Node_Id) return Boolean is
1683 
   begin
1684 
      pragma Assert (False
1685 
        or else NT (N).Nkind = N_Package_Specification
1686 
        or else NT (N).Nkind = N_With_Clause);
1687 
      return Flag18 (N);
1688 
   end Limited_View_Installed;
1689 
 
1690 
   function Limited_Present
1691 
      (N : Node_Id) return Boolean is
1692 
   begin
1693 
      pragma Assert (False
1694 
        or else NT (N).Nkind = N_Derived_Type_Definition
1695 
        or else NT (N).Nkind = N_Formal_Private_Type_Definition
1696 
        or else NT (N).Nkind = N_Private_Extension_Declaration
1697 
        or else NT (N).Nkind = N_Private_Type_Declaration
1698 
        or else NT (N).Nkind = N_Record_Definition
1699 
        or else NT (N).Nkind = N_With_Clause);
1700 
      return Flag17 (N);
1701 
   end Limited_Present;
1702 
 
1703 
   function Literals
1704 
      (N : Node_Id) return List_Id is
1705 
   begin
1706 
      pragma Assert (False
1707 
        or else NT (N).Nkind = N_Enumeration_Type_Definition);
1708 
      return List1 (N);
1709 
   end Literals;
1710 
 
1711 
   function Loop_Actions
1712 
      (N : Node_Id) return List_Id is
1713 
   begin
1714 
      pragma Assert (False
1715 
        or else NT (N).Nkind = N_Component_Association);
1716 
      return List2 (N);
1717 
   end Loop_Actions;
1718 
 
1719 
   function Loop_Parameter_Specification
1720 
      (N : Node_Id) return Node_Id is
1721 
   begin
1722 
      pragma Assert (False
1723 
        or else NT (N).Nkind = N_Iteration_Scheme);
1724 
      return Node4 (N);
1725 
   end Loop_Parameter_Specification;
1726 
 
1727 
   function Low_Bound
1728 
      (N : Node_Id) return Node_Id is
1729 
   begin
1730 
      pragma Assert (False
1731 
        or else NT (N).Nkind = N_Range
1732 
        or else NT (N).Nkind = N_Real_Range_Specification
1733 
        or else NT (N).Nkind = N_Signed_Integer_Type_Definition);
1734 
      return Node1 (N);
1735 
   end Low_Bound;
1736 
 
1737 
   function Mod_Clause
1738 
      (N : Node_Id) return Node_Id is
1739 
   begin
1740 
      pragma Assert (False
1741 
        or else NT (N).Nkind = N_Record_Representation_Clause);
1742 
      return Node2 (N);
1743 
   end Mod_Clause;
1744 
 
1745 
   function More_Ids
1746 
      (N : Node_Id) return Boolean is
1747 
   begin
1748 
      pragma Assert (False
1749 
        or else NT (N).Nkind = N_Component_Declaration
1750 
        or else NT (N).Nkind = N_Discriminant_Specification
1751 
        or else NT (N).Nkind = N_Exception_Declaration
1752 
        or else NT (N).Nkind = N_Formal_Object_Declaration
1753 
        or else NT (N).Nkind = N_Number_Declaration
1754 
        or else NT (N).Nkind = N_Object_Declaration
1755 
        or else NT (N).Nkind = N_Parameter_Specification);
1756 
      return Flag5 (N);
1757 
   end More_Ids;
1758 
 
1759 
   function Must_Be_Byte_Aligned
1760 
      (N : Node_Id) return Boolean is
1761 
   begin
1762 
      pragma Assert (False
1763 
        or else NT (N).Nkind = N_Attribute_Reference);
1764 
      return Flag14 (N);
1765 
   end Must_Be_Byte_Aligned;
1766 
 
1767 
   function Must_Not_Freeze
1768 
      (N : Node_Id) return Boolean is
1769 
   begin
1770 
      pragma Assert (False
1771 
        or else NT (N).Nkind = N_Subtype_Indication
1772 
        or else NT (N).Nkind in N_Subexpr);
1773 
      return Flag8 (N);
1774 
   end Must_Not_Freeze;
1775 
 
1776 
   function Must_Not_Override
1777 
      (N : Node_Id) return Boolean is
1778 
   begin
1779 
      pragma Assert (False
1780 
        or else NT (N).Nkind = N_Entry_Declaration
1781 
        or else NT (N).Nkind = N_Function_Instantiation
1782 
        or else NT (N).Nkind = N_Function_Specification
1783 
        or else NT (N).Nkind = N_Procedure_Instantiation
1784 
        or else NT (N).Nkind = N_Procedure_Specification);
1785 
      return Flag15 (N);
1786 
   end Must_Not_Override;
1787 
 
1788 
   function Must_Override
1789 
      (N : Node_Id) return Boolean is
1790 
   begin
1791 
      pragma Assert (False
1792 
        or else NT (N).Nkind = N_Entry_Declaration
1793 
        or else NT (N).Nkind = N_Function_Instantiation
1794 
        or else NT (N).Nkind = N_Function_Specification
1795 
        or else NT (N).Nkind = N_Procedure_Instantiation
1796 
        or else NT (N).Nkind = N_Procedure_Specification);
1797 
      return Flag14 (N);
1798 
   end Must_Override;
1799 
 
1800 
   function Name
1801 
      (N : Node_Id) return Node_Id is
1802 
   begin
1803 
      pragma Assert (False
1804 
        or else NT (N).Nkind = N_Assignment_Statement
1805 
        or else NT (N).Nkind = N_Attribute_Definition_Clause
1806 
        or else NT (N).Nkind = N_Defining_Program_Unit_Name
1807 
        or else NT (N).Nkind = N_Designator
1808 
        or else NT (N).Nkind = N_Entry_Call_Statement
1809 
        or else NT (N).Nkind = N_Exception_Renaming_Declaration
1810 
        or else NT (N).Nkind = N_Exit_Statement
1811 
        or else NT (N).Nkind = N_Formal_Package_Declaration
1812 
        or else NT (N).Nkind = N_Function_Call
1813 
        or else NT (N).Nkind = N_Function_Instantiation
1814 
        or else NT (N).Nkind = N_Generic_Function_Renaming_Declaration
1815 
        or else NT (N).Nkind = N_Generic_Package_Renaming_Declaration
1816 
        or else NT (N).Nkind = N_Generic_Procedure_Renaming_Declaration
1817 
        or else NT (N).Nkind = N_Goto_Statement
1818 
        or else NT (N).Nkind = N_Object_Renaming_Declaration
1819 
        or else NT (N).Nkind = N_Package_Instantiation
1820 
        or else NT (N).Nkind = N_Package_Renaming_Declaration
1821 
        or else NT (N).Nkind = N_Procedure_Call_Statement
1822 
        or else NT (N).Nkind = N_Procedure_Instantiation
1823 
        or else NT (N).Nkind = N_Raise_Statement
1824 
        or else NT (N).Nkind = N_Requeue_Statement
1825 
        or else NT (N).Nkind = N_Subprogram_Renaming_Declaration
1826 
        or else NT (N).Nkind = N_Subunit
1827 
        or else NT (N).Nkind = N_Variant_Part
1828 
        or else NT (N).Nkind = N_With_Clause
1829 
        or else NT (N).Nkind = N_With_Type_Clause);
1830 
      return Node2 (N);
1831 
   end Name;
1832 
 
1833 
   function Names
1834 
      (N : Node_Id) return List_Id is
1835 
   begin
1836 
      pragma Assert (False
1837 
        or else NT (N).Nkind = N_Abort_Statement
1838 
        or else NT (N).Nkind = N_Use_Package_Clause);
1839 
      return List2 (N);
1840 
   end Names;
1841 
 
1842 
   function Next_Entity
1843 
      (N : Node_Id) return Node_Id is
1844 
   begin
1845 
      pragma Assert (False
1846 
        or else NT (N).Nkind = N_Defining_Character_Literal
1847 
        or else NT (N).Nkind = N_Defining_Identifier
1848 
        or else NT (N).Nkind = N_Defining_Operator_Symbol);
1849 
      return Node2 (N);
1850 
   end Next_Entity;
1851 
 
1852 
   function Next_Named_Actual
1853 
      (N : Node_Id) return Node_Id is
1854 
   begin
1855 
      pragma Assert (False
1856 
        or else NT (N).Nkind = N_Parameter_Association);
1857 
      return Node4 (N);
1858 
   end Next_Named_Actual;
1859 
 
1860 
   function Next_Rep_Item
1861 
      (N : Node_Id) return Node_Id is
1862 
   begin
1863 
      pragma Assert (False
1864 
        or else NT (N).Nkind = N_Attribute_Definition_Clause
1865 
        or else NT (N).Nkind = N_Enumeration_Representation_Clause
1866 
        or else NT (N).Nkind = N_Pragma
1867 
        or else NT (N).Nkind = N_Record_Representation_Clause);
1868 
      return Node4 (N);
1869 
   end Next_Rep_Item;
1870 
 
1871 
   function Next_Use_Clause
1872 
      (N : Node_Id) return Node_Id is
1873 
   begin
1874 
      pragma Assert (False
1875 
        or else NT (N).Nkind = N_Use_Package_Clause
1876 
        or else NT (N).Nkind = N_Use_Type_Clause);
1877 
      return Node3 (N);
1878 
   end Next_Use_Clause;
1879 
 
1880 
   function No_Ctrl_Actions
1881 
      (N : Node_Id) return Boolean is
1882 
   begin
1883 
      pragma Assert (False
1884 
        or else NT (N).Nkind = N_Assignment_Statement);
1885 
      return Flag7 (N);
1886 
   end No_Ctrl_Actions;
1887 
 
1888 
   function No_Elaboration_Check
1889 
      (N : Node_Id) return Boolean is
1890 
   begin
1891 
      pragma Assert (False
1892 
        or else NT (N).Nkind = N_Function_Call
1893 
        or else NT (N).Nkind = N_Procedure_Call_Statement);
1894 
      return Flag14 (N);
1895 
   end No_Elaboration_Check;
1896 
 
1897 
   function No_Entities_Ref_In_Spec
1898 
      (N : Node_Id) return Boolean is
1899 
   begin
1900 
      pragma Assert (False
1901 
        or else NT (N).Nkind = N_With_Clause);
1902 
      return Flag8 (N);
1903 
   end No_Entities_Ref_In_Spec;
1904 
 
1905 
   function No_Initialization
1906 
      (N : Node_Id) return Boolean is
1907 
   begin
1908 
      pragma Assert (False
1909 
        or else NT (N).Nkind = N_Allocator
1910 
        or else NT (N).Nkind = N_Object_Declaration);
1911 
      return Flag13 (N);
1912 
   end No_Initialization;
1913 
 
1914 
   function No_Truncation
1915 
      (N : Node_Id) return Boolean is
1916 
   begin
1917 
      pragma Assert (False
1918 
        or else NT (N).Nkind = N_Unchecked_Type_Conversion);
1919 
      return Flag17 (N);
1920 
   end No_Truncation;
1921 
 
1922 
   function Null_Present
1923 
      (N : Node_Id) return Boolean is
1924 
   begin
1925 
      pragma Assert (False
1926 
        or else NT (N).Nkind = N_Component_List
1927 
        or else NT (N).Nkind = N_Procedure_Specification
1928 
        or else NT (N).Nkind = N_Record_Definition);
1929 
      return Flag13 (N);
1930 
   end Null_Present;
1931 
 
1932 
   function Null_Exclusion_Present
1933 
      (N : Node_Id) return Boolean is
1934 
   begin
1935 
      pragma Assert (False
1936 
        or else NT (N).Nkind = N_Access_Definition
1937 
        or else NT (N).Nkind = N_Access_Function_Definition
1938 
        or else NT (N).Nkind = N_Access_Procedure_Definition
1939 
        or else NT (N).Nkind = N_Access_To_Object_Definition
1940 
        or else NT (N).Nkind = N_Allocator
1941 
        or else NT (N).Nkind = N_Component_Definition
1942 
        or else NT (N).Nkind = N_Derived_Type_Definition
1943 
        or else NT (N).Nkind = N_Discriminant_Specification
1944 
        or else NT (N).Nkind = N_Function_Specification
1945 
        or else NT (N).Nkind = N_Object_Declaration
1946 
        or else NT (N).Nkind = N_Parameter_Specification
1947 
        or else NT (N).Nkind = N_Subtype_Declaration);
1948 
      return Flag11 (N);
1949 
   end Null_Exclusion_Present;
1950 
 
1951 
   function Null_Record_Present
1952 
      (N : Node_Id) return Boolean is
1953 
   begin
1954 
      pragma Assert (False
1955 
        or else NT (N).Nkind = N_Aggregate
1956 
        or else NT (N).Nkind = N_Extension_Aggregate);
1957 
      return Flag17 (N);
1958 
   end Null_Record_Present;
1959 
 
1960 
   function Object_Definition
1961 
      (N : Node_Id) return Node_Id is
1962 
   begin
1963 
      pragma Assert (False
1964 
        or else NT (N).Nkind = N_Object_Declaration);
1965 
      return Node4 (N);
1966 
   end Object_Definition;
1967 
 
1968 
   function Original_Discriminant
1969 
      (N : Node_Id) return Node_Id is
1970 
   begin
1971 
      pragma Assert (False
1972 
        or else NT (N).Nkind = N_Identifier);
1973 
      return Node2 (N);
1974 
   end Original_Discriminant;
1975 
 
1976 
   function Original_Entity
1977 
      (N : Node_Id) return Entity_Id is
1978 
   begin
1979 
      pragma Assert (False
1980 
        or else NT (N).Nkind = N_Integer_Literal
1981 
        or else NT (N).Nkind = N_Real_Literal);
1982 
      return Node2 (N);
1983 
   end Original_Entity;
1984 
 
1985 
   function Others_Discrete_Choices
1986 
      (N : Node_Id) return List_Id is
1987 
   begin
1988 
      pragma Assert (False
1989 
        or else NT (N).Nkind = N_Others_Choice);
1990 
      return List1 (N);
1991 
   end Others_Discrete_Choices;
1992 
 
1993 
   function Out_Present
1994 
      (N : Node_Id) return Boolean is
1995 
   begin
1996 
      pragma Assert (False
1997 
        or else NT (N).Nkind = N_Formal_Object_Declaration
1998 
        or else NT (N).Nkind = N_Parameter_Specification);
1999 
      return Flag17 (N);
2000 
   end Out_Present;
2001 
 
2002 
   function Parameter_Associations
2003 
      (N : Node_Id) return List_Id is
2004 
   begin
2005 
      pragma Assert (False
2006 
        or else NT (N).Nkind = N_Entry_Call_Statement
2007 
        or else NT (N).Nkind = N_Function_Call
2008 
        or else NT (N).Nkind = N_Procedure_Call_Statement);
2009 
      return List3 (N);
2010 
   end Parameter_Associations;
2011 
 
2012 
   function Parameter_List_Truncated
2013 
      (N : Node_Id) return Boolean is
2014 
   begin
2015 
      pragma Assert (False
2016 
        or else NT (N).Nkind = N_Function_Call
2017 
        or else NT (N).Nkind = N_Procedure_Call_Statement);
2018 
      return Flag17 (N);
2019 
   end Parameter_List_Truncated;
2020 
 
2021 
   function Parameter_Specifications
2022 
      (N : Node_Id) return List_Id is
2023 
   begin
2024 
      pragma Assert (False
2025 
        or else NT (N).Nkind = N_Accept_Statement
2026 
        or else NT (N).Nkind = N_Access_Function_Definition
2027 
        or else NT (N).Nkind = N_Access_Procedure_Definition
2028 
        or else NT (N).Nkind = N_Entry_Body_Formal_Part
2029 
        or else NT (N).Nkind = N_Entry_Declaration
2030 
        or else NT (N).Nkind = N_Function_Specification
2031 
        or else NT (N).Nkind = N_Procedure_Specification);
2032 
      return List3 (N);
2033 
   end Parameter_Specifications;
2034 
 
2035 
   function Parameter_Type
2036 
      (N : Node_Id) return Node_Id is
2037 
   begin
2038 
      pragma Assert (False
2039 
        or else NT (N).Nkind = N_Parameter_Specification);
2040 
      return Node2 (N);
2041 
   end Parameter_Type;
2042 
 
2043 
   function Parent_Spec
2044 
      (N : Node_Id) return Node_Id is
2045 
   begin
2046 
      pragma Assert (False
2047 
        or else NT (N).Nkind = N_Function_Instantiation
2048 
        or else NT (N).Nkind = N_Generic_Function_Renaming_Declaration
2049 
        or else NT (N).Nkind = N_Generic_Package_Declaration
2050 
        or else NT (N).Nkind = N_Generic_Package_Renaming_Declaration
2051 
        or else NT (N).Nkind = N_Generic_Procedure_Renaming_Declaration
2052 
        or else NT (N).Nkind = N_Generic_Subprogram_Declaration
2053 
        or else NT (N).Nkind = N_Package_Declaration
2054 
        or else NT (N).Nkind = N_Package_Instantiation
2055 
        or else NT (N).Nkind = N_Package_Renaming_Declaration
2056 
        or else NT (N).Nkind = N_Procedure_Instantiation
2057 
        or else NT (N).Nkind = N_Subprogram_Declaration
2058 
        or else NT (N).Nkind = N_Subprogram_Renaming_Declaration);
2059 
      return Node4 (N);
2060 
   end Parent_Spec;
2061 
 
2062 
   function Position
2063 
      (N : Node_Id) return Node_Id is
2064 
   begin
2065 
      pragma Assert (False
2066 
        or else NT (N).Nkind = N_Component_Clause);
2067 
      return Node2 (N);
2068 
   end Position;
2069 
 
2070 
   function Pragma_Argument_Associations
2071 
      (N : Node_Id) return List_Id is
2072 
   begin
2073 
      pragma Assert (False
2074 
        or else NT (N).Nkind = N_Pragma);
2075 
      return List2 (N);
2076 
   end Pragma_Argument_Associations;
2077 
 
2078 
   function Pragmas_After
2079 
      (N : Node_Id) return List_Id is
2080 
   begin
2081 
      pragma Assert (False
2082 
        or else NT (N).Nkind = N_Compilation_Unit_Aux
2083 
        or else NT (N).Nkind = N_Terminate_Alternative);
2084 
      return List5 (N);
2085 
   end Pragmas_After;
2086 
 
2087 
   function Pragmas_Before
2088 
      (N : Node_Id) return List_Id is
2089 
   begin
2090 
      pragma Assert (False
2091 
        or else NT (N).Nkind = N_Accept_Alternative
2092 
        or else NT (N).Nkind = N_Delay_Alternative
2093 
        or else NT (N).Nkind = N_Entry_Call_Alternative
2094 
        or else NT (N).Nkind = N_Mod_Clause
2095 
        or else NT (N).Nkind = N_Terminate_Alternative
2096 
        or else NT (N).Nkind = N_Triggering_Alternative);
2097 
      return List4 (N);
2098 
   end Pragmas_Before;
2099 
 
2100 
   function Prefix
2101 
      (N : Node_Id) return Node_Id is
2102 
   begin
2103 
      pragma Assert (False
2104 
        or else NT (N).Nkind = N_Attribute_Reference
2105 
        or else NT (N).Nkind = N_Expanded_Name
2106 
        or else NT (N).Nkind = N_Explicit_Dereference
2107 
        or else NT (N).Nkind = N_Indexed_Component
2108 
        or else NT (N).Nkind = N_Reference
2109 
        or else NT (N).Nkind = N_Selected_Component
2110 
        or else NT (N).Nkind = N_Slice);
2111 
      return Node3 (N);
2112 
   end Prefix;
2113 
 
2114 
   function Present_Expr
2115 
      (N : Node_Id) return Uint is
2116 
   begin
2117 
      pragma Assert (False
2118 
        or else NT (N).Nkind = N_Variant);
2119 
      return Uint3 (N);
2120 
   end Present_Expr;
2121 
 
2122 
   function Prev_Ids
2123 
      (N : Node_Id) return Boolean is
2124 
   begin
2125 
      pragma Assert (False
2126 
        or else NT (N).Nkind = N_Component_Declaration
2127 
        or else NT (N).Nkind = N_Discriminant_Specification
2128 
        or else NT (N).Nkind = N_Exception_Declaration
2129 
        or else NT (N).Nkind = N_Formal_Object_Declaration
2130 
        or else NT (N).Nkind = N_Number_Declaration
2131 
        or else NT (N).Nkind = N_Object_Declaration
2132 
        or else NT (N).Nkind = N_Parameter_Specification);
2133 
      return Flag6 (N);
2134 
   end Prev_Ids;
2135 
 
2136 
   function Print_In_Hex
2137 
      (N : Node_Id) return Boolean is
2138 
   begin
2139 
      pragma Assert (False
2140 
        or else NT (N).Nkind = N_Integer_Literal);
2141 
      return Flag13 (N);
2142 
   end Print_In_Hex;
2143 
 
2144 
   function Private_Declarations
2145 
      (N : Node_Id) return List_Id is
2146 
   begin
2147 
      pragma Assert (False
2148 
        or else NT (N).Nkind = N_Package_Specification
2149 
        or else NT (N).Nkind = N_Protected_Definition
2150 
        or else NT (N).Nkind = N_Task_Definition);
2151 
      return List3 (N);
2152 
   end Private_Declarations;
2153 
 
2154 
   function Private_Present
2155 
      (N : Node_Id) return Boolean is
2156 
   begin
2157 
      pragma Assert (False
2158 
        or else NT (N).Nkind = N_Compilation_Unit
2159 
        or else NT (N).Nkind = N_Formal_Derived_Type_Definition
2160 
        or else NT (N).Nkind = N_With_Clause);
2161 
      return Flag15 (N);
2162 
   end Private_Present;
2163 
 
2164 
   function Procedure_To_Call
2165 
      (N : Node_Id) return Node_Id is
2166 
   begin
2167 
      pragma Assert (False
2168 
        or else NT (N).Nkind = N_Allocator
2169 
        or else NT (N).Nkind = N_Free_Statement
2170 
        or else NT (N).Nkind = N_Return_Statement);
2171 
      return Node4 (N);
2172 
   end Procedure_To_Call;
2173 
 
2174 
   function Proper_Body
2175 
      (N : Node_Id) return Node_Id is
2176 
   begin
2177 
      pragma Assert (False
2178 
        or else NT (N).Nkind = N_Subunit);
2179 
      return Node1 (N);
2180 
   end Proper_Body;
2181 
 
2182 
   function Protected_Definition
2183 
      (N : Node_Id) return Node_Id is
2184 
   begin
2185 
      pragma Assert (False
2186 
        or else NT (N).Nkind = N_Protected_Type_Declaration
2187 
        or else NT (N).Nkind = N_Single_Protected_Declaration);
2188 
      return Node3 (N);
2189 
   end Protected_Definition;
2190 
 
2191 
   function Protected_Present
2192 
      (N : Node_Id) return Boolean is
2193 
   begin
2194 
      pragma Assert (False
2195 
        or else NT (N).Nkind = N_Access_Function_Definition
2196 
        or else NT (N).Nkind = N_Access_Procedure_Definition
2197 
        or else NT (N).Nkind = N_Derived_Type_Definition
2198 
        or else NT (N).Nkind = N_Record_Definition);
2199 
      return Flag6 (N);
2200 
   end Protected_Present;
2201 
 
2202 
   function Raises_Constraint_Error
2203 
      (N : Node_Id) return Boolean is
2204 
   begin
2205 
      pragma Assert (False
2206 
        or else NT (N).Nkind in N_Subexpr);
2207 
      return Flag7 (N);
2208 
   end Raises_Constraint_Error;
2209 
 
2210 
   function Range_Constraint
2211 
      (N : Node_Id) return Node_Id is
2212 
   begin
2213 
      pragma Assert (False
2214 
        or else NT (N).Nkind = N_Delta_Constraint
2215 
        or else NT (N).Nkind = N_Digits_Constraint);
2216 
      return Node4 (N);
2217 
   end Range_Constraint;
2218 
 
2219 
   function Range_Expression
2220 
      (N : Node_Id) return Node_Id is
2221 
   begin
2222 
      pragma Assert (False
2223 
        or else NT (N).Nkind = N_Range_Constraint);
2224 
      return Node4 (N);
2225 
   end Range_Expression;
2226 
 
2227 
   function Real_Range_Specification
2228 
      (N : Node_Id) return Node_Id is
2229 
   begin
2230 
      pragma Assert (False
2231 
        or else NT (N).Nkind = N_Decimal_Fixed_Point_Definition
2232 
        or else NT (N).Nkind = N_Floating_Point_Definition
2233 
        or else NT (N).Nkind = N_Ordinary_Fixed_Point_Definition);
2234 
      return Node4 (N);
2235 
   end Real_Range_Specification;
2236 
 
2237 
   function Realval
2238 
      (N : Node_Id) return Ureal is
2239 
   begin
2240 
      pragma Assert (False
2241 
        or else NT (N).Nkind = N_Real_Literal);
2242 
      return Ureal3 (N);
2243 
   end Realval;
2244 
 
2245 
   function Reason
2246 
      (N : Node_Id) return Uint is
2247 
   begin
2248 
      pragma Assert (False
2249 
        or else NT (N).Nkind = N_Raise_Constraint_Error
2250 
        or else NT (N).Nkind = N_Raise_Program_Error
2251 
        or else NT (N).Nkind = N_Raise_Storage_Error);
2252 
      return Uint3 (N);
2253 
   end Reason;
2254 
 
2255 
   function Record_Extension_Part
2256 
      (N : Node_Id) return Node_Id is
2257 
   begin
2258 
      pragma Assert (False
2259 
        or else NT (N).Nkind = N_Derived_Type_Definition);
2260 
      return Node3 (N);
2261 
   end Record_Extension_Part;
2262 
 
2263 
   function Redundant_Use
2264 
      (N : Node_Id) return Boolean is
2265 
   begin
2266 
      pragma Assert (False
2267 
        or else NT (N).Nkind = N_Attribute_Reference
2268 
        or else NT (N).Nkind = N_Expanded_Name
2269 
        or else NT (N).Nkind = N_Identifier);
2270 
      return Flag13 (N);
2271 
   end Redundant_Use;
2272 
 
2273 
   function Result_Definition
2274 
     (N : Node_Id) return Node_Id is
2275 
   begin
2276 
      pragma Assert (False
2277 
        or else NT (N).Nkind = N_Access_Function_Definition
2278 
        or else NT (N).Nkind = N_Function_Specification);
2279 
      return Node4 (N);
2280 
   end Result_Definition;
2281 
 
2282 
   function Return_Type
2283 
      (N : Node_Id) return Node_Id is
2284 
   begin
2285 
      pragma Assert (False
2286 
        or else NT (N).Nkind = N_Return_Statement);
2287 
      return Node2 (N);
2288 
   end Return_Type;
2289 
 
2290 
   function Reverse_Present
2291 
      (N : Node_Id) return Boolean is
2292 
   begin
2293 
      pragma Assert (False
2294 
        or else NT (N).Nkind = N_Loop_Parameter_Specification);
2295 
      return Flag15 (N);
2296 
   end Reverse_Present;
2297 
 
2298 
   function Right_Opnd
2299 
      (N : Node_Id) return Node_Id is
2300 
   begin
2301 
      pragma Assert (False
2302 
        or else NT (N).Nkind in N_Op
2303 
        or else NT (N).Nkind = N_And_Then
2304 
        or else NT (N).Nkind = N_In
2305 
        or else NT (N).Nkind = N_Not_In
2306 
        or else NT (N).Nkind = N_Or_Else);
2307 
      return Node3 (N);
2308 
   end Right_Opnd;
2309 
 
2310 
   function Rounded_Result
2311 
      (N : Node_Id) return Boolean is
2312 
   begin
2313 
      pragma Assert (False
2314 
        or else NT (N).Nkind = N_Op_Divide
2315 
        or else NT (N).Nkind = N_Op_Multiply
2316 
        or else NT (N).Nkind = N_Type_Conversion);
2317 
      return Flag18 (N);
2318 
   end Rounded_Result;
2319 
 
2320 
   function Scope
2321 
      (N : Node_Id) return Node_Id is
2322 
   begin
2323 
      pragma Assert (False
2324 
        or else NT (N).Nkind = N_Defining_Character_Literal
2325 
        or else NT (N).Nkind = N_Defining_Identifier
2326 
        or else NT (N).Nkind = N_Defining_Operator_Symbol);
2327 
      return Node3 (N);
2328 
   end Scope;
2329 
 
2330 
   function Select_Alternatives
2331 
      (N : Node_Id) return List_Id is
2332 
   begin
2333 
      pragma Assert (False
2334 
        or else NT (N).Nkind = N_Selective_Accept);
2335 
      return List1 (N);
2336 
   end Select_Alternatives;
2337 
 
2338 
   function Selector_Name
2339 
      (N : Node_Id) return Node_Id is
2340 
   begin
2341 
      pragma Assert (False
2342 
        or else NT (N).Nkind = N_Expanded_Name
2343 
        or else NT (N).Nkind = N_Generic_Association
2344 
        or else NT (N).Nkind = N_Parameter_Association
2345 
        or else NT (N).Nkind = N_Selected_Component);
2346 
      return Node2 (N);
2347 
   end Selector_Name;
2348 
 
2349 
   function Selector_Names
2350 
      (N : Node_Id) return List_Id is
2351 
   begin
2352 
      pragma Assert (False
2353 
        or else NT (N).Nkind = N_Discriminant_Association);
2354 
      return List1 (N);
2355 
   end Selector_Names;
2356 
 
2357 
   function Shift_Count_OK
2358 
      (N : Node_Id) return Boolean is
2359 
   begin
2360 
      pragma Assert (False
2361 
        or else NT (N).Nkind = N_Op_Rotate_Left
2362 
        or else NT (N).Nkind = N_Op_Rotate_Right
2363 
        or else NT (N).Nkind = N_Op_Shift_Left
2364 
        or else NT (N).Nkind = N_Op_Shift_Right
2365 
        or else NT (N).Nkind = N_Op_Shift_Right_Arithmetic);
2366 
      return Flag4 (N);
2367 
   end Shift_Count_OK;
2368 
 
2369 
   function Source_Type
2370 
      (N : Node_Id) return Entity_Id is
2371 
   begin
2372 
      pragma Assert (False
2373 
        or else NT (N).Nkind = N_Validate_Unchecked_Conversion);
2374 
      return Node1 (N);
2375 
   end Source_Type;
2376 
 
2377 
   function Specification
2378 
      (N : Node_Id) return Node_Id is
2379 
   begin
2380 
      pragma Assert (False
2381 
        or else NT (N).Nkind = N_Abstract_Subprogram_Declaration
2382 
        or else NT (N).Nkind = N_Formal_Abstract_Subprogram_Declaration
2383 
        or else NT (N).Nkind = N_Formal_Concrete_Subprogram_Declaration
2384 
        or else NT (N).Nkind = N_Generic_Package_Declaration
2385 
        or else NT (N).Nkind = N_Generic_Subprogram_Declaration
2386 
        or else NT (N).Nkind = N_Package_Declaration
2387 
        or else NT (N).Nkind = N_Subprogram_Body
2388 
        or else NT (N).Nkind = N_Subprogram_Body_Stub
2389 
        or else NT (N).Nkind = N_Subprogram_Declaration
2390 
        or else NT (N).Nkind = N_Subprogram_Renaming_Declaration);
2391 
      return Node1 (N);
2392 
   end Specification;
2393 
 
2394 
   function Statements
2395 
      (N : Node_Id) return List_Id is
2396 
   begin
2397 
      pragma Assert (False
2398 
        or else NT (N).Nkind = N_Abortable_Part
2399 
        or else NT (N).Nkind = N_Accept_Alternative
2400 
        or else NT (N).Nkind = N_Case_Statement_Alternative
2401 
        or else NT (N).Nkind = N_Delay_Alternative
2402 
        or else NT (N).Nkind = N_Entry_Call_Alternative
2403 
        or else NT (N).Nkind = N_Exception_Handler
2404 
        or else NT (N).Nkind = N_Handled_Sequence_Of_Statements
2405 
        or else NT (N).Nkind = N_Loop_Statement
2406 
        or else NT (N).Nkind = N_Triggering_Alternative);
2407 
      return List3 (N);
2408 
   end Statements;
2409 
 
2410 
   function Static_Processing_OK
2411 
      (N : Node_Id) return Boolean is
2412 
   begin
2413 
      pragma Assert (False
2414 
        or else NT (N).Nkind = N_Aggregate);
2415 
      return Flag4 (N);
2416 
   end Static_Processing_OK;
2417 
 
2418 
   function Storage_Pool
2419 
      (N : Node_Id) return Node_Id is
2420 
   begin
2421 
      pragma Assert (False
2422 
        or else NT (N).Nkind = N_Allocator
2423 
        or else NT (N).Nkind = N_Free_Statement
2424 
        or else NT (N).Nkind = N_Return_Statement);
2425 
      return Node1 (N);
2426 
   end Storage_Pool;
2427 
 
2428 
   function Strval
2429 
      (N : Node_Id) return String_Id is
2430 
   begin
2431 
      pragma Assert (False
2432 
        or else NT (N).Nkind = N_Operator_Symbol
2433 
        or else NT (N).Nkind = N_String_Literal);
2434 
      return Str3 (N);
2435 
   end Strval;
2436 
 
2437 
   function Subtype_Indication
2438 
      (N : Node_Id) return Node_Id is
2439 
   begin
2440 
      pragma Assert (False
2441 
        or else NT (N).Nkind = N_Access_To_Object_Definition
2442 
        or else NT (N).Nkind = N_Component_Definition
2443 
        or else NT (N).Nkind = N_Derived_Type_Definition
2444 
        or else NT (N).Nkind = N_Private_Extension_Declaration
2445 
        or else NT (N).Nkind = N_Subtype_Declaration);
2446 
      return Node5 (N);
2447 
   end Subtype_Indication;
2448 
 
2449 
   function Subtype_Mark
2450 
      (N : Node_Id) return Node_Id is
2451 
   begin
2452 
      pragma Assert (False
2453 
        or else NT (N).Nkind = N_Access_Definition
2454 
        or else NT (N).Nkind = N_Formal_Derived_Type_Definition
2455 
        or else NT (N).Nkind = N_Formal_Object_Declaration
2456 
        or else NT (N).Nkind = N_Object_Renaming_Declaration
2457 
        or else NT (N).Nkind = N_Qualified_Expression
2458 
        or else NT (N).Nkind = N_Subtype_Indication
2459 
        or else NT (N).Nkind = N_Type_Conversion
2460 
        or else NT (N).Nkind = N_Unchecked_Type_Conversion);
2461 
      return Node4 (N);
2462 
   end Subtype_Mark;
2463 
 
2464 
   function Subtype_Marks
2465 
      (N : Node_Id) return List_Id is
2466 
   begin
2467 
      pragma Assert (False
2468 
        or else NT (N).Nkind = N_Unconstrained_Array_Definition
2469 
        or else NT (N).Nkind = N_Use_Type_Clause);
2470 
      return List2 (N);
2471 
   end Subtype_Marks;
2472 
 
2473 
   function Synchronized_Present
2474 
     (N : Node_Id) return Boolean is
2475 
   begin
2476 
      pragma Assert (False
2477 
        or else NT (N).Nkind = N_Derived_Type_Definition
2478 
        or else NT (N).Nkind = N_Record_Definition);
2479 
      return Flag7 (N);
2480 
   end Synchronized_Present;
2481 
 
2482 
   function Tagged_Present
2483 
      (N : Node_Id) return Boolean is
2484 
   begin
2485 
      pragma Assert (False
2486 
        or else NT (N).Nkind = N_Formal_Private_Type_Definition
2487 
        or else NT (N).Nkind = N_Incomplete_Type_Declaration
2488 
        or else NT (N).Nkind = N_Private_Type_Declaration
2489 
        or else NT (N).Nkind = N_Record_Definition
2490 
        or else NT (N).Nkind = N_With_Type_Clause);
2491 
      return Flag15 (N);
2492 
   end Tagged_Present;
2493 
 
2494 
   function Target_Type
2495 
      (N : Node_Id) return Entity_Id is
2496 
   begin
2497 
      pragma Assert (False
2498 
        or else NT (N).Nkind = N_Validate_Unchecked_Conversion);
2499 
      return Node2 (N);
2500 
   end Target_Type;
2501 
 
2502 
   function Task_Definition
2503 
      (N : Node_Id) return Node_Id is
2504 
   begin
2505 
      pragma Assert (False
2506 
        or else NT (N).Nkind = N_Single_Task_Declaration
2507 
        or else NT (N).Nkind = N_Task_Type_Declaration);
2508 
      return Node3 (N);
2509 
   end Task_Definition;
2510 
 
2511 
   function Task_Present
2512 
     (N : Node_Id) return Boolean is
2513 
   begin
2514 
      pragma Assert (False
2515 
        or else NT (N).Nkind = N_Derived_Type_Definition
2516 
        or else NT (N).Nkind = N_Record_Definition);
2517 
      return Flag5 (N);
2518 
   end Task_Present;
2519 
 
2520 
   function Then_Actions
2521 
      (N : Node_Id) return List_Id is
2522 
   begin
2523 
      pragma Assert (False
2524 
        or else NT (N).Nkind = N_Conditional_Expression);
2525 
      return List2 (N);
2526 
   end Then_Actions;
2527 
 
2528 
   function Then_Statements
2529 
      (N : Node_Id) return List_Id is
2530 
   begin
2531 
      pragma Assert (False
2532 
        or else NT (N).Nkind = N_Elsif_Part
2533 
        or else NT (N).Nkind = N_If_Statement);
2534 
      return List2 (N);
2535 
   end Then_Statements;
2536 
 
2537 
   function Treat_Fixed_As_Integer
2538 
      (N : Node_Id) return Boolean is
2539 
   begin
2540 
      pragma Assert (False
2541 
        or else NT (N).Nkind = N_Op_Divide
2542 
        or else NT (N).Nkind = N_Op_Mod
2543 
        or else NT (N).Nkind = N_Op_Multiply
2544 
        or else NT (N).Nkind = N_Op_Rem);
2545 
      return Flag14 (N);
2546 
   end Treat_Fixed_As_Integer;
2547 
 
2548 
   function Triggering_Alternative
2549 
      (N : Node_Id) return Node_Id is
2550 
   begin
2551 
      pragma Assert (False
2552 
        or else NT (N).Nkind = N_Asynchronous_Select);
2553 
      return Node1 (N);
2554 
   end Triggering_Alternative;
2555 
 
2556 
   function Triggering_Statement
2557 
      (N : Node_Id) return Node_Id is
2558 
   begin
2559 
      pragma Assert (False
2560 
        or else NT (N).Nkind = N_Triggering_Alternative);
2561 
      return Node1 (N);
2562 
   end Triggering_Statement;
2563 
 
2564 
   function TSS_Elist
2565 
      (N : Node_Id) return Elist_Id is
2566 
   begin
2567 
      pragma Assert (False
2568 
        or else NT (N).Nkind = N_Freeze_Entity);
2569 
      return Elist3 (N);
2570 
   end TSS_Elist;
2571 
 
2572 
   function Type_Definition
2573 
      (N : Node_Id) return Node_Id is
2574 
   begin
2575 
      pragma Assert (False
2576 
        or else NT (N).Nkind = N_Full_Type_Declaration);
2577 
      return Node3 (N);
2578 
   end Type_Definition;
2579 
 
2580 
   function Unit
2581 
      (N : Node_Id) return Node_Id is
2582 
   begin
2583 
      pragma Assert (False
2584 
        or else NT (N).Nkind = N_Compilation_Unit);
2585 
      return Node2 (N);
2586 
   end Unit;
2587 
 
2588 
   function Unknown_Discriminants_Present
2589 
      (N : Node_Id) return Boolean is
2590 
   begin
2591 
      pragma Assert (False
2592 
        or else NT (N).Nkind = N_Formal_Type_Declaration
2593 
        or else NT (N).Nkind = N_Incomplete_Type_Declaration
2594 
        or else NT (N).Nkind = N_Private_Extension_Declaration
2595 
        or else NT (N).Nkind = N_Private_Type_Declaration);
2596 
      return Flag13 (N);
2597 
   end Unknown_Discriminants_Present;
2598 
 
2599 
   function Unreferenced_In_Spec
2600 
      (N : Node_Id) return Boolean is
2601 
   begin
2602 
      pragma Assert (False
2603 
        or else NT (N).Nkind = N_With_Clause);
2604 
      return Flag7 (N);
2605 
   end Unreferenced_In_Spec;
2606 
 
2607 
   function Variant_Part
2608 
      (N : Node_Id) return Node_Id is
2609 
   begin
2610 
      pragma Assert (False
2611 
        or else NT (N).Nkind = N_Component_List);
2612 
      return Node4 (N);
2613 
   end Variant_Part;
2614 
 
2615 
   function Variants
2616 
      (N : Node_Id) return List_Id is
2617 
   begin
2618 
      pragma Assert (False
2619 
        or else NT (N).Nkind = N_Variant_Part);
2620 
      return List1 (N);
2621 
   end Variants;
2622 
 
2623 
   function Visible_Declarations
2624 
      (N : Node_Id) return List_Id is
2625 
   begin
2626 
      pragma Assert (False
2627 
        or else NT (N).Nkind = N_Package_Specification
2628 
        or else NT (N).Nkind = N_Protected_Definition
2629 
        or else NT (N).Nkind = N_Task_Definition);
2630 
      return List2 (N);
2631 
   end Visible_Declarations;
2632 
 
2633 
   function Was_Originally_Stub
2634 
      (N : Node_Id) return Boolean is
2635 
   begin
2636 
      pragma Assert (False
2637 
        or else NT (N).Nkind = N_Package_Body
2638 
        or else NT (N).Nkind = N_Protected_Body
2639 
        or else NT (N).Nkind = N_Subprogram_Body
2640 
        or else NT (N).Nkind = N_Task_Body);
2641 
      return Flag13 (N);
2642 
   end Was_Originally_Stub;
2643 
 
2644 
   function Zero_Cost_Handling
2645 
      (N : Node_Id) return Boolean is
2646 
   begin
2647 
      pragma Assert (False
2648 
        or else NT (N).Nkind = N_Exception_Handler
2649 
        or else NT (N).Nkind = N_Handled_Sequence_Of_Statements);
2650 
      return Flag5 (N);
2651 
   end Zero_Cost_Handling;
2652 
 
2653 
   --------------------------
2654 
   -- Field Set Procedures --
2655 
   --------------------------
2656 
 
2657 
   procedure Set_ABE_Is_Certain
2658 
      (N : Node_Id; Val : Boolean := True) is
2659 
   begin
2660 
      pragma Assert (False
2661 
        or else NT (N).Nkind = N_Formal_Package_Declaration
2662 
        or else NT (N).Nkind = N_Function_Call
2663 
        or else NT (N).Nkind = N_Function_Instantiation
2664 
        or else NT (N).Nkind = N_Package_Instantiation
2665 
        or else NT (N).Nkind = N_Procedure_Call_Statement
2666 
        or else NT (N).Nkind = N_Procedure_Instantiation);
2667 
      Set_Flag18 (N, Val);
2668 
   end Set_ABE_Is_Certain;
2669 
 
2670 
   procedure Set_Abort_Present
2671 
      (N : Node_Id; Val : Boolean := True) is
2672 
   begin
2673 
      pragma Assert (False
2674 
        or else NT (N).Nkind = N_Requeue_Statement);
2675 
      Set_Flag15 (N, Val);
2676 
   end Set_Abort_Present;
2677 
 
2678 
   procedure Set_Abortable_Part
2679 
      (N : Node_Id; Val : Node_Id) is
2680 
   begin
2681 
      pragma Assert (False
2682 
        or else NT (N).Nkind = N_Asynchronous_Select);
2683 
      Set_Node2_With_Parent (N, Val);
2684 
   end Set_Abortable_Part;
2685 
 
2686 
   procedure Set_Abstract_Present
2687 
      (N : Node_Id; Val : Boolean := True) is
2688 
   begin
2689 
      pragma Assert (False
2690 
        or else NT (N).Nkind = N_Derived_Type_Definition
2691 
        or else NT (N).Nkind = N_Formal_Derived_Type_Definition
2692 
        or else NT (N).Nkind = N_Formal_Private_Type_Definition
2693 
        or else NT (N).Nkind = N_Private_Extension_Declaration
2694 
        or else NT (N).Nkind = N_Private_Type_Declaration
2695 
        or else NT (N).Nkind = N_Record_Definition);
2696 
      Set_Flag4 (N, Val);
2697 
   end Set_Abstract_Present;
2698 
 
2699 
   procedure Set_Accept_Handler_Records
2700 
      (N : Node_Id; Val : List_Id) is
2701 
   begin
2702 
      pragma Assert (False
2703 
        or else NT (N).Nkind = N_Accept_Alternative);
2704 
      Set_List5 (N, Val); -- semantic field, no parent set
2705 
   end Set_Accept_Handler_Records;
2706 
 
2707 
   procedure Set_Accept_Statement
2708 
      (N : Node_Id; Val : Node_Id) is
2709 
   begin
2710 
      pragma Assert (False
2711 
        or else NT (N).Nkind = N_Accept_Alternative);
2712 
      Set_Node2_With_Parent (N, Val);
2713 
   end Set_Accept_Statement;
2714 
 
2715 
   procedure Set_Access_Definition
2716 
     (N : Node_Id; Val : Node_Id) is
2717 
   begin
2718 
      pragma Assert (False
2719 
        or else NT (N).Nkind = N_Component_Definition
2720 
        or else NT (N).Nkind = N_Object_Renaming_Declaration);
2721 
      Set_Node3_With_Parent (N, Val);
2722 
   end Set_Access_Definition;
2723 
 
2724 
   procedure Set_Access_To_Subprogram_Definition
2725 
     (N : Node_Id; Val : Node_Id) is
2726 
   begin
2727 
      pragma Assert (False
2728 
        or else NT (N).Nkind = N_Access_Definition);
2729 
      Set_Node3_With_Parent (N, Val);
2730 
   end Set_Access_To_Subprogram_Definition;
2731 
 
2732 
   procedure Set_Access_Types_To_Process
2733 
      (N : Node_Id; Val : Elist_Id) is
2734 
   begin
2735 
      pragma Assert (False
2736 
        or else NT (N).Nkind = N_Freeze_Entity);
2737 
      Set_Elist2 (N, Val); -- semantic field, no parent set
2738 
   end Set_Access_Types_To_Process;
2739 
 
2740 
   procedure Set_Actions
2741 
      (N : Node_Id; Val : List_Id) is
2742 
   begin
2743 
      pragma Assert (False
2744 
        or else NT (N).Nkind = N_And_Then
2745 
        or else NT (N).Nkind = N_Compilation_Unit_Aux
2746 
        or else NT (N).Nkind = N_Freeze_Entity
2747 
        or else NT (N).Nkind = N_Or_Else);
2748 
      Set_List1_With_Parent (N, Val);
2749 
   end Set_Actions;
2750 
 
2751 
   procedure Set_Activation_Chain_Entity
2752 
      (N : Node_Id; Val : Node_Id) is
2753 
   begin
2754 
      pragma Assert (False
2755 
        or else NT (N).Nkind = N_Block_Statement
2756 
        or else NT (N).Nkind = N_Entry_Body
2757 
        or else NT (N).Nkind = N_Generic_Package_Declaration
2758 
        or else NT (N).Nkind = N_Package_Declaration
2759 
        or else NT (N).Nkind = N_Subprogram_Body
2760 
        or else NT (N).Nkind = N_Task_Body);
2761 
      Set_Node3 (N, Val); -- semantic field, no parent set
2762 
   end Set_Activation_Chain_Entity;
2763 
 
2764 
   procedure Set_Acts_As_Spec
2765 
      (N : Node_Id; Val : Boolean := True) is
2766 
   begin
2767 
      pragma Assert (False
2768 
        or else NT (N).Nkind = N_Compilation_Unit
2769 
        or else NT (N).Nkind = N_Subprogram_Body);
2770 
      Set_Flag4 (N, Val);
2771 
   end Set_Acts_As_Spec;
2772 
 
2773 
   procedure Set_Actual_Designated_Subtype
2774 
     (N : Node_Id; Val : Node_Id) is
2775 
   begin
2776 
      pragma Assert (False
2777 
        or else NT (N).Nkind = N_Explicit_Dereference
2778 
        or else NT (N).Nkind = N_Free_Statement);
2779 
      Set_Node2 (N, Val);
2780 
   end Set_Actual_Designated_Subtype;
2781 
 
2782 
   procedure Set_Aggregate_Bounds
2783 
      (N : Node_Id; Val : Node_Id) is
2784 
   begin
2785 
      pragma Assert (False
2786 
        or else NT (N).Nkind = N_Aggregate);
2787 
      Set_Node3 (N, Val); -- semantic field, no parent set
2788 
   end Set_Aggregate_Bounds;
2789 
 
2790 
   procedure Set_Aliased_Present
2791 
      (N : Node_Id; Val : Boolean := True) is
2792 
   begin
2793 
      pragma Assert (False
2794 
        or else NT (N).Nkind = N_Component_Definition
2795 
        or else NT (N).Nkind = N_Object_Declaration);
2796 
      Set_Flag4 (N, Val);
2797 
   end Set_Aliased_Present;
2798 
 
2799 
   procedure Set_All_Others
2800 
      (N : Node_Id; Val : Boolean := True) is
2801 
   begin
2802 
      pragma Assert (False
2803 
        or else NT (N).Nkind = N_Others_Choice);
2804 
      Set_Flag11 (N, Val);
2805 
   end Set_All_Others;
2806 
 
2807 
   procedure Set_All_Present
2808 
      (N : Node_Id; Val : Boolean := True) is
2809 
   begin
2810 
      pragma Assert (False
2811 
        or else NT (N).Nkind = N_Access_Definition
2812 
        or else NT (N).Nkind = N_Access_To_Object_Definition);
2813 
      Set_Flag15 (N, Val);
2814 
   end Set_All_Present;
2815 
 
2816 
   procedure Set_Alternatives
2817 
      (N : Node_Id; Val : List_Id) is
2818 
   begin
2819 
      pragma Assert (False
2820 
        or else NT (N).Nkind = N_Case_Statement);
2821 
      Set_List4_With_Parent (N, Val);
2822 
   end Set_Alternatives;
2823 
 
2824 
   procedure Set_Ancestor_Part
2825 
      (N : Node_Id; Val : Node_Id) is
2826 
   begin
2827 
      pragma Assert (False
2828 
        or else NT (N).Nkind = N_Extension_Aggregate);
2829 
      Set_Node3_With_Parent (N, Val);
2830 
   end Set_Ancestor_Part;
2831 
 
2832 
   procedure Set_Array_Aggregate
2833 
      (N : Node_Id; Val : Node_Id) is
2834 
   begin
2835 
      pragma Assert (False
2836 
        or else NT (N).Nkind = N_Enumeration_Representation_Clause);
2837 
      Set_Node3_With_Parent (N, Val);
2838 
   end Set_Array_Aggregate;
2839 
 
2840 
   procedure Set_Assignment_OK
2841 
      (N : Node_Id; Val : Boolean := True) is
2842 
   begin
2843 
      pragma Assert (False
2844 
        or else NT (N).Nkind = N_Object_Declaration
2845 
        or else NT (N).Nkind in N_Subexpr);
2846 
      Set_Flag15 (N, Val);
2847 
   end Set_Assignment_OK;
2848 
 
2849 
   procedure Set_Associated_Node
2850 
      (N : Node_Id; Val : Node_Id) is
2851 
   begin
2852 
      pragma Assert (False
2853 
        or else NT (N).Nkind in N_Has_Entity
2854 
        or else NT (N).Nkind = N_Aggregate
2855 
        or else NT (N).Nkind = N_Extension_Aggregate
2856 
        or else NT (N).Nkind = N_Selected_Component);
2857 
      Set_Node4 (N, Val); -- semantic field, no parent set
2858 
   end Set_Associated_Node;
2859 
 
2860 
   procedure Set_At_End_Proc
2861 
      (N : Node_Id; Val : Node_Id) is
2862 
   begin
2863 
      pragma Assert (False
2864 
        or else NT (N).Nkind = N_Handled_Sequence_Of_Statements);
2865 
      Set_Node1 (N, Val);
2866 
   end Set_At_End_Proc;
2867 
 
2868 
   procedure Set_Attribute_Name
2869 
      (N : Node_Id; Val : Name_Id) is
2870 
   begin
2871 
      pragma Assert (False
2872 
        or else NT (N).Nkind = N_Attribute_Reference);
2873 
      Set_Name2 (N, Val);
2874 
   end Set_Attribute_Name;
2875 
 
2876 
   procedure Set_Aux_Decls_Node
2877 
      (N : Node_Id; Val : Node_Id) is
2878 
   begin
2879 
      pragma Assert (False
2880 
        or else NT (N).Nkind = N_Compilation_Unit);
2881 
      Set_Node5_With_Parent (N, Val);
2882 
   end Set_Aux_Decls_Node;
2883 
 
2884 
   procedure Set_Backwards_OK
2885 
      (N : Node_Id; Val : Boolean := True) is
2886 
   begin
2887 
      pragma Assert (False
2888 
        or else NT (N).Nkind = N_Assignment_Statement);
2889 
      Set_Flag6 (N, Val);
2890 
   end Set_Backwards_OK;
2891 
 
2892 
   procedure Set_Bad_Is_Detected
2893 
      (N : Node_Id; Val : Boolean := True) is
2894 
   begin
2895 
      pragma Assert (False
2896 
        or else NT (N).Nkind = N_Subprogram_Body);
2897 
      Set_Flag15 (N, Val);
2898 
   end Set_Bad_Is_Detected;
2899 
 
2900 
   procedure Set_Body_Required
2901 
      (N : Node_Id; Val : Boolean := True) is
2902 
   begin
2903 
      pragma Assert (False
2904 
        or else NT (N).Nkind = N_Compilation_Unit);
2905 
      Set_Flag13 (N, Val);
2906 
   end Set_Body_Required;
2907 
 
2908 
   procedure Set_Body_To_Inline
2909 
      (N : Node_Id; Val : Node_Id) is
2910 
   begin
2911 
      pragma Assert (False
2912 
        or else NT (N).Nkind = N_Subprogram_Declaration);
2913 
      Set_Node3 (N, Val);
2914 
   end Set_Body_To_Inline;
2915 
 
2916 
   procedure Set_Box_Present
2917 
      (N : Node_Id; Val : Boolean := True) is
2918 
   begin
2919 
      pragma Assert (False
2920 
        or else NT (N).Nkind = N_Component_Association
2921 
        or else NT (N).Nkind = N_Formal_Abstract_Subprogram_Declaration
2922 
        or else NT (N).Nkind = N_Formal_Concrete_Subprogram_Declaration
2923 
        or else NT (N).Nkind = N_Formal_Package_Declaration);
2924 
      Set_Flag15 (N, Val);
2925 
   end Set_Box_Present;
2926 
 
2927 
   procedure Set_By_Ref
2928 
      (N : Node_Id; Val : Boolean := True) is
2929 
   begin
2930 
      pragma Assert (False
2931 
        or else NT (N).Nkind = N_Return_Statement);
2932 
      Set_Flag5 (N, Val);
2933 
   end Set_By_Ref;
2934 
 
2935 
   procedure Set_Char_Literal_Value
2936 
      (N : Node_Id; Val : Uint) is
2937 
   begin
2938 
      pragma Assert (False
2939 
        or else NT (N).Nkind = N_Character_Literal);
2940 
      Set_Uint2 (N, Val);
2941 
   end Set_Char_Literal_Value;
2942 
 
2943 
   procedure Set_Chars
2944 
      (N : Node_Id; Val : Name_Id) is
2945 
   begin
2946 
      pragma Assert (False
2947 
        or else NT (N).Nkind in N_Has_Chars);
2948 
      Set_Name1 (N, Val);
2949 
   end Set_Chars;
2950 
 
2951 
   procedure Set_Check_Address_Alignment
2952 
      (N : Node_Id; Val : Boolean := True) is
2953 
   begin
2954 
      pragma Assert (False
2955 
          or else NT (N).Nkind = N_Attribute_Definition_Clause);
2956 
      Set_Flag11 (N, Val);
2957 
   end Set_Check_Address_Alignment;
2958 
 
2959 
   procedure Set_Choice_Parameter
2960 
      (N : Node_Id; Val : Node_Id) is
2961 
   begin
2962 
      pragma Assert (False
2963 
        or else NT (N).Nkind = N_Exception_Handler);
2964 
      Set_Node2_With_Parent (N, Val);
2965 
   end Set_Choice_Parameter;
2966 
 
2967 
   procedure Set_Choices
2968 
      (N : Node_Id; Val : List_Id) is
2969 
   begin
2970 
      pragma Assert (False
2971 
        or else NT (N).Nkind = N_Component_Association);
2972 
      Set_List1_With_Parent (N, Val);
2973 
   end Set_Choices;
2974 
 
2975 
   procedure Set_Compile_Time_Known_Aggregate
2976 
      (N : Node_Id; Val : Boolean := True) is
2977 
   begin
2978 
      pragma Assert (False
2979 
        or else NT (N).Nkind = N_Aggregate);
2980 
      Set_Flag18 (N, Val);
2981 
   end Set_Compile_Time_Known_Aggregate;
2982 
 
2983 
   procedure Set_Component_Associations
2984 
      (N : Node_Id; Val : List_Id) is
2985 
   begin
2986 
      pragma Assert (False
2987 
        or else NT (N).Nkind = N_Aggregate
2988 
        or else NT (N).Nkind = N_Extension_Aggregate);
2989 
      Set_List2_With_Parent (N, Val);
2990 
   end Set_Component_Associations;
2991 
 
2992 
   procedure Set_Component_Clauses
2993 
      (N : Node_Id; Val : List_Id) is
2994 
   begin
2995 
      pragma Assert (False
2996 
        or else NT (N).Nkind = N_Record_Representation_Clause);
2997 
      Set_List3_With_Parent (N, Val);
2998 
   end Set_Component_Clauses;
2999 
 
3000 
   procedure Set_Component_Definition
3001 
      (N : Node_Id; Val : Node_Id) is
3002 
   begin
3003 
      pragma Assert (False
3004 
        or else NT (N).Nkind = N_Component_Declaration
3005 
        or else NT (N).Nkind = N_Constrained_Array_Definition
3006 
        or else NT (N).Nkind = N_Unconstrained_Array_Definition);
3007 
      Set_Node4_With_Parent (N, Val);
3008 
   end Set_Component_Definition;
3009 
 
3010 
   procedure Set_Component_Items
3011 
      (N : Node_Id; Val : List_Id) is
3012 
   begin
3013 
      pragma Assert (False
3014 
        or else NT (N).Nkind = N_Component_List);
3015 
      Set_List3_With_Parent (N, Val);
3016 
   end Set_Component_Items;
3017 
 
3018 
   procedure Set_Component_List
3019 
      (N : Node_Id; Val : Node_Id) is
3020 
   begin
3021 
      pragma Assert (False
3022 
        or else NT (N).Nkind = N_Record_Definition
3023 
        or else NT (N).Nkind = N_Variant);
3024 
      Set_Node1_With_Parent (N, Val);
3025 
   end Set_Component_List;
3026 
 
3027 
   procedure Set_Component_Name
3028 
      (N : Node_Id; Val : Node_Id) is
3029 
   begin
3030 
      pragma Assert (False
3031 
        or else NT (N).Nkind = N_Component_Clause);
3032 
      Set_Node1_With_Parent (N, Val);
3033 
   end Set_Component_Name;
3034 
 
3035 
   procedure Set_Condition
3036 
      (N : Node_Id; Val : Node_Id) is
3037 
   begin
3038 
      pragma Assert (False
3039 
        or else NT (N).Nkind = N_Accept_Alternative
3040 
        or else NT (N).Nkind = N_Delay_Alternative
3041 
        or else NT (N).Nkind = N_Elsif_Part
3042 
        or else NT (N).Nkind = N_Entry_Body_Formal_Part
3043 
        or else NT (N).Nkind = N_Exit_Statement
3044 
        or else NT (N).Nkind = N_If_Statement
3045 
        or else NT (N).Nkind = N_Iteration_Scheme
3046 
        or else NT (N).Nkind = N_Raise_Constraint_Error
3047 
        or else NT (N).Nkind = N_Raise_Program_Error
3048 
        or else NT (N).Nkind = N_Raise_Storage_Error
3049 
        or else NT (N).Nkind = N_Terminate_Alternative);
3050 
      Set_Node1_With_Parent (N, Val);
3051 
   end Set_Condition;
3052 
 
3053 
   procedure Set_Condition_Actions
3054 
      (N : Node_Id; Val : List_Id) is
3055 
   begin
3056 
      pragma Assert (False
3057 
        or else NT (N).Nkind = N_Elsif_Part
3058 
        or else NT (N).Nkind = N_Iteration_Scheme);
3059 
      Set_List3 (N, Val); -- semantic field, no parent set
3060 
   end Set_Condition_Actions;
3061 
 
3062 
   procedure Set_Config_Pragmas
3063 
      (N : Node_Id; Val : List_Id) is
3064 
   begin
3065 
      pragma Assert (False
3066 
        or else NT (N).Nkind = N_Compilation_Unit_Aux);
3067 
      Set_List4_With_Parent (N, Val);
3068 
   end Set_Config_Pragmas;
3069 
 
3070 
   procedure Set_Constant_Present
3071 
      (N : Node_Id; Val : Boolean := True) is
3072 
   begin
3073 
      pragma Assert (False
3074 
        or else NT (N).Nkind = N_Access_Definition
3075 
        or else NT (N).Nkind = N_Access_To_Object_Definition
3076 
        or else NT (N).Nkind = N_Object_Declaration);
3077 
      Set_Flag17 (N, Val);
3078 
   end Set_Constant_Present;
3079 
 
3080 
   procedure Set_Constraint
3081 
      (N : Node_Id; Val : Node_Id) is
3082 
   begin
3083 
      pragma Assert (False
3084 
        or else NT (N).Nkind = N_Subtype_Indication);
3085 
      Set_Node3_With_Parent (N, Val);
3086 
   end Set_Constraint;
3087 
 
3088 
   procedure Set_Constraints
3089 
      (N : Node_Id; Val : List_Id) is
3090 
   begin
3091 
      pragma Assert (False
3092 
        or else NT (N).Nkind = N_Index_Or_Discriminant_Constraint);
3093 
      Set_List1_With_Parent (N, Val);
3094 
   end Set_Constraints;
3095 
 
3096 
   procedure Set_Context_Installed
3097 
      (N : Node_Id; Val : Boolean := True) is
3098 
   begin
3099 
      pragma Assert (False
3100 
        or else NT (N).Nkind = N_With_Clause);
3101 
      Set_Flag13 (N, Val);
3102 
   end Set_Context_Installed;
3103 
 
3104 
   procedure Set_Context_Items
3105 
      (N : Node_Id; Val : List_Id) is
3106 
   begin
3107 
      pragma Assert (False
3108 
        or else NT (N).Nkind = N_Compilation_Unit);
3109 
      Set_List1_With_Parent (N, Val);
3110 
   end Set_Context_Items;
3111 
 
3112 
   procedure Set_Controlling_Argument
3113 
      (N : Node_Id; Val : Node_Id) is
3114 
   begin
3115 
      pragma Assert (False
3116 
        or else NT (N).Nkind = N_Function_Call
3117 
        or else NT (N).Nkind = N_Procedure_Call_Statement);
3118 
      Set_Node1 (N, Val); -- semantic field, no parent set
3119 
   end Set_Controlling_Argument;
3120 
 
3121 
   procedure Set_Conversion_OK
3122 
      (N : Node_Id; Val : Boolean := True) is
3123 
   begin
3124 
      pragma Assert (False
3125 
        or else NT (N).Nkind = N_Type_Conversion);
3126 
      Set_Flag14 (N, Val);
3127 
   end Set_Conversion_OK;
3128 
 
3129 
   procedure Set_Corresponding_Body
3130 
      (N : Node_Id; Val : Node_Id) is
3131 
   begin
3132 
      pragma Assert (False
3133 
        or else NT (N).Nkind = N_Entry_Declaration
3134 
        or else NT (N).Nkind = N_Generic_Package_Declaration
3135 
        or else NT (N).Nkind = N_Generic_Subprogram_Declaration
3136 
        or else NT (N).Nkind = N_Package_Body_Stub
3137 
        or else NT (N).Nkind = N_Package_Declaration
3138 
        or else NT (N).Nkind = N_Protected_Body_Stub
3139 
        or else NT (N).Nkind = N_Protected_Type_Declaration
3140 
        or else NT (N).Nkind = N_Subprogram_Body_Stub
3141 
        or else NT (N).Nkind = N_Subprogram_Declaration
3142 
        or else NT (N).Nkind = N_Task_Body_Stub
3143 
        or else NT (N).Nkind = N_Task_Type_Declaration);
3144 
      Set_Node5 (N, Val); -- semantic field, no parent set
3145 
   end Set_Corresponding_Body;
3146 
 
3147 
   procedure Set_Corresponding_Formal_Spec
3148 
      (N : Node_Id; Val : Node_Id) is
3149 
   begin
3150 
      pragma Assert (False
3151 
        or else NT (N).Nkind = N_Subprogram_Renaming_Declaration);
3152 
      Set_Node3 (N, Val); -- semantic field, no parent set
3153 
   end Set_Corresponding_Formal_Spec;
3154 
 
3155 
   procedure Set_Corresponding_Generic_Association
3156 
      (N : Node_Id; Val : Node_Id) is
3157 
   begin
3158 
      pragma Assert (False
3159 
        or else NT (N).Nkind = N_Object_Declaration
3160 
        or else NT (N).Nkind = N_Object_Renaming_Declaration);
3161 
      Set_Node5 (N, Val); -- semantic field, no parent set
3162 
   end Set_Corresponding_Generic_Association;
3163 
 
3164 
   procedure Set_Corresponding_Integer_Value
3165 
      (N : Node_Id; Val : Uint) is
3166 
   begin
3167 
      pragma Assert (False
3168 
        or else NT (N).Nkind = N_Real_Literal);
3169 
      Set_Uint4 (N, Val); -- semantic field, no parent set
3170 
   end Set_Corresponding_Integer_Value;
3171 
 
3172 
   procedure Set_Corresponding_Spec
3173 
      (N : Node_Id; Val : Node_Id) is
3174 
   begin
3175 
      pragma Assert (False
3176 
        or else NT (N).Nkind = N_Package_Body
3177 
        or else NT (N).Nkind = N_Protected_Body
3178 
        or else NT (N).Nkind = N_Subprogram_Body
3179 
        or else NT (N).Nkind = N_Subprogram_Renaming_Declaration
3180 
        or else NT (N).Nkind = N_Task_Body
3181 
        or else NT (N).Nkind = N_With_Clause);
3182 
      Set_Node5 (N, Val); -- semantic field, no parent set
3183 
   end Set_Corresponding_Spec;
3184 
 
3185 
   procedure Set_Corresponding_Stub
3186 
      (N : Node_Id; Val : Node_Id) is
3187 
   begin
3188 
      pragma Assert (False
3189 
        or else NT (N).Nkind = N_Subunit);
3190 
      Set_Node3 (N, Val);
3191 
   end Set_Corresponding_Stub;
3192 
 
3193 
   procedure Set_Dcheck_Function
3194 
      (N : Node_Id; Val : Entity_Id) is
3195 
   begin
3196 
      pragma Assert (False
3197 
        or else NT (N).Nkind = N_Variant);
3198 
      Set_Node5 (N, Val); -- semantic field, no parent set
3199 
   end Set_Dcheck_Function;
3200 
 
3201 
   procedure Set_Debug_Statement
3202 
      (N : Node_Id; Val : Node_Id) is
3203 
   begin
3204 
      pragma Assert (False
3205 
        or else NT (N).Nkind = N_Pragma);
3206 
      Set_Node3_With_Parent (N, Val);
3207 
   end Set_Debug_Statement;
3208 
 
3209 
   procedure Set_Declarations
3210 
      (N : Node_Id; Val : List_Id) is
3211 
   begin
3212 
      pragma Assert (False
3213 
        or else NT (N).Nkind = N_Accept_Statement
3214 
        or else NT (N).Nkind = N_Block_Statement
3215 
        or else NT (N).Nkind = N_Compilation_Unit_Aux
3216 
        or else NT (N).Nkind = N_Entry_Body
3217 
        or else NT (N).Nkind = N_Package_Body
3218 
        or else NT (N).Nkind = N_Protected_Body
3219 
        or else NT (N).Nkind = N_Subprogram_Body
3220 
        or else NT (N).Nkind = N_Task_Body);
3221 
      Set_List2_With_Parent (N, Val);
3222 
   end Set_Declarations;
3223 
 
3224 
   procedure Set_Default_Expression
3225 
      (N : Node_Id; Val : Node_Id) is
3226 
   begin
3227 
      pragma Assert (False
3228 
        or else NT (N).Nkind = N_Parameter_Specification);
3229 
      Set_Node5 (N, Val); -- semantic field, no parent set
3230 
   end Set_Default_Expression;
3231 
 
3232 
   procedure Set_Default_Name
3233 
      (N : Node_Id; Val : Node_Id) is
3234 
   begin
3235 
      pragma Assert (False
3236 
        or else NT (N).Nkind = N_Formal_Abstract_Subprogram_Declaration
3237 
        or else NT (N).Nkind = N_Formal_Concrete_Subprogram_Declaration);
3238 
      Set_Node2_With_Parent (N, Val);
3239 
   end Set_Default_Name;
3240 
 
3241 
   procedure Set_Defining_Identifier
3242 
      (N : Node_Id; Val : Entity_Id) is
3243 
   begin
3244 
      pragma Assert (False
3245 
        or else NT (N).Nkind = N_Component_Declaration
3246 
        or else NT (N).Nkind = N_Defining_Program_Unit_Name
3247 
        or else NT (N).Nkind = N_Discriminant_Specification
3248 
        or else NT (N).Nkind = N_Entry_Body
3249 
        or else NT (N).Nkind = N_Entry_Declaration
3250 
        or else NT (N).Nkind = N_Entry_Index_Specification
3251 
        or else NT (N).Nkind = N_Exception_Declaration
3252 
        or else NT (N).Nkind = N_Exception_Renaming_Declaration
3253 
        or else NT (N).Nkind = N_Formal_Object_Declaration
3254 
        or else NT (N).Nkind = N_Formal_Package_Declaration
3255 
        or else NT (N).Nkind = N_Formal_Type_Declaration
3256 
        or else NT (N).Nkind = N_Full_Type_Declaration
3257 
        or else NT (N).Nkind = N_Implicit_Label_Declaration
3258 
        or else NT (N).Nkind = N_Incomplete_Type_Declaration
3259 
        or else NT (N).Nkind = N_Loop_Parameter_Specification
3260 
        or else NT (N).Nkind = N_Number_Declaration
3261 
        or else NT (N).Nkind = N_Object_Declaration
3262 
        or else NT (N).Nkind = N_Object_Renaming_Declaration
3263 
        or else NT (N).Nkind = N_Package_Body_Stub
3264 
        or else NT (N).Nkind = N_Parameter_Specification
3265 
        or else NT (N).Nkind = N_Private_Extension_Declaration
3266 
        or else NT (N).Nkind = N_Private_Type_Declaration
3267 
        or else NT (N).Nkind = N_Protected_Body
3268 
        or else NT (N).Nkind = N_Protected_Body_Stub
3269 
        or else NT (N).Nkind = N_Protected_Type_Declaration
3270 
        or else NT (N).Nkind = N_Single_Protected_Declaration
3271 
        or else NT (N).Nkind = N_Single_Task_Declaration
3272 
        or else NT (N).Nkind = N_Subtype_Declaration
3273 
        or else NT (N).Nkind = N_Task_Body
3274 
        or else NT (N).Nkind = N_Task_Body_Stub
3275 
        or else NT (N).Nkind = N_Task_Type_Declaration);
3276 
      Set_Node1_With_Parent (N, Val);
3277 
   end Set_Defining_Identifier;
3278 
 
3279 
   procedure Set_Defining_Unit_Name
3280 
      (N : Node_Id; Val : Node_Id) is
3281 
   begin
3282 
      pragma Assert (False
3283 
        or else NT (N).Nkind = N_Function_Instantiation
3284 
        or else NT (N).Nkind = N_Function_Specification
3285 
        or else NT (N).Nkind = N_Generic_Function_Renaming_Declaration
3286 
        or else NT (N).Nkind = N_Generic_Package_Renaming_Declaration
3287 
        or else NT (N).Nkind = N_Generic_Procedure_Renaming_Declaration
3288 
        or else NT (N).Nkind = N_Package_Body
3289 
        or else NT (N).Nkind = N_Package_Instantiation
3290 
        or else NT (N).Nkind = N_Package_Renaming_Declaration
3291 
        or else NT (N).Nkind = N_Package_Specification
3292 
        or else NT (N).Nkind = N_Procedure_Instantiation
3293 
        or else NT (N).Nkind = N_Procedure_Specification);
3294 
      Set_Node1_With_Parent (N, Val);
3295 
   end Set_Defining_Unit_Name;
3296 
 
3297 
   procedure Set_Delay_Alternative
3298 
      (N : Node_Id; Val : Node_Id) is
3299 
   begin
3300 
      pragma Assert (False
3301 
        or else NT (N).Nkind = N_Timed_Entry_Call);
3302 
      Set_Node4_With_Parent (N, Val);
3303 
   end Set_Delay_Alternative;
3304 
 
3305 
   procedure Set_Delay_Finalize_Attach
3306 
      (N : Node_Id; Val : Boolean := True) is
3307 
   begin
3308 
      pragma Assert (False
3309 
        or else NT (N).Nkind = N_Object_Declaration);
3310 
      Set_Flag14 (N, Val);
3311 
   end Set_Delay_Finalize_Attach;
3312 
 
3313 
   procedure Set_Delay_Statement
3314 
      (N : Node_Id; Val : Node_Id) is
3315 
   begin
3316 
      pragma Assert (False
3317 
        or else NT (N).Nkind = N_Delay_Alternative);
3318 
      Set_Node2_With_Parent (N, Val);
3319 
   end Set_Delay_Statement;
3320 
 
3321 
   procedure Set_Delta_Expression
3322 
      (N : Node_Id; Val : Node_Id) is
3323 
   begin
3324 
      pragma Assert (False
3325 
        or else NT (N).Nkind = N_Decimal_Fixed_Point_Definition
3326 
        or else NT (N).Nkind = N_Delta_Constraint
3327 
        or else NT (N).Nkind = N_Ordinary_Fixed_Point_Definition);
3328 
      Set_Node3_With_Parent (N, Val);
3329 
   end Set_Delta_Expression;
3330 
 
3331 
   procedure Set_Digits_Expression
3332 
      (N : Node_Id; Val : Node_Id) is
3333 
   begin
3334 
      pragma Assert (False
3335 
        or else NT (N).Nkind = N_Decimal_Fixed_Point_Definition
3336 
        or else NT (N).Nkind = N_Digits_Constraint
3337 
        or else NT (N).Nkind = N_Floating_Point_Definition);
3338 
      Set_Node2_With_Parent (N, Val);
3339 
   end Set_Digits_Expression;
3340 
 
3341 
   procedure Set_Discr_Check_Funcs_Built
3342 
      (N : Node_Id; Val : Boolean := True) is
3343 
   begin
3344 
      pragma Assert (False
3345 
        or else NT (N).Nkind = N_Full_Type_Declaration);
3346 
      Set_Flag11 (N, Val);
3347 
   end Set_Discr_Check_Funcs_Built;
3348 
 
3349 
   procedure Set_Discrete_Choices
3350 
      (N : Node_Id; Val : List_Id) is
3351 
   begin
3352 
      pragma Assert (False
3353 
        or else NT (N).Nkind = N_Case_Statement_Alternative
3354 
        or else NT (N).Nkind = N_Variant);
3355 
      Set_List4_With_Parent (N, Val);
3356 
   end Set_Discrete_Choices;
3357 
 
3358 
   procedure Set_Discrete_Range
3359 
      (N : Node_Id; Val : Node_Id) is
3360 
   begin
3361 
      pragma Assert (False
3362 
        or else NT (N).Nkind = N_Slice);
3363 
      Set_Node4_With_Parent (N, Val);
3364 
   end Set_Discrete_Range;
3365 
 
3366 
   procedure Set_Discrete_Subtype_Definition
3367 
      (N : Node_Id; Val : Node_Id) is
3368 
   begin
3369 
      pragma Assert (False
3370 
        or else NT (N).Nkind = N_Entry_Declaration
3371 
        or else NT (N).Nkind = N_Entry_Index_Specification
3372 
        or else NT (N).Nkind = N_Loop_Parameter_Specification);
3373 
      Set_Node4_With_Parent (N, Val);
3374 
   end Set_Discrete_Subtype_Definition;
3375 
 
3376 
   procedure Set_Discrete_Subtype_Definitions
3377 
      (N : Node_Id; Val : List_Id) is
3378 
   begin
3379 
      pragma Assert (False
3380 
        or else NT (N).Nkind = N_Constrained_Array_Definition);
3381 
      Set_List2_With_Parent (N, Val);
3382 
   end Set_Discrete_Subtype_Definitions;
3383 
 
3384 
   procedure Set_Discriminant_Specifications
3385 
      (N : Node_Id; Val : List_Id) is
3386 
   begin
3387 
      pragma Assert (False
3388 
        or else NT (N).Nkind = N_Formal_Type_Declaration
3389 
        or else NT (N).Nkind = N_Full_Type_Declaration
3390 
        or else NT (N).Nkind = N_Incomplete_Type_Declaration
3391 
        or else NT (N).Nkind = N_Private_Extension_Declaration
3392 
        or else NT (N).Nkind = N_Private_Type_Declaration
3393 
        or else NT (N).Nkind = N_Protected_Type_Declaration
3394 
        or else NT (N).Nkind = N_Task_Type_Declaration);
3395 
      Set_List4_With_Parent (N, Val);
3396 
   end Set_Discriminant_Specifications;
3397 
 
3398 
   procedure Set_Discriminant_Type
3399 
      (N : Node_Id; Val : Node_Id) is
3400 
   begin
3401 
      pragma Assert (False
3402 
        or else NT (N).Nkind = N_Discriminant_Specification);
3403 
      Set_Node5_With_Parent (N, Val);
3404 
   end Set_Discriminant_Type;
3405 
 
3406 
   procedure Set_Do_Accessibility_Check
3407 
      (N : Node_Id; Val : Boolean := True) is
3408 
   begin
3409 
      pragma Assert (False
3410 
        or else NT (N).Nkind = N_Parameter_Specification);
3411 
      Set_Flag13 (N, Val);
3412 
   end Set_Do_Accessibility_Check;
3413 
 
3414 
   procedure Set_Do_Discriminant_Check
3415 
      (N : Node_Id; Val : Boolean := True) is
3416 
   begin
3417 
      pragma Assert (False
3418 
        or else NT (N).Nkind = N_Selected_Component);
3419 
      Set_Flag13 (N, Val);
3420 
   end Set_Do_Discriminant_Check;
3421 
 
3422 
   procedure Set_Do_Division_Check
3423 
      (N : Node_Id; Val : Boolean := True) is
3424 
   begin
3425 
      pragma Assert (False
3426 
        or else NT (N).Nkind = N_Op_Divide
3427 
        or else NT (N).Nkind = N_Op_Mod
3428 
        or else NT (N).Nkind = N_Op_Rem);
3429 
      Set_Flag13 (N, Val);
3430 
   end Set_Do_Division_Check;
3431 
 
3432 
   procedure Set_Do_Length_Check
3433 
      (N : Node_Id; Val : Boolean := True) is
3434 
   begin
3435 
      pragma Assert (False
3436 
        or else NT (N).Nkind = N_Assignment_Statement
3437 
        or else NT (N).Nkind = N_Op_And
3438 
        or else NT (N).Nkind = N_Op_Or
3439 
        or else NT (N).Nkind = N_Op_Xor
3440 
        or else NT (N).Nkind = N_Type_Conversion);
3441 
      Set_Flag4 (N, Val);
3442 
   end Set_Do_Length_Check;
3443 
 
3444 
   procedure Set_Do_Overflow_Check
3445 
      (N : Node_Id; Val : Boolean := True) is
3446 
   begin
3447 
      pragma Assert (False
3448 
        or else NT (N).Nkind in N_Op
3449 
        or else NT (N).Nkind = N_Attribute_Reference
3450 
        or else NT (N).Nkind = N_Type_Conversion);
3451 
      Set_Flag17 (N, Val);
3452 
   end Set_Do_Overflow_Check;
3453 
 
3454 
   procedure Set_Do_Range_Check
3455 
      (N : Node_Id; Val : Boolean := True) is
3456 
   begin
3457 
      pragma Assert (False
3458 
        or else NT (N).Nkind in N_Subexpr);
3459 
      Set_Flag9 (N, Val);
3460 
   end Set_Do_Range_Check;
3461 
 
3462 
   procedure Set_Do_Storage_Check
3463 
      (N : Node_Id; Val : Boolean := True) is
3464 
   begin
3465 
      pragma Assert (False
3466 
        or else NT (N).Nkind = N_Allocator
3467 
        or else NT (N).Nkind = N_Subprogram_Body);
3468 
      Set_Flag17 (N, Val);
3469 
   end Set_Do_Storage_Check;
3470 
 
3471 
   procedure Set_Do_Tag_Check
3472 
      (N : Node_Id; Val : Boolean := True) is
3473 
   begin
3474 
      pragma Assert (False
3475 
        or else NT (N).Nkind = N_Assignment_Statement
3476 
        or else NT (N).Nkind = N_Function_Call
3477 
        or else NT (N).Nkind = N_Procedure_Call_Statement
3478 
        or else NT (N).Nkind = N_Return_Statement
3479 
        or else NT (N).Nkind = N_Type_Conversion);
3480 
      Set_Flag13 (N, Val);
3481 
   end Set_Do_Tag_Check;
3482 
 
3483 
   procedure Set_Elaborate_All_Desirable
3484 
      (N : Node_Id; Val : Boolean := True) is
3485 
   begin
3486 
      pragma Assert (False
3487 
        or else NT (N).Nkind = N_With_Clause);
3488 
      Set_Flag9 (N, Val);
3489 
   end Set_Elaborate_All_Desirable;
3490 
 
3491 
   procedure Set_Elaborate_All_Present
3492 
      (N : Node_Id; Val : Boolean := True) is
3493 
   begin
3494 
      pragma Assert (False
3495 
        or else NT (N).Nkind = N_With_Clause);
3496 
      Set_Flag14 (N, Val);
3497 
   end Set_Elaborate_All_Present;
3498 
 
3499 
   procedure Set_Elaborate_Desirable
3500 
      (N : Node_Id; Val : Boolean := True) is
3501 
   begin
3502 
      pragma Assert (False
3503 
        or else NT (N).Nkind = N_With_Clause);
3504 
      Set_Flag11 (N, Val);
3505 
   end Set_Elaborate_Desirable;
3506 
 
3507 
   procedure Set_Elaborate_Present
3508 
      (N : Node_Id; Val : Boolean := True) is
3509 
   begin
3510 
      pragma Assert (False
3511 
        or else NT (N).Nkind = N_With_Clause);
3512 
      Set_Flag4 (N, Val);
3513 
   end Set_Elaborate_Present;
3514 
 
3515 
   procedure Set_Elaboration_Boolean
3516 
      (N : Node_Id; Val : Node_Id) is
3517 
   begin
3518 
      pragma Assert (False
3519 
        or else NT (N).Nkind = N_Function_Specification
3520 
        or else NT (N).Nkind = N_Procedure_Specification);
3521 
      Set_Node2 (N, Val);
3522 
   end Set_Elaboration_Boolean;
3523 
 
3524 
   procedure Set_Else_Actions
3525 
      (N : Node_Id; Val : List_Id) is
3526 
   begin
3527 
      pragma Assert (False
3528 
        or else NT (N).Nkind = N_Conditional_Expression);
3529 
      Set_List3 (N, Val); -- semantic field, no parent set
3530 
   end Set_Else_Actions;
3531 
 
3532 
   procedure Set_Else_Statements
3533 
      (N : Node_Id; Val : List_Id) is
3534 
   begin
3535 
      pragma Assert (False
3536 
        or else NT (N).Nkind = N_Conditional_Entry_Call
3537 
        or else NT (N).Nkind = N_If_Statement
3538 
        or else NT (N).Nkind = N_Selective_Accept);
3539 
      Set_List4_With_Parent (N, Val);
3540 
   end Set_Else_Statements;
3541 
 
3542 
   procedure Set_Elsif_Parts
3543 
      (N : Node_Id; Val : List_Id) is
3544 
   begin
3545 
      pragma Assert (False
3546 
        or else NT (N).Nkind = N_If_Statement);
3547 
      Set_List3_With_Parent (N, Val);
3548 
   end Set_Elsif_Parts;
3549 
 
3550 
   procedure Set_Enclosing_Variant
3551 
      (N : Node_Id; Val : Node_Id) is
3552 
   begin
3553 
      pragma Assert (False
3554 
        or else NT (N).Nkind = N_Variant);
3555 
      Set_Node2 (N, Val); -- semantic field, no parent set
3556 
   end Set_Enclosing_Variant;
3557 
 
3558 
   procedure Set_End_Label
3559 
      (N : Node_Id; Val : Node_Id) is
3560 
   begin
3561 
      pragma Assert (False
3562 
        or else NT (N).Nkind = N_Enumeration_Type_Definition
3563 
        or else NT (N).Nkind = N_Handled_Sequence_Of_Statements
3564 
        or else NT (N).Nkind = N_Loop_Statement
3565 
        or else NT (N).Nkind = N_Package_Specification
3566 
        or else NT (N).Nkind = N_Protected_Body
3567 
        or else NT (N).Nkind = N_Protected_Definition
3568 
        or else NT (N).Nkind = N_Record_Definition
3569 
        or else NT (N).Nkind = N_Task_Definition);
3570 
      Set_Node4_With_Parent (N, Val);
3571 
   end Set_End_Label;
3572 
 
3573 
   procedure Set_End_Span
3574 
      (N : Node_Id; Val : Uint) is
3575 
   begin
3576 
      pragma Assert (False
3577 
        or else NT (N).Nkind = N_Case_Statement
3578 
        or else NT (N).Nkind = N_If_Statement);
3579 
      Set_Uint5 (N, Val);
3580 
   end Set_End_Span;
3581 
 
3582 
   procedure Set_Entity
3583 
      (N : Node_Id; Val : Node_Id) is
3584 
   begin
3585 
      pragma Assert (False
3586 
        or else NT (N).Nkind in N_Has_Entity
3587 
        or else NT (N).Nkind = N_Freeze_Entity);
3588 
      Set_Node4 (N, Val); -- semantic field, no parent set
3589 
   end Set_Entity;
3590 
 
3591 
   procedure Set_Entry_Body_Formal_Part
3592 
      (N : Node_Id; Val : Node_Id) is
3593 
   begin
3594 
      pragma Assert (False
3595 
        or else NT (N).Nkind = N_Entry_Body);
3596 
      Set_Node5_With_Parent (N, Val);
3597 
   end Set_Entry_Body_Formal_Part;
3598 
 
3599 
   procedure Set_Entry_Call_Alternative
3600 
      (N : Node_Id; Val : Node_Id) is
3601 
   begin
3602 
      pragma Assert (False
3603 
        or else NT (N).Nkind = N_Conditional_Entry_Call
3604 
        or else NT (N).Nkind = N_Timed_Entry_Call);
3605 
      Set_Node1_With_Parent (N, Val);
3606 
   end Set_Entry_Call_Alternative;
3607 
 
3608 
   procedure Set_Entry_Call_Statement
3609 
      (N : Node_Id; Val : Node_Id) is
3610 
   begin
3611 
      pragma Assert (False
3612 
        or else NT (N).Nkind = N_Entry_Call_Alternative);
3613 
      Set_Node1_With_Parent (N, Val);
3614 
   end Set_Entry_Call_Statement;
3615 
 
3616 
   procedure Set_Entry_Direct_Name
3617 
      (N : Node_Id; Val : Node_Id) is
3618 
   begin
3619 
      pragma Assert (False
3620 
        or else NT (N).Nkind = N_Accept_Statement);
3621 
      Set_Node1_With_Parent (N, Val);
3622 
   end Set_Entry_Direct_Name;
3623 
 
3624 
   procedure Set_Entry_Index
3625 
      (N : Node_Id; Val : Node_Id) is
3626 
   begin
3627 
      pragma Assert (False
3628 
        or else NT (N).Nkind = N_Accept_Statement);
3629 
      Set_Node5_With_Parent (N, Val);
3630 
   end Set_Entry_Index;
3631 
 
3632 
   procedure Set_Entry_Index_Specification
3633 
      (N : Node_Id; Val : Node_Id) is
3634 
   begin
3635 
      pragma Assert (False
3636 
        or else NT (N).Nkind = N_Entry_Body_Formal_Part);
3637 
      Set_Node4_With_Parent (N, Val);
3638 
   end Set_Entry_Index_Specification;
3639 
 
3640 
   procedure Set_Etype
3641 
      (N : Node_Id; Val : Node_Id) is
3642 
   begin
3643 
      pragma Assert (False
3644 
        or else NT (N).Nkind in N_Has_Etype);
3645 
      Set_Node5 (N, Val); -- semantic field, no parent set
3646 
   end Set_Etype;
3647 
 
3648 
   procedure Set_Exception_Choices
3649 
      (N : Node_Id; Val : List_Id) is
3650 
   begin
3651 
      pragma Assert (False
3652 
        or else NT (N).Nkind = N_Exception_Handler);
3653 
      Set_List4_With_Parent (N, Val);
3654 
   end Set_Exception_Choices;
3655 
 
3656 
   procedure Set_Exception_Handlers
3657 
      (N : Node_Id; Val : List_Id) is
3658 
   begin
3659 
      pragma Assert (False
3660 
        or else NT (N).Nkind = N_Handled_Sequence_Of_Statements);
3661 
      Set_List5_With_Parent (N, Val);
3662 
   end Set_Exception_Handlers;
3663 
 
3664 
   procedure Set_Exception_Junk
3665 
     (N : Node_Id; Val : Boolean := True) is
3666 
   begin
3667 
      pragma Assert (False
3668 
        or else NT (N).Nkind = N_Goto_Statement
3669 
        or else NT (N).Nkind = N_Label
3670 
        or else NT (N).Nkind = N_Object_Declaration
3671 
        or else NT (N).Nkind = N_Subtype_Declaration);
3672 
      Set_Flag7 (N, Val);
3673 
   end Set_Exception_Junk;
3674 
 
3675 
   procedure Set_Expansion_Delayed
3676 
     (N : Node_Id; Val : Boolean := True) is
3677 
   begin
3678 
      pragma Assert (False
3679 
        or else NT (N).Nkind = N_Aggregate
3680 
        or else NT (N).Nkind = N_Extension_Aggregate);
3681 
      Set_Flag11 (N, Val);
3682 
   end Set_Expansion_Delayed;
3683 
 
3684 
   procedure Set_Explicit_Actual_Parameter
3685 
      (N : Node_Id; Val : Node_Id) is
3686 
   begin
3687 
      pragma Assert (False
3688 
        or else NT (N).Nkind = N_Parameter_Association);
3689 
      Set_Node3_With_Parent (N, Val);
3690 
   end Set_Explicit_Actual_Parameter;
3691 
 
3692 
   procedure Set_Explicit_Generic_Actual_Parameter
3693 
      (N : Node_Id; Val : Node_Id) is
3694 
   begin
3695 
      pragma Assert (False
3696 
        or else NT (N).Nkind = N_Generic_Association);
3697 
      Set_Node1_With_Parent (N, Val);
3698 
   end Set_Explicit_Generic_Actual_Parameter;
3699 
 
3700 
   procedure Set_Expression
3701 
      (N : Node_Id; Val : Node_Id) is
3702 
   begin
3703 
      pragma Assert (False
3704 
        or else NT (N).Nkind = N_Allocator
3705 
        or else NT (N).Nkind = N_Assignment_Statement
3706 
        or else NT (N).Nkind = N_At_Clause
3707 
        or else NT (N).Nkind = N_Attribute_Definition_Clause
3708 
        or else NT (N).Nkind = N_Case_Statement
3709 
        or else NT (N).Nkind = N_Code_Statement
3710 
        or else NT (N).Nkind = N_Component_Association
3711 
        or else NT (N).Nkind = N_Component_Declaration
3712 
        or else NT (N).Nkind = N_Delay_Relative_Statement
3713 
        or else NT (N).Nkind = N_Delay_Until_Statement
3714 
        or else NT (N).Nkind = N_Discriminant_Association
3715 
        or else NT (N).Nkind = N_Discriminant_Specification
3716 
        or else NT (N).Nkind = N_Exception_Declaration
3717 
        or else NT (N).Nkind = N_Formal_Object_Declaration
3718 
        or else NT (N).Nkind = N_Free_Statement
3719 
        or else NT (N).Nkind = N_Mod_Clause
3720 
        or else NT (N).Nkind = N_Modular_Type_Definition
3721 
        or else NT (N).Nkind = N_Number_Declaration
3722 
        or else NT (N).Nkind = N_Object_Declaration
3723 
        or else NT (N).Nkind = N_Parameter_Specification
3724 
        or else NT (N).Nkind = N_Pragma_Argument_Association
3725 
        or else NT (N).Nkind = N_Qualified_Expression
3726 
        or else NT (N).Nkind = N_Raise_Statement
3727 
        or else NT (N).Nkind = N_Return_Statement
3728 
        or else NT (N).Nkind = N_Type_Conversion
3729 
        or else NT (N).Nkind = N_Unchecked_Expression
3730 
        or else NT (N).Nkind = N_Unchecked_Type_Conversion);
3731 
      Set_Node3_With_Parent (N, Val);
3732 
   end Set_Expression;
3733 
 
3734 
   procedure Set_Expressions
3735 
      (N : Node_Id; Val : List_Id) is
3736 
   begin
3737 
      pragma Assert (False
3738 
        or else NT (N).Nkind = N_Aggregate
3739 
        or else NT (N).Nkind = N_Attribute_Reference
3740 
        or else NT (N).Nkind = N_Conditional_Expression
3741 
        or else NT (N).Nkind = N_Extension_Aggregate
3742 
        or else NT (N).Nkind = N_Indexed_Component);
3743 
      Set_List1_With_Parent (N, Val);
3744 
   end Set_Expressions;
3745 
 
3746 
   procedure Set_First_Bit
3747 
      (N : Node_Id; Val : Node_Id) is
3748 
   begin
3749 
      pragma Assert (False
3750 
        or else NT (N).Nkind = N_Component_Clause);
3751 
      Set_Node3_With_Parent (N, Val);
3752 
   end Set_First_Bit;
3753 
 
3754 
   procedure Set_First_Inlined_Subprogram
3755 
      (N : Node_Id; Val : Entity_Id) is
3756 
   begin
3757 
      pragma Assert (False
3758 
        or else NT (N).Nkind = N_Compilation_Unit);
3759 
      Set_Node3 (N, Val);  -- semantic field, no parent set
3760 
   end Set_First_Inlined_Subprogram;
3761 
 
3762 
   procedure Set_First_Name
3763 
      (N : Node_Id; Val : Boolean := True) is
3764 
   begin
3765 
      pragma Assert (False
3766 
        or else NT (N).Nkind = N_With_Clause);
3767 
      Set_Flag5 (N, Val);
3768 
   end Set_First_Name;
3769 
 
3770 
   procedure Set_First_Named_Actual
3771 
      (N : Node_Id; Val : Node_Id) is
3772 
   begin
3773 
      pragma Assert (False
3774 
        or else NT (N).Nkind = N_Entry_Call_Statement
3775 
        or else NT (N).Nkind = N_Function_Call
3776 
        or else NT (N).Nkind = N_Procedure_Call_Statement);
3777 
      Set_Node4 (N, Val); -- semantic field, no parent set
3778 
   end Set_First_Named_Actual;
3779 
 
3780 
   procedure Set_First_Real_Statement
3781 
      (N : Node_Id; Val : Node_Id) is
3782 
   begin
3783 
      pragma Assert (False
3784 
        or else NT (N).Nkind = N_Handled_Sequence_Of_Statements);
3785 
      Set_Node2 (N, Val); -- semantic field, no parent set
3786 
   end Set_First_Real_Statement;
3787 
 
3788 
   procedure Set_First_Subtype_Link
3789 
      (N : Node_Id; Val : Entity_Id) is
3790 
   begin
3791 
      pragma Assert (False
3792 
        or else NT (N).Nkind = N_Freeze_Entity);
3793 
      Set_Node5 (N, Val); -- semantic field, no parent set
3794 
   end Set_First_Subtype_Link;
3795 
 
3796 
   procedure Set_Float_Truncate
3797 
      (N : Node_Id; Val : Boolean := True) is
3798 
   begin
3799 
      pragma Assert (False
3800 
        or else NT (N).Nkind = N_Type_Conversion);
3801 
      Set_Flag11 (N, Val);
3802 
   end Set_Float_Truncate;
3803 
 
3804 
   procedure Set_Formal_Type_Definition
3805 
      (N : Node_Id; Val : Node_Id) is
3806 
   begin
3807 
      pragma Assert (False
3808 
        or else NT (N).Nkind = N_Formal_Type_Declaration);
3809 
      Set_Node3_With_Parent (N, Val);
3810 
   end Set_Formal_Type_Definition;
3811 
 
3812 
   procedure Set_Forwards_OK
3813 
      (N : Node_Id; Val : Boolean := True) is
3814 
   begin
3815 
      pragma Assert (False
3816 
        or else NT (N).Nkind = N_Assignment_Statement);
3817 
      Set_Flag5 (N, Val);
3818 
   end Set_Forwards_OK;
3819 
 
3820 
   procedure Set_From_At_Mod
3821 
      (N : Node_Id; Val : Boolean := True) is
3822 
   begin
3823 
      pragma Assert (False
3824 
        or else NT (N).Nkind = N_Attribute_Definition_Clause);
3825 
      Set_Flag4 (N, Val);
3826 
   end Set_From_At_Mod;
3827 
 
3828 
   procedure Set_From_Default
3829 
      (N : Node_Id; Val : Boolean := True) is
3830 
   begin
3831 
      pragma Assert (False
3832 
        or else NT (N).Nkind = N_Subprogram_Renaming_Declaration);
3833 
      Set_Flag6 (N, Val);
3834 
   end Set_From_Default;
3835 
 
3836 
   procedure Set_Generic_Associations
3837 
      (N : Node_Id; Val : List_Id) is
3838 
   begin
3839 
      pragma Assert (False
3840 
        or else NT (N).Nkind = N_Formal_Package_Declaration
3841 
        or else NT (N).Nkind = N_Function_Instantiation
3842 
        or else NT (N).Nkind = N_Package_Instantiation
3843 
        or else NT (N).Nkind = N_Procedure_Instantiation);
3844 
      Set_List3_With_Parent (N, Val);
3845 
   end Set_Generic_Associations;
3846 
 
3847 
   procedure Set_Generic_Formal_Declarations
3848 
      (N : Node_Id; Val : List_Id) is
3849 
   begin
3850 
      pragma Assert (False
3851 
        or else NT (N).Nkind = N_Generic_Package_Declaration
3852 
        or else NT (N).Nkind = N_Generic_Subprogram_Declaration);
3853 
      Set_List2_With_Parent (N, Val);
3854 
   end Set_Generic_Formal_Declarations;
3855 
 
3856 
   procedure Set_Generic_Parent
3857 
      (N : Node_Id; Val : Node_Id) is
3858 
   begin
3859 
      pragma Assert (False
3860 
        or else NT (N).Nkind = N_Function_Specification
3861 
        or else NT (N).Nkind = N_Package_Specification
3862 
        or else NT (N).Nkind = N_Procedure_Specification);
3863 
      Set_Node5 (N, Val);
3864 
   end Set_Generic_Parent;
3865 
 
3866 
   procedure Set_Generic_Parent_Type
3867 
      (N : Node_Id; Val : Node_Id) is
3868 
   begin
3869 
      pragma Assert (False
3870 
        or else NT (N).Nkind = N_Subtype_Declaration);
3871 
      Set_Node4 (N, Val);
3872 
   end Set_Generic_Parent_Type;
3873 
 
3874 
   procedure Set_Handled_Statement_Sequence
3875 
      (N : Node_Id; Val : Node_Id) is
3876 
   begin
3877 
      pragma Assert (False
3878 
        or else NT (N).Nkind = N_Accept_Statement
3879 
        or else NT (N).Nkind = N_Block_Statement
3880 
        or else NT (N).Nkind = N_Entry_Body
3881 
        or else NT (N).Nkind = N_Package_Body
3882 
        or else NT (N).Nkind = N_Subprogram_Body
3883 
        or else NT (N).Nkind = N_Task_Body);
3884 
      Set_Node4_With_Parent (N, Val);
3885 
   end Set_Handled_Statement_Sequence;
3886 
 
3887 
   procedure Set_Handler_List_Entry
3888 
      (N : Node_Id; Val : Node_Id) is
3889 
   begin
3890 
      pragma Assert (False
3891 
        or else NT (N).Nkind = N_Object_Declaration);
3892 
      Set_Node2 (N, Val);
3893 
   end Set_Handler_List_Entry;
3894 
 
3895 
   procedure Set_Has_Created_Identifier
3896 
      (N : Node_Id; Val : Boolean := True) is
3897 
   begin
3898 
      pragma Assert (False
3899 
        or else NT (N).Nkind = N_Block_Statement
3900 
        or else NT (N).Nkind = N_Loop_Statement);
3901 
      Set_Flag15 (N, Val);
3902 
   end Set_Has_Created_Identifier;
3903 
 
3904 
   procedure Set_Has_Dynamic_Length_Check
3905 
      (N : Node_Id; Val : Boolean := True) is
3906 
   begin
3907 
      Set_Flag10 (N, Val);
3908 
   end Set_Has_Dynamic_Length_Check;
3909 
 
3910 
   procedure Set_Has_Dynamic_Range_Check
3911 
      (N : Node_Id; Val : Boolean := True) is
3912 
   begin
3913 
      Set_Flag12 (N, Val);
3914 
   end Set_Has_Dynamic_Range_Check;
3915 
 
3916 
   procedure Set_Has_No_Elaboration_Code
3917 
      (N : Node_Id; Val : Boolean := True) is
3918 
   begin
3919 
      pragma Assert (False
3920 
        or else NT (N).Nkind = N_Compilation_Unit);
3921 
      Set_Flag17 (N, Val);
3922 
   end Set_Has_No_Elaboration_Code;
3923 
 
3924 
   procedure Set_Has_Priority_Pragma
3925 
      (N : Node_Id; Val : Boolean := True) is
3926 
   begin
3927 
      pragma Assert (False
3928 
        or else NT (N).Nkind = N_Protected_Definition
3929 
        or else NT (N).Nkind = N_Subprogram_Body
3930 
        or else NT (N).Nkind = N_Task_Definition);
3931 
      Set_Flag6 (N, Val);
3932 
   end Set_Has_Priority_Pragma;
3933 
 
3934 
   procedure Set_Has_Private_View
3935 
      (N : Node_Id; Val : Boolean := True) is
3936 
   begin
3937 
      pragma Assert (False
3938 
       or else NT (N).Nkind in N_Op
3939 
       or else NT (N).Nkind = N_Character_Literal
3940 
       or else NT (N).Nkind = N_Expanded_Name
3941 
       or else NT (N).Nkind = N_Identifier
3942 
       or else NT (N).Nkind = N_Operator_Symbol);
3943 
      Set_Flag11 (N, Val);
3944 
   end Set_Has_Private_View;
3945 
 
3946 
   procedure Set_Has_Storage_Size_Pragma
3947 
      (N : Node_Id; Val : Boolean := True) is
3948 
   begin
3949 
      pragma Assert (False
3950 
        or else NT (N).Nkind = N_Task_Definition);
3951 
      Set_Flag5 (N, Val);
3952 
   end Set_Has_Storage_Size_Pragma;
3953 
 
3954 
   procedure Set_Has_Task_Info_Pragma
3955 
      (N : Node_Id; Val : Boolean := True) is
3956 
   begin
3957 
      pragma Assert (False
3958 
        or else NT (N).Nkind = N_Task_Definition);
3959 
      Set_Flag7 (N, Val);
3960 
   end Set_Has_Task_Info_Pragma;
3961 
 
3962 
   procedure Set_Has_Task_Name_Pragma
3963 
      (N : Node_Id; Val : Boolean := True) is
3964 
   begin
3965 
      pragma Assert (False
3966 
        or else NT (N).Nkind = N_Task_Definition);
3967 
      Set_Flag8 (N, Val);
3968 
   end Set_Has_Task_Name_Pragma;
3969 
 
3970 
   procedure Set_Has_Wide_Character
3971 
      (N : Node_Id; Val : Boolean := True) is
3972 
   begin
3973 
      pragma Assert (False
3974 
        or else NT (N).Nkind = N_String_Literal);
3975 
      Set_Flag11 (N, Val);
3976 
   end Set_Has_Wide_Character;
3977 
 
3978 
   procedure Set_Hidden_By_Use_Clause
3979 
     (N : Node_Id; Val : Elist_Id) is
3980 
   begin
3981 
      pragma Assert (False
3982 
        or else NT (N).Nkind = N_Use_Package_Clause
3983 
        or else NT (N).Nkind = N_Use_Type_Clause);
3984 
      Set_Elist4 (N, Val);
3985 
   end Set_Hidden_By_Use_Clause;
3986 
 
3987 
   procedure Set_High_Bound
3988 
      (N : Node_Id; Val : Node_Id) is
3989 
   begin
3990 
      pragma Assert (False
3991 
        or else NT (N).Nkind = N_Range
3992 
        or else NT (N).Nkind = N_Real_Range_Specification
3993 
        or else NT (N).Nkind = N_Signed_Integer_Type_Definition);
3994 
      Set_Node2_With_Parent (N, Val);
3995 
   end Set_High_Bound;
3996 
 
3997 
   procedure Set_Identifier
3998 
      (N : Node_Id; Val : Node_Id) is
3999 
   begin
4000 
      pragma Assert (False
4001 
        or else NT (N).Nkind = N_At_Clause
4002 
        or else NT (N).Nkind = N_Block_Statement
4003 
        or else NT (N).Nkind = N_Designator
4004 
        or else NT (N).Nkind = N_Enumeration_Representation_Clause
4005 
        or else NT (N).Nkind = N_Label
4006 
        or else NT (N).Nkind = N_Loop_Statement
4007 
        or else NT (N).Nkind = N_Record_Representation_Clause
4008 
        or else NT (N).Nkind = N_Subprogram_Info);
4009 
      Set_Node1_With_Parent (N, Val);
4010 
   end Set_Identifier;
4011 
 
4012 
   procedure Set_Implicit_With
4013 
      (N : Node_Id; Val : Boolean := True) is
4014 
   begin
4015 
      pragma Assert (False
4016 
        or else NT (N).Nkind = N_With_Clause);
4017 
      Set_Flag16 (N, Val);
4018 
   end Set_Implicit_With;
4019 
 
4020 
   procedure Set_Interface_List
4021 
      (N : Node_Id; Val : List_Id) is
4022 
   begin
4023 
      pragma Assert (False
4024 
        or else NT (N).Nkind = N_Derived_Type_Definition
4025 
        or else NT (N).Nkind = N_Formal_Derived_Type_Definition
4026 
        or else NT (N).Nkind = N_Private_Extension_Declaration
4027 
        or else NT (N).Nkind = N_Protected_Type_Declaration
4028 
        or else NT (N).Nkind = N_Record_Definition
4029 
        or else NT (N).Nkind = N_Single_Protected_Declaration
4030 
        or else NT (N).Nkind = N_Single_Task_Declaration
4031 
        or else NT (N).Nkind = N_Task_Type_Declaration);
4032 
      Set_List2_With_Parent (N, Val);
4033 
   end Set_Interface_List;
4034 
 
4035 
   procedure Set_Interface_Present
4036 
      (N : Node_Id; Val : Boolean := True) is
4037 
   begin
4038 
      pragma Assert (False
4039 
        or else NT (N).Nkind = N_Derived_Type_Definition
4040 
        or else NT (N).Nkind = N_Record_Definition);
4041 
      Set_Flag16 (N, Val);
4042 
   end Set_Interface_Present;
4043 
 
4044 
   procedure Set_In_Present
4045 
      (N : Node_Id; Val : Boolean := True) is
4046 
   begin
4047 
      pragma Assert (False
4048 
        or else NT (N).Nkind = N_Formal_Object_Declaration
4049 
        or else NT (N).Nkind = N_Parameter_Specification);
4050 
      Set_Flag15 (N, Val);
4051 
   end Set_In_Present;
4052 
 
4053 
   procedure Set_Includes_Infinities
4054 
      (N : Node_Id; Val : Boolean := True) is
4055 
   begin
4056 
      pragma Assert (False
4057 
        or else NT (N).Nkind = N_Range);
4058 
      Set_Flag11 (N, Val);
4059 
   end Set_Includes_Infinities;
4060 
 
4061 
   procedure Set_Instance_Spec
4062 
      (N : Node_Id; Val : Node_Id) is
4063 
   begin
4064 
      pragma Assert (False
4065 
        or else NT (N).Nkind = N_Formal_Package_Declaration
4066 
        or else NT (N).Nkind = N_Function_Instantiation
4067 
        or else NT (N).Nkind = N_Package_Instantiation
4068 
        or else NT (N).Nkind = N_Procedure_Instantiation);
4069 
      Set_Node5 (N, Val); -- semantic field, no Parent set
4070 
   end Set_Instance_Spec;
4071 
 
4072 
   procedure Set_Intval
4073 
      (N : Node_Id; Val : Uint) is
4074 
   begin
4075 
      pragma Assert (False
4076 
        or else NT (N).Nkind = N_Integer_Literal);
4077 
      Set_Uint3 (N, Val);
4078 
   end Set_Intval;
4079 
 
4080 
   procedure Set_Is_Asynchronous_Call_Block
4081 
      (N : Node_Id; Val : Boolean := True) is
4082 
   begin
4083 
      pragma Assert (False
4084 
        or else NT (N).Nkind = N_Block_Statement);
4085 
      Set_Flag7 (N, Val);
4086 
   end Set_Is_Asynchronous_Call_Block;
4087 
 
4088 
   procedure Set_Is_Component_Left_Opnd
4089 
      (N : Node_Id; Val : Boolean := True) is
4090 
   begin
4091 
      pragma Assert (False
4092 
        or else NT (N).Nkind = N_Op_Concat);
4093 
      Set_Flag13 (N, Val);
4094 
   end Set_Is_Component_Left_Opnd;
4095 
 
4096 
   procedure Set_Is_Component_Right_Opnd
4097 
      (N : Node_Id; Val : Boolean := True) is
4098 
   begin
4099 
      pragma Assert (False
4100 
        or else NT (N).Nkind = N_Op_Concat);
4101 
      Set_Flag14 (N, Val);
4102 
   end Set_Is_Component_Right_Opnd;
4103 
 
4104 
   procedure Set_Is_Controlling_Actual
4105 
      (N : Node_Id; Val : Boolean := True) is
4106 
   begin
4107 
      pragma Assert (False
4108 
        or else NT (N).Nkind in N_Subexpr);
4109 
      Set_Flag16 (N, Val);
4110 
   end Set_Is_Controlling_Actual;
4111 
 
4112 
   procedure Set_Is_In_Discriminant_Check
4113 
      (N : Node_Id; Val : Boolean := True) is
4114 
   begin
4115 
      pragma Assert (False
4116 
        or else NT (N).Nkind = N_Selected_Component);
4117 
      Set_Flag11 (N, Val);
4118 
   end Set_Is_In_Discriminant_Check;
4119 
 
4120 
   procedure Set_Is_Machine_Number
4121 
      (N : Node_Id; Val : Boolean := True) is
4122 
   begin
4123 
      pragma Assert (False
4124 
        or else NT (N).Nkind = N_Real_Literal);
4125 
      Set_Flag11 (N, Val);
4126 
   end Set_Is_Machine_Number;
4127 
 
4128 
   procedure Set_Is_Null_Loop
4129 
      (N : Node_Id; Val : Boolean := True) is
4130 
   begin
4131 
      pragma Assert (False
4132 
        or else NT (N).Nkind = N_Loop_Statement);
4133 
      Set_Flag16 (N, Val);
4134 
   end Set_Is_Null_Loop;
4135 
 
4136 
   procedure Set_Is_Overloaded
4137 
      (N : Node_Id; Val : Boolean := True) is
4138 
   begin
4139 
      pragma Assert (False
4140 
        or else NT (N).Nkind in N_Subexpr);
4141 
      Set_Flag5 (N, Val);
4142 
   end Set_Is_Overloaded;
4143 
 
4144 
   procedure Set_Is_Power_Of_2_For_Shift
4145 
      (N : Node_Id; Val : Boolean := True) is
4146 
   begin
4147 
      pragma Assert (False
4148 
        or else NT (N).Nkind = N_Op_Expon);
4149 
      Set_Flag13 (N, Val);
4150 
   end Set_Is_Power_Of_2_For_Shift;
4151 
 
4152 
   procedure Set_Is_Protected_Subprogram_Body
4153 
      (N : Node_Id; Val : Boolean := True) is
4154 
   begin
4155 
      pragma Assert (False
4156 
        or else NT (N).Nkind = N_Subprogram_Body);
4157 
      Set_Flag7 (N, Val);
4158 
   end Set_Is_Protected_Subprogram_Body;
4159 
 
4160 
   procedure Set_Is_Static_Expression
4161 
      (N : Node_Id; Val : Boolean := True) is
4162 
   begin
4163 
      pragma Assert (False
4164 
        or else NT (N).Nkind in N_Subexpr);
4165 
      Set_Flag6 (N, Val);
4166 
   end Set_Is_Static_Expression;
4167 
 
4168 
   procedure Set_Is_Subprogram_Descriptor
4169 
      (N : Node_Id; Val : Boolean := True) is
4170 
   begin
4171 
      pragma Assert (False
4172 
        or else NT (N).Nkind = N_Object_Declaration);
4173 
      Set_Flag16 (N, Val);
4174 
   end Set_Is_Subprogram_Descriptor;
4175 
 
4176 
   procedure Set_Is_Task_Allocation_Block
4177 
      (N : Node_Id; Val : Boolean := True) is
4178 
   begin
4179 
      pragma Assert (False
4180 
        or else NT (N).Nkind = N_Block_Statement);
4181 
      Set_Flag6 (N, Val);
4182 
   end Set_Is_Task_Allocation_Block;
4183 
 
4184 
   procedure Set_Is_Task_Master
4185 
      (N : Node_Id; Val : Boolean := True) is
4186 
   begin
4187 
      pragma Assert (False
4188 
        or else NT (N).Nkind = N_Block_Statement
4189 
        or else NT (N).Nkind = N_Subprogram_Body
4190 
        or else NT (N).Nkind = N_Task_Body);
4191 
      Set_Flag5 (N, Val);
4192 
   end Set_Is_Task_Master;
4193 
 
4194 
   procedure Set_Iteration_Scheme
4195 
      (N : Node_Id; Val : Node_Id) is
4196 
   begin
4197 
      pragma Assert (False
4198 
        or else NT (N).Nkind = N_Loop_Statement);
4199 
      Set_Node2_With_Parent (N, Val);
4200 
   end Set_Iteration_Scheme;
4201 
 
4202 
   procedure Set_Itype
4203 
      (N : Node_Id; Val : Entity_Id) is
4204 
   begin
4205 
      pragma Assert (False
4206 
      or else NT (N).Nkind = N_Itype_Reference);
4207 
      Set_Node1 (N, Val); -- no parent, semantic field
4208 
   end Set_Itype;
4209 
 
4210 
   procedure Set_Kill_Range_Check
4211 
      (N : Node_Id; Val : Boolean := True) is
4212 
   begin
4213 
      pragma Assert (False
4214 
        or else NT (N).Nkind = N_Unchecked_Type_Conversion);
4215 
      Set_Flag11 (N, Val);
4216 
   end Set_Kill_Range_Check;
4217 
 
4218 
   procedure Set_Label_Construct
4219 
      (N : Node_Id; Val : Node_Id) is
4220 
   begin
4221 
      pragma Assert (False
4222 
        or else NT (N).Nkind = N_Implicit_Label_Declaration);
4223 
      Set_Node2 (N, Val); -- semantic field, no parent set
4224 
   end Set_Label_Construct;
4225 
 
4226 
   procedure Set_Last_Bit
4227 
      (N : Node_Id; Val : Node_Id) is
4228 
   begin
4229 
      pragma Assert (False
4230 
        or else NT (N).Nkind = N_Component_Clause);
4231 
      Set_Node4_With_Parent (N, Val);
4232 
   end Set_Last_Bit;
4233 
 
4234 
   procedure Set_Last_Name
4235 
      (N : Node_Id; Val : Boolean := True) is
4236 
   begin
4237 
      pragma Assert (False
4238 
        or else NT (N).Nkind = N_With_Clause);
4239 
      Set_Flag6 (N, Val);
4240 
   end Set_Last_Name;
4241 
 
4242 
   procedure Set_Left_Opnd
4243 
      (N : Node_Id; Val : Node_Id) is
4244 
   begin
4245 
      pragma Assert (False
4246 
        or else NT (N).Nkind = N_And_Then
4247 
        or else NT (N).Nkind = N_In
4248 
        or else NT (N).Nkind = N_Not_In
4249 
        or else NT (N).Nkind = N_Or_Else
4250 
        or else NT (N).Nkind in N_Binary_Op);
4251 
      Set_Node2_With_Parent (N, Val);
4252 
   end Set_Left_Opnd;
4253 
 
4254 
   procedure Set_Library_Unit
4255 
      (N : Node_Id; Val : Node_Id) is
4256 
   begin
4257 
      pragma Assert (False
4258 
        or else NT (N).Nkind = N_Compilation_Unit
4259 
        or else NT (N).Nkind = N_Package_Body_Stub
4260 
        or else NT (N).Nkind = N_Protected_Body_Stub
4261 
        or else NT (N).Nkind = N_Subprogram_Body_Stub
4262 
        or else NT (N).Nkind = N_Task_Body_Stub
4263 
        or else NT (N).Nkind = N_With_Clause);
4264 
      Set_Node4 (N, Val); -- semantic field, no parent set
4265 
   end Set_Library_Unit;
4266 
 
4267 
   procedure Set_Limited_View_Installed
4268 
      (N : Node_Id; Val : Boolean := True) is
4269 
   begin
4270 
      pragma Assert (False
4271 
        or else NT (N).Nkind = N_Package_Specification
4272 
        or else NT (N).Nkind = N_With_Clause);
4273 
      Set_Flag18 (N, Val);
4274 
   end Set_Limited_View_Installed;
4275 
 
4276 
   procedure Set_Limited_Present
4277 
      (N : Node_Id; Val : Boolean := True) is
4278 
   begin
4279 
      pragma Assert (False
4280 
        or else NT (N).Nkind = N_Derived_Type_Definition
4281 
        or else NT (N).Nkind = N_Formal_Private_Type_Definition
4282 
        or else NT (N).Nkind = N_Private_Extension_Declaration
4283 
        or else NT (N).Nkind = N_Private_Type_Declaration
4284 
        or else NT (N).Nkind = N_Record_Definition
4285 
        or else NT (N).Nkind = N_With_Clause);
4286 
      Set_Flag17 (N, Val);
4287 
   end Set_Limited_Present;
4288 
 
4289 
   procedure Set_Literals
4290 
      (N : Node_Id; Val : List_Id) is
4291 
   begin
4292 
      pragma Assert (False
4293 
        or else NT (N).Nkind = N_Enumeration_Type_Definition);
4294 
      Set_List1_With_Parent (N, Val);
4295 
   end Set_Literals;
4296 
 
4297 
   procedure Set_Loop_Actions
4298 
      (N : Node_Id; Val : List_Id) is
4299 
   begin
4300 
      pragma Assert (False
4301 
        or else NT (N).Nkind = N_Component_Association);
4302 
      Set_List2 (N, Val); -- semantic field, no parent set
4303 
   end Set_Loop_Actions;
4304 
 
4305 
   procedure Set_Loop_Parameter_Specification
4306 
      (N : Node_Id; Val : Node_Id) is
4307 
   begin
4308 
      pragma Assert (False
4309 
        or else NT (N).Nkind = N_Iteration_Scheme);
4310 
      Set_Node4_With_Parent (N, Val);
4311 
   end Set_Loop_Parameter_Specification;
4312 
 
4313 
   procedure Set_Low_Bound
4314 
      (N : Node_Id; Val : Node_Id) is
4315 
   begin
4316 
      pragma Assert (False
4317 
        or else NT (N).Nkind = N_Range
4318 
        or else NT (N).Nkind = N_Real_Range_Specification
4319 
        or else NT (N).Nkind = N_Signed_Integer_Type_Definition);
4320 
      Set_Node1_With_Parent (N, Val);
4321 
   end Set_Low_Bound;
4322 
 
4323 
   procedure Set_Mod_Clause
4324 
      (N : Node_Id; Val : Node_Id) is
4325 
   begin
4326 
      pragma Assert (False
4327 
        or else NT (N).Nkind = N_Record_Representation_Clause);
4328 
      Set_Node2_With_Parent (N, Val);
4329 
   end Set_Mod_Clause;
4330 
 
4331 
   procedure Set_More_Ids
4332 
      (N : Node_Id; Val : Boolean := True) is
4333 
   begin
4334 
      pragma Assert (False
4335 
        or else NT (N).Nkind = N_Component_Declaration
4336 
        or else NT (N).Nkind = N_Discriminant_Specification
4337 
        or else NT (N).Nkind = N_Exception_Declaration
4338 
        or else NT (N).Nkind = N_Formal_Object_Declaration
4339 
        or else NT (N).Nkind = N_Number_Declaration
4340 
        or else NT (N).Nkind = N_Object_Declaration
4341 
        or else NT (N).Nkind = N_Parameter_Specification);
4342 
      Set_Flag5 (N, Val);
4343 
   end Set_More_Ids;
4344 
 
4345 
   procedure Set_Must_Be_Byte_Aligned
4346 
      (N : Node_Id; Val : Boolean := True) is
4347 
   begin
4348 
      pragma Assert (False
4349 
        or else NT (N).Nkind = N_Attribute_Reference);
4350 
      Set_Flag14 (N, Val);
4351 
   end Set_Must_Be_Byte_Aligned;
4352 
 
4353 
   procedure Set_Must_Not_Freeze
4354 
      (N : Node_Id; Val : Boolean := True) is
4355 
   begin
4356 
      pragma Assert (False
4357 
        or else NT (N).Nkind = N_Subtype_Indication
4358 
        or else NT (N).Nkind in N_Subexpr);
4359 
      Set_Flag8 (N, Val);
4360 
   end Set_Must_Not_Freeze;
4361 
 
4362 
   procedure Set_Must_Not_Override
4363 
      (N : Node_Id; Val : Boolean := True) is
4364 
   begin
4365 
      pragma Assert (False
4366 
        or else NT (N).Nkind = N_Entry_Declaration
4367 
        or else NT (N).Nkind = N_Function_Instantiation
4368 
        or else NT (N).Nkind = N_Function_Specification
4369 
        or else NT (N).Nkind = N_Procedure_Instantiation
4370 
        or else NT (N).Nkind = N_Procedure_Specification);
4371 
      Set_Flag15 (N, Val);
4372 
   end Set_Must_Not_Override;
4373 
 
4374 
   procedure Set_Must_Override
4375 
      (N : Node_Id; Val : Boolean := True) is
4376 
   begin
4377 
      pragma Assert (False
4378 
        or else NT (N).Nkind = N_Entry_Declaration
4379 
        or else NT (N).Nkind = N_Function_Instantiation
4380 
        or else NT (N).Nkind = N_Function_Specification
4381 
        or else NT (N).Nkind = N_Procedure_Instantiation
4382 
        or else NT (N).Nkind = N_Procedure_Specification);
4383 
      Set_Flag14 (N, Val);
4384 
   end Set_Must_Override;
4385 
 
4386 
   procedure Set_Name
4387 
      (N : Node_Id; Val : Node_Id) is
4388 
   begin
4389 
      pragma Assert (False
4390 
        or else NT (N).Nkind = N_Assignment_Statement
4391 
        or else NT (N).Nkind = N_Attribute_Definition_Clause
4392 
        or else NT (N).Nkind = N_Defining_Program_Unit_Name
4393 
        or else NT (N).Nkind = N_Designator
4394 
        or else NT (N).Nkind = N_Entry_Call_Statement
4395 
        or else NT (N).Nkind = N_Exception_Renaming_Declaration
4396 
        or else NT (N).Nkind = N_Exit_Statement
4397 
        or else NT (N).Nkind = N_Formal_Package_Declaration
4398 
        or else NT (N).Nkind = N_Function_Call
4399 
        or else NT (N).Nkind = N_Function_Instantiation
4400 
        or else NT (N).Nkind = N_Generic_Function_Renaming_Declaration
4401 
        or else NT (N).Nkind = N_Generic_Package_Renaming_Declaration
4402 
        or else NT (N).Nkind = N_Generic_Procedure_Renaming_Declaration
4403 
        or else NT (N).Nkind = N_Goto_Statement
4404 
        or else NT (N).Nkind = N_Object_Renaming_Declaration
4405 
        or else NT (N).Nkind = N_Package_Instantiation
4406 
        or else NT (N).Nkind = N_Package_Renaming_Declaration
4407 
        or else NT (N).Nkind = N_Procedure_Call_Statement
4408 
        or else NT (N).Nkind = N_Procedure_Instantiation
4409 
        or else NT (N).Nkind = N_Raise_Statement
4410 
        or else NT (N).Nkind = N_Requeue_Statement
4411 
        or else NT (N).Nkind = N_Subprogram_Renaming_Declaration
4412 
        or else NT (N).Nkind = N_Subunit
4413 
        or else NT (N).Nkind = N_Variant_Part
4414 
        or else NT (N).Nkind = N_With_Clause
4415 
        or else NT (N).Nkind = N_With_Type_Clause);
4416 
      Set_Node2_With_Parent (N, Val);
4417 
   end Set_Name;
4418 
 
4419 
   procedure Set_Names
4420 
      (N : Node_Id; Val : List_Id) is
4421 
   begin
4422 
      pragma Assert (False
4423 
        or else NT (N).Nkind = N_Abort_Statement
4424 
        or else NT (N).Nkind = N_Use_Package_Clause);
4425 
      Set_List2_With_Parent (N, Val);
4426 
   end Set_Names;
4427 
 
4428 
   procedure Set_Next_Entity
4429 
      (N : Node_Id; Val : Node_Id) is
4430 
   begin
4431 
      pragma Assert (False
4432 
        or else NT (N).Nkind = N_Defining_Character_Literal
4433 
        or else NT (N).Nkind = N_Defining_Identifier
4434 
        or else NT (N).Nkind = N_Defining_Operator_Symbol);
4435 
      Set_Node2 (N, Val); -- semantic field, no parent set
4436 
   end Set_Next_Entity;
4437 
 
4438 
   procedure Set_Next_Named_Actual
4439 
      (N : Node_Id; Val : Node_Id) is
4440 
   begin
4441 
      pragma Assert (False
4442 
        or else NT (N).Nkind = N_Parameter_Association);
4443 
      Set_Node4 (N, Val); -- semantic field, no parent set
4444 
   end Set_Next_Named_Actual;
4445 
 
4446 
   procedure Set_Next_Rep_Item
4447 
      (N : Node_Id; Val : Node_Id) is
4448 
   begin
4449 
      pragma Assert (False
4450 
        or else NT (N).Nkind = N_Attribute_Definition_Clause
4451 
        or else NT (N).Nkind = N_Enumeration_Representation_Clause
4452 
        or else NT (N).Nkind = N_Pragma
4453 
        or else NT (N).Nkind = N_Record_Representation_Clause);
4454 
      Set_Node4 (N, Val); -- semantic field, no parent set
4455 
   end Set_Next_Rep_Item;
4456 
 
4457 
   procedure Set_Next_Use_Clause
4458 
      (N : Node_Id; Val : Node_Id) is
4459 
   begin
4460 
      pragma Assert (False
4461 
        or else NT (N).Nkind = N_Use_Package_Clause
4462 
        or else NT (N).Nkind = N_Use_Type_Clause);
4463 
      Set_Node3 (N, Val); -- semantic field, no parent set
4464 
   end Set_Next_Use_Clause;
4465 
 
4466 
   procedure Set_No_Ctrl_Actions
4467 
      (N : Node_Id; Val : Boolean := True) is
4468 
   begin
4469 
      pragma Assert (False
4470 
        or else NT (N).Nkind = N_Assignment_Statement);
4471 
      Set_Flag7 (N, Val);
4472 
   end Set_No_Ctrl_Actions;
4473 
 
4474 
   procedure Set_No_Elaboration_Check
4475 
      (N : Node_Id; Val : Boolean := True) is
4476 
   begin
4477 
      pragma Assert (False
4478 
        or else NT (N).Nkind = N_Function_Call
4479 
        or else NT (N).Nkind = N_Procedure_Call_Statement);
4480 
      Set_Flag14 (N, Val);
4481 
   end Set_No_Elaboration_Check;
4482 
 
4483 
   procedure Set_No_Entities_Ref_In_Spec
4484 
      (N : Node_Id; Val : Boolean := True) is
4485 
   begin
4486 
      pragma Assert (False
4487 
        or else NT (N).Nkind = N_With_Clause);
4488 
      Set_Flag8 (N, Val);
4489 
   end Set_No_Entities_Ref_In_Spec;
4490 
 
4491 
   procedure Set_No_Initialization
4492 
      (N : Node_Id; Val : Boolean := True) is
4493 
   begin
4494 
      pragma Assert (False
4495 
        or else NT (N).Nkind = N_Allocator
4496 
        or else NT (N).Nkind = N_Object_Declaration);
4497 
      Set_Flag13 (N, Val);
4498 
   end Set_No_Initialization;
4499 
 
4500 
   procedure Set_No_Truncation
4501 
      (N : Node_Id; Val : Boolean := True) is
4502 
   begin
4503 
      pragma Assert (False
4504 
        or else NT (N).Nkind = N_Unchecked_Type_Conversion);
4505 
      Set_Flag17 (N, Val);
4506 
   end Set_No_Truncation;
4507 
 
4508 
   procedure Set_Null_Present
4509 
      (N : Node_Id; Val : Boolean := True) is
4510 
   begin
4511 
      pragma Assert (False
4512 
        or else NT (N).Nkind = N_Component_List
4513 
        or else NT (N).Nkind = N_Procedure_Specification
4514 
        or else NT (N).Nkind = N_Record_Definition);
4515 
      Set_Flag13 (N, Val);
4516 
   end Set_Null_Present;
4517 
 
4518 
   procedure Set_Null_Exclusion_Present
4519 
      (N : Node_Id; Val : Boolean := True) is
4520 
   begin
4521 
      pragma Assert (False
4522 
        or else NT (N).Nkind = N_Access_Definition
4523 
        or else NT (N).Nkind = N_Access_Function_Definition
4524 
        or else NT (N).Nkind = N_Access_Procedure_Definition
4525 
        or else NT (N).Nkind = N_Access_To_Object_Definition
4526 
        or else NT (N).Nkind = N_Allocator
4527 
        or else NT (N).Nkind = N_Component_Definition
4528 
        or else NT (N).Nkind = N_Derived_Type_Definition
4529 
        or else NT (N).Nkind = N_Discriminant_Specification
4530 
        or else NT (N).Nkind = N_Function_Specification
4531 
        or else NT (N).Nkind = N_Object_Declaration
4532 
        or else NT (N).Nkind = N_Parameter_Specification
4533 
        or else NT (N).Nkind = N_Subtype_Declaration);
4534 
      Set_Flag11 (N, Val);
4535 
   end Set_Null_Exclusion_Present;
4536 
 
4537 
   procedure Set_Null_Record_Present
4538 
      (N : Node_Id; Val : Boolean := True) is
4539 
   begin
4540 
      pragma Assert (False
4541 
        or else NT (N).Nkind = N_Aggregate
4542 
        or else NT (N).Nkind = N_Extension_Aggregate);
4543 
      Set_Flag17 (N, Val);
4544 
   end Set_Null_Record_Present;
4545 
 
4546 
   procedure Set_Object_Definition
4547 
      (N : Node_Id; Val : Node_Id) is
4548 
   begin
4549 
      pragma Assert (False
4550 
        or else NT (N).Nkind = N_Object_Declaration);
4551 
      Set_Node4_With_Parent (N, Val);
4552 
   end Set_Object_Definition;
4553 
 
4554 
   procedure Set_Original_Discriminant
4555 
      (N : Node_Id; Val : Node_Id) is
4556 
   begin
4557 
      pragma Assert (False
4558 
        or else NT (N).Nkind = N_Identifier);
4559 
      Set_Node2 (N, Val); -- semantic field, no parent set
4560 
   end Set_Original_Discriminant;
4561 
 
4562 
   procedure Set_Original_Entity
4563 
      (N : Node_Id; Val : Entity_Id) is
4564 
   begin
4565 
      pragma Assert (False
4566 
        or else NT (N).Nkind = N_Integer_Literal
4567 
        or else NT (N).Nkind = N_Real_Literal);
4568 
      Set_Node2 (N, Val); --  semantic field, no parent set
4569 
   end Set_Original_Entity;
4570 
 
4571 
   procedure Set_Others_Discrete_Choices
4572 
      (N : Node_Id; Val : List_Id) is
4573 
   begin
4574 
      pragma Assert (False
4575 
        or else NT (N).Nkind = N_Others_Choice);
4576 
      Set_List1_With_Parent (N, Val);
4577 
   end Set_Others_Discrete_Choices;
4578 
 
4579 
   procedure Set_Out_Present
4580 
      (N : Node_Id; Val : Boolean := True) is
4581 
   begin
4582 
      pragma Assert (False
4583 
        or else NT (N).Nkind = N_Formal_Object_Declaration
4584 
        or else NT (N).Nkind = N_Parameter_Specification);
4585 
      Set_Flag17 (N, Val);
4586 
   end Set_Out_Present;
4587 
 
4588 
   procedure Set_Parameter_Associations
4589 
      (N : Node_Id; Val : List_Id) is
4590 
   begin
4591 
      pragma Assert (False
4592 
        or else NT (N).Nkind = N_Entry_Call_Statement
4593 
        or else NT (N).Nkind = N_Function_Call
4594 
        or else NT (N).Nkind = N_Procedure_Call_Statement);
4595 
      Set_List3_With_Parent (N, Val);
4596 
   end Set_Parameter_Associations;
4597 
 
4598 
   procedure Set_Parameter_List_Truncated
4599 
      (N : Node_Id; Val : Boolean := True) is
4600 
   begin
4601 
      pragma Assert (False
4602 
        or else NT (N).Nkind = N_Function_Call
4603 
        or else NT (N).Nkind = N_Procedure_Call_Statement);
4604 
      Set_Flag17 (N, Val);
4605 
   end Set_Parameter_List_Truncated;
4606 
 
4607 
   procedure Set_Parameter_Specifications
4608 
      (N : Node_Id; Val : List_Id) is
4609 
   begin
4610 
      pragma Assert (False
4611 
        or else NT (N).Nkind = N_Accept_Statement
4612 
        or else NT (N).Nkind = N_Access_Function_Definition
4613 
        or else NT (N).Nkind = N_Access_Procedure_Definition
4614 
        or else NT (N).Nkind = N_Entry_Body_Formal_Part
4615 
        or else NT (N).Nkind = N_Entry_Declaration
4616 
        or else NT (N).Nkind = N_Function_Specification
4617 
        or else NT (N).Nkind = N_Procedure_Specification);
4618 
      Set_List3_With_Parent (N, Val);
4619 
   end Set_Parameter_Specifications;
4620 
 
4621 
   procedure Set_Parameter_Type
4622 
      (N : Node_Id; Val : Node_Id) is
4623 
   begin
4624 
      pragma Assert (False
4625 
        or else NT (N).Nkind = N_Parameter_Specification);
4626 
      Set_Node2_With_Parent (N, Val);
4627 
   end Set_Parameter_Type;
4628 
 
4629 
   procedure Set_Parent_Spec
4630 
      (N : Node_Id; Val : Node_Id) is
4631 
   begin
4632 
      pragma Assert (False
4633 
        or else NT (N).Nkind = N_Function_Instantiation
4634 
        or else NT (N).Nkind = N_Generic_Function_Renaming_Declaration
4635 
        or else NT (N).Nkind = N_Generic_Package_Declaration
4636 
        or else NT (N).Nkind = N_Generic_Package_Renaming_Declaration
4637 
        or else NT (N).Nkind = N_Generic_Procedure_Renaming_Declaration
4638 
        or else NT (N).Nkind = N_Generic_Subprogram_Declaration
4639 
        or else NT (N).Nkind = N_Package_Declaration
4640 
        or else NT (N).Nkind = N_Package_Instantiation
4641 
        or else NT (N).Nkind = N_Package_Renaming_Declaration
4642 
        or else NT (N).Nkind = N_Procedure_Instantiation
4643 
        or else NT (N).Nkind = N_Subprogram_Declaration
4644 
        or else NT (N).Nkind = N_Subprogram_Renaming_Declaration);
4645 
      Set_Node4 (N, Val); -- semantic field, no parent set
4646 
   end Set_Parent_Spec;
4647 
 
4648 
   procedure Set_Position
4649 
      (N : Node_Id; Val : Node_Id) is
4650 
   begin
4651 
      pragma Assert (False
4652 
        or else NT (N).Nkind = N_Component_Clause);
4653 
      Set_Node2_With_Parent (N, Val);
4654 
   end Set_Position;
4655 
 
4656 
   procedure Set_Pragma_Argument_Associations
4657 
      (N : Node_Id; Val : List_Id) is
4658 
   begin
4659 
      pragma Assert (False
4660 
        or else NT (N).Nkind = N_Pragma);
4661 
      Set_List2_With_Parent (N, Val);
4662 
   end Set_Pragma_Argument_Associations;
4663 
 
4664 
   procedure Set_Pragmas_After
4665 
      (N : Node_Id; Val : List_Id) is
4666 
   begin
4667 
      pragma Assert (False
4668 
        or else NT (N).Nkind = N_Compilation_Unit_Aux
4669 
        or else NT (N).Nkind = N_Terminate_Alternative);
4670 
      Set_List5_With_Parent (N, Val);
4671 
   end Set_Pragmas_After;
4672 
 
4673 
   procedure Set_Pragmas_Before
4674 
      (N : Node_Id; Val : List_Id) is
4675 
   begin
4676 
      pragma Assert (False
4677 
        or else NT (N).Nkind = N_Accept_Alternative
4678 
        or else NT (N).Nkind = N_Delay_Alternative
4679 
        or else NT (N).Nkind = N_Entry_Call_Alternative
4680 
        or else NT (N).Nkind = N_Mod_Clause
4681 
        or else NT (N).Nkind = N_Terminate_Alternative
4682 
        or else NT (N).Nkind = N_Triggering_Alternative);
4683 
      Set_List4_With_Parent (N, Val);
4684 
   end Set_Pragmas_Before;
4685 
 
4686 
   procedure Set_Prefix
4687 
      (N : Node_Id; Val : Node_Id) is
4688 
   begin
4689 
      pragma Assert (False
4690 
        or else NT (N).Nkind = N_Attribute_Reference
4691 
        or else NT (N).Nkind = N_Expanded_Name
4692 
        or else NT (N).Nkind = N_Explicit_Dereference
4693 
        or else NT (N).Nkind = N_Indexed_Component
4694 
        or else NT (N).Nkind = N_Reference
4695 
        or else NT (N).Nkind = N_Selected_Component
4696 
        or else NT (N).Nkind = N_Slice);
4697 
      Set_Node3_With_Parent (N, Val);
4698 
   end Set_Prefix;
4699 
 
4700 
   procedure Set_Present_Expr
4701 
      (N : Node_Id; Val : Uint) is
4702 
   begin
4703 
      pragma Assert (False
4704 
        or else NT (N).Nkind = N_Variant);
4705 
      Set_Uint3 (N, Val);
4706 
   end Set_Present_Expr;
4707 
 
4708 
   procedure Set_Prev_Ids
4709 
      (N : Node_Id; Val : Boolean := True) is
4710 
   begin
4711 
      pragma Assert (False
4712 
        or else NT (N).Nkind = N_Component_Declaration
4713 
        or else NT (N).Nkind = N_Discriminant_Specification
4714 
        or else NT (N).Nkind = N_Exception_Declaration
4715 
        or else NT (N).Nkind = N_Formal_Object_Declaration
4716 
        or else NT (N).Nkind = N_Number_Declaration
4717 
        or else NT (N).Nkind = N_Object_Declaration
4718 
        or else NT (N).Nkind = N_Parameter_Specification);
4719 
      Set_Flag6 (N, Val);
4720 
   end Set_Prev_Ids;
4721 
 
4722 
   procedure Set_Print_In_Hex
4723 
      (N : Node_Id; Val : Boolean := True) is
4724 
   begin
4725 
      pragma Assert (False
4726 
        or else NT (N).Nkind = N_Integer_Literal);
4727 
      Set_Flag13 (N, Val);
4728 
   end Set_Print_In_Hex;
4729 
 
4730 
   procedure Set_Private_Declarations
4731 
      (N : Node_Id; Val : List_Id) is
4732 
   begin
4733 
      pragma Assert (False
4734 
        or else NT (N).Nkind = N_Package_Specification
4735 
        or else NT (N).Nkind = N_Protected_Definition
4736 
        or else NT (N).Nkind = N_Task_Definition);
4737 
      Set_List3_With_Parent (N, Val);
4738 
   end Set_Private_Declarations;
4739 
 
4740 
   procedure Set_Private_Present
4741 
      (N : Node_Id; Val : Boolean := True) is
4742 
   begin
4743 
      pragma Assert (False
4744 
        or else NT (N).Nkind = N_Compilation_Unit
4745 
        or else NT (N).Nkind = N_Formal_Derived_Type_Definition
4746 
        or else NT (N).Nkind = N_With_Clause);
4747 
      Set_Flag15 (N, Val);
4748 
   end Set_Private_Present;
4749 
 
4750 
   procedure Set_Procedure_To_Call
4751 
      (N : Node_Id; Val : Node_Id) is
4752 
   begin
4753 
      pragma Assert (False
4754 
        or else NT (N).Nkind = N_Allocator
4755 
        or else NT (N).Nkind = N_Free_Statement
4756 
        or else NT (N).Nkind = N_Return_Statement);
4757 
      Set_Node4 (N, Val); -- semantic field, no parent set
4758 
   end Set_Procedure_To_Call;
4759 
 
4760 
   procedure Set_Proper_Body
4761 
      (N : Node_Id; Val : Node_Id) is
4762 
   begin
4763 
      pragma Assert (False
4764 
        or else NT (N).Nkind = N_Subunit);
4765 
      Set_Node1_With_Parent (N, Val);
4766 
   end Set_Proper_Body;
4767 
 
4768 
   procedure Set_Protected_Definition
4769 
      (N : Node_Id; Val : Node_Id) is
4770 
   begin
4771 
      pragma Assert (False
4772 
        or else NT (N).Nkind = N_Protected_Type_Declaration
4773 
        or else NT (N).Nkind = N_Single_Protected_Declaration);
4774 
      Set_Node3_With_Parent (N, Val);
4775 
   end Set_Protected_Definition;
4776 
 
4777 
   procedure Set_Protected_Present
4778 
      (N : Node_Id; Val : Boolean := True) is
4779 
   begin
4780 
      pragma Assert (False
4781 
        or else NT (N).Nkind = N_Access_Function_Definition
4782 
        or else NT (N).Nkind = N_Access_Procedure_Definition
4783 
        or else NT (N).Nkind = N_Derived_Type_Definition
4784 
        or else NT (N).Nkind = N_Record_Definition);
4785 
      Set_Flag6 (N, Val);
4786 
   end Set_Protected_Present;
4787 
 
4788 
   procedure Set_Raises_Constraint_Error
4789 
      (N : Node_Id; Val : Boolean := True) is
4790 
   begin
4791 
      pragma Assert (False
4792 
        or else NT (N).Nkind in N_Subexpr);
4793 
      Set_Flag7 (N, Val);
4794 
   end Set_Raises_Constraint_Error;
4795 
 
4796 
   procedure Set_Range_Constraint
4797 
      (N : Node_Id; Val : Node_Id) is
4798 
   begin
4799 
      pragma Assert (False
4800 
        or else NT (N).Nkind = N_Delta_Constraint
4801 
        or else NT (N).Nkind = N_Digits_Constraint);
4802 
      Set_Node4_With_Parent (N, Val);
4803 
   end Set_Range_Constraint;
4804 
 
4805 
   procedure Set_Range_Expression
4806 
      (N : Node_Id; Val : Node_Id) is
4807 
   begin
4808 
      pragma Assert (False
4809 
        or else NT (N).Nkind = N_Range_Constraint);
4810 
      Set_Node4_With_Parent (N, Val);
4811 
   end Set_Range_Expression;
4812 
 
4813 
   procedure Set_Real_Range_Specification
4814 
      (N : Node_Id; Val : Node_Id) is
4815 
   begin
4816 
      pragma Assert (False
4817 
        or else NT (N).Nkind = N_Decimal_Fixed_Point_Definition
4818 
        or else NT (N).Nkind = N_Floating_Point_Definition
4819 
        or else NT (N).Nkind = N_Ordinary_Fixed_Point_Definition);
4820 
      Set_Node4_With_Parent (N, Val);
4821 
   end Set_Real_Range_Specification;
4822 
 
4823 
   procedure Set_Realval
4824 
     (N : Node_Id; Val : Ureal) is
4825 
   begin
4826 
      pragma Assert (False
4827 
        or else NT (N).Nkind = N_Real_Literal);
4828 
      Set_Ureal3 (N, Val);
4829 
   end Set_Realval;
4830 
 
4831 
   procedure Set_Reason
4832 
      (N : Node_Id; Val : Uint) is
4833 
   begin
4834 
      pragma Assert (False
4835 
        or else NT (N).Nkind = N_Raise_Constraint_Error
4836 
        or else NT (N).Nkind = N_Raise_Program_Error
4837 
        or else NT (N).Nkind = N_Raise_Storage_Error);
4838 
      Set_Uint3 (N, Val);
4839 
   end Set_Reason;
4840 
 
4841 
   procedure Set_Record_Extension_Part
4842 
      (N : Node_Id; Val : Node_Id) is
4843 
   begin
4844 
      pragma Assert (False
4845 
        or else NT (N).Nkind = N_Derived_Type_Definition);
4846 
      Set_Node3_With_Parent (N, Val);
4847 
   end Set_Record_Extension_Part;
4848 
 
4849 
   procedure Set_Redundant_Use
4850 
      (N : Node_Id; Val : Boolean := True) is
4851 
   begin
4852 
      pragma Assert (False
4853 
        or else NT (N).Nkind = N_Attribute_Reference
4854 
        or else NT (N).Nkind = N_Expanded_Name
4855 
        or else NT (N).Nkind = N_Identifier);
4856 
      Set_Flag13 (N, Val);
4857 
   end Set_Redundant_Use;
4858 
 
4859 
   procedure Set_Result_Definition
4860 
     (N : Node_Id; Val : Node_Id) is
4861 
   begin
4862 
      pragma Assert (False
4863 
        or else NT (N).Nkind = N_Access_Function_Definition
4864 
        or else NT (N).Nkind = N_Function_Specification);
4865 
      Set_Node4_With_Parent (N, Val);
4866 
   end Set_Result_Definition;
4867 
 
4868 
   procedure Set_Return_Type
4869 
      (N : Node_Id; Val : Node_Id) is
4870 
   begin
4871 
      pragma Assert (False
4872 
        or else NT (N).Nkind = N_Return_Statement);
4873 
      Set_Node2 (N, Val); -- semantic field, no parent set
4874 
   end Set_Return_Type;
4875 
 
4876 
   procedure Set_Reverse_Present
4877 
      (N : Node_Id; Val : Boolean := True) is
4878 
   begin
4879 
      pragma Assert (False
4880 
        or else NT (N).Nkind = N_Loop_Parameter_Specification);
4881 
      Set_Flag15 (N, Val);
4882 
   end Set_Reverse_Present;
4883 
 
4884 
   procedure Set_Right_Opnd
4885 
      (N : Node_Id; Val : Node_Id) is
4886 
   begin
4887 
      pragma Assert (False
4888 
        or else NT (N).Nkind in N_Op
4889 
        or else NT (N).Nkind = N_And_Then
4890 
        or else NT (N).Nkind = N_In
4891 
        or else NT (N).Nkind = N_Not_In
4892 
        or else NT (N).Nkind = N_Or_Else);
4893 
      Set_Node3_With_Parent (N, Val);
4894 
   end Set_Right_Opnd;
4895 
 
4896 
   procedure Set_Rounded_Result
4897 
      (N : Node_Id; Val : Boolean := True) is
4898 
   begin
4899 
      pragma Assert (False
4900 
        or else NT (N).Nkind = N_Op_Divide
4901 
        or else NT (N).Nkind = N_Op_Multiply
4902 
        or else NT (N).Nkind = N_Type_Conversion);
4903 
      Set_Flag18 (N, Val);
4904 
   end Set_Rounded_Result;
4905 
 
4906 
   procedure Set_Scope
4907 
      (N : Node_Id; Val : Node_Id) is
4908 
   begin
4909 
      pragma Assert (False
4910 
        or else NT (N).Nkind = N_Defining_Character_Literal
4911 
        or else NT (N).Nkind = N_Defining_Identifier
4912 
        or else NT (N).Nkind = N_Defining_Operator_Symbol);
4913 
      Set_Node3 (N, Val); -- semantic field, no parent set
4914 
   end Set_Scope;
4915 
 
4916 
   procedure Set_Select_Alternatives
4917 
      (N : Node_Id; Val : List_Id) is
4918 
   begin
4919 
      pragma Assert (False
4920 
        or else NT (N).Nkind = N_Selective_Accept);
4921 
      Set_List1_With_Parent (N, Val);
4922 
   end Set_Select_Alternatives;
4923 
 
4924 
   procedure Set_Selector_Name
4925 
      (N : Node_Id; Val : Node_Id) is
4926 
   begin
4927 
      pragma Assert (False
4928 
        or else NT (N).Nkind = N_Expanded_Name
4929 
        or else NT (N).Nkind = N_Generic_Association
4930 
        or else NT (N).Nkind = N_Parameter_Association
4931 
        or else NT (N).Nkind = N_Selected_Component);
4932 
      Set_Node2_With_Parent (N, Val);
4933 
   end Set_Selector_Name;
4934 
 
4935 
   procedure Set_Selector_Names
4936 
      (N : Node_Id; Val : List_Id) is
4937 
   begin
4938 
      pragma Assert (False
4939 
        or else NT (N).Nkind = N_Discriminant_Association);
4940 
      Set_List1_With_Parent (N, Val);
4941 
   end Set_Selector_Names;
4942 
 
4943 
   procedure Set_Shift_Count_OK
4944 
      (N : Node_Id; Val : Boolean := True) is
4945 
   begin
4946 
      pragma Assert (False
4947 
        or else NT (N).Nkind = N_Op_Rotate_Left
4948 
        or else NT (N).Nkind = N_Op_Rotate_Right
4949 
        or else NT (N).Nkind = N_Op_Shift_Left
4950 
        or else NT (N).Nkind = N_Op_Shift_Right
4951 
        or else NT (N).Nkind = N_Op_Shift_Right_Arithmetic);
4952 
      Set_Flag4 (N, Val);
4953 
   end Set_Shift_Count_OK;
4954 
 
4955 
   procedure Set_Source_Type
4956 
      (N : Node_Id; Val : Entity_Id) is
4957 
   begin
4958 
      pragma Assert (False
4959 
        or else NT (N).Nkind = N_Validate_Unchecked_Conversion);
4960 
      Set_Node1 (N, Val); -- semantic field, no parent set
4961 
   end Set_Source_Type;
4962 
 
4963 
   procedure Set_Specification
4964 
      (N : Node_Id; Val : Node_Id) is
4965 
   begin
4966 
      pragma Assert (False
4967 
        or else NT (N).Nkind = N_Abstract_Subprogram_Declaration
4968 
        or else NT (N).Nkind = N_Formal_Abstract_Subprogram_Declaration
4969 
        or else NT (N).Nkind = N_Formal_Concrete_Subprogram_Declaration
4970 
        or else NT (N).Nkind = N_Generic_Package_Declaration
4971 
        or else NT (N).Nkind = N_Generic_Subprogram_Declaration
4972 
        or else NT (N).Nkind = N_Package_Declaration
4973 
        or else NT (N).Nkind = N_Subprogram_Body
4974 
        or else NT (N).Nkind = N_Subprogram_Body_Stub
4975 
        or else NT (N).Nkind = N_Subprogram_Declaration
4976 
        or else NT (N).Nkind = N_Subprogram_Renaming_Declaration);
4977 
      Set_Node1_With_Parent (N, Val);
4978 
   end Set_Specification;
4979 
 
4980 
   procedure Set_Statements
4981 
      (N : Node_Id; Val : List_Id) is
4982 
   begin
4983 
      pragma Assert (False
4984 
        or else NT (N).Nkind = N_Abortable_Part
4985 
        or else NT (N).Nkind = N_Accept_Alternative
4986 
        or else NT (N).Nkind = N_Case_Statement_Alternative
4987 
        or else NT (N).Nkind = N_Delay_Alternative
4988 
        or else NT (N).Nkind = N_Entry_Call_Alternative
4989 
        or else NT (N).Nkind = N_Exception_Handler
4990 
        or else NT (N).Nkind = N_Handled_Sequence_Of_Statements
4991 
        or else NT (N).Nkind = N_Loop_Statement
4992 
        or else NT (N).Nkind = N_Triggering_Alternative);
4993 
      Set_List3_With_Parent (N, Val);
4994 
   end Set_Statements;
4995 
 
4996 
   procedure Set_Static_Processing_OK
4997 
      (N : Node_Id; Val : Boolean) is
4998 
   begin
4999 
      pragma Assert (False
5000 
        or else NT (N).Nkind = N_Aggregate);
5001 
      Set_Flag4 (N, Val);
5002 
   end Set_Static_Processing_OK;
5003 
 
5004 
   procedure Set_Storage_Pool
5005 
      (N : Node_Id; Val : Node_Id) is
5006 
   begin
5007 
      pragma Assert (False
5008 
        or else NT (N).Nkind = N_Allocator
5009 
        or else NT (N).Nkind = N_Free_Statement
5010 
        or else NT (N).Nkind = N_Return_Statement);
5011 
      Set_Node1 (N, Val); -- semantic field, no parent set
5012 
   end Set_Storage_Pool;
5013 
 
5014 
   procedure Set_Strval
5015 
      (N : Node_Id; Val : String_Id) is
5016 
   begin
5017 
      pragma Assert (False
5018 
        or else NT (N).Nkind = N_Operator_Symbol
5019 
        or else NT (N).Nkind = N_String_Literal);
5020 
      Set_Str3 (N, Val);
5021 
   end Set_Strval;
5022 
 
5023 
   procedure Set_Subtype_Indication
5024 
      (N : Node_Id; Val : Node_Id) is
5025 
   begin
5026 
      pragma Assert (False
5027 
        or else NT (N).Nkind = N_Access_To_Object_Definition
5028 
        or else NT (N).Nkind = N_Component_Definition
5029 
        or else NT (N).Nkind = N_Derived_Type_Definition
5030 
        or else NT (N).Nkind = N_Private_Extension_Declaration
5031 
        or else NT (N).Nkind = N_Subtype_Declaration);
5032 
      Set_Node5_With_Parent (N, Val);
5033 
   end Set_Subtype_Indication;
5034 
 
5035 
   procedure Set_Subtype_Mark
5036 
      (N : Node_Id; Val : Node_Id) is
5037 
   begin
5038 
      pragma Assert (False
5039 
        or else NT (N).Nkind = N_Access_Definition
5040 
        or else NT (N).Nkind = N_Formal_Derived_Type_Definition
5041 
        or else NT (N).Nkind = N_Formal_Object_Declaration
5042 
        or else NT (N).Nkind = N_Object_Renaming_Declaration
5043 
        or else NT (N).Nkind = N_Qualified_Expression
5044 
        or else NT (N).Nkind = N_Subtype_Indication
5045 
        or else NT (N).Nkind = N_Type_Conversion
5046 
        or else NT (N).Nkind = N_Unchecked_Type_Conversion);
5047 
      Set_Node4_With_Parent (N, Val);
5048 
   end Set_Subtype_Mark;
5049 
 
5050 
   procedure Set_Subtype_Marks
5051 
      (N : Node_Id; Val : List_Id) is
5052 
   begin
5053 
      pragma Assert (False
5054 
        or else NT (N).Nkind = N_Unconstrained_Array_Definition
5055 
        or else NT (N).Nkind = N_Use_Type_Clause);
5056 
      Set_List2_With_Parent (N, Val);
5057 
   end Set_Subtype_Marks;
5058 
 
5059 
   procedure Set_Synchronized_Present
5060 
     (N : Node_Id; Val : Boolean := True) is
5061 
   begin
5062 
      pragma Assert (False
5063 
        or else NT (N).Nkind = N_Derived_Type_Definition
5064 
        or else NT (N).Nkind = N_Record_Definition);
5065 
      Set_Flag7 (N, Val);
5066 
   end Set_Synchronized_Present;
5067 
 
5068 
   procedure Set_Tagged_Present
5069 
      (N : Node_Id; Val : Boolean := True) is
5070 
   begin
5071 
      pragma Assert (False
5072 
        or else NT (N).Nkind = N_Formal_Private_Type_Definition
5073 
        or else NT (N).Nkind = N_Incomplete_Type_Declaration
5074 
        or else NT (N).Nkind = N_Private_Type_Declaration
5075 
        or else NT (N).Nkind = N_Record_Definition
5076 
        or else NT (N).Nkind = N_With_Type_Clause);
5077 
      Set_Flag15 (N, Val);
5078 
   end Set_Tagged_Present;
5079 
 
5080 
   procedure Set_Target_Type
5081 
      (N : Node_Id; Val : Entity_Id) is
5082 
   begin
5083 
      pragma Assert (False
5084 
        or else NT (N).Nkind = N_Validate_Unchecked_Conversion);
5085 
      Set_Node2 (N, Val); -- semantic field, no parent set
5086 
   end Set_Target_Type;
5087 
 
5088 
   procedure Set_Task_Definition
5089 
      (N : Node_Id; Val : Node_Id) is
5090 
   begin
5091 
      pragma Assert (False
5092 
        or else NT (N).Nkind = N_Single_Task_Declaration
5093 
        or else NT (N).Nkind = N_Task_Type_Declaration);
5094 
      Set_Node3_With_Parent (N, Val);
5095 
   end Set_Task_Definition;
5096 
 
5097 
   procedure Set_Task_Present
5098 
     (N : Node_Id; Val : Boolean := True) is
5099 
   begin
5100 
      pragma Assert (False
5101 
        or else NT (N).Nkind = N_Derived_Type_Definition
5102 
        or else NT (N).Nkind = N_Record_Definition);
5103 
      Set_Flag5 (N, Val);
5104 
   end Set_Task_Present;
5105 
 
5106 
   procedure Set_Then_Actions
5107 
      (N : Node_Id; Val : List_Id) is
5108 
   begin
5109 
      pragma Assert (False
5110 
        or else NT (N).Nkind = N_Conditional_Expression);
5111 
      Set_List2 (N, Val); -- semantic field, no parent set
5112 
   end Set_Then_Actions;
5113 
 
5114 
   procedure Set_Then_Statements
5115 
      (N : Node_Id; Val : List_Id) is
5116 
   begin
5117 
      pragma Assert (False
5118 
        or else NT (N).Nkind = N_Elsif_Part
5119 
        or else NT (N).Nkind = N_If_Statement);
5120 
      Set_List2_With_Parent (N, Val);
5121 
   end Set_Then_Statements;
5122 
 
5123 
   procedure Set_Treat_Fixed_As_Integer
5124 
      (N : Node_Id; Val : Boolean := True) is
5125 
   begin
5126 
      pragma Assert (False
5127 
        or else NT (N).Nkind = N_Op_Divide
5128 
        or else NT (N).Nkind = N_Op_Mod
5129 
        or else NT (N).Nkind = N_Op_Multiply
5130 
        or else NT (N).Nkind = N_Op_Rem);
5131 
      Set_Flag14 (N, Val);
5132 
   end Set_Treat_Fixed_As_Integer;
5133 
 
5134 
   procedure Set_Triggering_Alternative
5135 
      (N : Node_Id; Val : Node_Id) is
5136 
   begin
5137 
      pragma Assert (False
5138 
        or else NT (N).Nkind = N_Asynchronous_Select);
5139 
      Set_Node1_With_Parent (N, Val);
5140 
   end Set_Triggering_Alternative;
5141 
 
5142 
   procedure Set_Triggering_Statement
5143 
      (N : Node_Id; Val : Node_Id) is
5144 
   begin
5145 
      pragma Assert (False
5146 
        or else NT (N).Nkind = N_Triggering_Alternative);
5147 
      Set_Node1_With_Parent (N, Val);
5148 
   end Set_Triggering_Statement;
5149 
 
5150 
   procedure Set_TSS_Elist
5151 
      (N : Node_Id; Val : Elist_Id) is
5152 
   begin
5153 
      pragma Assert (False
5154 
        or else NT (N).Nkind = N_Freeze_Entity);
5155 
      Set_Elist3 (N, Val); -- semantic field, no parent set
5156 
   end Set_TSS_Elist;
5157 
 
5158 
   procedure Set_Type_Definition
5159 
      (N : Node_Id; Val : Node_Id) is
5160 
   begin
5161 
      pragma Assert (False
5162 
        or else NT (N).Nkind = N_Full_Type_Declaration);
5163 
      Set_Node3_With_Parent (N, Val);
5164 
   end Set_Type_Definition;
5165 
 
5166 
   procedure Set_Unit
5167 
      (N : Node_Id; Val : Node_Id) is
5168 
   begin
5169 
      pragma Assert (False
5170 
        or else NT (N).Nkind = N_Compilation_Unit);
5171 
      Set_Node2_With_Parent (N, Val);
5172 
   end Set_Unit;
5173 
 
5174 
   procedure Set_Unknown_Discriminants_Present
5175 
      (N : Node_Id; Val : Boolean := True) is
5176 
   begin
5177 
      pragma Assert (False
5178 
        or else NT (N).Nkind = N_Formal_Type_Declaration
5179 
        or else NT (N).Nkind = N_Incomplete_Type_Declaration
5180 
        or else NT (N).Nkind = N_Private_Extension_Declaration
5181 
        or else NT (N).Nkind = N_Private_Type_Declaration);
5182 
      Set_Flag13 (N, Val);
5183 
   end Set_Unknown_Discriminants_Present;
5184 
 
5185 
   procedure Set_Unreferenced_In_Spec
5186 
      (N : Node_Id; Val : Boolean := True) is
5187 
   begin
5188 
      pragma Assert (False
5189 
        or else NT (N).Nkind = N_With_Clause);
5190 
      Set_Flag7 (N, Val);
5191 
   end Set_Unreferenced_In_Spec;
5192 
 
5193 
   procedure Set_Variant_Part
5194 
      (N : Node_Id; Val : Node_Id) is
5195 
   begin
5196 
      pragma Assert (False
5197 
        or else NT (N).Nkind = N_Component_List);
5198 
      Set_Node4_With_Parent (N, Val);
5199 
   end Set_Variant_Part;
5200 
 
5201 
   procedure Set_Variants
5202 
      (N : Node_Id; Val : List_Id) is
5203 
   begin
5204 
      pragma Assert (False
5205 
        or else NT (N).Nkind = N_Variant_Part);
5206 
      Set_List1_With_Parent (N, Val);
5207 
   end Set_Variants;
5208 
 
5209 
   procedure Set_Visible_Declarations
5210 
      (N : Node_Id; Val : List_Id) is
5211 
   begin
5212 
      pragma Assert (False
5213 
        or else NT (N).Nkind = N_Package_Specification
5214 
        or else NT (N).Nkind = N_Protected_Definition
5215 
        or else NT (N).Nkind = N_Task_Definition);
5216 
      Set_List2_With_Parent (N, Val);
5217 
   end Set_Visible_Declarations;
5218 
 
5219 
   procedure Set_Was_Originally_Stub
5220 
      (N : Node_Id; Val : Boolean := True) is
5221 
   begin
5222 
      pragma Assert (False
5223 
        or else NT (N).Nkind = N_Package_Body
5224 
        or else NT (N).Nkind = N_Protected_Body
5225 
        or else NT (N).Nkind = N_Subprogram_Body
5226 
        or else NT (N).Nkind = N_Task_Body);
5227 
      Set_Flag13 (N, Val);
5228 
   end Set_Was_Originally_Stub;
5229 
 
5230 
   procedure Set_Zero_Cost_Handling
5231 
      (N : Node_Id; Val : Boolean := True) is
5232 
   begin
5233 
      pragma Assert (False
5234 
        or else NT (N).Nkind = N_Exception_Handler
5235 
        or else NT (N).Nkind = N_Handled_Sequence_Of_Statements);
5236 
      Set_Flag5 (N, Val);
5237 
   end Set_Zero_Cost_Handling;
5238 
 
5239 
   -------------------------
5240 
   -- Iterator Procedures --
5241 
   -------------------------
5242 
 
5243 
   procedure Next_Entity       (N : in out Node_Id) is
5244 
   begin
5245 
      N := Next_Entity (N);
5246 
   end Next_Entity;
5247 
 
5248 
   procedure Next_Named_Actual (N : in out Node_Id) is
5249 
   begin
5250 
      N := Next_Named_Actual (N);
5251 
   end Next_Named_Actual;
5252 
 
5253 
   procedure Next_Rep_Item     (N : in out Node_Id) is
5254 
   begin
5255 
      N := Next_Rep_Item (N);
5256 
   end Next_Rep_Item;
5257 
 
5258 
   procedure Next_Use_Clause   (N : in out Node_Id) is
5259 
   begin
5260 
      N := Next_Use_Clause (N);
5261 
   end Next_Use_Clause;
5262 
 
5263 
   ------------------
5264 
   -- End_Location --
5265 
   ------------------
5266 
 
5267 
   function End_Location (N : Node_Id) return Source_Ptr is
5268 
      L : constant Uint := End_Span (N);
5269 
 
5270 
   begin
5271 
      if L = No_Uint then
5272 
         return No_Location;
5273 
      else
5274 
         return Source_Ptr (Int (Sloc (N)) + UI_To_Int (L));
5275 
      end if;
5276 
   end End_Location;
5277 
 
5278 
   ----------------------
5279 
   -- Set_End_Location --
5280 
   ----------------------
5281 
 
5282 
   procedure Set_End_Location (N : Node_Id; S : Source_Ptr) is
5283 
   begin
5284 
      Set_End_Span (N,
5285 
        UI_From_Int (Int (S) - Int (Sloc (N))));
5286 
   end Set_End_Location;
5287 
 
5288 
end Sinfo;

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.