313 lines
16 KiB
Ada
313 lines
16 KiB
Ada
------------------------------------------------------------------------------
|
|
-- --
|
|
-- GNAT COMPILER COMPONENTS --
|
|
-- --
|
|
-- E X P _ C H 9 --
|
|
-- --
|
|
-- S p e c --
|
|
-- --
|
|
-- $Revision: 1.56 $
|
|
-- --
|
|
-- Copyright (C) 1992-1999 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 2, 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 COPYING. If not, write --
|
|
-- to the Free Software Foundation, 59 Temple Place - Suite 330, Boston, --
|
|
-- MA 02111-1307, USA. --
|
|
-- --
|
|
-- GNAT was originally developed by the GNAT team at New York University. --
|
|
-- It is now maintained by Ada Core Technologies Inc (http://www.gnat.com). --
|
|
-- --
|
|
------------------------------------------------------------------------------
|
|
|
|
-- Expand routines for chapter 9 constructs
|
|
|
|
with Types; use Types;
|
|
|
|
package Exp_Ch9 is
|
|
|
|
procedure Add_Discriminal_Declarations
|
|
(Decls : List_Id;
|
|
Typ : Entity_Id;
|
|
Name : Name_Id;
|
|
Loc : Source_Ptr);
|
|
-- This routine is used to add discriminal declarations to task and
|
|
-- protected operation bodies. The discriminants are available by normal
|
|
-- selection from the concurrent object (whose name is passed as the third
|
|
-- parameter). Discriminant references inside the body have already
|
|
-- been replaced by references to the corresponding discriminals. The
|
|
-- declarations constructed by this procedure hook the references up with
|
|
-- the objects:
|
|
--
|
|
-- discriminal_name : discr_type renames name.discriminant_name;
|
|
--
|
|
-- Obviously we could have expanded the discriminant references in the
|
|
-- first place to be the appropriate selection, but this turns out to
|
|
-- be hard to do because it would introduce difference in handling of
|
|
-- discriminant references depending on their location.
|
|
|
|
procedure Add_Private_Declarations
|
|
(Decls : List_Id;
|
|
Typ : Entity_Id;
|
|
Name : Name_Id;
|
|
Loc : Source_Ptr);
|
|
-- This routine is used to add private declarations to protected bodies.
|
|
-- These are analogous to the discriminal declarations added to tasks
|
|
-- and protected operations, and consist of a renaming of each private
|
|
-- object to a selection from the concurrent object passed as an extra
|
|
-- parameter to each such operation:
|
|
-- private_name : private_type renames name.private_name;
|
|
-- As with discriminals, private references inside the protected
|
|
-- subprogram bodies have already been replaced by references to the
|
|
-- corresponding privals.
|
|
|
|
procedure Build_Activation_Chain_Entity (N : Node_Id);
|
|
-- Given a declaration N of an object that is a task, or contains tasks
|
|
-- (other than allocators to tasks) this routine ensures that an activation
|
|
-- chain has been declared in the appropriate scope, building the required
|
|
-- declaration for the chain variable if not. The name of this variable
|
|
-- is always _Chain and it is accessed by name. This procedure also adds
|
|
-- an appropriate call to Activate_Tasks to activate the tasks for this
|
|
-- activation chain. It does not however deal with the call needed in the
|
|
-- case of allocators to Expunge_Unactivated_Tasks, this is separately
|
|
-- handled in the Expand_Task_Allocator routine.
|
|
|
|
function Build_Call_With_Task (N : Node_Id; E : Entity_Id) return Node_Id;
|
|
-- N is a node representing the name of a task or an access to a task.
|
|
-- The value returned is a call to the function whose name is the entity
|
|
-- E (typically a runtime routine entity obtained using RTE) with the
|
|
-- Task_Id of the associated task as the parameter. The caller is
|
|
-- responsible for analyzing and resolving the resulting tree.
|
|
|
|
procedure Build_Master_Entity (E : Entity_Id);
|
|
-- Given an entity E for the declaration of an object containing tasks
|
|
-- or of a type declaration for an allocator whose designated type is a
|
|
-- task or contains tasks, this routine marks the appropriate enclosing
|
|
-- context as a master, and also declares a variable called _Master in
|
|
-- the current declarative part which captures the value of Current_Master
|
|
-- (if not already built by a prior call). We build this object (instead
|
|
-- of just calling Current_Master) for two reasons. First it is clearly
|
|
-- more efficient to call Current_Master only once for a bunch of tasks
|
|
-- in the same declarative part, and second it makes things easier in
|
|
-- generating the initialization routines, since they can just reference
|
|
-- the object _Master by name, and they will get the proper Current_Master
|
|
-- value at the outer level, and copy in the parameter value for the outer
|
|
-- initialization call if the call is for a nested component). Note that
|
|
-- in the case of nested packages, we only really need to make one such
|
|
-- object at the outer level, but it is much easier to generate one per
|
|
-- declarative part.
|
|
|
|
function Build_Protected_Sub_Specification
|
|
(N : Node_Id;
|
|
Prottyp : Entity_Id;
|
|
Unprotected : Boolean := False)
|
|
return Node_Id;
|
|
-- Build specification for protected subprogram. This is called when
|
|
-- expanding a protected type, and also when expanding the declaration for
|
|
-- an Access_To_Protected_Subprogram type. In the latter case, Prottyp is
|
|
-- empty, and the first parameter of the signature of the protected op is
|
|
-- of type System.Address.
|
|
|
|
procedure Build_Protected_Subprogram_Call
|
|
(N : Node_Id;
|
|
Name : Node_Id;
|
|
Rec : Node_Id;
|
|
External : Boolean := True);
|
|
-- The node N is a subprogram or entry call to a protected subprogram.
|
|
-- This procedure rewrites this call with the appropriate expansion.
|
|
-- Name is the subprogram, and Rec is the record corresponding to the
|
|
-- protected object. External is False if the call is to another
|
|
-- protected subprogram within the same object.
|
|
|
|
procedure Build_Task_Activation_Call (N : Node_Id);
|
|
-- This procedure is called for constructs that can be task activators
|
|
-- i.e. task bodies, subprogram bodies, package bodies and blocks. If
|
|
-- the construct is a task activator (as indicated by the non-empty
|
|
-- setting of Activation_Chain_Entity, either in the construct, or, in
|
|
-- the case of a package body, in its associated package spec), then
|
|
-- a call to Activate_Tasks with this entity as the single parameter
|
|
-- is inserted at the start of the statements of the activator.
|
|
|
|
procedure Build_Task_Allocate_Block
|
|
(Actions : List_Id;
|
|
N : Node_Id;
|
|
Args : List_Id);
|
|
-- This routine is used in the case of allocators where the designated
|
|
-- type is a task or contains tasks. In this case, the normal initialize
|
|
-- call is replaced by:
|
|
--
|
|
-- blockname : label;
|
|
-- blockname : declare
|
|
-- _Chain : Activation_Chain;
|
|
--
|
|
-- procedure _Expunge is
|
|
-- begin
|
|
-- Expunge_Unactivated_Tasks (_Chain);
|
|
-- end;
|
|
--
|
|
-- begin
|
|
-- Init (Args);
|
|
-- Activate_Tasks (_Chain);
|
|
-- at end
|
|
-- _Expunge;
|
|
-- end;
|
|
--
|
|
-- to get the task or tasks created and initialized. The expunge call
|
|
-- ensures that any tasks that get created but not activated due to an
|
|
-- exception are properly expunged (it has no effect in the normal case)
|
|
-- The argument N is the allocator, and Args is the list of arguments
|
|
-- for the initialization call, constructed by the caller, which uses
|
|
-- the Master_Id of the access type as the _Master parameter, and _Chain
|
|
-- (defined above) as the _Chain parameter.
|
|
|
|
function Concurrent_Ref (N : Node_Id) return Node_Id;
|
|
-- Given the name of a concurrent object (task or protected object), or
|
|
-- the name of an access to a concurrent object, this function returns an
|
|
-- expression referencing the associated Task_Id or Protection object,
|
|
-- respectively. Note that a special case is when the name is a reference
|
|
-- to a task type name. This can only happen within a task body, and the
|
|
-- meaning is to get the Task_Id for the currently executing task.
|
|
|
|
function Convert_Concurrent
|
|
(N : Node_Id;
|
|
Typ : Entity_Id)
|
|
return Node_Id;
|
|
-- N is an expression of type Typ. If the type is not a concurrent
|
|
-- type then it is returned unchanged. If it is a task or protected
|
|
-- reference, Convert_Concurrent creates an unchecked conversion node
|
|
-- from this expression to the corresponding concurrent record type
|
|
-- value. We need this in any situation where the concurrent type is
|
|
-- used, because the actual concurrent object is an object of the
|
|
-- corresponding concurrent type, and manipulations on the concurrent
|
|
-- object actually manipulate the corresponding object of the record
|
|
-- type.
|
|
|
|
function Entry_Index_Expression
|
|
(Sloc : Source_Ptr;
|
|
Ent : Entity_Id;
|
|
Index : Node_Id;
|
|
Ttyp : Entity_Id)
|
|
return Node_Id;
|
|
-- Returns an expression to compute a task entry index given the name
|
|
-- of the entry or entry family. For the case of a task entry family,
|
|
-- the Index parameter contains the expression for the subscript.
|
|
-- Ttyp is the task type.
|
|
|
|
procedure Establish_Task_Master (N : Node_Id);
|
|
-- Given a subprogram body, or a block statement, or a task body, this
|
|
-- proccedure makes the necessary transformations required of a task
|
|
-- master (add Enter_Master call at start, and establish a cleanup
|
|
-- routine to make sure Complete_Master is called on exit).
|
|
|
|
procedure Expand_Access_Protected_Subprogram_Type (N : Node_Id);
|
|
-- Build Equivalent_Type for an Access_to_protected_Subprogram.
|
|
|
|
procedure Expand_Accept_Declarations (N : Node_Id; Ent : Entity_Id);
|
|
-- Expand declarations required for accept statement. See bodies of
|
|
-- both Expand_Accept_Declarations and Expand_N_Accept_Statement for
|
|
-- full details of the nature and use of these declarations, which
|
|
-- are inserted immediately before the accept node N. The second
|
|
-- argument is the entity for the corresponding entry.
|
|
|
|
procedure Expand_Entry_Barrier (N : Node_Id; Ent : Entity_Id);
|
|
-- Expand the entry barrier into a function. This is called directly
|
|
-- from Analyze_Entry_Body so that the discriminals and privals of the
|
|
-- barrier can be attached to the function declaration list, and a new
|
|
-- set prepared for the entry body procedure, bedore the entry body
|
|
-- statement sequence can be expanded. The resulting function is analyzed
|
|
-- now, within the context of the protected object, to resolve calls to
|
|
-- other protected functions.
|
|
|
|
procedure Expand_Entry_Body_Declarations (N : Node_Id);
|
|
-- Expand declarations required for the expansion of the
|
|
-- statements of the body.
|
|
|
|
procedure Expand_N_Abort_Statement (N : Node_Id);
|
|
procedure Expand_N_Accept_Statement (N : Node_Id);
|
|
procedure Expand_N_Asynchronous_Select (N : Node_Id);
|
|
procedure Expand_N_Conditional_Entry_Call (N : Node_Id);
|
|
procedure Expand_N_Delay_Relative_Statement (N : Node_Id);
|
|
procedure Expand_N_Delay_Until_Statement (N : Node_Id);
|
|
procedure Expand_N_Entry_Body (N : Node_Id);
|
|
procedure Expand_N_Entry_Call_Statement (N : Node_Id);
|
|
procedure Expand_N_Entry_Declaration (N : Node_Id);
|
|
procedure Expand_N_Protected_Body (N : Node_Id);
|
|
|
|
procedure Expand_N_Protected_Type_Declaration (N : Node_Id);
|
|
-- Expands protected type declarations. This results, among
|
|
-- other things, in the declaration of a record type for the
|
|
-- representation of protected objects and (if there are entries)
|
|
-- in an entry service procedure. The Protection value used by
|
|
-- the GNARL to control the object will always be the first
|
|
-- field of the record, and the entry service procedure spec
|
|
-- (if it exists) will always immediately follow the record
|
|
-- declaration. This allows these two nodes to be found from
|
|
-- the type using Corresponding_Record, without benefit of
|
|
-- of further attributes.
|
|
|
|
procedure Expand_N_Requeue_Statement (N : Node_Id);
|
|
procedure Expand_N_Selective_Accept (N : Node_Id);
|
|
procedure Expand_N_Single_Task_Declaration (N : Node_Id);
|
|
procedure Expand_N_Task_Body (N : Node_Id);
|
|
procedure Expand_N_Task_Type_Declaration (N : Node_Id);
|
|
procedure Expand_N_Timed_Entry_Call (N : Node_Id);
|
|
|
|
procedure Expand_Protected_Body_Declarations
|
|
(N : Node_Id;
|
|
Spec_Id : Entity_Id);
|
|
-- Expand declarations required for a protected body. See bodies of
|
|
-- both Expand_Protected_Body_Declarations and Expand_N_Protected_Body
|
|
-- for full details of the nature and use of these declarations.
|
|
-- The second argument is the entity for the corresponding
|
|
-- protected type declaration.
|
|
|
|
function External_Subprogram (E : Entity_Id) return Entity_Id;
|
|
-- return the external version of a protected operation, which locks
|
|
-- the object before invoking the internal protected subprogram body.
|
|
|
|
function First_Protected_Operation (D : List_Id) return Node_Id;
|
|
-- Given the declarations list for a protected body, find the
|
|
-- first protected operation body.
|
|
|
|
function Make_Task_Create_Call (Task_Rec : Entity_Id) return Node_Id;
|
|
-- Given the entity of the record type created for a task type, build
|
|
-- the call to Create_Task
|
|
|
|
function Make_Initialize_Protection
|
|
(Protect_Rec : Entity_Id)
|
|
return List_Id;
|
|
-- Given the entity of the record type created for a protected type, build
|
|
-- a list of statements needed for proper initialization of the object.
|
|
|
|
function Next_Protected_Operation (N : Node_Id) return Node_Id;
|
|
-- Given a protected operation node (a subprogram or entry body),
|
|
-- find the following node in the declarations list.
|
|
|
|
procedure Set_Discriminals
|
|
(Dec : Node_Id;
|
|
Op : Node_Id;
|
|
Loc : Source_Ptr);
|
|
-- Replace discriminals in a protected type for use by the
|
|
-- next protected operation on the type. Each operation needs a
|
|
-- new set of discirminals, since it needs a unique renaming of
|
|
-- the discriminant fields in the record used to implement the
|
|
-- protected type.
|
|
|
|
procedure Set_Privals
|
|
(Dec : Node_Id;
|
|
Op : Node_Id;
|
|
Loc : Source_Ptr);
|
|
-- Associates a new set of privals (placeholders for later access to
|
|
-- private components of protected objects) with the private object
|
|
-- declarations of a protected object. These will be used to expand
|
|
-- the references to private objects in the next protected
|
|
-- subprogram or entry body to be expanded.
|
|
|
|
end Exp_Ch9;
|