-- --
-- S p e c --
-- --
--- Copyright (C) 1992-2008, Free Software Foundation, Inc. --
+-- Copyright (C) 1992-2009, 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- --
-- not necessarily mean that CE could be raised, but a response of True
-- means that for sure CE cannot be raised.
+ procedure Check_Dynamically_Tagged_Expression
+ (Expr : Node_Id;
+ Typ : Entity_Id;
+ Related_Nod : Node_Id);
+ -- Check wrong use of dynamically tagged expression
+
procedure Check_Fully_Declared (T : Entity_Id; N : Node_Id);
-- Verify that the full declaration of type T has been seen. If not,
-- place error message on node N. Used in object declarations, type
-- of Old is set and Old has no yet been Frozen (i.e. Is_Frozen is false);
function Copy_Parameter_List (Subp_Id : Entity_Id) return List_Id;
- -- Utility to create a parameter profile for a new subprogram spec,
- -- when the subprogram has a body that acts as spec. This is done for
- -- some cases of inlining, and for private protected ops. Also used
- -- to create bodies for stubbed subprograms.
+ -- Utility to create a parameter profile for a new subprogram spec, when
+ -- the subprogram has a body that acts as spec. This is done for some cases
+ -- of inlining, and for private protected ops. Also used to create bodies
+ -- for stubbed subprograms.
function Current_Entity (N : Node_Id) return Entity_Id;
-- Find the currently visible definition for a given identifier, that is to
function Current_Subprogram return Entity_Id;
-- Returns current enclosing subprogram. If Current_Scope is a subprogram,
- -- then that is what is returned, otherwise the Enclosing_Subprogram of
- -- the Current_Scope is returned. The returned value is Empty if this
- -- is called from a library package which is not within any subprogram.
+ -- then that is what is returned, otherwise the Enclosing_Subprogram of the
+ -- Current_Scope is returned. The returned value is Empty if this is called
+ -- from a library package which is not within any subprogram.
function Defining_Entity (N : Node_Id) return Entity_Id;
-- Given a declaration N, returns the associated defining entity. If
-- components of protected types, and constraint checks on entry
-- families constrained by discriminants.
+ function Denotes_Same_Object (A1, A2 : Node_Id) return Boolean;
+ function Denotes_Same_Prefix (A1, A2 : Node_Id) return Boolean;
+ -- Functions to detect suspicious overlapping between actuals in a call,
+ -- when one of them is writable. The predicates are those proposed in
+ -- AI05-0144, to detect dangerous order dependence in complex calls.
+ -- I would add a parameter Warn which enables more extensive testing of
+ -- cases as we find appropriate when we are only warning ??? Or perhaps
+ -- return an indication of (Error, Warn, OK) ???
+
function Denotes_Variable (N : Node_Id) return Boolean;
-- Returns True if node N denotes a single variable without parentheses
-- denotes when analyzed. Subsequent uses of this id on a different
-- type denote the discriminant at the same position in this new type.
- function Find_Overlaid_Object (N : Node_Id) return Entity_Id;
- -- The node N should be an address representation clause. This function
- -- checks if the target expression is the address of some stand alone
- -- object (variable or constant), and if so, returns its entity. If N is
- -- not an address representation clause, or if it is not possible to
- -- determine that the address is of this form, then Empty is returned.
+ procedure Find_Overlaid_Entity
+ (N : Node_Id;
+ Ent : out Entity_Id;
+ Off : out Boolean);
+ -- The node N should be an address representation clause. Determines if the
+ -- target expression is the address of an entity with an optional offset.
+ -- If so, Ent is set to the entity and, if there is an offset, Off is set
+ -- to True, otherwise to False. If N is not an address representation
+ -- clause, or if it is not possible to determine that the address is of
+ -- this form, then Ent is set to Empty, and Off is set to False.
function Find_Parameter_Type (Param : Node_Id) return Entity_Id;
-- Return the type of formal parameter Param as determined by its
-- Given an entity for an exception, package, subprogram or generic unit,
-- returns the ultimately renamed entity if this is a renaming. If this is
-- not a renamed entity, returns its argument. It is an error to call this
- -- with any any other kind of entity.
+ -- with any other kind of entity.
function Get_Subprogram_Entity (Nod : Node_Id) return Entity_Id;
-- Nod is either a procedure call statement, or a function call, or
-- corresponding private part must not.
procedure Insert_Explicit_Dereference (N : Node_Id);
- -- In a context that requires a composite or subprogram type and
- -- where a prefix is an access type, rewrite the access type node
- -- N (which is the prefix, e.g. of an indexed component) as an
- -- explicit dereference.
+ -- In a context that requires a composite or subprogram type and where a
+ -- prefix is an access type, rewrite the access type node N (which is the
+ -- prefix, e.g. of an indexed component) as an explicit dereference.
procedure Inspect_Deferred_Constant_Completion (Decls : List_Id);
-- Examine all deferred constants in the declaration list Decls and check
-- Import pragma. Emit the error message if that is not the case.
function Is_AAMP_Float (E : Entity_Id) return Boolean;
- -- Defined for all type entities. Returns True only for the base type
- -- of float types with AAMP format. The particular format is determined
- -- by the Digits_Value value which is 6 for the 32-bit floating point type,
- -- or 9 for the 48-bit type. This is not an attribute function (like
- -- VAX_Float) in order to not use up an extra flag and to prevent
- -- the dependency of Einfo on Targparm which would be required for a
- -- synthesized attribute.
+ -- Defined for all type entities. Returns True only for the base type of
+ -- float types with AAMP format. The particular format is determined by the
+ -- Digits_Value value which is 6 for the 32-bit floating point type, or 9
+ -- for the 48-bit type. This is not an attribute function (like VAX_Float)
+ -- in order to not use up an extra flag and to prevent the dependency of
+ -- Einfo on Targparm which would be required for a synthesized attribute.
+
+ function Is_Actual_Out_Parameter (N : Node_Id) return Boolean;
+ -- Determines if N is an actual parameter of out mode in a subprogram call
function Is_Actual_Parameter (N : Node_Id) return Boolean;
-- Determines if N is an actual parameter in a subprogram call
-- Ada 2005 (AI-345): Determine whether Proc_Nam is a primitive procedure
-- of a limited interface with a controlling first parameter.
+ function Is_CPP_Constructor_Call (N : Node_Id) return Boolean;
+ -- Returns True if N is a call to a CPP constructor
+
function Is_Dependent_Component_Of_Mutable_Object
(Object : Node_Id) return Boolean;
- -- Returns True if Object is the name of a subcomponent that
- -- depends on discriminants of a variable whose nominal subtype
- -- is unconstrained and not indefinite, and the variable is
- -- not aliased. Otherwise returns False. The nodes passed
- -- to this function are assumed to denote objects.
+ -- Returns True if Object is the name of a subcomponent that depends on
+ -- discriminants of a variable whose nominal subtype is unconstrained and
+ -- not indefinite, and the variable is not aliased. Otherwise returns
+ -- False. The nodes passed to this function are assumed to denote objects.
function Is_Dereferenced (N : Node_Id) return Boolean;
- -- N is a subexpression node of an access type. This function returns
- -- true if N appears as the prefix of a node that does a dereference
- -- of the access value (selected/indexed component, explicit dereference
- -- or a slice), and false otherwise.
+ -- N is a subexpression node of an access type. This function returns true
+ -- if N appears as the prefix of a node that does a dereference of the
+ -- access value (selected/indexed component, explicit dereference or a
+ -- slice), and false otherwise.
function Is_Descendent_Of (T1 : Entity_Id; T2 : Entity_Id) return Boolean;
-- Returns True if type T1 is a descendent of type T2, and false otherwise.
-- point type T, i.e. if it is an exact multiple of Small.
function Is_Fully_Initialized_Type (Typ : Entity_Id) return Boolean;
- -- Typ is a type entity. This function returns true if this type is
- -- fully initialized, meaning that an object of the type is fully
- -- initialized. Note that initialization resulting from the use of
- -- pragma Normalized_Scalars does not count. Note that this is only
- -- used for the purpose of issuing warnings for objects that are
- -- potentially referenced uninitialized. This means that the result
- -- returned is not crucial, but probably should err on the side of
- -- thinking things are fully initialized if it does not know.
+ -- Typ is a type entity. This function returns true if this type is fully
+ -- initialized, meaning that an object of the type is fully initialized.
+ -- Note that initialization resulting from use of pragma Normalized_Scalars
+ -- does not count. Note that this is only used for the purpose of issuing
+ -- warnings for objects that are potentially referenced uninitialized. This
+ -- means that the result returned is not crucial, but should err on the
+ -- side of thinking things are fully initialized if it does not know.
function Is_Inherited_Operation (E : Entity_Id) return Boolean;
-- E is a subprogram. Return True is E is an implicit operation inherited
-- by a derived type declarations.
+ function Is_LHS (N : Node_Id) return Boolean;
+ -- Returns True iff N is used as Name in an assignment statement.
+
function Is_Library_Level_Entity (E : Entity_Id) return Boolean;
-- A library-level declaration is one that is accessible from Standard,
-- i.e. a library unit or an entity declared in a library package.
function Is_Local_Variable_Reference (Expr : Node_Id) return Boolean;
- -- Determines whether Expr is a reference to a variable or IN OUT
- -- mode parameter of the current enclosing subprogram.
+ -- Determines whether Expr is a reference to a variable or IN OUT mode
+ -- parameter of the current enclosing subprogram.
-- Why are OUT parameters not considered here ???
function Is_Object_Reference (N : Node_Id) return Boolean;
-- target are considered view conversions and hence variables.
function Is_Partially_Initialized_Type (Typ : Entity_Id) return Boolean;
- -- Typ is a type entity. This function returns true if this type is
- -- partly initialized, meaning that an object of the type is at least
- -- partly initialized (in particular in the record case, that at least
- -- one component has an initialization expression). Note that
- -- initialization resulting from the use of pragma Normalized_Scalars does
- -- not count.
+ -- Typ is a type entity. This function returns true if this type is partly
+ -- initialized, meaning that an object of the type is at least partly
+ -- initialized (in particular in the record case, that at least one
+ -- component has an initialization expression). Note that initialization
+ -- resulting from the use of pragma Normalized_Scalars does not count.
function Is_Potentially_Persistent_Type (T : Entity_Id) return Boolean;
-- Determines if type T is a potentially persistent type. A potentially
function Is_Value_Type (T : Entity_Id) return Boolean;
-- Returns true if type T represents a value type. This is only relevant to
- -- CIL, will always return false for other targets.
- -- What is a "value type", since this is not an Ada term, it should be
- -- defined here ???
+ -- CIL, will always return false for other targets. A value type is a CIL
+ -- object that is accessed directly, as opposed to the other CIL objects
+ -- that are accessed through managed pointers.
+
+ function Is_Delegate (T : Entity_Id) return Boolean;
+ -- Returns true if type T represents a delegate. A Delegate is the CIL
+ -- object used to represent access-to-subprogram types. This is only
+ -- relevant to CIL, will always return false for other targets.
function Is_Variable (N : Node_Id) return Boolean;
- -- Determines if the tree referenced by N represents a variable, i.e.
- -- can appear on the left side of an assignment. There is one situation,
- -- namely formal parameters, in which non-tagged type conversions are
- -- also considered variables, but Is_Variable returns False for such
- -- cases, since it has no knowledge of the context. Note that this is
- -- the point at which Assignment_OK is checked, and True is returned
- -- for any tree thus marked.
+ -- Determines if the tree referenced by N represents a variable, i.e. can
+ -- appear on the left side of an assignment. There is one situation (formal
+ -- parameters) in which non-tagged type conversions are also considered
+ -- variables, but Is_Variable returns False for such cases, since it has
+ -- no knowledge of the context. Note that this is the point at which
+ -- Assignment_OK is checked, and True is returned for any tree thus marked.
+
+ function Is_Visibly_Controlled (T : Entity_Id) return Boolean;
+ -- Check whether T is derived from a visibly controlled type. This is true
+ -- if the root type is declared in Ada.Finalization. If T is derived
+ -- instead from a private type whose full view is controlled, an explicit
+ -- Initialize/Adjust/Finalize subprogram does not override the inherited
+ -- one.
function Is_Volatile_Object (N : Node_Id) return Boolean;
- -- Determines if the given node denotes an volatile object in the sense
- -- of the legality checks described in RM C.6(12). Note that the test
- -- here is for something actually declared as volatile, not for an object
- -- that gets treated as volatile (see Einfo.Treat_As_Volatile).
+ -- Determines if the given node denotes an volatile object in the sense of
+ -- the legality checks described in RM C.6(12). Note that the test here is
+ -- for something actually declared as volatile, not for an object that gets
+ -- treated as volatile (see Einfo.Treat_As_Volatile).
procedure Kill_Current_Values (Last_Assignment_Only : Boolean := False);
-- This procedure is called to clear all constant indications from all
-- clear the Is_True_Constant flag, since that only gets reset if there
-- really is an assignment somewhere in the entity scope). This procedure
-- also calls Kill_All_Checks, since this is a special case of needing to
- -- forget saved values. This procedure also clears Is_Known_Non_Null flags
- -- in variables, constants or parameters since these are also not known to
- -- be valid.
+ -- forget saved values. This procedure also clears the Is_Known_Null and
+ -- Is_Known_Non_Null and Is_Known_Valid flags in variables, constants or
+ -- parameters since these are also not known to be trustable any more.
--
-- The Last_Assignment_Only flag is set True to clear only Last_Assignment
-- fields and leave other fields unchanged. This is used when we encounter
Last_Assignment_Only : Boolean := False);
-- This performs the same processing as described above for the form with
-- no argument, but for the specific entity given. The call has no effect
- -- if the entity Ent is not for an object. Again, Last_Assignment_Only is
- -- set if you want to clear only the Last_Assignment field (see above).
+ -- if the entity Ent is not for an object. Last_Assignment_Only has the
+ -- same meaning as for the call with no Ent.
procedure Kill_Size_Check_Code (E : Entity_Id);
-- Called when an address clause or pragma Import is applied to an entity.
-- If the entity is a variable or a constant, and size check code is
- -- present, this size check code is killed, since the object will not
- -- be allocated by the program.
+ -- present, this size check code is killed, since the object will not be
+ -- allocated by the program.
function Known_To_Be_Assigned (N : Node_Id) return Boolean;
-- The node N is an entity reference. This function determines whether the
-- formal. Used in Ada 2005 mode to solve the syntactic ambiguity that
-- results from an indexing of a function call written in prefix form.
+ function New_Copy_List_Tree (List : List_Id) return List_Id;
+ -- Copy recursively an analyzed list of nodes. Uses New_Copy_Tree defined
+ -- below. As for New_Copy_Tree, it is illegal to attempt to copy extended
+ -- nodes (entities) either directly or indirectly using this function.
+
+ function New_Copy_Tree
+ (Source : Node_Id;
+ Map : Elist_Id := No_Elist;
+ New_Sloc : Source_Ptr := No_Location;
+ New_Scope : Entity_Id := Empty) return Node_Id;
+ -- Given a node that is the root of a subtree, Copy_Tree copies the entire
+ -- syntactic subtree, including recursively any descendents whose parent
+ -- field references a copied node (descendents not linked to a copied node
+ -- by the parent field are not copied, instead the copied tree references
+ -- the same descendent as the original in this case, which is appropriate
+ -- for non-syntactic fields such as Etype). The parent pointers in the
+ -- copy are properly set. Copy_Tree (Empty/Error) returns Empty/Error.
+ -- The one exception to the rule of not copying semantic fields is that
+ -- any implicit types attached to the subtree are duplicated, so that
+ -- the copy contains a distinct set of implicit type entities. Thus this
+ -- function is used when it is necessary to duplicate an analyzed tree,
+ -- declared in the same or some other compilation unit. This function is
+ -- declared here rather than in atree because it uses semantic information
+ -- in particular concerning the structure of itypes and the generation of
+ -- public symbols.
+
+ -- The Map argument, if set to a non-empty Elist, specifies a set of
+ -- mappings to be applied to entities in the tree. The map has the form:
+ --
+ -- old entity 1
+ -- new entity to replace references to entity 1
+ -- old entity 2
+ -- new entity to replace references to entity 2
+ -- ...
+ --
+ -- The call destroys the contents of Map in this case
+ --
+ -- The parameter New_Sloc, if set to a value other than No_Location, is
+ -- used as the Sloc value for all nodes in the new copy. If New_Sloc is
+ -- set to its default value No_Location, then the Sloc values of the
+ -- nodes in the copy are simply copied from the corresponding original.
+ --
+ -- The Comes_From_Source indication is unchanged if New_Sloc is set to
+ -- the default No_Location value, but is reset if New_Sloc is given, since
+ -- in this case the result clearly is neither a source node or an exact
+ -- copy of a source node.
+ --
+ -- The parameter New_Scope, if set to a value other than Empty, is the
+ -- value to use as the Scope for any Itypes that are copied. The most
+ -- typical value for this parameter, if given, is Current_Scope.
+
function New_External_Entity
(Kind : Entity_Kind;
Scope_Id : Entity_Id;
-- S is a possibly signed syntactically valid real literal. The result
-- returned is an N_Real_Literal node representing the literal value.
+ function References_Generic_Formal_Type (N : Node_Id) return Boolean;
+ -- Returns True if the expression Expr contains any references to a
+ -- generic type. This can only happen within a generic template.
+
procedure Remove_Homonym (E : Entity_Id);
-- Removes E from the homonym chain