gcc/ada/nmake.adb

   1 ------------------------------------------------------------------------------
   2 --                                                                          --
   3 --                         GNAT COMPILER COMPONENTS                         --
   4 --                                                                          --
   5 --                                N M A K E                                 --
   6 --                                                                          --
   7 --                                 B o d y                                  --
   8 --                                                                          --
   9 --                 Generated by xnmake revision 1.29 using                  --
  10 --                         sinfo.ads revision 1.439                         --
  11 --                         nmake.adt revision 1.12                          --
  12 --                                                                          --
  13 --          Copyright (C) 1992-2001 Free Software Foundation, Inc.          --
  14 --                                                                          --
  15 -- GNAT is free software;  you can  redistribute it  and/or modify it under --
  16 -- terms of the  GNU General Public License as published  by the Free Soft- --
  17 -- ware  Foundation;  either version 2,  or (at your option) any later ver- --
  18 -- sion.  GNAT is distributed in the hope that it will be useful, but WITH- --
  19 -- OUT ANY WARRANTY;  without even the  implied warranty of MERCHANTABILITY --
  20 -- or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License --
  21 -- for  more details.  You should have  received  a copy of the GNU General --
  22 -- Public License  distributed with GNAT;  see file COPYING.  If not, write --
  23 -- to  the Free Software Foundation,  59 Temple Place - Suite 330,  Boston, --
  24 -- MA 02111-1307, USA.                                                      --
  25 --                                                                          --
  26 -- GNAT was originally developed  by the GNAT team at  New York University. --
  27 -- Extensive contributions were provided by Ada Core Technologies Inc.      --
  28 --                                                                          --
  29 ------------------------------------------------------------------------------
  30
  31 pragma Style_Checks (All_Checks);
  32 --  Turn off subprogram order checking, since the routines here are
  33 --  generated automatically in order.
  34
  35
  36 with Atree;  use Atree;
  37 with Sinfo;  use Sinfo;
  38 with Snames; use Snames;
  39 with Stand;  use Stand;
  40
  41 package body Nmake is
  42
  43    function Make_Unused_At_Start (Sloc : Source_Ptr)
  44       return Node_Id
  45    is
  46       N : constant Node_Id :=
  47             New_Node (N_Unused_At_Start, Sloc);
  48    begin
  49       return N;
  50    end Make_Unused_At_Start;
  51
  52    function Make_Unused_At_End (Sloc : Source_Ptr)
  53       return Node_Id
  54    is
  55       N : constant Node_Id :=
  56             New_Node (N_Unused_At_End, Sloc);
  57    begin
  58       return N;
  59    end Make_Unused_At_End;
  60
  61    function Make_Identifier (Sloc : Source_Ptr;
  62       Chars                        : Name_Id)
  63       return Node_Id
  64    is
  65       N : constant Node_Id :=
  66             New_Node (N_Identifier, Sloc);
  67    begin
  68       Set_Chars (N, Chars);
  69       return N;
  70    end Make_Identifier;
  71
  72    function Make_Integer_Literal (Sloc : Source_Ptr;
  73       Intval                       : Uint)
  74       return Node_Id
  75    is
  76       N : constant Node_Id :=
  77             New_Node (N_Integer_Literal, Sloc);
  78    begin
  79       Set_Intval (N, Intval);
  80       return N;
  81    end Make_Integer_Literal;
  82
  83    function Make_Real_Literal (Sloc : Source_Ptr;
  84       Realval                      : Ureal)
  85       return Node_Id
  86    is
  87       N : constant Node_Id :=
  88             New_Node (N_Real_Literal, Sloc);
  89    begin
  90       Set_Realval (N, Realval);
  91       return N;
  92    end Make_Real_Literal;
  93
  94    function Make_Character_Literal (Sloc : Source_Ptr;
  95       Chars                        : Name_Id;
  96       Char_Literal_Value           : Char_Code)
  97       return Node_Id
  98    is
  99       N : constant Node_Id :=
 100             New_Node (N_Character_Literal, Sloc);
 101    begin
 102       Set_Chars (N, Chars);
 103       Set_Char_Literal_Value (N, Char_Literal_Value);
 104       return N;
 105    end Make_Character_Literal;
 106
 107    function Make_String_Literal (Sloc : Source_Ptr;
 108       Strval                       : String_Id)
 109       return Node_Id
 110    is
 111       N : constant Node_Id :=
 112             New_Node (N_String_Literal, Sloc);
 113    begin
 114       Set_Strval (N, Strval);
 115       return N;
 116    end Make_String_Literal;
 117
 118    function Make_Pragma (Sloc : Source_Ptr;
 119       Chars                        : Name_Id;
 120       Pragma_Argument_Associations : List_Id := No_List;
 121       Debug_Statement              : Node_Id := Empty)
 122       return Node_Id
 123    is
 124       N : constant Node_Id :=
 125             New_Node (N_Pragma, Sloc);
 126    begin
 127       Set_Chars (N, Chars);
 128       Set_Pragma_Argument_Associations
 129         (N, Pragma_Argument_Associations);
 130       Set_Debug_Statement (N, Debug_Statement);
 131       return N;
 132    end Make_Pragma;
 133
 134    function Make_Pragma_Argument_Association (Sloc : Source_Ptr;
 135       Chars                        : Name_Id := No_Name;
 136       Expression                   : Node_Id)
 137       return Node_Id
 138    is
 139       N : constant Node_Id :=
 140             New_Node (N_Pragma_Argument_Association, Sloc);
 141    begin
 142       Set_Chars (N, Chars);
 143       Set_Expression (N, Expression);
 144       return N;
 145    end Make_Pragma_Argument_Association;
 146
 147    function Make_Defining_Identifier (Sloc : Source_Ptr;
 148       Chars                        : Name_Id)
 149       return Node_Id
 150    is
 151       N : constant Node_Id :=
 152             New_Entity (N_Defining_Identifier, Sloc);
 153    begin
 154       Set_Chars (N, Chars);
 155       return N;
 156    end Make_Defining_Identifier;
 157
 158    function Make_Full_Type_Declaration (Sloc : Source_Ptr;
 159       Defining_Identifier          : Node_Id;
 160       Discriminant_Specifications  : List_Id := No_List;
 161       Type_Definition              : Node_Id)
 162       return Node_Id
 163    is
 164       N : constant Node_Id :=
 165             New_Node (N_Full_Type_Declaration, Sloc);
 166    begin
 167       Set_Defining_Identifier (N, Defining_Identifier);
 168       Set_Discriminant_Specifications (N, Discriminant_Specifications);
 169       Set_Type_Definition (N, Type_Definition);
 170       return N;
 171    end Make_Full_Type_Declaration;
 172
 173    function Make_Subtype_Declaration (Sloc : Source_Ptr;
 174       Defining_Identifier          : Node_Id;
 175       Subtype_Indication           : Node_Id)
 176       return Node_Id
 177    is
 178       N : constant Node_Id :=
 179             New_Node (N_Subtype_Declaration, Sloc);
 180    begin
 181       Set_Defining_Identifier (N, Defining_Identifier);
 182       Set_Subtype_Indication (N, Subtype_Indication);
 183       return N;
 184    end Make_Subtype_Declaration;
 185
 186    function Make_Subtype_Indication (Sloc : Source_Ptr;
 187       Subtype_Mark                 : Node_Id;
 188       Constraint                   : Node_Id)
 189       return Node_Id
 190    is
 191       N : constant Node_Id :=
 192             New_Node (N_Subtype_Indication, Sloc);
 193    begin
 194       Set_Subtype_Mark (N, Subtype_Mark);
 195       Set_Constraint (N, Constraint);
 196       return N;
 197    end Make_Subtype_Indication;
 198
 199    function Make_Object_Declaration (Sloc : Source_Ptr;
 200       Defining_Identifier          : Node_Id;
 201       Aliased_Present              : Boolean := False;
 202       Constant_Present             : Boolean := False;
 203       Object_Definition            : Node_Id;
 204       Expression                   : Node_Id := Empty)
 205       return Node_Id
 206    is
 207       N : constant Node_Id :=
 208             New_Node (N_Object_Declaration, Sloc);
 209    begin
 210       Set_Defining_Identifier (N, Defining_Identifier);
 211       Set_Aliased_Present (N, Aliased_Present);
 212       Set_Constant_Present (N, Constant_Present);
 213       Set_Object_Definition (N, Object_Definition);
 214       Set_Expression (N, Expression);
 215       return N;
 216    end Make_Object_Declaration;
 217
 218    function Make_Number_Declaration (Sloc : Source_Ptr;
 219       Defining_Identifier          : Node_Id;
 220       Expression                   : Node_Id)
 221       return Node_Id
 222    is
 223       N : constant Node_Id :=
 224             New_Node (N_Number_Declaration, Sloc);
 225    begin
 226       Set_Defining_Identifier (N, Defining_Identifier);
 227       Set_Expression (N, Expression);
 228       return N;
 229    end Make_Number_Declaration;
 230
 231    function Make_Derived_Type_Definition (Sloc : Source_Ptr;
 232       Abstract_Present             : Boolean := False;
 233       Subtype_Indication           : Node_Id;
 234       Record_Extension_Part        : Node_Id := Empty)
 235       return Node_Id
 236    is
 237       N : constant Node_Id :=
 238             New_Node (N_Derived_Type_Definition, Sloc);
 239    begin
 240       Set_Abstract_Present (N, Abstract_Present);
 241       Set_Subtype_Indication (N, Subtype_Indication);
 242       Set_Record_Extension_Part (N, Record_Extension_Part);
 243       return N;
 244    end Make_Derived_Type_Definition;
 245
 246    function Make_Range_Constraint (Sloc : Source_Ptr;
 247       Range_Expression             : Node_Id)
 248       return Node_Id
 249    is
 250       N : constant Node_Id :=
 251             New_Node (N_Range_Constraint, Sloc);
 252    begin
 253       Set_Range_Expression (N, Range_Expression);
 254       return N;
 255    end Make_Range_Constraint;
 256
 257    function Make_Range (Sloc : Source_Ptr;
 258       Low_Bound                    : Node_Id;
 259       High_Bound                   : Node_Id;
 260       Includes_Infinities          : Boolean := False)
 261       return Node_Id
 262    is
 263       N : constant Node_Id :=
 264             New_Node (N_Range, Sloc);
 265    begin
 266       Set_Low_Bound (N, Low_Bound);
 267       Set_High_Bound (N, High_Bound);
 268       Set_Includes_Infinities (N, Includes_Infinities);
 269       return N;
 270    end Make_Range;
 271
 272    function Make_Enumeration_Type_Definition (Sloc : Source_Ptr;
 273       Literals                     : List_Id;
 274       End_Label                    : Node_Id := Empty)
 275       return Node_Id
 276    is
 277       N : constant Node_Id :=
 278             New_Node (N_Enumeration_Type_Definition, Sloc);
 279    begin
 280       Set_Literals (N, Literals);
 281       Set_End_Label (N, End_Label);
 282       return N;
 283    end Make_Enumeration_Type_Definition;
 284
 285    function Make_Defining_Character_Literal (Sloc : Source_Ptr;
 286       Chars                        : Name_Id)
 287       return Node_Id
 288    is
 289       N : constant Node_Id :=
 290             New_Entity (N_Defining_Character_Literal, Sloc);
 291    begin
 292       Set_Chars (N, Chars);
 293       return N;
 294    end Make_Defining_Character_Literal;
 295
 296    function Make_Signed_Integer_Type_Definition (Sloc : Source_Ptr;
 297       Low_Bound                    : Node_Id;
 298       High_Bound                   : Node_Id)
 299       return Node_Id
 300    is
 301       N : constant Node_Id :=
 302             New_Node (N_Signed_Integer_Type_Definition, Sloc);
 303    begin
 304       Set_Low_Bound (N, Low_Bound);
 305       Set_High_Bound (N, High_Bound);
 306       return N;
 307    end Make_Signed_Integer_Type_Definition;
 308
 309    function Make_Modular_Type_Definition (Sloc : Source_Ptr;
 310       Expression                   : Node_Id)
 311       return Node_Id
 312    is
 313       N : constant Node_Id :=
 314             New_Node (N_Modular_Type_Definition, Sloc);
 315    begin
 316       Set_Expression (N, Expression);
 317       return N;
 318    end Make_Modular_Type_Definition;
 319
 320    function Make_Floating_Point_Definition (Sloc : Source_Ptr;
 321       Digits_Expression            : Node_Id;
 322       Real_Range_Specification     : Node_Id := Empty)
 323       return Node_Id
 324    is
 325       N : constant Node_Id :=
 326             New_Node (N_Floating_Point_Definition, Sloc);
 327    begin
 328       Set_Digits_Expression (N, Digits_Expression);
 329       Set_Real_Range_Specification (N, Real_Range_Specification);
 330       return N;
 331    end Make_Floating_Point_Definition;
 332
 333    function Make_Real_Range_Specification (Sloc : Source_Ptr;
 334       Low_Bound                    : Node_Id;
 335       High_Bound                   : Node_Id)
 336       return Node_Id
 337    is
 338       N : constant Node_Id :=
 339             New_Node (N_Real_Range_Specification, Sloc);
 340    begin
 341       Set_Low_Bound (N, Low_Bound);
 342       Set_High_Bound (N, High_Bound);
 343       return N;
 344    end Make_Real_Range_Specification;
 345
 346    function Make_Ordinary_Fixed_Point_Definition (Sloc : Source_Ptr;
 347       Delta_Expression             : Node_Id;
 348       Real_Range_Specification     : Node_Id)
 349       return Node_Id
 350    is
 351       N : constant Node_Id :=
 352             New_Node (N_Ordinary_Fixed_Point_Definition, Sloc);
 353    begin
 354       Set_Delta_Expression (N, Delta_Expression);
 355       Set_Real_Range_Specification (N, Real_Range_Specification);
 356       return N;
 357    end Make_Ordinary_Fixed_Point_Definition;
 358
 359    function Make_Decimal_Fixed_Point_Definition (Sloc : Source_Ptr;
 360       Delta_Expression             : Node_Id;
 361       Digits_Expression            : Node_Id;
 362       Real_Range_Specification     : Node_Id := Empty)
 363       return Node_Id
 364    is
 365       N : constant Node_Id :=
 366             New_Node (N_Decimal_Fixed_Point_Definition, Sloc);
 367    begin
 368       Set_Delta_Expression (N, Delta_Expression);
 369       Set_Digits_Expression (N, Digits_Expression);
 370       Set_Real_Range_Specification (N, Real_Range_Specification);
 371       return N;
 372    end Make_Decimal_Fixed_Point_Definition;
 373
 374    function Make_Digits_Constraint (Sloc : Source_Ptr;
 375       Digits_Expression            : Node_Id;
 376       Range_Constraint             : Node_Id := Empty)
 377       return Node_Id
 378    is
 379       N : constant Node_Id :=
 380             New_Node (N_Digits_Constraint, Sloc);
 381    begin
 382       Set_Digits_Expression (N, Digits_Expression);
 383       Set_Range_Constraint (N, Range_Constraint);
 384       return N;
 385    end Make_Digits_Constraint;
 386
 387    function Make_Unconstrained_Array_Definition (Sloc : Source_Ptr;
 388       Subtype_Marks                : List_Id;
 389       Aliased_Present              : Boolean := False;
 390       Subtype_Indication           : Node_Id)
 391       return Node_Id
 392    is
 393       N : constant Node_Id :=
 394             New_Node (N_Unconstrained_Array_Definition, Sloc);
 395    begin
 396       Set_Subtype_Marks (N, Subtype_Marks);
 397       Set_Aliased_Present (N, Aliased_Present);
 398       Set_Subtype_Indication (N, Subtype_Indication);
 399       return N;
 400    end Make_Unconstrained_Array_Definition;
 401
 402    function Make_Constrained_Array_Definition (Sloc : Source_Ptr;
 403       Discrete_Subtype_Definitions : List_Id;
 404       Aliased_Present              : Boolean := False;
 405       Subtype_Indication           : Node_Id)
 406       return Node_Id
 407    is
 408       N : constant Node_Id :=
 409             New_Node (N_Constrained_Array_Definition, Sloc);
 410    begin
 411       Set_Discrete_Subtype_Definitions
 412         (N, Discrete_Subtype_Definitions);
 413       Set_Aliased_Present (N, Aliased_Present);
 414       Set_Subtype_Indication (N, Subtype_Indication);
 415       return N;
 416    end Make_Constrained_Array_Definition;
 417
 418    function Make_Discriminant_Specification (Sloc : Source_Ptr;
 419       Defining_Identifier          : Node_Id;
 420       Discriminant_Type            : Node_Id;
 421       Expression                   : Node_Id := Empty)
 422       return Node_Id
 423    is
 424       N : constant Node_Id :=
 425             New_Node (N_Discriminant_Specification, Sloc);
 426    begin
 427       Set_Defining_Identifier (N, Defining_Identifier);
 428       Set_Discriminant_Type (N, Discriminant_Type);
 429       Set_Expression (N, Expression);
 430       return N;
 431    end Make_Discriminant_Specification;
 432
 433    function Make_Index_Or_Discriminant_Constraint (Sloc : Source_Ptr;
 434       Constraints                  : List_Id)
 435       return Node_Id
 436    is
 437       N : constant Node_Id :=
 438             New_Node (N_Index_Or_Discriminant_Constraint, Sloc);
 439    begin
 440       Set_Constraints (N, Constraints);
 441       return N;
 442    end Make_Index_Or_Discriminant_Constraint;
 443
 444    function Make_Discriminant_Association (Sloc : Source_Ptr;
 445       Selector_Names               : List_Id;
 446       Expression                   : Node_Id)
 447       return Node_Id
 448    is
 449       N : constant Node_Id :=
 450             New_Node (N_Discriminant_Association, Sloc);
 451    begin
 452       Set_Selector_Names (N, Selector_Names);
 453       Set_Expression (N, Expression);
 454       return N;
 455    end Make_Discriminant_Association;
 456
 457    function Make_Record_Definition (Sloc : Source_Ptr;
 458       End_Label                    : Node_Id := Empty;
 459       Abstract_Present             : Boolean := False;
 460       Tagged_Present               : Boolean := False;
 461       Limited_Present              : Boolean := False;
 462       Component_List               : Node_Id;
 463       Null_Present                 : Boolean := False)
 464       return Node_Id
 465    is
 466       N : constant Node_Id :=
 467             New_Node (N_Record_Definition, Sloc);
 468    begin
 469       Set_End_Label (N, End_Label);
 470       Set_Abstract_Present (N, Abstract_Present);
 471       Set_Tagged_Present (N, Tagged_Present);
 472       Set_Limited_Present (N, Limited_Present);
 473       Set_Component_List (N, Component_List);
 474       Set_Null_Present (N, Null_Present);
 475       return N;
 476    end Make_Record_Definition;
 477
 478    function Make_Component_List (Sloc : Source_Ptr;
 479       Component_Items              : List_Id;
 480       Variant_Part                 : Node_Id := Empty;
 481       Null_Present                 : Boolean := False)
 482       return Node_Id
 483    is
 484       N : constant Node_Id :=
 485             New_Node (N_Component_List, Sloc);
 486    begin
 487       Set_Component_Items (N, Component_Items);
 488       Set_Variant_Part (N, Variant_Part);
 489       Set_Null_Present (N, Null_Present);
 490       return N;
 491    end Make_Component_List;
 492
 493    function Make_Component_Declaration (Sloc : Source_Ptr;
 494       Defining_Identifier          : Node_Id;
 495       Aliased_Present              : Boolean := False;
 496       Subtype_Indication           : Node_Id;
 497       Expression                   : Node_Id := Empty)
 498       return Node_Id
 499    is
 500       N : constant Node_Id :=
 501             New_Node (N_Component_Declaration, Sloc);
 502    begin
 503       Set_Defining_Identifier (N, Defining_Identifier);
 504       Set_Aliased_Present (N, Aliased_Present);
 505       Set_Subtype_Indication (N, Subtype_Indication);
 506       Set_Expression (N, Expression);
 507       return N;
 508    end Make_Component_Declaration;
 509
 510    function Make_Variant_Part (Sloc : Source_Ptr;
 511       Name                         : Node_Id;
 512       Variants                     : List_Id)
 513       return Node_Id
 514    is
 515       N : constant Node_Id :=
 516             New_Node (N_Variant_Part, Sloc);
 517    begin
 518       Set_Name (N, Name);
 519       Set_Variants (N, Variants);
 520       return N;
 521    end Make_Variant_Part;
 522
 523    function Make_Variant (Sloc : Source_Ptr;
 524       Discrete_Choices             : List_Id;
 525       Component_List               : Node_Id)
 526       return Node_Id
 527    is
 528       N : constant Node_Id :=
 529             New_Node (N_Variant, Sloc);
 530    begin
 531       Set_Discrete_Choices (N, Discrete_Choices);
 532       Set_Component_List (N, Component_List);
 533       return N;
 534    end Make_Variant;
 535
 536    function Make_Others_Choice (Sloc : Source_Ptr)
 537       return Node_Id
 538    is
 539       N : constant Node_Id :=
 540             New_Node (N_Others_Choice, Sloc);
 541    begin
 542       return N;
 543    end Make_Others_Choice;
 544
 545    function Make_Access_To_Object_Definition (Sloc : Source_Ptr;
 546       All_Present                  : Boolean := False;
 547       Subtype_Indication           : Node_Id;
 548       Constant_Present             : Boolean := False)
 549       return Node_Id
 550    is
 551       N : constant Node_Id :=
 552             New_Node (N_Access_To_Object_Definition, Sloc);
 553    begin
 554       Set_All_Present (N, All_Present);
 555       Set_Subtype_Indication (N, Subtype_Indication);
 556       Set_Constant_Present (N, Constant_Present);
 557       return N;
 558    end Make_Access_To_Object_Definition;
 559
 560    function Make_Access_Function_Definition (Sloc : Source_Ptr;
 561       Protected_Present            : Boolean := False;
 562       Parameter_Specifications     : List_Id := No_List;
 563       Subtype_Mark                 : Node_Id)
 564       return Node_Id
 565    is
 566       N : constant Node_Id :=
 567             New_Node (N_Access_Function_Definition, Sloc);
 568    begin
 569       Set_Protected_Present (N, Protected_Present);
 570       Set_Parameter_Specifications (N, Parameter_Specifications);
 571       Set_Subtype_Mark (N, Subtype_Mark);
 572       return N;
 573    end Make_Access_Function_Definition;
 574
 575    function Make_Access_Procedure_Definition (Sloc : Source_Ptr;
 576       Protected_Present            : Boolean := False;
 577       Parameter_Specifications     : List_Id := No_List)
 578       return Node_Id
 579    is
 580       N : constant Node_Id :=
 581             New_Node (N_Access_Procedure_Definition, Sloc);
 582    begin
 583       Set_Protected_Present (N, Protected_Present);
 584       Set_Parameter_Specifications (N, Parameter_Specifications);
 585       return N;
 586    end Make_Access_Procedure_Definition;
 587
 588    function Make_Access_Definition (Sloc : Source_Ptr;
 589       Subtype_Mark                 : Node_Id)
 590       return Node_Id
 591    is
 592       N : constant Node_Id :=
 593             New_Node (N_Access_Definition, Sloc);
 594    begin
 595       Set_Subtype_Mark (N, Subtype_Mark);
 596       return N;
 597    end Make_Access_Definition;
 598
 599    function Make_Incomplete_Type_Declaration (Sloc : Source_Ptr;
 600       Defining_Identifier          : Node_Id;
 601       Discriminant_Specifications  : List_Id := No_List;
 602       Unknown_Discriminants_Present : Boolean := False)
 603       return Node_Id
 604    is
 605       N : constant Node_Id :=
 606             New_Node (N_Incomplete_Type_Declaration, Sloc);
 607    begin
 608       Set_Defining_Identifier (N, Defining_Identifier);
 609       Set_Discriminant_Specifications (N, Discriminant_Specifications);
 610       Set_Unknown_Discriminants_Present
 611         (N, Unknown_Discriminants_Present);
 612       return N;
 613    end Make_Incomplete_Type_Declaration;
 614
 615    function Make_Explicit_Dereference (Sloc : Source_Ptr;
 616       Prefix                       : Node_Id)
 617       return Node_Id
 618    is
 619       N : constant Node_Id :=
 620             New_Node (N_Explicit_Dereference, Sloc);
 621    begin
 622       Set_Prefix (N, Prefix);
 623       return N;
 624    end Make_Explicit_Dereference;
 625
 626    function Make_Indexed_Component (Sloc : Source_Ptr;
 627       Prefix                       : Node_Id;
 628       Expressions                  : List_Id)
 629       return Node_Id
 630    is
 631       N : constant Node_Id :=
 632             New_Node (N_Indexed_Component, Sloc);
 633    begin
 634       Set_Prefix (N, Prefix);
 635       Set_Expressions (N, Expressions);
 636       return N;
 637    end Make_Indexed_Component;
 638
 639    function Make_Slice (Sloc : Source_Ptr;
 640       Prefix                       : Node_Id;
 641       Discrete_Range               : Node_Id)
 642       return Node_Id
 643    is
 644       N : constant Node_Id :=
 645             New_Node (N_Slice, Sloc);
 646    begin
 647       Set_Prefix (N, Prefix);
 648       Set_Discrete_Range (N, Discrete_Range);
 649       return N;
 650    end Make_Slice;
 651
 652    function Make_Selected_Component (Sloc : Source_Ptr;
 653       Prefix                       : Node_Id;
 654       Selector_Name                : Node_Id)
 655       return Node_Id
 656    is
 657       N : constant Node_Id :=
 658             New_Node (N_Selected_Component, Sloc);
 659    begin
 660       Set_Prefix (N, Prefix);
 661       Set_Selector_Name (N, Selector_Name);
 662       return N;
 663    end Make_Selected_Component;
 664
 665    function Make_Attribute_Reference (Sloc : Source_Ptr;
 666       Prefix                       : Node_Id;
 667       Attribute_Name               : Name_Id;
 668       Expressions                  : List_Id := No_List;
 669       Must_Be_Byte_Aligned         : Boolean := False)
 670       return Node_Id
 671    is
 672       N : constant Node_Id :=
 673             New_Node (N_Attribute_Reference, Sloc);
 674    begin
 675       Set_Prefix (N, Prefix);
 676       Set_Attribute_Name (N, Attribute_Name);
 677       Set_Expressions (N, Expressions);
 678       Set_Must_Be_Byte_Aligned (N, Must_Be_Byte_Aligned);
 679       return N;
 680    end Make_Attribute_Reference;
 681
 682    function Make_Aggregate (Sloc : Source_Ptr;
 683       Expressions                  : List_Id := No_List;
 684       Component_Associations       : List_Id := No_List;
 685       Null_Record_Present          : Boolean := False)
 686       return Node_Id
 687    is
 688       N : constant Node_Id :=
 689             New_Node (N_Aggregate, Sloc);
 690    begin
 691       Set_Expressions (N, Expressions);
 692       Set_Component_Associations (N, Component_Associations);
 693       Set_Null_Record_Present (N, Null_Record_Present);
 694       return N;
 695    end Make_Aggregate;
 696
 697    function Make_Component_Association (Sloc : Source_Ptr;
 698       Choices                      : List_Id;
 699       Expression                   : Node_Id)
 700       return Node_Id
 701    is
 702       N : constant Node_Id :=
 703             New_Node (N_Component_Association, Sloc);
 704    begin
 705       Set_Choices (N, Choices);
 706       Set_Expression (N, Expression);
 707       return N;
 708    end Make_Component_Association;
 709
 710    function Make_Extension_Aggregate (Sloc : Source_Ptr;
 711       Ancestor_Part                : Node_Id;
 712       Expressions                  : List_Id := No_List;
 713       Component_Associations       : List_Id := No_List;
 714       Null_Record_Present          : Boolean := False)
 715       return Node_Id
 716    is
 717       N : constant Node_Id :=
 718             New_Node (N_Extension_Aggregate, Sloc);
 719    begin
 720       Set_Ancestor_Part (N, Ancestor_Part);
 721       Set_Expressions (N, Expressions);
 722       Set_Component_Associations (N, Component_Associations);
 723       Set_Null_Record_Present (N, Null_Record_Present);
 724       return N;
 725    end Make_Extension_Aggregate;
 726
 727    function Make_Null (Sloc : Source_Ptr)
 728       return Node_Id
 729    is
 730       N : constant Node_Id :=
 731             New_Node (N_Null, Sloc);
 732    begin
 733       return N;
 734    end Make_Null;
 735
 736    function Make_And_Then (Sloc : Source_Ptr;
 737       Left_Opnd                    : Node_Id;
 738       Right_Opnd                   : Node_Id)
 739       return Node_Id
 740    is
 741       N : constant Node_Id :=
 742             New_Node (N_And_Then, Sloc);
 743    begin
 744       Set_Left_Opnd (N, Left_Opnd);
 745       Set_Right_Opnd (N, Right_Opnd);
 746       return N;
 747    end Make_And_Then;
 748
 749    function Make_Or_Else (Sloc : Source_Ptr;
 750       Left_Opnd                    : Node_Id;
 751       Right_Opnd                   : Node_Id)
 752       return Node_Id
 753    is
 754       N : constant Node_Id :=
 755             New_Node (N_Or_Else, Sloc);
 756    begin
 757       Set_Left_Opnd (N, Left_Opnd);
 758       Set_Right_Opnd (N, Right_Opnd);
 759       return N;
 760    end Make_Or_Else;
 761
 762    function Make_In (Sloc : Source_Ptr;
 763       Left_Opnd                    : Node_Id;
 764       Right_Opnd                   : Node_Id)
 765       return Node_Id
 766    is
 767       N : constant Node_Id :=
 768             New_Node (N_In, Sloc);
 769    begin
 770       Set_Left_Opnd (N, Left_Opnd);
 771       Set_Right_Opnd (N, Right_Opnd);
 772       return N;
 773    end Make_In;
 774
 775    function Make_Not_In (Sloc : Source_Ptr;
 776       Left_Opnd                    : Node_Id;
 777       Right_Opnd                   : Node_Id)
 778       return Node_Id
 779    is
 780       N : constant Node_Id :=
 781             New_Node (N_Not_In, Sloc);
 782    begin
 783       Set_Left_Opnd (N, Left_Opnd);
 784       Set_Right_Opnd (N, Right_Opnd);
 785       return N;
 786    end Make_Not_In;
 787
 788    function Make_Op_And (Sloc : Source_Ptr;
 789       Left_Opnd                    : Node_Id;
 790       Right_Opnd                   : Node_Id)
 791       return Node_Id
 792    is
 793       N : constant Node_Id :=
 794             New_Node (N_Op_And, Sloc);
 795    begin
 796       Set_Left_Opnd (N, Left_Opnd);
 797       Set_Right_Opnd (N, Right_Opnd);
 798       Set_Chars (N, Name_Op_And);
 799       Set_Entity (N, Standard_Op_And);
 800       return N;
 801    end Make_Op_And;
 802
 803    function Make_Op_Or (Sloc : Source_Ptr;
 804       Left_Opnd                    : Node_Id;
 805       Right_Opnd                   : Node_Id)
 806       return Node_Id
 807    is
 808       N : constant Node_Id :=
 809             New_Node (N_Op_Or, Sloc);
 810    begin
 811       Set_Left_Opnd (N, Left_Opnd);
 812       Set_Right_Opnd (N, Right_Opnd);
 813       Set_Chars (N, Name_Op_Or);
 814       Set_Entity (N, Standard_Op_Or);
 815       return N;
 816    end Make_Op_Or;
 817
 818    function Make_Op_Xor (Sloc : Source_Ptr;
 819       Left_Opnd                    : Node_Id;
 820       Right_Opnd                   : Node_Id)
 821       return Node_Id
 822    is
 823       N : constant Node_Id :=
 824             New_Node (N_Op_Xor, Sloc);
 825    begin
 826       Set_Left_Opnd (N, Left_Opnd);
 827       Set_Right_Opnd (N, Right_Opnd);
 828       Set_Chars (N, Name_Op_Xor);
 829       Set_Entity (N, Standard_Op_Xor);
 830       return N;
 831    end Make_Op_Xor;
 832
 833    function Make_Op_Eq (Sloc : Source_Ptr;
 834       Left_Opnd                    : Node_Id;
 835       Right_Opnd                   : Node_Id)
 836       return Node_Id
 837    is
 838       N : constant Node_Id :=
 839             New_Node (N_Op_Eq, Sloc);
 840    begin
 841       Set_Left_Opnd (N, Left_Opnd);
 842       Set_Right_Opnd (N, Right_Opnd);
 843       Set_Chars (N, Name_Op_Eq);
 844       Set_Entity (N, Standard_Op_Eq);
 845       return N;
 846    end Make_Op_Eq;
 847
 848    function Make_Op_Ne (Sloc : Source_Ptr;
 849       Left_Opnd                    : Node_Id;
 850       Right_Opnd                   : Node_Id)
 851       return Node_Id
 852    is
 853       N : constant Node_Id :=
 854             New_Node (N_Op_Ne, Sloc);
 855    begin
 856       Set_Left_Opnd (N, Left_Opnd);
 857       Set_Right_Opnd (N, Right_Opnd);
 858       Set_Chars (N, Name_Op_Ne);
 859       Set_Entity (N, Standard_Op_Ne);
 860       return N;
 861    end Make_Op_Ne;
 862
 863    function Make_Op_Lt (Sloc : Source_Ptr;
 864       Left_Opnd                    : Node_Id;
 865       Right_Opnd                   : Node_Id)
 866       return Node_Id
 867    is
 868       N : constant Node_Id :=
 869             New_Node (N_Op_Lt, Sloc);
 870    begin
 871       Set_Left_Opnd (N, Left_Opnd);
 872       Set_Right_Opnd (N, Right_Opnd);
 873       Set_Chars (N, Name_Op_Lt);
 874       Set_Entity (N, Standard_Op_Lt);
 875       return N;
 876    end Make_Op_Lt;
 877
 878    function Make_Op_Le (Sloc : Source_Ptr;
 879       Left_Opnd                    : Node_Id;
 880       Right_Opnd                   : Node_Id)
 881       return Node_Id
 882    is
 883       N : constant Node_Id :=
 884             New_Node (N_Op_Le, Sloc);
 885    begin
 886       Set_Left_Opnd (N, Left_Opnd);
 887       Set_Right_Opnd (N, Right_Opnd);
 888       Set_Chars (N, Name_Op_Le);
 889       Set_Entity (N, Standard_Op_Le);
 890       return N;
 891    end Make_Op_Le;
 892
 893    function Make_Op_Gt (Sloc : Source_Ptr;
 894       Left_Opnd                    : Node_Id;
 895       Right_Opnd                   : Node_Id)
 896       return Node_Id
 897    is
 898       N : constant Node_Id :=
 899             New_Node (N_Op_Gt, Sloc);
 900    begin
 901       Set_Left_Opnd (N, Left_Opnd);
 902       Set_Right_Opnd (N, Right_Opnd);
 903       Set_Chars (N, Name_Op_Gt);
 904       Set_Entity (N, Standard_Op_Gt);
 905       return N;
 906    end Make_Op_Gt;
 907
 908    function Make_Op_Ge (Sloc : Source_Ptr;
 909       Left_Opnd                    : Node_Id;
 910       Right_Opnd                   : Node_Id)
 911       return Node_Id
 912    is
 913       N : constant Node_Id :=
 914             New_Node (N_Op_Ge, Sloc);
 915    begin
 916       Set_Left_Opnd (N, Left_Opnd);
 917       Set_Right_Opnd (N, Right_Opnd);
 918       Set_Chars (N, Name_Op_Ge);
 919       Set_Entity (N, Standard_Op_Ge);
 920       return N;
 921    end Make_Op_Ge;
 922
 923    function Make_Op_Add (Sloc : Source_Ptr;
 924       Left_Opnd                    : Node_Id;
 925       Right_Opnd                   : Node_Id)
 926       return Node_Id
 927    is
 928       N : constant Node_Id :=
 929             New_Node (N_Op_Add, Sloc);
 930    begin
 931       Set_Left_Opnd (N, Left_Opnd);
 932       Set_Right_Opnd (N, Right_Opnd);
 933       Set_Chars (N, Name_Op_Add);
 934       Set_Entity (N, Standard_Op_Add);
 935       return N;
 936    end Make_Op_Add;
 937
 938    function Make_Op_Subtract (Sloc : Source_Ptr;
 939       Left_Opnd                    : Node_Id;
 940       Right_Opnd                   : Node_Id)
 941       return Node_Id
 942    is
 943       N : constant Node_Id :=
 944             New_Node (N_Op_Subtract, Sloc);
 945    begin
 946       Set_Left_Opnd (N, Left_Opnd);
 947       Set_Right_Opnd (N, Right_Opnd);
 948       Set_Chars (N, Name_Op_Subtract);
 949       Set_Entity (N, Standard_Op_Subtract);
 950       return N;
 951    end Make_Op_Subtract;
 952
 953    function Make_Op_Concat (Sloc : Source_Ptr;
 954       Left_Opnd                    : Node_Id;
 955       Right_Opnd                   : Node_Id)
 956       return Node_Id
 957    is
 958       N : constant Node_Id :=
 959             New_Node (N_Op_Concat, Sloc);
 960    begin
 961       Set_Left_Opnd (N, Left_Opnd);
 962       Set_Right_Opnd (N, Right_Opnd);
 963       Set_Chars (N, Name_Op_Concat);
 964       Set_Entity (N, Standard_Op_Concat);
 965       return N;
 966    end Make_Op_Concat;
 967
 968    function Make_Op_Multiply (Sloc : Source_Ptr;
 969       Left_Opnd                    : Node_Id;
 970       Right_Opnd                   : Node_Id)
 971       return Node_Id
 972    is
 973       N : constant Node_Id :=
 974             New_Node (N_Op_Multiply, Sloc);
 975    begin
 976       Set_Left_Opnd (N, Left_Opnd);
 977       Set_Right_Opnd (N, Right_Opnd);
 978       Set_Chars (N, Name_Op_Multiply);
 979       Set_Entity (N, Standard_Op_Multiply);
 980       return N;
 981    end Make_Op_Multiply;
 982
 983    function Make_Op_Divide (Sloc : Source_Ptr;
 984       Left_Opnd                    : Node_Id;
 985       Right_Opnd                   : Node_Id)
 986       return Node_Id
 987    is
 988       N : constant Node_Id :=
 989             New_Node (N_Op_Divide, Sloc);
 990    begin
 991       Set_Left_Opnd (N, Left_Opnd);
 992       Set_Right_Opnd (N, Right_Opnd);
 993       Set_Chars (N, Name_Op_Divide);
 994       Set_Entity (N, Standard_Op_Divide);
 995       return N;
 996    end Make_Op_Divide;
 997
 998    function Make_Op_Mod (Sloc : Source_Ptr;
 999       Left_Opnd                    : Node_Id;
1000       Right_Opnd                   : Node_Id)
1001       return Node_Id
1002    is
1003       N : constant Node_Id :=
1004             New_Node (N_Op_Mod, Sloc);
1005    begin
1006       Set_Left_Opnd (N, Left_Opnd);
1007       Set_Right_Opnd (N, Right_Opnd);
1008       Set_Chars (N, Name_Op_Mod);
1009       Set_Entity (N, Standard_Op_Mod);
1010       return N;
1011    end Make_Op_Mod;
1012
1013    function Make_Op_Rem (Sloc : Source_Ptr;
1014       Left_Opnd                    : Node_Id;
1015       Right_Opnd                   : Node_Id)
1016       return Node_Id
1017    is
1018       N : constant Node_Id :=
1019             New_Node (N_Op_Rem, Sloc);
1020    begin
1021       Set_Left_Opnd (N, Left_Opnd);
1022       Set_Right_Opnd (N, Right_Opnd);
1023       Set_Chars (N, Name_Op_Rem);
1024       Set_Entity (N, Standard_Op_Rem);
1025       return N;
1026    end Make_Op_Rem;
1027
1028    function Make_Op_Expon (Sloc : Source_Ptr;
1029       Left_Opnd                    : Node_Id;
1030       Right_Opnd                   : Node_Id)
1031       return Node_Id
1032    is
1033       N : constant Node_Id :=
1034             New_Node (N_Op_Expon, Sloc);
1035    begin
1036       Set_Left_Opnd (N, Left_Opnd);
1037       Set_Right_Opnd (N, Right_Opnd);
1038       Set_Chars (N, Name_Op_Expon);
1039       Set_Entity (N, Standard_Op_Expon);
1040       return N;
1041    end Make_Op_Expon;
1042
1043    function Make_Op_Plus (Sloc : Source_Ptr;
1044       Right_Opnd                   : Node_Id)
1045       return Node_Id
1046    is
1047       N : constant Node_Id :=
1048             New_Node (N_Op_Plus, Sloc);
1049    begin
1050       Set_Right_Opnd (N, Right_Opnd);
1051       Set_Chars (N, Name_Op_Add);
1052       Set_Entity (N, Standard_Op_Plus);
1053       return N;
1054    end Make_Op_Plus;
1055
1056    function Make_Op_Minus (Sloc : Source_Ptr;
1057       Right_Opnd                   : Node_Id)
1058       return Node_Id
1059    is
1060       N : constant Node_Id :=
1061             New_Node (N_Op_Minus, Sloc);
1062    begin
1063       Set_Right_Opnd (N, Right_Opnd);
1064       Set_Chars (N, Name_Op_Subtract);
1065       Set_Entity (N, Standard_Op_Minus);
1066       return N;
1067    end Make_Op_Minus;
1068
1069    function Make_Op_Abs (Sloc : Source_Ptr;
1070       Right_Opnd                   : Node_Id)
1071       return Node_Id
1072    is
1073       N : constant Node_Id :=
1074             New_Node (N_Op_Abs, Sloc);
1075    begin
1076       Set_Right_Opnd (N, Right_Opnd);
1077       Set_Chars (N, Name_Op_Abs);
1078       Set_Entity (N, Standard_Op_Abs);
1079       return N;
1080    end Make_Op_Abs;
1081
1082    function Make_Op_Not (Sloc : Source_Ptr;
1083       Right_Opnd                   : Node_Id)
1084       return Node_Id
1085    is
1086       N : constant Node_Id :=
1087             New_Node (N_Op_Not, Sloc);
1088    begin
1089       Set_Right_Opnd (N, Right_Opnd);
1090       Set_Chars (N, Name_Op_Not);
1091       Set_Entity (N, Standard_Op_Not);
1092       return N;
1093    end Make_Op_Not;
1094
1095    function Make_Type_Conversion (Sloc : Source_Ptr;
1096       Subtype_Mark                 : Node_Id;
1097       Expression                   : Node_Id)
1098       return Node_Id
1099    is
1100       N : constant Node_Id :=
1101             New_Node (N_Type_Conversion, Sloc);
1102    begin
1103       Set_Subtype_Mark (N, Subtype_Mark);
1104       Set_Expression (N, Expression);
1105       return N;
1106    end Make_Type_Conversion;
1107
1108    function Make_Qualified_Expression (Sloc : Source_Ptr;
1109       Subtype_Mark                 : Node_Id;
1110       Expression                   : Node_Id)
1111       return Node_Id
1112    is
1113       N : constant Node_Id :=
1114             New_Node (N_Qualified_Expression, Sloc);
1115    begin
1116       Set_Subtype_Mark (N, Subtype_Mark);
1117       Set_Expression (N, Expression);
1118       return N;
1119    end Make_Qualified_Expression;
1120
1121    function Make_Allocator (Sloc : Source_Ptr;
1122       Expression                   : Node_Id)
1123       return Node_Id
1124    is
1125       N : constant Node_Id :=
1126             New_Node (N_Allocator, Sloc);
1127    begin
1128       Set_Expression (N, Expression);
1129       return N;
1130    end Make_Allocator;
1131
1132    function Make_Null_Statement (Sloc : Source_Ptr)
1133       return Node_Id
1134    is
1135       N : constant Node_Id :=
1136             New_Node (N_Null_Statement, Sloc);
1137    begin
1138       return N;
1139    end Make_Null_Statement;
1140
1141    function Make_Label (Sloc : Source_Ptr;
1142       Identifier                   : Node_Id)
1143       return Node_Id
1144    is
1145       N : constant Node_Id :=
1146             New_Node (N_Label, Sloc);
1147    begin
1148       Set_Identifier (N, Identifier);
1149       return N;
1150    end Make_Label;
1151
1152    function Make_Assignment_Statement (Sloc : Source_Ptr;
1153       Name                         : Node_Id;
1154       Expression                   : Node_Id)
1155       return Node_Id
1156    is
1157       N : constant Node_Id :=
1158             New_Node (N_Assignment_Statement, Sloc);
1159    begin
1160       Set_Name (N, Name);
1161       Set_Expression (N, Expression);
1162       return N;
1163    end Make_Assignment_Statement;
1164
1165    function Make_If_Statement (Sloc : Source_Ptr;
1166       Condition                    : Node_Id;
1167       Then_Statements              : List_Id;
1168       Elsif_Parts                  : List_Id := No_List;
1169       Else_Statements              : List_Id := No_List;
1170       End_Span                     : Uint := No_Uint)
1171       return Node_Id
1172    is
1173       N : constant Node_Id :=
1174             New_Node (N_If_Statement, Sloc);
1175    begin
1176       Set_Condition (N, Condition);
1177       Set_Then_Statements (N, Then_Statements);
1178       Set_Elsif_Parts (N, Elsif_Parts);
1179       Set_Else_Statements (N, Else_Statements);
1180       Set_End_Span (N, End_Span);
1181       return N;
1182    end Make_If_Statement;
1183
1184    function Make_Elsif_Part (Sloc : Source_Ptr;
1185       Condition                    : Node_Id;
1186       Then_Statements              : List_Id)
1187       return Node_Id
1188    is
1189       N : constant Node_Id :=
1190             New_Node (N_Elsif_Part, Sloc);
1191    begin
1192       Set_Condition (N, Condition);
1193       Set_Then_Statements (N, Then_Statements);
1194       return N;
1195    end Make_Elsif_Part;
1196
1197    function Make_Case_Statement (Sloc : Source_Ptr;
1198       Expression                   : Node_Id;
1199       Alternatives                 : List_Id;
1200       End_Span                     : Uint := No_Uint)
1201       return Node_Id
1202    is
1203       N : constant Node_Id :=
1204             New_Node (N_Case_Statement, Sloc);
1205    begin
1206       Set_Expression (N, Expression);
1207       Set_Alternatives (N, Alternatives);
1208       Set_End_Span (N, End_Span);
1209       return N;
1210    end Make_Case_Statement;
1211
1212    function Make_Case_Statement_Alternative (Sloc : Source_Ptr;
1213       Discrete_Choices             : List_Id;
1214       Statements                   : List_Id)
1215       return Node_Id
1216    is
1217       N : constant Node_Id :=
1218             New_Node (N_Case_Statement_Alternative, Sloc);
1219    begin
1220       Set_Discrete_Choices (N, Discrete_Choices);
1221       Set_Statements (N, Statements);
1222       return N;
1223    end Make_Case_Statement_Alternative;
1224
1225    function Make_Loop_Statement (Sloc : Source_Ptr;
1226       Identifier                   : Node_Id := Empty;
1227       Iteration_Scheme             : Node_Id := Empty;
1228       Statements                   : List_Id;
1229       End_Label                    : Node_Id;
1230       Has_Created_Identifier       : Boolean := False)
1231       return Node_Id
1232    is
1233       N : constant Node_Id :=
1234             New_Node (N_Loop_Statement, Sloc);
1235    begin
1236       Set_Identifier (N, Identifier);
1237       Set_Iteration_Scheme (N, Iteration_Scheme);
1238       Set_Statements (N, Statements);
1239       Set_End_Label (N, End_Label);
1240       Set_Has_Created_Identifier (N, Has_Created_Identifier);
1241       return N;
1242    end Make_Loop_Statement;
1243
1244    function Make_Iteration_Scheme (Sloc : Source_Ptr;
1245       Condition                    : Node_Id := Empty;
1246       Loop_Parameter_Specification : Node_Id := Empty)
1247       return Node_Id
1248    is
1249       N : constant Node_Id :=
1250             New_Node (N_Iteration_Scheme, Sloc);
1251    begin
1252       Set_Condition (N, Condition);
1253       Set_Loop_Parameter_Specification
1254         (N, Loop_Parameter_Specification);
1255       return N;
1256    end Make_Iteration_Scheme;
1257
1258    function Make_Loop_Parameter_Specification (Sloc : Source_Ptr;
1259       Defining_Identifier          : Node_Id;
1260       Reverse_Present              : Boolean := False;
1261       Discrete_Subtype_Definition  : Node_Id)
1262       return Node_Id
1263    is
1264       N : constant Node_Id :=
1265             New_Node (N_Loop_Parameter_Specification, Sloc);
1266    begin
1267       Set_Defining_Identifier (N, Defining_Identifier);
1268       Set_Reverse_Present (N, Reverse_Present);
1269       Set_Discrete_Subtype_Definition (N, Discrete_Subtype_Definition);
1270       return N;
1271    end Make_Loop_Parameter_Specification;
1272
1273    function Make_Block_Statement (Sloc : Source_Ptr;
1274       Identifier                   : Node_Id := Empty;
1275       Declarations                 : List_Id := No_List;
1276       Handled_Statement_Sequence   : Node_Id;
1277       Has_Created_Identifier       : Boolean := False;
1278       Is_Task_Allocation_Block     : Boolean := False;
1279       Is_Asynchronous_Call_Block   : Boolean := False)
1280       return Node_Id
1281    is
1282       N : constant Node_Id :=
1283             New_Node (N_Block_Statement, Sloc);
1284    begin
1285       Set_Identifier (N, Identifier);
1286       Set_Declarations (N, Declarations);
1287       Set_Handled_Statement_Sequence (N, Handled_Statement_Sequence);
1288       Set_Has_Created_Identifier (N, Has_Created_Identifier);
1289       Set_Is_Task_Allocation_Block (N, Is_Task_Allocation_Block);
1290       Set_Is_Asynchronous_Call_Block (N, Is_Asynchronous_Call_Block);
1291       return N;
1292    end Make_Block_Statement;
1293
1294    function Make_Exit_Statement (Sloc : Source_Ptr;
1295       Name                         : Node_Id := Empty;
1296       Condition                    : Node_Id := Empty)
1297       return Node_Id
1298    is
1299       N : constant Node_Id :=
1300             New_Node (N_Exit_Statement, Sloc);
1301    begin
1302       Set_Name (N, Name);
1303       Set_Condition (N, Condition);
1304       return N;
1305    end Make_Exit_Statement;
1306
1307    function Make_Goto_Statement (Sloc : Source_Ptr;
1308       Name                         : Node_Id)
1309       return Node_Id
1310    is
1311       N : constant Node_Id :=
1312             New_Node (N_Goto_Statement, Sloc);
1313    begin
1314       Set_Name (N, Name);
1315       return N;
1316    end Make_Goto_Statement;
1317
1318    function Make_Subprogram_Declaration (Sloc : Source_Ptr;
1319       Specification                : Node_Id)
1320       return Node_Id
1321    is
1322       N : constant Node_Id :=
1323             New_Node (N_Subprogram_Declaration, Sloc);
1324    begin
1325       Set_Specification (N, Specification);
1326       return N;
1327    end Make_Subprogram_Declaration;
1328
1329    function Make_Abstract_Subprogram_Declaration (Sloc : Source_Ptr;
1330       Specification                : Node_Id)
1331       return Node_Id
1332    is
1333       N : constant Node_Id :=
1334             New_Node (N_Abstract_Subprogram_Declaration, Sloc);
1335    begin
1336       Set_Specification (N, Specification);
1337       return N;
1338    end Make_Abstract_Subprogram_Declaration;
1339
1340    function Make_Function_Specification (Sloc : Source_Ptr;
1341       Defining_Unit_Name           : Node_Id;
1342       Parameter_Specifications     : List_Id := No_List;
1343       Subtype_Mark                 : Node_Id)
1344       return Node_Id
1345    is
1346       N : constant Node_Id :=
1347             New_Node (N_Function_Specification, Sloc);
1348    begin
1349       Set_Defining_Unit_Name (N, Defining_Unit_Name);
1350       Set_Parameter_Specifications (N, Parameter_Specifications);
1351       Set_Subtype_Mark (N, Subtype_Mark);
1352       return N;
1353    end Make_Function_Specification;
1354
1355    function Make_Procedure_Specification (Sloc : Source_Ptr;
1356       Defining_Unit_Name           : Node_Id;
1357       Parameter_Specifications     : List_Id := No_List)
1358       return Node_Id
1359    is
1360       N : constant Node_Id :=
1361             New_Node (N_Procedure_Specification, Sloc);
1362    begin
1363       Set_Defining_Unit_Name (N, Defining_Unit_Name);
1364       Set_Parameter_Specifications (N, Parameter_Specifications);
1365       return N;
1366    end Make_Procedure_Specification;
1367
1368    function Make_Designator (Sloc : Source_Ptr;
1369       Name                         : Node_Id;
1370       Identifier                   : Node_Id)
1371       return Node_Id
1372    is
1373       N : constant Node_Id :=
1374             New_Node (N_Designator, Sloc);
1375    begin
1376       Set_Name (N, Name);
1377       Set_Identifier (N, Identifier);
1378       return N;
1379    end Make_Designator;
1380
1381    function Make_Defining_Program_Unit_Name (Sloc : Source_Ptr;
1382       Name                         : Node_Id;
1383       Defining_Identifier          : Node_Id)
1384       return Node_Id
1385    is
1386       N : constant Node_Id :=
1387             New_Node (N_Defining_Program_Unit_Name, Sloc);
1388    begin
1389       Set_Name (N, Name);
1390       Set_Defining_Identifier (N, Defining_Identifier);
1391       return N;
1392    end Make_Defining_Program_Unit_Name;
1393
1394    function Make_Operator_Symbol (Sloc : Source_Ptr;
1395       Chars                        : Name_Id;
1396       Strval                       : String_Id)
1397       return Node_Id
1398    is
1399       N : constant Node_Id :=
1400             New_Node (N_Operator_Symbol, Sloc);
1401    begin
1402       Set_Chars (N, Chars);
1403       Set_Strval (N, Strval);
1404       return N;
1405    end Make_Operator_Symbol;
1406
1407    function Make_Defining_Operator_Symbol (Sloc : Source_Ptr;
1408       Chars                        : Name_Id)
1409       return Node_Id
1410    is
1411       N : constant Node_Id :=
1412             New_Entity (N_Defining_Operator_Symbol, Sloc);
1413    begin
1414       Set_Chars (N, Chars);
1415       return N;
1416    end Make_Defining_Operator_Symbol;
1417
1418    function Make_Parameter_Specification (Sloc : Source_Ptr;
1419       Defining_Identifier          : Node_Id;
1420       In_Present                   : Boolean := False;
1421       Out_Present                  : Boolean := False;
1422       Parameter_Type               : Node_Id;
1423       Expression                   : Node_Id := Empty)
1424       return Node_Id
1425    is
1426       N : constant Node_Id :=
1427             New_Node (N_Parameter_Specification, Sloc);
1428    begin
1429       Set_Defining_Identifier (N, Defining_Identifier);
1430       Set_In_Present (N, In_Present);
1431       Set_Out_Present (N, Out_Present);
1432       Set_Parameter_Type (N, Parameter_Type);
1433       Set_Expression (N, Expression);
1434       return N;
1435    end Make_Parameter_Specification;
1436
1437    function Make_Subprogram_Body (Sloc : Source_Ptr;
1438       Specification                : Node_Id;
1439       Declarations                 : List_Id;
1440       Handled_Statement_Sequence   : Node_Id;
1441       Bad_Is_Detected              : Boolean := False)
1442       return Node_Id
1443    is
1444       N : constant Node_Id :=
1445             New_Node (N_Subprogram_Body, Sloc);
1446    begin
1447       Set_Specification (N, Specification);
1448       Set_Declarations (N, Declarations);
1449       Set_Handled_Statement_Sequence (N, Handled_Statement_Sequence);
1450       Set_Bad_Is_Detected (N, Bad_Is_Detected);
1451       return N;
1452    end Make_Subprogram_Body;
1453
1454    function Make_Procedure_Call_Statement (Sloc : Source_Ptr;
1455       Name                         : Node_Id;
1456       Parameter_Associations       : List_Id := No_List)
1457       return Node_Id
1458    is
1459       N : constant Node_Id :=
1460             New_Node (N_Procedure_Call_Statement, Sloc);
1461    begin
1462       Set_Name (N, Name);
1463       Set_Parameter_Associations (N, Parameter_Associations);
1464       return N;
1465    end Make_Procedure_Call_Statement;
1466
1467    function Make_Function_Call (Sloc : Source_Ptr;
1468       Name                         : Node_Id;
1469       Parameter_Associations       : List_Id := No_List)
1470       return Node_Id
1471    is
1472       N : constant Node_Id :=
1473             New_Node (N_Function_Call, Sloc);
1474    begin
1475       Set_Name (N, Name);
1476       Set_Parameter_Associations (N, Parameter_Associations);
1477       return N;
1478    end Make_Function_Call;
1479
1480    function Make_Parameter_Association (Sloc : Source_Ptr;
1481       Selector_Name                : Node_Id;
1482       Explicit_Actual_Parameter    : Node_Id)
1483       return Node_Id
1484    is
1485       N : constant Node_Id :=
1486             New_Node (N_Parameter_Association, Sloc);
1487    begin
1488       Set_Selector_Name (N, Selector_Name);
1489       Set_Explicit_Actual_Parameter (N, Explicit_Actual_Parameter);
1490       return N;
1491    end Make_Parameter_Association;
1492
1493    function Make_Return_Statement (Sloc : Source_Ptr;
1494       Expression                   : Node_Id := Empty)
1495       return Node_Id
1496    is
1497       N : constant Node_Id :=
1498             New_Node (N_Return_Statement, Sloc);
1499    begin
1500       Set_Expression (N, Expression);
1501       return N;
1502    end Make_Return_Statement;
1503
1504    function Make_Package_Declaration (Sloc : Source_Ptr;
1505       Specification                : Node_Id)
1506       return Node_Id
1507    is
1508       N : constant Node_Id :=
1509             New_Node (N_Package_Declaration, Sloc);
1510    begin
1511       Set_Specification (N, Specification);
1512       return N;
1513    end Make_Package_Declaration;
1514
1515    function Make_Package_Specification (Sloc : Source_Ptr;
1516       Defining_Unit_Name           : Node_Id;
1517       Visible_Declarations         : List_Id;
1518       Private_Declarations         : List_Id := No_List;
1519       End_Label                    : Node_Id)
1520       return Node_Id
1521    is
1522       N : constant Node_Id :=
1523             New_Node (N_Package_Specification, Sloc);
1524    begin
1525       Set_Defining_Unit_Name (N, Defining_Unit_Name);
1526       Set_Visible_Declarations (N, Visible_Declarations);
1527       Set_Private_Declarations (N, Private_Declarations);
1528       Set_End_Label (N, End_Label);
1529       return N;
1530    end Make_Package_Specification;
1531
1532    function Make_Package_Body (Sloc : Source_Ptr;
1533       Defining_Unit_Name           : Node_Id;
1534       Declarations                 : List_Id;
1535       Handled_Statement_Sequence   : Node_Id := Empty)
1536       return Node_Id
1537    is
1538       N : constant Node_Id :=
1539             New_Node (N_Package_Body, Sloc);
1540    begin
1541       Set_Defining_Unit_Name (N, Defining_Unit_Name);
1542       Set_Declarations (N, Declarations);
1543       Set_Handled_Statement_Sequence (N, Handled_Statement_Sequence);
1544       return N;
1545    end Make_Package_Body;
1546
1547    function Make_Private_Type_Declaration (Sloc : Source_Ptr;
1548       Defining_Identifier          : Node_Id;
1549       Discriminant_Specifications  : List_Id := No_List;
1550       Unknown_Discriminants_Present : Boolean := False;
1551       Abstract_Present             : Boolean := False;
1552       Tagged_Present               : Boolean := False;
1553       Limited_Present              : Boolean := False)
1554       return Node_Id
1555    is
1556       N : constant Node_Id :=
1557             New_Node (N_Private_Type_Declaration, Sloc);
1558    begin
1559       Set_Defining_Identifier (N, Defining_Identifier);
1560       Set_Discriminant_Specifications (N, Discriminant_Specifications);
1561       Set_Unknown_Discriminants_Present
1562         (N, Unknown_Discriminants_Present);
1563       Set_Abstract_Present (N, Abstract_Present);
1564       Set_Tagged_Present (N, Tagged_Present);
1565       Set_Limited_Present (N, Limited_Present);
1566       return N;
1567    end Make_Private_Type_Declaration;
1568
1569    function Make_Private_Extension_Declaration (Sloc : Source_Ptr;
1570       Defining_Identifier          : Node_Id;
1571       Discriminant_Specifications  : List_Id := No_List;
1572       Unknown_Discriminants_Present : Boolean := False;
1573       Abstract_Present             : Boolean := False;
1574       Subtype_Indication           : Node_Id)
1575       return Node_Id
1576    is
1577       N : constant Node_Id :=
1578             New_Node (N_Private_Extension_Declaration, Sloc);
1579    begin
1580       Set_Defining_Identifier (N, Defining_Identifier);
1581       Set_Discriminant_Specifications (N, Discriminant_Specifications);
1582       Set_Unknown_Discriminants_Present
1583         (N, Unknown_Discriminants_Present);
1584       Set_Abstract_Present (N, Abstract_Present);
1585       Set_Subtype_Indication (N, Subtype_Indication);
1586       return N;
1587    end Make_Private_Extension_Declaration;
1588
1589    function Make_Use_Package_Clause (Sloc : Source_Ptr;
1590       Names                        : List_Id)
1591       return Node_Id
1592    is
1593       N : constant Node_Id :=
1594             New_Node (N_Use_Package_Clause, Sloc);
1595    begin
1596       Set_Names (N, Names);
1597       return N;
1598    end Make_Use_Package_Clause;
1599
1600    function Make_Use_Type_Clause (Sloc : Source_Ptr;
1601       Subtype_Marks                : List_Id)
1602       return Node_Id
1603    is
1604       N : constant Node_Id :=
1605             New_Node (N_Use_Type_Clause, Sloc);
1606    begin
1607       Set_Subtype_Marks (N, Subtype_Marks);
1608       return N;
1609    end Make_Use_Type_Clause;
1610
1611    function Make_Object_Renaming_Declaration (Sloc : Source_Ptr;
1612       Defining_Identifier          : Node_Id;
1613       Subtype_Mark                 : Node_Id;
1614       Name                         : Node_Id)
1615       return Node_Id
1616    is
1617       N : constant Node_Id :=
1618             New_Node (N_Object_Renaming_Declaration, Sloc);
1619    begin
1620       Set_Defining_Identifier (N, Defining_Identifier);
1621       Set_Subtype_Mark (N, Subtype_Mark);
1622       Set_Name (N, Name);
1623       return N;
1624    end Make_Object_Renaming_Declaration;
1625
1626    function Make_Exception_Renaming_Declaration (Sloc : Source_Ptr;
1627       Defining_Identifier          : Node_Id;
1628       Name                         : Node_Id)
1629       return Node_Id
1630    is
1631       N : constant Node_Id :=
1632             New_Node (N_Exception_Renaming_Declaration, Sloc);
1633    begin
1634       Set_Defining_Identifier (N, Defining_Identifier);
1635       Set_Name (N, Name);
1636       return N;
1637    end Make_Exception_Renaming_Declaration;
1638
1639    function Make_Package_Renaming_Declaration (Sloc : Source_Ptr;
1640       Defining_Unit_Name           : Node_Id;
1641       Name                         : Node_Id)
1642       return Node_Id
1643    is
1644       N : constant Node_Id :=
1645             New_Node (N_Package_Renaming_Declaration, Sloc);
1646    begin
1647       Set_Defining_Unit_Name (N, Defining_Unit_Name);
1648       Set_Name (N, Name);
1649       return N;
1650    end Make_Package_Renaming_Declaration;
1651
1652    function Make_Subprogram_Renaming_Declaration (Sloc : Source_Ptr;
1653       Specification                : Node_Id;
1654       Name                         : Node_Id)
1655       return Node_Id
1656    is
1657       N : constant Node_Id :=
1658             New_Node (N_Subprogram_Renaming_Declaration, Sloc);
1659    begin
1660       Set_Specification (N, Specification);
1661       Set_Name (N, Name);
1662       return N;
1663    end Make_Subprogram_Renaming_Declaration;
1664
1665    function Make_Generic_Package_Renaming_Declaration (Sloc : Source_Ptr;
1666       Defining_Unit_Name           : Node_Id;
1667       Name                         : Node_Id)
1668       return Node_Id
1669    is
1670       N : constant Node_Id :=
1671             New_Node (N_Generic_Package_Renaming_Declaration, Sloc);
1672    begin
1673       Set_Defining_Unit_Name (N, Defining_Unit_Name);
1674       Set_Name (N, Name);
1675       return N;
1676    end Make_Generic_Package_Renaming_Declaration;
1677
1678    function Make_Generic_Procedure_Renaming_Declaration (Sloc : Source_Ptr;
1679       Defining_Unit_Name           : Node_Id;
1680       Name                         : Node_Id)
1681       return Node_Id
1682    is
1683       N : constant Node_Id :=
1684             New_Node (N_Generic_Procedure_Renaming_Declaration, Sloc);
1685    begin
1686       Set_Defining_Unit_Name (N, Defining_Unit_Name);
1687       Set_Name (N, Name);
1688       return N;
1689    end Make_Generic_Procedure_Renaming_Declaration;
1690
1691    function Make_Generic_Function_Renaming_Declaration (Sloc : Source_Ptr;
1692       Defining_Unit_Name           : Node_Id;
1693       Name                         : Node_Id)
1694       return Node_Id
1695    is
1696       N : constant Node_Id :=
1697             New_Node (N_Generic_Function_Renaming_Declaration, Sloc);
1698    begin
1699       Set_Defining_Unit_Name (N, Defining_Unit_Name);
1700       Set_Name (N, Name);
1701       return N;
1702    end Make_Generic_Function_Renaming_Declaration;
1703
1704    function Make_Task_Type_Declaration (Sloc : Source_Ptr;
1705       Defining_Identifier          : Node_Id;
1706       Discriminant_Specifications  : List_Id := No_List;
1707       Task_Definition              : Node_Id := Empty)
1708       return Node_Id
1709    is
1710       N : constant Node_Id :=
1711             New_Node (N_Task_Type_Declaration, Sloc);
1712    begin
1713       Set_Defining_Identifier (N, Defining_Identifier);
1714       Set_Discriminant_Specifications (N, Discriminant_Specifications);
1715       Set_Task_Definition (N, Task_Definition);
1716       return N;
1717    end Make_Task_Type_Declaration;
1718
1719    function Make_Single_Task_Declaration (Sloc : Source_Ptr;
1720       Defining_Identifier          : Node_Id;
1721       Task_Definition              : Node_Id := Empty)
1722       return Node_Id
1723    is
1724       N : constant Node_Id :=
1725             New_Node (N_Single_Task_Declaration, Sloc);
1726    begin
1727       Set_Defining_Identifier (N, Defining_Identifier);
1728       Set_Task_Definition (N, Task_Definition);
1729       return N;
1730    end Make_Single_Task_Declaration;
1731
1732    function Make_Task_Definition (Sloc : Source_Ptr;
1733       Visible_Declarations         : List_Id;
1734       Private_Declarations         : List_Id := No_List;
1735       End_Label                    : Node_Id)
1736       return Node_Id
1737    is
1738       N : constant Node_Id :=
1739             New_Node (N_Task_Definition, Sloc);
1740    begin
1741       Set_Visible_Declarations (N, Visible_Declarations);
1742       Set_Private_Declarations (N, Private_Declarations);
1743       Set_End_Label (N, End_Label);
1744       return N;
1745    end Make_Task_Definition;
1746
1747    function Make_Task_Body (Sloc : Source_Ptr;
1748       Defining_Identifier          : Node_Id;
1749       Declarations                 : List_Id;
1750       Handled_Statement_Sequence   : Node_Id)
1751       return Node_Id
1752    is
1753       N : constant Node_Id :=
1754             New_Node (N_Task_Body, Sloc);
1755    begin
1756       Set_Defining_Identifier (N, Defining_Identifier);
1757       Set_Declarations (N, Declarations);
1758       Set_Handled_Statement_Sequence (N, Handled_Statement_Sequence);
1759       return N;
1760    end Make_Task_Body;
1761
1762    function Make_Protected_Type_Declaration (Sloc : Source_Ptr;
1763       Defining_Identifier          : Node_Id;
1764       Discriminant_Specifications  : List_Id := No_List;
1765       Protected_Definition         : Node_Id)
1766       return Node_Id
1767    is
1768       N : constant Node_Id :=
1769             New_Node (N_Protected_Type_Declaration, Sloc);
1770    begin
1771       Set_Defining_Identifier (N, Defining_Identifier);
1772       Set_Discriminant_Specifications (N, Discriminant_Specifications);
1773       Set_Protected_Definition (N, Protected_Definition);
1774       return N;
1775    end Make_Protected_Type_Declaration;
1776
1777    function Make_Single_Protected_Declaration (Sloc : Source_Ptr;
1778       Defining_Identifier          : Node_Id;
1779       Protected_Definition         : Node_Id)
1780       return Node_Id
1781    is
1782       N : constant Node_Id :=
1783             New_Node (N_Single_Protected_Declaration, Sloc);
1784    begin
1785       Set_Defining_Identifier (N, Defining_Identifier);
1786       Set_Protected_Definition (N, Protected_Definition);
1787       return N;
1788    end Make_Single_Protected_Declaration;
1789
1790    function Make_Protected_Definition (Sloc : Source_Ptr;
1791       Visible_Declarations         : List_Id;
1792       Private_Declarations         : List_Id := No_List;
1793       End_Label                    : Node_Id)
1794       return Node_Id
1795    is
1796       N : constant Node_Id :=
1797             New_Node (N_Protected_Definition, Sloc);
1798    begin
1799       Set_Visible_Declarations (N, Visible_Declarations);
1800       Set_Private_Declarations (N, Private_Declarations);
1801       Set_End_Label (N, End_Label);
1802       return N;
1803    end Make_Protected_Definition;
1804
1805    function Make_Protected_Body (Sloc : Source_Ptr;
1806       Defining_Identifier          : Node_Id;
1807       Declarations                 : List_Id;
1808       End_Label                    : Node_Id)
1809       return Node_Id
1810    is
1811       N : constant Node_Id :=
1812             New_Node (N_Protected_Body, Sloc);
1813    begin
1814       Set_Defining_Identifier (N, Defining_Identifier);
1815       Set_Declarations (N, Declarations);
1816       Set_End_Label (N, End_Label);
1817       return N;
1818    end Make_Protected_Body;
1819
1820    function Make_Entry_Declaration (Sloc : Source_Ptr;
1821       Defining_Identifier          : Node_Id;
1822       Discrete_Subtype_Definition  : Node_Id := Empty;
1823       Parameter_Specifications     : List_Id := No_List)
1824       return Node_Id
1825    is
1826       N : constant Node_Id :=
1827             New_Node (N_Entry_Declaration, Sloc);
1828    begin
1829       Set_Defining_Identifier (N, Defining_Identifier);
1830       Set_Discrete_Subtype_Definition (N, Discrete_Subtype_Definition);
1831       Set_Parameter_Specifications (N, Parameter_Specifications);
1832       return N;
1833    end Make_Entry_Declaration;
1834
1835    function Make_Accept_Statement (Sloc : Source_Ptr;
1836       Entry_Direct_Name            : Node_Id;
1837       Entry_Index                  : Node_Id := Empty;
1838       Parameter_Specifications     : List_Id := No_List;
1839       Handled_Statement_Sequence   : Node_Id;
1840       Declarations                 : List_Id := No_List)
1841       return Node_Id
1842    is
1843       N : constant Node_Id :=
1844             New_Node (N_Accept_Statement, Sloc);
1845    begin
1846       Set_Entry_Direct_Name (N, Entry_Direct_Name);
1847       Set_Entry_Index (N, Entry_Index);
1848       Set_Parameter_Specifications (N, Parameter_Specifications);
1849       Set_Handled_Statement_Sequence (N, Handled_Statement_Sequence);
1850       Set_Declarations (N, Declarations);
1851       return N;
1852    end Make_Accept_Statement;
1853
1854    function Make_Entry_Body (Sloc : Source_Ptr;
1855       Defining_Identifier          : Node_Id;
1856       Entry_Body_Formal_Part       : Node_Id;
1857       Declarations                 : List_Id;
1858       Handled_Statement_Sequence   : Node_Id)
1859       return Node_Id
1860    is
1861       N : constant Node_Id :=
1862             New_Node (N_Entry_Body, Sloc);
1863    begin
1864       Set_Defining_Identifier (N, Defining_Identifier);
1865       Set_Entry_Body_Formal_Part (N, Entry_Body_Formal_Part);
1866       Set_Declarations (N, Declarations);
1867       Set_Handled_Statement_Sequence (N, Handled_Statement_Sequence);
1868       return N;
1869    end Make_Entry_Body;
1870
1871    function Make_Entry_Body_Formal_Part (Sloc : Source_Ptr;
1872       Entry_Index_Specification    : Node_Id := Empty;
1873       Parameter_Specifications     : List_Id := No_List;
1874       Condition                    : Node_Id)
1875       return Node_Id
1876    is
1877       N : constant Node_Id :=
1878             New_Node (N_Entry_Body_Formal_Part, Sloc);
1879    begin
1880       Set_Entry_Index_Specification (N, Entry_Index_Specification);
1881       Set_Parameter_Specifications (N, Parameter_Specifications);
1882       Set_Condition (N, Condition);
1883       return N;
1884    end Make_Entry_Body_Formal_Part;
1885
1886    function Make_Entry_Index_Specification (Sloc : Source_Ptr;
1887       Defining_Identifier          : Node_Id;
1888       Discrete_Subtype_Definition  : Node_Id)
1889       return Node_Id
1890    is
1891       N : constant Node_Id :=
1892             New_Node (N_Entry_Index_Specification, Sloc);
1893    begin
1894       Set_Defining_Identifier (N, Defining_Identifier);
1895       Set_Discrete_Subtype_Definition (N, Discrete_Subtype_Definition);
1896       return N;
1897    end Make_Entry_Index_Specification;
1898
1899    function Make_Entry_Call_Statement (Sloc : Source_Ptr;
1900       Name                         : Node_Id;
1901       Parameter_Associations       : List_Id := No_List)
1902       return Node_Id
1903    is
1904       N : constant Node_Id :=
1905             New_Node (N_Entry_Call_Statement, Sloc);
1906    begin
1907       Set_Name (N, Name);
1908       Set_Parameter_Associations (N, Parameter_Associations);
1909       return N;
1910    end Make_Entry_Call_Statement;
1911
1912    function Make_Requeue_Statement (Sloc : Source_Ptr;
1913       Name                         : Node_Id;
1914       Abort_Present                : Boolean := False)
1915       return Node_Id
1916    is
1917       N : constant Node_Id :=
1918             New_Node (N_Requeue_Statement, Sloc);
1919    begin
1920       Set_Name (N, Name);
1921       Set_Abort_Present (N, Abort_Present);
1922       return N;
1923    end Make_Requeue_Statement;
1924
1925    function Make_Delay_Until_Statement (Sloc : Source_Ptr;
1926       Expression                   : Node_Id)
1927       return Node_Id
1928    is
1929       N : constant Node_Id :=
1930             New_Node (N_Delay_Until_Statement, Sloc);
1931    begin
1932       Set_Expression (N, Expression);
1933       return N;
1934    end Make_Delay_Until_Statement;
1935
1936    function Make_Delay_Relative_Statement (Sloc : Source_Ptr;
1937       Expression                   : Node_Id)
1938       return Node_Id
1939    is
1940       N : constant Node_Id :=
1941             New_Node (N_Delay_Relative_Statement, Sloc);
1942    begin
1943       Set_Expression (N, Expression);
1944       return N;
1945    end Make_Delay_Relative_Statement;
1946
1947    function Make_Selective_Accept (Sloc : Source_Ptr;
1948       Select_Alternatives          : List_Id;
1949       Else_Statements              : List_Id := No_List)
1950       return Node_Id
1951    is
1952       N : constant Node_Id :=
1953             New_Node (N_Selective_Accept, Sloc);
1954    begin
1955       Set_Select_Alternatives (N, Select_Alternatives);
1956       Set_Else_Statements (N, Else_Statements);
1957       return N;
1958    end Make_Selective_Accept;
1959
1960    function Make_Accept_Alternative (Sloc : Source_Ptr;
1961       Accept_Statement             : Node_Id;
1962       Condition                    : Node_Id := Empty;
1963       Statements                   : List_Id := Empty_List;
1964       Pragmas_Before               : List_Id := No_List)
1965       return Node_Id
1966    is
1967       N : constant Node_Id :=
1968             New_Node (N_Accept_Alternative, Sloc);
1969    begin
1970       Set_Accept_Statement (N, Accept_Statement);
1971       Set_Condition (N, Condition);
1972       Set_Statements (N, Statements);
1973       Set_Pragmas_Before (N, Pragmas_Before);
1974       return N;
1975    end Make_Accept_Alternative;
1976
1977    function Make_Delay_Alternative (Sloc : Source_Ptr;
1978       Delay_Statement              : Node_Id;
1979       Condition                    : Node_Id := Empty;
1980       Statements                   : List_Id := Empty_List;
1981       Pragmas_Before               : List_Id := No_List)
1982       return Node_Id
1983    is
1984       N : constant Node_Id :=
1985             New_Node (N_Delay_Alternative, Sloc);
1986    begin
1987       Set_Delay_Statement (N, Delay_Statement);
1988       Set_Condition (N, Condition);
1989       Set_Statements (N, Statements);
1990       Set_Pragmas_Before (N, Pragmas_Before);
1991       return N;
1992    end Make_Delay_Alternative;
1993
1994    function Make_Terminate_Alternative (Sloc : Source_Ptr;
1995       Condition                    : Node_Id := Empty;
1996       Pragmas_Before               : List_Id := No_List;
1997       Pragmas_After                : List_Id := No_List)
1998       return Node_Id
1999    is
2000       N : constant Node_Id :=
2001             New_Node (N_Terminate_Alternative, Sloc);
2002    begin
2003       Set_Condition (N, Condition);
2004       Set_Pragmas_Before (N, Pragmas_Before);
2005       Set_Pragmas_After (N, Pragmas_After);
2006       return N;
2007    end Make_Terminate_Alternative;
2008
2009    function Make_Timed_Entry_Call (Sloc : Source_Ptr;
2010       Entry_Call_Alternative       : Node_Id;
2011       Delay_Alternative            : Node_Id)
2012       return Node_Id
2013    is
2014       N : constant Node_Id :=
2015             New_Node (N_Timed_Entry_Call, Sloc);
2016    begin
2017       Set_Entry_Call_Alternative (N, Entry_Call_Alternative);
2018       Set_Delay_Alternative (N, Delay_Alternative);
2019       return N;
2020    end Make_Timed_Entry_Call;
2021
2022    function Make_Entry_Call_Alternative (Sloc : Source_Ptr;
2023       Entry_Call_Statement         : Node_Id;
2024       Statements                   : List_Id := Empty_List;
2025       Pragmas_Before               : List_Id := No_List)
2026       return Node_Id
2027    is
2028       N : constant Node_Id :=
2029             New_Node (N_Entry_Call_Alternative, Sloc);
2030    begin
2031       Set_Entry_Call_Statement (N, Entry_Call_Statement);
2032       Set_Statements (N, Statements);
2033       Set_Pragmas_Before (N, Pragmas_Before);
2034       return N;
2035    end Make_Entry_Call_Alternative;
2036
2037    function Make_Conditional_Entry_Call (Sloc : Source_Ptr;
2038       Entry_Call_Alternative       : Node_Id;
2039       Else_Statements              : List_Id)
2040       return Node_Id
2041    is
2042       N : constant Node_Id :=
2043             New_Node (N_Conditional_Entry_Call, Sloc);
2044    begin
2045       Set_Entry_Call_Alternative (N, Entry_Call_Alternative);
2046       Set_Else_Statements (N, Else_Statements);
2047       return N;
2048    end Make_Conditional_Entry_Call;
2049
2050    function Make_Asynchronous_Select (Sloc : Source_Ptr;
2051       Triggering_Alternative       : Node_Id;
2052       Abortable_Part               : Node_Id)
2053       return Node_Id
2054    is
2055       N : constant Node_Id :=
2056             New_Node (N_Asynchronous_Select, Sloc);
2057    begin
2058       Set_Triggering_Alternative (N, Triggering_Alternative);
2059       Set_Abortable_Part (N, Abortable_Part);
2060       return N;
2061    end Make_Asynchronous_Select;
2062
2063    function Make_Triggering_Alternative (Sloc : Source_Ptr;
2064       Triggering_Statement         : Node_Id;
2065       Statements                   : List_Id := Empty_List;
2066       Pragmas_Before               : List_Id := No_List)
2067       return Node_Id
2068    is
2069       N : constant Node_Id :=
2070             New_Node (N_Triggering_Alternative, Sloc);
2071    begin
2072       Set_Triggering_Statement (N, Triggering_Statement);
2073       Set_Statements (N, Statements);
2074       Set_Pragmas_Before (N, Pragmas_Before);
2075       return N;
2076    end Make_Triggering_Alternative;
2077
2078    function Make_Abortable_Part (Sloc : Source_Ptr;
2079       Statements                   : List_Id)
2080       return Node_Id
2081    is
2082       N : constant Node_Id :=
2083             New_Node (N_Abortable_Part, Sloc);
2084    begin
2085       Set_Statements (N, Statements);
2086       return N;
2087    end Make_Abortable_Part;
2088
2089    function Make_Abort_Statement (Sloc : Source_Ptr;
2090       Names                        : List_Id)
2091       return Node_Id
2092    is
2093       N : constant Node_Id :=
2094             New_Node (N_Abort_Statement, Sloc);
2095    begin
2096       Set_Names (N, Names);
2097       return N;
2098    end Make_Abort_Statement;
2099
2100    function Make_Compilation_Unit (Sloc : Source_Ptr;
2101       Context_Items                : List_Id;
2102       Private_Present              : Boolean := False;
2103       Unit                         : Node_Id;
2104       Aux_Decls_Node               : Node_Id)
2105       return Node_Id
2106    is
2107       N : constant Node_Id :=
2108             New_Node (N_Compilation_Unit, Sloc);
2109    begin
2110       Set_Context_Items (N, Context_Items);
2111       Set_Private_Present (N, Private_Present);
2112       Set_Unit (N, Unit);
2113       Set_Aux_Decls_Node (N, Aux_Decls_Node);
2114       return N;
2115    end Make_Compilation_Unit;
2116
2117    function Make_Compilation_Unit_Aux (Sloc : Source_Ptr;
2118       Declarations                 : List_Id := No_List;
2119       Actions                      : List_Id := No_List;
2120       Pragmas_After                : List_Id := No_List)
2121       return Node_Id
2122    is
2123       N : constant Node_Id :=
2124             New_Node (N_Compilation_Unit_Aux, Sloc);
2125    begin
2126       Set_Declarations (N, Declarations);
2127       Set_Actions (N, Actions);
2128       Set_Pragmas_After (N, Pragmas_After);
2129       return N;
2130    end Make_Compilation_Unit_Aux;
2131
2132    function Make_With_Clause (Sloc : Source_Ptr;
2133       Name                         : Node_Id;
2134       First_Name                   : Boolean := True;
2135       Last_Name                    : Boolean := True)
2136       return Node_Id
2137    is
2138       N : constant Node_Id :=
2139             New_Node (N_With_Clause, Sloc);
2140    begin
2141       Set_Name (N, Name);
2142       Set_First_Name (N, First_Name);
2143       Set_Last_Name (N, Last_Name);
2144       return N;
2145    end Make_With_Clause;
2146
2147    function Make_With_Type_Clause (Sloc : Source_Ptr;
2148       Name                         : Node_Id;
2149       Tagged_Present               : Boolean := False)
2150       return Node_Id
2151    is
2152       N : constant Node_Id :=
2153             New_Node (N_With_Type_Clause, Sloc);
2154    begin
2155       Set_Name (N, Name);
2156       Set_Tagged_Present (N, Tagged_Present);
2157       return N;
2158    end Make_With_Type_Clause;
2159
2160    function Make_Subprogram_Body_Stub (Sloc : Source_Ptr;
2161       Specification                : Node_Id)
2162       return Node_Id
2163    is
2164       N : constant Node_Id :=
2165             New_Node (N_Subprogram_Body_Stub, Sloc);
2166    begin
2167       Set_Specification (N, Specification);
2168       return N;
2169    end Make_Subprogram_Body_Stub;
2170
2171    function Make_Package_Body_Stub (Sloc : Source_Ptr;
2172       Defining_Identifier          : Node_Id)
2173       return Node_Id
2174    is
2175       N : constant Node_Id :=
2176             New_Node (N_Package_Body_Stub, Sloc);
2177    begin
2178       Set_Defining_Identifier (N, Defining_Identifier);
2179       return N;
2180    end Make_Package_Body_Stub;
2181
2182    function Make_Task_Body_Stub (Sloc : Source_Ptr;
2183       Defining_Identifier          : Node_Id)
2184       return Node_Id
2185    is
2186       N : constant Node_Id :=
2187             New_Node (N_Task_Body_Stub, Sloc);
2188    begin
2189       Set_Defining_Identifier (N, Defining_Identifier);
2190       return N;
2191    end Make_Task_Body_Stub;
2192
2193    function Make_Protected_Body_Stub (Sloc : Source_Ptr;
2194       Defining_Identifier          : Node_Id)
2195       return Node_Id
2196    is
2197       N : constant Node_Id :=
2198             New_Node (N_Protected_Body_Stub, Sloc);
2199    begin
2200       Set_Defining_Identifier (N, Defining_Identifier);
2201       return N;
2202    end Make_Protected_Body_Stub;
2203
2204    function Make_Subunit (Sloc : Source_Ptr;
2205       Name                         : Node_Id;
2206       Proper_Body                  : Node_Id)
2207       return Node_Id
2208    is
2209       N : constant Node_Id :=
2210             New_Node (N_Subunit, Sloc);
2211    begin
2212       Set_Name (N, Name);
2213       Set_Proper_Body (N, Proper_Body);
2214       return N;
2215    end Make_Subunit;
2216
2217    function Make_Exception_Declaration (Sloc : Source_Ptr;
2218       Defining_Identifier          : Node_Id)
2219       return Node_Id
2220    is
2221       N : constant Node_Id :=
2222             New_Node (N_Exception_Declaration, Sloc);
2223    begin
2224       Set_Defining_Identifier (N, Defining_Identifier);
2225       return N;
2226    end Make_Exception_Declaration;
2227
2228    function Make_Handled_Sequence_Of_Statements (Sloc : Source_Ptr;
2229       Statements                   : List_Id;
2230       End_Label                    : Node_Id := Empty;
2231       Exception_Handlers           : List_Id := No_List;
2232       At_End_Proc                  : Node_Id := Empty)
2233       return Node_Id
2234    is
2235       N : constant Node_Id :=
2236             New_Node (N_Handled_Sequence_Of_Statements, Sloc);
2237    begin
2238       Set_Statements (N, Statements);
2239       Set_End_Label (N, End_Label);
2240       Set_Exception_Handlers (N, Exception_Handlers);
2241       Set_At_End_Proc (N, At_End_Proc);
2242       return N;
2243    end Make_Handled_Sequence_Of_Statements;
2244
2245    function Make_Exception_Handler (Sloc : Source_Ptr;
2246       Choice_Parameter             : Node_Id := Empty;
2247       Exception_Choices            : List_Id;
2248       Statements                   : List_Id)
2249       return Node_Id
2250    is
2251       N : constant Node_Id :=
2252             New_Node (N_Exception_Handler, Sloc);
2253    begin
2254       Set_Choice_Parameter (N, Choice_Parameter);
2255       Set_Exception_Choices (N, Exception_Choices);
2256       Set_Statements (N, Statements);
2257       return N;
2258    end Make_Exception_Handler;
2259
2260    function Make_Raise_Statement (Sloc : Source_Ptr;
2261       Name                         : Node_Id := Empty)
2262       return Node_Id
2263    is
2264       N : constant Node_Id :=
2265             New_Node (N_Raise_Statement, Sloc);
2266    begin
2267       Set_Name (N, Name);
2268       return N;
2269    end Make_Raise_Statement;
2270
2271    function Make_Generic_Subprogram_Declaration (Sloc : Source_Ptr;
2272       Specification                : Node_Id;
2273       Generic_Formal_Declarations  : List_Id)
2274       return Node_Id
2275    is
2276       N : constant Node_Id :=
2277             New_Node (N_Generic_Subprogram_Declaration, Sloc);
2278    begin
2279       Set_Specification (N, Specification);
2280       Set_Generic_Formal_Declarations (N, Generic_Formal_Declarations);
2281       return N;
2282    end Make_Generic_Subprogram_Declaration;
2283
2284    function Make_Generic_Package_Declaration (Sloc : Source_Ptr;
2285       Specification                : Node_Id;
2286       Generic_Formal_Declarations  : List_Id)
2287       return Node_Id
2288    is
2289       N : constant Node_Id :=
2290             New_Node (N_Generic_Package_Declaration, Sloc);
2291    begin
2292       Set_Specification (N, Specification);
2293       Set_Generic_Formal_Declarations (N, Generic_Formal_Declarations);
2294       return N;
2295    end Make_Generic_Package_Declaration;
2296
2297    function Make_Package_Instantiation (Sloc : Source_Ptr;
2298       Defining_Unit_Name           : Node_Id;
2299       Name                         : Node_Id;
2300       Generic_Associations         : List_Id := No_List)
2301       return Node_Id
2302    is
2303       N : constant Node_Id :=
2304             New_Node (N_Package_Instantiation, Sloc);
2305    begin
2306       Set_Defining_Unit_Name (N, Defining_Unit_Name);
2307       Set_Name (N, Name);
2308       Set_Generic_Associations (N, Generic_Associations);
2309       return N;
2310    end Make_Package_Instantiation;
2311
2312    function Make_Procedure_Instantiation (Sloc : Source_Ptr;
2313       Defining_Unit_Name           : Node_Id;
2314       Name                         : Node_Id;
2315       Generic_Associations         : List_Id := No_List)
2316       return Node_Id
2317    is
2318       N : constant Node_Id :=
2319             New_Node (N_Procedure_Instantiation, Sloc);
2320    begin
2321       Set_Defining_Unit_Name (N, Defining_Unit_Name);
2322       Set_Name (N, Name);
2323       Set_Generic_Associations (N, Generic_Associations);
2324       return N;
2325    end Make_Procedure_Instantiation;
2326
2327    function Make_Function_Instantiation (Sloc : Source_Ptr;
2328       Defining_Unit_Name           : Node_Id;
2329       Name                         : Node_Id;
2330       Generic_Associations         : List_Id := No_List)
2331       return Node_Id
2332    is
2333       N : constant Node_Id :=
2334             New_Node (N_Function_Instantiation, Sloc);
2335    begin
2336       Set_Defining_Unit_Name (N, Defining_Unit_Name);
2337       Set_Name (N, Name);
2338       Set_Generic_Associations (N, Generic_Associations);
2339       return N;
2340    end Make_Function_Instantiation;
2341
2342    function Make_Generic_Association (Sloc : Source_Ptr;
2343       Selector_Name                : Node_Id := Empty;
2344       Explicit_Generic_Actual_Parameter : Node_Id)
2345       return Node_Id
2346    is
2347       N : constant Node_Id :=
2348             New_Node (N_Generic_Association, Sloc);
2349    begin
2350       Set_Selector_Name (N, Selector_Name);
2351       Set_Explicit_Generic_Actual_Parameter
2352         (N, Explicit_Generic_Actual_Parameter);
2353       return N;
2354    end Make_Generic_Association;
2355
2356    function Make_Formal_Object_Declaration (Sloc : Source_Ptr;
2357       Defining_Identifier          : Node_Id;
2358       In_Present                   : Boolean := False;
2359       Out_Present                  : Boolean := False;
2360       Subtype_Mark                 : Node_Id;
2361       Expression                   : Node_Id := Empty)
2362       return Node_Id
2363    is
2364       N : constant Node_Id :=
2365             New_Node (N_Formal_Object_Declaration, Sloc);
2366    begin
2367       Set_Defining_Identifier (N, Defining_Identifier);
2368       Set_In_Present (N, In_Present);
2369       Set_Out_Present (N, Out_Present);
2370       Set_Subtype_Mark (N, Subtype_Mark);
2371       Set_Expression (N, Expression);
2372       return N;
2373    end Make_Formal_Object_Declaration;
2374
2375    function Make_Formal_Type_Declaration (Sloc : Source_Ptr;
2376       Defining_Identifier          : Node_Id;
2377       Formal_Type_Definition       : Node_Id;
2378       Discriminant_Specifications  : List_Id := No_List;
2379       Unknown_Discriminants_Present : Boolean := False)
2380       return Node_Id
2381    is
2382       N : constant Node_Id :=
2383             New_Node (N_Formal_Type_Declaration, Sloc);
2384    begin
2385       Set_Defining_Identifier (N, Defining_Identifier);
2386       Set_Formal_Type_Definition (N, Formal_Type_Definition);
2387       Set_Discriminant_Specifications (N, Discriminant_Specifications);
2388       Set_Unknown_Discriminants_Present
2389         (N, Unknown_Discriminants_Present);
2390       return N;
2391    end Make_Formal_Type_Declaration;
2392
2393    function Make_Formal_Private_Type_Definition (Sloc : Source_Ptr;
2394       Abstract_Present             : Boolean := False;
2395       Tagged_Present               : Boolean := False;
2396       Limited_Present              : Boolean := False)
2397       return Node_Id
2398    is
2399       N : constant Node_Id :=
2400             New_Node (N_Formal_Private_Type_Definition, Sloc);
2401    begin
2402       Set_Abstract_Present (N, Abstract_Present);
2403       Set_Tagged_Present (N, Tagged_Present);
2404       Set_Limited_Present (N, Limited_Present);
2405       return N;
2406    end Make_Formal_Private_Type_Definition;
2407
2408    function Make_Formal_Derived_Type_Definition (Sloc : Source_Ptr;
2409       Subtype_Mark                 : Node_Id;
2410       Private_Present              : Boolean := False;
2411       Abstract_Present             : Boolean := False)
2412       return Node_Id
2413    is
2414       N : constant Node_Id :=
2415             New_Node (N_Formal_Derived_Type_Definition, Sloc);
2416    begin
2417       Set_Subtype_Mark (N, Subtype_Mark);
2418       Set_Private_Present (N, Private_Present);
2419       Set_Abstract_Present (N, Abstract_Present);
2420       return N;
2421    end Make_Formal_Derived_Type_Definition;
2422
2423    function Make_Formal_Discrete_Type_Definition (Sloc : Source_Ptr)
2424       return Node_Id
2425    is
2426       N : constant Node_Id :=
2427             New_Node (N_Formal_Discrete_Type_Definition, Sloc);
2428    begin
2429       return N;
2430    end Make_Formal_Discrete_Type_Definition;
2431
2432    function Make_Formal_Signed_Integer_Type_Definition (Sloc : Source_Ptr)
2433       return Node_Id
2434    is
2435       N : constant Node_Id :=
2436             New_Node (N_Formal_Signed_Integer_Type_Definition, Sloc);
2437    begin
2438       return N;
2439    end Make_Formal_Signed_Integer_Type_Definition;
2440
2441    function Make_Formal_Modular_Type_Definition (Sloc : Source_Ptr)
2442       return Node_Id
2443    is
2444       N : constant Node_Id :=
2445             New_Node (N_Formal_Modular_Type_Definition, Sloc);
2446    begin
2447       return N;
2448    end Make_Formal_Modular_Type_Definition;
2449
2450    function Make_Formal_Floating_Point_Definition (Sloc : Source_Ptr)
2451       return Node_Id
2452    is
2453       N : constant Node_Id :=
2454             New_Node (N_Formal_Floating_Point_Definition, Sloc);
2455    begin
2456       return N;
2457    end Make_Formal_Floating_Point_Definition;
2458
2459    function Make_Formal_Ordinary_Fixed_Point_Definition (Sloc : Source_Ptr)
2460       return Node_Id
2461    is
2462       N : constant Node_Id :=
2463             New_Node (N_Formal_Ordinary_Fixed_Point_Definition, Sloc);
2464    begin
2465       return N;
2466    end Make_Formal_Ordinary_Fixed_Point_Definition;
2467
2468    function Make_Formal_Decimal_Fixed_Point_Definition (Sloc : Source_Ptr)
2469       return Node_Id
2470    is
2471       N : constant Node_Id :=
2472             New_Node (N_Formal_Decimal_Fixed_Point_Definition, Sloc);
2473    begin
2474       return N;
2475    end Make_Formal_Decimal_Fixed_Point_Definition;
2476
2477    function Make_Formal_Subprogram_Declaration (Sloc : Source_Ptr;
2478       Specification                : Node_Id;
2479       Default_Name                 : Node_Id := Empty;
2480       Box_Present                  : Boolean := False)
2481       return Node_Id
2482    is
2483       N : constant Node_Id :=
2484             New_Node (N_Formal_Subprogram_Declaration, Sloc);
2485    begin
2486       Set_Specification (N, Specification);
2487       Set_Default_Name (N, Default_Name);
2488       Set_Box_Present (N, Box_Present);
2489       return N;
2490    end Make_Formal_Subprogram_Declaration;
2491
2492    function Make_Formal_Package_Declaration (Sloc : Source_Ptr;
2493       Defining_Identifier          : Node_Id;
2494       Name                         : Node_Id;
2495       Generic_Associations         : List_Id := No_List;
2496       Box_Present                  : Boolean := False)
2497       return Node_Id
2498    is
2499       N : constant Node_Id :=
2500             New_Node (N_Formal_Package_Declaration, Sloc);
2501    begin
2502       Set_Defining_Identifier (N, Defining_Identifier);
2503       Set_Name (N, Name);
2504       Set_Generic_Associations (N, Generic_Associations);
2505       Set_Box_Present (N, Box_Present);
2506       return N;
2507    end Make_Formal_Package_Declaration;
2508
2509    function Make_Attribute_Definition_Clause (Sloc : Source_Ptr;
2510       Name                         : Node_Id;
2511       Chars                        : Name_Id;
2512       Expression                   : Node_Id)
2513       return Node_Id
2514    is
2515       N : constant Node_Id :=
2516             New_Node (N_Attribute_Definition_Clause, Sloc);
2517    begin
2518       Set_Name (N, Name);
2519       Set_Chars (N, Chars);
2520       Set_Expression (N, Expression);
2521       return N;
2522    end Make_Attribute_Definition_Clause;
2523
2524    function Make_Enumeration_Representation_Clause (Sloc : Source_Ptr;
2525       Identifier                   : Node_Id;
2526       Array_Aggregate              : Node_Id)
2527       return Node_Id
2528    is
2529       N : constant Node_Id :=
2530             New_Node (N_Enumeration_Representation_Clause, Sloc);
2531    begin
2532       Set_Identifier (N, Identifier);
2533       Set_Array_Aggregate (N, Array_Aggregate);
2534       return N;
2535    end Make_Enumeration_Representation_Clause;
2536
2537    function Make_Record_Representation_Clause (Sloc : Source_Ptr;
2538       Identifier                   : Node_Id;
2539       Mod_Clause                   : Node_Id := Empty;
2540       Component_Clauses            : List_Id)
2541       return Node_Id
2542    is
2543       N : constant Node_Id :=
2544             New_Node (N_Record_Representation_Clause, Sloc);
2545    begin
2546       Set_Identifier (N, Identifier);
2547       Set_Mod_Clause (N, Mod_Clause);
2548       Set_Component_Clauses (N, Component_Clauses);
2549       return N;
2550    end Make_Record_Representation_Clause;
2551
2552    function Make_Component_Clause (Sloc : Source_Ptr;
2553       Component_Name               : Node_Id;
2554       Position                     : Node_Id;
2555       First_Bit                    : Node_Id;
2556       Last_Bit                     : Node_Id)
2557       return Node_Id
2558    is
2559       N : constant Node_Id :=
2560             New_Node (N_Component_Clause, Sloc);
2561    begin
2562       Set_Component_Name (N, Component_Name);
2563       Set_Position (N, Position);
2564       Set_First_Bit (N, First_Bit);
2565       Set_Last_Bit (N, Last_Bit);
2566       return N;
2567    end Make_Component_Clause;
2568
2569    function Make_Code_Statement (Sloc : Source_Ptr;
2570       Expression                   : Node_Id)
2571       return Node_Id
2572    is
2573       N : constant Node_Id :=
2574             New_Node (N_Code_Statement, Sloc);
2575    begin
2576       Set_Expression (N, Expression);
2577       return N;
2578    end Make_Code_Statement;
2579
2580    function Make_Op_Rotate_Left (Sloc : Source_Ptr;
2581       Left_Opnd                    : Node_Id;
2582       Right_Opnd                   : Node_Id)
2583       return Node_Id
2584    is
2585       N : constant Node_Id :=
2586             New_Node (N_Op_Rotate_Left, Sloc);
2587    begin
2588       Set_Left_Opnd (N, Left_Opnd);
2589       Set_Right_Opnd (N, Right_Opnd);
2590       Set_Chars (N, Name_Rotate_Left);
2591       Set_Entity (N, Standard_Op_Rotate_Left);
2592       return N;
2593    end Make_Op_Rotate_Left;
2594
2595    function Make_Op_Rotate_Right (Sloc : Source_Ptr;
2596       Left_Opnd                    : Node_Id;
2597       Right_Opnd                   : Node_Id)
2598       return Node_Id
2599    is
2600       N : constant Node_Id :=
2601             New_Node (N_Op_Rotate_Right, Sloc);
2602    begin
2603       Set_Left_Opnd (N, Left_Opnd);
2604       Set_Right_Opnd (N, Right_Opnd);
2605       Set_Chars (N, Name_Rotate_Right);
2606       Set_Entity (N, Standard_Op_Rotate_Right);
2607       return N;
2608    end Make_Op_Rotate_Right;
2609
2610    function Make_Op_Shift_Left (Sloc : Source_Ptr;
2611       Left_Opnd                    : Node_Id;
2612       Right_Opnd                   : Node_Id)
2613       return Node_Id
2614    is
2615       N : constant Node_Id :=
2616             New_Node (N_Op_Shift_Left, Sloc);
2617    begin
2618       Set_Left_Opnd (N, Left_Opnd);
2619       Set_Right_Opnd (N, Right_Opnd);
2620       Set_Chars (N, Name_Shift_Left);
2621       Set_Entity (N, Standard_Op_Shift_Left);
2622       return N;
2623    end Make_Op_Shift_Left;
2624
2625    function Make_Op_Shift_Right_Arithmetic (Sloc : Source_Ptr;
2626       Left_Opnd                    : Node_Id;
2627       Right_Opnd                   : Node_Id)
2628       return Node_Id
2629    is
2630       N : constant Node_Id :=
2631             New_Node (N_Op_Shift_Right_Arithmetic, Sloc);
2632    begin
2633       Set_Left_Opnd (N, Left_Opnd);
2634       Set_Right_Opnd (N, Right_Opnd);
2635       Set_Chars (N, Name_Shift_Right_Arithmetic);
2636       Set_Entity (N, Standard_Op_Shift_Right_Arithmetic);
2637       return N;
2638    end Make_Op_Shift_Right_Arithmetic;
2639
2640    function Make_Op_Shift_Right (Sloc : Source_Ptr;
2641       Left_Opnd                    : Node_Id;
2642       Right_Opnd                   : Node_Id)
2643       return Node_Id
2644    is
2645       N : constant Node_Id :=
2646             New_Node (N_Op_Shift_Right, Sloc);
2647    begin
2648       Set_Left_Opnd (N, Left_Opnd);
2649       Set_Right_Opnd (N, Right_Opnd);
2650       Set_Chars (N, Name_Shift_Right);
2651       Set_Entity (N, Standard_Op_Shift_Right);
2652       return N;
2653    end Make_Op_Shift_Right;
2654
2655    function Make_Delta_Constraint (Sloc : Source_Ptr;
2656       Delta_Expression             : Node_Id;
2657       Range_Constraint             : Node_Id := Empty)
2658       return Node_Id
2659    is
2660       N : constant Node_Id :=
2661             New_Node (N_Delta_Constraint, Sloc);
2662    begin
2663       Set_Delta_Expression (N, Delta_Expression);
2664       Set_Range_Constraint (N, Range_Constraint);
2665       return N;
2666    end Make_Delta_Constraint;
2667
2668    function Make_At_Clause (Sloc : Source_Ptr;
2669       Identifier                   : Node_Id;
2670       Expression                   : Node_Id)
2671       return Node_Id
2672    is
2673       N : constant Node_Id :=
2674             New_Node (N_At_Clause, Sloc);
2675    begin
2676       Set_Identifier (N, Identifier);
2677       Set_Expression (N, Expression);
2678       return N;
2679    end Make_At_Clause;
2680
2681    function Make_Mod_Clause (Sloc : Source_Ptr;
2682       Expression                   : Node_Id;
2683       Pragmas_Before               : List_Id)
2684       return Node_Id
2685    is
2686       N : constant Node_Id :=
2687             New_Node (N_Mod_Clause, Sloc);
2688    begin
2689       Set_Expression (N, Expression);
2690       Set_Pragmas_Before (N, Pragmas_Before);
2691       return N;
2692    end Make_Mod_Clause;
2693
2694    function Make_Conditional_Expression (Sloc : Source_Ptr;
2695       Expressions                  : List_Id)
2696       return Node_Id
2697    is
2698       N : constant Node_Id :=
2699             New_Node (N_Conditional_Expression, Sloc);
2700    begin
2701       Set_Expressions (N, Expressions);
2702       return N;
2703    end Make_Conditional_Expression;
2704
2705    function Make_Expanded_Name (Sloc : Source_Ptr;
2706       Chars                        : Name_Id;
2707       Prefix                       : Node_Id;
2708       Selector_Name                : Node_Id)
2709       return Node_Id
2710    is
2711       N : constant Node_Id :=
2712             New_Node (N_Expanded_Name, Sloc);
2713    begin
2714       Set_Chars (N, Chars);
2715       Set_Prefix (N, Prefix);
2716       Set_Selector_Name (N, Selector_Name);
2717       return N;
2718    end Make_Expanded_Name;
2719
2720    function Make_Free_Statement (Sloc : Source_Ptr;
2721       Expression                   : Node_Id)
2722       return Node_Id
2723    is
2724       N : constant Node_Id :=
2725             New_Node (N_Free_Statement, Sloc);
2726    begin
2727       Set_Expression (N, Expression);
2728       return N;
2729    end Make_Free_Statement;
2730
2731    function Make_Freeze_Entity (Sloc : Source_Ptr;
2732       Actions                      : List_Id := No_List)
2733       return Node_Id
2734    is
2735       N : constant Node_Id :=
2736             New_Node (N_Freeze_Entity, Sloc);
2737    begin
2738       Set_Actions (N, Actions);
2739       return N;
2740    end Make_Freeze_Entity;
2741
2742    function Make_Implicit_Label_Declaration (Sloc : Source_Ptr;
2743       Defining_Identifier          : Node_Id)
2744       return Node_Id
2745    is
2746       N : constant Node_Id :=
2747             New_Node (N_Implicit_Label_Declaration, Sloc);
2748    begin
2749       Set_Defining_Identifier (N, Defining_Identifier);
2750       return N;
2751    end Make_Implicit_Label_Declaration;
2752
2753    function Make_Itype_Reference (Sloc : Source_Ptr)
2754       return Node_Id
2755    is
2756       N : constant Node_Id :=
2757             New_Node (N_Itype_Reference, Sloc);
2758    begin
2759       return N;
2760    end Make_Itype_Reference;
2761
2762    function Make_Raise_Constraint_Error (Sloc : Source_Ptr;
2763       Condition                    : Node_Id := Empty;
2764       Reason                       : Uint)
2765       return Node_Id
2766    is
2767       N : constant Node_Id :=
2768             New_Node (N_Raise_Constraint_Error, Sloc);
2769    begin
2770       Set_Condition (N, Condition);
2771       Set_Reason (N, Reason);
2772       return N;
2773    end Make_Raise_Constraint_Error;
2774
2775    function Make_Raise_Program_Error (Sloc : Source_Ptr;
2776       Condition                    : Node_Id := Empty;
2777       Reason                       : Uint)
2778       return Node_Id
2779    is
2780       N : constant Node_Id :=
2781             New_Node (N_Raise_Program_Error, Sloc);
2782    begin
2783       Set_Condition (N, Condition);
2784       Set_Reason (N, Reason);
2785       return N;
2786    end Make_Raise_Program_Error;
2787
2788    function Make_Raise_Storage_Error (Sloc : Source_Ptr;
2789       Condition                    : Node_Id := Empty;
2790       Reason                       : Uint)
2791       return Node_Id
2792    is
2793       N : constant Node_Id :=
2794             New_Node (N_Raise_Storage_Error, Sloc);
2795    begin
2796       Set_Condition (N, Condition);
2797       Set_Reason (N, Reason);
2798       return N;
2799    end Make_Raise_Storage_Error;
2800
2801    function Make_Reference (Sloc : Source_Ptr;
2802       Prefix                       : Node_Id)
2803       return Node_Id
2804    is
2805       N : constant Node_Id :=
2806             New_Node (N_Reference, Sloc);
2807    begin
2808       Set_Prefix (N, Prefix);
2809       return N;
2810    end Make_Reference;
2811
2812    function Make_Subprogram_Info (Sloc : Source_Ptr;
2813       Identifier                   : Node_Id)
2814       return Node_Id
2815    is
2816       N : constant Node_Id :=
2817             New_Node (N_Subprogram_Info, Sloc);
2818    begin
2819       Set_Identifier (N, Identifier);
2820       return N;
2821    end Make_Subprogram_Info;
2822
2823    function Make_Unchecked_Expression (Sloc : Source_Ptr;
2824       Expression                   : Node_Id)
2825       return Node_Id
2826    is
2827       N : constant Node_Id :=
2828             New_Node (N_Unchecked_Expression, Sloc);
2829    begin
2830       Set_Expression (N, Expression);
2831       return N;
2832    end Make_Unchecked_Expression;
2833
2834    function Make_Unchecked_Type_Conversion (Sloc : Source_Ptr;
2835       Subtype_Mark                 : Node_Id;
2836       Expression                   : Node_Id)
2837       return Node_Id
2838    is
2839       N : constant Node_Id :=
2840             New_Node (N_Unchecked_Type_Conversion, Sloc);
2841    begin
2842       Set_Subtype_Mark (N, Subtype_Mark);
2843       Set_Expression (N, Expression);
2844       return N;
2845    end Make_Unchecked_Type_Conversion;
2846
2847    function Make_Validate_Unchecked_Conversion (Sloc : Source_Ptr)
2848       return Node_Id
2849    is
2850       N : constant Node_Id :=
2851             New_Node (N_Validate_Unchecked_Conversion, Sloc);
2852    begin
2853       return N;
2854    end Make_Validate_Unchecked_Conversion;
2855
2856 end Nmake;