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 --                 Generated by xnmake revision 1.29 using                  --
  10 --                         sinfo.ads revision 1.439                         --
  11 --                         nmake.adt revision 1.12                          --
  12 --                                                                          --
  13 --          Copyright (C) 1992-2001 Free Software Foundation, Inc.          --
  14 --                                                                          --
  15 -- GNAT is free software;  you can  redistribute it  and/or modify it under --
  16 -- terms of the  GNU General Public License as published  by the Free Soft- --
  17 -- ware  Foundation;  either version 2,  or (at your option) any later ver- --
  18 -- sion.  GNAT is distributed in the hope that it will be useful, but WITH- --
  19 -- OUT ANY WARRANTY;  without even the  implied warranty of MERCHANTABILITY --
  20 -- or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License --
  21 -- for  more details.  You should have  received  a copy of the GNU General --
  22 -- Public License  distributed with GNAT;  see file COPYING.  If not, write --
  23 -- to  the Free Software Foundation,  59 Temple Place - Suite 330,  Boston, --
  24 -- MA 02111-1307, USA.                                                      --
  25 --                                                                          --
  26 -- GNAT was originally developed  by the GNAT team at  New York University. --
  27 -- Extensive contributions were provided by Ada Core Technologies Inc.      --
  28 --                                                                          --
  29 ------------------------------------------------------------------------------
  30
  31 pragma Style_Checks (All_Checks);
  32 --  Turn off subprogram order checking, since the routines here are
  33 --  generated automatically in order.
  34
  35
  36 with Nlists; use Nlists;
  37 with Types;  use Types;
  38 with Uintp;  use Uintp;
  39 with Urealp; use Urealp;
  40
  41 package Nmake is
  42
  43 --  This package contains a set of routines used to construct tree nodes
  44 --  using a functional style. There is one routine for each node type defined
  45 --  in Sinfo with the general interface:
  46
  47 --    function Make_xxx (Sloc : Source_Ptr,
  48 --                       Field_Name_1 : Field_Name_1_Type [:= default]
  49 --                       Field_Name_2 : Field_Name_2_Type [:= default]
  50 --                       ...)
  51 --    return Node_Id
  52
  53 --  Only syntactic fields are included (i.e. fields marked as "-Sem" or "-Lib"
  54 --  in the Sinfo spec are excluded). In addition, the following four syntactic
  55 --  fields are excluded:
  56
  57 --    Prev_Ids
  58 --    More_Ids
  59 --    Comes_From_Source
  60 --    Paren_Count
  61
  62 --  since they are very rarely set in expanded code. If they need to be set,
  63 --  to other than the default values (False, False, False, zero), then the
  64 --  appropriate Set_xxx procedures must be used on the returned value.
  65
  66 --  Default values are provided only for flag fields (where the default is
  67 --  False), and for optional fields. An optional field is one where the
  68 --  comment line describing the field contains the string "(set to xxx if".
  69 --  For such fields, a default value of xxx is provided."
  70
  71 --  Warning: since calls to Make_xxx routines are normal function calls, the
  72 --  arguments can be evaluated in any order. This means that at most one such
  73 --  argument can have side effects (e.g. be a call to a parse routine).
  74
  75    function Make_Unused_At_Start (Sloc : Source_Ptr)
  76       return Node_Id;
  77    pragma Inline (Make_Unused_At_Start);
  78
  79    function Make_Unused_At_End (Sloc : Source_Ptr)
  80       return Node_Id;
  81    pragma Inline (Make_Unused_At_End);
  82
  83    function Make_Identifier (Sloc : Source_Ptr;
  84       Chars                        : Name_Id)
  85       return Node_Id;
  86    pragma Inline (Make_Identifier);
  87
  88    function Make_Integer_Literal (Sloc : Source_Ptr;
  89       Intval                       : Uint)
  90       return Node_Id;
  91    pragma Inline (Make_Integer_Literal);
  92
  93    function Make_Real_Literal (Sloc : Source_Ptr;
  94       Realval                      : Ureal)
  95       return Node_Id;
  96    pragma Inline (Make_Real_Literal);
  97
  98    function Make_Character_Literal (Sloc : Source_Ptr;
  99       Chars                        : Name_Id;
 100       Char_Literal_Value           : Char_Code)
 101       return Node_Id;
 102    pragma Inline (Make_Character_Literal);
 103
 104    function Make_String_Literal (Sloc : Source_Ptr;
 105       Strval                       : String_Id)
 106       return Node_Id;
 107    pragma Inline (Make_String_Literal);
 108
 109    function Make_Pragma (Sloc : Source_Ptr;
 110       Chars                        : Name_Id;
 111       Pragma_Argument_Associations : List_Id := No_List;
 112       Debug_Statement              : Node_Id := Empty)
 113       return Node_Id;
 114    pragma Inline (Make_Pragma);
 115
 116    function Make_Pragma_Argument_Association (Sloc : Source_Ptr;
 117       Chars                        : Name_Id := No_Name;
 118       Expression                   : Node_Id)
 119       return Node_Id;
 120    pragma Inline (Make_Pragma_Argument_Association);
 121
 122    function Make_Defining_Identifier (Sloc : Source_Ptr;
 123       Chars                        : Name_Id)
 124       return Node_Id;
 125    pragma Inline (Make_Defining_Identifier);
 126
 127    function Make_Full_Type_Declaration (Sloc : Source_Ptr;
 128       Defining_Identifier          : Node_Id;
 129       Discriminant_Specifications  : List_Id := No_List;
 130       Type_Definition              : Node_Id)
 131       return Node_Id;
 132    pragma Inline (Make_Full_Type_Declaration);
 133
 134    function Make_Subtype_Declaration (Sloc : Source_Ptr;
 135       Defining_Identifier          : Node_Id;
 136       Subtype_Indication           : Node_Id)
 137       return Node_Id;
 138    pragma Inline (Make_Subtype_Declaration);
 139
 140    function Make_Subtype_Indication (Sloc : Source_Ptr;
 141       Subtype_Mark                 : Node_Id;
 142       Constraint                   : Node_Id)
 143       return Node_Id;
 144    pragma Inline (Make_Subtype_Indication);
 145
 146    function Make_Object_Declaration (Sloc : Source_Ptr;
 147       Defining_Identifier          : Node_Id;
 148       Aliased_Present              : Boolean := False;
 149       Constant_Present             : Boolean := False;
 150       Object_Definition            : Node_Id;
 151       Expression                   : Node_Id := Empty)
 152       return Node_Id;
 153    pragma Inline (Make_Object_Declaration);
 154
 155    function Make_Number_Declaration (Sloc : Source_Ptr;
 156       Defining_Identifier          : Node_Id;
 157       Expression                   : Node_Id)
 158       return Node_Id;
 159    pragma Inline (Make_Number_Declaration);
 160
 161    function Make_Derived_Type_Definition (Sloc : Source_Ptr;
 162       Abstract_Present             : Boolean := False;
 163       Subtype_Indication           : Node_Id;
 164       Record_Extension_Part        : Node_Id := Empty)
 165       return Node_Id;
 166    pragma Inline (Make_Derived_Type_Definition);
 167
 168    function Make_Range_Constraint (Sloc : Source_Ptr;
 169       Range_Expression             : Node_Id)
 170       return Node_Id;
 171    pragma Inline (Make_Range_Constraint);
 172
 173    function Make_Range (Sloc : Source_Ptr;
 174       Low_Bound                    : Node_Id;
 175       High_Bound                   : Node_Id;
 176       Includes_Infinities          : Boolean := False)
 177       return Node_Id;
 178    pragma Inline (Make_Range);
 179
 180    function Make_Enumeration_Type_Definition (Sloc : Source_Ptr;
 181       Literals                     : List_Id;
 182       End_Label                    : Node_Id := Empty)
 183       return Node_Id;
 184    pragma Inline (Make_Enumeration_Type_Definition);
 185
 186    function Make_Defining_Character_Literal (Sloc : Source_Ptr;
 187       Chars                        : Name_Id)
 188       return Node_Id;
 189    pragma Inline (Make_Defining_Character_Literal);
 190
 191    function Make_Signed_Integer_Type_Definition (Sloc : Source_Ptr;
 192       Low_Bound                    : Node_Id;
 193       High_Bound                   : Node_Id)
 194       return Node_Id;
 195    pragma Inline (Make_Signed_Integer_Type_Definition);
 196
 197    function Make_Modular_Type_Definition (Sloc : Source_Ptr;
 198       Expression                   : Node_Id)
 199       return Node_Id;
 200    pragma Inline (Make_Modular_Type_Definition);
 201
 202    function Make_Floating_Point_Definition (Sloc : Source_Ptr;
 203       Digits_Expression            : Node_Id;
 204       Real_Range_Specification     : Node_Id := Empty)
 205       return Node_Id;
 206    pragma Inline (Make_Floating_Point_Definition);
 207
 208    function Make_Real_Range_Specification (Sloc : Source_Ptr;
 209       Low_Bound                    : Node_Id;
 210       High_Bound                   : Node_Id)
 211       return Node_Id;
 212    pragma Inline (Make_Real_Range_Specification);
 213
 214    function Make_Ordinary_Fixed_Point_Definition (Sloc : Source_Ptr;
 215       Delta_Expression             : Node_Id;
 216       Real_Range_Specification     : Node_Id)
 217       return Node_Id;
 218    pragma Inline (Make_Ordinary_Fixed_Point_Definition);
 219
 220    function Make_Decimal_Fixed_Point_Definition (Sloc : Source_Ptr;
 221       Delta_Expression             : Node_Id;
 222       Digits_Expression            : Node_Id;
 223       Real_Range_Specification     : Node_Id := Empty)
 224       return Node_Id;
 225    pragma Inline (Make_Decimal_Fixed_Point_Definition);
 226
 227    function Make_Digits_Constraint (Sloc : Source_Ptr;
 228       Digits_Expression            : Node_Id;
 229       Range_Constraint             : Node_Id := Empty)
 230       return Node_Id;
 231    pragma Inline (Make_Digits_Constraint);
 232
 233    function Make_Unconstrained_Array_Definition (Sloc : Source_Ptr;
 234       Subtype_Marks                : List_Id;
 235       Aliased_Present              : Boolean := False;
 236       Subtype_Indication           : Node_Id)
 237       return Node_Id;
 238    pragma Inline (Make_Unconstrained_Array_Definition);
 239
 240    function Make_Constrained_Array_Definition (Sloc : Source_Ptr;
 241       Discrete_Subtype_Definitions : List_Id;
 242       Aliased_Present              : Boolean := False;
 243       Subtype_Indication           : Node_Id)
 244       return Node_Id;
 245    pragma Inline (Make_Constrained_Array_Definition);
 246
 247    function Make_Discriminant_Specification (Sloc : Source_Ptr;
 248       Defining_Identifier          : Node_Id;
 249       Discriminant_Type            : Node_Id;
 250       Expression                   : Node_Id := Empty)
 251       return Node_Id;
 252    pragma Inline (Make_Discriminant_Specification);
 253
 254    function Make_Index_Or_Discriminant_Constraint (Sloc : Source_Ptr;
 255       Constraints                  : List_Id)
 256       return Node_Id;
 257    pragma Inline (Make_Index_Or_Discriminant_Constraint);
 258
 259    function Make_Discriminant_Association (Sloc : Source_Ptr;
 260       Selector_Names               : List_Id;
 261       Expression                   : Node_Id)
 262       return Node_Id;
 263    pragma Inline (Make_Discriminant_Association);
 264
 265    function Make_Record_Definition (Sloc : Source_Ptr;
 266       End_Label                    : Node_Id := Empty;
 267       Abstract_Present             : Boolean := False;
 268       Tagged_Present               : Boolean := False;
 269       Limited_Present              : Boolean := False;
 270       Component_List               : Node_Id;
 271       Null_Present                 : Boolean := False)
 272       return Node_Id;
 273    pragma Inline (Make_Record_Definition);
 274
 275    function Make_Component_List (Sloc : Source_Ptr;
 276       Component_Items              : List_Id;
 277       Variant_Part                 : Node_Id := Empty;
 278       Null_Present                 : Boolean := False)
 279       return Node_Id;
 280    pragma Inline (Make_Component_List);
 281
 282    function Make_Component_Declaration (Sloc : Source_Ptr;
 283       Defining_Identifier          : Node_Id;
 284       Aliased_Present              : Boolean := False;
 285       Subtype_Indication           : Node_Id;
 286       Expression                   : Node_Id := Empty)
 287       return Node_Id;
 288    pragma Inline (Make_Component_Declaration);
 289
 290    function Make_Variant_Part (Sloc : Source_Ptr;
 291       Name                         : Node_Id;
 292       Variants                     : List_Id)
 293       return Node_Id;
 294    pragma Inline (Make_Variant_Part);
 295
 296    function Make_Variant (Sloc : Source_Ptr;
 297       Discrete_Choices             : List_Id;
 298       Component_List               : Node_Id)
 299       return Node_Id;
 300    pragma Inline (Make_Variant);
 301
 302    function Make_Others_Choice (Sloc : Source_Ptr)
 303       return Node_Id;
 304    pragma Inline (Make_Others_Choice);
 305
 306    function Make_Access_To_Object_Definition (Sloc : Source_Ptr;
 307       All_Present                  : Boolean := False;
 308       Subtype_Indication           : Node_Id;
 309       Constant_Present             : Boolean := False)
 310       return Node_Id;
 311    pragma Inline (Make_Access_To_Object_Definition);
 312
 313    function Make_Access_Function_Definition (Sloc : Source_Ptr;
 314       Protected_Present            : Boolean := False;
 315       Parameter_Specifications     : List_Id := No_List;
 316       Subtype_Mark                 : Node_Id)
 317       return Node_Id;
 318    pragma Inline (Make_Access_Function_Definition);
 319
 320    function Make_Access_Procedure_Definition (Sloc : Source_Ptr;
 321       Protected_Present            : Boolean := False;
 322       Parameter_Specifications     : List_Id := No_List)
 323       return Node_Id;
 324    pragma Inline (Make_Access_Procedure_Definition);
 325
 326    function Make_Access_Definition (Sloc : Source_Ptr;
 327       Subtype_Mark                 : Node_Id)
 328       return Node_Id;
 329    pragma Inline (Make_Access_Definition);
 330
 331    function Make_Incomplete_Type_Declaration (Sloc : Source_Ptr;
 332       Defining_Identifier          : Node_Id;
 333       Discriminant_Specifications  : List_Id := No_List;
 334       Unknown_Discriminants_Present : Boolean := False)
 335       return Node_Id;
 336    pragma Inline (Make_Incomplete_Type_Declaration);
 337
 338    function Make_Explicit_Dereference (Sloc : Source_Ptr;
 339       Prefix                       : Node_Id)
 340       return Node_Id;
 341    pragma Inline (Make_Explicit_Dereference);
 342
 343    function Make_Indexed_Component (Sloc : Source_Ptr;
 344       Prefix                       : Node_Id;
 345       Expressions                  : List_Id)
 346       return Node_Id;
 347    pragma Inline (Make_Indexed_Component);
 348
 349    function Make_Slice (Sloc : Source_Ptr;
 350       Prefix                       : Node_Id;
 351       Discrete_Range               : Node_Id)
 352       return Node_Id;
 353    pragma Inline (Make_Slice);
 354
 355    function Make_Selected_Component (Sloc : Source_Ptr;
 356       Prefix                       : Node_Id;
 357       Selector_Name                : Node_Id)
 358       return Node_Id;
 359    pragma Inline (Make_Selected_Component);
 360
 361    function Make_Attribute_Reference (Sloc : Source_Ptr;
 362       Prefix                       : Node_Id;
 363       Attribute_Name               : Name_Id;
 364       Expressions                  : List_Id := No_List;
 365       Must_Be_Byte_Aligned         : Boolean := False)
 366       return Node_Id;
 367    pragma Inline (Make_Attribute_Reference);
 368
 369    function Make_Aggregate (Sloc : Source_Ptr;
 370       Expressions                  : List_Id := No_List;
 371       Component_Associations       : List_Id := No_List;
 372       Null_Record_Present          : Boolean := False)
 373       return Node_Id;
 374    pragma Inline (Make_Aggregate);
 375
 376    function Make_Component_Association (Sloc : Source_Ptr;
 377       Choices                      : List_Id;
 378       Expression                   : Node_Id)
 379       return Node_Id;
 380    pragma Inline (Make_Component_Association);
 381
 382    function Make_Extension_Aggregate (Sloc : Source_Ptr;
 383       Ancestor_Part                : Node_Id;
 384       Expressions                  : List_Id := No_List;
 385       Component_Associations       : List_Id := No_List;
 386       Null_Record_Present          : Boolean := False)
 387       return Node_Id;
 388    pragma Inline (Make_Extension_Aggregate);
 389
 390    function Make_Null (Sloc : Source_Ptr)
 391       return Node_Id;
 392    pragma Inline (Make_Null);
 393
 394    function Make_And_Then (Sloc : Source_Ptr;
 395       Left_Opnd                    : Node_Id;
 396       Right_Opnd                   : Node_Id)
 397       return Node_Id;
 398    pragma Inline (Make_And_Then);
 399
 400    function Make_Or_Else (Sloc : Source_Ptr;
 401       Left_Opnd                    : Node_Id;
 402       Right_Opnd                   : Node_Id)
 403       return Node_Id;
 404    pragma Inline (Make_Or_Else);
 405
 406    function Make_In (Sloc : Source_Ptr;
 407       Left_Opnd                    : Node_Id;
 408       Right_Opnd                   : Node_Id)
 409       return Node_Id;
 410    pragma Inline (Make_In);
 411
 412    function Make_Not_In (Sloc : Source_Ptr;
 413       Left_Opnd                    : Node_Id;
 414       Right_Opnd                   : Node_Id)
 415       return Node_Id;
 416    pragma Inline (Make_Not_In);
 417
 418    function Make_Op_And (Sloc : Source_Ptr;
 419       Left_Opnd                    : Node_Id;
 420       Right_Opnd                   : Node_Id)
 421       return Node_Id;
 422    pragma Inline (Make_Op_And);
 423
 424    function Make_Op_Or (Sloc : Source_Ptr;
 425       Left_Opnd                    : Node_Id;
 426       Right_Opnd                   : Node_Id)
 427       return Node_Id;
 428    pragma Inline (Make_Op_Or);
 429
 430    function Make_Op_Xor (Sloc : Source_Ptr;
 431       Left_Opnd                    : Node_Id;
 432       Right_Opnd                   : Node_Id)
 433       return Node_Id;
 434    pragma Inline (Make_Op_Xor);
 435
 436    function Make_Op_Eq (Sloc : Source_Ptr;
 437       Left_Opnd                    : Node_Id;
 438       Right_Opnd                   : Node_Id)
 439       return Node_Id;
 440    pragma Inline (Make_Op_Eq);
 441
 442    function Make_Op_Ne (Sloc : Source_Ptr;
 443       Left_Opnd                    : Node_Id;
 444       Right_Opnd                   : Node_Id)
 445       return Node_Id;
 446    pragma Inline (Make_Op_Ne);
 447
 448    function Make_Op_Lt (Sloc : Source_Ptr;
 449       Left_Opnd                    : Node_Id;
 450       Right_Opnd                   : Node_Id)
 451       return Node_Id;
 452    pragma Inline (Make_Op_Lt);
 453
 454    function Make_Op_Le (Sloc : Source_Ptr;
 455       Left_Opnd                    : Node_Id;
 456       Right_Opnd                   : Node_Id)
 457       return Node_Id;
 458    pragma Inline (Make_Op_Le);
 459
 460    function Make_Op_Gt (Sloc : Source_Ptr;
 461       Left_Opnd                    : Node_Id;
 462       Right_Opnd                   : Node_Id)
 463       return Node_Id;
 464    pragma Inline (Make_Op_Gt);
 465
 466    function Make_Op_Ge (Sloc : Source_Ptr;
 467       Left_Opnd                    : Node_Id;
 468       Right_Opnd                   : Node_Id)
 469       return Node_Id;
 470    pragma Inline (Make_Op_Ge);
 471
 472    function Make_Op_Add (Sloc : Source_Ptr;
 473       Left_Opnd                    : Node_Id;
 474       Right_Opnd                   : Node_Id)
 475       return Node_Id;
 476    pragma Inline (Make_Op_Add);
 477
 478    function Make_Op_Subtract (Sloc : Source_Ptr;
 479       Left_Opnd                    : Node_Id;
 480       Right_Opnd                   : Node_Id)
 481       return Node_Id;
 482    pragma Inline (Make_Op_Subtract);
 483
 484    function Make_Op_Concat (Sloc : Source_Ptr;
 485       Left_Opnd                    : Node_Id;
 486       Right_Opnd                   : Node_Id)
 487       return Node_Id;
 488    pragma Inline (Make_Op_Concat);
 489
 490    function Make_Op_Multiply (Sloc : Source_Ptr;
 491       Left_Opnd                    : Node_Id;
 492       Right_Opnd                   : Node_Id)
 493       return Node_Id;
 494    pragma Inline (Make_Op_Multiply);
 495
 496    function Make_Op_Divide (Sloc : Source_Ptr;
 497       Left_Opnd                    : Node_Id;
 498       Right_Opnd                   : Node_Id)
 499       return Node_Id;
 500    pragma Inline (Make_Op_Divide);
 501
 502    function Make_Op_Mod (Sloc : Source_Ptr;
 503       Left_Opnd                    : Node_Id;
 504       Right_Opnd                   : Node_Id)
 505       return Node_Id;
 506    pragma Inline (Make_Op_Mod);
 507
 508    function Make_Op_Rem (Sloc : Source_Ptr;
 509       Left_Opnd                    : Node_Id;
 510       Right_Opnd                   : Node_Id)
 511       return Node_Id;
 512    pragma Inline (Make_Op_Rem);
 513
 514    function Make_Op_Expon (Sloc : Source_Ptr;
 515       Left_Opnd                    : Node_Id;
 516       Right_Opnd                   : Node_Id)
 517       return Node_Id;
 518    pragma Inline (Make_Op_Expon);
 519
 520    function Make_Op_Plus (Sloc : Source_Ptr;
 521       Right_Opnd                   : Node_Id)
 522       return Node_Id;
 523    pragma Inline (Make_Op_Plus);
 524
 525    function Make_Op_Minus (Sloc : Source_Ptr;
 526       Right_Opnd                   : Node_Id)
 527       return Node_Id;
 528    pragma Inline (Make_Op_Minus);
 529
 530    function Make_Op_Abs (Sloc : Source_Ptr;
 531       Right_Opnd                   : Node_Id)
 532       return Node_Id;
 533    pragma Inline (Make_Op_Abs);
 534
 535    function Make_Op_Not (Sloc : Source_Ptr;
 536       Right_Opnd                   : Node_Id)
 537       return Node_Id;
 538    pragma Inline (Make_Op_Not);
 539
 540    function Make_Type_Conversion (Sloc : Source_Ptr;
 541       Subtype_Mark                 : Node_Id;
 542       Expression                   : Node_Id)
 543       return Node_Id;
 544    pragma Inline (Make_Type_Conversion);
 545
 546    function Make_Qualified_Expression (Sloc : Source_Ptr;
 547       Subtype_Mark                 : Node_Id;
 548       Expression                   : Node_Id)
 549       return Node_Id;
 550    pragma Inline (Make_Qualified_Expression);
 551
 552    function Make_Allocator (Sloc : Source_Ptr;
 553       Expression                   : Node_Id)
 554       return Node_Id;
 555    pragma Inline (Make_Allocator);
 556
 557    function Make_Null_Statement (Sloc : Source_Ptr)
 558       return Node_Id;
 559    pragma Inline (Make_Null_Statement);
 560
 561    function Make_Label (Sloc : Source_Ptr;
 562       Identifier                   : Node_Id)
 563       return Node_Id;
 564    pragma Inline (Make_Label);
 565
 566    function Make_Assignment_Statement (Sloc : Source_Ptr;
 567       Name                         : Node_Id;
 568       Expression                   : Node_Id)
 569       return Node_Id;
 570    pragma Inline (Make_Assignment_Statement);
 571
 572    function Make_If_Statement (Sloc : Source_Ptr;
 573       Condition                    : Node_Id;
 574       Then_Statements              : List_Id;
 575       Elsif_Parts                  : List_Id := No_List;
 576       Else_Statements              : List_Id := No_List;
 577       End_Span                     : Uint := No_Uint)
 578       return Node_Id;
 579    pragma Inline (Make_If_Statement);
 580
 581    function Make_Elsif_Part (Sloc : Source_Ptr;
 582       Condition                    : Node_Id;
 583       Then_Statements              : List_Id)
 584       return Node_Id;
 585    pragma Inline (Make_Elsif_Part);
 586
 587    function Make_Case_Statement (Sloc : Source_Ptr;
 588       Expression                   : Node_Id;
 589       Alternatives                 : List_Id;
 590       End_Span                     : Uint := No_Uint)
 591       return Node_Id;
 592    pragma Inline (Make_Case_Statement);
 593
 594    function Make_Case_Statement_Alternative (Sloc : Source_Ptr;
 595       Discrete_Choices             : List_Id;
 596       Statements                   : List_Id)
 597       return Node_Id;
 598    pragma Inline (Make_Case_Statement_Alternative);
 599
 600    function Make_Loop_Statement (Sloc : Source_Ptr;
 601       Identifier                   : Node_Id := Empty;
 602       Iteration_Scheme             : Node_Id := Empty;
 603       Statements                   : List_Id;
 604       End_Label                    : Node_Id;
 605       Has_Created_Identifier       : Boolean := False)
 606       return Node_Id;
 607    pragma Inline (Make_Loop_Statement);
 608
 609    function Make_Iteration_Scheme (Sloc : Source_Ptr;
 610       Condition                    : Node_Id := Empty;
 611       Loop_Parameter_Specification : Node_Id := Empty)
 612       return Node_Id;
 613    pragma Inline (Make_Iteration_Scheme);
 614
 615    function Make_Loop_Parameter_Specification (Sloc : Source_Ptr;
 616       Defining_Identifier          : Node_Id;
 617       Reverse_Present              : Boolean := False;
 618       Discrete_Subtype_Definition  : Node_Id)
 619       return Node_Id;
 620    pragma Inline (Make_Loop_Parameter_Specification);
 621
 622    function Make_Block_Statement (Sloc : Source_Ptr;
 623       Identifier                   : Node_Id := Empty;
 624       Declarations                 : List_Id := No_List;
 625       Handled_Statement_Sequence   : Node_Id;
 626       Has_Created_Identifier       : Boolean := False;
 627       Is_Task_Allocation_Block     : Boolean := False;
 628       Is_Asynchronous_Call_Block   : Boolean := False)
 629       return Node_Id;
 630    pragma Inline (Make_Block_Statement);
 631
 632    function Make_Exit_Statement (Sloc : Source_Ptr;
 633       Name                         : Node_Id := Empty;
 634       Condition                    : Node_Id := Empty)
 635       return Node_Id;
 636    pragma Inline (Make_Exit_Statement);
 637
 638    function Make_Goto_Statement (Sloc : Source_Ptr;
 639       Name                         : Node_Id)
 640       return Node_Id;
 641    pragma Inline (Make_Goto_Statement);
 642
 643    function Make_Subprogram_Declaration (Sloc : Source_Ptr;
 644       Specification                : Node_Id)
 645       return Node_Id;
 646    pragma Inline (Make_Subprogram_Declaration);
 647
 648    function Make_Abstract_Subprogram_Declaration (Sloc : Source_Ptr;
 649       Specification                : Node_Id)
 650       return Node_Id;
 651    pragma Inline (Make_Abstract_Subprogram_Declaration);
 652
 653    function Make_Function_Specification (Sloc : Source_Ptr;
 654       Defining_Unit_Name           : Node_Id;
 655       Parameter_Specifications     : List_Id := No_List;
 656       Subtype_Mark                 : Node_Id)
 657       return Node_Id;
 658    pragma Inline (Make_Function_Specification);
 659
 660    function Make_Procedure_Specification (Sloc : Source_Ptr;
 661       Defining_Unit_Name           : Node_Id;
 662       Parameter_Specifications     : List_Id := No_List)
 663       return Node_Id;
 664    pragma Inline (Make_Procedure_Specification);
 665
 666    function Make_Designator (Sloc : Source_Ptr;
 667       Name                         : Node_Id;
 668       Identifier                   : Node_Id)
 669       return Node_Id;
 670    pragma Inline (Make_Designator);
 671
 672    function Make_Defining_Program_Unit_Name (Sloc : Source_Ptr;
 673       Name                         : Node_Id;
 674       Defining_Identifier          : Node_Id)
 675       return Node_Id;
 676    pragma Inline (Make_Defining_Program_Unit_Name);
 677
 678    function Make_Operator_Symbol (Sloc : Source_Ptr;
 679       Chars                        : Name_Id;
 680       Strval                       : String_Id)
 681       return Node_Id;
 682    pragma Inline (Make_Operator_Symbol);
 683
 684    function Make_Defining_Operator_Symbol (Sloc : Source_Ptr;
 685       Chars                        : Name_Id)
 686       return Node_Id;
 687    pragma Inline (Make_Defining_Operator_Symbol);
 688
 689    function Make_Parameter_Specification (Sloc : Source_Ptr;
 690       Defining_Identifier          : Node_Id;
 691       In_Present                   : Boolean := False;
 692       Out_Present                  : Boolean := False;
 693       Parameter_Type               : Node_Id;
 694       Expression                   : Node_Id := Empty)
 695       return Node_Id;
 696    pragma Inline (Make_Parameter_Specification);
 697
 698    function Make_Subprogram_Body (Sloc : Source_Ptr;
 699       Specification                : Node_Id;
 700       Declarations                 : List_Id;
 701       Handled_Statement_Sequence   : Node_Id;
 702       Bad_Is_Detected              : Boolean := False)
 703       return Node_Id;
 704    pragma Inline (Make_Subprogram_Body);
 705
 706    function Make_Procedure_Call_Statement (Sloc : Source_Ptr;
 707       Name                         : Node_Id;
 708       Parameter_Associations       : List_Id := No_List)
 709       return Node_Id;
 710    pragma Inline (Make_Procedure_Call_Statement);
 711
 712    function Make_Function_Call (Sloc : Source_Ptr;
 713       Name                         : Node_Id;
 714       Parameter_Associations       : List_Id := No_List)
 715       return Node_Id;
 716    pragma Inline (Make_Function_Call);
 717
 718    function Make_Parameter_Association (Sloc : Source_Ptr;
 719       Selector_Name                : Node_Id;
 720       Explicit_Actual_Parameter    : Node_Id)
 721       return Node_Id;
 722    pragma Inline (Make_Parameter_Association);
 723
 724    function Make_Return_Statement (Sloc : Source_Ptr;
 725       Expression                   : Node_Id := Empty)
 726       return Node_Id;
 727    pragma Inline (Make_Return_Statement);
 728
 729    function Make_Package_Declaration (Sloc : Source_Ptr;
 730       Specification                : Node_Id)
 731       return Node_Id;
 732    pragma Inline (Make_Package_Declaration);
 733
 734    function Make_Package_Specification (Sloc : Source_Ptr;
 735       Defining_Unit_Name           : Node_Id;
 736       Visible_Declarations         : List_Id;
 737       Private_Declarations         : List_Id := No_List;
 738       End_Label                    : Node_Id)
 739       return Node_Id;
 740    pragma Inline (Make_Package_Specification);
 741
 742    function Make_Package_Body (Sloc : Source_Ptr;
 743       Defining_Unit_Name           : Node_Id;
 744       Declarations                 : List_Id;
 745       Handled_Statement_Sequence   : Node_Id := Empty)
 746       return Node_Id;
 747    pragma Inline (Make_Package_Body);
 748
 749    function Make_Private_Type_Declaration (Sloc : Source_Ptr;
 750       Defining_Identifier          : Node_Id;
 751       Discriminant_Specifications  : List_Id := No_List;
 752       Unknown_Discriminants_Present : Boolean := False;
 753       Abstract_Present             : Boolean := False;
 754       Tagged_Present               : Boolean := False;
 755       Limited_Present              : Boolean := False)
 756       return Node_Id;
 757    pragma Inline (Make_Private_Type_Declaration);
 758
 759    function Make_Private_Extension_Declaration (Sloc : Source_Ptr;
 760       Defining_Identifier          : Node_Id;
 761       Discriminant_Specifications  : List_Id := No_List;
 762       Unknown_Discriminants_Present : Boolean := False;
 763       Abstract_Present             : Boolean := False;
 764       Subtype_Indication           : Node_Id)
 765       return Node_Id;
 766    pragma Inline (Make_Private_Extension_Declaration);
 767
 768    function Make_Use_Package_Clause (Sloc : Source_Ptr;
 769       Names                        : List_Id)
 770       return Node_Id;
 771    pragma Inline (Make_Use_Package_Clause);
 772
 773    function Make_Use_Type_Clause (Sloc : Source_Ptr;
 774       Subtype_Marks                : List_Id)
 775       return Node_Id;
 776    pragma Inline (Make_Use_Type_Clause);
 777
 778    function Make_Object_Renaming_Declaration (Sloc : Source_Ptr;
 779       Defining_Identifier          : Node_Id;
 780       Subtype_Mark                 : Node_Id;
 781       Name                         : Node_Id)
 782       return Node_Id;
 783    pragma Inline (Make_Object_Renaming_Declaration);
 784
 785    function Make_Exception_Renaming_Declaration (Sloc : Source_Ptr;
 786       Defining_Identifier          : Node_Id;
 787       Name                         : Node_Id)
 788       return Node_Id;
 789    pragma Inline (Make_Exception_Renaming_Declaration);
 790
 791    function Make_Package_Renaming_Declaration (Sloc : Source_Ptr;
 792       Defining_Unit_Name           : Node_Id;
 793       Name                         : Node_Id)
 794       return Node_Id;
 795    pragma Inline (Make_Package_Renaming_Declaration);
 796
 797    function Make_Subprogram_Renaming_Declaration (Sloc : Source_Ptr;
 798       Specification                : Node_Id;
 799       Name                         : Node_Id)
 800       return Node_Id;
 801    pragma Inline (Make_Subprogram_Renaming_Declaration);
 802
 803    function Make_Generic_Package_Renaming_Declaration (Sloc : Source_Ptr;
 804       Defining_Unit_Name           : Node_Id;
 805       Name                         : Node_Id)
 806       return Node_Id;
 807    pragma Inline (Make_Generic_Package_Renaming_Declaration);
 808
 809    function Make_Generic_Procedure_Renaming_Declaration (Sloc : Source_Ptr;
 810       Defining_Unit_Name           : Node_Id;
 811       Name                         : Node_Id)
 812       return Node_Id;
 813    pragma Inline (Make_Generic_Procedure_Renaming_Declaration);
 814
 815    function Make_Generic_Function_Renaming_Declaration (Sloc : Source_Ptr;
 816       Defining_Unit_Name           : Node_Id;
 817       Name                         : Node_Id)
 818       return Node_Id;
 819    pragma Inline (Make_Generic_Function_Renaming_Declaration);
 820
 821    function Make_Task_Type_Declaration (Sloc : Source_Ptr;
 822       Defining_Identifier          : Node_Id;
 823       Discriminant_Specifications  : List_Id := No_List;
 824       Task_Definition              : Node_Id := Empty)
 825       return Node_Id;
 826    pragma Inline (Make_Task_Type_Declaration);
 827
 828    function Make_Single_Task_Declaration (Sloc : Source_Ptr;
 829       Defining_Identifier          : Node_Id;
 830       Task_Definition              : Node_Id := Empty)
 831       return Node_Id;
 832    pragma Inline (Make_Single_Task_Declaration);
 833
 834    function Make_Task_Definition (Sloc : Source_Ptr;
 835       Visible_Declarations         : List_Id;
 836       Private_Declarations         : List_Id := No_List;
 837       End_Label                    : Node_Id)
 838       return Node_Id;
 839    pragma Inline (Make_Task_Definition);
 840
 841    function Make_Task_Body (Sloc : Source_Ptr;
 842       Defining_Identifier          : Node_Id;
 843       Declarations                 : List_Id;
 844       Handled_Statement_Sequence   : Node_Id)
 845       return Node_Id;
 846    pragma Inline (Make_Task_Body);
 847
 848    function Make_Protected_Type_Declaration (Sloc : Source_Ptr;
 849       Defining_Identifier          : Node_Id;
 850       Discriminant_Specifications  : List_Id := No_List;
 851       Protected_Definition         : Node_Id)
 852       return Node_Id;
 853    pragma Inline (Make_Protected_Type_Declaration);
 854
 855    function Make_Single_Protected_Declaration (Sloc : Source_Ptr;
 856       Defining_Identifier          : Node_Id;
 857       Protected_Definition         : Node_Id)
 858       return Node_Id;
 859    pragma Inline (Make_Single_Protected_Declaration);
 860
 861    function Make_Protected_Definition (Sloc : Source_Ptr;
 862       Visible_Declarations         : List_Id;
 863       Private_Declarations         : List_Id := No_List;
 864       End_Label                    : Node_Id)
 865       return Node_Id;
 866    pragma Inline (Make_Protected_Definition);
 867
 868    function Make_Protected_Body (Sloc : Source_Ptr;
 869       Defining_Identifier          : Node_Id;
 870       Declarations                 : List_Id;
 871       End_Label                    : Node_Id)
 872       return Node_Id;
 873    pragma Inline (Make_Protected_Body);
 874
 875    function Make_Entry_Declaration (Sloc : Source_Ptr;
 876       Defining_Identifier          : Node_Id;
 877       Discrete_Subtype_Definition  : Node_Id := Empty;
 878       Parameter_Specifications     : List_Id := No_List)
 879       return Node_Id;
 880    pragma Inline (Make_Entry_Declaration);
 881
 882    function Make_Accept_Statement (Sloc : Source_Ptr;
 883       Entry_Direct_Name            : Node_Id;
 884       Entry_Index                  : Node_Id := Empty;
 885       Parameter_Specifications     : List_Id := No_List;
 886       Handled_Statement_Sequence   : Node_Id;
 887       Declarations                 : List_Id := No_List)
 888       return Node_Id;
 889    pragma Inline (Make_Accept_Statement);
 890
 891    function Make_Entry_Body (Sloc : Source_Ptr;
 892       Defining_Identifier          : Node_Id;
 893       Entry_Body_Formal_Part       : Node_Id;
 894       Declarations                 : List_Id;
 895       Handled_Statement_Sequence   : Node_Id)
 896       return Node_Id;
 897    pragma Inline (Make_Entry_Body);
 898
 899    function Make_Entry_Body_Formal_Part (Sloc : Source_Ptr;
 900       Entry_Index_Specification    : Node_Id := Empty;
 901       Parameter_Specifications     : List_Id := No_List;
 902       Condition                    : Node_Id)
 903       return Node_Id;
 904    pragma Inline (Make_Entry_Body_Formal_Part);
 905
 906    function Make_Entry_Index_Specification (Sloc : Source_Ptr;
 907       Defining_Identifier          : Node_Id;
 908       Discrete_Subtype_Definition  : Node_Id)
 909       return Node_Id;
 910    pragma Inline (Make_Entry_Index_Specification);
 911
 912    function Make_Entry_Call_Statement (Sloc : Source_Ptr;
 913       Name                         : Node_Id;
 914       Parameter_Associations       : List_Id := No_List)
 915       return Node_Id;
 916    pragma Inline (Make_Entry_Call_Statement);
 917
 918    function Make_Requeue_Statement (Sloc : Source_Ptr;
 919       Name                         : Node_Id;
 920       Abort_Present                : Boolean := False)
 921       return Node_Id;
 922    pragma Inline (Make_Requeue_Statement);
 923
 924    function Make_Delay_Until_Statement (Sloc : Source_Ptr;
 925       Expression                   : Node_Id)
 926       return Node_Id;
 927    pragma Inline (Make_Delay_Until_Statement);
 928
 929    function Make_Delay_Relative_Statement (Sloc : Source_Ptr;
 930       Expression                   : Node_Id)
 931       return Node_Id;
 932    pragma Inline (Make_Delay_Relative_Statement);
 933
 934    function Make_Selective_Accept (Sloc : Source_Ptr;
 935       Select_Alternatives          : List_Id;
 936       Else_Statements              : List_Id := No_List)
 937       return Node_Id;
 938    pragma Inline (Make_Selective_Accept);
 939
 940    function Make_Accept_Alternative (Sloc : Source_Ptr;
 941       Accept_Statement             : Node_Id;
 942       Condition                    : Node_Id := Empty;
 943       Statements                   : List_Id := Empty_List;
 944       Pragmas_Before               : List_Id := No_List)
 945       return Node_Id;
 946    pragma Inline (Make_Accept_Alternative);
 947
 948    function Make_Delay_Alternative (Sloc : Source_Ptr;
 949       Delay_Statement              : Node_Id;
 950       Condition                    : Node_Id := Empty;
 951       Statements                   : List_Id := Empty_List;
 952       Pragmas_Before               : List_Id := No_List)
 953       return Node_Id;
 954    pragma Inline (Make_Delay_Alternative);
 955
 956    function Make_Terminate_Alternative (Sloc : Source_Ptr;
 957       Condition                    : Node_Id := Empty;
 958       Pragmas_Before               : List_Id := No_List;
 959       Pragmas_After                : List_Id := No_List)
 960       return Node_Id;
 961    pragma Inline (Make_Terminate_Alternative);
 962
 963    function Make_Timed_Entry_Call (Sloc : Source_Ptr;
 964       Entry_Call_Alternative       : Node_Id;
 965       Delay_Alternative            : Node_Id)
 966       return Node_Id;
 967    pragma Inline (Make_Timed_Entry_Call);
 968
 969    function Make_Entry_Call_Alternative (Sloc : Source_Ptr;
 970       Entry_Call_Statement         : Node_Id;
 971       Statements                   : List_Id := Empty_List;
 972       Pragmas_Before               : List_Id := No_List)
 973       return Node_Id;
 974    pragma Inline (Make_Entry_Call_Alternative);
 975
 976    function Make_Conditional_Entry_Call (Sloc : Source_Ptr;
 977       Entry_Call_Alternative       : Node_Id;
 978       Else_Statements              : List_Id)
 979       return Node_Id;
 980    pragma Inline (Make_Conditional_Entry_Call);
 981
 982    function Make_Asynchronous_Select (Sloc : Source_Ptr;
 983       Triggering_Alternative       : Node_Id;
 984       Abortable_Part               : Node_Id)
 985       return Node_Id;
 986    pragma Inline (Make_Asynchronous_Select);
 987
 988    function Make_Triggering_Alternative (Sloc : Source_Ptr;
 989       Triggering_Statement         : Node_Id;
 990       Statements                   : List_Id := Empty_List;
 991       Pragmas_Before               : List_Id := No_List)
 992       return Node_Id;
 993    pragma Inline (Make_Triggering_Alternative);
 994
 995    function Make_Abortable_Part (Sloc : Source_Ptr;
 996       Statements                   : List_Id)
 997       return Node_Id;
 998    pragma Inline (Make_Abortable_Part);
 999
1000    function Make_Abort_Statement (Sloc : Source_Ptr;
1001       Names                        : List_Id)
1002       return Node_Id;
1003    pragma Inline (Make_Abort_Statement);
1004
1005    function Make_Compilation_Unit (Sloc : Source_Ptr;
1006       Context_Items                : List_Id;
1007       Private_Present              : Boolean := False;
1008       Unit                         : Node_Id;
1009       Aux_Decls_Node               : Node_Id)
1010       return Node_Id;
1011    pragma Inline (Make_Compilation_Unit);
1012
1013    function Make_Compilation_Unit_Aux (Sloc : Source_Ptr;
1014       Declarations                 : List_Id := No_List;
1015       Actions                      : List_Id := No_List;
1016       Pragmas_After                : List_Id := No_List)
1017       return Node_Id;
1018    pragma Inline (Make_Compilation_Unit_Aux);
1019
1020    function Make_With_Clause (Sloc : Source_Ptr;
1021       Name                         : Node_Id;
1022       First_Name                   : Boolean := True;
1023       Last_Name                    : Boolean := True)
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;