| ------------------------------------------------------------------------------ |
| -- -- |
| -- GNAT COMPILER COMPONENTS -- |
| -- -- |
| -- G E N _ I L . G E N . G E N _ N O D E S -- |
| -- -- |
| -- B o d y -- |
| -- -- |
| -- Copyright (C) 2020-2022, Free Software Foundation, Inc. -- |
| -- -- |
| -- GNAT is free software; you can redistribute it and/or modify it under -- |
| -- terms of the GNU General Public License as published by the Free Soft- -- |
| -- ware Foundation; either version 3, or (at your option) any later ver- -- |
| -- sion. GNAT is distributed in the hope that it will be useful, but WITH- -- |
| -- OUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY -- |
| -- or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -- |
| -- for more details. You should have received a copy of the GNU General -- |
| -- Public License distributed with GNAT; see file COPYING3. If not, go to -- |
| -- http://www.gnu.org/licenses for a complete copy of the license. -- |
| -- -- |
| -- GNAT was originally developed by the GNAT team at New York University. -- |
| -- Extensive contributions were provided by Ada Core Technologies Inc. -- |
| -- -- |
| ------------------------------------------------------------------------------ |
| |
| procedure Gen_IL.Gen.Gen_Nodes is |
| |
| procedure Ab -- Short for "Abstract" |
| (T : Abstract_Node; Parent : Abstract_Type; |
| Fields : Field_Sequence := No_Fields) |
| renames Create_Abstract_Node_Type; |
| procedure Cc -- Short for "ConCrete" |
| (T : Concrete_Node; Parent : Abstract_Type; |
| Fields : Field_Sequence := No_Fields; |
| Nmake_Assert : String := "") |
| renames Create_Concrete_Node_Type; |
| |
| function Sy -- Short for "Syntactic" |
| (Field : Node_Field; Field_Type : Type_Enum; |
| Default_Value : Field_Default_Value := No_Default; |
| Pre, Pre_Get, Pre_Set : String := "") return Field_Desc |
| renames Create_Syntactic_Field; |
| function Sm -- Short for "Semantic" |
| (Field : Field_Enum; Field_Type : Type_Enum; |
| Type_Only : Type_Only_Enum := No_Type_Only; |
| Pre, Pre_Get, Pre_Set : String := "") return Field_Desc |
| renames Create_Semantic_Field; |
| |
| procedure Union (T : Abstract_Node; Children : Type_Array) |
| renames Create_Node_Union_Type; |
| |
| begin -- Gen_IL.Gen.Gen_Nodes |
| pragma Style_Checks ("M200"); |
| |
| Create_Root_Node_Type (Node_Kind, |
| (Sm (Nkind, Node_Kind_Type), |
| Sm (Sloc, Source_Ptr), |
| Sm (In_List, Flag), |
| Sm (Rewrite_Ins, Flag), |
| Sm (Comes_From_Source, Flag), |
| Sm (Analyzed, Flag), |
| Sm (Error_Posted, Flag), |
| Sm (Small_Paren_Count, Small_Paren_Count_Type), |
| Sm (Check_Actuals, Flag), |
| Sm (Has_Aspects, Flag), |
| Sm (Is_Ignored_Ghost_Node, Flag), |
| Sm (Link, Union_Id))); |
| |
| Cc (N_Unused_At_Start, Node_Kind); |
| |
| Ab (N_Representation_Clause, Node_Kind); |
| |
| Cc (N_At_Clause, N_Representation_Clause, |
| (Sy (Identifier, Node_Id, Default_Empty), |
| Sy (Expression, Node_Id, Default_Empty))); |
| |
| Cc (N_Component_Clause, N_Representation_Clause, |
| (Sy (Component_Name, Node_Id), |
| Sy (Position, Node_Id), |
| Sy (First_Bit, Node_Id), |
| Sy (Last_Bit, Node_Id))); |
| |
| Cc (N_Enumeration_Representation_Clause, N_Representation_Clause, |
| (Sy (Identifier, Node_Id, Default_Empty), |
| Sy (Array_Aggregate, Node_Id), |
| Sm (Next_Rep_Item, Node_Id))); |
| |
| Cc (N_Mod_Clause, N_Representation_Clause, |
| (Sy (Expression, Node_Id, Default_Empty), |
| Sy (Pragmas_Before, List_Id, Default_No_List))); |
| |
| Cc (N_Record_Representation_Clause, N_Representation_Clause, |
| (Sy (Identifier, Node_Id, Default_Empty), |
| Sy (Mod_Clause, Node_Id, Default_Empty), |
| Sy (Component_Clauses, List_Id), |
| Sm (Next_Rep_Item, Node_Id))); |
| |
| Cc (N_Attribute_Definition_Clause, N_Representation_Clause, |
| (Sy (Name, Node_Id, Default_Empty), |
| Sy (Chars, Name_Id, Default_No_Name), |
| Sy (Expression, Node_Id, Default_Empty), |
| Sm (Address_Warning_Posted, Flag), |
| Sm (Check_Address_Alignment, Flag), |
| Sm (Entity_Or_Associated_Node, Node_Id), -- just Entity |
| Sm (From_Aspect_Specification, Flag), |
| Sm (From_At_Mod, Flag), |
| Sm (Is_Delayed_Aspect, Flag), |
| Sm (Next_Rep_Item, Node_Id))); |
| |
| Cc (N_Empty, Node_Kind, |
| (Sy (Chars, Name_Id, Default_No_Name))); |
| -- The following getters and setters are called on Empty, |
| -- and are currently inherited from Node_Kind: |
| -- |
| -- Set_Comes_From_Source |
| -- Set_Sloc |
| -- |
| -- Comes_From_Source |
| -- Error_Posted |
| -- In_List |
| -- Link |
| -- Rewrite_Ins |
| -- Sloc |
| -- Small_Paren_Count |
| |
| Cc (N_Pragma_Argument_Association, Node_Kind, |
| (Sy (Chars, Name_Id, Default_No_Name), |
| Sy (Expression, Node_Id, Default_Empty), |
| Sm (Expression_Copy, Node_Id))); |
| |
| Ab (N_Has_Etype, Node_Kind, |
| (Sm (Etype, Node_Id))); |
| |
| Cc (N_Error, N_Has_Etype, |
| (Sy (Chars, Name_Id, Default_No_Name))); |
| |
| Ab (N_Entity, N_Has_Etype, |
| (Sm (Next_Entity, Node_Id), |
| Sm (Scope, Node_Id))); |
| |
| Cc (N_Defining_Character_Literal, N_Entity, |
| (Sy (Chars, Name_Id, Default_No_Name))); |
| |
| Cc (N_Defining_Identifier, N_Entity, |
| (Sy (Chars, Name_Id, Default_No_Name))); |
| |
| Cc (N_Defining_Operator_Symbol, N_Entity, |
| (Sy (Chars, Name_Id, Default_No_Name))); |
| |
| Ab (N_Subexpr, N_Has_Etype, |
| -- Nodes with expression fields |
| (Sm (Assignment_OK, Flag), |
| Sm (Do_Range_Check, Flag), |
| Sm (Has_Dynamic_Length_Check, Flag), |
| Sm (Is_Controlling_Actual, Flag), |
| Sm (Is_Overloaded, Flag), |
| Sm (Is_Static_Expression, Flag), |
| Sm (Must_Not_Freeze, Flag), |
| Sm (Raises_Constraint_Error, Flag))); |
| |
| Ab (N_Has_Entity, N_Subexpr, |
| -- Nodes that have Entity fields |
| -- Warning: DOES NOT INCLUDE N_Freeze_Entity, N_Freeze_Generic_Entity, |
| -- N_Aspect_Specification, or N_Attribute_Definition_Clause. |
| (Sm (Entity_Or_Associated_Node, Node_Id))); -- both |
| |
| Cc (N_Expanded_Name, N_Has_Entity, |
| (Sy (Chars, Name_Id, Default_No_Name), |
| Sy (Prefix, Node_Id), |
| Sy (Selector_Name, Node_Id, Default_Empty), |
| Sm (Atomic_Sync_Required, Flag), |
| Sm (Has_Private_View, Flag), |
| Sm (Is_Elaboration_Checks_OK_Node, Flag), |
| Sm (Is_Elaboration_Warnings_OK_Node, Flag), |
| Sm (Is_SPARK_Mode_On_Node, Flag), |
| Sm (Redundant_Use, Flag))); |
| |
| Ab (N_Direct_Name, N_Has_Entity, |
| (Sm (Has_Private_View, Flag))); |
| |
| Cc (N_Identifier, N_Direct_Name, |
| (Sy (Chars, Name_Id, Default_No_Name), |
| Sm (Atomic_Sync_Required, Flag), |
| Sm (Is_Elaboration_Checks_OK_Node, Flag), |
| Sm (Is_Elaboration_Warnings_OK_Node, Flag), |
| Sm (Is_SPARK_Mode_On_Node, Flag), |
| Sm (Original_Discriminant, Node_Id), |
| Sm (Redundant_Use, Flag))); |
| |
| Cc (N_Operator_Symbol, N_Direct_Name, |
| (Sy (Chars, Name_Id, Default_No_Name), |
| Sy (Strval, String_Id))); |
| |
| Cc (N_Character_Literal, N_Direct_Name, |
| (Sy (Chars, Name_Id, Default_No_Name), |
| Sy (Char_Literal_Value, Unat))); |
| |
| Ab (N_Op, N_Has_Entity, |
| (Sm (Do_Overflow_Check, Flag), |
| Sm (Has_Private_View, Flag))); |
| |
| Ab (N_Binary_Op, N_Op); |
| |
| Cc (N_Op_Add, N_Binary_Op, |
| (Sm (Chars, Name_Id), |
| Sy (Left_Opnd, Node_Id), |
| Sy (Right_Opnd, Node_Id))); |
| |
| Cc (N_Op_Concat, N_Binary_Op, |
| (Sm (Chars, Name_Id), |
| Sy (Left_Opnd, Node_Id), |
| Sy (Right_Opnd, Node_Id), |
| Sm (Is_Component_Left_Opnd, Flag), |
| Sm (Is_Component_Right_Opnd, Flag))); |
| |
| Cc (N_Op_Expon, N_Binary_Op, |
| (Sm (Chars, Name_Id), |
| Sy (Left_Opnd, Node_Id), |
| Sy (Right_Opnd, Node_Id), |
| Sm (Is_Power_Of_2_For_Shift, Flag))); |
| |
| Cc (N_Op_Subtract, N_Binary_Op, |
| (Sm (Chars, Name_Id), |
| Sy (Left_Opnd, Node_Id), |
| Sy (Right_Opnd, Node_Id))); |
| |
| Ab (N_Multiplying_Operator, N_Binary_Op); |
| |
| Cc (N_Op_Divide, N_Multiplying_Operator, |
| (Sm (Chars, Name_Id), |
| Sy (Left_Opnd, Node_Id), |
| Sy (Right_Opnd, Node_Id), |
| Sm (Do_Division_Check, Flag), |
| Sm (Rounded_Result, Flag))); |
| |
| Cc (N_Op_Mod, N_Multiplying_Operator, |
| (Sm (Chars, Name_Id), |
| Sy (Left_Opnd, Node_Id), |
| Sy (Right_Opnd, Node_Id), |
| Sm (Do_Division_Check, Flag))); |
| |
| Cc (N_Op_Multiply, N_Multiplying_Operator, |
| (Sm (Chars, Name_Id), |
| Sy (Left_Opnd, Node_Id), |
| Sy (Right_Opnd, Node_Id), |
| Sm (Rounded_Result, Flag))); |
| |
| Cc (N_Op_Rem, N_Multiplying_Operator, |
| (Sm (Chars, Name_Id), |
| Sy (Left_Opnd, Node_Id), |
| Sy (Right_Opnd, Node_Id), |
| Sm (Do_Division_Check, Flag))); |
| |
| Ab (N_Op_Boolean, N_Binary_Op); |
| -- Binary operators that take operands of a boolean type, and yield a |
| -- result of a boolean type. |
| |
| Cc (N_Op_And, N_Op_Boolean, |
| (Sm (Chars, Name_Id), |
| Sy (Left_Opnd, Node_Id), |
| Sy (Right_Opnd, Node_Id), |
| Sm (Do_Length_Check, Flag))); |
| |
| Ab (N_Op_Compare, N_Op_Boolean); |
| |
| Cc (N_Op_Eq, N_Op_Compare, |
| (Sm (Chars, Name_Id), |
| Sy (Left_Opnd, Node_Id), |
| Sy (Right_Opnd, Node_Id))); |
| |
| Cc (N_Op_Ge, N_Op_Compare, |
| (Sm (Chars, Name_Id), |
| Sy (Left_Opnd, Node_Id), |
| Sy (Right_Opnd, Node_Id))); |
| |
| Cc (N_Op_Gt, N_Op_Compare, |
| (Sm (Chars, Name_Id), |
| Sy (Left_Opnd, Node_Id), |
| Sy (Right_Opnd, Node_Id))); |
| |
| Cc (N_Op_Le, N_Op_Compare, |
| (Sm (Chars, Name_Id), |
| Sy (Left_Opnd, Node_Id), |
| Sy (Right_Opnd, Node_Id))); |
| |
| Cc (N_Op_Lt, N_Op_Compare, |
| (Sm (Chars, Name_Id), |
| Sy (Left_Opnd, Node_Id), |
| Sy (Right_Opnd, Node_Id))); |
| |
| Cc (N_Op_Ne, N_Op_Compare, |
| (Sm (Chars, Name_Id), |
| Sy (Left_Opnd, Node_Id), |
| Sy (Right_Opnd, Node_Id))); |
| |
| Cc (N_Op_Or, N_Op_Boolean, |
| (Sm (Chars, Name_Id), |
| Sy (Left_Opnd, Node_Id), |
| Sy (Right_Opnd, Node_Id), |
| Sm (Do_Length_Check, Flag))); |
| |
| Cc (N_Op_Xor, N_Op_Boolean, |
| (Sm (Chars, Name_Id), |
| Sy (Left_Opnd, Node_Id), |
| Sy (Right_Opnd, Node_Id), |
| Sm (Do_Length_Check, Flag))); |
| |
| Ab (N_Op_Shift, N_Binary_Op, |
| (Sm (Shift_Count_OK, Flag))); |
| |
| Cc (N_Op_Rotate_Left, N_Op_Shift, |
| (Sm (Chars, Name_Id), |
| Sy (Left_Opnd, Node_Id), |
| Sy (Right_Opnd, Node_Id))); |
| |
| Cc (N_Op_Rotate_Right, N_Op_Shift, |
| (Sm (Chars, Name_Id), |
| Sy (Left_Opnd, Node_Id), |
| Sy (Right_Opnd, Node_Id))); |
| |
| Cc (N_Op_Shift_Left, N_Op_Shift, |
| (Sm (Chars, Name_Id), |
| Sy (Left_Opnd, Node_Id), |
| Sy (Right_Opnd, Node_Id))); |
| |
| Cc (N_Op_Shift_Right, N_Op_Shift, |
| (Sm (Chars, Name_Id), |
| Sy (Left_Opnd, Node_Id), |
| Sy (Right_Opnd, Node_Id))); |
| |
| Cc (N_Op_Shift_Right_Arithmetic, N_Op_Shift, |
| (Sm (Chars, Name_Id), |
| Sy (Left_Opnd, Node_Id), |
| Sy (Right_Opnd, Node_Id))); |
| |
| Ab (N_Unary_Op, N_Op); |
| |
| Cc (N_Op_Abs, N_Unary_Op, |
| (Sm (Chars, Name_Id), |
| Sy (Right_Opnd, Node_Id))); |
| |
| Cc (N_Op_Minus, N_Unary_Op, |
| (Sm (Chars, Name_Id), |
| Sy (Right_Opnd, Node_Id))); |
| |
| Cc (N_Op_Not, N_Unary_Op, |
| (Sm (Chars, Name_Id), |
| Sy (Right_Opnd, Node_Id))); |
| |
| Cc (N_Op_Plus, N_Unary_Op, |
| (Sm (Chars, Name_Id), |
| Sy (Right_Opnd, Node_Id))); |
| |
| Cc (N_Attribute_Reference, N_Has_Entity, |
| (Sy (Prefix, Node_Id), |
| Sy (Attribute_Name, Name_Id), |
| Sy (Expressions, List_Id, Default_No_List), |
| Sm (Do_Overflow_Check, Flag), |
| Sm (Header_Size_Added, Flag), |
| Sm (Is_Elaboration_Checks_OK_Node, Flag), |
| Sm (Is_Elaboration_Warnings_OK_Node, Flag), |
| Sm (Is_SPARK_Mode_On_Node, Flag), |
| Sm (Must_Be_Byte_Aligned, Flag), |
| Sm (Redundant_Use, Flag))); |
| |
| Ab (N_Membership_Test, N_Subexpr); |
| |
| Cc (N_In, N_Membership_Test, |
| (Sy (Left_Opnd, Node_Id), |
| Sy (Right_Opnd, Node_Id), |
| Sy (Alternatives, List_Id, Default_No_List), |
| Sy (No_Minimize_Eliminate, Flag))); |
| |
| Cc (N_Not_In, N_Membership_Test, |
| (Sy (Left_Opnd, Node_Id), |
| Sy (Right_Opnd, Node_Id), |
| Sy (Alternatives, List_Id, Default_No_List), |
| Sy (No_Minimize_Eliminate, Flag))); |
| |
| Ab (N_Short_Circuit, N_Subexpr); |
| |
| Cc (N_And_Then, N_Short_Circuit, |
| (Sy (Left_Opnd, Node_Id), |
| Sy (Right_Opnd, Node_Id), |
| Sm (Actions, List_Id))); |
| |
| Cc (N_Or_Else, N_Short_Circuit, |
| (Sy (Left_Opnd, Node_Id), |
| Sy (Right_Opnd, Node_Id), |
| Sm (Actions, List_Id))); |
| |
| Ab (N_Subprogram_Call, N_Subexpr, |
| (Sm (Controlling_Argument, Node_Id), |
| Sm (First_Named_Actual, Node_Id), |
| Sm (Is_Elaboration_Checks_OK_Node, Flag), |
| Sm (Is_Elaboration_Warnings_OK_Node, Flag), |
| Sm (Is_Known_Guaranteed_ABE, Flag), |
| Sm (Is_SPARK_Mode_On_Node, Flag), |
| Sm (No_Elaboration_Check, Flag))); |
| |
| Cc (N_Function_Call, N_Subprogram_Call, |
| (Sy (Name, Node_Id, Default_Empty), |
| Sy (Parameter_Associations, List_Id, Default_No_List), |
| Sm (Is_Expanded_Build_In_Place_Call, Flag), |
| Sm (No_Side_Effect_Removal, Flag))); |
| |
| Cc (N_Procedure_Call_Statement, N_Subprogram_Call, |
| (Sy (Name, Node_Id, Default_Empty), |
| Sy (Parameter_Associations, List_Id, Default_No_List))); |
| |
| Ab (N_Raise_xxx_Error, N_Subexpr); |
| |
| Cc (N_Raise_Constraint_Error, N_Raise_xxx_Error, |
| (Sy (Condition, Node_Id, Default_Empty), |
| Sy (Reason, Unat))); |
| |
| Cc (N_Raise_Program_Error, N_Raise_xxx_Error, |
| (Sy (Condition, Node_Id, Default_Empty), |
| Sy (Reason, Unat))); |
| |
| Cc (N_Raise_Storage_Error, N_Raise_xxx_Error, |
| (Sy (Condition, Node_Id, Default_Empty), |
| Sy (Reason, Unat))); |
| |
| Ab (N_Numeric_Or_String_Literal, N_Subexpr); |
| |
| Cc (N_Integer_Literal, N_Numeric_Or_String_Literal, |
| (Sy (Intval, Valid_Uint), |
| Sm (Original_Entity, Node_Id), |
| Sm (Print_In_Hex, Flag))); |
| |
| Cc (N_Real_Literal, N_Numeric_Or_String_Literal, |
| (Sy (Realval, Ureal), |
| Sm (Corresponding_Integer_Value, Valid_Uint), |
| Sm (Is_Machine_Number, Flag), |
| Sm (Original_Entity, Node_Id))); |
| |
| Cc (N_String_Literal, N_Numeric_Or_String_Literal, |
| (Sy (Strval, String_Id), |
| Sy (Is_Folded_In_Parser, Flag), |
| Sm (Has_Wide_Character, Flag), |
| Sm (Has_Wide_Wide_Character, Flag))); |
| |
| Cc (N_Explicit_Dereference, N_Subexpr, |
| (Sy (Prefix, Node_Id), |
| Sm (Actual_Designated_Subtype, Node_Id), |
| Sm (Atomic_Sync_Required, Flag), |
| Sm (Has_Dereference_Action, Flag))); |
| |
| Cc (N_Expression_With_Actions, N_Subexpr, |
| (Sy (Actions, List_Id, Default_No_List), |
| Sy (Expression, Node_Id, Default_Empty))); |
| |
| Cc (N_If_Expression, N_Subexpr, |
| (Sy (Expressions, List_Id, Default_No_List), |
| Sy (Is_Elsif, Flag), |
| Sm (Do_Overflow_Check, Flag), |
| Sm (Else_Actions, List_Id), |
| Sm (Then_Actions, List_Id))); |
| |
| Cc (N_Indexed_Component, N_Subexpr, |
| (Sy (Prefix, Node_Id), |
| Sy (Expressions, List_Id, Default_No_List), |
| Sm (Atomic_Sync_Required, Flag), |
| Sm (Generalized_Indexing, Node_Id))); |
| |
| Cc (N_Null, N_Subexpr); |
| |
| Cc (N_Qualified_Expression, N_Subexpr, |
| (Sy (Subtype_Mark, Node_Id, Default_Empty), |
| Sy (Expression, Node_Id, Default_Empty), |
| Sm (Is_Qualified_Universal_Literal, Flag))); |
| |
| Cc (N_Quantified_Expression, N_Subexpr, |
| (Sy (Iterator_Specification, Node_Id, Default_Empty), |
| Sy (Loop_Parameter_Specification, Node_Id, Default_Empty), |
| Sy (Condition, Node_Id, Default_Empty), |
| Sy (All_Present, Flag))); |
| |
| Cc (N_Aggregate, N_Subexpr, |
| (Sy (Expressions, List_Id, Default_No_List), |
| Sy (Component_Associations, List_Id, Default_No_List), |
| Sy (Null_Record_Present, Flag), |
| Sy (Is_Parenthesis_Aggregate, Flag), |
| Sy (Is_Homogeneous_Aggregate, Flag), |
| Sy (Is_Enum_Array_Aggregate, Flag), |
| Sm (Aggregate_Bounds, Node_Id), |
| Sm (Entity_Or_Associated_Node, Node_Id), -- just Associated_Node |
| Sm (Compile_Time_Known_Aggregate, Flag), |
| Sm (Expansion_Delayed, Flag), |
| Sm (Has_Self_Reference, Flag))); |
| |
| Cc (N_Allocator, N_Subexpr, |
| (Sy (Expression, Node_Id, Default_Empty), |
| Sy (Subpool_Handle_Name, Node_Id, Default_Empty), |
| Sy (Null_Exclusion_Present, Flag, Default_False), |
| Sm (Alloc_For_BIP_Return, Flag), |
| Sm (Do_Storage_Check, Flag), |
| Sm (Is_Dynamic_Coextension, Flag), |
| Sm (Is_Static_Coextension, Flag), |
| Sm (No_Initialization, Flag), |
| Sm (Procedure_To_Call, Node_Id), |
| Sm (Storage_Pool, Node_Id))); |
| |
| Cc (N_Case_Expression, N_Subexpr, |
| (Sy (Expression, Node_Id, Default_Empty), |
| Sy (Alternatives, List_Id, Default_No_List), |
| Sm (Do_Overflow_Check, Flag))); |
| |
| Cc (N_Delta_Aggregate, N_Subexpr, |
| (Sy (Expression, Node_Id, Default_Empty), |
| Sy (Component_Associations, List_Id, Default_No_List))); |
| |
| Cc (N_Extension_Aggregate, N_Subexpr, |
| (Sy (Ancestor_Part, Node_Id), |
| Sy (Expressions, List_Id, Default_No_List), |
| Sy (Component_Associations, List_Id, Default_No_List), |
| Sy (Null_Record_Present, Flag), |
| Sm (Entity_Or_Associated_Node, Node_Id), -- just Associated_Node |
| Sm (Expansion_Delayed, Flag), |
| Sm (Has_Self_Reference, Flag))); |
| |
| Cc (N_Raise_Expression, N_Subexpr, |
| (Sy (Name, Node_Id, Default_Empty), |
| Sy (Expression, Node_Id, Default_Empty), |
| Sm (Convert_To_Return_False, Flag))); |
| |
| Cc (N_Range, N_Subexpr, |
| (Sy (Low_Bound, Node_Id), |
| Sy (High_Bound, Node_Id), |
| Sy (Includes_Infinities, Flag))); |
| |
| Cc (N_Reference, N_Subexpr, |
| (Sy (Prefix, Node_Id))); |
| |
| Cc (N_Selected_Component, N_Subexpr, |
| (Sy (Prefix, Node_Id), |
| Sy (Selector_Name, Node_Id, Default_Empty), |
| Sm (Atomic_Sync_Required, Flag), |
| Sm (Entity_Or_Associated_Node, Node_Id), -- just Associated_Node |
| Sm (Do_Discriminant_Check, Flag), |
| Sm (Is_In_Discriminant_Check, Flag), |
| Sm (Is_Prefixed_Call, Flag))); |
| |
| Cc (N_Slice, N_Subexpr, |
| (Sy (Prefix, Node_Id), |
| Sy (Discrete_Range, Node_Id))); |
| |
| Cc (N_Target_Name, N_Subexpr); |
| |
| Cc (N_Type_Conversion, N_Subexpr, |
| (Sy (Subtype_Mark, Node_Id, Default_Empty), |
| Sy (Expression, Node_Id, Default_Empty), |
| Sm (Conversion_OK, Flag), |
| Sm (Do_Discriminant_Check, Flag), |
| Sm (Do_Length_Check, Flag), |
| Sm (Do_Overflow_Check, Flag), |
| Sm (Float_Truncate, Flag), |
| Sm (Rounded_Result, Flag))); |
| |
| Cc (N_Unchecked_Expression, N_Subexpr, |
| (Sy (Expression, Node_Id, Default_Empty))); |
| |
| Cc (N_Unchecked_Type_Conversion, N_Subexpr, |
| (Sy (Subtype_Mark, Node_Id, Default_Empty), |
| Sy (Expression, Node_Id, Default_Empty), |
| Sm (Kill_Range_Check, Flag), |
| Sm (No_Truncation, Flag)), |
| Nmake_Assert => "True or else Nkind (Expression) /= N_Unchecked_Type_Conversion"); |
| -- Nmake_Assert => "Nkind (Expression) /= N_Unchecked_Type_Conversion"); |
| -- Assert that we don't have unchecked conversions of unchecked |
| -- conversions; if Expression might be an unchecked conversion, |
| -- then Tbuild.Unchecked_Convert_To should be used. |
| |
| Cc (N_Subtype_Indication, N_Has_Etype, |
| (Sy (Subtype_Mark, Node_Id, Default_Empty), |
| Sy (Constraint, Node_Id), |
| Sm (Must_Not_Freeze, Flag))); |
| |
| Ab (N_Declaration, Node_Kind); |
| -- Note: this includes all constructs normally thought of as declarations |
| -- except those that are separately grouped in N_Later_Decl_Item. But |
| -- Declaration_Node may return yet more node types; see N_Is_Decl below. |
| |
| Cc (N_Component_Declaration, N_Declaration, |
| (Sy (Defining_Identifier, Node_Id), |
| Sy (Component_Definition, Node_Id), |
| Sy (Expression, Node_Id, Default_Empty), |
| Sm (More_Ids, Flag), |
| Sm (Prev_Ids, Flag))); |
| |
| Cc (N_Entry_Declaration, N_Declaration, |
| (Sy (Defining_Identifier, Node_Id), |
| Sy (Discrete_Subtype_Definition, Node_Id, Default_Empty), |
| Sy (Parameter_Specifications, List_Id, Default_No_List), |
| Sy (Must_Override, Flag), |
| Sy (Must_Not_Override, Flag), |
| Sm (Corresponding_Body, Node_Id))); |
| |
| Cc (N_Expression_Function, N_Declaration, |
| (Sy (Specification, Node_Id), |
| Sy (Expression, Node_Id, Default_Empty), |
| Sm (Corresponding_Spec, Node_Id))); |
| |
| Cc (N_Formal_Object_Declaration, N_Declaration, |
| (Sy (Defining_Identifier, Node_Id), |
| Sy (In_Present, Flag), |
| Sy (Out_Present, Flag), |
| Sy (Null_Exclusion_Present, Flag, Default_False), |
| Sy (Subtype_Mark, Node_Id, Default_Empty), |
| Sy (Access_Definition, Node_Id, Default_Empty), |
| Sy (Default_Expression, Node_Id, Default_Empty), |
| Sm (More_Ids, Flag), |
| Sm (Prev_Ids, Flag))); |
| |
| Cc (N_Formal_Type_Declaration, N_Declaration, |
| (Sy (Defining_Identifier, Node_Id), |
| Sy (Formal_Type_Definition, Node_Id), |
| Sy (Discriminant_Specifications, List_Id, Default_No_List), |
| Sy (Unknown_Discriminants_Present, Flag), |
| Sy (Default_Subtype_Mark, Node_Id))); |
| |
| Cc (N_Full_Type_Declaration, N_Declaration, |
| (Sy (Defining_Identifier, Node_Id), |
| Sy (Discriminant_Specifications, List_Id, Default_No_List), |
| Sy (Type_Definition, Node_Id), |
| Sm (Discr_Check_Funcs_Built, Flag), |
| Sm (Incomplete_View, Node_Id))); |
| |
| Cc (N_Incomplete_Type_Declaration, N_Declaration, |
| (Sy (Defining_Identifier, Node_Id), |
| Sy (Discriminant_Specifications, List_Id, Default_No_List), |
| Sy (Unknown_Discriminants_Present, Flag), |
| Sy (Tagged_Present, Flag), |
| Sm (Premature_Use, Node_Id))); |
| |
| Cc (N_Iterator_Specification, N_Declaration, |
| (Sy (Defining_Identifier, Node_Id), |
| Sy (Name, Node_Id, Default_Empty), |
| Sy (Reverse_Present, Flag), |
| Sy (Of_Present, Flag), |
| Sy (Iterator_Filter, Node_Id, Default_Empty), |
| Sy (Subtype_Indication, Node_Id, Default_Empty))); |
| |
| Cc (N_Loop_Parameter_Specification, N_Declaration, |
| (Sy (Defining_Identifier, Node_Id), |
| Sy (Reverse_Present, Flag), |
| Sy (Iterator_Filter, Node_Id, Default_Empty), |
| Sy (Discrete_Subtype_Definition, Node_Id, Default_Empty))); |
| |
| Cc (N_Object_Declaration, N_Declaration, |
| (Sy (Defining_Identifier, Node_Id), |
| Sy (Aliased_Present, Flag), |
| Sy (Constant_Present, Flag), |
| Sy (Null_Exclusion_Present, Flag, Default_False), |
| Sy (Object_Definition, Node_Id), |
| Sy (Expression, Node_Id, Default_Empty), |
| Sy (Has_Init_Expression, Flag), |
| Sm (Assignment_OK, Flag), |
| Sm (Corresponding_Generic_Association, Node_Id), |
| Sm (Exception_Junk, Flag), |
| Sm (Handler_List_Entry, Node_Id), |
| Sm (Is_Subprogram_Descriptor, Flag), |
| Sm (More_Ids, Flag), |
| Sm (No_Initialization, Flag), |
| Sm (Prev_Ids, Flag), |
| Sm (Suppress_Assignment_Checks, Flag))); |
| |
| Cc (N_Protected_Type_Declaration, N_Declaration, |
| (Sy (Defining_Identifier, Node_Id), |
| Sy (Discriminant_Specifications, List_Id, Default_No_List), |
| Sy (Interface_List, List_Id, Default_No_List), |
| Sy (Protected_Definition, Node_Id), |
| Sm (Corresponding_Body, Node_Id))); |
| |
| Cc (N_Private_Extension_Declaration, N_Declaration, |
| (Sy (Defining_Identifier, Node_Id), |
| Sy (Discriminant_Specifications, List_Id, Default_No_List), |
| Sy (Unknown_Discriminants_Present, Flag), |
| Sy (Abstract_Present, Flag), |
| Sy (Limited_Present, Flag), |
| Sy (Synchronized_Present, Flag), |
| Sy (Subtype_Indication, Node_Id, Default_Empty), |
| Sy (Interface_List, List_Id, Default_No_List), |
| Sm (Uninitialized_Variable, Node_Id))); |
| |
| Cc (N_Private_Type_Declaration, N_Declaration, |
| (Sy (Defining_Identifier, Node_Id), |
| Sy (Discriminant_Specifications, List_Id, Default_No_List), |
| Sy (Unknown_Discriminants_Present, Flag), |
| Sy (Abstract_Present, Flag), |
| Sy (Tagged_Present, Flag), |
| Sy (Limited_Present, Flag))); |
| |
| Cc (N_Subtype_Declaration, N_Declaration, |
| (Sy (Defining_Identifier, Node_Id), |
| Sy (Null_Exclusion_Present, Flag, Default_False), |
| Sy (Subtype_Indication, Node_Id, Default_Empty), |
| Sm (Exception_Junk, Flag), |
| Sm (Generic_Parent_Type, Node_Id))); |
| |
| Ab (N_Subprogram_Specification, N_Declaration, |
| (Sm (Generic_Parent, Node_Id))); |
| |
| Cc (N_Function_Specification, N_Subprogram_Specification, |
| (Sy (Defining_Unit_Name, Node_Id), |
| Sy (Parameter_Specifications, List_Id, Default_No_List), |
| Sy (Null_Exclusion_Present, Flag, Default_False), |
| Sy (Result_Definition, Node_Id), |
| Sy (Must_Override, Flag), |
| Sy (Must_Not_Override, Flag))); |
| |
| Cc (N_Procedure_Specification, N_Subprogram_Specification, |
| (Sy (Defining_Unit_Name, Node_Id), |
| Sy (Parameter_Specifications, List_Id, Default_No_List), |
| Sy (Null_Present, Flag), |
| Sy (Must_Override, Flag), |
| Sy (Must_Not_Override, Flag), |
| Sm (Null_Statement, Node_Id))); |
| |
| Ab (N_Access_To_Subprogram_Definition, Node_Kind); |
| |
| Cc (N_Access_Function_Definition, N_Access_To_Subprogram_Definition, |
| (Sy (Null_Exclusion_Present, Flag, Default_False), |
| Sy (Null_Exclusion_In_Return_Present, Flag), |
| Sy (Protected_Present, Flag), |
| Sy (Parameter_Specifications, List_Id, Default_No_List), |
| Sy (Result_Definition, Node_Id))); |
| |
| Cc (N_Access_Procedure_Definition, N_Access_To_Subprogram_Definition, |
| (Sy (Null_Exclusion_Present, Flag, Default_False), |
| Sy (Protected_Present, Flag), |
| Sy (Parameter_Specifications, List_Id, Default_No_List))); |
| |
| Ab (N_Later_Decl_Item, Node_Kind); |
| -- Note: this is Ada 83 relevant only (see Ada 83 RM 3.9 (2)) and includes |
| -- only those items which can appear as later declarative items. This also |
| -- includes N_Implicit_Label_Declaration which is not specifically in the |
| -- grammar but may appear as a valid later declarative items. It does NOT |
| -- include N_Pragma which can also appear among later declarative items. |
| -- It does however include N_Protected_Body, which is a bit peculiar, but |
| -- harmless since this cannot appear in Ada 83 mode anyway. |
| |
| Cc (N_Task_Type_Declaration, N_Later_Decl_Item, |
| (Sy (Defining_Identifier, Node_Id), |
| Sy (Discriminant_Specifications, List_Id, Default_No_List), |
| Sy (Interface_List, List_Id, Default_No_List), |
| Sy (Task_Definition, Node_Id, Default_Empty), |
| Sm (Corresponding_Body, Node_Id))); |
| |
| Ab (N_Body_Stub, N_Later_Decl_Item, |
| (Sm (Corresponding_Body, Node_Id), |
| Sm (Corresponding_Spec_Of_Stub, Node_Id), |
| Sm (Library_Unit, Node_Id))); |
| |
| Cc (N_Package_Body_Stub, N_Body_Stub, |
| (Sy (Defining_Identifier, Node_Id))); |
| |
| Cc (N_Protected_Body_Stub, N_Body_Stub, |
| (Sy (Defining_Identifier, Node_Id))); |
| |
| Cc (N_Subprogram_Body_Stub, N_Body_Stub, |
| (Sy (Specification, Node_Id))); |
| |
| Cc (N_Task_Body_Stub, N_Body_Stub, |
| (Sy (Defining_Identifier, Node_Id))); |
| |
| Ab (N_Generic_Instantiation, N_Later_Decl_Item, |
| (Sm (Instance_Spec, Node_Id), |
| Sm (Is_Declaration_Level_Node, Flag), |
| Sm (Is_Elaboration_Checks_OK_Node, Flag), |
| Sm (Is_Elaboration_Warnings_OK_Node, Flag), |
| Sm (Is_Known_Guaranteed_ABE, Flag), |
| Sm (Is_SPARK_Mode_On_Node, Flag), |
| Sm (Parent_Spec, Node_Id))); |
| |
| Ab (N_Subprogram_Instantiation, N_Generic_Instantiation); |
| |
| Cc (N_Function_Instantiation, N_Subprogram_Instantiation, |
| (Sy (Defining_Unit_Name, Node_Id), |
| Sy (Name, Node_Id, Default_Empty), |
| Sy (Generic_Associations, List_Id, Default_No_List), |
| Sy (Must_Override, Flag), |
| Sy (Must_Not_Override, Flag))); |
| |
| Cc (N_Procedure_Instantiation, N_Subprogram_Instantiation, |
| (Sy (Defining_Unit_Name, Node_Id), |
| Sy (Name, Node_Id, Default_Empty), |
| Sy (Generic_Associations, List_Id, Default_No_List), |
| Sy (Must_Override, Flag), |
| Sy (Must_Not_Override, Flag))); |
| |
| Cc (N_Package_Instantiation, N_Generic_Instantiation, |
| (Sy (Defining_Unit_Name, Node_Id), |
| Sy (Name, Node_Id, Default_Empty), |
| Sy (Generic_Associations, List_Id, Default_No_List))); |
| |
| Ab (N_Proper_Body, N_Later_Decl_Item, |
| (Sm (Corresponding_Spec, Node_Id), |
| Sm (Was_Originally_Stub, Flag))); |
| |
| Ab (N_Unit_Body, N_Proper_Body); |
| |
| Cc (N_Package_Body, N_Unit_Body, |
| (Sy (Defining_Unit_Name, Node_Id), |
| Sy (Declarations, List_Id, Default_No_List), |
| Sy (Handled_Statement_Sequence, Node_Id, Default_Empty))); |
| |
| Cc (N_Subprogram_Body, N_Unit_Body, |
| (Sy (Specification, Node_Id), |
| Sy (Declarations, List_Id, Default_No_List), |
| Sy (Handled_Statement_Sequence, Node_Id, Default_Empty), |
| Sy (Bad_Is_Detected, Flag), |
| Sm (Activation_Chain_Entity, Node_Id), |
| Sm (Acts_As_Spec, Flag), |
| Sm (Corresponding_Entry_Body, Node_Id), |
| Sm (Do_Storage_Check, Flag), |
| Sm (Has_Relative_Deadline_Pragma, Flag), |
| Sm (Is_Entry_Barrier_Function, Flag), |
| Sm (Is_Protected_Subprogram_Body, Flag), |
| Sm (Is_Task_Body_Procedure, Flag), |
| Sm (Is_Task_Master, Flag), |
| Sm (Was_Attribute_Reference, Flag), |
| Sm (Was_Expression_Function, Flag))); |
| |
| Cc (N_Protected_Body, N_Proper_Body, |
| (Sy (Defining_Identifier, Node_Id), |
| Sy (Declarations, List_Id, Default_No_List), |
| Sy (End_Label, Node_Id, Default_Empty))); |
| |
| Cc (N_Task_Body, N_Proper_Body, |
| (Sy (Defining_Identifier, Node_Id), |
| Sy (Declarations, List_Id, Default_No_List), |
| Sy (Handled_Statement_Sequence, Node_Id, Default_Empty), |
| Sm (Activation_Chain_Entity, Node_Id), |
| Sm (Is_Task_Master, Flag))); |
| |
| Cc (N_Implicit_Label_Declaration, N_Later_Decl_Item, |
| (Sy (Defining_Identifier, Node_Id), |
| Sm (Label_Construct, Node_Id))); |
| |
| Cc (N_Package_Declaration, N_Later_Decl_Item, |
| (Sy (Specification, Node_Id), |
| Sm (Activation_Chain_Entity, Node_Id), |
| Sm (Corresponding_Body, Node_Id), |
| Sm (Parent_Spec, Node_Id))); |
| |
| Cc (N_Single_Task_Declaration, N_Later_Decl_Item, |
| (Sy (Defining_Identifier, Node_Id), |
| Sy (Interface_List, List_Id, Default_No_List), |
| Sy (Task_Definition, Node_Id, Default_Empty))); |
| |
| Cc (N_Subprogram_Declaration, N_Later_Decl_Item, |
| (Sy (Specification, Node_Id), |
| Sm (Body_To_Inline, Node_Id), |
| Sm (Corresponding_Body, Node_Id), |
| Sm (Is_Entry_Barrier_Function, Flag), |
| Sm (Is_Task_Body_Procedure, Flag), |
| Sm (Parent_Spec, Node_Id))); |
| |
| Cc (N_Use_Package_Clause, N_Later_Decl_Item, |
| (Sy (Name, Node_Id, Default_Empty), |
| Sy (Is_Effective_Use_Clause, Flag), |
| Sm (Entity_Or_Associated_Node, Node_Id), -- just Associated_Node |
| Sm (Hidden_By_Use_Clause, Elist_Id), |
| Sm (More_Ids, Flag), |
| Sm (Next_Use_Clause, Node_Id), |
| Sm (Prev_Ids, Flag), |
| Sm (Prev_Use_Clause, Node_Id))); |
| |
| Ab (N_Generic_Declaration, N_Later_Decl_Item, |
| (Sm (Corresponding_Body, Node_Id), |
| Sm (Parent_Spec, Node_Id))); |
| |
| Cc (N_Generic_Package_Declaration, N_Generic_Declaration, |
| (Sy (Specification, Node_Id), |
| Sy (Generic_Formal_Declarations, List_Id), |
| Sm (Activation_Chain_Entity, Node_Id))); |
| |
| Cc (N_Generic_Subprogram_Declaration, N_Generic_Declaration, |
| (Sy (Specification, Node_Id), |
| Sy (Generic_Formal_Declarations, List_Id))); |
| |
| Ab (N_Array_Type_Definition, Node_Kind); |
| |
| Cc (N_Constrained_Array_Definition, N_Array_Type_Definition, |
| (Sy (Discrete_Subtype_Definitions, List_Id), |
| Sy (Component_Definition, Node_Id))); |
| |
| Cc (N_Unconstrained_Array_Definition, N_Array_Type_Definition, |
| (Sy (Subtype_Marks, List_Id), |
| Sy (Component_Definition, Node_Id))); |
| |
| Ab (N_Renaming_Declaration, Node_Kind); |
| |
| Cc (N_Exception_Renaming_Declaration, N_Renaming_Declaration, |
| (Sy (Defining_Identifier, Node_Id), |
| Sy (Name, Node_Id, Default_Empty))); |
| |
| Cc (N_Object_Renaming_Declaration, N_Renaming_Declaration, |
| (Sy (Defining_Identifier, Node_Id), |
| Sy (Null_Exclusion_Present, Flag, Default_False), |
| Sy (Subtype_Mark, Node_Id, Default_Empty), |
| Sy (Access_Definition, Node_Id, Default_Empty), |
| Sy (Name, Node_Id, Default_Empty), |
| Sm (Corresponding_Generic_Association, Node_Id))); |
| |
| Cc (N_Package_Renaming_Declaration, N_Renaming_Declaration, |
| (Sy (Defining_Unit_Name, Node_Id), |
| Sy (Name, Node_Id, Default_Empty), |
| Sm (Parent_Spec, Node_Id))); |
| |
| Cc (N_Subprogram_Renaming_Declaration, N_Renaming_Declaration, |
| (Sy (Specification, Node_Id), |
| Sy (Name, Node_Id, Default_Empty), |
| Sm (Corresponding_Formal_Spec, Node_Id), |
| Sm (Corresponding_Spec, Node_Id), |
| Sm (From_Default, Flag), |
| Sm (Parent_Spec, Node_Id))); |
| |
| Ab (N_Generic_Renaming_Declaration, N_Renaming_Declaration, |
| (Sm (Parent_Spec, Node_Id))); |
| |
| Cc (N_Generic_Function_Renaming_Declaration, N_Generic_Renaming_Declaration, |
| (Sy (Defining_Unit_Name, Node_Id), |
| Sy (Name, Node_Id, Default_Empty))); |
| |
| Cc (N_Generic_Package_Renaming_Declaration, N_Generic_Renaming_Declaration, |
| (Sy (Defining_Unit_Name, Node_Id), |
| Sy (Name, Node_Id, Default_Empty))); |
| |
| Cc (N_Generic_Procedure_Renaming_Declaration, N_Generic_Renaming_Declaration, |
| (Sy (Defining_Unit_Name, Node_Id), |
| Sy (Name, Node_Id, Default_Empty))); |
| |
| Ab (N_Statement_Other_Than_Procedure_Call, Node_Kind); |
| -- Note that this includes all statement types except for the cases of the |
| -- N_Procedure_Call_Statement which is considered to be a subexpression |
| -- (since overloading is possible, so it needs to go through the normal |
| -- overloading resolution for expressions). |
| |
| Cc (N_Abort_Statement, N_Statement_Other_Than_Procedure_Call, |
| (Sy (Names, List_Id))); |
| |
| Cc (N_Accept_Statement, N_Statement_Other_Than_Procedure_Call, |
| (Sy (Entry_Direct_Name, Node_Id), |
| Sy (Entry_Index, Node_Id, Default_Empty), |
| Sy (Parameter_Specifications, List_Id, Default_No_List), |
| Sy (Handled_Statement_Sequence, Node_Id, Default_Empty), |
| Sy (Declarations, List_Id, Default_No_List))); |
| |
| Cc (N_Assignment_Statement, N_Statement_Other_Than_Procedure_Call, |
| (Sy (Name, Node_Id, Default_Empty), |
| Sy (Expression, Node_Id, Default_Empty), |
| Sm (Backwards_OK, Flag), |
| Sm (Componentwise_Assignment, Flag), |
| Sm (Do_Discriminant_Check, Flag), |
| Sm (Do_Length_Check, Flag), |
| Sm (Forwards_OK, Flag), |
| Sm (Has_Target_Names, Flag), |
| Sm (Is_Elaboration_Checks_OK_Node, Flag), |
| Sm (Is_Elaboration_Code, Flag), |
| Sm (Is_SPARK_Mode_On_Node, Flag), |
| Sm (No_Ctrl_Actions, Flag), |
| Sm (Suppress_Assignment_Checks, Flag))); |
| |
| Cc (N_Asynchronous_Select, N_Statement_Other_Than_Procedure_Call, |
| (Sy (Triggering_Alternative, Node_Id), |
| Sy (Abortable_Part, Node_Id))); |
| |
| Cc (N_Block_Statement, N_Statement_Other_Than_Procedure_Call, |
| (Sy (Identifier, Node_Id, Default_Empty), |
| Sy (Declarations, List_Id, Default_No_List), |
| Sy (Handled_Statement_Sequence, Node_Id, Default_Empty), |
| Sy (Has_Created_Identifier, Flag), |
| Sy (Is_Asynchronous_Call_Block, Flag), |
| Sy (Is_Task_Allocation_Block, Flag), |
| Sm (Activation_Chain_Entity, Node_Id), |
| Sm (Cleanup_Actions, List_Id), |
| Sm (Exception_Junk, Flag), |
| Sm (Is_Abort_Block, Flag), |
| Sm (Is_Finalization_Wrapper, Flag), |
| Sm (Is_Initialization_Block, Flag), |
| Sm (Is_Task_Master, Flag))); |
| |
| Cc (N_Case_Statement, N_Statement_Other_Than_Procedure_Call, |
| (Sy (Expression, Node_Id, Default_Empty), |
| Sy (Alternatives, List_Id, Default_No_List), |
| Sy (End_Span, Unat, Default_Uint_0), |
| Sm (From_Conditional_Expression, Flag))); |
| |
| Cc (N_Code_Statement, N_Statement_Other_Than_Procedure_Call, |
| (Sy (Expression, Node_Id, Default_Empty))); |
| |
| Cc (N_Compound_Statement, N_Statement_Other_Than_Procedure_Call, |
| (Sy (Actions, List_Id, Default_No_List))); |
| |
| Cc (N_Conditional_Entry_Call, N_Statement_Other_Than_Procedure_Call, |
| (Sy (Entry_Call_Alternative, Node_Id), |
| Sy (Else_Statements, List_Id, Default_No_List))); |
| |
| Ab (N_Delay_Statement, N_Statement_Other_Than_Procedure_Call); |
| |
| Cc (N_Delay_Relative_Statement, N_Delay_Statement, |
| (Sy (Expression, Node_Id, Default_Empty))); |
| |
| Cc (N_Delay_Until_Statement, N_Delay_Statement, |
| (Sy (Expression, Node_Id, Default_Empty))); |
| |
| Cc (N_Entry_Call_Statement, N_Statement_Other_Than_Procedure_Call, |
| (Sy (Name, Node_Id, Default_Empty), |
| Sy (Parameter_Associations, List_Id, Default_No_List), |
| Sm (First_Named_Actual, Node_Id), |
| Sm (Is_Elaboration_Checks_OK_Node, Flag), |
| Sm (Is_Elaboration_Warnings_OK_Node, Flag), |
| Sm (Is_SPARK_Mode_On_Node, Flag))); |
| |
| Cc (N_Free_Statement, N_Statement_Other_Than_Procedure_Call, |
| (Sy (Expression, Node_Id, Default_Empty), |
| Sm (Actual_Designated_Subtype, Node_Id), |
| Sm (Procedure_To_Call, Node_Id), |
| Sm (Storage_Pool, Node_Id))); |
| |
| Cc (N_Goto_Statement, N_Statement_Other_Than_Procedure_Call, |
| (Sy (Name, Node_Id, Default_Empty), |
| Sm (Exception_Junk, Flag))); |
| |
| Cc (N_Goto_When_Statement, N_Statement_Other_Than_Procedure_Call, |
| (Sy (Name, Node_Id, Default_Empty), |
| Sy (Condition, Node_Id, Default_Empty))); |
| |
| Cc (N_Loop_Statement, N_Statement_Other_Than_Procedure_Call, |
| (Sy (Identifier, Node_Id, Default_Empty), |
| Sy (Iteration_Scheme, Node_Id, Default_Empty), |
| Sy (Statements, List_Id, Default_Empty_List), |
| Sy (End_Label, Node_Id, Default_Empty), |
| Sy (Has_Created_Identifier, Flag), |
| Sy (Is_Null_Loop, Flag), |
| Sy (Suppress_Loop_Warnings, Flag))); |
| |
| Cc (N_Null_Statement, N_Statement_Other_Than_Procedure_Call, |
| (Sm (Next_Rep_Item, Node_Id))); |
| |
| Cc (N_Raise_Statement, N_Statement_Other_Than_Procedure_Call, |
| (Sy (Name, Node_Id, Default_Empty), |
| Sy (Expression, Node_Id, Default_Empty), |
| Sm (From_At_End, Flag))); |
| |
| Cc (N_Raise_When_Statement, N_Statement_Other_Than_Procedure_Call, |
| (Sy (Name, Node_Id, Default_Empty), |
| Sy (Expression, Node_Id, Default_Empty), |
| Sy (Condition, Node_Id, Default_Empty))); |
| |
| Cc (N_Requeue_Statement, N_Statement_Other_Than_Procedure_Call, |
| (Sy (Name, Node_Id, Default_Empty), |
| Sy (Abort_Present, Flag), |
| Sm (Is_Elaboration_Checks_OK_Node, Flag), |
| Sm (Is_Elaboration_Warnings_OK_Node, Flag), |
| Sm (Is_SPARK_Mode_On_Node, Flag))); |
| |
| Cc (N_Simple_Return_Statement, N_Statement_Other_Than_Procedure_Call, |
| (Sy (Expression, Node_Id, Default_Empty), |
| Sm (By_Ref, Flag), |
| Sm (Comes_From_Extended_Return_Statement, Flag), |
| Sm (Procedure_To_Call, Node_Id), |
| Sm (Return_Statement_Entity, Node_Id), |
| Sm (Storage_Pool, Node_Id))); |
| |
| Cc (N_Extended_Return_Statement, N_Statement_Other_Than_Procedure_Call, |
| (Sy (Return_Object_Declarations, List_Id), |
| Sy (Handled_Statement_Sequence, Node_Id, Default_Empty), |
| Sm (By_Ref, Flag), |
| Sm (Procedure_To_Call, Node_Id), |
| Sm (Return_Statement_Entity, Node_Id), |
| Sm (Storage_Pool, Node_Id))); |
| |
| Cc (N_Return_When_Statement, N_Statement_Other_Than_Procedure_Call, |
| (Sy (Expression, Node_Id, Default_Empty), |
| Sy (Condition, Node_Id, Default_Empty))); |
| |
| Cc (N_Selective_Accept, N_Statement_Other_Than_Procedure_Call, |
| (Sy (Select_Alternatives, List_Id), |
| Sy (Else_Statements, List_Id, Default_No_List))); |
| |
| Cc (N_Timed_Entry_Call, N_Statement_Other_Than_Procedure_Call, |
| (Sy (Entry_Call_Alternative, Node_Id), |
| Sy (Delay_Alternative, Node_Id))); |
| |
| Cc (N_Exit_Statement, N_Statement_Other_Than_Procedure_Call, |
| (Sy (Name, Node_Id, Default_Empty), |
| Sy (Condition, Node_Id, Default_Empty), |
| Sm (Next_Exit_Statement, Node_Id))); |
| |
| Cc (N_If_Statement, N_Statement_Other_Than_Procedure_Call, |
| (Sy (Condition, Node_Id, Default_Empty), |
| Sy (Then_Statements, List_Id), |
| Sy (Elsif_Parts, List_Id, Default_No_List), |
| Sy (Else_Statements, List_Id, Default_No_List), |
| Sy (End_Span, Unat, Default_Uint_0), |
| Sm (From_Conditional_Expression, Flag))); |
| |
| Cc (N_Accept_Alternative, Node_Kind, |
| (Sy (Accept_Statement, Node_Id), |
| Sy (Condition, Node_Id, Default_Empty), |
| Sy (Statements, List_Id, Default_Empty_List), |
| Sy (Pragmas_Before, List_Id, Default_No_List), |
| Sm (Accept_Handler_Records, List_Id))); |
| |
| Cc (N_Delay_Alternative, Node_Kind, |
| (Sy (Delay_Statement, Node_Id), |
| Sy (Condition, Node_Id, Default_Empty), |
| Sy (Statements, List_Id, Default_Empty_List), |
| Sy (Pragmas_Before, List_Id, Default_No_List))); |
| |
| Cc (N_Elsif_Part, Node_Kind, |
| (Sy (Condition, Node_Id, Default_Empty), |
| Sy (Then_Statements, List_Id), |
| Sm (Condition_Actions, List_Id))); |
| |
| Cc (N_Entry_Body_Formal_Part, Node_Kind, |
| (Sy (Entry_Index_Specification, Node_Id, Default_Empty), |
| Sy (Parameter_Specifications, List_Id, Default_No_List), |
| Sy (Condition, Node_Id, Default_Empty))); |
| |
| Cc (N_Iteration_Scheme, Node_Kind, |
| (Sy (Condition, Node_Id, Default_Empty), |
| Sy (Iterator_Specification, Node_Id, Default_Empty), |
| Sy (Loop_Parameter_Specification, Node_Id, Default_Empty), |
| Sm (Condition_Actions, List_Id))); |
| |
| Cc (N_Terminate_Alternative, Node_Kind, |
| (Sy (Condition, Node_Id, Default_Empty), |
| Sy (Pragmas_Before, List_Id, Default_No_List), |
| Sy (Pragmas_After, List_Id, Default_No_List))); |
| |
| Ab (N_Formal_Subprogram_Declaration, Node_Kind); |
| |
| Cc (N_Formal_Abstract_Subprogram_Declaration, N_Formal_Subprogram_Declaration, |
| (Sy (Specification, Node_Id), |
| Sy (Default_Name, Node_Id, Default_Empty), |
| Sy (Expression, Node_Id, Default_Empty), |
| Sy (Box_Present, Flag))); |
| |
| Cc (N_Formal_Concrete_Subprogram_Declaration, N_Formal_Subprogram_Declaration, |
| (Sy (Specification, Node_Id), |
| Sy (Default_Name, Node_Id, Default_Empty), |
| Sy (Expression, Node_Id, Default_Empty), |
| Sy (Box_Present, Flag))); |
| |
| Ab (N_Push_Pop_xxx_Label, Node_Kind); |
| |
| Ab (N_Push_xxx_Label, N_Push_Pop_xxx_Label, |
| (Sm (Exception_Label, Node_Id))); |
| |
| Cc (N_Push_Constraint_Error_Label, N_Push_xxx_Label); |
| |
| Cc (N_Push_Program_Error_Label, N_Push_xxx_Label); |
| |
| Cc (N_Push_Storage_Error_Label, N_Push_xxx_Label); |
| |
| Ab (N_Pop_xxx_Label, N_Push_Pop_xxx_Label); |
| |
| Cc (N_Pop_Constraint_Error_Label, N_Pop_xxx_Label); |
| |
| Cc (N_Pop_Program_Error_Label, N_Pop_xxx_Label); |
| |
| Cc (N_Pop_Storage_Error_Label, N_Pop_xxx_Label); |
| |
| Ab (N_SCIL_Node, Node_Kind, |
| (Sm (SCIL_Entity, Node_Id))); |
| |
| Cc (N_SCIL_Dispatch_Table_Tag_Init, N_SCIL_Node); |
| |
| Cc (N_SCIL_Dispatching_Call, N_SCIL_Node, |
| (Sm (SCIL_Controlling_Tag, Node_Id), |
| Sm (SCIL_Target_Prim, Node_Id))); |
| |
| Cc (N_SCIL_Membership_Test, N_SCIL_Node, |
| (Sm (SCIL_Tag_Value, Node_Id))); |
| |
| Cc (N_Abortable_Part, Node_Kind, |
| (Sy (Statements, List_Id, Default_Empty_List))); |
| |
| Cc (N_Abstract_Subprogram_Declaration, Node_Kind, |
| (Sy (Specification, Node_Id))); |
| |
| Cc (N_Access_Definition, Node_Kind, |
| (Sy (Null_Exclusion_Present, Flag, Default_False), |
| Sy (All_Present, Flag), |
| Sy (Constant_Present, Flag), |
| Sy (Subtype_Mark, Node_Id, Default_Empty), |
| Sy (Access_To_Subprogram_Definition, Node_Id, Default_Empty))); |
| |
| Cc (N_Access_To_Object_Definition, Node_Kind, |
| (Sy (All_Present, Flag), |
| Sy (Null_Exclusion_Present, Flag, Default_False), |
| Sy (Null_Excluding_Subtype, Flag), |
| Sy (Subtype_Indication, Node_Id, Default_Empty), |
| Sy (Constant_Present, Flag))); |
| |
| Cc (N_Aspect_Specification, Node_Kind, |
| (Sy (Identifier, Node_Id, Default_Empty), |
| Sy (Expression, Node_Id, Default_Empty), |
| Sy (Class_Present, Flag), |
| Sy (Split_PPC, Flag), |
| Sm (Aspect_On_Partial_View, Flag), |
| Sm (Aspect_Rep_Item, Node_Id), |
| Sm (Entity_Or_Associated_Node, Node_Id), -- just Entity |
| Sm (Is_Boolean_Aspect, Flag), |
| Sm (Is_Checked, Flag), |
| Sm (Is_Delayed_Aspect, Flag), |
| Sm (Is_Disabled, Flag), |
| Sm (Is_Ignored, Flag), |
| Sm (Next_Rep_Item, Node_Id))); |
| |
| Cc (N_Call_Marker, Node_Kind, |
| (Sm (Is_Declaration_Level_Node, Flag), |
| Sm (Is_Dispatching_Call, Flag), |
| Sm (Is_Elaboration_Checks_OK_Node, Flag), |
| Sm (Is_Elaboration_Warnings_OK_Node, Flag), |
| Sm (Is_Known_Guaranteed_ABE, Flag), |
| Sm (Is_Preelaborable_Call, Flag), |
| Sm (Is_Source_Call, Flag), |
| Sm (Is_SPARK_Mode_On_Node, Flag), |
| Sm (Target, Node_Id))); |
| |
| Cc (N_Case_Expression_Alternative, Node_Kind, |
| (Sm (Actions, List_Id), |
| Sy (Discrete_Choices, List_Id), |
| Sy (Expression, Node_Id, Default_Empty), |
| Sm (Has_SP_Choice, Flag))); |
| |
| Cc (N_Case_Statement_Alternative, Node_Kind, |
| (Sy (Discrete_Choices, List_Id), |
| Sy (Statements, List_Id, Default_Empty_List), |
| Sm (Has_SP_Choice, Flag), |
| Sm (Multidefined_Bindings, Flag))); |
| |
| Cc (N_Compilation_Unit, Node_Kind, |
| (Sy (Context_Items, List_Id), |
| Sy (Private_Present, Flag), |
| Sy (Unit, Node_Id), |
| Sy (Aux_Decls_Node, Node_Id), |
| Sm (Acts_As_Spec, Flag), |
| Sm (Body_Required, Flag), |
| Sm (Context_Pending, Flag), |
| Sm (First_Inlined_Subprogram, Node_Id), |
| Sm (Has_No_Elaboration_Code, Flag), |
| Sm (Has_Pragma_Suppress_All, Flag), |
| Sm (Library_Unit, Node_Id), |
| Sm (Save_Invocation_Graph_Of_Body, Flag))); |
| |
| Cc (N_Compilation_Unit_Aux, Node_Kind, |
| (Sy (Declarations, List_Id, Default_No_List), |
| Sy (Actions, List_Id, Default_No_List), |
| Sy (Pragmas_After, List_Id, Default_No_List), |
| Sy (Config_Pragmas, List_Id, Default_Empty_List), |
| Sm (Default_Storage_Pool, Node_Id))); |
| |
| Cc (N_Component_Association, Node_Kind, |
| (Sy (Choices, List_Id), |
| Sy (Expression, Node_Id, Default_Empty), |
| Sy (Box_Present, Flag), |
| Sy (Inherited_Discriminant, Flag), |
| Sy (Binding_Chars, Name_Id, Default_No_Name), |
| Sm (Loop_Actions, List_Id), |
| Sm (Was_Default_Init_Box_Association, Flag))); |
| |
| Cc (N_Component_Definition, Node_Kind, |
| (Sy (Aliased_Present, Flag), |
| Sy (Null_Exclusion_Present, Flag, Default_False), |
| Sy (Subtype_Indication, Node_Id, Default_Empty), |
| Sy (Access_Definition, Node_Id, Default_Empty))); |
| |
| Cc (N_Component_List, Node_Kind, |
| (Sy (Component_Items, List_Id), |
| Sy (Variant_Part, Node_Id, Default_Empty), |
| Sy (Null_Present, Flag))); |
| |
| Cc (N_Contract, Node_Kind, |
| (Sm (Classifications, Node_Id), |
| Sm (Contract_Test_Cases, Node_Id), |
| Sm (Is_Expanded_Contract, Flag), |
| Sm (Pre_Post_Conditions, Node_Id))); |
| |
| Cc (N_Derived_Type_Definition, Node_Kind, |
| (Sy (Abstract_Present, Flag), |
| Sy (Null_Exclusion_Present, Flag, Default_False), |
| Sy (Subtype_Indication, Node_Id, Default_Empty), |
| Sy (Record_Extension_Part, Node_Id, Default_Empty), |
| Sy (Limited_Present, Flag), |
| Sy (Task_Present, Flag), |
| Sy (Protected_Present, Flag), |
| Sy (Synchronized_Present, Flag), |
| Sy (Interface_List, List_Id, Default_No_List), |
| Sy (Interface_Present, Flag))); |
| |
| Cc (N_Decimal_Fixed_Point_Definition, Node_Kind, |
| (Sy (Delta_Expression, Node_Id), |
| Sy (Digits_Expression, Node_Id), |
| Sy (Real_Range_Specification, Node_Id, Default_Empty))); |
| |
| Cc (N_Defining_Program_Unit_Name, Node_Kind, |
| (Sy (Name, Node_Id, Default_Empty), |
| Sy (Defining_Identifier, Node_Id))); |
| |
| Cc (N_Delta_Constraint, Node_Kind, |
| (Sy (Delta_Expression, Node_Id), |
| Sy (Range_Constraint, Node_Id, Default_Empty))); |
| |
| Cc (N_Designator, Node_Kind, |
| (Sy (Name, Node_Id, Default_Empty), |
| Sy (Identifier, Node_Id, Default_Empty))); |
| |
| Cc (N_Digits_Constraint, Node_Kind, |
| (Sy (Digits_Expression, Node_Id), |
| Sy (Range_Constraint, Node_Id, Default_Empty))); |
| |
| Cc (N_Discriminant_Association, Node_Kind, |
| (Sy (Selector_Names, List_Id), |
| Sy (Expression, Node_Id, Default_Empty))); |
| |
| Cc (N_Discriminant_Specification, Node_Kind, |
| (Sy (Defining_Identifier, Node_Id), |
| Sy (Null_Exclusion_Present, Flag, Default_False), |
| Sy (Discriminant_Type, Node_Id), |
| Sy (Expression, Node_Id, Default_Empty), |
| Sm (More_Ids, Flag), |
| Sm (Prev_Ids, Flag))); |
| |
| Cc (N_Enumeration_Type_Definition, Node_Kind, |
| (Sy (Literals, List_Id), |
| Sy (End_Label, Node_Id, Default_Empty))); |
| |
| Cc (N_Entry_Body, Node_Kind, |
| (Sy (Defining_Identifier, Node_Id), |
| Sy (Entry_Body_Formal_Part, Node_Id), |
| Sy (Declarations, List_Id, Default_No_List), |
| Sy (Handled_Statement_Sequence, Node_Id, Default_Empty), |
| Sm (Activation_Chain_Entity, Node_Id))); |
| |
| Cc (N_Entry_Call_Alternative, Node_Kind, |
| (Sy (Entry_Call_Statement, Node_Id), |
| Sy (Statements, List_Id, Default_Empty_List), |
| Sy (Pragmas_Before, List_Id, Default_No_List))); |
| |
| Cc (N_Entry_Index_Specification, Node_Kind, |
| (Sy (Defining_Identifier, Node_Id), |
| Sy (Discrete_Subtype_Definition, Node_Id, Default_Empty))); |
| |
| Cc (N_Exception_Declaration, N_Declaration, |
| (Sy (Defining_Identifier, Node_Id), |
| Sm (Expression, Node_Id), |
| Sm (More_Ids, Flag), |
| Sm (Prev_Ids, Flag), |
| Sm (Renaming_Exception, Node_Id))); |
| |
| Cc (N_Exception_Handler, Node_Kind, |
| (Sy (Choice_Parameter, Node_Id, Default_Empty), |
| Sy (Exception_Choices, List_Id), |
| Sy (Statements, List_Id, Default_Empty_List), |
| Sm (Exception_Label, Node_Id), |
| Sm (Has_Local_Raise, Flag), |
| Sm (Local_Raise_Not_OK, Flag), |
| Sm (Local_Raise_Statements, Elist_Id))); |
| |
| Cc (N_Floating_Point_Definition, Node_Kind, |
| (Sy (Digits_Expression, Node_Id), |
| Sy (Real_Range_Specification, Node_Id, Default_Empty))); |
| |
| Cc (N_Formal_Decimal_Fixed_Point_Definition, Node_Kind); |
| |
| Cc (N_Formal_Derived_Type_Definition, Node_Kind, |
| (Sy (Subtype_Mark, Node_Id, Default_Empty), |
| Sy (Private_Present, Flag), |
| Sy (Abstract_Present, Flag), |
| Sy (Limited_Present, Flag), |
| Sy (Synchronized_Present, Flag), |
| Sy (Interface_List, List_Id, Default_No_List))); |
| |
| Cc (N_Formal_Discrete_Type_Definition, Node_Kind); |
| |
| Cc (N_Formal_Floating_Point_Definition, Node_Kind); |
| |
| Cc (N_Formal_Modular_Type_Definition, Node_Kind); |
| |
| Cc (N_Formal_Ordinary_Fixed_Point_Definition, Node_Kind); |
| |
| Cc (N_Formal_Package_Declaration, Node_Kind, |
| (Sy (Defining_Identifier, Node_Id), |
| Sy (Name, Node_Id, Default_Empty), |
| Sy (Generic_Associations, List_Id, Default_No_List), |
| Sy (Box_Present, Flag), |
| Sm (Instance_Spec, Node_Id), |
| Sm (Is_Known_Guaranteed_ABE, Flag))); |
| |
| Cc (N_Formal_Private_Type_Definition, Node_Kind, |
| (Sy (Abstract_Present, Flag), |
| Sy (Tagged_Present, Flag), |
| Sy (Limited_Present, Flag), |
| Sm (Uninitialized_Variable, Node_Id))); |
| |
| Cc (N_Formal_Incomplete_Type_Definition, Node_Kind, |
| (Sy (Tagged_Present, Flag))); |
| |
| Cc (N_Formal_Signed_Integer_Type_Definition, Node_Kind); |
| |
| Cc (N_Freeze_Entity, Node_Kind, |
| (Sy (Actions, List_Id, Default_No_List), |
| Sm (Access_Types_To_Process, Elist_Id), |
| Sm (Entity_Or_Associated_Node, Node_Id), -- just Entity |
| Sm (First_Subtype_Link, Node_Id), |
| Sm (TSS_Elist, Elist_Id))); |
| |
| Cc (N_Freeze_Generic_Entity, Node_Kind, |
| Sm (Entity_Or_Associated_Node, Node_Id)); -- just Entity |
| |
| Cc (N_Generic_Association, Node_Kind, |
| (Sy (Selector_Name, Node_Id, Default_Empty), |
| Sy (Explicit_Generic_Actual_Parameter, Node_Id), |
| Sy (Box_Present, Flag))); |
| |
| Cc (N_Handled_Sequence_Of_Statements, Node_Kind, |
| (Sy (Statements, List_Id, Default_Empty_List), |
| Sy (End_Label, Node_Id, Default_Empty), |
| Sy (Exception_Handlers, List_Id, Default_No_List), |
| Sy (At_End_Proc, Node_Id, Default_Empty), |
| Sm (First_Real_Statement, Node_Id))); |
| |
| Cc (N_Index_Or_Discriminant_Constraint, Node_Kind, |
| (Sy (Constraints, List_Id))); |
| |
| Cc (N_Iterated_Component_Association, Node_Kind, |
| (Sy (Defining_Identifier, Node_Id), |
| Sy (Iterator_Specification, Node_Id, Default_Empty), |
| Sy (Expression, Node_Id, Default_Empty), |
| Sy (Discrete_Choices, List_Id), |
| Sy (Box_Present, Flag), |
| Sm (Loop_Actions, List_Id))); |
| |
| Cc (N_Iterated_Element_Association, Node_Kind, |
| (Sy (Key_Expression, Node_Id), |
| Sy (Iterator_Specification, Node_Id, Default_Empty), |
| Sy (Expression, Node_Id, Default_Empty), |
| Sy (Loop_Parameter_Specification, Node_Id, Default_Empty), |
| Sy (Box_Present, Flag), |
| Sm (Loop_Actions, List_Id))); |
| |
| Cc (N_Itype_Reference, Node_Kind, |
| (Sm (Itype, Node_Id))); |
| |
| Cc (N_Label, Node_Kind, |
| (Sy (Identifier, Node_Id, Default_Empty), |
| Sm (Exception_Junk, Flag))); |
| |
| Cc (N_Modular_Type_Definition, Node_Kind, |
| (Sy (Expression, Node_Id, Default_Empty))); |
| |
| Cc (N_Number_Declaration, Node_Kind, |
| (Sy (Defining_Identifier, Node_Id), |
| Sy (Expression, Node_Id, Default_Empty), |
| Sm (More_Ids, Flag), |
| Sm (Prev_Ids, Flag))); |
| |
| Cc (N_Ordinary_Fixed_Point_Definition, Node_Kind, |
| (Sy (Delta_Expression, Node_Id), |
| Sy (Real_Range_Specification, Node_Id, Default_Empty))); |
| |
| Cc (N_Others_Choice, Node_Kind, |
| (Sm (All_Others, Flag), |
| Sm (Others_Discrete_Choices, List_Id))); |
| |
| Cc (N_Package_Specification, Node_Kind, |
| (Sy (Defining_Unit_Name, Node_Id), |
| Sy (Visible_Declarations, List_Id), |
| Sy (Private_Declarations, List_Id, Default_No_List), |
| Sy (End_Label, Node_Id, Default_Empty), |
| Sm (Generic_Parent, Node_Id), |
| Sm (Limited_View_Installed, Flag))); |
| |
| Cc (N_Parameter_Association, Node_Kind, |
| (Sy (Selector_Name, Node_Id, Default_Empty), |
| Sy (Explicit_Actual_Parameter, Node_Id), |
| Sm (Is_Accessibility_Actual, Flag), |
| Sm (Next_Named_Actual, Node_Id))); |
| |
| Cc (N_Parameter_Specification, Node_Kind, |
| (Sy (Defining_Identifier, Node_Id), |
| Sy (Aliased_Present, Flag), |
| Sy (In_Present, Flag), |
| Sy (Out_Present, Flag), |
| Sy (Null_Exclusion_Present, Flag, Default_False), |
| Sy (Parameter_Type, Node_Id), |
| Sy (Expression, Node_Id, Default_Empty), |
| Sm (Default_Expression, Node_Id), |
| Sm (More_Ids, Flag), |
| Sm (Prev_Ids, Flag))); |
| |
| Cc (N_Pragma, Node_Kind, |
| (Sy (Pragma_Argument_Associations, List_Id, Default_No_List), |
| Sy (Pragma_Identifier, Node_Id), |
| Sy (Class_Present, Flag), |
| Sy (Split_PPC, Flag), |
| Sm (Corresponding_Aspect, Node_Id), |
| Sm (From_Aspect_Specification, Flag), |
| Sm (Import_Interface_Present, Flag), |
| Sm (Is_Analyzed_Pragma, Flag), |
| Sm (Is_Checked, Flag), |
| Sm (Is_Checked_Ghost_Pragma, Flag), |
| Sm (Is_Delayed_Aspect, Flag), |
| Sm (Is_Disabled, Flag), |
| Sm (Is_Generic_Contract_Pragma, Flag), |
| Sm (Is_Ignored, Flag), |
| Sm (Is_Ignored_Ghost_Pragma, Flag), |
| Sm (Is_Inherited_Pragma, Flag), |
| Sm (Next_Pragma, Node_Id), |
| Sm (Next_Rep_Item, Node_Id), |
| Sm (Uneval_Old_Accept, Flag), |
| Sm (Uneval_Old_Warn, Flag))); |
| |
| Cc (N_Protected_Definition, Node_Kind, |
| (Sy (Visible_Declarations, List_Id), |
| Sy (Private_Declarations, List_Id, Default_No_List), |
| Sy (End_Label, Node_Id, Default_Empty))); |
| |
| Cc (N_Range_Constraint, Node_Kind, |
| (Sy (Range_Expression, Node_Id))); |
| |
| Cc (N_Real_Range_Specification, Node_Kind, |
| (Sy (Low_Bound, Node_Id), |
| Sy (High_Bound, Node_Id))); |
| |
| Cc (N_Record_Definition, Node_Kind, |
| (Sy (End_Label, Node_Id, Default_Empty), |
| Sy (Abstract_Present, Flag), |
| Sy (Tagged_Present, Flag), |
| Sy (Limited_Present, Flag), |
| Sy (Component_List, Node_Id), |
| Sy (Null_Present, Flag), |
| Sy (Task_Present, Flag), |
| Sy (Protected_Present, Flag), |
| Sy (Synchronized_Present, Flag), |
| Sy (Interface_Present, Flag), |
| Sy (Interface_List, List_Id, Default_No_List))); |
| |
| Cc (N_Signed_Integer_Type_Definition, Node_Kind, |
| (Sy (Low_Bound, Node_Id), |
| Sy (High_Bound, Node_Id))); |
| |
| Cc (N_Single_Protected_Declaration, Node_Kind, |
| (Sy (Defining_Identifier, Node_Id), |
| Sy (Interface_List, List_Id, Default_No_List), |
| Sy (Protected_Definition, Node_Id))); |
| |
| Cc (N_Subunit, Node_Kind, |
| (Sy (Name, Node_Id, Default_Empty), |
| Sy (Proper_Body, Node_Id), |
| Sm (Corresponding_Stub, Node_Id))); |
| |
| Cc (N_Task_Definition, Node_Kind, |
| (Sy (Visible_Declarations, List_Id), |
| Sy (Private_Declarations, List_Id, Default_No_List), |
| Sy (End_Label, Node_Id, Default_Empty), |
| Sm (Has_Relative_Deadline_Pragma, Flag), |
| Sm (Has_Storage_Size_Pragma, Flag))); |
| |
| Cc (N_Triggering_Alternative, Node_Kind, |
| (Sy (Triggering_Statement, Node_Id), |
| Sy (Statements, List_Id, Default_Empty_List), |
| Sy (Pragmas_Before, List_Id, Default_No_List))); |
| |
| Cc (N_Use_Type_Clause, Node_Kind, |
| (Sy (Subtype_Mark, Node_Id, Default_Empty), |
| Sy (Is_Effective_Use_Clause, Flag), |
| Sy (All_Present, Flag), |
| Sm (Hidden_By_Use_Clause, Elist_Id), |
| Sm (More_Ids, Flag), |
| Sm (Next_Use_Clause, Node_Id), |
| Sm (Prev_Ids, Flag), |
| Sm (Prev_Use_Clause, Node_Id), |
| Sm (Used_Operations, Elist_Id))); |
| |
| Cc (N_Validate_Unchecked_Conversion, Node_Kind, |
| (Sm (Source_Type, Node_Id), |
| Sm (Target_Type, Node_Id))); |
| |
| Cc (N_Variable_Reference_Marker, Node_Kind, |
| (Sm (Is_Elaboration_Checks_OK_Node, Flag), |
| Sm (Is_Elaboration_Warnings_OK_Node, Flag), |
| Sm (Is_Read, Flag), |
| Sm (Is_SPARK_Mode_On_Node, Flag), |
| Sm (Is_Write, Flag), |
| Sm (Target, Node_Id))); |
| |
| Cc (N_Variant, Node_Kind, |
| (Sy (Discrete_Choices, List_Id), |
| Sy (Component_List, Node_Id), |
| Sm (Dcheck_Function, Node_Id), |
| Sm (Enclosing_Variant, Node_Id), |
| Sm (Has_SP_Choice, Flag), |
| Sm (Present_Expr, Valid_Uint))); |
| |
| Cc (N_Variant_Part, Node_Kind, |
| (Sy (Name, Node_Id, Default_Empty), |
| Sy (Variants, List_Id))); |
| |
| Cc (N_With_Clause, Node_Kind, |
| (Sy (Name, Node_Id, Default_Empty), |
| Sy (Private_Present, Flag), |
| Sy (Limited_Present, Flag), |
| Sy (First_Name, Flag, Default_True), |
| Sy (Last_Name, Flag, Default_True), |
| Sm (Context_Installed, Flag), |
| Sm (Corresponding_Spec, Node_Id), |
| Sm (Elaborate_All_Desirable, Flag), |
| Sm (Elaborate_All_Present, Flag), |
| Sm (Elaborate_Desirable, Flag), |
| Sm (Elaborate_Present, Flag), |
| Sm (Implicit_With, Flag), |
| Sm (Library_Unit, Node_Id), |
| Sm (Limited_View_Installed, Flag), |
| Sm (Next_Implicit_With, Node_Id), |
| Sm (No_Entities_Ref_In_Spec, Flag), |
| Sm (Parent_With, Flag), |
| Sm (Unreferenced_In_Spec, Flag))); |
| |
| Cc (N_Unused_At_End, Node_Kind); |
| |
| -- Union types. These don't fit into the normal parent/child hierarchy |
| -- above. |
| |
| Union (N_Has_Chars, |
| Children => |
| (N_Attribute_Definition_Clause, |
| N_Empty, |
| N_Pragma_Argument_Association, |
| N_Error, |
| N_Entity, |
| N_Expanded_Name, |
| N_Identifier, |
| N_Operator_Symbol, |
| N_Character_Literal, |
| N_Op)); |
| |
| Union (N_Has_Condition, |
| Children => |
| (N_Exit_Statement, |
| N_If_Statement, |
| N_Accept_Alternative, |
| N_Delay_Alternative, |
| N_Elsif_Part, |
| N_Entry_Body_Formal_Part, |
| N_Iteration_Scheme, |
| N_Terminate_Alternative)); |
| -- Nodes with condition fields (does not include N_Raise_xxx_Error) |
| |
| Union (N_Has_Bounds, |
| Children => |
| (N_Range, |
| N_Real_Range_Specification, |
| N_Signed_Integer_Type_Definition)); |
| -- Nodes that have Low_Bound and High_Bound defined |
| |
| Union (N_Is_Index, |
| Children => |
| (N_Has_Bounds, |
| N_Has_Entity, |
| N_Subtype_Indication)); |
| -- Nodes that can be an index of an array |
| |
| Union (N_Entity_Name, |
| Children => |
| (N_Expanded_Name, |
| N_Identifier, |
| N_Operator_Symbol)); |
| -- Nodes that are definitely representing an entity. |
| -- Some N_Attribute_Reference nodes may also represent an entity. See |
| -- Is_Entity_Name. |
| |
| Union (N_Is_Decl, |
| Children => |
| (N_Aggregate, |
| N_Block_Statement, |
| N_Declaration, |
| N_Discriminant_Specification, |
| N_Entry_Index_Specification, |
| N_Enumeration_Type_Definition, |
| N_Exception_Handler, |
| N_Explicit_Dereference, |
| N_Expression_With_Actions, |
| N_Extension_Aggregate, |
| N_Identifier, |
| N_Iterated_Component_Association, |
| N_Later_Decl_Item, |
| N_Loop_Statement, |
| N_Null_Statement, |
| N_Number_Declaration, |
| N_Package_Specification, |
| N_Parameter_Specification, |
| N_Renaming_Declaration, |
| N_Quantified_Expression)); |
| -- Nodes that can be returned by Declaration_Node; it can also return |
| -- Empty. Not all of these are true "declarations", but Declaration_Node |
| -- can return them in some cases. |
| |
| Union (N_Is_Range, |
| Children => |
| (N_Character_Literal, |
| N_Entity_Name, |
| N_Has_Bounds, |
| N_Integer_Literal, |
| N_Subtype_Indication)); |
| -- Nodes that can be used to specify a range |
| |
| Union (N_Is_Case_Choice, |
| Children => |
| (N_Is_Range, |
| N_Others_Choice)); |
| -- Nodes that can be in the choices of a case statement |
| |
| Union (N_Is_Exception_Choice, |
| Children => |
| (N_Entity_Name, |
| N_Others_Choice)); |
| -- Nodes that can be in the choices of an exception handler |
| |
| Union (N_Alternative, |
| Children => |
| (N_Case_Statement_Alternative, |
| N_Variant)); |
| -- Nodes that can be alternatives in case contructs |
| |
| end Gen_IL.Gen.Gen_Nodes; |
