-- -- Copyright (C) 2014-2022, AdaCore -- SPDX-License-Identifier: Apache-2.0 -- with Ada.Exceptions; use Ada.Exceptions; with Ada.Unchecked_Conversion; with Ada.Unchecked_Deallocation; with System; with Langkit_Support.Slocs; use Langkit_Support.Slocs; with Langkit_Support.Token_Data_Handlers; use Langkit_Support.Token_Data_Handlers; with Libadalang.Common; use Libadalang.Common; with Libadalang.Implementation; with Libadalang.Lexer_Implementation; use Libadalang.Lexer_Implementation; with Libadalang.Unparsing_Implementation; use Libadalang.Unparsing_Implementation; package body Libadalang.Rewriting_Implementation is function Convert is new Ada.Unchecked_Conversion (Rewriting_Handle, Rewriting_Handle_Pointer); function Convert is new Ada.Unchecked_Conversion (Rewriting_Handle_Pointer, Rewriting_Handle); procedure Pre_Check (Value : Boolean; Msg : String); -- Raise a Precondition_Failure exception with the given message -- if the Value is False. --------------- -- Pre_Check -- --------------- procedure Pre_Check (Value : Boolean; Msg : String) is begin if not Value then raise Precondition_Failure with Msg; end if; end Pre_Check; function Handle (Context : Internal_Context) return Rewriting_Handle is (Convert (Get_Rewriting_Handle (Context))); function Context (Handle : Rewriting_Handle) return Internal_Context is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Handle.Context; end Context; function Allocate (Kind : Ada_Node_Kind_Type; Context : Rewriting_Handle; Unit_Handle : Unit_Rewriting_Handle; Parent_Handle : Node_Rewriting_Handle) return Node_Rewriting_Handle with Pre => Context /= No_Rewriting_Handle and then (Unit_Handle = No_Unit_Rewriting_Handle or else Unit_Handle.Context_Handle = Context) and then (Parent_Handle = No_Node_Rewriting_Handle or else Parent_Handle.Context_Handle = Context); function Allocate (Node : Bare_Ada_Node; Context : Rewriting_Handle; Unit_Handle : Unit_Rewriting_Handle; Parent_Handle : Node_Rewriting_Handle) return Node_Rewriting_Handle with Pre => Context /= No_Rewriting_Handle and then (Unit_Handle = No_Unit_Rewriting_Handle or else Unit_Handle.Context_Handle = Context) and then (Parent_Handle = No_Node_Rewriting_Handle or else Parent_Handle.Context_Handle = Context); -- Allocate a handle for Node and register it in Unit_Handle's map procedure Expand_Children (Node : Node_Rewriting_Handle) with Pre => Node /= No_Node_Rewriting_Handle; -- If Node.Children.Kind is Unexpanded, populate Node's list of Children to -- mimic the related bare AST node. Otherwise, do nothing. procedure Free_Handles (Handle : in out Rewriting_Handle); -- Free all resources tied to Handle. This also releases the rewriting -- handle singleton in Handle's Context. procedure Tie (Handle, Parent : Node_Rewriting_Handle; Unit : Unit_Rewriting_Handle); -- Tie the node represented by handle so that either: -- -- * it is the root of Unit (Parent is null); -- * it is a child of Parent (Unit is null). -- -- Do nothing if Handle is null. procedure Untie (Handle : Node_Rewriting_Handle); -- Untie the node represented by Handle. Do nothing if Handle is null. --------------------- -- Start_Rewriting -- --------------------- function Start_Rewriting (Context : Internal_Context) return Rewriting_Handle is begin Pre_Check (Handle (Context) = No_Rewriting_Handle, "Handle (Context) must be null"); if Context.File_Reader /= null then raise Precondition_Failure with "tree rewriting forbidden with a file reader"; end if; declare Result : constant Rewriting_Handle := new Rewriting_Handle_Type' (Context => Context, Units => <>, Pool => Create, New_Nodes => <>); begin Result.New_Nodes := Nodes_Pools.Create (Result.Pool); Set_Rewriting_Handle (Context, Convert (Result)); return Result; end; end Start_Rewriting; --------------------- -- Abort_Rewriting -- --------------------- procedure Abort_Rewriting (Handle : in out Rewriting_Handle) is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); Free_Handles (Handle); end Abort_Rewriting; ----------- -- Apply -- ----------- function Apply (Handle : in out Rewriting_Handle) return Apply_Result is type Processed_Unit_Record is record Unit : Internal_Unit; New_Data : Reparsed_Unit; end record; type Processed_Unit is access Processed_Unit_Record; procedure Free is new Ada.Unchecked_Deallocation (Processed_Unit_Record, Processed_Unit); package Processed_Unit_Vectors is new Ada.Containers.Vectors (Positive, Processed_Unit); Units : Processed_Unit_Vectors.Vector; Result : Apply_Result := (Success => True); begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); -- Try to reparse all units that were potentially modified for Unit_Handle of Handle.Units loop declare PU : constant Processed_Unit := new Processed_Unit_Record' (Unit => Unit_Handle.Unit, New_Data => <>); Input : Internal_Lexer_Input := (Kind => Bytes_Buffer, Charset => <>, Read_BOM => False, Bytes => System.Null_Address, Bytes_Count => 0); Bytes : String_Access; function Error_Result return Apply_Result is ((Success => False, Unit => PU.Unit, Diagnostics => <>)); begin Units.Append (PU); -- Reparse (i.e. unparse and then parse) this rewritten unit begin Bytes := Unparse (Create_Abstract_Node (Unit_Handle.Root), PU.Unit, Preserve_Formatting => True, As_Unit => True); exception when Exc : Malformed_Tree_Error => Result := Error_Result; Append (Result.Diagnostics, No_Source_Location_Range, To_Text (Exception_Message (Exc))); exit; end; Input.Charset := Unit_Handle.Unit.Charset; Input.Bytes := Bytes.all'Address; Input.Bytes_Count := Bytes.all'Length; Do_Parsing (PU.Unit, Input, PU.New_Data); Free (Bytes); -- If there is a parsing error, abort the rewriting process if not PU.New_Data.Diagnostics.Is_Empty then Result := Error_Result; Result.Diagnostics.Move (PU.New_Data.Diagnostics); Destroy (PU.New_Data); exit; end if; end; end loop; -- If all reparsing went fine, actually replace the AST nodes all over -- the context and free all resources associated to Handle. if Result.Success then for PU of Units loop Update_After_Reparse (PU.Unit, PU.New_Data); end loop; Free_Handles (Handle); end if; -- Clean-up our local resources and return for PU of Units loop Free (PU); end loop; return Result; end Apply; ------------------ -- Unit_Handles -- ------------------ function Unit_Handles (Handle : Rewriting_Handle) return Unit_Rewriting_Handle_Array is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); declare Count : constant Natural := Natural (Handle.Units.Length); Result : Unit_Rewriting_Handle_Array (1 .. Count); I : Positive := 1; begin for Unit of Handle.Units loop Result (I) := Unit; I := I + 1; end loop; return Result; end; end Unit_Handles; ------------ -- Handle -- ------------ function Handle (Unit : Internal_Unit) return Unit_Rewriting_Handle is begin Pre_Check (Handle (Context (Unit)) /= No_Rewriting_Handle, "Handle (Context (Unit)) should not be null"); Pre_Check (not Has_Diagnostics (Unit), "Unit must not have diagnostics"); declare use Unit_Maps; Context : constant Internal_Context := Unit.Context; Context_Handle : constant Rewriting_Handle := Handle (Context); Filename : constant Unbounded_String := To_Unbounded_String (Get_Filename (Unit)); Cur : constant Cursor := Context_Handle.Units.Find (Filename); begin if Cur /= No_Element then return Element (Cur); end if; declare Result : constant Unit_Rewriting_Handle := new Unit_Rewriting_Handle_Type'(Context_Handle => Context_Handle, Unit => Unit, Root => <>, Nodes => <>); begin Context_Handle.Units.Insert (Filename, Result); Result.Root := Handle (Root (Unit)); return Result; end; end; end Handle; ---------- -- Unit -- ---------- function Unit (Handle : Unit_Rewriting_Handle) return Internal_Unit is begin Pre_Check (Handle /= No_Unit_Rewriting_Handle, "Handle should not be null"); return Handle.Unit; end Unit; ---------- -- Root -- ---------- function Root (Handle : Unit_Rewriting_Handle) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Unit_Rewriting_Handle, "Handle should not be null"); return Handle.Root; end Root; -------------- -- Set_Root -- -------------- procedure Set_Root (Handle : Unit_Rewriting_Handle; Root : Node_Rewriting_Handle) is begin Pre_Check (Handle /= No_Unit_Rewriting_Handle, "Handle should not be null"); Pre_Check (Root = No_Node_Rewriting_Handle or else not Tied (Root), "Root must not be tied to another rewriting context."); Untie (Handle.Root); Handle.Root := Root; Tie (Root, No_Node_Rewriting_Handle, Handle); end Set_Root; ------------- -- Unparse -- ------------- function Unparse (Handle : Unit_Rewriting_Handle) return Unbounded_Text_Type is begin Pre_Check (Handle /= No_Unit_Rewriting_Handle, "Handle should not be null"); return Unparsing_Implementation.Unparse (Node => Create_Abstract_Node (Handle.Root), Unit => Handle.Unit, Preserve_Formatting => True, As_Unit => True); end Unparse; ------------ -- Handle -- ------------ function Handle (Node : Bare_Ada_Node) return Node_Rewriting_Handle is begin Pre_Check (Handle (Context (Node.Unit)) /= No_Rewriting_Handle, "Handle (Context (Node.Unit)) should not be null"); Pre_Check (not Has_Diagnostics (Node.Unit), "Node.Unit must not have diagnostics"); if Node = null then return No_Node_Rewriting_Handle; end if; declare use Node_Maps; Unit_Handle : constant Unit_Rewriting_Handle := Handle (Node.Unit); Cur : constant Cursor := Unit_Handle.Nodes.Find (Node); begin -- If we have already built a handle for this node, just return it if Cur /= No_Element then return Element (Cur); -- Otherwise, if this node has a parent, make sure this parent has -- its own handle, then expand its children. This last must create -- the handle we are supposed to return. elsif Node.Parent /= null then Expand_Children (Handle (Node.Parent)); return Element (Unit_Handle.Nodes.Find (Node)); end if; -- Otherwise, we are dealing with the root node: just create its -- rewriting handle. return Allocate (Node, Unit_Handle.Context_Handle, Unit_Handle, No_Node_Rewriting_Handle); end; end Handle; ---------- -- Node -- ---------- function Node (Handle : Node_Rewriting_Handle) return Bare_Ada_Node is begin Pre_Check (Handle /= No_Node_Rewriting_Handle, "Handle should not be null"); return Handle.Node; end Node; ------------- -- Context -- ------------- function Context (Handle : Node_Rewriting_Handle) return Rewriting_Handle is begin Pre_Check (Handle /= No_Node_Rewriting_Handle, "Handle should not be null"); return Handle.Context_Handle; end Context; ------------- -- Unparse -- ------------- function Unparse (Handle : Node_Rewriting_Handle) return Text_Type is begin Pre_Check (Handle /= No_Node_Rewriting_Handle, "Handle should not be null"); return To_Wide_Wide_String (Unparsing_Implementation.Unparse (Create_Abstract_Node (Handle), Unit => null, Preserve_Formatting => True, As_Unit => False)); end Unparse; -------------- -- Allocate -- -------------- function Allocate (Kind : Ada_Node_Kind_Type; Context : Rewriting_Handle; Unit_Handle : Unit_Rewriting_Handle; Parent_Handle : Node_Rewriting_Handle) return Node_Rewriting_Handle is Tied : constant Boolean := Unit_Handle /= No_Unit_Rewriting_Handle; begin return new Node_Rewriting_Handle_Type' (Context_Handle => Context, Node => null, Parent => Parent_Handle, Kind => Kind, Tied => Tied, Root_Of => (if Tied and then Parent_Handle = No_Node_Rewriting_Handle then Unit_Handle else No_Unit_Rewriting_Handle), Children => Unexpanded_Children); end Allocate; -------------- -- Allocate -- -------------- function Allocate (Node : Bare_Ada_Node; Context : Rewriting_Handle; Unit_Handle : Unit_Rewriting_Handle; Parent_Handle : Node_Rewriting_Handle) return Node_Rewriting_Handle is Result : constant Node_Rewriting_Handle := Allocate (Node.Kind, Context, Unit_Handle, Parent_Handle); begin Result.Node := Node; if Result.Tied then Unit_Handle.Nodes.Insert (Node, Result); end if; return Result; end Allocate; --------------------- -- Expand_Children -- --------------------- procedure Expand_Children (Node : Node_Rewriting_Handle) is Children : Node_Children renames Node.Children; begin -- If this handle has already be expanded, there is nothing to do if Children.Kind /= Unexpanded then return; end if; -- Otherwise, expand to the appropriate children form: token node or -- regular one. declare N : constant Bare_Ada_Node := Node.Node; Unit_Handle : constant Unit_Rewriting_Handle := Handle (N.Unit); begin if Is_Token_Node (N) then Children := (Kind => Expanded_Token_Node, Text => To_Unbounded_Wide_Wide_String (Text (N))); else Children := (Kind => Expanded_Regular, Vector => <>); declare Count : constant Natural := Children_Count (N); begin Children.Vector.Reserve_Capacity (Ada.Containers.Count_Type (Count)); for I in 1 .. Count loop declare Child : constant Bare_Ada_Node := Implementation.Child (N, I); begin Children.Vector.Append ((if Child = null then null else Allocate (Child, Unit_Handle.Context_Handle, Unit_Handle, Node))); end; end loop; end; end if; end; end Expand_Children; ------------------ -- Free_Handles -- ------------------ procedure Free_Handles (Handle : in out Rewriting_Handle) is procedure Free is new Ada.Unchecked_Deallocation (Rewriting_Handle_Type, Rewriting_Handle); procedure Free is new Ada.Unchecked_Deallocation (Unit_Rewriting_Handle_Type, Unit_Rewriting_Handle); procedure Free is new Ada.Unchecked_Deallocation (Node_Rewriting_Handle_Type, Node_Rewriting_Handle); Ctx : constant Internal_Context := Context (Handle); begin -- Free all resources tied to Handle for Unit of Handle.Units loop for Node of Unit.Nodes loop Free (Node); end loop; Free (Unit); end loop; for Node of Handle.New_Nodes loop declare N : Node_Rewriting_Handle := Node; begin Free (N); end; end loop; Free (Handle.Pool); Free (Handle); -- Release the rewriting handle singleton for its context Set_Rewriting_Handle (Ctx, Convert (Handle)); end Free_Handles; --------- -- Tie -- --------- procedure Tie (Handle, Parent : Node_Rewriting_Handle; Unit : Unit_Rewriting_Handle) is begin if Handle /= No_Node_Rewriting_Handle then Handle.Parent := Parent; Handle.Tied := True; if Parent = No_Node_Rewriting_Handle then Handle.Root_Of := Unit; end if; end if; end Tie; ----------- -- Untie -- ----------- procedure Untie (Handle : Node_Rewriting_Handle) is begin if Handle /= No_Node_Rewriting_Handle then Handle.Parent := No_Node_Rewriting_Handle; Handle.Tied := False; Handle.Root_Of := No_Unit_Rewriting_Handle; end if; end Untie; ---------- -- Kind -- ---------- function Kind (Handle : Node_Rewriting_Handle) return Ada_Node_Kind_Type is begin Pre_Check (Handle /= No_Node_Rewriting_Handle, "Handle should not be null"); return Handle.Kind; end Kind; ---------- -- Tied -- ---------- function Tied (Handle : Node_Rewriting_Handle) return Boolean is begin Pre_Check (Handle /= No_Node_Rewriting_Handle, "Handle should not be null"); return Handle.Tied; end Tied; ------------ -- Parent -- ------------ function Parent (Handle : Node_Rewriting_Handle) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Node_Rewriting_Handle, "Handle should not be null"); return Handle.Parent; end Parent; -------------------- -- Children_Count -- -------------------- function Children_Count (Handle : Node_Rewriting_Handle) return Natural is begin Pre_Check (Handle /= No_Node_Rewriting_Handle, "Handle should not be null"); return (case Handle.Children.Kind is when Unexpanded => Children_Count (Handle.Node), when Expanded_Regular => Natural (Handle.Children.Vector.Length), when Expanded_Token_Node => 0); end Children_Count; ----------- -- Child -- ----------- function Child (Handle : Node_Rewriting_Handle; Index : Positive) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Node_Rewriting_Handle, "Handle should not be null"); if Index > Children_Count (Handle) then raise Precondition_Failure with "Invalid index " & Index'Image & ": Handle has " & Children_Count (Handle)'Image & " children"; end if; -- If this handle represents an already existing node, make sure it is -- expanded so we have a handle to return. Expand_Children (Handle); return Handle.Children.Vector.Element (Index); end Child; --------------- -- Set_Child -- --------------- procedure Set_Child (Handle : Node_Rewriting_Handle; Index : Positive; Child : Node_Rewriting_Handle) is begin Pre_Check (Handle /= No_Node_Rewriting_Handle, "Handle should not be null"); if Index > Children_Count (Handle) then raise Precondition_Failure with "Invalid index " & Index'Image & ": Handle has " & Children_Count (Handle)'Image & " children"; end if; Pre_Check (Child = No_Node_Rewriting_Handle or else not Tied (Child), "Child must not be tied to another rewriting context."); -- If this handle represents an already existing node, make sure it is -- expanded so that its children vector can be modified. Expand_Children (Handle); declare Child_Slot : Node_Rewriting_Handle renames Handle.Children.Vector.Reference (Index); begin -- Untie the child to be replaced if it exists Untie (Child_Slot); -- Tie the new child if it exists Tie (Child, Handle, No_Unit_Rewriting_Handle); Child_Slot := Child; end; end Set_Child; ---------- -- Text -- ---------- function Text (Handle : Node_Rewriting_Handle) return Text_Type is begin Pre_Check (Handle /= No_Node_Rewriting_Handle, "Handle should not be null"); Pre_Check (Is_Token_Node (Kind (Handle)), "Expected a token node. Got " & Kind (Handle)'Image); case Handle.Children.Kind is when Unexpanded => if Is_Token_Node (Handle.Kind) then return Text (Handle.Node); else raise Program_Error; end if; when Expanded_Regular => return (raise Program_Error); when Expanded_Token_Node => return To_Wide_Wide_String (Handle.Children.Text); end case; end Text; -------------- -- Set_Text -- -------------- procedure Set_Text (Handle : Node_Rewriting_Handle; Text : Text_Type) is begin Pre_Check (Handle /= No_Node_Rewriting_Handle, "Handle should not be null"); Pre_Check (Is_Token_Node (Kind (Handle)), "Expected a token node. Got " & Kind (Handle)'Image); -- Make sure Handle is expanded so we have a Text field to override Expand_Children (Handle); Handle.Children.Text := To_Unbounded_Wide_Wide_String (Text); end Set_Text; ------------- -- Replace -- ------------- procedure Replace (Handle, New_Node : Node_Rewriting_Handle) is begin Pre_Check (Handle /= No_Node_Rewriting_Handle, "Handle should not be null"); Pre_Check (Tied (Handle), "Handle must be tied to an analysis unit."); Pre_Check (New_Node = No_Node_Rewriting_Handle or else not Tied (New_Node), "New_Node must not be tied to another rewriting context."); if Handle = New_Node then return; end if; if Handle.Root_Of = No_Unit_Rewriting_Handle then -- If Handle is not the root node of its owning unit, go replace it -- in its parent's children list. declare Parent : Node_Rewriting_Handle renames Handle.Parent; Index : Natural := 0; begin for I in 1 .. Children_Count (Parent) loop if Child (Parent, I) = Handle then Index := I; exit; end if; end loop; pragma Assert (Index > 0); Set_Child (Parent, Index, New_Node); end; else -- Otherwise, replace it as a root node Set_Root (Handle.Root_Of, New_Node); end if; end Replace; ------------------ -- Insert_Child -- ------------------ procedure Insert_Child (Handle : Node_Rewriting_Handle; Index : Positive; Child : Node_Rewriting_Handle) is begin Pre_Check (Handle /= No_Node_Rewriting_Handle, "Handle should not be null"); Pre_Check (Is_List_Node (Kind (Handle)), "Expected a list node. Got " & Kind (Handle)'Image); if Index > Children_Count (Handle) + 1 then raise Precondition_Failure with "Invalid index " & Index'Image & ": Handle has " & Children_Count (Handle)'Image & " children"; end if; Pre_Check (Child = No_Node_Rewriting_Handle or else not Tied (Child), "Child must not be tied to another rewriting context."); -- First, just create room for the new node and let Set_Child take care -- of tiding Child to Handle's tree. Expand_Children (Handle); Handle.Children.Vector.Insert (Index, No_Node_Rewriting_Handle); Set_Child (Handle, Index, Child); end Insert_Child; ------------------ -- Append_Child -- ------------------ procedure Append_Child (Handle : Node_Rewriting_Handle; Child : Node_Rewriting_Handle) is begin Pre_Check (Handle /= No_Node_Rewriting_Handle, "Handle should not be null"); Pre_Check (Is_List_Node (Kind (Handle)), "Expected a list node. Got " & Kind (Handle)'Image); Pre_Check (Child = No_Node_Rewriting_Handle or else not Tied (Child), "Child must not be tied to another rewriting context."); Insert_Child (Handle, Children_Count (Handle) + 1, Child); end Append_Child; ------------------ -- Remove_Child -- ------------------ procedure Remove_Child (Handle : Node_Rewriting_Handle; Index : Positive) is begin Pre_Check (Handle /= No_Node_Rewriting_Handle, "Handle should not be null"); Pre_Check (Is_List_Node (Kind (Handle)), "Expected a list node. Got " & Kind (Handle)'Image); if Index > Children_Count (Handle) + 1 then raise Precondition_Failure with "Invalid index " & Index'Image & ": Handle has " & Children_Count (Handle)'Image & " children"; end if; -- First, let Set_Child take care of untiding the child to remove, and -- then actually remove the corresponding children list slot. Set_Child (Handle, Index, No_Node_Rewriting_Handle); Handle.Children.Vector.Delete (Index); end Remove_Child; ----------- -- Clone -- ----------- function Clone (Handle : Node_Rewriting_Handle) return Node_Rewriting_Handle is Result : Node_Rewriting_Handle; begin if Handle = No_Node_Rewriting_Handle then return Handle; end if; -- Make sure the original handle is expanded so we can iterate on it Expand_Children (Handle); -- If the input handle is associated to a node, so should be the cloned -- handle, so that its formatting is copied as well. Result := (if Handle.Node = null then Allocate (Handle.Kind, Handle.Context_Handle, No_Unit_Rewriting_Handle, No_Node_Rewriting_Handle) else Allocate (Handle.Node, Handle.Context_Handle, No_Unit_Rewriting_Handle, No_Node_Rewriting_Handle)); Nodes_Pools.Append (Handle.Context_Handle.New_Nodes, Result); -- Recursively clone children case Handle.Children.Kind is when Unexpanded => raise Program_Error; when Expanded_Token_Node => Result.Children := (Kind => Expanded_Token_Node, Text => Handle.Children.Text); when Expanded_Regular => Result.Children := (Kind => Expanded_Regular, Vector => <>); Result.Children.Vector.Reserve_Capacity (Handle.Children.Vector.Length); for I in 1 .. Handle.Children.Vector.Last_Index loop Result.Children.Vector.Append (Clone (Handle.Children.Vector.Element (I))); end loop; end case; return Result; end Clone; ----------------- -- Create_Node -- ----------------- function Create_Node (Handle : Rewriting_Handle; Kind : Ada_Node_Kind_Type) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); Pre_Check (not Is_Error_Node (Kind), "Expected a non-error node. Got " & Kind'Image); if Is_Token_Node (Kind) then return Create_Token_Node (Handle, Kind, ""); else declare Count : constant Integer := Kind_To_Node_Children_Count (Kind); Children : constant Node_Rewriting_Handle_Array (1 .. Count) := (others => No_Node_Rewriting_Handle); begin return Create_Regular_Node (Handle, Kind, Children); end; end if; end Create_Node; ----------------------- -- Create_Token_Node -- ----------------------- function Create_Token_Node (Handle : Rewriting_Handle; Kind : Ada_Node_Kind_Type; Text : Text_Type) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); Pre_Check (Is_Token_Node (Kind), "Expected a token node. Got " & Kind'Image); declare Result : constant Node_Rewriting_Handle := Allocate (Kind, Handle, No_Unit_Rewriting_Handle, No_Node_Rewriting_Handle); begin Result.Children := (Kind => Expanded_Token_Node, Text => To_Unbounded_Wide_Wide_String (Text)); Nodes_Pools.Append (Handle.New_Nodes, Result); return Result; end; end Create_Token_Node; ------------------------- -- Create_Regular_Node -- ------------------------- function Create_Regular_Node (Handle : Rewriting_Handle; Kind : Ada_Node_Kind_Type; Children : Node_Rewriting_Handle_Array) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); Pre_Check (not Is_Token_Node (Kind), "Expected a token node. Got " & Kind'Image); Pre_Check (not Is_Error_Node (Kind), "Expected a non-error node. Got " & Kind'Image); for One_Child of Children loop Pre_Check (One_Child = No_Node_Rewriting_Handle or else not Tied (One_Child), "One_Child must not be tied to another rewriting context."); end loop; declare Result : Node_Rewriting_Handle := Allocate (Kind, Handle, No_Unit_Rewriting_Handle, No_Node_Rewriting_Handle); begin Result.Children := (Kind => Expanded_Regular, Vector => <>); Result.Children.Vector.Reserve_Capacity (Children'Length); for C of Children loop Result.Children.Vector.Append (C); if C /= No_Node_Rewriting_Handle then Tie (C, Result, No_Unit_Rewriting_Handle); end if; end loop; Nodes_Pools.Append (Handle.New_Nodes, Result); return Result; end; end Create_Regular_Node; -------------------------- -- Create_From_Template -- -------------------------- function Create_From_Template (Handle : Rewriting_Handle; Template : Text_Type; Arguments : Node_Rewriting_Handle_Array; Rule : Grammar_Rule) return Node_Rewriting_Handle is type State_Type is ( Default, -- Default state: no meta character being processed Open_Brace, -- The previous character is a open brace: the current one -- determines what it means. Close_Brace -- The previous character is a closing brace: the current one must be -- another closing brace. ); Buffer : Unbounded_Wide_Wide_String; State : State_Type := Default; Next_Arg : Positive := Arguments'First; begin for One_Argument of Arguments loop Pre_Check (One_Argument = No_Node_Rewriting_Handle or else Context (One_Argument) = Handle, "One_Argument should be associated to rewriting context Handle."); end loop; -- Interpret the template looping over its characters with a state -- machine. for C of Template loop case State is when Default => case C is when '{' => State := Open_Brace; when '}' => State := Close_Brace; when others => Append (Buffer, C); end case; when Open_Brace => case C is when '{' => State := Default; Append (Buffer, C); when '}' => State := Default; if Next_Arg in Arguments'Range then declare Unparsed_Arg : constant Wide_Wide_String := Unparse (Arguments (Next_Arg)); begin Next_Arg := Next_Arg + 1; Append (Buffer, Unparsed_Arg); end; else raise Template_Args_Error with "not enough arguments provided"; end if; when others => raise Template_Format_Error with "standalone ""{"" character"; end case; when Close_Brace => case C is when '}' => State := Default; Append (Buffer, C); when others => raise Template_Format_Error with "standalone ""}"" character"; end case; end case; end loop; -- Make sure that there is no standalone metacharacter at the end of the -- template. case State is when Default => null; when Open_Brace => raise Template_Format_Error with "standalone ""{"" character"; when Close_Brace => raise Template_Format_Error with "standalone ""}"" character"; end case; -- Make sure all given arguments were consumed if Next_Arg in Arguments'Range then raise Template_Args_Error with "too many arguments provided"; end if; -- Now parse the resulting buffer and create the corresponding tree of -- nodes. declare Context : constant Internal_Context := Rewriting_Implementation.Context (Handle); Unit : constant Internal_Unit := Templates_Unit (Context); Reparsed : Reparsed_Unit; Text : constant Text_Type := To_Wide_Wide_String (Buffer); Input : constant Internal_Lexer_Input := (Kind => Text_Buffer, Text => Text'Address, Text_Count => Text'Length); function Transform (Node : Bare_Ada_Node; Parent : Node_Rewriting_Handle) return Node_Rewriting_Handle; -- Turn a node from the Reparsed unit into a recursively expanded -- node rewriting handle. --------------- -- Transform -- --------------- function Transform (Node : Bare_Ada_Node; Parent : Node_Rewriting_Handle) return Node_Rewriting_Handle is Result : Node_Rewriting_Handle; begin if Node = null then return No_Node_Rewriting_Handle; end if; -- Allocate the handle for Node, and don't forget to remove the -- backlink to Node itself as it exists only temporarily for -- template instantiation. Also, track the newly allocated node -- so that it is freed correctly upon destruction of the -- rewriting context. Result := Allocate (Node, Handle, No_Unit_Rewriting_Handle, Parent); Result.Node := null; Nodes_Pools.Append (Handle.New_Nodes, Result); if Is_Token_Node (Node) then declare Index : constant Natural := Natural (Node.Token_Start_Index); Data : constant Stored_Token_Data := Reparsed.TDH.Tokens.Get (Index); Text : constant Text_Type := Reparsed.TDH.Source_Buffer (Data.Source_First .. Data.Source_Last); begin Result.Children := (Kind => Expanded_Token_Node, Text => To_Unbounded_Wide_Wide_String (Text)); end; else declare Count : constant Natural := Children_Count (Node); begin Result.Children := (Kind => Expanded_Regular, Vector => <>); Result.Children.Vector.Reserve_Capacity (Ada.Containers.Count_Type (Count)); for I in 1 .. Count loop Result.Children.Vector.Append (Transform (Child (Node, I), Result)); end loop; end; end if; return Result; end Transform; begin Set_Rule (Unit, Rule); Do_Parsing (Unit, Input, Reparsed); if not Reparsed.Diagnostics.Is_Empty then Destroy (Reparsed); raise Template_Instantiation_Error; end if; declare Result : constant Node_Rewriting_Handle := Transform (Reparsed.Ast_Root, No_Node_Rewriting_Handle); begin Destroy (Reparsed); return Result; end; end; end Create_From_Template; function Create_Constrained_Array_Indices (Handle : Rewriting_Handle ; Constrained_Array_Indices_F_List : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Constrained_Array_Indices, (1 => Constrained_Array_Indices_F_List)); end; function Create_Unconstrained_Array_Indices (Handle : Rewriting_Handle ; Unconstrained_Array_Indices_F_Types : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Unconstrained_Array_Indices, (1 => Unconstrained_Array_Indices_F_Types)); end; function Create_Aspect_Assoc (Handle : Rewriting_Handle ; Aspect_Assoc_F_Id : Node_Rewriting_Handle ; Aspect_Assoc_F_Expr : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Aspect_Assoc, (1 => Aspect_Assoc_F_Id, 2 => Aspect_Assoc_F_Expr)); end; function Create_At_Clause (Handle : Rewriting_Handle ; At_Clause_F_Name : Node_Rewriting_Handle ; At_Clause_F_Expr : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_At_Clause, (1 => At_Clause_F_Name, 2 => At_Clause_F_Expr)); end; function Create_Attribute_Def_Clause (Handle : Rewriting_Handle ; Attribute_Def_Clause_F_Attribute_Expr : Node_Rewriting_Handle ; Attribute_Def_Clause_F_Expr : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Attribute_Def_Clause, (1 => Attribute_Def_Clause_F_Attribute_Expr, 2 => Attribute_Def_Clause_F_Expr)); end; function Create_Enum_Rep_Clause (Handle : Rewriting_Handle ; Enum_Rep_Clause_F_Type_Name : Node_Rewriting_Handle ; Enum_Rep_Clause_F_Aggregate : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Enum_Rep_Clause, (1 => Enum_Rep_Clause_F_Type_Name, 2 => Enum_Rep_Clause_F_Aggregate)); end; function Create_Record_Rep_Clause (Handle : Rewriting_Handle ; Record_Rep_Clause_F_Name : Node_Rewriting_Handle ; Record_Rep_Clause_F_At_Expr : Node_Rewriting_Handle ; Record_Rep_Clause_F_Components : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Record_Rep_Clause, (1 => Record_Rep_Clause_F_Name, 2 => Record_Rep_Clause_F_At_Expr, 3 => Record_Rep_Clause_F_Components)); end; function Create_Aspect_Spec (Handle : Rewriting_Handle ; Aspect_Spec_F_Aspect_Assocs : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Aspect_Spec, (1 => Aspect_Spec_F_Aspect_Assocs)); end; function Create_Contract_Case_Assoc (Handle : Rewriting_Handle ; Contract_Case_Assoc_F_Guard : Node_Rewriting_Handle ; Contract_Case_Assoc_F_Consequence : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Contract_Case_Assoc, (1 => Contract_Case_Assoc_F_Guard, 2 => Contract_Case_Assoc_F_Consequence)); end; function Create_Pragma_Argument_Assoc (Handle : Rewriting_Handle ; Pragma_Argument_Assoc_F_Name : Node_Rewriting_Handle ; Pragma_Argument_Assoc_F_Expr : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Pragma_Argument_Assoc, (1 => Pragma_Argument_Assoc_F_Name, 2 => Pragma_Argument_Assoc_F_Expr)); end; function Create_Entry_Spec (Handle : Rewriting_Handle ; Entry_Spec_F_Entry_Name : Node_Rewriting_Handle ; Entry_Spec_F_Family_Type : Node_Rewriting_Handle ; Entry_Spec_F_Entry_Params : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Entry_Spec, (1 => Entry_Spec_F_Entry_Name, 2 => Entry_Spec_F_Family_Type, 3 => Entry_Spec_F_Entry_Params)); end; function Create_Subp_Spec (Handle : Rewriting_Handle ; Subp_Spec_F_Subp_Kind : Node_Rewriting_Handle ; Subp_Spec_F_Subp_Name : Node_Rewriting_Handle ; Subp_Spec_F_Subp_Params : Node_Rewriting_Handle ; Subp_Spec_F_Subp_Returns : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Subp_Spec, (1 => Subp_Spec_F_Subp_Kind, 2 => Subp_Spec_F_Subp_Name, 3 => Subp_Spec_F_Subp_Params, 4 => Subp_Spec_F_Subp_Returns)); end; function Create_Synthetic_Binary_Spec (Handle : Rewriting_Handle ; Synthetic_Binary_Spec_F_Left_Param : Node_Rewriting_Handle ; Synthetic_Binary_Spec_F_Right_Param : Node_Rewriting_Handle ; Synthetic_Binary_Spec_F_Return_Type_Expr : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Synthetic_Binary_Spec, (1 => Synthetic_Binary_Spec_F_Left_Param, 2 => Synthetic_Binary_Spec_F_Right_Param, 3 => Synthetic_Binary_Spec_F_Return_Type_Expr)); end; function Create_Synthetic_Unary_Spec (Handle : Rewriting_Handle ; Synthetic_Unary_Spec_F_Right_Param : Node_Rewriting_Handle ; Synthetic_Unary_Spec_F_Return_Type_Expr : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Synthetic_Unary_Spec, (1 => Synthetic_Unary_Spec_F_Right_Param, 2 => Synthetic_Unary_Spec_F_Return_Type_Expr)); end; function Create_Component_List (Handle : Rewriting_Handle ; Component_List_F_Components : Node_Rewriting_Handle ; Component_List_F_Variant_Part : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Component_List, (1 => Component_List_F_Components, 2 => Component_List_F_Variant_Part)); end; function Create_Known_Discriminant_Part (Handle : Rewriting_Handle ; Known_Discriminant_Part_F_Discr_Specs : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Known_Discriminant_Part, (1 => Known_Discriminant_Part_F_Discr_Specs)); end; function Create_Entry_Completion_Formal_Params (Handle : Rewriting_Handle ; Entry_Completion_Formal_Params_F_Params : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Entry_Completion_Formal_Params, (1 => Entry_Completion_Formal_Params_F_Params)); end; function Create_Generic_Formal_Part (Handle : Rewriting_Handle ; Generic_Formal_Part_F_Decls : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Generic_Formal_Part, (1 => Generic_Formal_Part_F_Decls)); end; function Create_Null_Record_Def (Handle : Rewriting_Handle ; Base_Record_Def_F_Components : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Null_Record_Def, (1 => Base_Record_Def_F_Components)); end; function Create_Record_Def (Handle : Rewriting_Handle ; Base_Record_Def_F_Components : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Record_Def, (1 => Base_Record_Def_F_Components)); end; function Create_Aggregate_Assoc (Handle : Rewriting_Handle ; Aggregate_Assoc_F_Designators : Node_Rewriting_Handle ; Aggregate_Assoc_F_R_Expr : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Aggregate_Assoc, (1 => Aggregate_Assoc_F_Designators, 2 => Aggregate_Assoc_F_R_Expr)); end; function Create_Multi_Dim_Array_Assoc (Handle : Rewriting_Handle ; Aggregate_Assoc_F_Designators : Node_Rewriting_Handle ; Aggregate_Assoc_F_R_Expr : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Multi_Dim_Array_Assoc, (1 => Aggregate_Assoc_F_Designators, 2 => Aggregate_Assoc_F_R_Expr)); end; function Create_Composite_Constraint_Assoc (Handle : Rewriting_Handle ; Composite_Constraint_Assoc_F_Ids : Node_Rewriting_Handle ; Composite_Constraint_Assoc_F_Constraint_Expr : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Composite_Constraint_Assoc, (1 => Composite_Constraint_Assoc_F_Ids, 2 => Composite_Constraint_Assoc_F_Constraint_Expr)); end; function Create_Iterated_Assoc (Handle : Rewriting_Handle ; Iterated_Assoc_F_Spec : Node_Rewriting_Handle ; Iterated_Assoc_F_R_Expr : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Iterated_Assoc, (1 => Iterated_Assoc_F_Spec, 2 => Iterated_Assoc_F_R_Expr)); end; function Create_Param_Assoc (Handle : Rewriting_Handle ; Param_Assoc_F_Designator : Node_Rewriting_Handle ; Param_Assoc_F_R_Expr : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Param_Assoc, (1 => Param_Assoc_F_Designator, 2 => Param_Assoc_F_R_Expr)); end; function Create_Abstract_State_Decl (Handle : Rewriting_Handle ; Abstract_State_Decl_F_Name : Node_Rewriting_Handle ; Abstract_State_Decl_F_Aspects : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Abstract_State_Decl, (1 => Abstract_State_Decl_F_Name, 2 => Abstract_State_Decl_F_Aspects)); end; function Create_Anonymous_Expr_Decl (Handle : Rewriting_Handle ; Anonymous_Expr_Decl_F_Expr : Node_Rewriting_Handle ; Anonymous_Expr_Decl_F_Aspects : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Anonymous_Expr_Decl, (1 => Anonymous_Expr_Decl_F_Expr, 2 => Anonymous_Expr_Decl_F_Aspects)); end; function Create_Component_Decl (Handle : Rewriting_Handle ; Component_Decl_F_Ids : Node_Rewriting_Handle ; Component_Decl_F_Component_Def : Node_Rewriting_Handle ; Component_Decl_F_Default_Expr : Node_Rewriting_Handle ; Component_Decl_F_Aspects : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Component_Decl, (1 => Component_Decl_F_Ids, 2 => Component_Decl_F_Component_Def, 3 => Component_Decl_F_Default_Expr, 4 => Component_Decl_F_Aspects)); end; function Create_Discriminant_Spec (Handle : Rewriting_Handle ; Discriminant_Spec_F_Ids : Node_Rewriting_Handle ; Discriminant_Spec_F_Type_Expr : Node_Rewriting_Handle ; Discriminant_Spec_F_Default_Expr : Node_Rewriting_Handle ; Discriminant_Spec_F_Aspects : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Discriminant_Spec, (1 => Discriminant_Spec_F_Ids, 2 => Discriminant_Spec_F_Type_Expr, 3 => Discriminant_Spec_F_Default_Expr, 4 => Discriminant_Spec_F_Aspects)); end; function Create_Generic_Formal_Obj_Decl (Handle : Rewriting_Handle ; Generic_Formal_F_Decl : Node_Rewriting_Handle ; Generic_Formal_F_Aspects : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Generic_Formal_Obj_Decl, (1 => Generic_Formal_F_Decl, 2 => Generic_Formal_F_Aspects)); end; function Create_Generic_Formal_Package (Handle : Rewriting_Handle ; Generic_Formal_F_Decl : Node_Rewriting_Handle ; Generic_Formal_F_Aspects : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Generic_Formal_Package, (1 => Generic_Formal_F_Decl, 2 => Generic_Formal_F_Aspects)); end; function Create_Generic_Formal_Subp_Decl (Handle : Rewriting_Handle ; Generic_Formal_F_Decl : Node_Rewriting_Handle ; Generic_Formal_F_Aspects : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Generic_Formal_Subp_Decl, (1 => Generic_Formal_F_Decl, 2 => Generic_Formal_F_Aspects)); end; function Create_Generic_Formal_Type_Decl (Handle : Rewriting_Handle ; Generic_Formal_F_Decl : Node_Rewriting_Handle ; Generic_Formal_F_Aspects : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Generic_Formal_Type_Decl, (1 => Generic_Formal_F_Decl, 2 => Generic_Formal_F_Aspects)); end; function Create_Param_Spec (Handle : Rewriting_Handle ; Param_Spec_F_Ids : Node_Rewriting_Handle ; Param_Spec_F_Has_Aliased : Node_Rewriting_Handle ; Param_Spec_F_Mode : Node_Rewriting_Handle ; Param_Spec_F_Type_Expr : Node_Rewriting_Handle ; Param_Spec_F_Default_Expr : Node_Rewriting_Handle ; Param_Spec_F_Aspects : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Param_Spec, (1 => Param_Spec_F_Ids, 2 => Param_Spec_F_Has_Aliased, 3 => Param_Spec_F_Mode, 4 => Param_Spec_F_Type_Expr, 5 => Param_Spec_F_Default_Expr, 6 => Param_Spec_F_Aspects)); end; function Create_Synthetic_Formal_Param_Decl (Handle : Rewriting_Handle ; Synthetic_Formal_Param_Decl_F_Param_Type : Node_Rewriting_Handle ; Synthetic_Formal_Param_Decl_F_Aspects : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Synthetic_Formal_Param_Decl, (1 => Synthetic_Formal_Param_Decl_F_Param_Type, 2 => Synthetic_Formal_Param_Decl_F_Aspects)); end; function Create_Generic_Package_Internal (Handle : Rewriting_Handle ; Base_Package_Decl_F_Package_Name : Node_Rewriting_Handle ; Base_Package_Decl_F_Aspects : Node_Rewriting_Handle ; Base_Package_Decl_F_Public_Part : Node_Rewriting_Handle ; Base_Package_Decl_F_Private_Part : Node_Rewriting_Handle ; Base_Package_Decl_F_End_Name : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Generic_Package_Internal, (1 => Base_Package_Decl_F_Package_Name, 2 => Base_Package_Decl_F_Aspects, 3 => Base_Package_Decl_F_Public_Part, 4 => Base_Package_Decl_F_Private_Part, 5 => Base_Package_Decl_F_End_Name)); end; function Create_Package_Decl (Handle : Rewriting_Handle ; Base_Package_Decl_F_Package_Name : Node_Rewriting_Handle ; Base_Package_Decl_F_Aspects : Node_Rewriting_Handle ; Base_Package_Decl_F_Public_Part : Node_Rewriting_Handle ; Base_Package_Decl_F_Private_Part : Node_Rewriting_Handle ; Base_Package_Decl_F_End_Name : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Package_Decl, (1 => Base_Package_Decl_F_Package_Name, 2 => Base_Package_Decl_F_Aspects, 3 => Base_Package_Decl_F_Public_Part, 4 => Base_Package_Decl_F_Private_Part, 5 => Base_Package_Decl_F_End_Name)); end; function Create_Discrete_Base_Subtype_Decl (Handle : Rewriting_Handle ; Base_Type_Decl_F_Name : Node_Rewriting_Handle ; Discrete_Base_Subtype_Decl_F_Aspects : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Discrete_Base_Subtype_Decl, (1 => Base_Type_Decl_F_Name, 2 => Discrete_Base_Subtype_Decl_F_Aspects)); end; function Create_Subtype_Decl (Handle : Rewriting_Handle ; Base_Type_Decl_F_Name : Node_Rewriting_Handle ; Subtype_Decl_F_Subtype : Node_Rewriting_Handle ; Subtype_Decl_F_Aspects : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Subtype_Decl, (1 => Base_Type_Decl_F_Name, 2 => Subtype_Decl_F_Subtype, 3 => Subtype_Decl_F_Aspects)); end; function Create_Classwide_Type_Decl (Handle : Rewriting_Handle ; Base_Type_Decl_F_Name : Node_Rewriting_Handle ; Classwide_Type_Decl_F_Aspects : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Classwide_Type_Decl, (1 => Base_Type_Decl_F_Name, 2 => Classwide_Type_Decl_F_Aspects)); end; function Create_Incomplete_Type_Decl (Handle : Rewriting_Handle ; Base_Type_Decl_F_Name : Node_Rewriting_Handle ; Incomplete_Type_Decl_F_Discriminants : Node_Rewriting_Handle ; Incomplete_Type_Decl_F_Aspects : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Incomplete_Type_Decl, (1 => Base_Type_Decl_F_Name, 2 => Incomplete_Type_Decl_F_Discriminants, 3 => Incomplete_Type_Decl_F_Aspects)); end; function Create_Incomplete_Formal_Type_Decl (Handle : Rewriting_Handle ; Base_Type_Decl_F_Name : Node_Rewriting_Handle ; Incomplete_Type_Decl_F_Discriminants : Node_Rewriting_Handle ; Incomplete_Type_Decl_F_Aspects : Node_Rewriting_Handle ; Incomplete_Formal_Type_Decl_F_Is_Tagged : Node_Rewriting_Handle ; Incomplete_Formal_Type_Decl_F_Default_Type : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Incomplete_Formal_Type_Decl, (1 => Base_Type_Decl_F_Name, 2 => Incomplete_Type_Decl_F_Discriminants, 3 => Incomplete_Type_Decl_F_Aspects, 4 => Incomplete_Formal_Type_Decl_F_Is_Tagged, 5 => Incomplete_Formal_Type_Decl_F_Default_Type)); end; function Create_Incomplete_Tagged_Type_Decl (Handle : Rewriting_Handle ; Base_Type_Decl_F_Name : Node_Rewriting_Handle ; Incomplete_Type_Decl_F_Discriminants : Node_Rewriting_Handle ; Incomplete_Type_Decl_F_Aspects : Node_Rewriting_Handle ; Incomplete_Tagged_Type_Decl_F_Has_Abstract : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Incomplete_Tagged_Type_Decl, (1 => Base_Type_Decl_F_Name, 2 => Incomplete_Type_Decl_F_Discriminants, 3 => Incomplete_Type_Decl_F_Aspects, 4 => Incomplete_Tagged_Type_Decl_F_Has_Abstract)); end; function Create_Protected_Type_Decl (Handle : Rewriting_Handle ; Base_Type_Decl_F_Name : Node_Rewriting_Handle ; Protected_Type_Decl_F_Discriminants : Node_Rewriting_Handle ; Protected_Type_Decl_F_Aspects : Node_Rewriting_Handle ; Protected_Type_Decl_F_Interfaces : Node_Rewriting_Handle ; Protected_Type_Decl_F_Definition : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Protected_Type_Decl, (1 => Base_Type_Decl_F_Name, 2 => Protected_Type_Decl_F_Discriminants, 3 => Protected_Type_Decl_F_Aspects, 4 => Protected_Type_Decl_F_Interfaces, 5 => Protected_Type_Decl_F_Definition)); end; function Create_Task_Type_Decl (Handle : Rewriting_Handle ; Base_Type_Decl_F_Name : Node_Rewriting_Handle ; Task_Type_Decl_F_Discriminants : Node_Rewriting_Handle ; Task_Type_Decl_F_Aspects : Node_Rewriting_Handle ; Task_Type_Decl_F_Definition : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Task_Type_Decl, (1 => Base_Type_Decl_F_Name, 2 => Task_Type_Decl_F_Discriminants, 3 => Task_Type_Decl_F_Aspects, 4 => Task_Type_Decl_F_Definition)); end; function Create_Single_Task_Type_Decl (Handle : Rewriting_Handle ; Base_Type_Decl_F_Name : Node_Rewriting_Handle ; Task_Type_Decl_F_Discriminants : Node_Rewriting_Handle ; Task_Type_Decl_F_Aspects : Node_Rewriting_Handle ; Task_Type_Decl_F_Definition : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Single_Task_Type_Decl, (1 => Base_Type_Decl_F_Name, 2 => Task_Type_Decl_F_Discriminants, 3 => Task_Type_Decl_F_Aspects, 4 => Task_Type_Decl_F_Definition)); end; function Create_Anonymous_Type_Decl (Handle : Rewriting_Handle ; Base_Type_Decl_F_Name : Node_Rewriting_Handle ; Type_Decl_F_Discriminants : Node_Rewriting_Handle ; Type_Decl_F_Type_Def : Node_Rewriting_Handle ; Anonymous_Type_Decl_F_Aspects : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Anonymous_Type_Decl, (1 => Base_Type_Decl_F_Name, 2 => Type_Decl_F_Discriminants, 3 => Type_Decl_F_Type_Def, 4 => Anonymous_Type_Decl_F_Aspects)); end; function Create_Synth_Anonymous_Type_Decl (Handle : Rewriting_Handle ; Base_Type_Decl_F_Name : Node_Rewriting_Handle ; Type_Decl_F_Discriminants : Node_Rewriting_Handle ; Type_Decl_F_Type_Def : Node_Rewriting_Handle ; Anonymous_Type_Decl_F_Aspects : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Synth_Anonymous_Type_Decl, (1 => Base_Type_Decl_F_Name, 2 => Type_Decl_F_Discriminants, 3 => Type_Decl_F_Type_Def, 4 => Anonymous_Type_Decl_F_Aspects)); end; function Create_Concrete_Type_Decl (Handle : Rewriting_Handle ; Base_Type_Decl_F_Name : Node_Rewriting_Handle ; Type_Decl_F_Discriminants : Node_Rewriting_Handle ; Type_Decl_F_Type_Def : Node_Rewriting_Handle ; Concrete_Type_Decl_F_Aspects : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Concrete_Type_Decl, (1 => Base_Type_Decl_F_Name, 2 => Type_Decl_F_Discriminants, 3 => Type_Decl_F_Type_Def, 4 => Concrete_Type_Decl_F_Aspects)); end; function Create_Formal_Type_Decl (Handle : Rewriting_Handle ; Base_Type_Decl_F_Name : Node_Rewriting_Handle ; Type_Decl_F_Discriminants : Node_Rewriting_Handle ; Type_Decl_F_Type_Def : Node_Rewriting_Handle ; Formal_Type_Decl_F_Default_Type : Node_Rewriting_Handle ; Formal_Type_Decl_F_Aspects : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Formal_Type_Decl, (1 => Base_Type_Decl_F_Name, 2 => Type_Decl_F_Discriminants, 3 => Type_Decl_F_Type_Def, 4 => Formal_Type_Decl_F_Default_Type, 5 => Formal_Type_Decl_F_Aspects)); end; function Create_Abstract_Subp_Decl (Handle : Rewriting_Handle ; Classic_Subp_Decl_F_Overriding : Node_Rewriting_Handle ; Classic_Subp_Decl_F_Subp_Spec : Node_Rewriting_Handle ; Abstract_Subp_Decl_F_Aspects : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Abstract_Subp_Decl, (1 => Classic_Subp_Decl_F_Overriding, 2 => Classic_Subp_Decl_F_Subp_Spec, 3 => Abstract_Subp_Decl_F_Aspects)); end; function Create_Abstract_Formal_Subp_Decl (Handle : Rewriting_Handle ; Classic_Subp_Decl_F_Overriding : Node_Rewriting_Handle ; Classic_Subp_Decl_F_Subp_Spec : Node_Rewriting_Handle ; Formal_Subp_Decl_F_Default_Expr : Node_Rewriting_Handle ; Formal_Subp_Decl_F_Aspects : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Abstract_Formal_Subp_Decl, (1 => Classic_Subp_Decl_F_Overriding, 2 => Classic_Subp_Decl_F_Subp_Spec, 3 => Formal_Subp_Decl_F_Default_Expr, 4 => Formal_Subp_Decl_F_Aspects)); end; function Create_Concrete_Formal_Subp_Decl (Handle : Rewriting_Handle ; Classic_Subp_Decl_F_Overriding : Node_Rewriting_Handle ; Classic_Subp_Decl_F_Subp_Spec : Node_Rewriting_Handle ; Formal_Subp_Decl_F_Default_Expr : Node_Rewriting_Handle ; Formal_Subp_Decl_F_Aspects : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Concrete_Formal_Subp_Decl, (1 => Classic_Subp_Decl_F_Overriding, 2 => Classic_Subp_Decl_F_Subp_Spec, 3 => Formal_Subp_Decl_F_Default_Expr, 4 => Formal_Subp_Decl_F_Aspects)); end; function Create_Subp_Decl (Handle : Rewriting_Handle ; Classic_Subp_Decl_F_Overriding : Node_Rewriting_Handle ; Classic_Subp_Decl_F_Subp_Spec : Node_Rewriting_Handle ; Subp_Decl_F_Aspects : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Subp_Decl, (1 => Classic_Subp_Decl_F_Overriding, 2 => Classic_Subp_Decl_F_Subp_Spec, 3 => Subp_Decl_F_Aspects)); end; function Create_Entry_Decl (Handle : Rewriting_Handle ; Entry_Decl_F_Overriding : Node_Rewriting_Handle ; Entry_Decl_F_Spec : Node_Rewriting_Handle ; Entry_Decl_F_Aspects : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Entry_Decl, (1 => Entry_Decl_F_Overriding, 2 => Entry_Decl_F_Spec, 3 => Entry_Decl_F_Aspects)); end; function Create_Enum_Literal_Decl (Handle : Rewriting_Handle ; Enum_Literal_Decl_F_Name : Node_Rewriting_Handle ; Enum_Literal_Decl_F_Aspects : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Enum_Literal_Decl, (1 => Enum_Literal_Decl_F_Name, 2 => Enum_Literal_Decl_F_Aspects)); end; function Create_Synthetic_Char_Enum_Lit (Handle : Rewriting_Handle ; Enum_Literal_Decl_F_Name : Node_Rewriting_Handle ; Enum_Literal_Decl_F_Aspects : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Synthetic_Char_Enum_Lit, (1 => Enum_Literal_Decl_F_Name, 2 => Enum_Literal_Decl_F_Aspects)); end; function Create_Generic_Subp_Internal (Handle : Rewriting_Handle ; Generic_Subp_Internal_F_Subp_Spec : Node_Rewriting_Handle ; Generic_Subp_Internal_F_Aspects : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Generic_Subp_Internal, (1 => Generic_Subp_Internal_F_Subp_Spec, 2 => Generic_Subp_Internal_F_Aspects)); end; function Create_Synthetic_Subp_Decl (Handle : Rewriting_Handle ; Synthetic_Subp_Decl_F_Aspects : Node_Rewriting_Handle ; Synthetic_Subp_Decl_F_Spec : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Synthetic_Subp_Decl, (1 => Synthetic_Subp_Decl_F_Aspects, 2 => Synthetic_Subp_Decl_F_Spec)); end; function Create_Accept_Stmt_Body (Handle : Rewriting_Handle ; Accept_Stmt_Body_F_Name : Node_Rewriting_Handle ; Accept_Stmt_Body_F_Aspects : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Accept_Stmt_Body, (1 => Accept_Stmt_Body_F_Name, 2 => Accept_Stmt_Body_F_Aspects)); end; function Create_Expr_Function (Handle : Rewriting_Handle ; Base_Subp_Body_F_Overriding : Node_Rewriting_Handle ; Base_Subp_Body_F_Subp_Spec : Node_Rewriting_Handle ; Expr_Function_F_Expr : Node_Rewriting_Handle ; Expr_Function_F_Aspects : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Expr_Function, (1 => Base_Subp_Body_F_Overriding, 2 => Base_Subp_Body_F_Subp_Spec, 3 => Expr_Function_F_Expr, 4 => Expr_Function_F_Aspects)); end; function Create_Null_Subp_Decl (Handle : Rewriting_Handle ; Base_Subp_Body_F_Overriding : Node_Rewriting_Handle ; Base_Subp_Body_F_Subp_Spec : Node_Rewriting_Handle ; Null_Subp_Decl_F_Aspects : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Null_Subp_Decl, (1 => Base_Subp_Body_F_Overriding, 2 => Base_Subp_Body_F_Subp_Spec, 3 => Null_Subp_Decl_F_Aspects)); end; function Create_Subp_Body (Handle : Rewriting_Handle ; Base_Subp_Body_F_Overriding : Node_Rewriting_Handle ; Base_Subp_Body_F_Subp_Spec : Node_Rewriting_Handle ; Subp_Body_F_Aspects : Node_Rewriting_Handle ; Subp_Body_F_Decls : Node_Rewriting_Handle ; Subp_Body_F_Stmts : Node_Rewriting_Handle ; Subp_Body_F_End_Name : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Subp_Body, (1 => Base_Subp_Body_F_Overriding, 2 => Base_Subp_Body_F_Subp_Spec, 3 => Subp_Body_F_Aspects, 4 => Subp_Body_F_Decls, 5 => Subp_Body_F_Stmts, 6 => Subp_Body_F_End_Name)); end; function Create_Subp_Renaming_Decl (Handle : Rewriting_Handle ; Base_Subp_Body_F_Overriding : Node_Rewriting_Handle ; Base_Subp_Body_F_Subp_Spec : Node_Rewriting_Handle ; Subp_Renaming_Decl_F_Renames : Node_Rewriting_Handle ; Subp_Renaming_Decl_F_Aspects : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Subp_Renaming_Decl, (1 => Base_Subp_Body_F_Overriding, 2 => Base_Subp_Body_F_Subp_Spec, 3 => Subp_Renaming_Decl_F_Renames, 4 => Subp_Renaming_Decl_F_Aspects)); end; function Create_Package_Body_Stub (Handle : Rewriting_Handle ; Package_Body_Stub_F_Name : Node_Rewriting_Handle ; Package_Body_Stub_F_Aspects : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Package_Body_Stub, (1 => Package_Body_Stub_F_Name, 2 => Package_Body_Stub_F_Aspects)); end; function Create_Protected_Body_Stub (Handle : Rewriting_Handle ; Protected_Body_Stub_F_Name : Node_Rewriting_Handle ; Protected_Body_Stub_F_Aspects : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Protected_Body_Stub, (1 => Protected_Body_Stub_F_Name, 2 => Protected_Body_Stub_F_Aspects)); end; function Create_Subp_Body_Stub (Handle : Rewriting_Handle ; Subp_Body_Stub_F_Overriding : Node_Rewriting_Handle ; Subp_Body_Stub_F_Subp_Spec : Node_Rewriting_Handle ; Subp_Body_Stub_F_Aspects : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Subp_Body_Stub, (1 => Subp_Body_Stub_F_Overriding, 2 => Subp_Body_Stub_F_Subp_Spec, 3 => Subp_Body_Stub_F_Aspects)); end; function Create_Task_Body_Stub (Handle : Rewriting_Handle ; Task_Body_Stub_F_Name : Node_Rewriting_Handle ; Task_Body_Stub_F_Aspects : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Task_Body_Stub, (1 => Task_Body_Stub_F_Name, 2 => Task_Body_Stub_F_Aspects)); end; function Create_Entry_Body (Handle : Rewriting_Handle ; Entry_Body_F_Entry_Name : Node_Rewriting_Handle ; Entry_Body_F_Index_Spec : Node_Rewriting_Handle ; Entry_Body_F_Params : Node_Rewriting_Handle ; Entry_Body_F_Aspects : Node_Rewriting_Handle ; Entry_Body_F_Barrier : Node_Rewriting_Handle ; Entry_Body_F_Decls : Node_Rewriting_Handle ; Entry_Body_F_Stmts : Node_Rewriting_Handle ; Entry_Body_F_End_Name : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Entry_Body, (1 => Entry_Body_F_Entry_Name, 2 => Entry_Body_F_Index_Spec, 3 => Entry_Body_F_Params, 4 => Entry_Body_F_Aspects, 5 => Entry_Body_F_Barrier, 6 => Entry_Body_F_Decls, 7 => Entry_Body_F_Stmts, 8 => Entry_Body_F_End_Name)); end; function Create_Package_Body (Handle : Rewriting_Handle ; Package_Body_F_Package_Name : Node_Rewriting_Handle ; Package_Body_F_Aspects : Node_Rewriting_Handle ; Package_Body_F_Decls : Node_Rewriting_Handle ; Package_Body_F_Stmts : Node_Rewriting_Handle ; Package_Body_F_End_Name : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Package_Body, (1 => Package_Body_F_Package_Name, 2 => Package_Body_F_Aspects, 3 => Package_Body_F_Decls, 4 => Package_Body_F_Stmts, 5 => Package_Body_F_End_Name)); end; function Create_Protected_Body (Handle : Rewriting_Handle ; Protected_Body_F_Name : Node_Rewriting_Handle ; Protected_Body_F_Aspects : Node_Rewriting_Handle ; Protected_Body_F_Decls : Node_Rewriting_Handle ; Protected_Body_F_End_Name : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Protected_Body, (1 => Protected_Body_F_Name, 2 => Protected_Body_F_Aspects, 3 => Protected_Body_F_Decls, 4 => Protected_Body_F_End_Name)); end; function Create_Task_Body (Handle : Rewriting_Handle ; Task_Body_F_Name : Node_Rewriting_Handle ; Task_Body_F_Aspects : Node_Rewriting_Handle ; Task_Body_F_Decls : Node_Rewriting_Handle ; Task_Body_F_Stmts : Node_Rewriting_Handle ; Task_Body_F_End_Name : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Task_Body, (1 => Task_Body_F_Name, 2 => Task_Body_F_Aspects, 3 => Task_Body_F_Decls, 4 => Task_Body_F_Stmts, 5 => Task_Body_F_End_Name)); end; function Create_Entry_Index_Spec (Handle : Rewriting_Handle ; Entry_Index_Spec_F_Id : Node_Rewriting_Handle ; Entry_Index_Spec_F_Subtype : Node_Rewriting_Handle ; Entry_Index_Spec_F_Aspects : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Entry_Index_Spec, (1 => Entry_Index_Spec_F_Id, 2 => Entry_Index_Spec_F_Subtype, 3 => Entry_Index_Spec_F_Aspects)); end; function Create_Error_Decl (Handle : Rewriting_Handle ; Error_Decl_F_Aspects : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Error_Decl, (1 => Error_Decl_F_Aspects)); end; function Create_Exception_Decl (Handle : Rewriting_Handle ; Exception_Decl_F_Ids : Node_Rewriting_Handle ; Exception_Decl_F_Renames : Node_Rewriting_Handle ; Exception_Decl_F_Aspects : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Exception_Decl, (1 => Exception_Decl_F_Ids, 2 => Exception_Decl_F_Renames, 3 => Exception_Decl_F_Aspects)); end; function Create_Exception_Handler (Handle : Rewriting_Handle ; Exception_Handler_F_Exception_Name : Node_Rewriting_Handle ; Exception_Handler_F_Handled_Exceptions : Node_Rewriting_Handle ; Exception_Handler_F_Stmts : Node_Rewriting_Handle ; Exception_Handler_F_Aspects : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Exception_Handler, (1 => Exception_Handler_F_Exception_Name, 2 => Exception_Handler_F_Handled_Exceptions, 3 => Exception_Handler_F_Stmts, 4 => Exception_Handler_F_Aspects)); end; function Create_For_Loop_Var_Decl (Handle : Rewriting_Handle ; For_Loop_Var_Decl_F_Id : Node_Rewriting_Handle ; For_Loop_Var_Decl_F_Id_Type : Node_Rewriting_Handle ; For_Loop_Var_Decl_F_Aspects : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_For_Loop_Var_Decl, (1 => For_Loop_Var_Decl_F_Id, 2 => For_Loop_Var_Decl_F_Id_Type, 3 => For_Loop_Var_Decl_F_Aspects)); end; function Create_Generic_Package_Decl (Handle : Rewriting_Handle ; Generic_Decl_F_Formal_Part : Node_Rewriting_Handle ; Generic_Package_Decl_F_Package_Decl : Node_Rewriting_Handle ; Generic_Package_Decl_F_Aspects : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Generic_Package_Decl, (1 => Generic_Decl_F_Formal_Part, 2 => Generic_Package_Decl_F_Package_Decl, 3 => Generic_Package_Decl_F_Aspects)); end; function Create_Generic_Subp_Decl (Handle : Rewriting_Handle ; Generic_Decl_F_Formal_Part : Node_Rewriting_Handle ; Generic_Subp_Decl_F_Subp_Decl : Node_Rewriting_Handle ; Generic_Subp_Decl_F_Aspects : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Generic_Subp_Decl, (1 => Generic_Decl_F_Formal_Part, 2 => Generic_Subp_Decl_F_Subp_Decl, 3 => Generic_Subp_Decl_F_Aspects)); end; function Create_Generic_Package_Instantiation (Handle : Rewriting_Handle ; Generic_Package_Instantiation_F_Name : Node_Rewriting_Handle ; Generic_Package_Instantiation_F_Generic_Pkg_Name : Node_Rewriting_Handle ; Generic_Package_Instantiation_F_Params : Node_Rewriting_Handle ; Generic_Package_Instantiation_F_Aspects : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Generic_Package_Instantiation, (1 => Generic_Package_Instantiation_F_Name, 2 => Generic_Package_Instantiation_F_Generic_Pkg_Name, 3 => Generic_Package_Instantiation_F_Params, 4 => Generic_Package_Instantiation_F_Aspects)); end; function Create_Generic_Subp_Instantiation (Handle : Rewriting_Handle ; Generic_Subp_Instantiation_F_Overriding : Node_Rewriting_Handle ; Generic_Subp_Instantiation_F_Kind : Node_Rewriting_Handle ; Generic_Subp_Instantiation_F_Subp_Name : Node_Rewriting_Handle ; Generic_Subp_Instantiation_F_Generic_Subp_Name : Node_Rewriting_Handle ; Generic_Subp_Instantiation_F_Params : Node_Rewriting_Handle ; Generic_Subp_Instantiation_F_Aspects : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Generic_Subp_Instantiation, (1 => Generic_Subp_Instantiation_F_Overriding, 2 => Generic_Subp_Instantiation_F_Kind, 3 => Generic_Subp_Instantiation_F_Subp_Name, 4 => Generic_Subp_Instantiation_F_Generic_Subp_Name, 5 => Generic_Subp_Instantiation_F_Params, 6 => Generic_Subp_Instantiation_F_Aspects)); end; function Create_Generic_Package_Renaming_Decl (Handle : Rewriting_Handle ; Generic_Package_Renaming_Decl_F_Name : Node_Rewriting_Handle ; Generic_Package_Renaming_Decl_F_Renames : Node_Rewriting_Handle ; Generic_Package_Renaming_Decl_F_Aspects : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Generic_Package_Renaming_Decl, (1 => Generic_Package_Renaming_Decl_F_Name, 2 => Generic_Package_Renaming_Decl_F_Renames, 3 => Generic_Package_Renaming_Decl_F_Aspects)); end; function Create_Generic_Subp_Renaming_Decl (Handle : Rewriting_Handle ; Generic_Subp_Renaming_Decl_F_Kind : Node_Rewriting_Handle ; Generic_Subp_Renaming_Decl_F_Name : Node_Rewriting_Handle ; Generic_Subp_Renaming_Decl_F_Renames : Node_Rewriting_Handle ; Generic_Subp_Renaming_Decl_F_Aspects : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Generic_Subp_Renaming_Decl, (1 => Generic_Subp_Renaming_Decl_F_Kind, 2 => Generic_Subp_Renaming_Decl_F_Name, 3 => Generic_Subp_Renaming_Decl_F_Renames, 4 => Generic_Subp_Renaming_Decl_F_Aspects)); end; function Create_Label_Decl (Handle : Rewriting_Handle ; Label_Decl_F_Name : Node_Rewriting_Handle ; Label_Decl_F_Aspects : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Label_Decl, (1 => Label_Decl_F_Name, 2 => Label_Decl_F_Aspects)); end; function Create_Named_Stmt_Decl (Handle : Rewriting_Handle ; Named_Stmt_Decl_F_Name : Node_Rewriting_Handle ; Named_Stmt_Decl_F_Aspects : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Named_Stmt_Decl, (1 => Named_Stmt_Decl_F_Name, 2 => Named_Stmt_Decl_F_Aspects)); end; function Create_Number_Decl (Handle : Rewriting_Handle ; Number_Decl_F_Ids : Node_Rewriting_Handle ; Number_Decl_F_Expr : Node_Rewriting_Handle ; Number_Decl_F_Aspects : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Number_Decl, (1 => Number_Decl_F_Ids, 2 => Number_Decl_F_Expr, 3 => Number_Decl_F_Aspects)); end; function Create_Object_Decl (Handle : Rewriting_Handle ; Object_Decl_F_Ids : Node_Rewriting_Handle ; Object_Decl_F_Has_Aliased : Node_Rewriting_Handle ; Object_Decl_F_Has_Constant : Node_Rewriting_Handle ; Object_Decl_F_Mode : Node_Rewriting_Handle ; Object_Decl_F_Type_Expr : Node_Rewriting_Handle ; Object_Decl_F_Default_Expr : Node_Rewriting_Handle ; Object_Decl_F_Renaming_Clause : Node_Rewriting_Handle ; Object_Decl_F_Aspects : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Object_Decl, (1 => Object_Decl_F_Ids, 2 => Object_Decl_F_Has_Aliased, 3 => Object_Decl_F_Has_Constant, 4 => Object_Decl_F_Mode, 5 => Object_Decl_F_Type_Expr, 6 => Object_Decl_F_Default_Expr, 7 => Object_Decl_F_Renaming_Clause, 8 => Object_Decl_F_Aspects)); end; function Create_Extended_Return_Stmt_Object_Decl (Handle : Rewriting_Handle ; Object_Decl_F_Ids : Node_Rewriting_Handle ; Object_Decl_F_Has_Aliased : Node_Rewriting_Handle ; Object_Decl_F_Has_Constant : Node_Rewriting_Handle ; Object_Decl_F_Mode : Node_Rewriting_Handle ; Object_Decl_F_Type_Expr : Node_Rewriting_Handle ; Object_Decl_F_Default_Expr : Node_Rewriting_Handle ; Object_Decl_F_Renaming_Clause : Node_Rewriting_Handle ; Object_Decl_F_Aspects : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Extended_Return_Stmt_Object_Decl, (1 => Object_Decl_F_Ids, 2 => Object_Decl_F_Has_Aliased, 3 => Object_Decl_F_Has_Constant, 4 => Object_Decl_F_Mode, 5 => Object_Decl_F_Type_Expr, 6 => Object_Decl_F_Default_Expr, 7 => Object_Decl_F_Renaming_Clause, 8 => Object_Decl_F_Aspects)); end; function Create_No_Type_Object_Renaming_Decl (Handle : Rewriting_Handle ; Object_Decl_F_Ids : Node_Rewriting_Handle ; Object_Decl_F_Has_Aliased : Node_Rewriting_Handle ; Object_Decl_F_Has_Constant : Node_Rewriting_Handle ; Object_Decl_F_Mode : Node_Rewriting_Handle ; Object_Decl_F_Type_Expr : Node_Rewriting_Handle ; Object_Decl_F_Default_Expr : Node_Rewriting_Handle ; Object_Decl_F_Renaming_Clause : Node_Rewriting_Handle ; Object_Decl_F_Aspects : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_No_Type_Object_Renaming_Decl, (1 => Object_Decl_F_Ids, 2 => Object_Decl_F_Has_Aliased, 3 => Object_Decl_F_Has_Constant, 4 => Object_Decl_F_Mode, 5 => Object_Decl_F_Type_Expr, 6 => Object_Decl_F_Default_Expr, 7 => Object_Decl_F_Renaming_Clause, 8 => Object_Decl_F_Aspects)); end; function Create_Package_Renaming_Decl (Handle : Rewriting_Handle ; Package_Renaming_Decl_F_Name : Node_Rewriting_Handle ; Package_Renaming_Decl_F_Renames : Node_Rewriting_Handle ; Package_Renaming_Decl_F_Aspects : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Package_Renaming_Decl, (1 => Package_Renaming_Decl_F_Name, 2 => Package_Renaming_Decl_F_Renames, 3 => Package_Renaming_Decl_F_Aspects)); end; function Create_Single_Protected_Decl (Handle : Rewriting_Handle ; Single_Protected_Decl_F_Name : Node_Rewriting_Handle ; Single_Protected_Decl_F_Aspects : Node_Rewriting_Handle ; Single_Protected_Decl_F_Interfaces : Node_Rewriting_Handle ; Single_Protected_Decl_F_Definition : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Single_Protected_Decl, (1 => Single_Protected_Decl_F_Name, 2 => Single_Protected_Decl_F_Aspects, 3 => Single_Protected_Decl_F_Interfaces, 4 => Single_Protected_Decl_F_Definition)); end; function Create_Single_Task_Decl (Handle : Rewriting_Handle ; Single_Task_Decl_F_Task_Type : Node_Rewriting_Handle ; Single_Task_Decl_F_Aspects : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Single_Task_Decl, (1 => Single_Task_Decl_F_Task_Type, 2 => Single_Task_Decl_F_Aspects)); end; function Create_Case_Stmt_Alternative (Handle : Rewriting_Handle ; Case_Stmt_Alternative_F_Choices : Node_Rewriting_Handle ; Case_Stmt_Alternative_F_Stmts : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Case_Stmt_Alternative, (1 => Case_Stmt_Alternative_F_Choices, 2 => Case_Stmt_Alternative_F_Stmts)); end; function Create_Compilation_Unit (Handle : Rewriting_Handle ; Compilation_Unit_F_Prelude : Node_Rewriting_Handle ; Compilation_Unit_F_Body : Node_Rewriting_Handle ; Compilation_Unit_F_Pragmas : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Compilation_Unit, (1 => Compilation_Unit_F_Prelude, 2 => Compilation_Unit_F_Body, 3 => Compilation_Unit_F_Pragmas)); end; function Create_Component_Clause (Handle : Rewriting_Handle ; Component_Clause_F_Id : Node_Rewriting_Handle ; Component_Clause_F_Position : Node_Rewriting_Handle ; Component_Clause_F_Range : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Component_Clause, (1 => Component_Clause_F_Id, 2 => Component_Clause_F_Position, 3 => Component_Clause_F_Range)); end; function Create_Component_Def (Handle : Rewriting_Handle ; Component_Def_F_Has_Aliased : Node_Rewriting_Handle ; Component_Def_F_Has_Constant : Node_Rewriting_Handle ; Component_Def_F_Type_Expr : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Component_Def, (1 => Component_Def_F_Has_Aliased, 2 => Component_Def_F_Has_Constant, 3 => Component_Def_F_Type_Expr)); end; function Create_Composite_Constraint (Handle : Rewriting_Handle ; Composite_Constraint_F_Constraints : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Composite_Constraint, (1 => Composite_Constraint_F_Constraints)); end; function Create_Delta_Constraint (Handle : Rewriting_Handle ; Delta_Constraint_F_Digits : Node_Rewriting_Handle ; Delta_Constraint_F_Range : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Delta_Constraint, (1 => Delta_Constraint_F_Digits, 2 => Delta_Constraint_F_Range)); end; function Create_Digits_Constraint (Handle : Rewriting_Handle ; Digits_Constraint_F_Digits : Node_Rewriting_Handle ; Digits_Constraint_F_Range : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Digits_Constraint, (1 => Digits_Constraint_F_Digits, 2 => Digits_Constraint_F_Range)); end; function Create_Range_Constraint (Handle : Rewriting_Handle ; Range_Constraint_F_Range : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Range_Constraint, (1 => Range_Constraint_F_Range)); end; function Create_Declarative_Part (Handle : Rewriting_Handle ; Declarative_Part_F_Decls : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Declarative_Part, (1 => Declarative_Part_F_Decls)); end; function Create_Private_Part (Handle : Rewriting_Handle ; Declarative_Part_F_Decls : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Private_Part, (1 => Declarative_Part_F_Decls)); end; function Create_Public_Part (Handle : Rewriting_Handle ; Declarative_Part_F_Decls : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Public_Part, (1 => Declarative_Part_F_Decls)); end; function Create_Elsif_Expr_Part (Handle : Rewriting_Handle ; Elsif_Expr_Part_F_Cond_Expr : Node_Rewriting_Handle ; Elsif_Expr_Part_F_Then_Expr : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Elsif_Expr_Part, (1 => Elsif_Expr_Part_F_Cond_Expr, 2 => Elsif_Expr_Part_F_Then_Expr)); end; function Create_Elsif_Stmt_Part (Handle : Rewriting_Handle ; Elsif_Stmt_Part_F_Cond_Expr : Node_Rewriting_Handle ; Elsif_Stmt_Part_F_Stmts : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Elsif_Stmt_Part, (1 => Elsif_Stmt_Part_F_Cond_Expr, 2 => Elsif_Stmt_Part_F_Stmts)); end; function Create_Abstract_State_Decl_Expr (Handle : Rewriting_Handle ; Abstract_State_Decl_Expr_F_State_Decl : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Abstract_State_Decl_Expr, (1 => Abstract_State_Decl_Expr_F_State_Decl)); end; function Create_Allocator (Handle : Rewriting_Handle ; Allocator_F_Subpool : Node_Rewriting_Handle ; Allocator_F_Type_Or_Expr : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Allocator, (1 => Allocator_F_Subpool, 2 => Allocator_F_Type_Or_Expr)); end; function Create_Aggregate (Handle : Rewriting_Handle ; Base_Aggregate_F_Ancestor_Expr : Node_Rewriting_Handle ; Base_Aggregate_F_Assocs : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Aggregate, (1 => Base_Aggregate_F_Ancestor_Expr, 2 => Base_Aggregate_F_Assocs)); end; function Create_Bracket_Aggregate (Handle : Rewriting_Handle ; Base_Aggregate_F_Ancestor_Expr : Node_Rewriting_Handle ; Base_Aggregate_F_Assocs : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Bracket_Aggregate, (1 => Base_Aggregate_F_Ancestor_Expr, 2 => Base_Aggregate_F_Assocs)); end; function Create_Delta_Aggregate (Handle : Rewriting_Handle ; Base_Aggregate_F_Ancestor_Expr : Node_Rewriting_Handle ; Base_Aggregate_F_Assocs : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Delta_Aggregate, (1 => Base_Aggregate_F_Ancestor_Expr, 2 => Base_Aggregate_F_Assocs)); end; function Create_Bracket_Delta_Aggregate (Handle : Rewriting_Handle ; Base_Aggregate_F_Ancestor_Expr : Node_Rewriting_Handle ; Base_Aggregate_F_Assocs : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Bracket_Delta_Aggregate, (1 => Base_Aggregate_F_Ancestor_Expr, 2 => Base_Aggregate_F_Assocs)); end; function Create_Null_Record_Aggregate (Handle : Rewriting_Handle ; Base_Aggregate_F_Ancestor_Expr : Node_Rewriting_Handle ; Base_Aggregate_F_Assocs : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Null_Record_Aggregate, (1 => Base_Aggregate_F_Ancestor_Expr, 2 => Base_Aggregate_F_Assocs)); end; function Create_Bin_Op (Handle : Rewriting_Handle ; Bin_Op_F_Left : Node_Rewriting_Handle ; Bin_Op_F_Op : Node_Rewriting_Handle ; Bin_Op_F_Right : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Bin_Op, (1 => Bin_Op_F_Left, 2 => Bin_Op_F_Op, 3 => Bin_Op_F_Right)); end; function Create_Relation_Op (Handle : Rewriting_Handle ; Bin_Op_F_Left : Node_Rewriting_Handle ; Bin_Op_F_Op : Node_Rewriting_Handle ; Bin_Op_F_Right : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Relation_Op, (1 => Bin_Op_F_Left, 2 => Bin_Op_F_Op, 3 => Bin_Op_F_Right)); end; function Create_Case_Expr_Alternative (Handle : Rewriting_Handle ; Case_Expr_Alternative_F_Choices : Node_Rewriting_Handle ; Case_Expr_Alternative_F_Expr : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Case_Expr_Alternative, (1 => Case_Expr_Alternative_F_Choices, 2 => Case_Expr_Alternative_F_Expr)); end; function Create_Concat_Op (Handle : Rewriting_Handle ; Concat_Op_F_First_Operand : Node_Rewriting_Handle ; Concat_Op_F_Other_Operands : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Concat_Op, (1 => Concat_Op_F_First_Operand, 2 => Concat_Op_F_Other_Operands)); end; function Create_Concat_Operand (Handle : Rewriting_Handle ; Concat_Operand_F_Operator : Node_Rewriting_Handle ; Concat_Operand_F_Operand : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Concat_Operand, (1 => Concat_Operand_F_Operator, 2 => Concat_Operand_F_Operand)); end; function Create_Case_Expr (Handle : Rewriting_Handle ; Case_Expr_F_Expr : Node_Rewriting_Handle ; Case_Expr_F_Cases : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Case_Expr, (1 => Case_Expr_F_Expr, 2 => Case_Expr_F_Cases)); end; function Create_If_Expr (Handle : Rewriting_Handle ; If_Expr_F_Cond_Expr : Node_Rewriting_Handle ; If_Expr_F_Then_Expr : Node_Rewriting_Handle ; If_Expr_F_Alternatives : Node_Rewriting_Handle ; If_Expr_F_Else_Expr : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_If_Expr, (1 => If_Expr_F_Cond_Expr, 2 => If_Expr_F_Then_Expr, 3 => If_Expr_F_Alternatives, 4 => If_Expr_F_Else_Expr)); end; function Create_Contract_Cases (Handle : Rewriting_Handle ; Contract_Cases_F_Contract_Cases : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Contract_Cases, (1 => Contract_Cases_F_Contract_Cases)); end; function Create_Decl_Expr (Handle : Rewriting_Handle ; Decl_Expr_F_Decls : Node_Rewriting_Handle ; Decl_Expr_F_Expr : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Decl_Expr, (1 => Decl_Expr_F_Decls, 2 => Decl_Expr_F_Expr)); end; function Create_Membership_Expr (Handle : Rewriting_Handle ; Membership_Expr_F_Expr : Node_Rewriting_Handle ; Membership_Expr_F_Op : Node_Rewriting_Handle ; Membership_Expr_F_Membership_Exprs : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Membership_Expr, (1 => Membership_Expr_F_Expr, 2 => Membership_Expr_F_Op, 3 => Membership_Expr_F_Membership_Exprs)); end; function Create_Attribute_Ref (Handle : Rewriting_Handle ; Attribute_Ref_F_Prefix : Node_Rewriting_Handle ; Attribute_Ref_F_Attribute : Node_Rewriting_Handle ; Attribute_Ref_F_Args : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Attribute_Ref, (1 => Attribute_Ref_F_Prefix, 2 => Attribute_Ref_F_Attribute, 3 => Attribute_Ref_F_Args)); end; function Create_Call_Expr (Handle : Rewriting_Handle ; Call_Expr_F_Name : Node_Rewriting_Handle ; Call_Expr_F_Suffix : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Call_Expr, (1 => Call_Expr_F_Name, 2 => Call_Expr_F_Suffix)); end; function Create_Defining_Name (Handle : Rewriting_Handle ; Defining_Name_F_Name : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Defining_Name, (1 => Defining_Name_F_Name)); end; function Create_Synthetic_Defining_Name (Handle : Rewriting_Handle ; Defining_Name_F_Name : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Synthetic_Defining_Name, (1 => Defining_Name_F_Name)); end; function Create_Discrete_Subtype_Name (Handle : Rewriting_Handle ; Discrete_Subtype_Name_F_Subtype : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Discrete_Subtype_Name, (1 => Discrete_Subtype_Name_F_Subtype)); end; function Create_Dotted_Name (Handle : Rewriting_Handle ; Dotted_Name_F_Prefix : Node_Rewriting_Handle ; Dotted_Name_F_Suffix : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Dotted_Name, (1 => Dotted_Name_F_Prefix, 2 => Dotted_Name_F_Suffix)); end; function Create_End_Name (Handle : Rewriting_Handle ; End_Name_F_Name : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_End_Name, (1 => End_Name_F_Name)); end; function Create_Explicit_Deref (Handle : Rewriting_Handle ; Explicit_Deref_F_Prefix : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Explicit_Deref, (1 => Explicit_Deref_F_Prefix)); end; function Create_Qual_Expr (Handle : Rewriting_Handle ; Qual_Expr_F_Prefix : Node_Rewriting_Handle ; Qual_Expr_F_Suffix : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Qual_Expr, (1 => Qual_Expr_F_Prefix, 2 => Qual_Expr_F_Suffix)); end; function Create_Reduce_Attribute_Ref (Handle : Rewriting_Handle ; Reduce_Attribute_Ref_F_Prefix : Node_Rewriting_Handle ; Reduce_Attribute_Ref_F_Attribute : Node_Rewriting_Handle ; Reduce_Attribute_Ref_F_Args : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Reduce_Attribute_Ref, (1 => Reduce_Attribute_Ref_F_Prefix, 2 => Reduce_Attribute_Ref_F_Attribute, 3 => Reduce_Attribute_Ref_F_Args)); end; function Create_Update_Attribute_Ref (Handle : Rewriting_Handle ; Update_Attribute_Ref_F_Prefix : Node_Rewriting_Handle ; Update_Attribute_Ref_F_Attribute : Node_Rewriting_Handle ; Update_Attribute_Ref_F_Values : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Update_Attribute_Ref, (1 => Update_Attribute_Ref_F_Prefix, 2 => Update_Attribute_Ref_F_Attribute, 3 => Update_Attribute_Ref_F_Values)); end; function Create_Paren_Expr (Handle : Rewriting_Handle ; Paren_Expr_F_Expr : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Paren_Expr, (1 => Paren_Expr_F_Expr)); end; function Create_Quantified_Expr (Handle : Rewriting_Handle ; Quantified_Expr_F_Quantifier : Node_Rewriting_Handle ; Quantified_Expr_F_Loop_Spec : Node_Rewriting_Handle ; Quantified_Expr_F_Expr : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Quantified_Expr, (1 => Quantified_Expr_F_Quantifier, 2 => Quantified_Expr_F_Loop_Spec, 3 => Quantified_Expr_F_Expr)); end; function Create_Raise_Expr (Handle : Rewriting_Handle ; Raise_Expr_F_Exception_Name : Node_Rewriting_Handle ; Raise_Expr_F_Error_Message : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Raise_Expr, (1 => Raise_Expr_F_Exception_Name, 2 => Raise_Expr_F_Error_Message)); end; function Create_Un_Op (Handle : Rewriting_Handle ; Un_Op_F_Op : Node_Rewriting_Handle ; Un_Op_F_Expr : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Un_Op, (1 => Un_Op_F_Op, 2 => Un_Op_F_Expr)); end; function Create_Handled_Stmts (Handle : Rewriting_Handle ; Handled_Stmts_F_Stmts : Node_Rewriting_Handle ; Handled_Stmts_F_Exceptions : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Handled_Stmts, (1 => Handled_Stmts_F_Stmts, 2 => Handled_Stmts_F_Exceptions)); end; function Create_Library_Item (Handle : Rewriting_Handle ; Library_Item_F_Has_Private : Node_Rewriting_Handle ; Library_Item_F_Item : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Library_Item, (1 => Library_Item_F_Has_Private, 2 => Library_Item_F_Item)); end; function Create_For_Loop_Spec (Handle : Rewriting_Handle ; For_Loop_Spec_F_Var_Decl : Node_Rewriting_Handle ; For_Loop_Spec_F_Loop_Type : Node_Rewriting_Handle ; For_Loop_Spec_F_Has_Reverse : Node_Rewriting_Handle ; For_Loop_Spec_F_Iter_Expr : Node_Rewriting_Handle ; For_Loop_Spec_F_Iter_Filter : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_For_Loop_Spec, (1 => For_Loop_Spec_F_Var_Decl, 2 => For_Loop_Spec_F_Loop_Type, 3 => For_Loop_Spec_F_Has_Reverse, 4 => For_Loop_Spec_F_Iter_Expr, 5 => For_Loop_Spec_F_Iter_Filter)); end; function Create_While_Loop_Spec (Handle : Rewriting_Handle ; While_Loop_Spec_F_Expr : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_While_Loop_Spec, (1 => While_Loop_Spec_F_Expr)); end; function Create_Multi_Abstract_State_Decl (Handle : Rewriting_Handle ; Multi_Abstract_State_Decl_F_Decls : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Multi_Abstract_State_Decl, (1 => Multi_Abstract_State_Decl_F_Decls)); end; function Create_Params (Handle : Rewriting_Handle ; Params_F_Params : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Params, (1 => Params_F_Params)); end; function Create_Paren_Abstract_State_Decl (Handle : Rewriting_Handle ; Paren_Abstract_State_Decl_F_Decl : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Paren_Abstract_State_Decl, (1 => Paren_Abstract_State_Decl_F_Decl)); end; function Create_Pp_Elsif_Directive (Handle : Rewriting_Handle ; Pp_Elsif_Directive_F_Expr : Node_Rewriting_Handle ; Pp_Elsif_Directive_F_Then_Kw : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Pp_Elsif_Directive, (1 => Pp_Elsif_Directive_F_Expr, 2 => Pp_Elsif_Directive_F_Then_Kw)); end; function Create_Pp_If_Directive (Handle : Rewriting_Handle ; Pp_If_Directive_F_Expr : Node_Rewriting_Handle ; Pp_If_Directive_F_Then_Kw : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Pp_If_Directive, (1 => Pp_If_Directive_F_Expr, 2 => Pp_If_Directive_F_Then_Kw)); end; function Create_Pragma_Node (Handle : Rewriting_Handle ; Pragma_Node_F_Id : Node_Rewriting_Handle ; Pragma_Node_F_Args : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Pragma_Node, (1 => Pragma_Node_F_Id, 2 => Pragma_Node_F_Args)); end; function Create_Protected_Def (Handle : Rewriting_Handle ; Protected_Def_F_Public_Part : Node_Rewriting_Handle ; Protected_Def_F_Private_Part : Node_Rewriting_Handle ; Protected_Def_F_End_Name : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Protected_Def, (1 => Protected_Def_F_Public_Part, 2 => Protected_Def_F_Private_Part, 3 => Protected_Def_F_End_Name)); end; function Create_Range_Spec (Handle : Rewriting_Handle ; Range_Spec_F_Range : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Range_Spec, (1 => Range_Spec_F_Range)); end; function Create_Renaming_Clause (Handle : Rewriting_Handle ; Renaming_Clause_F_Renamed_Object : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Renaming_Clause, (1 => Renaming_Clause_F_Renamed_Object)); end; function Create_Synthetic_Renaming_Clause (Handle : Rewriting_Handle ; Renaming_Clause_F_Renamed_Object : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Synthetic_Renaming_Clause, (1 => Renaming_Clause_F_Renamed_Object)); end; function Create_Select_When_Part (Handle : Rewriting_Handle ; Select_When_Part_F_Cond_Expr : Node_Rewriting_Handle ; Select_When_Part_F_Stmts : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Select_When_Part, (1 => Select_When_Part_F_Cond_Expr, 2 => Select_When_Part_F_Stmts)); end; function Create_Accept_Stmt (Handle : Rewriting_Handle ; Accept_Stmt_F_Body_Decl : Node_Rewriting_Handle ; Accept_Stmt_F_Entry_Index_Expr : Node_Rewriting_Handle ; Accept_Stmt_F_Params : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Accept_Stmt, (1 => Accept_Stmt_F_Body_Decl, 2 => Accept_Stmt_F_Entry_Index_Expr, 3 => Accept_Stmt_F_Params)); end; function Create_Accept_Stmt_With_Stmts (Handle : Rewriting_Handle ; Accept_Stmt_F_Body_Decl : Node_Rewriting_Handle ; Accept_Stmt_F_Entry_Index_Expr : Node_Rewriting_Handle ; Accept_Stmt_F_Params : Node_Rewriting_Handle ; Accept_Stmt_With_Stmts_F_Stmts : Node_Rewriting_Handle ; Accept_Stmt_With_Stmts_F_End_Name : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Accept_Stmt_With_Stmts, (1 => Accept_Stmt_F_Body_Decl, 2 => Accept_Stmt_F_Entry_Index_Expr, 3 => Accept_Stmt_F_Params, 4 => Accept_Stmt_With_Stmts_F_Stmts, 5 => Accept_Stmt_With_Stmts_F_End_Name)); end; function Create_For_Loop_Stmt (Handle : Rewriting_Handle ; Base_Loop_Stmt_F_Spec : Node_Rewriting_Handle ; Base_Loop_Stmt_F_Stmts : Node_Rewriting_Handle ; Base_Loop_Stmt_F_End_Name : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_For_Loop_Stmt, (1 => Base_Loop_Stmt_F_Spec, 2 => Base_Loop_Stmt_F_Stmts, 3 => Base_Loop_Stmt_F_End_Name)); end; function Create_Loop_Stmt (Handle : Rewriting_Handle ; Base_Loop_Stmt_F_Spec : Node_Rewriting_Handle ; Base_Loop_Stmt_F_Stmts : Node_Rewriting_Handle ; Base_Loop_Stmt_F_End_Name : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Loop_Stmt, (1 => Base_Loop_Stmt_F_Spec, 2 => Base_Loop_Stmt_F_Stmts, 3 => Base_Loop_Stmt_F_End_Name)); end; function Create_While_Loop_Stmt (Handle : Rewriting_Handle ; Base_Loop_Stmt_F_Spec : Node_Rewriting_Handle ; Base_Loop_Stmt_F_Stmts : Node_Rewriting_Handle ; Base_Loop_Stmt_F_End_Name : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_While_Loop_Stmt, (1 => Base_Loop_Stmt_F_Spec, 2 => Base_Loop_Stmt_F_Stmts, 3 => Base_Loop_Stmt_F_End_Name)); end; function Create_Begin_Block (Handle : Rewriting_Handle ; Begin_Block_F_Stmts : Node_Rewriting_Handle ; Begin_Block_F_End_Name : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Begin_Block, (1 => Begin_Block_F_Stmts, 2 => Begin_Block_F_End_Name)); end; function Create_Decl_Block (Handle : Rewriting_Handle ; Decl_Block_F_Decls : Node_Rewriting_Handle ; Decl_Block_F_Stmts : Node_Rewriting_Handle ; Decl_Block_F_End_Name : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Decl_Block, (1 => Decl_Block_F_Decls, 2 => Decl_Block_F_Stmts, 3 => Decl_Block_F_End_Name)); end; function Create_Case_Stmt (Handle : Rewriting_Handle ; Case_Stmt_F_Expr : Node_Rewriting_Handle ; Case_Stmt_F_Pragmas : Node_Rewriting_Handle ; Case_Stmt_F_Alternatives : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Case_Stmt, (1 => Case_Stmt_F_Expr, 2 => Case_Stmt_F_Pragmas, 3 => Case_Stmt_F_Alternatives)); end; function Create_Extended_Return_Stmt (Handle : Rewriting_Handle ; Extended_Return_Stmt_F_Decl : Node_Rewriting_Handle ; Extended_Return_Stmt_F_Stmts : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Extended_Return_Stmt, (1 => Extended_Return_Stmt_F_Decl, 2 => Extended_Return_Stmt_F_Stmts)); end; function Create_If_Stmt (Handle : Rewriting_Handle ; If_Stmt_F_Cond_Expr : Node_Rewriting_Handle ; If_Stmt_F_Then_Stmts : Node_Rewriting_Handle ; If_Stmt_F_Alternatives : Node_Rewriting_Handle ; If_Stmt_F_Else_Stmts : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_If_Stmt, (1 => If_Stmt_F_Cond_Expr, 2 => If_Stmt_F_Then_Stmts, 3 => If_Stmt_F_Alternatives, 4 => If_Stmt_F_Else_Stmts)); end; function Create_Named_Stmt (Handle : Rewriting_Handle ; Named_Stmt_F_Decl : Node_Rewriting_Handle ; Named_Stmt_F_Stmt : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Named_Stmt, (1 => Named_Stmt_F_Decl, 2 => Named_Stmt_F_Stmt)); end; function Create_Select_Stmt (Handle : Rewriting_Handle ; Select_Stmt_F_Guards : Node_Rewriting_Handle ; Select_Stmt_F_Else_Stmts : Node_Rewriting_Handle ; Select_Stmt_F_Abort_Stmts : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Select_Stmt, (1 => Select_Stmt_F_Guards, 2 => Select_Stmt_F_Else_Stmts, 3 => Select_Stmt_F_Abort_Stmts)); end; function Create_Abort_Stmt (Handle : Rewriting_Handle ; Abort_Stmt_F_Names : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Abort_Stmt, (1 => Abort_Stmt_F_Names)); end; function Create_Assign_Stmt (Handle : Rewriting_Handle ; Assign_Stmt_F_Dest : Node_Rewriting_Handle ; Assign_Stmt_F_Expr : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Assign_Stmt, (1 => Assign_Stmt_F_Dest, 2 => Assign_Stmt_F_Expr)); end; function Create_Call_Stmt (Handle : Rewriting_Handle ; Call_Stmt_F_Call : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Call_Stmt, (1 => Call_Stmt_F_Call)); end; function Create_Delay_Stmt (Handle : Rewriting_Handle ; Delay_Stmt_F_Has_Until : Node_Rewriting_Handle ; Delay_Stmt_F_Expr : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Delay_Stmt, (1 => Delay_Stmt_F_Has_Until, 2 => Delay_Stmt_F_Expr)); end; function Create_Exit_Stmt (Handle : Rewriting_Handle ; Exit_Stmt_F_Loop_Name : Node_Rewriting_Handle ; Exit_Stmt_F_Cond_Expr : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Exit_Stmt, (1 => Exit_Stmt_F_Loop_Name, 2 => Exit_Stmt_F_Cond_Expr)); end; function Create_Goto_Stmt (Handle : Rewriting_Handle ; Goto_Stmt_F_Label_Name : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Goto_Stmt, (1 => Goto_Stmt_F_Label_Name)); end; function Create_Label (Handle : Rewriting_Handle ; Label_F_Decl : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Label, (1 => Label_F_Decl)); end; function Create_Raise_Stmt (Handle : Rewriting_Handle ; Raise_Stmt_F_Exception_Name : Node_Rewriting_Handle ; Raise_Stmt_F_Error_Message : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Raise_Stmt, (1 => Raise_Stmt_F_Exception_Name, 2 => Raise_Stmt_F_Error_Message)); end; function Create_Requeue_Stmt (Handle : Rewriting_Handle ; Requeue_Stmt_F_Call_Name : Node_Rewriting_Handle ; Requeue_Stmt_F_Has_Abort : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Requeue_Stmt, (1 => Requeue_Stmt_F_Call_Name, 2 => Requeue_Stmt_F_Has_Abort)); end; function Create_Return_Stmt (Handle : Rewriting_Handle ; Return_Stmt_F_Return_Expr : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Return_Stmt, (1 => Return_Stmt_F_Return_Expr)); end; function Create_Subunit (Handle : Rewriting_Handle ; Subunit_F_Name : Node_Rewriting_Handle ; Subunit_F_Body : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Subunit, (1 => Subunit_F_Name, 2 => Subunit_F_Body)); end; function Create_Task_Def (Handle : Rewriting_Handle ; Task_Def_F_Interfaces : Node_Rewriting_Handle ; Task_Def_F_Public_Part : Node_Rewriting_Handle ; Task_Def_F_Private_Part : Node_Rewriting_Handle ; Task_Def_F_End_Name : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Task_Def, (1 => Task_Def_F_Interfaces, 2 => Task_Def_F_Public_Part, 3 => Task_Def_F_Private_Part, 4 => Task_Def_F_End_Name)); end; function Create_Access_To_Subp_Def (Handle : Rewriting_Handle ; Access_Def_F_Has_Not_Null : Node_Rewriting_Handle ; Access_To_Subp_Def_F_Has_Protected : Node_Rewriting_Handle ; Access_To_Subp_Def_F_Subp_Spec : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Access_To_Subp_Def, (1 => Access_Def_F_Has_Not_Null, 2 => Access_To_Subp_Def_F_Has_Protected, 3 => Access_To_Subp_Def_F_Subp_Spec)); end; function Create_Anonymous_Type_Access_Def (Handle : Rewriting_Handle ; Access_Def_F_Has_Not_Null : Node_Rewriting_Handle ; Anonymous_Type_Access_Def_F_Type_Decl : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Anonymous_Type_Access_Def, (1 => Access_Def_F_Has_Not_Null, 2 => Anonymous_Type_Access_Def_F_Type_Decl)); end; function Create_Type_Access_Def (Handle : Rewriting_Handle ; Access_Def_F_Has_Not_Null : Node_Rewriting_Handle ; Type_Access_Def_F_Has_All : Node_Rewriting_Handle ; Type_Access_Def_F_Has_Constant : Node_Rewriting_Handle ; Type_Access_Def_F_Subtype_Indication : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Type_Access_Def, (1 => Access_Def_F_Has_Not_Null, 2 => Type_Access_Def_F_Has_All, 3 => Type_Access_Def_F_Has_Constant, 4 => Type_Access_Def_F_Subtype_Indication)); end; function Create_Array_Type_Def (Handle : Rewriting_Handle ; Array_Type_Def_F_Indices : Node_Rewriting_Handle ; Array_Type_Def_F_Component_Type : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Array_Type_Def, (1 => Array_Type_Def_F_Indices, 2 => Array_Type_Def_F_Component_Type)); end; function Create_Derived_Type_Def (Handle : Rewriting_Handle ; Derived_Type_Def_F_Has_Abstract : Node_Rewriting_Handle ; Derived_Type_Def_F_Has_Limited : Node_Rewriting_Handle ; Derived_Type_Def_F_Has_Synchronized : Node_Rewriting_Handle ; Derived_Type_Def_F_Subtype_Indication : Node_Rewriting_Handle ; Derived_Type_Def_F_Interfaces : Node_Rewriting_Handle ; Derived_Type_Def_F_Record_Extension : Node_Rewriting_Handle ; Derived_Type_Def_F_Has_With_Private : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Derived_Type_Def, (1 => Derived_Type_Def_F_Has_Abstract, 2 => Derived_Type_Def_F_Has_Limited, 3 => Derived_Type_Def_F_Has_Synchronized, 4 => Derived_Type_Def_F_Subtype_Indication, 5 => Derived_Type_Def_F_Interfaces, 6 => Derived_Type_Def_F_Record_Extension, 7 => Derived_Type_Def_F_Has_With_Private)); end; function Create_Enum_Type_Def (Handle : Rewriting_Handle ; Enum_Type_Def_F_Enum_Literals : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Enum_Type_Def, (1 => Enum_Type_Def_F_Enum_Literals)); end; function Create_Interface_Type_Def (Handle : Rewriting_Handle ; Interface_Type_Def_F_Interface_Kind : Node_Rewriting_Handle ; Interface_Type_Def_F_Interfaces : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Interface_Type_Def, (1 => Interface_Type_Def_F_Interface_Kind, 2 => Interface_Type_Def_F_Interfaces)); end; function Create_Mod_Int_Type_Def (Handle : Rewriting_Handle ; Mod_Int_Type_Def_F_Expr : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Mod_Int_Type_Def, (1 => Mod_Int_Type_Def_F_Expr)); end; function Create_Private_Type_Def (Handle : Rewriting_Handle ; Private_Type_Def_F_Has_Abstract : Node_Rewriting_Handle ; Private_Type_Def_F_Has_Tagged : Node_Rewriting_Handle ; Private_Type_Def_F_Has_Limited : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Private_Type_Def, (1 => Private_Type_Def_F_Has_Abstract, 2 => Private_Type_Def_F_Has_Tagged, 3 => Private_Type_Def_F_Has_Limited)); end; function Create_Decimal_Fixed_Point_Def (Handle : Rewriting_Handle ; Decimal_Fixed_Point_Def_F_Delta : Node_Rewriting_Handle ; Decimal_Fixed_Point_Def_F_Digits : Node_Rewriting_Handle ; Decimal_Fixed_Point_Def_F_Range : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Decimal_Fixed_Point_Def, (1 => Decimal_Fixed_Point_Def_F_Delta, 2 => Decimal_Fixed_Point_Def_F_Digits, 3 => Decimal_Fixed_Point_Def_F_Range)); end; function Create_Floating_Point_Def (Handle : Rewriting_Handle ; Floating_Point_Def_F_Num_Digits : Node_Rewriting_Handle ; Floating_Point_Def_F_Range : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Floating_Point_Def, (1 => Floating_Point_Def_F_Num_Digits, 2 => Floating_Point_Def_F_Range)); end; function Create_Ordinary_Fixed_Point_Def (Handle : Rewriting_Handle ; Ordinary_Fixed_Point_Def_F_Delta : Node_Rewriting_Handle ; Ordinary_Fixed_Point_Def_F_Range : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Ordinary_Fixed_Point_Def, (1 => Ordinary_Fixed_Point_Def_F_Delta, 2 => Ordinary_Fixed_Point_Def_F_Range)); end; function Create_Record_Type_Def (Handle : Rewriting_Handle ; Record_Type_Def_F_Has_Abstract : Node_Rewriting_Handle ; Record_Type_Def_F_Has_Tagged : Node_Rewriting_Handle ; Record_Type_Def_F_Has_Limited : Node_Rewriting_Handle ; Record_Type_Def_F_Record_Def : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Record_Type_Def, (1 => Record_Type_Def_F_Has_Abstract, 2 => Record_Type_Def_F_Has_Tagged, 3 => Record_Type_Def_F_Has_Limited, 4 => Record_Type_Def_F_Record_Def)); end; function Create_Signed_Int_Type_Def (Handle : Rewriting_Handle ; Signed_Int_Type_Def_F_Range : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Signed_Int_Type_Def, (1 => Signed_Int_Type_Def_F_Range)); end; function Create_Anonymous_Type (Handle : Rewriting_Handle ; Anonymous_Type_F_Type_Decl : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Anonymous_Type, (1 => Anonymous_Type_F_Type_Decl)); end; function Create_Subtype_Indication (Handle : Rewriting_Handle ; Subtype_Indication_F_Has_Not_Null : Node_Rewriting_Handle ; Subtype_Indication_F_Name : Node_Rewriting_Handle ; Subtype_Indication_F_Constraint : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Subtype_Indication, (1 => Subtype_Indication_F_Has_Not_Null, 2 => Subtype_Indication_F_Name, 3 => Subtype_Indication_F_Constraint)); end; function Create_Constrained_Subtype_Indication (Handle : Rewriting_Handle ; Subtype_Indication_F_Has_Not_Null : Node_Rewriting_Handle ; Subtype_Indication_F_Name : Node_Rewriting_Handle ; Subtype_Indication_F_Constraint : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Constrained_Subtype_Indication, (1 => Subtype_Indication_F_Has_Not_Null, 2 => Subtype_Indication_F_Name, 3 => Subtype_Indication_F_Constraint)); end; function Create_Discrete_Subtype_Indication (Handle : Rewriting_Handle ; Subtype_Indication_F_Has_Not_Null : Node_Rewriting_Handle ; Subtype_Indication_F_Name : Node_Rewriting_Handle ; Subtype_Indication_F_Constraint : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Discrete_Subtype_Indication, (1 => Subtype_Indication_F_Has_Not_Null, 2 => Subtype_Indication_F_Name, 3 => Subtype_Indication_F_Constraint)); end; function Create_Synthetic_Type_Expr (Handle : Rewriting_Handle ; Synthetic_Type_Expr_F_Target_Type : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Synthetic_Type_Expr, (1 => Synthetic_Type_Expr_F_Target_Type)); end; function Create_Unconstrained_Array_Index (Handle : Rewriting_Handle ; Unconstrained_Array_Index_F_Subtype_Indication : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Unconstrained_Array_Index, (1 => Unconstrained_Array_Index_F_Subtype_Indication)); end; function Create_Use_Package_Clause (Handle : Rewriting_Handle ; Use_Package_Clause_F_Packages : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Use_Package_Clause, (1 => Use_Package_Clause_F_Packages)); end; function Create_Use_Type_Clause (Handle : Rewriting_Handle ; Use_Type_Clause_F_Has_All : Node_Rewriting_Handle ; Use_Type_Clause_F_Types : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Use_Type_Clause, (1 => Use_Type_Clause_F_Has_All, 2 => Use_Type_Clause_F_Types)); end; function Create_Value_Sequence (Handle : Rewriting_Handle ; Value_Sequence_F_Iter_Assoc : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Value_Sequence, (1 => Value_Sequence_F_Iter_Assoc)); end; function Create_Variant (Handle : Rewriting_Handle ; Variant_F_Choices : Node_Rewriting_Handle ; Variant_F_Components : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Variant, (1 => Variant_F_Choices, 2 => Variant_F_Components)); end; function Create_Variant_Part (Handle : Rewriting_Handle ; Variant_Part_F_Discr_Name : Node_Rewriting_Handle ; Variant_Part_F_Variant : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_Variant_Part, (1 => Variant_Part_F_Discr_Name, 2 => Variant_Part_F_Variant)); end; function Create_With_Clause (Handle : Rewriting_Handle ; With_Clause_F_Has_Limited : Node_Rewriting_Handle ; With_Clause_F_Has_Private : Node_Rewriting_Handle ; With_Clause_F_Packages : Node_Rewriting_Handle ) return Node_Rewriting_Handle is begin Pre_Check (Handle /= No_Rewriting_Handle, "Handle should not be null"); return Create_Regular_Node (Handle, Ada_With_Clause, (1 => With_Clause_F_Has_Limited, 2 => With_Clause_F_Has_Private, 3 => With_Clause_F_Packages)); end; end Libadalang.Rewriting_Implementation;