gcc/ada/nmake.ads

   1 ------------------------------------------------------------------------------
   2 --                                                                          --
   3 --                         GNAT COMPILER COMPONENTS                         --
   4 --                                                                          --
   5 --                                N M A K E                                 --
   6 --                                                                          --
   7 --                                 S p e c                                  --
   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 Nlists; use Nlists;
  33 with Types;  use Types;
  34 with Uintp;  use Uintp;
  35 with Urealp; use Urealp;
  36
  37 package Nmake is
  38
  39 --  This package contains a set of routines used to construct tree nodes
  40 --  using a functional style. There is one routine for each node type defined
  41 --  in Sinfo with the general interface:
  42
  43 --    function Make_xxx (Sloc : Source_Ptr,
  44 --                       Field_Name_1 : Field_Name_1_Type [:= default]
  45 --                       Field_Name_2 : Field_Name_2_Type [:= default]
  46 --                       ...)
  47 --    return Node_Id
  48
  49 --  Only syntactic fields are included (i.e. fields marked as "-Sem" or "-Lib"
  50 --  in the Sinfo spec are excluded). In addition, the following four syntactic
  51 --  fields are excluded:
  52
  53 --    Prev_Ids
  54 --    More_Ids
  55 --    Comes_From_Source
  56 --    Paren_Count
  57
  58 --  since they are very rarely set in expanded code. If they need to be set,
  59 --  to other than the default values (False, False, False, zero), then the
  60 --  appropriate Set_xxx procedures must be used on the returned value.
  61
  62 --  Default values are provided only for flag fields (where the default is
  63 --  False), and for optional fields. An optional field is one where the
  64 --  comment line describing the field contains the string "(set to xxx if".
  65 --  For such fields, a default value of xxx is provided."
  66
  67 --  Warning: since calls to Make_xxx routines are normal function calls, the
  68 --  arguments can be evaluated in any order. This means that at most one such
  69 --  argument can have side effects (e.g. be a call to a parse routine).
  70
  71    function Make_Unused_At_Start (Sloc : Source_Ptr)
  72       return Node_Id;
  73    pragma Inline (Make_Unused_At_Start);
  74
  75    function Make_Unused_At_End (Sloc : Source_Ptr)
  76       return Node_Id;
  77    pragma Inline (Make_Unused_At_End);
  78
  79    function Make_Identifier (Sloc : Source_Ptr;
  80       Chars                        : Name_Id)
  81       return Node_Id;
  82    pragma Inline (Make_Identifier);
  83
  84    function Make_Integer_Literal (Sloc : Source_Ptr;
  85       Intval                       : Uint)
  86       return Node_Id;
  87    pragma Inline (Make_Integer_Literal);
  88
  89    function Make_Real_Literal (Sloc : Source_Ptr;
  90       Realval                      : Ureal)
  91       return Node_Id;
  92    pragma Inline (Make_Real_Literal);
  93
  94    function Make_Character_Literal (Sloc : Source_Ptr;
  95       Chars                        : Name_Id;
  96       Char_Literal_Value           : Char_Code)
  97       return Node_Id;
  98    pragma Inline (Make_Character_Literal);
  99
 100    function Make_String_Literal (Sloc : Source_Ptr;
 101       Strval                       : String_Id)
 102       return Node_Id;
 103    pragma Inline (Make_String_Literal);
 104
 105    function Make_Pragma (Sloc : Source_Ptr;
 106       Chars                        : Name_Id;
 107       Pragma_Argument_Associations : List_Id := No_List;
 108       Debug_Statement              : Node_Id := Empty)
 109       return Node_Id;
 110    pragma Inline (Make_Pragma);
 111
 112    function Make_Pragma_Argument_Association (Sloc : Source_Ptr;
 113       Chars                        : Name_Id := No_Name;
 114       Expression                   : Node_Id)
 115       return Node_Id;
 116    pragma Inline (Make_Pragma_Argument_Association);
 117
 118    function Make_Defining_Identifier (Sloc : Source_Ptr;
 119       Chars                        : Name_Id)
 120       return Node_Id;
 121    pragma Inline (Make_Defining_Identifier);
 122
 123    function Make_Full_Type_Declaration (Sloc : Source_Ptr;
 124       Defining_Identifier          : Node_Id;
 125       Discriminant_Specifications  : List_Id := No_List;
 126       Type_Definition              : Node_Id)
 127       return Node_Id;
 128    pragma Inline (Make_Full_Type_Declaration);
 129
 130    function Make_Subtype_Declaration (Sloc : Source_Ptr;
 131       Defining_Identifier          : Node_Id;
 132       Subtype_Indication           : Node_Id)
 133       return Node_Id;
 134    pragma Inline (Make_Subtype_Declaration);
 135
 136    function Make_Subtype_Indication (Sloc : Source_Ptr;
 137       Subtype_Mark                 : Node_Id;
 138       Constraint                   : Node_Id)
 139       return Node_Id;
 140    pragma Inline (Make_Subtype_Indication);
 141
 142    function Make_Object_Declaration (Sloc : Source_Ptr;
 143       Defining_Identifier          : Node_Id;
 144       Aliased_Present              : Boolean := False;
 145       Constant_Present             : Boolean := False;
 146       Object_Definition            : Node_Id;
 147       Expression                   : Node_Id := Empty)
 148       return Node_Id;
 149    pragma Inline (Make_Object_Declaration);
 150
 151    function Make_Number_Declaration (Sloc : Source_Ptr;
 152       Defining_Identifier          : Node_Id;
 153       Expression                   : Node_Id)
 154       return Node_Id;
 155    pragma Inline (Make_Number_Declaration);
 156
 157    function Make_Derived_Type_Definition (Sloc : Source_Ptr;
 158       Abstract_Present             : Boolean := False;
 159       Subtype_Indication           : Node_Id;
 160       Record_Extension_Part        : Node_Id := Empty)
 161       return Node_Id;
 162    pragma Inline (Make_Derived_Type_Definition);
 163
 164    function Make_Range_Constraint (Sloc : Source_Ptr;
 165       Range_Expression             : Node_Id)
 166       return Node_Id;
 167    pragma Inline (Make_Range_Constraint);
 168
 169    function Make_Range (Sloc : Source_Ptr;
 170       Low_Bound                    : Node_Id;
 171       High_Bound                   : Node_Id;
 172       Includes_Infinities          : Boolean := False)
 173       return Node_Id;
 174    pragma Inline (Make_Range);
 175
 176    function Make_Enumeration_Type_Definition (Sloc : Source_Ptr;
 177       Literals                     : List_Id;
 178       End_Label                    : Node_Id := Empty)
 179       return Node_Id;
 180    pragma Inline (Make_Enumeration_Type_Definition);
 181
 182    function Make_Defining_Character_Literal (Sloc : Source_Ptr;
 183       Chars                        : Name_Id)
 184       return Node_Id;
 185    pragma Inline (Make_Defining_Character_Literal);
 186
 187    function Make_Signed_Integer_Type_Definition (Sloc : Source_Ptr;
 188       Low_Bound                    : Node_Id;
 189       High_Bound                   : Node_Id)
 190       return Node_Id;
 191    pragma Inline (Make_Signed_Integer_Type_Definition);
 192
 193    function Make_Modular_Type_Definition (Sloc : Source_Ptr;
 194       Expression                   : Node_Id)
 195       return Node_Id;
 196    pragma Inline (Make_Modular_Type_Definition);
 197
 198    function Make_Floating_Point_Definition (Sloc : Source_Ptr;
 199       Digits_Expression            : Node_Id;
 200       Real_Range_Specification     : Node_Id := Empty)
 201       return Node_Id;
 202    pragma Inline (Make_Floating_Point_Definition);
 203
 204    function Make_Real_Range_Specification (Sloc : Source_Ptr;
 205       Low_Bound                    : Node_Id;
 206       High_Bound                   : Node_Id)
 207       return Node_Id;
 208    pragma Inline (Make_Real_Range_Specification);
 209
 210    function Make_Ordinary_Fixed_Point_Definition (Sloc : Source_Ptr;
 211       Delta_Expression             : Node_Id;
 212       Real_Range_Specification     : Node_Id)
 213       return Node_Id;
 214    pragma Inline (Make_Ordinary_Fixed_Point_Definition);
 215
 216    function Make_Decimal_Fixed_Point_Definition (Sloc : Source_Ptr;
 217       Delta_Expression             : Node_Id;
 218       Digits_Expression            : Node_Id;
 219       Real_Range_Specification     : Node_Id := Empty)
 220       return Node_Id;
 221    pragma Inline (Make_Decimal_Fixed_Point_Definition);
 222
 223    function Make_Digits_Constraint (Sloc : Source_Ptr;
 224       Digits_Expression            : Node_Id;
 225       Range_Constraint             : Node_Id := Empty)
 226       return Node_Id;
 227    pragma Inline (Make_Digits_Constraint);
 228
 229    function Make_Unconstrained_Array_Definition (Sloc : Source_Ptr;
 230       Subtype_Marks                : List_Id;
 231       Aliased_Present              : Boolean := False;
 232       Subtype_Indication           : Node_Id)
 233       return Node_Id;
 234    pragma Inline (Make_Unconstrained_Array_Definition);
 235
 236    function Make_Constrained_Array_Definition (Sloc : Source_Ptr;
 237       Discrete_Subtype_Definitions : List_Id;
 238       Aliased_Present              : Boolean := False;
 239       Subtype_Indication           : Node_Id)
 240       return Node_Id;
 241    pragma Inline (Make_Constrained_Array_Definition);
 242
 243    function Make_Discriminant_Specification (Sloc : Source_Ptr;
 244       Defining_Identifier          : Node_Id;
 245       Discriminant_Type            : Node_Id;
 246       Expression                   : Node_Id := Empty)
 247       return Node_Id;
 248    pragma Inline (Make_Discriminant_Specification);
 249
 250    function Make_Index_Or_Discriminant_Constraint (Sloc : Source_Ptr;
 251       Constraints                  : List_Id)
 252       return Node_Id;
 253    pragma Inline (Make_Index_Or_Discriminant_Constraint);
 254
 255    function Make_Discriminant_Association (Sloc : Source_Ptr;
 256       Selector_Names               : List_Id;
 257       Expression                   : Node_Id)
 258       return Node_Id;
 259    pragma Inline (Make_Discriminant_Association);
 260
 261    function Make_Record_Definition (Sloc : Source_Ptr;
 262       End_Label                    : Node_Id := Empty;
 263       Abstract_Present             : Boolean := False;
 264       Tagged_Present               : Boolean := False;
 265       Limited_Present              : Boolean := False;
 266       Component_List               : Node_Id;
 267       Null_Present                 : Boolean := False)
 268       return Node_Id;
 269    pragma Inline (Make_Record_Definition);
 270
 271    function Make_Component_List (Sloc : Source_Ptr;
 272       Component_Items              : List_Id;
 273       Variant_Part                 : Node_Id := Empty;
 274       Null_Present                 : Boolean := False)
 275       return Node_Id;
 276    pragma Inline (Make_Component_List);
 277
 278    function Make_Component_Declaration (Sloc : Source_Ptr;
 279       Defining_Identifier          : Node_Id;
 280       Aliased_Present              : Boolean := False;
 281       Subtype_Indication           : Node_Id;
 282       Expression                   : Node_Id := Empty)
 283       return Node_Id;
 284    pragma Inline (Make_Component_Declaration);
 285
 286    function Make_Variant_Part (Sloc : Source_Ptr;
 287       Name                         : Node_Id;
 288       Variants                     : List_Id)
 289       return Node_Id;
 290    pragma Inline (Make_Variant_Part);
 291
 292    function Make_Variant (Sloc : Source_Ptr;
 293       Discrete_Choices             : List_Id;
 294       Component_List               : Node_Id)
 295       return Node_Id;
 296    pragma Inline (Make_Variant);
 297
 298    function Make_Others_Choice (Sloc : Source_Ptr)
 299       return Node_Id;
 300    pragma Inline (Make_Others_Choice);
 301
 302    function Make_Access_To_Object_Definition (Sloc : Source_Ptr;
 303       All_Present                  : Boolean := False;
 304       Subtype_Indication           : Node_Id;
 305       Constant_Present             : Boolean := False)
 306       return Node_Id;
 307    pragma Inline (Make_Access_To_Object_Definition);
 308
 309    function Make_Access_Function_Definition (Sloc : Source_Ptr;
 310       Protected_Present            : Boolean := False;
 311       Parameter_Specifications     : List_Id := No_List;
 312       Subtype_Mark                 : Node_Id)
 313       return Node_Id;
 314    pragma Inline (Make_Access_Function_Definition);
 315
 316    function Make_Access_Procedure_Definition (Sloc : Source_Ptr;
 317       Protected_Present            : Boolean := False;
 318       Parameter_Specifications     : List_Id := No_List)
 319       return Node_Id;
 320    pragma Inline (Make_Access_Procedure_Definition);
 321
 322    function Make_Access_Definition (Sloc : Source_Ptr;
 323       Subtype_Mark                 : Node_Id)
 324       return Node_Id;
 325    pragma Inline (Make_Access_Definition);
 326
 327    function Make_Incomplete_Type_Declaration (Sloc : Source_Ptr;
 328       Defining_Identifier          : Node_Id;
 329       Discriminant_Specifications  : List_Id := No_List;
 330       Unknown_Discriminants_Present : Boolean := False)
 331       return Node_Id;
 332    pragma Inline (Make_Incomplete_Type_Declaration);
 333
 334    function Make_Explicit_Dereference (Sloc : Source_Ptr;
 335       Prefix                       : Node_Id)
 336       return Node_Id;
 337    pragma Inline (Make_Explicit_Dereference);
 338
 339    function Make_Indexed_Component (Sloc : Source_Ptr;
 340       Prefix                       : Node_Id;
 341       Expressions                  : List_Id)
 342       return Node_Id;
 343    pragma Inline (Make_Indexed_Component);
 344
 345    function Make_Slice (Sloc : Source_Ptr;
 346       Prefix                       : Node_Id;
 347       Discrete_Range               : Node_Id)
 348       return Node_Id;
 349    pragma Inline (Make_Slice);
 350
 351    function Make_Selected_Component (Sloc : Source_Ptr;
 352       Prefix                       : Node_Id;
 353       Selector_Name                : Node_Id)
 354       return Node_Id;
 355    pragma Inline (Make_Selected_Component);
 356
 357    function Make_Attribute_Reference (Sloc : Source_Ptr;
 358       Prefix                       : Node_Id;
 359       Attribute_Name               : Name_Id;
 360       Expressions                  : List_Id := No_List;
 361       Must_Be_Byte_Aligned         : Boolean := False)
 362       return Node_Id;
 363    pragma Inline (Make_Attribute_Reference);
 364
 365    function Make_Aggregate (Sloc : Source_Ptr;
 366       Expressions                  : List_Id := No_List;
 367       Component_Associations       : List_Id := No_List;
 368       Null_Record_Present          : Boolean := False)
 369       return Node_Id;
 370    pragma Inline (Make_Aggregate);
 371
 372    function Make_Component_Association (Sloc : Source_Ptr;
 373       Choices                      : List_Id;
 374       Expression                   : Node_Id;
 375       Box_Present                  : Boolean := False)
 376       return Node_Id;
 377    pragma Inline (Make_Component_Association);
 378
 379    function Make_Extension_Aggregate (Sloc : Source_Ptr;
 380       Ancestor_Part                : Node_Id;
 381       Expressions                  : List_Id := No_List;
 382       Component_Associations       : List_Id := No_List;
 383       Null_Record_Present          : Boolean := False)
 384       return Node_Id;
 385    pragma Inline (Make_Extension_Aggregate);
 386
 387    function Make_Null (Sloc : Source_Ptr)
 388       return Node_Id;
 389    pragma Inline (Make_Null);
 390
 391    function Make_And_Then (Sloc : Source_Ptr;
 392       Left_Opnd                    : Node_Id;
 393       Right_Opnd                   : Node_Id)
 394       return Node_Id;
 395    pragma Inline (Make_And_Then);
 396
 397    function Make_Or_Else (Sloc : Source_Ptr;
 398       Left_Opnd                    : Node_Id;
 399       Right_Opnd                   : Node_Id)
 400       return Node_Id;
 401    pragma Inline (Make_Or_Else);
 402
 403    function Make_In (Sloc : Source_Ptr;
 404       Left_Opnd                    : Node_Id;
 405       Right_Opnd                   : Node_Id)
 406       return Node_Id;
 407    pragma Inline (Make_In);
 408
 409    function Make_Not_In (Sloc : Source_Ptr;
 410       Left_Opnd                    : Node_Id;
 411       Right_Opnd                   : Node_Id)
 412       return Node_Id;
 413    pragma Inline (Make_Not_In);
 414
 415    function Make_Op_And (Sloc : Source_Ptr;
 416       Left_Opnd                    : Node_Id;
 417       Right_Opnd                   : Node_Id)
 418       return Node_Id;
 419    pragma Inline (Make_Op_And);
 420
 421    function Make_Op_Or (Sloc : Source_Ptr;
 422       Left_Opnd                    : Node_Id;
 423       Right_Opnd                   : Node_Id)
 424       return Node_Id;
 425    pragma Inline (Make_Op_Or);
 426
 427    function Make_Op_Xor (Sloc : Source_Ptr;
 428       Left_Opnd                    : Node_Id;
 429       Right_Opnd                   : Node_Id)
 430       return Node_Id;
 431    pragma Inline (Make_Op_Xor);
 432
 433    function Make_Op_Eq (Sloc : Source_Ptr;
 434       Left_Opnd                    : Node_Id;
 435       Right_Opnd                   : Node_Id)
 436       return Node_Id;
 437    pragma Inline (Make_Op_Eq);
 438
 439    function Make_Op_Ne (Sloc : Source_Ptr;
 440       Left_Opnd                    : Node_Id;
 441       Right_Opnd                   : Node_Id)
 442       return Node_Id;
 443    pragma Inline (Make_Op_Ne);
 444
 445    function Make_Op_Lt (Sloc : Source_Ptr;
 446       Left_Opnd                    : Node_Id;
 447       Right_Opnd                   : Node_Id)
 448       return Node_Id;
 449    pragma Inline (Make_Op_Lt);
 450
 451    function Make_Op_Le (Sloc : Source_Ptr;
 452       Left_Opnd                    : Node_Id;
 453       Right_Opnd                   : Node_Id)
 454       return Node_Id;
 455    pragma Inline (Make_Op_Le);
 456
 457    function Make_Op_Gt (Sloc : Source_Ptr;
 458       Left_Opnd                    : Node_Id;
 459       Right_Opnd                   : Node_Id)
 460       return Node_Id;
 461    pragma Inline (Make_Op_Gt);
 462
 463    function Make_Op_Ge (Sloc : Source_Ptr;
 464       Left_Opnd                    : Node_Id;
 465       Right_Opnd                   : Node_Id)
 466       return Node_Id;
 467    pragma Inline (Make_Op_Ge);
 468
 469    function Make_Op_Add (Sloc : Source_Ptr;
 470       Left_Opnd                    : Node_Id;
 471       Right_Opnd                   : Node_Id)
 472       return Node_Id;
 473    pragma Inline (Make_Op_Add);
 474
 475    function Make_Op_Subtract (Sloc : Source_Ptr;
 476       Left_Opnd                    : Node_Id;
 477       Right_Opnd                   : Node_Id)
 478       return Node_Id;
 479    pragma Inline (Make_Op_Subtract);
 480
 481    function Make_Op_Concat (Sloc : Source_Ptr;
 482       Left_Opnd                    : Node_Id;
 483       Right_Opnd                   : Node_Id)
 484       return Node_Id;
 485    pragma Inline (Make_Op_Concat);
 486
 487    function Make_Op_Multiply (Sloc : Source_Ptr;
 488       Left_Opnd                    : Node_Id;
 489       Right_Opnd                   : Node_Id)
 490       return Node_Id;
 491    pragma Inline (Make_Op_Multiply);
 492
 493    function Make_Op_Divide (Sloc : Source_Ptr;
 494       Left_Opnd                    : Node_Id;
 495       Right_Opnd                   : Node_Id)
 496       return Node_Id;
 497    pragma Inline (Make_Op_Divide);
 498
 499    function Make_Op_Mod (Sloc : Source_Ptr;
 500       Left_Opnd                    : Node_Id;
 501       Right_Opnd                   : Node_Id)
 502       return Node_Id;
 503    pragma Inline (Make_Op_Mod);
 504
 505    function Make_Op_Rem (Sloc : Source_Ptr;
 506       Left_Opnd                    : Node_Id;
 507       Right_Opnd                   : Node_Id)
 508       return Node_Id;
 509    pragma Inline (Make_Op_Rem);
 510
 511    function Make_Op_Expon (Sloc : Source_Ptr;
 512       Left_Opnd                    : Node_Id;
 513       Right_Opnd                   : Node_Id)
 514       return Node_Id;
 515    pragma Inline (Make_Op_Expon);
 516
 517    function Make_Op_Plus (Sloc : Source_Ptr;
 518       Right_Opnd                   : Node_Id)
 519       return Node_Id;
 520    pragma Inline (Make_Op_Plus);
 521
 522    function Make_Op_Minus (Sloc : Source_Ptr;
 523       Right_Opnd                   : Node_Id)
 524       return Node_Id;
 525    pragma Inline (Make_Op_Minus);
 526
 527    function Make_Op_Abs (Sloc : Source_Ptr;
 528       Right_Opnd                   : Node_Id)
 529       return Node_Id;
 530    pragma Inline (Make_Op_Abs);
 531
 532    function Make_Op_Not (Sloc : Source_Ptr;
 533       Right_Opnd                   : Node_Id)
 534       return Node_Id;
 535    pragma Inline (Make_Op_Not);
 536
 537    function Make_Type_Conversion (Sloc : Source_Ptr;
 538       Subtype_Mark                 : Node_Id;
 539       Expression                   : Node_Id)
 540       return Node_Id;
 541    pragma Inline (Make_Type_Conversion);
 542
 543    function Make_Qualified_Expression (Sloc : Source_Ptr;
 544       Subtype_Mark                 : Node_Id;
 545       Expression                   : Node_Id)
 546       return Node_Id;
 547    pragma Inline (Make_Qualified_Expression);
 548
 549    function Make_Allocator (Sloc : Source_Ptr;
 550       Expression                   : Node_Id)
 551       return Node_Id;
 552    pragma Inline (Make_Allocator);
 553
 554    function Make_Null_Statement (Sloc : Source_Ptr)
 555       return Node_Id;
 556    pragma Inline (Make_Null_Statement);
 557
 558    function Make_Label (Sloc : Source_Ptr;
 559       Identifier                   : Node_Id)
 560       return Node_Id;
 561    pragma Inline (Make_Label);
 562
 563    function Make_Assignment_Statement (Sloc : Source_Ptr;
 564       Name                         : Node_Id;
 565       Expression                   : Node_Id)
 566       return Node_Id;
 567    pragma Inline (Make_Assignment_Statement);
 568
 569    function Make_If_Statement (Sloc : Source_Ptr;
 570       Condition                    : Node_Id;
 571       Then_Statements              : List_Id;
 572       Elsif_Parts                  : List_Id := No_List;
 573       Else_Statements              : List_Id := No_List;
 574       End_Span                     : Uint := No_Uint)
 575       return Node_Id;
 576    pragma Inline (Make_If_Statement);
 577
 578    function Make_Elsif_Part (Sloc : Source_Ptr;
 579       Condition                    : Node_Id;
 580       Then_Statements              : List_Id)
 581       return Node_Id;
 582    pragma Inline (Make_Elsif_Part);
 583
 584    function Make_Case_Statement (Sloc : Source_Ptr;
 585       Expression                   : Node_Id;
 586       Alternatives                 : List_Id;
 587       End_Span                     : Uint := No_Uint)
 588       return Node_Id;
 589    pragma Inline (Make_Case_Statement);
 590
 591    function Make_Case_Statement_Alternative (Sloc : Source_Ptr;
 592       Discrete_Choices             : List_Id;
 593       Statements                   : List_Id)
 594       return Node_Id;
 595    pragma Inline (Make_Case_Statement_Alternative);
 596
 597    function Make_Loop_Statement (Sloc : Source_Ptr;
 598       Identifier                   : Node_Id := Empty;
 599       Iteration_Scheme             : Node_Id := Empty;
 600       Statements                   : List_Id;
 601       End_Label                    : Node_Id;
 602       Has_Created_Identifier       : Boolean := False;
 603       Is_Null_Loop                 : Boolean := False)
 604       return Node_Id;
 605    pragma Inline (Make_Loop_Statement);
 606
 607    function Make_Iteration_Scheme (Sloc : Source_Ptr;
 608       Condition                    : Node_Id := Empty;
 609       Loop_Parameter_Specification : Node_Id := Empty)
 610       return Node_Id;
 611    pragma Inline (Make_Iteration_Scheme);
 612
 613    function Make_Loop_Parameter_Specification (Sloc : Source_Ptr;
 614       Defining_Identifier          : Node_Id;
 615       Reverse_Present              : Boolean := False;
 616       Discrete_Subtype_Definition  : Node_Id)
 617       return Node_Id;
 618    pragma Inline (Make_Loop_Parameter_Specification);
 619
 620    function Make_Block_Statement (Sloc : Source_Ptr;
 621       Identifier                   : Node_Id := Empty;
 622       Declarations                 : List_Id := No_List;
 623       Handled_Statement_Sequence   : Node_Id;
 624       Has_Created_Identifier       : Boolean := False;
 625       Is_Task_Allocation_Block     : Boolean := False;
 626       Is_Asynchronous_Call_Block   : Boolean := False)
 627       return Node_Id;
 628    pragma Inline (Make_Block_Statement);
 629
 630    function Make_Exit_Statement (Sloc : Source_Ptr;
 631       Name                         : Node_Id := Empty;
 632       Condition                    : Node_Id := Empty)
 633       return Node_Id;
 634    pragma Inline (Make_Exit_Statement);
 635
 636    function Make_Goto_Statement (Sloc : Source_Ptr;
 637       Name                         : Node_Id)
 638       return Node_Id;
 639    pragma Inline (Make_Goto_Statement);
 640
 641    function Make_Subprogram_Declaration (Sloc : Source_Ptr;
 642       Specification                : Node_Id)
 643       return Node_Id;
 644    pragma Inline (Make_Subprogram_Declaration);
 645
 646    function Make_Abstract_Subprogram_Declaration (Sloc : Source_Ptr;
 647       Specification                : Node_Id)
 648       return Node_Id;
 649    pragma Inline (Make_Abstract_Subprogram_Declaration);
 650
 651    function Make_Function_Specification (Sloc : Source_Ptr;
 652       Defining_Unit_Name           : Node_Id;
 653       Parameter_Specifications     : List_Id := No_List;
 654       Subtype_Mark                 : Node_Id)
 655       return Node_Id;
 656    pragma Inline (Make_Function_Specification);
 657
 658    function Make_Procedure_Specification (Sloc : Source_Ptr;
 659       Defining_Unit_Name           : Node_Id;
 660       Parameter_Specifications     : List_Id := No_List)
 661       return Node_Id;
 662    pragma Inline (Make_Procedure_Specification);
 663
 664    function Make_Designator (Sloc : Source_Ptr;
 665       Name                         : Node_Id;
 666       Identifier                   : Node_Id)
 667       return Node_Id;
 668    pragma Inline (Make_Designator);
 669
 670    function Make_Defining_Program_Unit_Name (Sloc : Source_Ptr;
 671       Name                         : Node_Id;
 672       Defining_Identifier          : Node_Id)
 673       return Node_Id;
 674    pragma Inline (Make_Defining_Program_Unit_Name);
 675
 676    function Make_Operator_Symbol (Sloc : Source_Ptr;
 677       Chars                        : Name_Id;
 678       Strval                       : String_Id)
 679       return Node_Id;
 680    pragma Inline (Make_Operator_Symbol);
 681
 682    function Make_Defining_Operator_Symbol (Sloc : Source_Ptr;
 683       Chars                        : Name_Id)
 684       return Node_Id;
 685    pragma Inline (Make_Defining_Operator_Symbol);
 686
 687    function Make_Parameter_Specification (Sloc : Source_Ptr;
 688       Defining_Identifier          : Node_Id;
 689       In_Present                   : Boolean := False;
 690       Out_Present                  : Boolean := False;
 691       Parameter_Type               : Node_Id;
 692       Expression                   : Node_Id := Empty)
 693       return Node_Id;
 694    pragma Inline (Make_Parameter_Specification);
 695
 696    function Make_Subprogram_Body (Sloc : Source_Ptr;
 697       Specification                : Node_Id;
 698       Declarations                 : List_Id;
 699       Handled_Statement_Sequence   : Node_Id;
 700       Bad_Is_Detected              : Boolean := False)
 701       return Node_Id;
 702    pragma Inline (Make_Subprogram_Body);
 703
 704    function Make_Procedure_Call_Statement (Sloc : Source_Ptr;
 705       Name                         : Node_Id;
 706       Parameter_Associations       : List_Id := No_List)
 707       return Node_Id;
 708    pragma Inline (Make_Procedure_Call_Statement);
 709
 710    function Make_Function_Call (Sloc : Source_Ptr;
 711       Name                         : Node_Id;
 712       Parameter_Associations       : List_Id := No_List)
 713       return Node_Id;
 714    pragma Inline (Make_Function_Call);
 715
 716    function Make_Parameter_Association (Sloc : Source_Ptr;
 717       Selector_Name                : Node_Id;
 718       Explicit_Actual_Parameter    : Node_Id)
 719       return Node_Id;
 720    pragma Inline (Make_Parameter_Association);
 721
 722    function Make_Return_Statement (Sloc : Source_Ptr;
 723       Expression                   : Node_Id := Empty)
 724       return Node_Id;
 725    pragma Inline (Make_Return_Statement);
 726
 727    function Make_Package_Declaration (Sloc : Source_Ptr;
 728       Specification                : Node_Id)
 729       return Node_Id;
 730    pragma Inline (Make_Package_Declaration);
 731
 732    function Make_Package_Specification (Sloc : Source_Ptr;
 733       Defining_Unit_Name           : Node_Id;
 734       Visible_Declarations         : List_Id;
 735       Private_Declarations         : List_Id := No_List;
 736       End_Label                    : Node_Id)
 737       return Node_Id;
 738    pragma Inline (Make_Package_Specification);
 739
 740    function Make_Package_Body (Sloc : Source_Ptr;
 741       Defining_Unit_Name           : Node_Id;
 742       Declarations                 : List_Id;
 743       Handled_Statement_Sequence   : Node_Id := Empty)
 744       return Node_Id;
 745    pragma Inline (Make_Package_Body);
 746
 747    function Make_Private_Type_Declaration (Sloc : Source_Ptr;
 748       Defining_Identifier          : Node_Id;
 749       Discriminant_Specifications  : List_Id := No_List;
 750       Unknown_Discriminants_Present : Boolean := False;
 751       Abstract_Present             : Boolean := False;
 752       Tagged_Present               : Boolean := False;
 753       Limited_Present              : Boolean := False)
 754       return Node_Id;
 755    pragma Inline (Make_Private_Type_Declaration);
 756
 757    function Make_Private_Extension_Declaration (Sloc : Source_Ptr;
 758       Defining_Identifier          : Node_Id;
 759       Discriminant_Specifications  : List_Id := No_List;
 760       Unknown_Discriminants_Present : Boolean := False;
 761       Abstract_Present             : Boolean := False;
 762       Subtype_Indication           : Node_Id)
 763       return Node_Id;
 764    pragma Inline (Make_Private_Extension_Declaration);
 765
 766    function Make_Use_Package_Clause (Sloc : Source_Ptr;
 767       Names                        : List_Id)
 768       return Node_Id;
 769    pragma Inline (Make_Use_Package_Clause);
 770
 771    function Make_Use_Type_Clause (Sloc : Source_Ptr;
 772       Subtype_Marks                : List_Id)
 773       return Node_Id;
 774    pragma Inline (Make_Use_Type_Clause);
 775
 776    function Make_Object_Renaming_Declaration (Sloc : Source_Ptr;
 777       Defining_Identifier          : Node_Id;
 778       Subtype_Mark                 : Node_Id;
 779       Name                         : Node_Id)
 780       return Node_Id;
 781    pragma Inline (Make_Object_Renaming_Declaration);
 782
 783    function Make_Exception_Renaming_Declaration (Sloc : Source_Ptr;
 784       Defining_Identifier          : Node_Id;
 785       Name                         : Node_Id)
 786       return Node_Id;
 787    pragma Inline (Make_Exception_Renaming_Declaration);
 788
 789    function Make_Package_Renaming_Declaration (Sloc : Source_Ptr;
 790       Defining_Unit_Name           : Node_Id;
 791       Name                         : Node_Id)
 792       return Node_Id;
 793    pragma Inline (Make_Package_Renaming_Declaration);
 794
 795    function Make_Subprogram_Renaming_Declaration (Sloc : Source_Ptr;
 796       Specification                : Node_Id;
 797       Name                         : Node_Id)
 798       return Node_Id;
 799    pragma Inline (Make_Subprogram_Renaming_Declaration);
 800
 801    function Make_Generic_Package_Renaming_Declaration (Sloc : Source_Ptr;
 802       Defining_Unit_Name           : Node_Id;
 803       Name                         : Node_Id)
 804       return Node_Id;
 805    pragma Inline (Make_Generic_Package_Renaming_Declaration);
 806
 807    function Make_Generic_Procedure_Renaming_Declaration (Sloc : Source_Ptr;
 808       Defining_Unit_Name           : Node_Id;
 809       Name                         : Node_Id)
 810       return Node_Id;
 811    pragma Inline (Make_Generic_Procedure_Renaming_Declaration);
 812
 813    function Make_Generic_Function_Renaming_Declaration (Sloc : Source_Ptr;
 814       Defining_Unit_Name           : Node_Id;
 815       Name                         : Node_Id)
 816       return Node_Id;
 817    pragma Inline (Make_Generic_Function_Renaming_Declaration);
 818
 819    function Make_Task_Type_Declaration (Sloc : Source_Ptr;
 820       Defining_Identifier          : Node_Id;
 821       Discriminant_Specifications  : List_Id := No_List;
 822       Task_Definition              : Node_Id := Empty)
 823       return Node_Id;
 824    pragma Inline (Make_Task_Type_Declaration);
 825
 826    function Make_Single_Task_Declaration (Sloc : Source_Ptr;
 827       Defining_Identifier          : Node_Id;
 828       Task_Definition              : Node_Id := Empty)
 829       return Node_Id;
 830    pragma Inline (Make_Single_Task_Declaration);
 831
 832    function Make_Task_Definition (Sloc : Source_Ptr;
 833       Visible_Declarations         : List_Id;
 834       Private_Declarations         : List_Id := No_List;
 835       End_Label                    : Node_Id)
 836       return Node_Id;
 837    pragma Inline (Make_Task_Definition);
 838
 839    function Make_Task_Body (Sloc : Source_Ptr;
 840       Defining_Identifier          : Node_Id;
 841       Declarations                 : List_Id;
 842       Handled_Statement_Sequence   : Node_Id)
 843       return Node_Id;
 844    pragma Inline (Make_Task_Body);
 845
 846    function Make_Protected_Type_Declaration (Sloc : Source_Ptr;
 847       Defining_Identifier          : Node_Id;
 848       Discriminant_Specifications  : List_Id := No_List;
 849       Protected_Definition         : Node_Id)
 850       return Node_Id;
 851    pragma Inline (Make_Protected_Type_Declaration);
 852
 853    function Make_Single_Protected_Declaration (Sloc : Source_Ptr;
 854       Defining_Identifier          : Node_Id;
 855       Protected_Definition         : Node_Id)
 856       return Node_Id;
 857    pragma Inline (Make_Single_Protected_Declaration);
 858
 859    function Make_Protected_Definition (Sloc : Source_Ptr;
 860       Visible_Declarations         : List_Id;
 861       Private_Declarations         : List_Id := No_List;
 862       End_Label                    : Node_Id)
 863       return Node_Id;
 864    pragma Inline (Make_Protected_Definition);
 865
 866    function Make_Protected_Body (Sloc : Source_Ptr;
 867       Defining_Identifier          : Node_Id;
 868       Declarations                 : List_Id;
 869       End_Label                    : Node_Id)
 870       return Node_Id;
 871    pragma Inline (Make_Protected_Body);
 872
 873    function Make_Entry_Declaration (Sloc : Source_Ptr;
 874       Defining_Identifier          : Node_Id;
 875       Discrete_Subtype_Definition  : Node_Id := Empty;
 876       Parameter_Specifications     : List_Id := No_List)
 877       return Node_Id;
 878    pragma Inline (Make_Entry_Declaration);
 879
 880    function Make_Accept_Statement (Sloc : Source_Ptr;
 881       Entry_Direct_Name            : Node_Id;
 882       Entry_Index                  : Node_Id := Empty;
 883       Parameter_Specifications     : List_Id := No_List;
 884       Handled_Statement_Sequence   : Node_Id;
 885       Declarations                 : List_Id := No_List)
 886       return Node_Id;
 887    pragma Inline (Make_Accept_Statement);
 888
 889    function Make_Entry_Body (Sloc : Source_Ptr;
 890       Defining_Identifier          : Node_Id;
 891       Entry_Body_Formal_Part       : Node_Id;
 892       Declarations                 : List_Id;
 893       Handled_Statement_Sequence   : Node_Id)
 894       return Node_Id;
 895    pragma Inline (Make_Entry_Body);
 896
 897    function Make_Entry_Body_Formal_Part (Sloc : Source_Ptr;
 898       Entry_Index_Specification    : Node_Id := Empty;
 899       Parameter_Specifications     : List_Id := No_List;
 900       Condition                    : Node_Id)
 901       return Node_Id;
 902    pragma Inline (Make_Entry_Body_Formal_Part);
 903
 904    function Make_Entry_Index_Specification (Sloc : Source_Ptr;
 905       Defining_Identifier          : Node_Id;
 906       Discrete_Subtype_Definition  : Node_Id)
 907       return Node_Id;
 908    pragma Inline (Make_Entry_Index_Specification);
 909
 910    function Make_Entry_Call_Statement (Sloc : Source_Ptr;
 911       Name                         : Node_Id;
 912       Parameter_Associations       : List_Id := No_List)
 913       return Node_Id;
 914    pragma Inline (Make_Entry_Call_Statement);
 915
 916    function Make_Requeue_Statement (Sloc : Source_Ptr;
 917       Name                         : Node_Id;
 918       Abort_Present                : Boolean := False)
 919       return Node_Id;
 920    pragma Inline (Make_Requeue_Statement);
 921
 922    function Make_Delay_Until_Statement (Sloc : Source_Ptr;
 923       Expression                   : Node_Id)
 924       return Node_Id;
 925    pragma Inline (Make_Delay_Until_Statement);
 926
 927    function Make_Delay_Relative_Statement (Sloc : Source_Ptr;
 928       Expression                   : Node_Id)
 929       return Node_Id;
 930    pragma Inline (Make_Delay_Relative_Statement);
 931
 932    function Make_Selective_Accept (Sloc : Source_Ptr;
 933       Select_Alternatives          : List_Id;
 934       Else_Statements              : List_Id := No_List)
 935       return Node_Id;
 936    pragma Inline (Make_Selective_Accept);
 937
 938    function Make_Accept_Alternative (Sloc : Source_Ptr;
 939       Accept_Statement             : Node_Id;
 940       Condition                    : Node_Id := Empty;
 941       Statements                   : List_Id := Empty_List;
 942       Pragmas_Before               : List_Id := No_List)
 943       return Node_Id;
 944    pragma Inline (Make_Accept_Alternative);
 945
 946    function Make_Delay_Alternative (Sloc : Source_Ptr;
 947       Delay_Statement              : Node_Id;
 948       Condition                    : Node_Id := Empty;
 949       Statements                   : List_Id := Empty_List;
 950       Pragmas_Before               : List_Id := No_List)
 951       return Node_Id;
 952    pragma Inline (Make_Delay_Alternative);
 953
 954    function Make_Terminate_Alternative (Sloc : Source_Ptr;
 955       Condition                    : Node_Id := Empty;
 956       Pragmas_Before               : List_Id := No_List;
 957       Pragmas_After                : List_Id := No_List)
 958       return Node_Id;
 959    pragma Inline (Make_Terminate_Alternative);
 960
 961    function Make_Timed_Entry_Call (Sloc : Source_Ptr;
 962       Entry_Call_Alternative       : Node_Id;
 963       Delay_Alternative            : Node_Id)
 964       return Node_Id;
 965    pragma Inline (Make_Timed_Entry_Call);
 966
 967    function Make_Entry_Call_Alternative (Sloc : Source_Ptr;
 968       Entry_Call_Statement         : Node_Id;
 969       Statements                   : List_Id := Empty_List;
 970       Pragmas_Before               : List_Id := No_List)
 971       return Node_Id;
 972    pragma Inline (Make_Entry_Call_Alternative);
 973
 974    function Make_Conditional_Entry_Call (Sloc : Source_Ptr;
 975       Entry_Call_Alternative       : Node_Id;
 976       Else_Statements              : List_Id)
 977       return Node_Id;
 978    pragma Inline (Make_Conditional_Entry_Call);
 979
 980    function Make_Asynchronous_Select (Sloc : Source_Ptr;
 981       Triggering_Alternative       : Node_Id;
 982       Abortable_Part               : Node_Id)
 983       return Node_Id;
 984    pragma Inline (Make_Asynchronous_Select);
 985
 986    function Make_Triggering_Alternative (Sloc : Source_Ptr;
 987       Triggering_Statement         : Node_Id;
 988       Statements                   : List_Id := Empty_List;
 989       Pragmas_Before               : List_Id := No_List)
 990       return Node_Id;
 991    pragma Inline (Make_Triggering_Alternative);
 992
 993    function Make_Abortable_Part (Sloc : Source_Ptr;
 994       Statements                   : List_Id)
 995       return Node_Id;
 996    pragma Inline (Make_Abortable_Part);
 997
 998    function Make_Abort_Statement (Sloc : Source_Ptr;
 999       Names                        : List_Id)
