Geek Gadgets 1

home *** CD-ROM | disk | FTP | other *** search

/ Geek Gadgets 1 / ADE-1.bin / ade-dist / gnat-2.06-src.tgz / tar.out / fsf / gnat / ada / sem_util.ads < prev next >

Wrap

Text File | 1996-09-28 | 17KB | 324 lines

------------------------------------------------------------------------------ -- -- -- GNAT COMPILER COMPONENTS -- -- -- -- S E M _ U T I L -- -- -- -- S p e c -- -- -- -- $Revision: 1.103 $ -- -- -- -- Copyright (c) 1992,1993,1994,1995 NYU, All Rights Reserved -- -- -- -- 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, 675 Mass Ave, Cambridge, MA 02139, USA. -- -- -- ------------------------------------------------------------------------------ -- Package containing utility procedures used throughout the semantics with Einfo; use Einfo; with Types; use Types; with Uintp; use Uintp; with Urealp; use Urealp; package Sem_Util is function Build_Actual_Subtype (T : Entity_Id; N : Node_Or_Entity_Id) return Node_Id; -- Build an anonymous subtype for an entity or expression, using the -- bounds of the entity or the discriminants of the enclosing record. -- T is the type for which the actual subtype is required, and N is either -- a defining identifier, or any subexpression. function Build_Actual_Subtype_Of_Component (T : Entity_Id; N : Node_Id) return Node_Id; -- Determine whether a selected component has a type that depends on -- discriminants, and build actual subtype for it if so. 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 -- conversions, qualified expressions. procedure Compile_Time_Constraint_Error (N : Node_Id; Msg : String); -- N is a subexpression which will raise a constraint error if evaluated -- at runtime. Msg is a message that explains the reason for raising the -- exception. The last character of Msg is ? if the message is always a -- warning, even in Ada 95, and is not a ? if the message represents a -- real illegality (because of violation of static expression rules) in -- Ada 95 (but not in Ada 83). This routine posts appropriate messages, -- and replaces the expression with an N_Raise_Constraint_Error node. -- This node is marked as being static if the original node is static, -- but Raises_Constraint_Error is set, preventing further evaluation. -- The error message may contain a } insertion character, referencing -- the type of the node N. function Current_Entity (N : Node_Id) return Entity_Id; -- Find the currently visible definition for a given identifier, that is to -- say the first entry in the visibility chain for the Chars of N. function Current_Entity_In_Scope (N : Node_Id) return Entity_Id; -- Find whether there is a previous definition for identifier N in the -- current scope. Because declarations for a scope are not necessarily -- contiguous (e.g. for packages) the first entry on the visibility chain -- for N is not necessarily in the current scope. function Current_Scope return Entity_Id; -- Get entity representing current scope function Defining_Unit_Simple_Name (N : Node_Id) return Entity_Id; -- N is the declaration of a program unit (compilation or otherwise). -- If the unit is a child unit, return the final defining identifier; -- Otherwise, the program unit name itself. function Designate_Same_Unit (Name1 : Node_Id; Name2 : Node_Id) return Boolean; -- Return true if Name1 and Name2 designate the same unit name; -- each of these names is supposed to be a selected component name, -- an expanded name, a defining program unit name or an identifier function Enclosing_Dynamic_Scope (E : Entity_Id) return Entity_Id; -- Returns Standard_Standard for entities declared at a library level or -- the entity of the first enclosing scope (block, subprogram, task_type, -- or entry) for local entities. procedure Enter_Name (Def_Id : Node_Id); -- Insert new name in symbol table of current scope with check for -- duplications (error message is issued if a conflict is found) function First_Actual (Node : Node_Id) return Node_Id; -- Node is an N_Function_Call or N_Procedure_Call_Statement node. The -- result returned is the first actual parameter in declaration order -- (not the order of parameters as they appeared in the source, which -- can be quite different as a result of the use of named parameters). -- Empty is returned for a call with no parameters. The procedure for -- iterating through the actuals in declaration order is to use this -- function to find the first actual, and then use Next_Actual to obtain -- the next actual in declaration order. Note that the values returned -- may be either expressions or N_Parameter_Association nodes. function Get_Actual_Subtype (N : Node_Id) return Entity_Id; -- Given a node for an expression, obtain the actual subtype of the -- expression. This is the Etype, except in the case of unconstrained -- array types, where the nominal subtype is the unconstrained type, -- and the actual subtype is the subtype constrained with the actual -- bounds. Get_Actual_Subtype returns an appropriate subtype in this -- case, constructing it on the fly (and inserting it in the tree -- using Insert_Actions (N, ..) if necessary). procedure Get_Index_Bounds (I : Node_Id; L, H : out Node_Id); -- This procedure assigns to L and H respectively the values of the -- low and high bounds of node I, which must be a range, subtype -- indication, or the name of a scalar subtype. function Get_Declaration_Node (Unit_Id : Entity_Id) return Node_Id; -- Unit_Id is the simple name of a unit, this function returns the -- corresponding xxx_Declaration node for the entity, or the subprogram -- body node for it. The unit may be a child unit with any number of -- ancestors. function Get_Name_Entity_Id (Id : Name_Id) return Entity_Id; -- An entity value is associated with each name in the name table. The -- Get_Name_Entity_Id function fetches the Entity_Id of this entity, -- which is the innermost visible entity with the given name. See the -- body of Sem_Ch8 for further details on handling of entity visibility. function Get_Referenced_Object (N : Node_Id) return Node_Id; -- Given a node, return the renamed object if the node represents -- a renamed object, otherwise return the node unchanged. The node -- may represent an arbitrary expression. function Has_Private_Component (Type_Id : Entity_Id) return Boolean; -- Check if a type has a (sub)component of a private type that has not -- yet received a full declaration. function Has_Tagged_Component (Typ : Entity_Id) return Boolean; -- Typ must be a composite type (array or record). This function is used -- to check if '=' has to be expanded into a bunch component comparaisons. function In_Subrange_Of (T1 : Entity_Id; T2 : Entity_Id) return Boolean; -- Checks whether the range of values for type T1 is always in the range -- given for type T2. function Is_Entity_Name (N : Node_Id) return Boolean; -- Test if the node N is the name of an entity (i.e. is an identifier, -- expanded name, or an attribute reference that returns an entity). function Is_False (U : Uint) return Boolean; -- The argument is a Uint value which is the Boolean'Pos value of a -- Boolean operand (i.e. is either 0 for False, or 1 for True). This -- function simply tests if it is False (i.e. zero) 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_Object_Reference (N : Node_Id) return Boolean; -- Determines if the tree referenced by N represents an object. Both -- variable and constant objects return True (compare Is_Variable). function Is_Selector_Name (N : Node_Id) return Boolean; -- Given an N_Identifier node N, determines if it is a Selector_Name. -- As described in Sinfo, Selector_Names are special because they -- represent use of the N_Identifier node for a true identifer, when -- normally such nodes represent a direct name. function Is_True (U : Uint) return Boolean; -- The argument is a Uint value which is the Boolean'Pos value of a -- Boolean operand (i.e. is either 0 for False, or 1 for True). This -- function simply tests if it is True (i.e. non-zero) 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. function New_External_Entity (Kind : Entity_Kind; Scope_Id : Entity_Id; Sloc_Value : Source_Ptr; Related_Id : Entity_Id; Suffix : Character; Suffix_Index : Nat := 0; Prefix : Character := ' ') return Entity_Id; -- This function creates an N_Defining_Identifier node for an internal -- created entity, such as an implicit type or subtype, or a record -- initialization procedure. The entity name is constructed with a call -- to New_External_Name (Related_Id, Suffix, Suffix_Index, Prefix), so -- that the generated name may be referenced as a public entry, and the -- Is_Public flag is set if needed (using Set_Public_Status). function New_Internal_Entity (Kind : Entity_Kind; Scope_Id : Entity_Id; Sloc_Value : Source_Ptr; Id_Char : Character) return Entity_Id; -- This function is similar to New_External_Entity, except that the -- name is constructed by New_Internal_Name (Id_Char). This is used -- when the resulting entity does not have to be referenced as a -- public entity (and in this case Is_Public is not set). function Next_Actual (Actual_Id : Node_Id) return Node_Id; -- Find next actual parameter in declaration order. As described for -- First_Actual, this is the next actual in the declaration order, not -- the call order, so this does not correspond to simply taking the -- next entry of the Parameter_Associations list. The argument is either -- an expression or an N_Parameter_Association node, as returned by a -- previous call to First_Actual or Next_Actual. procedure Normalize_Actuals (N : Node_Id; S : Entity_Id; Report : Boolean; Success : out Boolean); -- Reorders lists of actuals according to names of formals, value returned -- in Success indicates sucess of reordering. For more details, see body. -- Errors are reported only if Report is set to True. function Object_Access_Level (Obj : Node_Id) return Uint; -- Return the accessibility level of the view of the object Obj. function Private_Ancestor (Type_Id : Entity_Id) return Entity_Id; -- Returns the private ancestor (if any) of the given Type_Id. -- A type has a private ancestor if it is a subtype of, or has any -- components that are a subtype of a private type whose full view -- has not yet been processed. function Real_Convert (S : String) return Node_Id; -- S is a possibly signed syntactically valid real literal. The result -- returned is an N_Real_Literal node representing the literal value. function Same_Name (N1, N2 : Node_Id) return Boolean; -- Determine if two (possibly expanded) names are the same name procedure Set_Current_Entity (E : Entity_Id); -- Establish the entity E as the currently visible definition of its -- associated name (i.e. the Node_Id associated with its name) procedure Set_Entity_With_Style_Check (N : Node_Id; Val : Entity_Id); -- This procedure has the same calling sequence as Set_Entity, but -- if Style_Check is set, then it calls a style checking routine which -- can check identifier spelling style. procedure Set_Name_Entity_Id (Id : Name_Id; Val : Entity_Id); -- Sets the Entity_Id value associated with the given name, which is the -- Id of the innermost visible entity with the given name. See the body -- of package Sem_Ch8 for further details on the handling of visibility. procedure Set_Next_Actual (Ass1_Id : Node_Id; Ass2_Id : Node_Id); -- The arguments may be parameter associations, whose descendants -- are the optional formal name and the actual parameter. Positional -- parameters are already members of a list, and do not need to be -- chained separately. See also First_Actual and Next_Actual. procedure Set_Public_Status (Id : Entity_Id); -- If an entity (visible or otherwise) is defined in a library -- package, or a package that is itself public, then this subprogram -- labels the entity public as well. function Static_Integer (N : Node_Id) return Uint; -- This function analyzes the given expression node and then resolves it -- as any integer type. If the result is static, then the value of the -- universal expression is returned, otherwise an error message is output -- and a value of No_Uint is returned. function Statically_Different (E1, E2 : Node_Id) return Boolean; -- Return True if it can be statically determined that the Expressions -- E1 and E2 refer to different objects function Subprogram_Access_Level (Subp : Entity_Id) return Uint; -- Return the accessibility level of the view denoted by Subp. procedure Trace_Scope (N : Node_Id; E : Entity_Id; Msg : String); -- Print debugging information on entry to each unit being analyzed. procedure Transfer_Entities (From : Entity_Id; To : Entity_Id); -- Move a list of entities from one scope to another, and recompute -- Is_Public based upon the new scope. function Type_Access_Level (Typ : Entity_Id) return Uint; -- Return the accessibility level of Typ. procedure Unimplemented (N : Node_Id; Feature : String); -- An indication that here and there we are not finished yet. Prints out -- a message on the given node indicating that the feature described by -- the given string is not implemented yet. procedure Wrong_Type (Expr : Node_Id; Expected_Type : Entity_Id); -- Output error message for incorrectly typed expression. Expr is the -- node for the incorrectly typed construct (Etype (Expr) is the type -- found), and Expected_Type is the entity for the expected type. Note -- that Expr does not have to be a subexpression, anything with an -- Etype field may be used. private pragma Inline (Current_Entity); pragma Inline (Get_Name_Entity_Id); pragma Inline (Is_Entity_Name); pragma Inline (Is_False); pragma Inline (Is_True); pragma Inline (Set_Current_Entity); pragma Inline (Set_Name_Entity_Id); end Sem_Util;