diff options
Diffstat (limited to 'gcc-4.8/gcc/ada/aspects.ads')
| -rw-r--r-- | gcc-4.8/gcc/ada/aspects.ads | 548 |
1 files changed, 0 insertions, 548 deletions
diff --git a/gcc-4.8/gcc/ada/aspects.ads b/gcc-4.8/gcc/ada/aspects.ads deleted file mode 100644 index c3199cc0d..000000000 --- a/gcc-4.8/gcc/ada/aspects.ads +++ /dev/null @@ -1,548 +0,0 @@ ------------------------------------------------------------------------------- --- -- --- GNAT COMPILER COMPONENTS -- --- -- --- A S P E C T S -- --- -- --- S p e c -- --- -- --- Copyright (C) 2010-2012, 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 3, 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. -- --- -- --- As a special exception under Section 7 of GPL version 3, you are granted -- --- additional permissions described in the GCC Runtime Library Exception, -- --- version 3.1, as published by the Free Software Foundation. -- --- -- --- You should have received a copy of the GNU General Public License and -- --- a copy of the GCC Runtime Library Exception along with this program; -- --- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- --- <http://www.gnu.org/licenses/>. -- --- -- --- GNAT was originally developed by the GNAT team at New York University. -- --- Extensive contributions were provided by Ada Core Technologies Inc. -- --- -- ------------------------------------------------------------------------------- - --- This package defines the aspects that are recognized by GNAT in aspect --- specifications. It also contains the subprograms for storing/retrieving --- aspect specifications from the tree. The semantic processing for aspect --- specifications is found in Sem_Ch13.Analyze_Aspect_Specifications. - ------------------------- --- Adding New Aspects -- ------------------------- - --- In general, each aspect should have a corresponding pragma, so that the --- newly developed functionality is available for Ada versions < Ada 2012. --- When both are defined, it is convenient to first transform the aspect into --- an equivalent pragma in Sem_Ch13.Analyze_Aspect_Specifications, and then --- analyze the pragma in Sem_Prag.Analyze_Pragma. - --- To add a new aspect, you need to do the following - --- 1. Create a name in snames.ads-tmpl - --- 2. Create a value in type Aspect_Id in this unit - --- 3. Add a value for the aspect in the global arrays defined in this unit - --- 4. Add code for the aspect in Sem_Ch13.Analyze_Aspect_Specifications. --- This may involve adding some nodes to the tree to perform additional --- treatments later. - --- 5. If the semantic analysis of expressions/names in the aspect should not --- occur at the point the aspect is defined, add code in the adequate --- semantic analysis procedure for the aspect. For example, this is the --- case for aspects Pre and Post on subprograms, which are pre-analyzed --- at the end of the declaration list to which the subprogram belongs, --- and fully analyzed (possibly with expansion) during the semantic --- analysis of subprogram bodies. - -with Namet; use Namet; -with Snames; use Snames; -with Types; use Types; - -package Aspects is - - -- Type defining recognized aspects - - type Aspect_Id is - (No_Aspect, -- Dummy entry for no aspect - Aspect_Abstract_State, -- GNAT - Aspect_Address, - Aspect_Alignment, - Aspect_Attach_Handler, - Aspect_Bit_Order, - Aspect_Component_Size, - Aspect_Constant_Indexing, - Aspect_Contract_Case, -- GNAT - Aspect_Contract_Cases, -- GNAT - Aspect_Convention, - Aspect_CPU, - Aspect_Default_Component_Value, - Aspect_Default_Iterator, - Aspect_Default_Value, - Aspect_Dimension, -- GNAT - Aspect_Dimension_System, -- GNAT - Aspect_Dispatching_Domain, - Aspect_Dynamic_Predicate, - Aspect_External_Name, - Aspect_External_Tag, - Aspect_Global, -- GNAT - Aspect_Implicit_Dereference, - Aspect_Input, - Aspect_Interrupt_Priority, - Aspect_Invariant, -- GNAT - Aspect_Iterator_Element, - Aspect_Link_Name, - Aspect_Machine_Radix, - Aspect_Object_Size, -- GNAT - Aspect_Output, - Aspect_Post, - Aspect_Postcondition, - Aspect_Pre, - Aspect_Precondition, - Aspect_Predicate, -- GNAT - Aspect_Priority, - Aspect_Read, - Aspect_Relative_Deadline, - Aspect_Scalar_Storage_Order, -- GNAT - Aspect_Simple_Storage_Pool, -- GNAT - Aspect_Size, - Aspect_Small, - Aspect_Static_Predicate, - Aspect_Storage_Pool, - Aspect_Storage_Size, - Aspect_Stream_Size, - Aspect_Suppress, - Aspect_Synchronization, - Aspect_Test_Case, -- GNAT - Aspect_Type_Invariant, - Aspect_Unsuppress, - Aspect_Value_Size, -- GNAT - Aspect_Variable_Indexing, - Aspect_Warnings, -- GNAT - Aspect_Write, - - -- The following aspects correspond to library unit pragmas - - Aspect_All_Calls_Remote, - Aspect_Compiler_Unit, -- GNAT - Aspect_Elaborate_Body, - Aspect_Preelaborate, - Aspect_Preelaborate_05, -- GNAT - Aspect_Pure, - Aspect_Pure_05, -- GNAT - Aspect_Pure_12, -- GNAT - Aspect_Remote_Call_Interface, - Aspect_Remote_Types, - Aspect_Shared_Passive, - Aspect_Universal_Data, -- GNAT - - -- Remaining aspects have a static boolean value that turns the aspect - -- on or off. They all correspond to pragmas, but are only converted to - -- the pragmas where the value is True. A value of False normally means - -- that the aspect is ignored, except in the case of derived types where - -- the aspect value is inherited from the parent, in which case, we do - -- not allow False if we inherit a True value from the parent. - - Aspect_Ada_2005, -- GNAT - Aspect_Ada_2012, -- GNAT - Aspect_Asynchronous, - Aspect_Atomic, - Aspect_Atomic_Components, - Aspect_Discard_Names, - Aspect_Export, - Aspect_Favor_Top_Level, -- GNAT - Aspect_Independent, - Aspect_Independent_Components, - Aspect_Import, - Aspect_Inline, - Aspect_Inline_Always, -- GNAT - Aspect_Interrupt_Handler, - Aspect_No_Return, - Aspect_Pack, - Aspect_Persistent_BSS, -- GNAT - Aspect_Preelaborable_Initialization, - Aspect_Pure_Function, -- GNAT - Aspect_Remote_Access_Type, -- GNAT - Aspect_Shared, -- GNAT (equivalent to Atomic) - Aspect_Simple_Storage_Pool_Type, -- GNAT - Aspect_Suppress_Debug_Info, -- GNAT - Aspect_Unchecked_Union, - Aspect_Universal_Aliasing, -- GNAT - Aspect_Unmodified, -- GNAT - Aspect_Unreferenced, -- GNAT - Aspect_Unreferenced_Objects, -- GNAT - Aspect_Volatile, - Aspect_Volatile_Components, - - -- Aspects that have a static boolean value but don't correspond to - -- pragmas - - Aspect_Lock_Free); - - subtype Aspect_Id_Exclude_No_Aspect is - Aspect_Id range Aspect_Id'Succ (No_Aspect) .. Aspect_Id'Last; - -- Aspect_Id's excluding No_Aspect - - -- The following array indicates aspects that accept 'Class - - Class_Aspect_OK : constant array (Aspect_Id) of Boolean := - (Aspect_Invariant => True, - Aspect_Pre => True, - Aspect_Predicate => True, - Aspect_Post => True, - Aspect_Type_Invariant => True, - others => False); - - -- The following array indicates aspects that a subtype inherits from - -- its base type. True means that the subtype inherits the aspect from - -- its base type. False means it is not inherited. - - Base_Aspect : constant array (Aspect_Id) of Boolean := - (Aspect_Atomic => True, - Aspect_Atomic_Components => True, - Aspect_Discard_Names => True, - Aspect_Independent_Components => True, - Aspect_Iterator_Element => True, - Aspect_Constant_Indexing => True, - Aspect_Default_Iterator => True, - Aspect_Type_Invariant => True, - Aspect_Unchecked_Union => True, - Aspect_Variable_Indexing => True, - Aspect_Volatile => True, - others => False); - - -- The following array identifies all implementation defined aspects - - Impl_Defined_Aspects : constant array (Aspect_Id) of Boolean := - (Aspect_Abstract_State => True, - Aspect_Ada_2005 => True, - Aspect_Ada_2012 => True, - Aspect_Compiler_Unit => True, - Aspect_Contract_Case => True, - Aspect_Contract_Cases => True, - Aspect_Dimension => True, - Aspect_Dimension_System => True, - Aspect_Favor_Top_Level => True, - Aspect_Global => True, - Aspect_Inline_Always => True, - Aspect_Invariant => True, - Aspect_Lock_Free => True, - Aspect_Object_Size => True, - Aspect_Persistent_BSS => True, - Aspect_Predicate => True, - Aspect_Preelaborate_05 => True, - Aspect_Pure_05 => True, - Aspect_Pure_12 => True, - Aspect_Pure_Function => True, - Aspect_Remote_Access_Type => True, - Aspect_Scalar_Storage_Order => True, - Aspect_Shared => True, - Aspect_Simple_Storage_Pool => True, - Aspect_Simple_Storage_Pool_Type => True, - Aspect_Suppress_Debug_Info => True, - Aspect_Test_Case => True, - Aspect_Universal_Aliasing => True, - Aspect_Universal_Data => True, - Aspect_Unmodified => True, - Aspect_Unreferenced => True, - Aspect_Unreferenced_Objects => True, - Aspect_Value_Size => True, - Aspect_Warnings => True, - others => False); - - -- The following array indicates aspects for which multiple occurrences of - -- the same aspect attached to the same declaration are allowed. - - No_Duplicates_Allowed : constant array (Aspect_Id) of Boolean := - (Aspect_Contract_Case => False, - Aspect_Test_Case => False, - others => True); - - -- The following array indicates type aspects that are inherited and apply - -- to the class-wide type as well. - - Inherited_Aspect : constant array (Aspect_Id) of Boolean := - (Aspect_Constant_Indexing => True, - Aspect_Default_Iterator => True, - Aspect_Implicit_Dereference => True, - Aspect_Iterator_Element => True, - Aspect_Remote_Types => True, - Aspect_Variable_Indexing => True, - others => False); - - -- The following subtype defines aspects corresponding to library unit - -- pragmas, these can only validly appear as aspects for library units, - -- and result in a corresponding pragma being inserted immediately after - -- the occurrence of the aspect. - - subtype Library_Unit_Aspects is - Aspect_Id range Aspect_All_Calls_Remote .. Aspect_Universal_Data; - - -- The following subtype defines aspects accepting an optional static - -- boolean parameter indicating if the aspect should be active or - -- cancelling. If the parameter is missing the effective value is True, - -- enabling the aspect. If the parameter is present it must be a static - -- expression of type Standard.Boolean. If the value is True, then the - -- aspect is enabled. If it is False, the aspect is disabled. - - subtype Boolean_Aspects is - Aspect_Id range Aspect_Ada_2005 .. Aspect_Id'Last; - - subtype Pre_Post_Aspects is - Aspect_Id range Aspect_Post .. Aspect_Precondition; - - -- The following type is used for indicating allowed expression forms - - type Aspect_Expression is - (Optional, -- Optional boolean expression - Expression, -- Required expression - Name); -- Required name - - -- The following array indicates what argument type is required - - Aspect_Argument : constant array (Aspect_Id) of Aspect_Expression := - (No_Aspect => Optional, - Aspect_Abstract_State => Expression, - Aspect_Address => Expression, - Aspect_Alignment => Expression, - Aspect_Attach_Handler => Expression, - Aspect_Bit_Order => Expression, - Aspect_Component_Size => Expression, - Aspect_Constant_Indexing => Name, - Aspect_Contract_Case => Expression, - Aspect_Contract_Cases => Expression, - Aspect_Convention => Name, - Aspect_CPU => Expression, - Aspect_Default_Component_Value => Expression, - Aspect_Default_Iterator => Name, - Aspect_Default_Value => Expression, - Aspect_Dimension => Expression, - Aspect_Dimension_System => Expression, - Aspect_Dispatching_Domain => Expression, - Aspect_Dynamic_Predicate => Expression, - Aspect_External_Name => Expression, - Aspect_External_Tag => Expression, - Aspect_Global => Expression, - Aspect_Implicit_Dereference => Name, - Aspect_Input => Name, - Aspect_Interrupt_Priority => Expression, - Aspect_Invariant => Expression, - Aspect_Iterator_Element => Name, - Aspect_Link_Name => Expression, - Aspect_Machine_Radix => Expression, - Aspect_Object_Size => Expression, - Aspect_Output => Name, - Aspect_Post => Expression, - Aspect_Postcondition => Expression, - Aspect_Pre => Expression, - Aspect_Precondition => Expression, - Aspect_Predicate => Expression, - Aspect_Priority => Expression, - Aspect_Read => Name, - Aspect_Relative_Deadline => Expression, - Aspect_Scalar_Storage_Order => Expression, - Aspect_Simple_Storage_Pool => Name, - Aspect_Size => Expression, - Aspect_Small => Expression, - Aspect_Static_Predicate => Expression, - Aspect_Storage_Pool => Name, - Aspect_Storage_Size => Expression, - Aspect_Stream_Size => Expression, - Aspect_Suppress => Name, - Aspect_Synchronization => Name, - Aspect_Test_Case => Expression, - Aspect_Type_Invariant => Expression, - Aspect_Unsuppress => Name, - Aspect_Value_Size => Expression, - Aspect_Variable_Indexing => Name, - Aspect_Warnings => Name, - Aspect_Write => Name, - - Library_Unit_Aspects => Optional, - Boolean_Aspects => Optional); - - ----------------------------------------- - -- Table Linking Names and Aspect_Id's -- - ----------------------------------------- - - -- Table linking aspect names and id's - - Aspect_Names : constant array (Aspect_Id) of Name_Id := ( - No_Aspect => No_Name, - Aspect_Abstract_State => Name_Abstract_State, - Aspect_Ada_2005 => Name_Ada_2005, - Aspect_Ada_2012 => Name_Ada_2012, - Aspect_Address => Name_Address, - Aspect_Alignment => Name_Alignment, - Aspect_All_Calls_Remote => Name_All_Calls_Remote, - Aspect_Asynchronous => Name_Asynchronous, - Aspect_Atomic => Name_Atomic, - Aspect_Atomic_Components => Name_Atomic_Components, - Aspect_Attach_Handler => Name_Attach_Handler, - Aspect_Bit_Order => Name_Bit_Order, - Aspect_Compiler_Unit => Name_Compiler_Unit, - Aspect_Component_Size => Name_Component_Size, - Aspect_Constant_Indexing => Name_Constant_Indexing, - Aspect_Contract_Case => Name_Contract_Case, - Aspect_Contract_Cases => Name_Contract_Cases, - Aspect_Convention => Name_Convention, - Aspect_CPU => Name_CPU, - Aspect_Default_Iterator => Name_Default_Iterator, - Aspect_Default_Value => Name_Default_Value, - Aspect_Default_Component_Value => Name_Default_Component_Value, - Aspect_Dimension => Name_Dimension, - Aspect_Dimension_System => Name_Dimension_System, - Aspect_Discard_Names => Name_Discard_Names, - Aspect_Dispatching_Domain => Name_Dispatching_Domain, - Aspect_Dynamic_Predicate => Name_Dynamic_Predicate, - Aspect_Elaborate_Body => Name_Elaborate_Body, - Aspect_External_Name => Name_External_Name, - Aspect_External_Tag => Name_External_Tag, - Aspect_Export => Name_Export, - Aspect_Favor_Top_Level => Name_Favor_Top_Level, - Aspect_Global => Name_Global, - Aspect_Implicit_Dereference => Name_Implicit_Dereference, - Aspect_Import => Name_Import, - Aspect_Independent => Name_Independent, - Aspect_Independent_Components => Name_Independent_Components, - Aspect_Inline => Name_Inline, - Aspect_Inline_Always => Name_Inline_Always, - Aspect_Input => Name_Input, - Aspect_Interrupt_Handler => Name_Interrupt_Handler, - Aspect_Interrupt_Priority => Name_Interrupt_Priority, - Aspect_Invariant => Name_Invariant, - Aspect_Iterator_Element => Name_Iterator_Element, - Aspect_Link_Name => Name_Link_Name, - Aspect_Lock_Free => Name_Lock_Free, - Aspect_Machine_Radix => Name_Machine_Radix, - Aspect_No_Return => Name_No_Return, - Aspect_Object_Size => Name_Object_Size, - Aspect_Output => Name_Output, - Aspect_Pack => Name_Pack, - Aspect_Persistent_BSS => Name_Persistent_BSS, - Aspect_Post => Name_Post, - Aspect_Postcondition => Name_Postcondition, - Aspect_Pre => Name_Pre, - Aspect_Precondition => Name_Precondition, - Aspect_Predicate => Name_Predicate, - Aspect_Preelaborable_Initialization => Name_Preelaborable_Initialization, - Aspect_Preelaborate => Name_Preelaborate, - Aspect_Preelaborate_05 => Name_Preelaborate_05, - Aspect_Priority => Name_Priority, - Aspect_Pure => Name_Pure, - Aspect_Pure_05 => Name_Pure_05, - Aspect_Pure_12 => Name_Pure_12, - Aspect_Pure_Function => Name_Pure_Function, - Aspect_Read => Name_Read, - Aspect_Relative_Deadline => Name_Relative_Deadline, - Aspect_Remote_Access_Type => Name_Remote_Access_Type, - Aspect_Remote_Call_Interface => Name_Remote_Call_Interface, - Aspect_Remote_Types => Name_Remote_Types, - Aspect_Scalar_Storage_Order => Name_Scalar_Storage_Order, - Aspect_Shared => Name_Shared, - Aspect_Shared_Passive => Name_Shared_Passive, - Aspect_Simple_Storage_Pool => Name_Simple_Storage_Pool, - Aspect_Simple_Storage_Pool_Type => Name_Simple_Storage_Pool_Type, - Aspect_Size => Name_Size, - Aspect_Small => Name_Small, - Aspect_Static_Predicate => Name_Static_Predicate, - Aspect_Storage_Pool => Name_Storage_Pool, - Aspect_Storage_Size => Name_Storage_Size, - Aspect_Stream_Size => Name_Stream_Size, - Aspect_Suppress => Name_Suppress, - Aspect_Suppress_Debug_Info => Name_Suppress_Debug_Info, - Aspect_Synchronization => Name_Synchronization, - Aspect_Test_Case => Name_Test_Case, - Aspect_Type_Invariant => Name_Type_Invariant, - Aspect_Unchecked_Union => Name_Unchecked_Union, - Aspect_Universal_Aliasing => Name_Universal_Aliasing, - Aspect_Universal_Data => Name_Universal_Data, - Aspect_Unmodified => Name_Unmodified, - Aspect_Unreferenced => Name_Unreferenced, - Aspect_Unreferenced_Objects => Name_Unreferenced_Objects, - Aspect_Unsuppress => Name_Unsuppress, - Aspect_Value_Size => Name_Value_Size, - Aspect_Variable_Indexing => Name_Variable_Indexing, - Aspect_Volatile => Name_Volatile, - Aspect_Volatile_Components => Name_Volatile_Components, - Aspect_Warnings => Name_Warnings, - Aspect_Write => Name_Write); - - function Get_Aspect_Id (Name : Name_Id) return Aspect_Id; - pragma Inline (Get_Aspect_Id); - -- Given a name Nam, returns the corresponding aspect id value. If the name - -- does not match any aspect, then No_Aspect is returned as the result. - - --------------------------------------------------- - -- Handling of Aspect Specifications in the Tree -- - --------------------------------------------------- - - -- Several kinds of declaration node permit aspect specifications in Ada - -- 2012 mode. If there was room in all the corresponding declaration nodes, - -- we could just have a field Aspect_Specifications pointing to a list of - -- nodes for the aspects (N_Aspect_Specification nodes). But there isn't - -- room, so we adopt a different approach. - - -- The following subprograms provide access to a specialized interface - -- implemented internally with a hash table in the body, that provides - -- access to aspect specifications. - - function Permits_Aspect_Specifications (N : Node_Id) return Boolean; - -- Returns True if the node N is a declaration node that permits aspect - -- specifications in the grammar. It is possible for other nodes to have - -- aspect specifications as a result of Rewrite or Replace calls. - - function Aspect_Specifications (N : Node_Id) return List_Id; - -- Given a node N, returns the list of N_Aspect_Specification nodes that - -- are attached to this declaration node. If the node is in the class of - -- declaration nodes that permit aspect specifications, as defined by the - -- predicate above, and if their Has_Aspects flag is set to True, then this - -- will always be a non-empty list. If this flag is set to False, then - -- No_List is returned. Normally, the only nodes that have Has_Aspects set - -- True are the nodes for which Permits_Aspect_Specifications would return - -- True (i.e. the declaration nodes defined in the RM as permitting the - -- presence of Aspect_Specifications). However, it is possible for the - -- flag Has_Aspects to be set on other nodes as a result of Rewrite and - -- Replace calls, and this function may be used to retrieve the aspect - -- specifications for the original rewritten node in such cases. - - procedure Set_Aspect_Specifications (N : Node_Id; L : List_Id); - -- The node N must be in the class of declaration nodes that permit aspect - -- specifications and the Has_Aspects flag must be False on entry. L must - -- be a non-empty list of N_Aspect_Specification nodes. This procedure sets - -- the Has_Aspects flag to True, and makes an entry that can be retrieved - -- by a subsequent Aspect_Specifications call. It is an error to call this - -- procedure with a node that does not permit aspect specifications, or a - -- node that has its Has_Aspects flag set True on entry, or with L being an - -- empty list or No_List. - - function Find_Aspect (Ent : Entity_Id; A : Aspect_Id) return Node_Id; - -- Find value of a given aspect from aspect list of entity - - procedure Move_Aspects (From : Node_Id; To : Node_Id); - -- Moves aspects from 'From' node to 'To' node. Has_Aspects (To) must be - -- False on entry. If Has_Aspects (From) is False, the call has no effect. - -- Otherwise the aspects are moved and on return Has_Aspects (To) is True, - -- and Has_Aspects (From) is False. - - function Same_Aspect (A1 : Aspect_Id; A2 : Aspect_Id) return Boolean; - -- Returns True if A1 and A2 are (essentially) the same aspect. This is not - -- a simple equality test because e.g. Post and Postcondition are the same. - -- This is used for detecting duplicate aspects. - - procedure Tree_Write; - -- Writes contents of Aspect_Specifications hash table to the tree file - - procedure Tree_Read; - -- Reads contents of Aspect_Specifications hash table from the tree file - -end Aspects; |