-- --
-- S p e c --
-- --
--- Copyright (C) 1992-2011, Free Software Foundation, Inc. --
+-- Copyright (C) 1992-2013, 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- --
-- For actions appearing in the then or else expression of a conditional
-- expression, these actions are similarly placed in the node, using the
-- Then_Actions or Else_Actions field as appropriate. Once again the
- -- expansion of the N_Conditional_Expression node rewrites the node so
- -- that the actions can be normally positioned.
+ -- expansion of the N_If_Expression node rewrites the node so that the
+ -- actions can be positioned normally.
+
+ -- For actions coming from expansion of the expression in an expression
+ -- with actions node, the action is appended to the list of actions.
-- Basically what we do is to climb up to the tree looking for the
-- proper insertion point, as described by one of the above cases,
-- Other Subprograms --
-----------------------
+ procedure Activate_Atomic_Synchronization (N : Node_Id);
+ -- N is a node for which atomic synchronization may be required (it is
+ -- either an identifier, expanded name, or selected/indexed component or
+ -- an explicit dereference). The caller has checked the basic conditions
+ -- (atomic variable appearing and Atomic_Sync not disabled). This function
+ -- checks if atomic synchronization is required and if so sets the flag
+ -- and if appropriate generates a warning (in -gnatw.n mode).
+
procedure Adjust_Condition (N : Node_Id);
-- The node N is an expression whose root-type is Boolean, and which
-- represents a boolean value used as a condition (i.e. a True/False
(N : Node_Id;
Is_Allocate : Boolean);
-- Create a custom Allocate/Deallocate to be associated with an allocation
- -- or deallocation of a controlled or class-wide object. In the case of
- -- allocation, N is the declaration of the temporary variable which
- -- represents the expression of the original allocator node, otherwise N
- -- must be a free statement. If flag Is_Allocate is set, the generated
- -- routine is allocate, deallocate otherwise. The generated routine is:
+ -- or deallocation:
--
- -- F : constant Boolean := -- CW case
- -- Ada.Tags.Needs_Finalization (<Expr>'Tag); -- CW case
+ -- 1) controlled objects
+ -- 2) class-wide objects
+ -- 3) any kind of object on a subpool
--
- -- procedure Allocate / Deallocate
- -- (P : Storage_Pool;
- -- A : [out] Address; -- out is present for Allocate
- -- S : Storage_Count;
- -- L : Storage_Count)
- -- is
- -- begin
- -- Allocate / Deallocate
- -- (<Ptr_Typ collection>, A, S, L, [Needs_Header => F]);
- -- end Allocate;
+ -- N must be an allocator or the declaration of a temporary variable which
+ -- represents the expression of the original allocator node, otherwise N
+ -- must be a free statement. If flag Is_Allocate is set, the generated
+ -- routine is allocate, deallocate otherwise.
function Build_Runtime_Call (Loc : Source_Ptr; RE : RE_Id) return Node_Id;
-- Build an N_Procedure_Call_Statement calling the given runtime entity.
-- which represent entry [family member] names. These strings are created
-- by the compiler and used by GDB.
+ procedure Evaluate_Name (Nam : Node_Id);
+ -- Remove the all side effects from a name which appears as part of an
+ -- object renaming declaration. More comments are needed here that explain
+ -- how this differs from Force_Evaluation and Remove_Side_Effects ???
+
procedure Evolve_And_Then (Cond : in out Node_Id; Cond1 : Node_Id);
-- Rewrites Cond with the expression: Cond and then Cond1. If Cond is
-- Empty, then simply returns Cond1 (this allows the use of Empty to
-- declarations and/or allocations when the type is indefinite (including
-- class-wide).
- function Find_Init_Call
- (Var : Entity_Id;
- Rep_Clause : Node_Id) return Node_Id;
- -- Look for init_proc call for variable Var, either among declarations
- -- between that of Var and a subsequent Rep_Clause applying to Var, or
- -- in the list of freeze actions associated with Var, and if found, return
- -- that call node.
-
function Find_Interface_ADT
(T : Entity_Id;
Iface : Entity_Id) return Elmt_Id;
function Fully_Qualified_Name_String (E : Entity_Id) return String_Id;
-- Generates the string literal corresponding to the fully qualified name
- -- of entity E with an ASCII.NUL appended at the end of the name.
+ -- of entity E, in all upper case, with an ASCII.NUL appended at the end
+ -- of the name.
procedure Generate_Poll_Call (N : Node_Id);
-- If polling is active, then a call to the Poll routine is built,
-- False otherwise. True for an empty list. It is an error to call this
-- routine with No_List as the argument.
+ function Is_Displacement_Of_Object_Or_Function_Result
+ (Obj_Id : Entity_Id) return Boolean;
+ -- Determine whether Obj_Id is a source entity that has been initialized by
+ -- either a controlled function call or the assignment of another source
+ -- object. In both cases the initialization expression is rewritten as a
+ -- class-wide conversion of Ada.Tags.Displace.
+
function Is_Finalizable_Transient
(Decl : Node_Id;
Rel_Node : Node_Id) return Boolean;
-- Return True if Typ is a library level tagged type. Currently we use
-- this information to build statically allocated dispatch tables.
- function Is_Null_Access_BIP_Func_Call (Expr : Node_Id) return Boolean;
- -- Determine whether node Expr denotes a build-in-place function call with
- -- a value of "null" for extra formal BIPaccess.
-
function Is_Non_BIP_Func_Call (Expr : Node_Id) return Boolean;
-- Determine whether node Expr denotes a non build-in-place function call
+ function Is_Possibly_Unaligned_Object (N : Node_Id) return Boolean;
+ -- Node N is an object reference. This function returns True if it is
+ -- possible that the object may not be aligned according to the normal
+ -- default alignment requirement for its type (e.g. if it appears in a
+ -- packed record, or as part of a component that has a component clause.)
+
+ function Is_Possibly_Unaligned_Slice (N : Node_Id) return Boolean;
+ -- Determine whether the node P is a slice of an array where the slice
+ -- result may cause alignment problems because it has an alignment that
+ -- is not compatible with the type. Return True if so.
+
function Is_Ref_To_Bit_Packed_Array (N : Node_Id) return Boolean;
-- Determine whether the node P is a reference to a bit packed array, i.e.
-- whether the designated object is a component of a bit packed array, or a
-- Determine whether object Id is related to an expanded return statement.
-- The case concerned is "return Id.all;".
- function Is_Possibly_Unaligned_Slice (N : Node_Id) return Boolean;
- -- Determine whether the node P is a slice of an array where the slice
- -- result may cause alignment problems because it has an alignment that
- -- is not compatible with the type. Return True if so.
-
- function Is_Possibly_Unaligned_Object (N : Node_Id) return Boolean;
- -- Node N is an object reference. This function returns True if it is
- -- possible that the object may not be aligned according to the normal
- -- default alignment requirement for its type (e.g. if it appears in a
- -- packed record, or as part of a component that has a component clause.)
-
function Is_Renamed_Object (N : Node_Id) return Boolean;
-- Returns True if the node N is a renamed object. An expression is
-- considered to be a renamed object if either it is the Name of an object
-- We consider that a (1 .. 2) is a renamed object since it is the prefix
-- of the name in the renaming declaration.
- function Is_Tag_To_CW_Conversion (Obj_Id : Entity_Id) return Boolean;
+ function Is_Secondary_Stack_BIP_Func_Call (Expr : Node_Id) return Boolean;
+ -- Determine whether Expr denotes a build-in-place function which returns
+ -- its result on the secondary stack.
+
+ function Is_Tag_To_Class_Wide_Conversion
+ (Obj_Id : Entity_Id) return Boolean;
-- Determine whether object Obj_Id is the result of a tag-to-class-wide
-- type conversion.
function Make_Predicate_Call
(Typ : Entity_Id;
- Expr : Node_Id) return Node_Id;
+ Expr : Node_Id;
+ Mem : Boolean := False) return Node_Id;
-- Typ is a type with Predicate_Function set. This routine builds a call to
-- this function passing Expr as the argument, and returns it unanalyzed.
+ -- If Mem is set True, this is the special call for the membership case,
+ -- and the function called is the Predicate_Function_M if present.
function Make_Predicate_Check
(Typ : Entity_Id;
-- causes trouble for the back end (see Component_May_Be_Bit_Aligned for
-- further details).
+ procedure Process_Statements_For_Controlled_Objects (N : Node_Id);
+ -- N is a node which contains a non-handled statement list. Inspect the
+ -- statements looking for declarations of controlled objects. If at least
+ -- one such object is found, wrap the statement list in a block.
+
+ function Remove_Init_Call
+ (Var : Entity_Id;
+ Rep_Clause : Node_Id) return Node_Id;
+ -- Look for init_proc call or aggregate initialization statements for
+ -- variable Var, either among declarations between that of Var and a
+ -- subsequent Rep_Clause applying to Var, or in the list of freeze actions
+ -- associated with Var, and if found, remove and return that call node.
+
procedure Remove_Side_Effects
(Exp : Node_Id;
Name_Req : Boolean := False;
-- terms is scalar. This is true for scalars in the Ada sense, and for
-- packed arrays which are represented by a scalar (modular) type.
- function Requires_Cleanup_Actions (N : Node_Id) return Boolean;
+ function Requires_Cleanup_Actions
+ (N : Node_Id;
+ Lib_Level : Boolean) return Boolean;
-- Given a node N, determine whether its declarative and/or statement list
-- contains one of the following:
--
-- 1) controlled objects
-- 2) library-level tagged types
--
- -- The above cases require special actions on scope exit.
+ -- These cases require special actions on scope exit. The flag Lib_Level
+ -- is set True if the construct is at library level, and False otherwise.
function Safe_Unchecked_Type_Conversion (Exp : Node_Id) return Boolean;
-- Given the node for an N_Unchecked_Type_Conversion, return True if this
-- is conservative, in that a result of False is decisive. A result of True
-- means that such a component may or may not be present.
+ function Within_Case_Or_If_Expression (N : Node_Id) return Boolean;
+ -- Determine whether arbitrary node N is within a case or an if expression
+
procedure Wrap_Cleanup_Procedure (N : Node_Id);
-- Given an N_Subprogram_Body node, this procedure adds an Abort_Defer call
-- at the start of the statement sequence, and an Abort_Undefer call at the
OSDN Git Service