1000       return Node_Id;
1001    pragma Inline (Make_Abort_Statement);
1002
1003    function Make_Compilation_Unit (Sloc : Source_Ptr;
1004       Context_Items                : List_Id;
1005       Private_Present              : Boolean := False;
1006       Unit                         : Node_Id;
1007       Aux_Decls_Node               : Node_Id)
1008       return Node_Id;
1009    pragma Inline (Make_Compilation_Unit);
1010
1011    function Make_Compilation_Unit_Aux (Sloc : Source_Ptr;
1012       Declarations                 : List_Id := No_List;
1013       Actions                      : List_Id := No_List;
1014       Pragmas_After                : List_Id := No_List;
1015       Config_Pragmas               : List_Id := Empty_List)
1016       return Node_Id;
1017    pragma Inline (Make_Compilation_Unit_Aux);
1018
1019    function Make_With_Clause (Sloc : Source_Ptr;
1020       Name                         : Node_Id;
1021       First_Name                   : Boolean := True;
1022       Last_Name                    : Boolean := True;
1023       Limited_Present              : Boolean := False)
1024       return Node_Id;
1025    pragma Inline (Make_With_Clause);
1026
1027    function Make_With_Type_Clause (Sloc : Source_Ptr;
1028       Name                         : Node_Id;
1029       Tagged_Present               : Boolean := False)
1030       return Node_Id;
1031    pragma Inline (Make_With_Type_Clause);
1032
1033    function Make_Subprogram_Body_Stub (Sloc : Source_Ptr;
1034       Specification                : Node_Id)
1035       return Node_Id;
1036    pragma Inline (Make_Subprogram_Body_Stub);
1037
1038    function Make_Package_Body_Stub (Sloc : Source_Ptr;
1039       Defining_Identifier          : Node_Id)
1040       return Node_Id;
1041    pragma Inline (Make_Package_Body_Stub);
1042
1043    function Make_Task_Body_Stub (Sloc : Source_Ptr;
1044       Defining_Identifier          : Node_Id)
1045       return Node_Id;
1046    pragma Inline (Make_Task_Body_Stub);
1047
1048    function Make_Protected_Body_Stub (Sloc : Source_Ptr;
1049       Defining_Identifier          : Node_Id)
1050       return Node_Id;
1051    pragma Inline (Make_Protected_Body_Stub);
1052
1053    function Make_Subunit (Sloc : Source_Ptr;
1054       Name                         : Node_Id;
1055       Proper_Body                  : Node_Id)
1056       return Node_Id;
1057    pragma Inline (Make_Subunit);
1058
1059    function Make_Exception_Declaration (Sloc : Source_Ptr;
1060       Defining_Identifier          : Node_Id)
1061       return Node_Id;
1062    pragma Inline (Make_Exception_Declaration);
1063
1064    function Make_Handled_Sequence_Of_Statements (Sloc : Source_Ptr;
1065       Statements                   : List_Id;
1066       End_Label                    : Node_Id := Empty;
1067       Exception_Handlers           : List_Id := No_List;
1068       At_End_Proc                  : Node_Id := Empty)
1069       return Node_Id;
1070    pragma Inline (Make_Handled_Sequence_Of_Statements);
1071
1072    function Make_Exception_Handler (Sloc : Source_Ptr;
1073       Choice_Parameter             : Node_Id := Empty;
1074       Exception_Choices            : List_Id;
1075       Statements                   : List_Id)
1076       return Node_Id;
1077    pragma Inline (Make_Exception_Handler);
1078
1079    function Make_Raise_Statement (Sloc : Source_Ptr;
1080       Name                         : Node_Id := Empty)
1081       return Node_Id;
1082    pragma Inline (Make_Raise_Statement);
1083
1084    function Make_Generic_Subprogram_Declaration (Sloc : Source_Ptr;
1085       Specification                : Node_Id;
1086       Generic_Formal_Declarations  : List_Id)
1087       return Node_Id;
1088    pragma Inline (Make_Generic_Subprogram_Declaration);
1089
1090    function Make_Generic_Package_Declaration (Sloc : Source_Ptr;
1091       Specification                : Node_Id;
1092       Generic_Formal_Declarations  : List_Id)
1093       return Node_Id;
1094    pragma Inline (Make_Generic_Package_Declaration);
1095
1096    function Make_Package_Instantiation (Sloc : Source_Ptr;
1097       Defining_Unit_Name           : Node_Id;
1098       Name                         : Node_Id;
1099       Generic_Associations         : List_Id := No_List)
1100       return Node_Id;
1101    pragma Inline (Make_Package_Instantiation);
1102
1103    function Make_Procedure_Instantiation (Sloc : Source_Ptr;
1104       Defining_Unit_Name           : Node_Id;
1105       Name                         : Node_Id;
1106       Generic_Associations         : List_Id := No_List)
1107       return Node_Id;
1108    pragma Inline (Make_Procedure_Instantiation);
1109
1110    function Make_Function_Instantiation (Sloc : Source_Ptr;
1111       Defining_Unit_Name           : Node_Id;
1112       Name                         : Node_Id;
1113       Generic_Associations         : List_Id := No_List)
1114       return Node_Id;
1115    pragma Inline (Make_Function_Instantiation);
1116
1117    function Make_Generic_Association (Sloc : Source_Ptr;
1118       Selector_Name                : Node_Id := Empty;
1119       Explicit_Generic_Actual_Parameter : Node_Id)
1120       return Node_Id;
1121    pragma Inline (Make_Generic_Association);
1122
1123    function Make_Formal_Object_Declaration (Sloc : Source_Ptr;
1124       Defining_Identifier          : Node_Id;
1125       In_Present                   : Boolean := False;
1126       Out_Present                  : Boolean := False;
1127       Subtype_Mark                 : Node_Id;
1128       Expression                   : Node_Id := Empty)
1129       return Node_Id;
1130    pragma Inline (Make_Formal_Object_Declaration);
1131
1132    function Make_Formal_Type_Declaration (Sloc : Source_Ptr;
1133       Defining_Identifier          : Node_Id;
1134       Formal_Type_Definition       : Node_Id;
1135       Discriminant_Specifications  : List_Id := No_List;
1136       Unknown_Discriminants_Present : Boolean := False)
1137       return Node_Id;
1138    pragma Inline (Make_Formal_Type_Declaration);
1139
1140    function Make_Formal_Private_Type_Definition (Sloc : Source_Ptr;
1141       Abstract_Present             : Boolean := False;
1142       Tagged_Present               : Boolean := False;
1143       Limited_Present              : Boolean := False)
1144       return Node_Id;
1145    pragma Inline (Make_Formal_Private_Type_Definition);
1146
1147    function Make_Formal_Derived_Type_Definition (Sloc : Source_Ptr;
1148       Subtype_Mark                 : Node_Id;
1149       Private_Present              : Boolean := False;
1150       Abstract_Present             : Boolean := False)
1151       return Node_Id;
1152    pragma Inline (Make_Formal_Derived_Type_Definition);
1153
1154    function Make_Formal_Discrete_Type_Definition (Sloc : Source_Ptr)
1155       return Node_Id;
1156    pragma Inline (Make_Formal_Discrete_Type_Definition);
1157
1158    function Make_Formal_Signed_Integer_Type_Definition (Sloc : Source_Ptr)
1159       return Node_Id;
1160    pragma Inline (Make_Formal_Signed_Integer_Type_Definition);
1161
1162    function Make_Formal_Modular_Type_Definition (Sloc : Source_Ptr)
1163       return Node_Id;
1164    pragma Inline (Make_Formal_Modular_Type_Definition);
1165
1166    function Make_Formal_Floating_Point_Definition (Sloc : Source_Ptr)
1167       return Node_Id;
1168    pragma Inline (Make_Formal_Floating_Point_Definition);
1169
1170    function Make_Formal_Ordinary_Fixed_Point_Definition (Sloc : Source_Ptr)
1171       return Node_Id;
1172    pragma Inline (Make_Formal_Ordinary_Fixed_Point_Definition);
1173
1174    function Make_Formal_Decimal_Fixed_Point_Definition (Sloc : Source_Ptr)
1175       return Node_Id;
1176    pragma Inline (Make_Formal_Decimal_Fixed_Point_Definition);
1177
1178    function Make_Formal_Subprogram_Declaration (Sloc : Source_Ptr;
1179       Specification                : Node_Id;
1180       Default_Name                 : Node_Id := Empty;
1181       Box_Present                  : Boolean := False)
1182       return Node_Id;
1183    pragma Inline (Make_Formal_Subprogram_Declaration);
1184
1185    function Make_Formal_Package_Declaration (Sloc : Source_Ptr;
1186       Defining_Identifier          : Node_Id;
1187       Name                         : Node_Id;
1188       Generic_Associations         : List_Id := No_List;
1189       Box_Present                  : Boolean := False)
1190       return Node_Id;
1191    pragma Inline (Make_Formal_Package_Declaration);
1192
1193    function Make_Attribute_Definition_Clause (Sloc : Source_Ptr;
1194       Name                         : Node_Id;
1195       Chars                        : Name_Id;
1196       Expression                   : Node_Id)
1197       return Node_Id;
1198    pragma Inline (Make_Attribute_Definition_Clause);
1199
1200    function Make_Enumeration_Representation_Clause (Sloc : Source_Ptr;
1201       Identifier                   : Node_Id;
1202       Array_Aggregate              : Node_Id)
1203       return Node_Id;
1204    pragma Inline (Make_Enumeration_Representation_Clause);
1205
1206    function Make_Record_Representation_Clause (Sloc : Source_Ptr;
1207       Identifier                   : Node_Id;
1208       Mod_Clause                   : Node_Id := Empty;
1209       Component_Clauses            : List_Id)
1210       return Node_Id;
1211    pragma Inline (Make_Record_Representation_Clause);
1212
1213    function Make_Component_Clause (Sloc : Source_Ptr;
1214       Component_Name               : Node_Id;
1215       Position                     : Node_Id;
1216       First_Bit                    : Node_Id;
1217       Last_Bit                     : Node_Id)
1218       return Node_Id;
1219    pragma Inline (Make_Component_Clause);
1220
1221    function Make_Code_Statement (Sloc : Source_Ptr;
1222       Expression                   : Node_Id)
1223       return Node_Id;
1224    pragma Inline (Make_Code_Statement);
1225
1226    function Make_Op_Rotate_Left (Sloc : Source_Ptr;
1227       Left_Opnd                    : Node_Id;
1228       Right_Opnd                   : Node_Id)
1229       return Node_Id;
1230    pragma Inline (Make_Op_Rotate_Left);
1231
1232    function Make_Op_Rotate_Right (Sloc : Source_Ptr;
1233       Left_Opnd                    : Node_Id;
1234       Right_Opnd                   : Node_Id)
1235       return Node_Id;
1236    pragma Inline (Make_Op_Rotate_Right);
1237
1238    function Make_Op_Shift_Left (Sloc : Source_Ptr;
1239       Left_Opnd                    : Node_Id;
1240       Right_Opnd                   : Node_Id)
1241       return Node_Id;
1242    pragma Inline (Make_Op_Shift_Left);
1243
1244    function Make_Op_Shift_Right_Arithmetic (Sloc : Source_Ptr;
1245       Left_Opnd                    : Node_Id;
1246       Right_Opnd                   : Node_Id)
1247       return Node_Id;
1248    pragma Inline (Make_Op_Shift_Right_Arithmetic);
1249
1250    function Make_Op_Shift_Right (Sloc : Source_Ptr;
1251       Left_Opnd                    : Node_Id;
1252       Right_Opnd                   : Node_Id)
1253       return Node_Id;
1254    pragma Inline (Make_Op_Shift_Right);
1255
1256    function Make_Delta_Constraint (Sloc : Source_Ptr;
1257       Delta_Expression             : Node_Id;
1258       Range_Constraint             : Node_Id := Empty)
1259       return Node_Id;
1260    pragma Inline (Make_Delta_Constraint);
1261
1262    function Make_At_Clause (Sloc : Source_Ptr;
1263       Identifier                   : Node_Id;
1264       Expression                   : Node_Id)
1265       return Node_Id;
1266    pragma Inline (Make_At_Clause);
1267
1268    function Make_Mod_Clause (Sloc : Source_Ptr;
1269       Expression                   : Node_Id;
1270       Pragmas_Before               : List_Id)
1271       return Node_Id;
1272    pragma Inline (Make_Mod_Clause);
1273
1274    function Make_Conditional_Expression (Sloc : Source_Ptr;
1275       Expressions                  : List_Id)
1276       return Node_Id;
1277    pragma Inline (Make_Conditional_Expression);
1278
1279    function Make_Expanded_Name (Sloc : Source_Ptr;
1280       Chars                        : Name_Id;
1281       Prefix                       : Node_Id;
1282       Selector_Name                : Node_Id)
1283       return Node_Id;
1284    pragma Inline (Make_Expanded_Name);
1285
1286    function Make_Free_Statement (Sloc : Source_Ptr;
1287       Expression                   : Node_Id)
1288       return Node_Id;
1289    pragma Inline (Make_Free_Statement);
1290
1291    function Make_Freeze_Entity (Sloc : Source_Ptr;
1292       Actions                      : List_Id := No_List)
1293       return Node_Id;
1294    pragma Inline (Make_Freeze_Entity);
1295
1296    function Make_Implicit_Label_Declaration (Sloc : Source_Ptr;
1297       Defining_Identifier          : Node_Id)
1298       return Node_Id;
1299    pragma Inline (Make_Implicit_Label_Declaration);
1300
1301    function Make_Itype_Reference (Sloc : Source_Ptr)
1302       return Node_Id;
1303    pragma Inline (Make_Itype_Reference);
1304
1305    function Make_Raise_Constraint_Error (Sloc : Source_Ptr;
1306       Condition                    : Node_Id := Empty;
1307       Reason                       : Uint)
1308       return Node_Id;
1309    pragma Inline (Make_Raise_Constraint_Error);
1310
1311    function Make_Raise_Program_Error (Sloc : Source_Ptr;
1312       Condition                    : Node_Id := Empty;
1313       Reason                       : Uint)
1314       return Node_Id;
1315    pragma Inline (Make_Raise_Program_Error);
1316
1317    function Make_Raise_Storage_Error (Sloc : Source_Ptr;
1318       Condition                    : Node_Id := Empty;
1319       Reason                       : Uint)
1320       return Node_Id;
1321    pragma Inline (Make_Raise_Storage_Error);
1322
1323    function Make_Reference (Sloc : Source_Ptr;
1324       Prefix                       : Node_Id)
1325       return Node_Id;
1326    pragma Inline (Make_Reference);
1327
1328    function Make_Subprogram_Info (Sloc : Source_Ptr;
1329       Identifier                   : Node_Id)
1330       return Node_Id;
1331    pragma Inline (Make_Subprogram_Info);
1332
1333    function Make_Unchecked_Expression (Sloc : Source_Ptr;
1334       Expression                   : Node_Id)
1335       return Node_Id;
1336    pragma Inline (Make_Unchecked_Expression);
1337
1338    function Make_Unchecked_Type_Conversion (Sloc : Source_Ptr;
1339       Subtype_Mark                 : Node_Id;
1340       Expression                   : Node_Id)
1341       return Node_Id;
1342    pragma Inline (Make_Unchecked_Type_Conversion);
1343
1344    function Make_Validate_Unchecked_Conversion (Sloc : Source_Ptr)
1345       return Node_Id;
1346    pragma Inline (Make_Validate_Unchecked_Conversion);
1347
1348 end Nmake;