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       return Node_Id;
 376    pragma Inline (Make_Component_Association);
 377
 378    function Make_Extension_Aggregate (Sloc : Source_Ptr;
 379       Ancestor_Part                : Node_Id;
 380       Expressions                  : List_Id := No_List;
 381       Component_Associations       : List_Id := No_List;
 382       Null_Record_Present          : Boolean := False)
 383       return Node_Id;
 384    pragma Inline (Make_Extension_Aggregate);
 385
 386    function Make_Null (Sloc : Source_Ptr)
 387       return Node_Id;
 388    pragma Inline (Make_Null);
 389
 390    function Make_And_Then (Sloc : Source_Ptr;
 391       Left_Opnd                    : Node_Id;
 392       Right_Opnd                   : Node_Id)
 393       return Node_Id;
 394    pragma Inline (Make_And_Then);
 395
 396    function Make_Or_Else (Sloc : Source_Ptr;
 397       Left_Opnd                    : Node_Id;
 398       Right_Opnd                   : Node_Id)
 399       return Node_Id;
 400    pragma Inline (Make_Or_Else);
 401
 402    function Make_In (Sloc : Source_Ptr;
 403       Left_Opnd                    : Node_Id;
 404       Right_Opnd                   : Node_Id)
 405       return Node_Id;
 406    pragma Inline (Make_In);
 407
 408    function Make_Not_In (Sloc : Source_Ptr;
 409       Left_Opnd                    : Node_Id;
 410       Right_Opnd                   : Node_Id)
 411       return Node_Id;
 412    pragma Inline (Make_Not_In);
 413
 414    function Make_Op_And (Sloc : Source_Ptr;
 415       Left_Opnd                    : Node_Id;
 416       Right_Opnd                   : Node_Id)
 417       return Node_Id;
 418    pragma Inline (Make_Op_And);
 419
 420    function Make_Op_Or (Sloc : Source_Ptr;
 421       Left_Opnd                    : Node_Id;
 422       Right_Opnd                   : Node_Id)
 423       return Node_Id;
 424    pragma Inline (Make_Op_Or);
 425
 426    function Make_Op_Xor (Sloc : Source_Ptr;
 427       Left_Opnd                    : Node_Id;
 428       Right_Opnd                   : Node_Id)
 429       return Node_Id;
 430    pragma Inline (Make_Op_Xor);
 431
 432    function Make_Op_Eq (Sloc : Source_Ptr;
 433       Left_Opnd                    : Node_Id;
 434       Right_Opnd                   : Node_Id)
 435       return Node_Id;
 436    pragma Inline (Make_Op_Eq);
 437
 438    function Make_Op_Ne (Sloc : Source_Ptr;
 439       Left_Opnd                    : Node_Id;
 440       Right_Opnd                   : Node_Id)
 441       return Node_Id;
 442    pragma Inline (Make_Op_Ne);
 443
 444    function Make_Op_Lt (Sloc : Source_Ptr;
 445       Left_Opnd                    : Node_Id;
 446       Right_Opnd                   : Node_Id)
 447       return Node_Id;
 448    pragma Inline (Make_Op_Lt);
 449
 450    function Make_Op_Le (Sloc : Source_Ptr;
 451       Left_Opnd                    : Node_Id;
 452       Right_Opnd                   : Node_Id)
 453       return Node_Id;
 454    pragma Inline (Make_Op_Le);
 455
 456    function Make_Op_Gt (Sloc : Source_Ptr;
 457       Left_Opnd                    : Node_Id;
 458       Right_Opnd                   : Node_Id)
 459       return Node_Id;
 460    pragma Inline (Make_Op_Gt);
 461
 462    function Make_Op_Ge (Sloc : Source_Ptr;
 463       Left_Opnd                    : Node_Id;
 464       Right_Opnd                   : Node_Id)
 465       return Node_Id;
 466    pragma Inline (Make_Op_Ge);
 467
 468    function Make_Op_Add (Sloc : Source_Ptr;
 469       Left_Opnd                    : Node_Id;
 470       Right_Opnd                   : Node_Id)
 471       return Node_Id;
 472    pragma Inline (Make_Op_Add);
 473
 474    function Make_Op_Subtract (Sloc : Source_Ptr;
 475       Left_Opnd                    : Node_Id;
 476       Right_Opnd                   : Node_Id)
 477       return Node_Id;
 478    pragma Inline (Make_Op_Subtract);
 479
 480    function Make_Op_Concat (Sloc : Source_Ptr;
 481       Left_Opnd                    : Node_Id;
 482       Right_Opnd                   : Node_Id)
 483       return Node_Id;
 484    pragma Inline (Make_Op_Concat);
 485
 486    function Make_Op_Multiply (Sloc : Source_Ptr;
 487       Left_Opnd                    : Node_Id;
 488       Right_Opnd                   : Node_Id)
 489       return Node_Id;
 490    pragma Inline (Make_Op_Multiply);
 491
 492    function Make_Op_Divide (Sloc : Source_Ptr;
 493       Left_Opnd                    : Node_Id;
 494       Right_Opnd                   : Node_Id)
 495       return Node_Id;
 496    pragma Inline (Make_Op_Divide);
 497
 498    function Make_Op_Mod (Sloc : Source_Ptr;
 499       Left_Opnd                    : Node_Id;
 500       Right_Opnd                   : Node_Id)
 501       return Node_Id;
 502    pragma Inline (Make_Op_Mod);
 503
 504    function Make_Op_Rem (Sloc : Source_Ptr;
 505       Left_Opnd                    : Node_Id;
 506       Right_Opnd                   : Node_Id)
 507       return Node_Id;
 508    pragma Inline (Make_Op_Rem);
 509
 510    function Make_Op_Expon (Sloc : Source_Ptr;
 511       Left_Opnd                    : Node_Id;
 512       Right_Opnd                   : Node_Id)
 513       return Node_Id;
 514    pragma Inline (Make_Op_Expon);
 515
 516    function Make_Op_Plus (Sloc : Source_Ptr;
 517       Right_Opnd                   : Node_Id)
 518       return Node_Id;
 519    pragma Inline (Make_Op_Plus);
 520
 521    function Make_Op_Minus (Sloc : Source_Ptr;
 522       Right_Opnd                   : Node_Id)
 523       return Node_Id;
 524    pragma Inline (Make_Op_Minus);
 525
 526    function Make_Op_Abs (Sloc : Source_Ptr;
 527       Right_Opnd                   : Node_Id)
 528       return Node_Id;
 529    pragma Inline (Make_Op_Abs);
 530
 531    function Make_Op_Not (Sloc : Source_Ptr;
 532       Right_Opnd                   : Node_Id)
 533       return Node_Id;
 534    pragma Inline (Make_Op_Not);
 535
 536    function Make_Type_Conversion (Sloc : Source_Ptr;
 537       Subtype_Mark                 : Node_Id;
 538       Expression                   : Node_Id)
 539       return Node_Id;
 540    pragma Inline (Make_Type_Conversion);
 541
 542    function Make_Qualified_Expression (Sloc : Source_Ptr;
 543       Subtype_Mark                 : Node_Id;
 544       Expression                   : Node_Id)
 545       return Node_Id;
 546    pragma Inline (Make_Qualified_Expression);
 547
 548    function Make_Allocator (Sloc : Source_Ptr;
 549       Expression                   : Node_Id)
 550       return Node_Id;
 551    pragma Inline (Make_Allocator);
 552
 553    function Make_Null_Statement (Sloc : Source_Ptr)
 554       return Node_Id;
 555    pragma Inline (Make_Null_Statement);
 556
 557    function Make_Label (Sloc : Source_Ptr;
 558       Identifier                   : Node_Id)
 559       return Node_Id;
 560    pragma Inline (Make_Label);
 561
 562    function Make_Assignment_Statement (Sloc : Source_Ptr;
 563       Name                         : Node_Id;
 564       Expression                   : Node_Id)
 565       return Node_Id;
 566    pragma Inline (Make_Assignment_Statement);
 567
 568    function Make_If_Statement (Sloc : Source_Ptr;
 569       Condition                    : Node_Id;
 570       Then_Statements              : List_Id;
 571       Elsif_Parts                  : List_Id := No_List;
 572       Else_Statements              : List_Id := No_List;
 573       End_Span                     : Uint := No_Uint)
 574       return Node_Id;
 575    pragma Inline (Make_If_Statement);
 576
 577    function Make_Elsif_Part (Sloc : Source_Ptr;
 578       Condition                    : Node_Id;
 579       Then_Statements              : List_Id)
 580       return Node_Id;
 581    pragma Inline (Make_Elsif_Part);
 582
 583    function Make_Case_Statement (Sloc : Source_Ptr;
 584       Expression                   : Node_Id;
 585       Alternatives                 : List_Id;
 586       End_Span                     : Uint := No_Uint)
 587       return Node_Id;
 588    pragma Inline (Make_Case_Statement);
 589
 590    function Make_Case_Statement_Alternative (Sloc : Source_Ptr;
 591       Discrete_Choices             : List_Id;
 592       Statements                   : List_Id)
 593       return Node_Id;
 594    pragma Inline (Make_Case_Statement_Alternative);
 595
 596    function Make_Loop_Statement (Sloc : Source_Ptr;
 597       Identifier                   : Node_Id := Empty;
 598       Iteration_Scheme             : Node_Id := Empty;
 599       Statements                   : List_Id;
 600       End_Label                    : Node_Id;
 601       Has_Created_Identifier       : Boolean := False;
 602       Is_Null_Loop                 : Boolean := False)
 603       return Node_Id;
 604    pragma Inline (Make_Loop_Statement);
 605
 606    function Make_Iteration_Scheme (Sloc : Source_Ptr;
 607       Condition                    : Node_Id := Empty;
 608       Loop_Parameter_Specification : Node_Id := Empty)
 609       return Node_Id;
 610    pragma Inline (Make_Iteration_Scheme);
 611
 612    function Make_Loop_Parameter_Specification (Sloc : Source_Ptr;
 613       Defining_Identifier          : Node_Id;
 614       Reverse_Present              : Boolean := False;
 615       Discrete_Subtype_Definition  : Node_Id)
 616       return Node_Id;
 617    pragma Inline (Make_Loop_Parameter_Specification);
 618
 619    function Make_Block_Statement (Sloc : Source_Ptr;
 620       Identifier                   : Node_Id := Empty;
 621       Declarations                 : List_Id := No_List;
 622       Handled_Statement_Sequence   : Node_Id;
 623       Has_Created_Identifier       : Boolean := False;
 624       Is_Task_Allocation_Block     : Boolean := False;
 625       Is_Asynchronous_Call_Block   : Boolean := False)
 626       return Node_Id;
 627    pragma Inline (Make_Block_Statement);
 628
 629    function Make_Exit_Statement (Sloc : Source_Ptr;
 630       Name                         : Node_Id := Empty;
 631       Condition                    : Node_Id := Empty)
 632       return Node_Id;
 633    pragma Inline (Make_Exit_Statement);
 634
 635    function Make_Goto_Statement (Sloc : Source_Ptr;
 636       Name                         : Node_Id)
 637       return Node_Id;
 638    pragma Inline (Make_Goto_Statement);
 639
 640    function Make_Subprogram_Declaration (Sloc : Source_Ptr;
 641       Specification                : Node_Id)
 642       return Node_Id;
 643    pragma Inline (Make_Subprogram_Declaration);
 644
 645    function Make_Abstract_Subprogram_Declaration (Sloc : Source_Ptr;
 646       Specification                : Node_Id)
 647       return Node_Id;
 648    pragma Inline (Make_Abstract_Subprogram_Declaration);
 649
 650    function Make_Function_Specification (Sloc : Source_Ptr;
 651       Defining_Unit_Name           : Node_Id;
 652       Parameter_Specifications     : List_Id := No_List;
 653       Subtype_Mark                 : Node_Id)
 654       return Node_Id;
 655    pragma Inline (Make_Function_Specification);
 656
 657    function Make_Procedure_Specification (Sloc : Source_Ptr;
 658       Defining_Unit_Name           : Node_Id;
 659       Parameter_Specifications     : List_Id := No_List)
 660       return Node_Id;
 661    pragma Inline (Make_Procedure_Specification);
 662
 663    function Make_Designator (Sloc : Source_Ptr;
 664       Name                         : Node_Id;
 665       Identifier                   : Node_Id)
 666       return Node_Id;
 667    pragma Inline (Make_Designator);
 668
 669    function Make_Defining_Program_Unit_Name (Sloc : Source_Ptr;
 670       Name                         : Node_Id;
 671       Defining_Identifier          : Node_Id)
 672       return Node_Id;
 673    pragma Inline (Make_Defining_Program_Unit_Name);
 674
 675    function Make_Operator_Symbol (Sloc : Source_Ptr;
 676       Chars                        : Name_Id;
 677       Strval                       : String_Id)
 678       return Node_Id;
 679    pragma Inline (Make_Operator_Symbol);
 680
 681    function Make_Defining_Operator_Symbol (Sloc : Source_Ptr;
 682       Chars                        : Name_Id)
 683       return Node_Id;
 684    pragma Inline (Make_Defining_Operator_Symbol);
 685
 686    function Make_Parameter_Specification (Sloc : Source_Ptr;
 687       Defining_Identifier          : Node_Id;
 688       In_Present                   : Boolean := False;
 689       Out_Present                  : Boolean := False;
 690       Parameter_Type               : Node_Id;
 691       Expression                   : Node_Id := Empty)
 692       return Node_Id;
 693    pragma Inline (Make_Parameter_Specification);
 694
 695    function Make_Subprogram_Body (Sloc : Source_Ptr;
 696       Specification                : Node_Id;
 697       Declarations                 : List_Id;
 698       Handled_Statement_Sequence   : Node_Id;
 699       Bad_Is_Detected              : Boolean := False)
 700       return Node_Id;
 701    pragma Inline (Make_Subprogram_Body);
 702
 703    function Make_Procedure_Call_Statement (Sloc : Source_Ptr;
 704       Name                         : Node_Id;
 705       Parameter_Associations       : List_Id := No_List)
 706       return Node_Id;
 707    pragma Inline (Make_Procedure_Call_Statement);
 708
 709    function Make_Function_Call (Sloc : Source_Ptr;
 710       Name                         : Node_Id;
 711       Parameter_Associations       : List_Id := No_List)
 712       return Node_Id;
 713    pragma Inline (Make_Function_Call);
 714
 715    function Make_Parameter_Association (Sloc : Source_Ptr;
 716       Selector_Name                : Node_Id;
 717       Explicit_Actual_Parameter    : Node_Id)
 718       return Node_Id;
 719    pragma Inline (Make_Parameter_Association);
 720
 721    function Make_Return_Statement (Sloc : Source_Ptr;
 722       Expression                   : Node_Id := Empty)
 723       return Node_Id;
 724    pragma Inline (Make_Return_Statement);
 725
 726    function Make_Package_Declaration (Sloc : Source_Ptr;
 727       Specification                : Node_Id)
 728       return Node_Id;
 729    pragma Inline (Make_Package_Declaration);
 730
 731    function Make_Package_Specification (Sloc : Source_Ptr;
 732       Defining_Unit_Name           : Node_Id;
 733       Visible_Declarations         : List_Id;
 734       Private_Declarations         : List_Id := No_List;
 735       End_Label                    : Node_Id)
 736       return Node_Id;
 737    pragma Inline (Make_Package_Specification);
 738
 739    function Make_Package_Body (Sloc : Source_Ptr;
 740       Defining_Unit_Name           : Node_Id;
 741       Declarations                 : List_Id;
 742       Handled_Statement_Sequence   : Node_Id := Empty)
 743       return Node_Id;
 744    pragma Inline (Make_Package_Body);
 745
 746    function Make_Private_Type_Declaration (Sloc : Source_Ptr;
 747       Defining_Identifier          : Node_Id;
 748       Discriminant_Specifications  : List_Id := No_List;
 749       Unknown_Discriminants_Present : Boolean := False;
 750       Abstract_Present             : Boolean := False;
 751       Tagged_Present               : Boolean := False;
 752       Limited_Present              : Boolean := False)
 753       return Node_Id;
 754    pragma Inline (Make_Private_Type_Declaration);
 755
 756    function Make_Private_Extension_Declaration (Sloc : Source_Ptr;
 757       Defining_Identifier          : Node_Id;
 758       Discriminant_Specifications  : List_Id := No_List;
 759       Unknown_Discriminants_Present : Boolean := False;
 760       Abstract_Present             : Boolean := False;
 761       Subtype_Indication           : Node_Id)
 762       return Node_Id;
 763    pragma Inline (Make_Private_Extension_Declaration);
 764
 765    function Make_Use_Package_Clause (Sloc : Source_Ptr;
 766       Names                        : List_Id)
 767       return Node_Id;
 768    pragma Inline (Make_Use_Package_Clause);
 769
 770    function Make_Use_Type_Clause (Sloc : Source_Ptr;
 771       Subtype_Marks                : List_Id)
 772       return Node_Id;
 773    pragma Inline (Make_Use_Type_Clause);
 774
 775    function Make_Object_Renaming_Declaration (Sloc : Source_Ptr;
 776       Defining_Identifier          : Node_Id;
 777       Subtype_Mark                 : Node_Id;
 778       Name                         : Node_Id)
 779       return Node_Id;
 780    pragma Inline (Make_Object_Renaming_Declaration);
 781
 782    function Make_Exception_Renaming_Declaration (Sloc : Source_Ptr;
 783       Defining_Identifier          : Node_Id;
 784       Name                         : Node_Id)
 785       return Node_Id;
 786    pragma Inline (Make_Exception_Renaming_Declaration);
 787
 788    function Make_Package_Renaming_Declaration (Sloc : Source_Ptr;
 789       Defining_Unit_Name           : Node_Id;
 790       Name                         : Node_Id)
 791       return Node_Id;
 792    pragma Inline (Make_Package_Renaming_Declaration);
 793
 794    function Make_Subprogram_Renaming_Declaration (Sloc : Source_Ptr;
 795       Specification                : Node_Id;
 796       Name                         : Node_Id)
 797       return Node_Id;
 798    pragma Inline (Make_Subprogram_Renaming_Declaration);
 799
 800    function Make_Generic_Package_Renaming_Declaration (Sloc : Source_Ptr;
 801       Defining_Unit_Name           : Node_Id;
 802       Name                         : Node_Id)
 803       return Node_Id;
 804    pragma Inline (Make_Generic_Package_Renaming_Declaration);
 805
 806    function Make_Generic_Procedure_Renaming_Declaration (Sloc : Source_Ptr;
 807       Defining_Unit_Name           : Node_Id;
 808       Name                         : Node_Id)
 809       return Node_Id;
 810    pragma Inline (Make_Generic_Procedure_Renaming_Declaration);
 811
 812    function Make_Generic_Function_Renaming_Declaration (Sloc : Source_Ptr;
 813       Defining_Unit_Name           : Node_Id;
 814       Name                         : Node_Id)
 815       return Node_Id;
 816    pragma Inline (Make_Generic_Function_Renaming_Declaration);
 817
 818    function Make_Task_Type_Declaration (Sloc : Source_Ptr;
 819       Defining_Identifier          : Node_Id;
 820       Discriminant_Specifications  : List_Id := No_List;
 821       Task_Definition              : Node_Id := Empty)
 822       return Node_Id;
 823    pragma Inline (Make_Task_Type_Declaration);
 824
 825    function Make_Single_Task_Declaration (Sloc : Source_Ptr;
 826       Defining_Identifier          : Node_Id;
 827       Task_Definition              : Node_Id := Empty)
 828       return Node_Id;
 829    pragma Inline (Make_Single_Task_Declaration);
 830
 831    function Make_Task_Definition (Sloc : Source_Ptr;
 832       Visible_Declarations         : List_Id;
 833       Private_Declarations         : List_Id := No_List;
 834       End_Label                    : Node_Id)
 835       return Node_Id;
 836    pragma Inline (Make_Task_Definition);
 837
 838    function Make_Task_Body (Sloc : Source_Ptr;
 839       Defining_Identifier          : Node_Id;
 840       Declarations                 : List_Id;
 841       Handled_Statement_Sequence   : Node_Id)
 842       return Node_Id;
 843    pragma Inline (Make_Task_Body);
 844
 845    function Make_Protected_Type_Declaration (Sloc : Source_Ptr;
 846       Defining_Identifier          : Node_Id;
 847       Discriminant_Specifications  : List_Id := No_List;
 848       Protected_Definition         : Node_Id)
 849       return Node_Id;
 850    pragma Inline (Make_Protected_Type_Declaration);
 851
 852    function Make_Single_Protected_Declaration (Sloc : Source_Ptr;
 853       Defining_Identifier          : Node_Id;
 854       Protected_Definition         : Node_Id)
 855       return Node_Id;
 856    pragma Inline (Make_Single_Protected_Declaration);
 857
 858    function Make_Protected_Definition (Sloc : Source_Ptr;
 859       Visible_Declarations         : List_Id;
 860       Private_Declarations         : List_Id := No_List;
 861       End_Label                    : Node_Id)
 862       return Node_Id;
 863    pragma Inline (Make_Protected_Definition);
 864
 865    function Make_Protected_Body (Sloc : Source_Ptr;
 866       Defining_Identifier          : Node_Id;
 867       Declarations                 : List_Id;
 868       End_Label                    : Node_Id)
 869       return Node_Id;
 870    pragma Inline (Make_Protected_Body);
 871
 872    function Make_Entry_Declaration (Sloc : Source_Ptr;
 873       Defining_Identifier          : Node_Id;
 874       Discrete_Subtype_Definition  : Node_Id := Empty;
 875       Parameter_Specifications     : List_Id := No_List)
 876       return Node_Id;
 877    pragma Inline (Make_Entry_Declaration);
 878
 879    function Make_Accept_Statement (Sloc : Source_Ptr;
 880       Entry_Direct_Name            : Node_Id;
 881       Entry_Index                  : Node_Id := Empty;
 882       Parameter_Specifications     : List_Id := No_List;
 883       Handled_Statement_Sequence   : Node_Id;
 884       Declarations                 : List_Id := No_List)
 885       return Node_Id;
 886    pragma Inline (Make_Accept_Statement);
 887
 888    function Make_Entry_Body (Sloc : Source_Ptr;
 889       Defining_Identifier          : Node_Id;
 890       Entry_Body_Formal_Part       : Node_Id;
 891       Declarations                 : List_Id;
 892       Handled_Statement_Sequence   : Node_Id)
 893       return Node_Id;
 894    pragma Inline (Make_Entry_Body);
 895
 896    function Make_Entry_Body_Formal_Part (Sloc : Source_Ptr;
 897       Entry_Index_Specification    : Node_Id := Empty;
 898       Parameter_Specifications     : List_Id := No_List;
 899       Condition                    : Node_Id)
 900       return Node_Id;
 901    pragma Inline (Make_Entry_Body_Formal_Part);
 902
 903    function Make_Entry_Index_Specification (Sloc : Source_Ptr;
 904       Defining_Identifier          : Node_Id;
 905       Discrete_Subtype_Definition  : Node_Id)
 906       return Node_Id;
 907    pragma Inline (Make_Entry_Index_Specification);
 908
 909    function Make_Entry_Call_Statement (Sloc : Source_Ptr;
 910       Name                         : Node_Id;
 911       Parameter_Associations       : List_Id := No_List)
 912       return Node_Id;
 913    pragma Inline (Make_Entry_Call_Statement);
 914
 915    function Make_Requeue_Statement (Sloc : Source_Ptr;
 916       Name                         : Node_Id;
 917       Abort_Present                : Boolean := False)
 918       return Node_Id;
 919    pragma Inline (Make_Requeue_Statement);
 920
 921    function Make_Delay_Until_Statement (Sloc : Source_Ptr;
 922       Expression                   : Node_Id)
 923       return Node_Id;
 924    pragma Inline (Make_Delay_Until_Statement);
 925
 926    function Make_Delay_Relative_Statement (Sloc : Source_Ptr;
 927       Expression                   : Node_Id)
 928       return Node_Id;
 929    pragma Inline (Make_Delay_Relative_Statement);
 930
 931    function Make_Selective_Accept (Sloc : Source_Ptr;
 932       Select_Alternatives          : List_Id;
 933       Else_Statements              : List_Id := No_List)
 934       return Node_Id;
 935    pragma Inline (Make_Selective_Accept);
 936
 937    function Make_Accept_Alternative (Sloc : Source_Ptr;
 938       Accept_Statement             : Node_Id;
 939       Condition                    : Node_Id := Empty;
 940       Statements                   : List_Id := Empty_List;
 941       Pragmas_Before               : List_Id := No_List)
 942       return Node_Id;
 943    pragma Inline (Make_Accept_Alternative);
 944
 945    function Make_Delay_Alternative (Sloc : Source_Ptr;
 946       Delay_Statement              : Node_Id;
 947       Condition                    : Node_Id := Empty;
 948       Statements                   : List_Id := Empty_List;
 949       Pragmas_Before               : List_Id := No_List)
 950       return Node_Id;
 951    pragma Inline (Make_Delay_Alternative);
 952
 953    function Make_Terminate_Alternative (Sloc : Source_Ptr;
 954       Condition                    : Node_Id := Empty;
 955       Pragmas_Before               : List_Id := No_List;
 956       Pragmas_After                : List_Id := No_List)
 957       return Node_Id;
 958    pragma Inline (Make_Terminate_Alternative);
 959
 960    function Make_Timed_Entry_Call (Sloc : Source_Ptr;
 961       Entry_Call_Alternative       : Node_Id;
 962       Delay_Alternative            : Node_Id)
 963       return Node_Id;
 964    pragma Inline (Make_Timed_Entry_Call);
 965
 966    function Make_Entry_Call_Alternative (Sloc : Source_Ptr;
 967       Entry_Call_Statement         : Node_Id;
 968       Statements                   : List_Id := Empty_List;
 969       Pragmas_Before               : List_Id := No_List)
 970       return Node_Id;
 971    pragma Inline (Make_Entry_Call_Alternative);
 972
 973    function Make_Conditional_Entry_Call (Sloc : Source_Ptr;
 974       Entry_Call_Alternative       : Node_Id;
 975       Else_Statements              : List_Id)
 976       return Node_Id;
 977    pragma Inline (Make_Conditional_Entry_Call);
 978
 979    function Make_Asynchronous_Select (Sloc : Source_Ptr;
 980       Triggering_Alternative       : Node_Id;
 981       Abortable_Part               : Node_Id)
 982       return Node_Id;
 983    pragma Inline (Make_Asynchronous_Select);
 984
 985    function Make_Triggering_Alternative (Sloc : Source_Ptr;
 986       Triggering_Statement         : Node_Id;
 987       Statements                   : List_Id := Empty_List;
 988       Pragmas_Before               : List_Id := No_List)
 989       return Node_Id;
 990    pragma Inline (Make_Triggering_Alternative);
 991
 992    function Make_Abortable_Part (Sloc : Source_Ptr;
 993       Statements                   : List_Id)
 994       return Node_Id;
 995    pragma Inline (Make_Abortable_Part);
 996
 997    function Make_Abort_Statement (Sloc : Source_Ptr;
 998       Names                        : List_Id)
 999       return Node_Id;
