mirror of
git://gcc.gnu.org/git/gcc.git
synced 2025-03-31 01:50:43 +08:00
273 lines
14 KiB
Ada
273 lines
14 KiB
Ada
------------------------------------------------------------------------------
|
|
-- --
|
|
-- GNAT COMPILER COMPONENTS --
|
|
-- --
|
|
-- T B U I L D --
|
|
-- --
|
|
-- S p e c --
|
|
-- --
|
|
-- Copyright (C) 1992-2005, 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, 51 Franklin Street, Fifth Floor, --
|
|
-- Boston, MA 02110-1301, USA. --
|
|
-- --
|
|
-- GNAT was originally developed by the GNAT team at New York University. --
|
|
-- Extensive contributions were provided by Ada Core Technologies Inc. --
|
|
-- --
|
|
------------------------------------------------------------------------------
|
|
|
|
-- This package contains various utility procedures to assist in
|
|
-- building specific types of tree nodes.
|
|
|
|
with Types; use Types;
|
|
|
|
package Tbuild is
|
|
|
|
function Checks_Off (N : Node_Id) return Node_Id;
|
|
pragma Inline (Checks_Off);
|
|
-- Returns an N_Unchecked_Expression node whose expression is the given
|
|
-- argument. The results is a subexpression identical to the argument,
|
|
-- except that it will be analyzed and resolved with checks off.
|
|
|
|
function Convert_To (Typ : Entity_Id; Expr : Node_Id) return Node_Id;
|
|
-- Returns an expression that represents the result of a checked convert
|
|
-- of expression Exp to type T. If the base type of Exp is T, then no
|
|
-- conversion is required, and Exp is returned unchanged. Otherwise an
|
|
-- N_Type_Conversion node is constructed to convert the expression.
|
|
-- If an N_Type_Conversion node is required, Relocate_Node is used on
|
|
-- Exp. This means that it is safe to replace a node by a Convert_To
|
|
-- of itself to some other type.
|
|
|
|
procedure Discard_Node (N : Node_Or_Entity_Id);
|
|
pragma Inline (Discard_Node);
|
|
-- This is a dummy procedure that simply returns and does nothing.
|
|
-- It is used when a function returning a Node_Id value is called
|
|
-- for its side effect (e.g. a call to Make to construct a node)
|
|
-- but the Node_Id value is not required.
|
|
|
|
procedure Discard_List (L : List_Id);
|
|
pragma Inline (Discard_List);
|
|
-- This is a dummy procedure that simply returns and does nothing.
|
|
-- It is used when a function returning a Node_Id value is called
|
|
-- for its side effect (e.g. a call to the pareser to parse a list
|
|
-- of compilation units), but the List_Id value is not required.
|
|
|
|
function Make_Byte_Aligned_Attribute_Reference
|
|
(Sloc : Source_Ptr;
|
|
Prefix : Node_Id;
|
|
Attribute_Name : Name_Id) return Node_Id;
|
|
pragma Inline (Make_Byte_Aligned_Attribute_Reference);
|
|
-- Like the standard Make_Attribute_Reference but the special flag
|
|
-- Must_Be_Byte_Aligned is set in the attribute reference node. The
|
|
-- Attribute_Name must be Name_Address or Name_Unrestricted_Access.
|
|
|
|
function Make_DT_Access
|
|
(Loc : Source_Ptr; Rec : Node_Id; Typ : Entity_Id) return Node_Id;
|
|
-- Create an access to the Dispatch Table by using the Tag field
|
|
-- of a tagged record : Acc_Dt (Rec.tag).all
|
|
|
|
function Make_Implicit_If_Statement
|
|
(Node : Node_Id;
|
|
Condition : Node_Id;
|
|
Then_Statements : List_Id;
|
|
Elsif_Parts : List_Id := No_List;
|
|
Else_Statements : List_Id := No_List) return Node_Id;
|
|
pragma Inline (Make_Implicit_If_Statement);
|
|
-- This function makes an N_If_Statement node whose fields are filled
|
|
-- in with the indicated values (see Sinfo), and whose Sloc field is
|
|
-- is set to Sloc (Node). The effect is identical to calling function
|
|
-- Nmake.Make_If_Statement except that there is a check for restriction
|
|
-- No_Implicit_Conditionals, and if this restriction is being violated,
|
|
-- an error message is posted on Node.
|
|
|
|
function Make_Implicit_Label_Declaration
|
|
(Loc : Source_Ptr;
|
|
Defining_Identifier : Node_Id;
|
|
Label_Construct : Node_Id) return Node_Id;
|
|
-- Used to contruct an implicit label declaration node, including setting
|
|
-- the proper Label_Construct field (since Label_Construct is a semantic
|
|
-- field, the normal call to Make_Implicit_Label_Declaration does not
|
|
-- set this field).
|
|
|
|
function Make_Implicit_Loop_Statement
|
|
(Node : Node_Id;
|
|
Statements : List_Id;
|
|
Identifier : Node_Id := Empty;
|
|
Iteration_Scheme : Node_Id := Empty;
|
|
Has_Created_Identifier : Boolean := False;
|
|
End_Label : Node_Id := Empty) return Node_Id;
|
|
-- This function makes an N_Loop_Statement node whose fields are filled
|
|
-- in with the indicated values (see Sinfo), and whose Sloc field is
|
|
-- is set to Sloc (Node). The effect is identical to calling function
|
|
-- Nmake.Make_Loop_Statement except that there is a check for restrictions
|
|
-- No_Implicit_Loops and No_Implicit_Conditionals (the first applying in
|
|
-- all cases, and the second only for while loops), and if one of these
|
|
-- restrictions is being violated, an error message is posted on Node.
|
|
|
|
function Make_Integer_Literal
|
|
(Loc : Source_Ptr;
|
|
Intval : Int) return Node_Id;
|
|
pragma Inline (Make_Integer_Literal);
|
|
-- A convenient form of Make_Integer_Literal taking Int instead of Uint
|
|
|
|
function Make_Linker_Section_Pragma
|
|
(Ent : Entity_Id;
|
|
Loc : Source_Ptr;
|
|
Sec : String) return Node_Id;
|
|
-- Construct a Linker_Section pragma for entity Ent, using string Sec as
|
|
-- the section name. Loc is the Sloc value to use in building the pragma.
|
|
|
|
function Make_Raise_Constraint_Error
|
|
(Sloc : Source_Ptr;
|
|
Condition : Node_Id := Empty;
|
|
Reason : RT_Exception_Code) return Node_Id;
|
|
pragma Inline (Make_Raise_Constraint_Error);
|
|
-- A convenient form of Make_Raise_Constraint_Error where the Reason
|
|
-- is given simply as an enumeration value, rather than a Uint code.
|
|
|
|
function Make_Raise_Program_Error
|
|
(Sloc : Source_Ptr;
|
|
Condition : Node_Id := Empty;
|
|
Reason : RT_Exception_Code) return Node_Id;
|
|
pragma Inline (Make_Raise_Program_Error);
|
|
-- A convenient form of Make_Raise_Program_Error where the Reason
|
|
-- is given simply as an enumeration value, rather than a Uint code.
|
|
|
|
function Make_Raise_Storage_Error
|
|
(Sloc : Source_Ptr;
|
|
Condition : Node_Id := Empty;
|
|
Reason : RT_Exception_Code) return Node_Id;
|
|
pragma Inline (Make_Raise_Storage_Error);
|
|
-- A convenient form of Make_Raise_Storage_Error where the Reason
|
|
-- is given simply as an enumeration value, rather than a Uint code.
|
|
|
|
function Make_String_Literal
|
|
(Sloc : Source_Ptr;
|
|
Strval : String) return Node_Id;
|
|
-- A convenient form of Make_String_Literal, where the string value
|
|
-- is given as a normal string instead of a String_Id value.
|
|
|
|
function Make_Unsuppress_Block
|
|
(Loc : Source_Ptr;
|
|
Check : Name_Id;
|
|
Stmts : List_Id) return Node_Id;
|
|
-- Build a block with a pragma Suppress on 'Check'. Stmts is the
|
|
-- statements list that needs protection against the check
|
|
|
|
function New_Constraint_Error (Loc : Source_Ptr) return Node_Id;
|
|
-- This function builds a tree corresponding to the Ada statement
|
|
-- "raise Constraint_Error" and returns the root of this tree,
|
|
-- the N_Raise_Statement node.
|
|
|
|
function New_External_Name
|
|
(Related_Id : Name_Id;
|
|
Suffix : Character := ' ';
|
|
Suffix_Index : Int := 0;
|
|
Prefix : Character := ' ') return Name_Id;
|
|
function New_External_Name
|
|
(Related_Id : Name_Id;
|
|
Suffix : String;
|
|
Suffix_Index : Int := 0;
|
|
Prefix : Character := ' ') return Name_Id;
|
|
-- Builds a new entry in the names table of the form:
|
|
--
|
|
-- [Prefix &] Related_Id [& Suffix] [& Suffix_Index]
|
|
--
|
|
-- Prefix is prepended only if Prefix is non-blank (in which case it
|
|
-- must be an upper case letter other than O,Q,U,W (which are used for
|
|
-- identifier encoding, see Namet), and T is reserved for use by implicit
|
|
-- types. and X is reserved for use by debug type encoding (see package
|
|
-- Exp_Dbug). Note: the reason that Prefix is last is that it is almost
|
|
-- always omitted. The notable case of Prefix being non-null is when
|
|
-- it is 'T' for an implicit type.
|
|
|
|
-- Suffix_Index'Image is appended only if the value of Suffix_Index is
|
|
-- positive, or if Suffix_Index is negative 1, then a unique serialized
|
|
-- suffix is added. If Suffix_Index is zero, then no index is appended.
|
|
|
|
-- Suffix is also a single upper case letter other than O,Q,U,W,X and is a
|
|
-- required parameter (T is permitted). The constructed name is stored
|
|
-- using Find_Name so that it can be located using a subsequent Find_Name
|
|
-- operation (i.e. it is properly hashed into the names table). The upper
|
|
-- case letter given as the Suffix argument ensures that the name does
|
|
-- not clash with any Ada identifier name. These generated names are
|
|
-- permitted, but not required, to be made public by setting the flag
|
|
-- Is_Public in the associated entity.
|
|
|
|
function New_External_Name
|
|
(Suffix : Character;
|
|
Suffix_Index : Nat) return Name_Id;
|
|
-- Builds a new entry in the names table of the form
|
|
-- Suffix & Suffix_Index'Image
|
|
-- where Suffix is a single upper case letter other than O,Q,U,W,X and is
|
|
-- a required parameter (T is permitted). The constructed name is stored
|
|
-- using Find_Name so that it can be located using a subsequent Find_Name
|
|
-- operation (i.e. it is properly hashed into the names table). The upper
|
|
-- case letter given as the Suffix argument ensures that the name does
|
|
-- not clash with any Ada identifier name. These generated names are
|
|
-- permitted, but not required, to be made public by setting the flag
|
|
-- Is_Public in the associated entity.
|
|
|
|
function New_Internal_Name (Id_Char : Character) return Name_Id;
|
|
-- Id_Char is an upper case letter other than O,Q,U,W (which are reserved
|
|
-- for identifier encoding (see Namet package for details) and X which is
|
|
-- used for debug encoding (see Exp_Dbug). The letter T is permitted, but
|
|
-- is reserved by convention for the case of internally generated types.
|
|
-- The result of the call is a new generated unique name of the form XyyyU
|
|
-- where X is Id_Char, yyy is a unique serial number, and U is either a
|
|
-- lower case s or b indicating if the current unit is a spec or a body.
|
|
--
|
|
-- The name is entered into the names table using Name_Enter rather than
|
|
-- Name_Find, because there can never be a need to locate the entry using
|
|
-- the Name_Find procedure later on. Names created by New_Internal_Name
|
|
-- are guaranteed to be consistent from one compilation to another (i.e.
|
|
-- if the identical unit is compiled with a semantically consistent set
|
|
-- of sources, the numbers will be consistent. This means that it is fine
|
|
-- to use these as public symbols.
|
|
|
|
function New_Occurrence_Of
|
|
(Def_Id : Entity_Id;
|
|
Loc : Source_Ptr) return Node_Id;
|
|
-- New_Occurrence_Of creates an N_Identifier node which is an
|
|
-- occurrence of the defining identifier which is passed as its
|
|
-- argument. The Entity and Etype of the result are set from
|
|
-- the given defining identifier as follows: Entity is simply
|
|
-- a copy of Def_Id. Etype is a copy of Def_Id for types, and
|
|
-- a copy of the Etype of Def_Id for other entities.
|
|
|
|
function New_Reference_To
|
|
(Def_Id : Entity_Id;
|
|
Loc : Source_Ptr) return Node_Id;
|
|
-- This is like New_Occurrence_Of, but it does not set the Etype field.
|
|
-- It is used from the expander, where Etype fields are generally not set,
|
|
-- since they are set when the expanded tree is reanalyzed.
|
|
|
|
function New_Suffixed_Name
|
|
(Related_Id : Name_Id;
|
|
Suffix : String) return Name_Id;
|
|
-- This function is used to create special suffixed names used by the
|
|
-- debugger. Suffix is a string of upper case letters, used to construct
|
|
-- the required name. For instance, the special type used to record the
|
|
-- fixed-point small is called typ_SMALL where typ is the name of the
|
|
-- fixed-point type (as passed in Related_Id), and Suffix is "SMALL".
|
|
|
|
function OK_Convert_To (Typ : Entity_Id; Expr : Node_Id) return Node_Id;
|
|
-- Like Convert_To, except that a conversion node is always generated,
|
|
-- and the Conversion_OK flag is set on this conversion node.
|
|
|
|
function Unchecked_Convert_To
|
|
(Typ : Entity_Id;
|
|
Expr : Node_Id) return Node_Id;
|
|
-- Like Convert_To, but if a conversion is actually needed, constructs
|
|
-- an N_Unchecked_Type_Conversion node to do the required conversion.
|
|
|
|
end Tbuild;
|