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