1000    pragma Inline (Make_Abort_Statement);
1001
1002    function Make_Compilation_Unit (Sloc : Source_Ptr;
1003       Context_Items                : List_Id;
1004       Private_Present              : Boolean := False;
1005       Unit                         : Node_Id;
1006       Aux_Decls_Node               : Node_Id)
1007       return Node_Id;
1008    pragma Inline (Make_Compilation_Unit);
1009
1010    function Make_Compilation_Unit_Aux (Sloc : Source_Ptr;
1011       Declarations                 : List_Id := No_List;
1012       Actions                      : List_Id := No_List;
1013       Pragmas_After                : List_Id := No_List;
1014       Config_Pragmas               : List_Id := Empty_List)
1015       return Node_Id;
1016    pragma Inline (Make_Compilation_Unit_Aux);
1017
1018    function Make_With_Clause (Sloc : Source_Ptr;
1019       Name                         : Node_Id;
1020       First_Name                   : Boolean := True;
1021       Last_Name                    : Boolean := True;
1022       Limited_Present              : Boolean := False)
1023       return Node_Id;
1024    pragma Inline (Make_With_Clause);
1025
1026    function Make_With_Type_Clause (Sloc : Source_Ptr;
1027       Name                         : Node_Id;
1028       Tagged_Present               : Boolean := False)
1029       return Node_Id;
1030    pragma Inline (Make_With_Type_Clause);
1031
1032    function Make_Subprogram_Body_Stub (Sloc : Source_Ptr;
1033       Specification                : Node_Id)
1034       return Node_Id;
1035    pragma Inline (Make_Subprogram_Body_Stub);
1036
1037    function Make_Package_Body_Stub (Sloc : Source_Ptr;
1038       Defining_Identifier          : Node_Id)
1039       return Node_Id;
1040    pragma Inline (Make_Package_Body_Stub);
1041
1042    function Make_Task_Body_Stub (Sloc : Source_Ptr;
1043       Defining_Identifier          : Node_Id)
1044       return Node_Id;
1045    pragma Inline (Make_Task_Body_Stub);
1046
1047    function Make_Protected_Body_Stub (Sloc : Source_Ptr;
1048       Defining_Identifier          : Node_Id)
1049       return Node_Id;
1050    pragma Inline (Make_Protected_Body_Stub);
1051
1052    function Make_Subunit (Sloc : Source_Ptr;
1053       Name                         : Node_Id;
1054       Proper_Body                  : Node_Id)
1055       return Node_Id;
1056    pragma Inline (Make_Subunit);
1057
1058    function Make_Exception_Declaration (Sloc : Source_Ptr;
1059       Defining_Identifier          : Node_Id)
1060       return Node_Id;
1061    pragma Inline (Make_Exception_Declaration);
1062
1063    function Make_Handled_Sequence_Of_Statements (Sloc : Source_Ptr;
1064       Statements                   : List_Id;
1065       End_Label                    : Node_Id := Empty;
1066       Exception_Handlers           : List_Id := No_List;
1067       At_End_Proc                  : Node_Id := Empty)
1068       return Node_Id;
1069    pragma Inline (Make_Handled_Sequence_Of_Statements);
1070
1071    function Make_Exception_Handler (Sloc : Source_Ptr;
1072       Choice_Parameter             : Node_Id := Empty;
1073       Exception_Choices            : List_Id;
1074       Statements                   : List_Id)
1075       return Node_Id;
1076    pragma Inline (Make_Exception_Handler);
1077
1078    function Make_Raise_Statement (Sloc : Source_Ptr;
1079       Name                         : Node_Id := Empty)
1080       return Node_Id;
1081    pragma Inline (Make_Raise_Statement);
1082
1083    function Make_Generic_Subprogram_Declaration (Sloc : Source_Ptr;
1084       Specification                : Node_Id;
1085       Generic_Formal_Declarations  : List_Id)
1086       return Node_Id;
1087    pragma Inline (Make_Generic_Subprogram_Declaration);
1088
1089    function Make_Generic_Package_Declaration (Sloc : Source_Ptr;
1090       Specification                : Node_Id;
1091       Generic_Formal_Declarations  : List_Id)
1092       return Node_Id;
1093    pragma Inline (Make_Generic_Package_Declaration);
1094
1095    function Make_Package_Instantiation (Sloc : Source_Ptr;
1096       Defining_Unit_Name           : Node_Id;
1097       Name                         : Node_Id;
1098       Generic_Associations         : List_Id := No_List)
1099       return Node_Id;
1100    pragma Inline (Make_Package_Instantiation);
1101
1102    function Make_Procedure_Instantiation (Sloc : Source_Ptr;
1103       Defining_Unit_Name           : Node_Id;
1104       Name                         : Node_Id;
1105       Generic_Associations         : List_Id := No_List)
1106       return Node_Id;
1107    pragma Inline (Make_Procedure_Instantiation);
1108
1109    function Make_Function_Instantiation (Sloc : Source_Ptr;
1110       Defining_Unit_Name           : Node_Id;
1111       Name                         : Node_Id;
1112       Generic_Associations         : List_Id := No_List)
1113       return Node_Id;
1114    pragma Inline (Make_Function_Instantiation);
1115
1116    function Make_Generic_Association (Sloc : Source_Ptr;
1117       Selector_Name                : Node_Id := Empty;
1118       Explicit_Generic_Actual_Parameter : Node_Id)
1119       return Node_Id;
1120    pragma Inline (Make_Generic_Association);
1121
1122    function Make_Formal_Object_Declaration (Sloc : Source_Ptr;
1123       Defining_Identifier          : Node_Id;
1124       In_Present                   : Boolean := False;
1125       Out_Present                  : Boolean := False;
1126       Subtype_Mark                 : Node_Id;
1127       Expression                   : Node_Id := Empty)
1128       return Node_Id;
1129    pragma Inline (Make_Formal_Object_Declaration);
1130
1131    function Make_Formal_Type_Declaration (Sloc : Source_Ptr;
1132       Defining_Identifier          : Node_Id;
1133       Formal_Type_Definition       : Node_Id;
1134       Discriminant_Specifications  : List_Id := No_List;
1135       Unknown_Discriminants_Present : Boolean := False)
1136       return Node_Id;
1137    pragma Inline (Make_Formal_Type_Declaration);
1138
1139    function Make_Formal_Private_Type_Definition (Sloc : Source_Ptr;
1140       Abstract_Present             : Boolean := False;
1141       Tagged_Present               : Boolean := False;
1142       Limited_Present              : Boolean := False)
1143       return Node_Id;
1144    pragma Inline (Make_Formal_Private_Type_Definition);
1145
1146    function Make_Formal_Derived_Type_Definition (Sloc : Source_Ptr;
1147       Subtype_Mark                 : Node_Id;
1148       Private_Present              : Boolean := False;
1149       Abstract_Present             : Boolean := False)
1150       return Node_Id;
1151    pragma Inline (Make_Formal_Derived_Type_Definition);
1152
1153    function Make_Formal_Discrete_Type_Definition (Sloc : Source_Ptr)
1154       return Node_Id;
1155    pragma Inline (Make_Formal_Discrete_Type_Definition);
1156
1157    function Make_Formal_Signed_Integer_Type_Definition (Sloc : Source_Ptr)
1158       return Node_Id;
1159    pragma Inline (Make_Formal_Signed_Integer_Type_Definition);
1160
1161    function Make_Formal_Modular_Type_Definition (Sloc : Source_Ptr)
1162       return Node_Id;
1163    pragma Inline (Make_Formal_Modular_Type_Definition);
1164
1165    function Make_Formal_Floating_Point_Definition (Sloc : Source_Ptr)
1166       return Node_Id;
1167    pragma Inline (Make_Formal_Floating_Point_Definition);
1168
1169    function Make_Formal_Ordinary_Fixed_Point_Definition (Sloc : Source_Ptr)
1170       return Node_Id;
1171    pragma Inline (Make_Formal_Ordinary_Fixed_Point_Definition);
1172
1173    function Make_Formal_Decimal_Fixed_Point_Definition (Sloc : Source_Ptr)
1174       return Node_Id;
1175    pragma Inline (Make_Formal_Decimal_Fixed_Point_Definition);
1176
1177    function Make_Formal_Subprogram_Declaration (Sloc : Source_Ptr;
1178       Specification                : Node_Id;
1179       Default_Name                 : Node_Id := Empty;
1180       Box_Present                  : Boolean := False)
1181       return Node_Id;
1182    pragma Inline (Make_Formal_Subprogram_Declaration);
1183
1184    function Make_Formal_Package_Declaration (Sloc : Source_Ptr;
1185       Defining_Identifier          : Node_Id;
1186       Name                         : Node_Id;
1187       Generic_Associations         : List_Id := No_List;
1188       Box_Present                  : Boolean := False)
1189       return Node_Id;
1190    pragma Inline (Make_Formal_Package_Declaration);
1191
1192    function Make_Attribute_Definition_Clause (Sloc : Source_Ptr;
1193       Name                         : Node_Id;
1194       Chars                        : Name_Id;
1195       Expression                   : Node_Id)
1196       return Node_Id;
1197    pragma Inline (Make_Attribute_Definition_Clause);
1198
1199    function Make_Enumeration_Representation_Clause (Sloc : Source_Ptr;
1200       Identifier                   : Node_Id;
1201       Array_Aggregate              : Node_Id)
1202       return Node_Id;
1203    pragma Inline (Make_Enumeration_Representation_Clause);
1204
1205    function Make_Record_Representation_Clause (Sloc : Source_Ptr;
1206       Identifier                   : Node_Id;
1207       Mod_Clause                   : Node_Id := Empty;
1208       Component_Clauses            : List_Id)
1209       return Node_Id;
1210    pragma Inline (Make_Record_Representation_Clause);
1211
1212    function Make_Component_Clause (Sloc : Source_Ptr;
1213       Component_Name               : Node_Id;
1214       Position                     : Node_Id;
1215       First_Bit                    : Node_Id;
1216       Last_Bit                     : Node_Id)
1217       return Node_Id;
1218    pragma Inline (Make_Component_Clause);
1219
1220    function Make_Code_Statement (Sloc : Source_Ptr;
1221       Expression                   : Node_Id)
1222       return Node_Id;
1223    pragma Inline (Make_Code_Statement);
1224
1225    function Make_Op_Rotate_Left (Sloc : Source_Ptr;
1226       Left_Opnd                    : Node_Id;
1227       Right_Opnd                   : Node_Id)
1228       return Node_Id;
1229    pragma Inline (Make_Op_Rotate_Left);
1230
1231    function Make_Op_Rotate_Right (Sloc : Source_Ptr;
1232       Left_Opnd                    : Node_Id;
1233       Right_Opnd                   : Node_Id)
1234       return Node_Id;
1235    pragma Inline (Make_Op_Rotate_Right);
1236
1237    function Make_Op_Shift_Left (Sloc : Source_Ptr;
1238       Left_Opnd                    : Node_Id;
1239       Right_Opnd                   : Node_Id)
1240       return Node_Id;
1241    pragma Inline (Make_Op_Shift_Left);
1242
1243    function Make_Op_Shift_Right_Arithmetic (Sloc : Source_Ptr;
1244       Left_Opnd                    : Node_Id;
1245       Right_Opnd                   : Node_Id)
1246       return Node_Id;
1247    pragma Inline (Make_Op_Shift_Right_Arithmetic);
1248
1249    function Make_Op_Shift_Right (Sloc : Source_Ptr;
1250       Left_Opnd                    : Node_Id;
1251       Right_Opnd                   : Node_Id)
1252       return Node_Id;
1253    pragma Inline (Make_Op_Shift_Right);
1254
1255    function Make_Delta_Constraint (Sloc : Source_Ptr;
1256       Delta_Expression             : Node_Id;
1257       Range_Constraint             : Node_Id := Empty)
1258       return Node_Id;
1259    pragma Inline (Make_Delta_Constraint);
1260
1261    function Make_At_Clause (Sloc : Source_Ptr;
1262       Identifier                   : Node_Id;
1263       Expression                   : Node_Id)
1264       return Node_Id;
1265    pragma Inline (Make_At_Clause);
1266
1267    function Make_Mod_Clause (Sloc : Source_Ptr;
1268       Expression                   : Node_Id;
1269       Pragmas_Before               : List_Id)
1270       return Node_Id;
1271    pragma Inline (Make_Mod_Clause);
1272
1273    function Make_Conditional_Expression (Sloc : Source_Ptr;
1274       Expressions                  : List_Id)
1275       return Node_Id;
1276    pragma Inline (Make_Conditional_Expression);
1277
1278    function Make_Expanded_Name (Sloc : Source_Ptr;
1279       Chars                        : Name_Id;
1280       Prefix                       : Node_Id;
1281       Selector_Name                : Node_Id)
1282       return Node_Id;
1283    pragma Inline (Make_Expanded_Name);
1284
1285    function Make_Free_Statement (Sloc : Source_Ptr;
1286       Expression                   : Node_Id)
1287       return Node_Id;
1288    pragma Inline (Make_Free_Statement);
1289
1290    function Make_Freeze_Entity (Sloc : Source_Ptr;
1291       Actions                      : List_Id := No_List)
1292       return Node_Id;
1293    pragma Inline (Make_Freeze_Entity);
1294
1295    function Make_Implicit_Label_Declaration (Sloc : Source_Ptr;
1296       Defining_Identifier          : Node_Id)
1297       return Node_Id;
1298    pragma Inline (Make_Implicit_Label_Declaration);
1299
1300    function Make_Itype_Reference (Sloc : Source_Ptr)
1301       return Node_Id;
1302    pragma Inline (Make_Itype_Reference);
1303
1304    function Make_Raise_Constraint_Error (Sloc : Source_Ptr;
1305       Condition                    : Node_Id := Empty;
1306       Reason                       : Uint)
1307       return Node_Id;
1308    pragma Inline (Make_Raise_Constraint_Error);
1309
1310    function Make_Raise_Program_Error (Sloc : Source_Ptr;
1311       Condition                    : Node_Id := Empty;
1312       Reason                       : Uint)
1313       return Node_Id;
1314    pragma Inline (Make_Raise_Program_Error);
1315
1316    function Make_Raise_Storage_Error (Sloc : Source_Ptr;
1317       Condition                    : Node_Id := Empty;
1318       Reason                       : Uint)
1319       return Node_Id;
1320    pragma Inline (Make_Raise_Storage_Error);
1321
1322    function Make_Reference (Sloc : Source_Ptr;
1323       Prefix                       : Node_Id)
1324       return Node_Id;
1325    pragma Inline (Make_Reference);
1326
1327    function Make_Subprogram_Info (Sloc : Source_Ptr;
1328       Identifier                   : Node_Id)
1329       return Node_Id;
1330    pragma Inline (Make_Subprogram_Info);
1331
1332    function Make_Unchecked_Expression (Sloc : Source_Ptr;
1333       Expression                   : Node_Id)
1334       return Node_Id;
1335    pragma Inline (Make_Unchecked_Expression);
1336
1337    function Make_Unchecked_Type_Conversion (Sloc : Source_Ptr;
1338       Subtype_Mark                 : Node_Id;
1339       Expression                   : Node_Id)
1340       return Node_Id;
1341    pragma Inline (Make_Unchecked_Type_Conversion);
1342
1343    function Make_Validate_Unchecked_Conversion (Sloc : Source_Ptr)
1344       return Node_Id;
1345    pragma Inline (Make_Validate_Unchecked_Conversion);
1346
1347 end Nmake;