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