------------------------------------------------------------------------------ -- -- -- GNAT COMPILER COMPONENTS -- -- -- -- E X P _ C H 7 -- -- -- -- S p e c -- -- -- -- Copyright (C) 1992-2008, Free Software Foundation, Inc. -- -- -- -- GNAT is free software; you can redistribute it and/or modify it under -- -- terms of the GNU General Public License as published by the Free Soft- -- -- ware Foundation; either version 3, or (at your option) any later ver- -- -- sion. GNAT is distributed in the hope that it will be useful, but WITH- -- -- OUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY -- -- or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -- -- for more details. You should have received a copy of the GNU General -- -- Public License distributed with GNAT; see file COPYING3. If not, go to -- -- http://www.gnu.org/licenses for a complete copy of the license. -- -- -- -- GNAT was originally developed by the GNAT team at New York University. -- -- Extensive contributions were provided by Ada Core Technologies Inc. -- -- -- ------------------------------------------------------------------------------ with Namet; use Namet; with Types; use Types; package Exp_Ch7 is procedure Expand_N_Package_Body (N : Node_Id); procedure Expand_N_Package_Declaration (N : Node_Id); ----------------------------- -- Finalization Management -- ----------------------------- function In_Finalization_Root (E : Entity_Id) return Boolean; -- True if current scope is in package System.Finalization_Root. Used -- to avoid certain expansions that would involve circularity in the -- Rtsfind mechanism. procedure Build_Final_List (N : Node_Id; Typ : Entity_Id); -- Build finalization list for anonymous access types, and for access -- types that are frozen before their designated types are known to -- be controlled. procedure Build_Controlling_Procs (Typ : Entity_Id); -- Typ is a record, and array type having controlled components. -- Create the procedures Deep_Initialize, Deep_Adjust and Deep_Finalize -- that take care of finalization management at run-time. procedure Build_Late_Proc (Typ : Entity_Id; Nam : Name_Id); -- Build one controlling procedure when a late body overrides one of -- the controlling operations. function Controller_Component (Typ : Entity_Id) return Entity_Id; -- Returns the entity of the component whose name is 'Name_uController' function CW_Or_Has_Controlled_Part (T : Entity_Id) return Boolean; -- True if T is a class-wide type, or if it has controlled parts ("part" -- means T or any of its subcomponents). This is the same as -- Needs_Finalization, except when pragma Restrictions (No_Finalization) -- applies, in which case we know that class-wide objects do not contain -- controlled parts. procedure Expand_Ctrl_Function_Call (N : Node_Id); -- Expand a call to a function returning a controlled value. That is to -- say attach the result of the call to the current finalization list, -- which is the one of the transient scope created for such constructs. function Find_Final_List (E : Entity_Id; Ref : Node_Id := Empty) return Node_Id; -- E is an entity representing a controlled object, a controlled type or a -- scope. If Ref is not empty, it is a reference to a controlled record, -- the closest Final list is in the controller component of the record -- containing Ref otherwise this function returns a reference to the final -- list attached to the closest dynamic scope (that can be E itself) -- creating this final list if necessary. function Has_New_Controlled_Component (E : Entity_Id) return Boolean; -- E is a type entity. Give the same result as Has_Controlled_Component -- except for tagged extensions where the result is True only if the -- latest extension contains a controlled component. function Make_Attach_Call (Obj_Ref : Node_Id; Flist_Ref : Node_Id; With_Attach : Node_Id) return Node_Id; -- Attach the referenced object to the referenced Final Chain 'Flist_Ref' -- With_Attach is an expression of type Short_Short_Integer which can be -- either '0' to signify no attachment, '1' for attachment to a simply -- linked list or '2' for attachment to a doubly linked list. function Make_Init_Call (Ref : Node_Id; Typ : Entity_Id; Flist_Ref : Node_Id; With_Attach : Node_Id) return List_Id; -- Ref is an expression (with no-side effect and is not required to have -- been previously analyzed) that references the object to be initialized. -- Typ is the expected type of Ref, which is either a controlled type -- (Is_Controlled) or a type with controlled components (Has_Controlled). -- With_Attach is an integer expression which is the attachment level, -- see System.Finalization_Implementation.Attach_To_Final_List for the -- documentation of Nb_Link. -- -- This function will generate the appropriate calls to make sure that the -- objects referenced by Ref are initialized. The generated code is quite -- different for an IS_Controlled type or a HAS_Controlled type, but this -- is not the problem for the caller, the details are in the body. function Make_Adjust_Call (Ref : Node_Id; Typ : Entity_Id; Flist_Ref : Node_Id; With_Attach : Node_Id; Allocator : Boolean := False) return List_Id; -- Ref is an expression (with no-side effect and is not required to have -- been previously analyzed) that references the object to be adjusted. Typ -- is the expected type of Ref, which is a controlled type (Is_Controlled) -- or a type with controlled components (Has_Controlled). With_Attach is an -- integer expression giving the attachment level (see documentation of -- Attach_To_Final_List.Nb_Link param documentation in s-finimp.ads. -- Note: if Typ is Finalize_Storage_Only and the object is at library -- level, then With_Attach will be ignored, and a zero link level will be -- passed to Attach_To_Final_List. -- -- This function will generate the appropriate calls to make sure that the -- objects referenced by Ref are adjusted. The generated code is quite -- different depending on the fact the type IS_Controlled or HAS_Controlled -- but this is not the problem of the caller, the details are in the body. -- The objects must be attached when the adjust takes place after an -- initialization expression but not when it takes place after a regular -- assignment. -- -- If Allocator is True, we are adjusting a newly-created object. The -- existing chaining pointers should not be left unchanged, because they -- may come from a bit-for-bit copy of those from an initializing object. -- So, when this flag is True, if the chaining pointers should otherwise -- be left unset, instead they are reset to null. function Make_Final_Call (Ref : Node_Id; Typ : Entity_Id; With_Detach : Node_Id) return List_Id; -- Ref is an expression (with no-side effect and is not required to have -- been previously analyzed) that references the object to be Finalized. -- Typ is the expected type of Ref, which is a controlled type -- (Is_Controlled) or a type with controlled components (Has_Controlled). -- With_Detach is a boolean expression indicating whether to detach the -- controlled object from whatever finalization list it is currently -- attached to. -- -- This function will generate the appropriate calls to make sure that the -- objects referenced by Ref are finalized. The generated code is quite -- different depending on the fact the type IS_Controlled or HAS_Controlled -- but this is not the problem of the caller, the details are in the body. -- The objects must be detached when finalizing an unchecked deallocated -- object but not when finalizing the target of an assignment, it is not -- necessary either on scope exit. function Make_Handler_For_Ctrl_Operation (Loc : Source_Ptr) return Node_Id; -- Generate an implicit exception handler with an 'others' choice, -- converting any occurrence to a raise of Program_Error. function Needs_Finalization (T : Entity_Id) return Boolean; -- True if T potentially needs finalization actions. True if T is -- controlled, or has subcomponents. Also True if T is a class-wide type, -- because some type extension might add controlled subcomponents, except -- that if pragma Restrictions (No_Finalization) applies, this is False for -- class-wide types. -------------------------------------------- -- Task and Protected Object finalization -- -------------------------------------------- function Cleanup_Array (N : Node_Id; Obj : Node_Id; Typ : Entity_Id) return List_Id; -- Generate loops to finalize any tasks or simple protected objects that -- are subcomponents of an array. function Cleanup_Protected_Object (N : Node_Id; Ref : Node_Id) return Node_Id; -- Generate code to finalize a protected object without entries function Cleanup_Record (N : Node_Id; Obj : Node_Id; Typ : Entity_Id) return List_Id; -- For each subcomponent of a record that contains tasks or simple -- protected objects, generate the appropriate finalization call. function Cleanup_Task (N : Node_Id; Ref : Node_Id) return Node_Id; -- Generate code to finalize a task function Has_Simple_Protected_Object (T : Entity_Id) return Boolean; -- Check whether composite type contains a simple protected component function Is_Simple_Protected_Type (T : Entity_Id) return Boolean; -- Check whether argument is a protected type without entries. Protected -- types with entries are controlled, and their cleanup is handled by the -- standard finalization machinery. For simple protected types we generate -- inline code to release their locks. -------------------------------- -- Transient Scope Management -- -------------------------------- procedure Expand_Cleanup_Actions (N : Node_Id); -- Expand the necessary stuff into a scope to enable finalization of local -- objects and deallocation of transient data when exiting the scope. N is -- a "scope node" that is to say one of the following: N_Block_Statement, -- N_Subprogram_Body, N_Task_Body, N_Entry_Body. procedure Establish_Transient_Scope (N : Node_Id; Sec_Stack : Boolean); -- Push a new transient scope on the scope stack. N is the node responsible -- for the need of a transient scope. If Sec_Stack is True then the -- secondary stack is brought in, otherwise it isn't. function Node_To_Be_Wrapped return Node_Id; -- return the node to be wrapped if the current scope is transient procedure Store_Before_Actions_In_Scope (L : List_Id); -- Append the list L of actions to the end of the before-actions store in -- the top of the scope stack procedure Store_After_Actions_In_Scope (L : List_Id); -- Append the list L of actions to the beginning of the after-actions store -- in the top of the scope stack procedure Wrap_Transient_Declaration (N : Node_Id); -- N is an object declaration. Expand the finalization calls after the -- declaration and make the outer scope being the transient one. procedure Wrap_Transient_Expression (N : Node_Id); -- N is a sub-expression. Expand a transient block around an expression procedure Wrap_Transient_Statement (N : Node_Id); -- N is a statement. Expand a transient block around an instruction end Exp_Ch7;