From sblake@alsys.com Wed Jun 21 21:12:55 1995 Return-Path: Date: Wed, 21 Jun 1995 17:41:52 -0700 From: sblake@alsys.com (Steve Blake @pulsar) To: asiswg-technical@sw-eng.falls-church.va.us Subject: ASIS Element, Unit, and Error kinds proposal Content-Length: 57797 X-Lines: 1416 Status: RO Proposed ASIS 9X element kind type hierarchy Draft 6, June, 1995 Steve Blake, Thomson Software Products (formerly Alsys, Inc.) 619-457-2700 x272 sblake@thomsoft.com Purpose This proposal addresses the Element Kinds Hierarchy changes required to evolve ASIS 1.1.1 into ASIS 2.0. Comments are welcome from anyone, hopefully prior to the meeting. Please submit comments via email to: asiswg-technical@sw-eng.falls-church.va.us Scope This proposal covers the changes dealing with kinds for both elements and units (compilation units). Draft 6 addresses issues raised at the ASISWG meeting Mar 6-8, 1995 in Ft. Lauderdale, FL. Organization This proposal is organized into four Sections. Section 1. ASISWG Review Issues Section 2. Changes in Draft 6 Section 3. Specification of package Asis_Element_Kinds. Section 4. Specification of package Asis_Unit_Kinds. Section 5. Specification of package Asis_Errors. Related Documents 1. Proposed ASIS 9X element kind type hierarchy, Draft 4, Nov 30, 1994 2. Proposed ASIS 9X element kind type hierarchy, Draft 5, March, 1994 3. Proposed ASIS 9X Version 2.0.B -- June 1995 This proposal addresses some of the changes required to evolve ASIS 1.1.1 into ASIS 2.0. Section 1. ASISWG Review Issues on Draft 5. 1. Improve the commentary describing the Trait_Kinds. Specifically, define use of the term ordinary, and indicate that all combinations are enumerated. 2. Revisit the definition of Alternative_Kinds. Section 2. Changes in Draft 6 (from Draft 5) - type Traverse_Control was moved to Asis.Elements where it belongs with the Traverse_Element generic. - Ada 83 LRM sections and references were updated to Ada 95 RM equivalents. - Trait_Kinds are a valid subordinate for: A_Private_Type_Declaration, -- 3.2.1 -> Trait_Kinds A_Private_Extension_Declaration, -- 3.2.1 -> Trait_Kinds - Trait_Kinds commentary was reworked to address ASISWG issue 1 from Section 1 above. - A commentary mixup was corrected for Default_Kinds. - Attribute_Kinds literal are fully defined. - Alternative_Kinds commentary and literals were reworked to address ASISWG issue 2 from Section 1 above. - The type Unit_Kinds was expanded to be more specific. Unit_Trait_Kinds and Unit_State_Kinds were added to completely classify compilation units. See the rationale presented in the related document: Proposed ASIS 9X Version 2.0.B -- June 1995 - The type Error_Kinds was moved into its own package Asis_Errors. Section 3. Specification of package Asis_Element_Kinds. package ASIS_Element_Kinds is ------------------------------------------------------------------------------ -- ASIS.Element_Kinds -- ASIS 95 Version 2.0.B -- June 1995 -- -- Enumeration types describing the various kinds of elements. -- --|95------------------------------------------------------------------------- --|95 package ASIS_Element_Kinds is new. --|95------------------------------------------------------------------------- --|95 The element kinds hierarchy is new. --|95------------------------------------------------------------------------- --|95 All type declarations of element kinds and subordinate element kinds are --|95 in this package. ------------------------------------------------------------------------------ -- Element_Kinds Hierarchy -- -- ASIS offers hierarchical classification of elements. At the highest -- level, the Element_Kinds type provides literals that define ten "kinds" or -- classes listed below into which all non-nil elements are grouped. Elements -- in each of the Element_Kinds classes, with the exception of -- An_Exception_Handler, can be further classified by a subordinate kind at the -- next level in the hierarchy. Several subordinate kinds also have additional -- subordinate kinds. -- -- For example Element_Kinds'A_Declaration might be classified into -- Declaration_Kinds'A_Parameter_Specification which might be further -- classified into Trait_Kinds'An_Access_Trait and into Mode_Kinds'An_In_Mode. -- This would fully identify the syntax of an element such as: -- (Who : IN ACCESS Person) -- -- All Element_Kind and subordinate kinds Queries are in Asis.Elements. -- -- It is not necessary to strictly follow the hierarchy; any element can be -- classified by any subordinate kind from any level. However, meaningful -- results will only be obtained from subordinate kinds that are appropriate, -- ie. that are designated within the hierarchy as shown below. -- -- Element_Kinds -> Subordinate Kinds ------------------------------------------------------------------------------ -- Key: Read "->" as "may be further classified by its" -- -- A_Pragma -> Pragma_Kinds -- -- A_Defining_Name -> Defining_Name_Kinds -- -> Operator_Kinds -- -- A_Declaration -> Declaration_Kinds -- -> Trait_Kinds -- -> Declaration_Origins -- -> Mode_Kinds -- -> Default_Kinds -- -- A_Definition -> Definition_Kinds -- -> Trait_Kinds -- -> Type_Kinds -- -> Trait_Kinds -- -> Formal_Type_Kinds -- -> Trait_Kinds -- -> Access_Type_Kinds -- -> Root_Type_Kinds -- -> Constraint_Kinds -- -> Discrete_Range_Kinds -- -- An_Expression -> Expression_Kinds -- -> Operator_Kinds -- -> Attribute_Kinds -- -- An_Association -> Association_Kinds -- -- A_Statement -> Statement_Kinds -- -- An_Alternative -> Alternative_Kinds -- -- A_Clause -> Clause_Kinds -- -> Representation_Clause_Kinds -- -- An_Exception_Handler -- ------------------------------------------------------------------------------ -- Enumerations for Asis.Elements ------------------------------------------------------------------------------ -- --|95------------------------------------------------------------------------- --|95 Element_Kinds: many literals are new, reordered, reorganized, and have --|95 improved names reflecting Ada 95 terminology. ------------------------------------------------------------------------------ -- Element_Kinds - general element classifications -- Literals -- ASIS package with queries for these kinds ------------------------------------------------------------------------------ type Element_Kinds is ( Not_An_Element, -- Nil_Element A_Pragma, -- Asis.Elements A_Defining_Name, -- Asis.Declarations A_Declaration, -- Asis.Declarations A_Definition, -- Asis.Definitions An_Expression, -- Asis.Expressions An_Association, -- Asis.Expressions A_Statement, -- Asis.Statements An_Alternative, -- Asis.Statements A_Clause, -- Asis.Clauses An_Exception_Handler); -- Asis.Statements ------------------------------------------------------------------------------ -- Pragma_Kinds - classifications for pragmas -- Literals -- Ada RM ------------------------------------------------------------------------------ type Pragma_Kinds is ( Not_A_Pragma, An_All_Calls_Remote_Pragma, -- I.2.3(6) An_Asynchronous_Pragma, -- I.4.1(3) An_Atomic_Pragma, -- G.5(3) An_Atomic_Components_Pragma, -- G.5(3) An_Attach_Handler_Pragma, -- G.3.1(3) A_Controlled_Pragma, -- 13.11.3(3), B(12) A_Convention_Pragma, -- B(16), M.1(5) An_Elaborate_All_Pragma, -- 10.2.1(19), B(8) An_Elaborate_Body_Pragma, -- 10.2.1(21), B(9) An_Export_Pragma, -- B(15), M.1(5) An_Import_Pragma, -- B(14), M.1(5) An_Inline_Pragma, -- 6.3.2(4), B(5) An_Inspection_Point_Pragma, -- L.2.2(2) An_Interrupt_Handler_Pragma, -- G.3.1(2) An_Interrupt_Priority_Pragma, -- H.1(4) A_List_Pragma, -- 2.8(18), B(2) A_Locking_Policy_Pragma, -- H.3(3) A_Normalize_Scalars_Pragma, -- L.1.1(2) An_Optimize_Pragma, -- 2.8(18), B(4) A_Pack_Pragma, -- 13.2(2), B(11) A_Page_Pragma, -- 2.8(18), B(3) A_Preelaborate_Pragma, -- 10.2.1(3), B(6) A_Priority_Pragma, -- H.1(3) A_Pure_Pragma, -- 10.2.1(13), B(7) A_Queuing_Policy, -- H.4(3) A_Remote_Call_Interface_Pragma, -- I.2.3(4) A_Remote_Types_Pragma, -- I.2.2(4) A_Restrictions_Pragma, -- 13.12(2), B(13) A_Reviewable_Pragma, -- L.2.1(2) A_Shared_Passive_Pragma, -- I.2.1(4) A_Suppress_Pragma, -- 11.5(4), B(10) A_Task_Dispatching_Policy_Pragma, -- H.2.2(2) A_Volatile_Pragma, -- G.5(3) A_Volatile_Components_Pragma, -- G.5(3) An_Implementation_Defined_Pragma, -- Vendor Annex M An_Unknown_Pragma); -- Unknown to the compiler. ------------------------------------------------------------------------------ -- Enumerations for Asis.Declarations ------------------------------------------------------------------------------ ------------------------------------------------------------------------------ -- Defining_Name_Kinds - names defined by declarations and specifications. -- Literals -- Ada RM ------------------------------------------------------------------------------ type Defining_Name_Kinds is ( Not_A_Defining_Name, A_Defining_Identifier, -- 3.1 A_Defining_Character_Literal, -- 3.5.1 A_Defining_Enumeration_Literal, -- 3.5.1 A_Defining_Operator_Symbol, -- 6.1 A_Defining_Expanded_Name); -- 6.1 program_unit_name.defining_identifier ------------------------------------------------------------------------------ -- Declaration_Kinds - declarations and specifications having defining_names. -- Literals -- Ada RM -> Subordinate Kinds ------------------------------------------------------------------------------ type Declaration_Kinds is ( Not_A_Declaration, An_Ordinary_Type_Declaration, -- 3.2.1 -- a full_type_declaration of the form: -- type defining_identifier [known_discriminant_part] is type_definition; A_Task_Type_Declaration, -- 3.2.1 A_Protected_Type_Declaration, -- 3.2.1 An_Incomplete_Type_Declaration, -- 3.2.1 A_Private_Type_Declaration, -- 3.2.1 -> Trait_Kinds A_Private_Extension_Declaration, -- 3.2.1 -> Trait_Kinds A_Subtype_Declaration, -- 3.2.2 A_Variable_Declaration, -- 3.3.1 -> Trait_Kinds A_Constant_Declaration, -- 3.3.1 -> Trait_Kinds A_Deferred_Constant_Declaration, -- 3.3.1 -> Trait_Kinds A_Single_Task_Declaration, -- 3.3.1 A_Single_Protected_Declaration, -- 3.3.1 An_Integer_Number_Declaration, -- 3.3.2 A_Real_Number_Declaration, -- 3.3.2 An_Enumeration_Literal_Specification, -- 3.5.1 A_Discriminant_Specification, -- 3.7 -> Trait_Kinds A_Component_Declaration, -- 3.8 A_Loop_Parameter_Specification, -- 5.5 -> Trait_Kinds A_Procedure_Declaration, -- 6.1 -> Trait_Kinds A_Function_Declaration, -- 6.1 -> Trait_Kinds A_Parameter_Specification, -- 6.1 -> Trait_Kinds -- -> Mode_Kinds A_Procedure_Body_Declaration, -- 6.3 A_Function_Body_Declaration, -- 6.3 A_Package_Declaration, -- 7.1 A_Package_Body_Declaration, -- 7.2 An_Object_Renaming_Declaration, -- 8.5.1 An_Exception_Renaming_Declaration, -- 8.5.2 A_Package_Renaming_Declaration, -- 8.5.3 A_Procedure_Renaming_Declaration, -- 8.5.4 A_Function_Renaming_Declaration, -- 8.5.4 A_Generic_Package_Renaming_Declaration, -- 8.5.5 A_Generic_Procedure_Renaming_Declaration, -- 8.5.5 A_Generic_Function_Renaming_Declaration, -- 8.5.5 A_Task_Body_Declaration, -- 9.1 A_Protected_Body_Declaration, -- 9.4 An_Entry_Declaration, -- 9.5.2 An_Entry_Body_Declaration, -- 9.5.2 An_Entry_Index_Specification, -- 9.5.2 A_Procedure_Body_Stub, -- 10.1.3 A_Function_Body_Stub, -- 10.1.3 A_Package_Body_Stub, -- 10.1.3 A_Task_Body_Stub, -- 10.1.3 A_Protected_Body_Stub, -- 10.1.3 An_Exception_Declaration, -- 11.1 A_Choice_Parameter_Specification, -- 11.2 A_Generic_Procedure_Declaration, -- 12.1 A_Generic_Function_Declaration, -- 12.1 A_Generic_Package_Declaration, -- 12.1 A_Package_Instantiation, -- 12.3 A_Procedure_Instantiation, -- 12.3 A_Function_Instantiation, -- 12.3 A_Formal_Object_Declaration, -- 12.4 -> Mode_Kinds A_Formal_Type_Declaration, -- 12.5 A_Formal_Procedure_Declaration, -- 12.6 -> Default_Kinds A_Formal_Function_Declaration, -- 12.6 -> Default_Kinds A_Formal_Package_Declaration, -- 12.7 A_Formal_Package_Declaration_With_Box); -- 12.7 subtype A_Type_Declaration is Declaration_Kinds range An_Ordinary_Type_Declaration .. A_Private_Extension_Declaration; subtype A_Full_Type_Declaration is Declaration_Kinds range An_Ordinary_Type_Declaration .. A_Protected_Type_Declaration; subtype An_Object_Declaration is Declaration_Kinds range A_Variable_Declaration .. A_Single_Protected_Declaration; subtype A_Number_Declaration is Declaration_Kinds range An_Integer_Number_Declaration .. A_Real_Number_Declaration; subtype A_Renaming_Declaration is Declaration_Kinds range An_Object_Renaming_Declaration .. A_Generic_Function_Renaming_Declaration; subtype A_Body_Stub is Declaration_Kinds range A_Procedure_Body_Stub .. A_Protected_Body_Stub; subtype A_Generic_Declaration is Declaration_Kinds range A_Generic_Procedure_Declaration .. A_Generic_Package_Declaration; subtype A_Generic_Instantiation is Declaration_Kinds range A_Package_Instantiation .. A_Function_Instantiation; subtype A_Formal_Declaration is Declaration_Kinds range A_Formal_Object_Declaration .. A_Formal_Package_Declaration_With_Box; ------------------------------------------------------------------------------ -- Trait_Kinds -- -- Trait_Kinds provide a means of further classifying the syntactic structure -- or "trait" of certain A_Declaration and A_Definition elements. -- Trait_Kinds are determined only by the presence (or absence) of certain -- reserved words. The semantics of an element are not considered. -- The reserved words of interest here are ABSTRACT, ALIASED, LIMITED, PRIVATE, -- REVERSE, and ACCESS when it appears in an access_definition. -- Trait_Kinds enumerates all combinations useful in this classification. -- -- For example, A_Variable_Declaration element that is semantically a -- limited type because its components are of a limited type is -- An_Ordinary_Trait, not A_Limited_Trait, since the reserved word LIMITED -- does not appear in its declaration or definition. -- -- The subordinate Trait_Kinds allow Declaration_Kinds and Definition_Kinds -- to enumerate fewer higher level elements, and be less cluttered by all -- possible permutations of syntactic possibilities. ie. In the case of a -- record_type_definition, Definition_Kinds can provide just two literals that -- dfferentiate between ordinary record types and tagged record types: -- -- A_Record_Type_Definition, -- 3.8 -> Trait_Kinds -- A_Tagged_Record_Type_Definition, -- 3.8 -> Trait_Kinds -- -- The remaining classification can be accomplished, if desired, using -- Trait_Kinds to determine if the definition is abstract, or limited, or both. -- Without Trait_Kinds, Definition_Kinds would need six literals to identify -- all the syntactic combinations for a record_type_definition. -- -- Elements expected by the Trait_Kind query are any Declaration_Kinds or -- Definition_Kinds for which Trait_Kinds is a subordinate kind: the literal -- definition will have "-> Trait_Kinds" following it. For example, the -- definitions of: -- -- A_Discriminant_Specification, -- 3.7 -> Trait_Kinds -- A_Component_Declaration, -- 3.8 -- -- indicate A_Discriminant_Specification is an expected kind while -- A_Component_Declaration is unexpected. -- -- All Declaration_Kinds and Definition_Kinds for which Trait_Kinds is not a -- subordinate kind, and all other Element_Kinds, are unexpected and are -- Not_A_Trait. -- -- An_Ordinary_Trait is any expected element whose syntax does not explicitly -- contain any of the reserved words listed above. -- ------------------------------------------------------------------------------ -- Trait_Kinds -- Literals ------------------------------------------------------------------------------ type Trait_Kinds is ( Not_A_Trait, An_Ordinary_Trait, -- The declaration or definition does -- not contain the reserved words -- ALIASED, REVERSE, PRIVATE, -- LIMITED, ABSTRACT, or -- ACCESS in an access_definition An_Aliased_Trait, -- ALIASED is present An_Access_Definition_Trait, -- ACCESS in an access_definition is -- present A_Reverse_Trait, -- REVERSE is present A_Private_Trait, -- only PRIVATE is present A_Limited_Trait, -- only LIMITED is present A_Limited_Private_Trait, -- LIMITED and PRIVATE are present An_Abstract_Trait, -- ABSTRACT is present An_Abstract_Private_Trait, -- ABSTRACT and PRIVATE are present An_Abstract_Limited_Trait, -- ABSTRACT and LIMITED are present An_Abstract_Limited_Private_Trait); -- ABSTRACT, LIMITED, and PRIVATE are -- present ------------------------------------------------------------------------------ -- Declaration_Origins -- Literals -- Ada RM ------------------------------------------------------------------------------ type Declaration_Origins is ( Not_A_Declaration_Origin, An_Explicit_Declaration, -- programmer declared An_Implicit_Predefined_Declaration, -- 3.2.3(1) An_Implicit_Inherited_Declaration); -- 3.4(7-23) ------------------------------------------------------------------------------ -- Mode_Kinds -- Literals -- Ada RM ------------------------------------------------------------------------------ type Mode_Kinds is ( -- 6.1 Not_A_Mode, A_Default_In_Mode, -- procedure A(B : C); An_In_Mode, -- procedure A(B : IN C); An_Out_Mode, -- procedure A(B : OUT C); An_In_Out_Mode); -- procedure A(B : IN OUT C); ------------------------------------------------------------------------------ -- Default_Kinds -- Literals -- Ada RM ------------------------------------------------------------------------------ type Default_Kinds is ( -- 12.6 Not_A_Default, A_Name_Default, -- with subprogram_specification is default_name; A_Box_Default, -- with subprogram_specification is <>; A_Nil_Default); -- with subprogram_specification; ------------------------------------------------------------------------------ -- Enumerations for Asis.Definitions ------------------------------------------------------------------------------ ------------------------------------------------------------------------------ -- Definition_Kinds -- Literals -- Ada RM -> Subordinate Kinds ------------------------------------------------------------------------------ type Definition_Kinds is ( Not_A_Definition, A_Type_Definition, -- 3.2.1 -> Type_Kinds A_Subtype_Indication, -- 3.2.2 A_Constraint, -- 3.2.2 -> Constraint_Kinds A_Component_Definition, -- 3.6 A_Discrete_Subtype_Definition, -- 3.6 -> Discrete_Range_Kinds A_Discrete_Range, -- 3.6.1 -> Discrete_Range_Kinds An_Unknown_Discriminant_Part, -- 3.7 A_Known_Discriminant_Part, -- 3.7 A_Record_Definition, -- 3.8 A_Null_Record_Definition, -- 3.8 A_Null_Component, -- 3.8 A_Variant_Part, -- 3.8 A_Variant, -- 3.8 An_Others_Choice, -- 3.8.1, 4.3.1, 4.3.3, 11.2 A_Private_Type_Definition, -- 7.3 -> Trait_Kinds A_Tagged_Private_Type_Definition, -- 7.3 -> Trait_Kinds A_Private_Extension_Definition, -- 7.3 -> Trait_Kinds A_Task_Definition, -- 9.1 A_Protected_Definition, -- 9.4 A_Formal_Type_Definition); -- 12.5 -> Formal_Type_Kinds ------------------------------------------------------------------------------ -- Type_Kinds -- Literals -- Ada RM -> Subordinate Kinds ------------------------------------------------------------------------------ type Type_Kinds is ( Not_A_Type_Definition, A_Derived_Type_Definition, -- 3.4 -> Trait_Kinds A_Derived_Record_Extension_Definition, -- 3.4 -> Trait_Kinds An_Enumeration_Type_Definition, -- 3.5.1 A_Signed_Integer_Type_Definition, -- 3.5.4 A_Modular_Type_Definition, -- 3.5.4 A_Root_Type_Definition, -- 3.5.4(10), 3.5.6(4) -- -> Root_Type_Kinds A_Floating_Point_Definition, -- 3.5.7 An_Ordinary_Fixed_Point_Definition, -- 3.5.9 A_Decimal_Fixed_Point_Definition, -- 3.5.9 An_Unconstrained_Array_Definition, -- 3.6 A_Constrained_Array_Definition, -- 3.6 A_Record_Type_Definition, -- 3.8 -> Trait_Kinds A_Tagged_Record_Type_Definition, -- 3.8 -> Trait_Kinds An_Access_Type_Definition); -- 3.10 -> Access_Type_Kinds ------------------------------------------------------------------------------ -- Formal_Type_Kinds -- Literals -- Ada RM -> Subordinate Kinds ------------------------------------------------------------------------------ type Formal_Type_Kinds is ( Not_A_Formal_Type_Definition, A_Formal_Private_Type_Definition, -- 12.5.1 -> Trait_Kinds A_Formal_Tagged_Private_Type_Definition, -- 12.5.1 -> Trait_Kinds A_Formal_Derived_Type_Definition, -- 12.5.1 -> Trait_Kinds A_Formal_Discrete_Type_Definition, -- 12.5.2 A_Formal_Signed_Integer_Type_Definition, -- 12.5.2 A_Formal_Modular_Type_Definition, -- 12.5.2 A_Formal_Floating_Point_Definition, -- 12.5.2 A_Formal_Ordinary_Fixed_Point_Definition, -- 12.5.2 A_Formal_Decimal_Fixed_Point_Definition, -- 12.5.2 A_Formal_Unconstrained_Array_Definition, -- 12.5.3 A_Formal_Constrained_Array_Definition, -- 12.5.3 A_Formal_Access_Type_Definition); -- 12.5.4 -> Access_Type_Kinds ------------------------------------------------------------------------------ -- Access_Type_Kinds -- Literals -- Ada RM ------------------------------------------------------------------------------ type Access_Type_Kinds is ( -- 3.10 Not_An_Access_Type_Definition, A_Pool_Specific_Access_To_Variable, -- access subtype_indication An_Access_To_Variable, -- access all subtype_indication An_Access_To_Constant, -- access constant subtype_indication An_Access_To_Procedure, -- access procedure An_Access_To_Protected_Procedure, -- access protected procedure An_Access_To_Function, -- access function An_Access_To_Protected_Function); -- access protected function subtype Access_To_Object_Definition is Access_Type_Kinds range A_Pool_Specific_Access_To_Variable .. An_Access_To_Constant; subtype Access_To_Subprogram_Definition is Access_Type_Kinds range An_Access_To_Procedure .. An_Access_To_Protected_Function; ------------------------------------------------------------------------------ -- Root_Type_Kinds -- Literals -- Ada RM ------------------------------------------------------------------------------ type Root_Type_Kinds is ( Not_A_Root_Type_Definition, A_Root_Integer_Definition, -- 3.5.4(9) A_Root_Real_Definition, -- 3.5.6(2) A_Root_Fixed_Definition, -- 3.5.6(2) A_Universal_Integer_Definition, -- 3.5.4(10) A_Universal_Real_Definition, -- 3.5.6(4) A_Universal_Fixed_Definition); -- 3.5.6(4) ------------------------------------------------------------------------------ -- Constraint_Kinds -- Literals -- Ada RM ------------------------------------------------------------------------------ type Constraint_Kinds is ( Not_A_Constraint, A_Range_Attribute_Reference, -- 3.2.2, 3.5 Simple_Expression_Range, -- 3.2.2, 3.5 A_Digits_Constraint, -- 3.2.2, 3.5.9 A_Delta_Constraint, -- 3.2.2, N.3 An_Index_Constraint, -- 3.2.2, 3.6.1 A_Discriminant_Constraint); -- 3.2.2 ------------------------------------------------------------------------------ -- Discrete_Range_Kinds -- Literals -- Ada RM ------------------------------------------------------------------------------ type Discrete_Range_Kinds is ( Not_A_Discrete_Range, A_Discrete_Subtype_Indication, -- 3.6.1, 3.2.2 A_Discrete_Range_Attribute_Reference, -- 3.6.1, 3.5 A_Discrete_Simple_Expression_Range); -- 3.6.1, 3.5 ------------------------------------------------------------------------------ -- Enumerations for Asis.Expressions ------------------------------------------------------------------------------ ------------------------------------------------------------------------------ -- Association_Kinds -- Literals -- Ada RM ------------------------------------------------------------------------------ type Association_Kinds is ( Not_An_Association, A_Pragma_Argument_Association, -- 2.8 A_Discriminant_Association, -- 3.7.1 A_Record_Component_Association, -- 4.3.1 An_Array_Component_Association, -- 4.3.3 A_Parameter_Association); -- 6.4 ------------------------------------------------------------------------------ -- Expression_Kinds - general expression classifications -- Literals -- Ada RM -> Subordinate Kinds ------------------------------------------------------------------------------ type Expression_Kinds is ( Not_An_Expression, An_Integer_Literal, -- 2.4 A_Real_Literal, -- 2.4.1 A_String_Literal, -- 2.6 An_Identifier, -- 4.1 An_Operator_Symbol, -- 4.1 A_Character_Literal, -- 4.1 An_Enumeration_Literal, -- 4.1 An_Explicit_Dereference, -- 4.1 A_Function_Call, -- 4.1 An_Indexed_Component, -- 4.1.1 A_Slice, -- 4.1.2 A_Selected_Component, -- 4.1.3 An_Attribute_Reference, -- 4.1.4 -> Attribute_Kinds A_Record_Aggregate, -- 4.3 An_Extension_Aggregate, -- 4.3 An_Positional_Array_Aggregate, -- 4.3 An_Named_Array_Aggregate, -- 4.3 An_And_Then_Short_Circuit, -- 4.4 An_Or_Else_Short_Circuit, -- 4.4 An_In_Range_Membership_Test, -- 4.4 A_Not_In_Range_Membership_Test, -- 4.4 An_In_Type_Membership_Test, -- 4.4 A_Not_In_Type_Membership_Test, -- 4.4 A_Null_Literal, -- 4.4 A_Parenthesized_Expression, -- 4.4 A_Type_Conversion, -- 4.6 A_Qualified_Expression, -- 4.7 An_Allocation_From_Subtype, -- 4.8 An_Allocation_From_Qualified_Expression); -- 4.8 ------------------------------------------------------------------------------ -- Operator_Kinds - classification of the various Ada predefined operators -- Literals -- Ada RM ------------------------------------------------------------------------------ type Operator_Kinds is ( -- 4.5 Not_An_Operator, An_And_Operator, -- and An_Or_Operator, -- or An_Xor_Operator, -- xor An_Equal_Operator, -- = A_Not_Equal_Operator, -- /= A_Less_Than_Operator, -- < A_Less_Than_Or_Equal_Operator, -- <= A_Greater_Than_Operator, -- > A_Greater_Than_Or_Equal_Operator, -- >= A_Plus_Operator, -- + A_Minus_Operator, -- - A_Concatenate_Operator, -- & A_Unary_Plus_Operator, -- + A_Unary_Minus_Operator, -- - A_Multiply_Operator, -- * A_Divide_Operator, -- / A_Mod_Operator, -- mod A_Rem_Operator, -- rem An_Exponentiate_Operator, -- ** An_Abs_Operator, -- abs A_Not_Operator); -- not ------------------------------------------------------------------------------ -- Attribute_Kinds - classifications for all known Ada attributes -- Literals -- Ada RM ------------------------------------------------------------------------------ type Attribute_Kinds is ( Not_An_Attribute, An_Access_Attribute, -- 3.10.2(24), 3.10.2(32), K(2), K(4) An_Address_Attribute, -- 13.3(11), J.7.1(5), K(6) An_Adjacent_Attribute, -- A.5.3(48), K(8) An_Aft_Attribute, -- 3.5.10(5), K(12) An_Alignment_Attribute, -- 13.3(23), K(14) A_Base_Attribute, -- 3.5(15), K(17) A_Bit_Order_Attribute, -- 13.5.3(4), K(19) A_Body_Version_Attribute, -- E.3(4), K(21) A_Callable_Attribute, -- 9.9(2), K(23) A_Caller_Attribute, -- C.7.1(14), K(25) A_Ceiling_Attribute, -- A.5.3(33), K(27) A_Class_Attribute, -- 3.9(14), 7.3.1(9), K(31), K(34) A_Component_Size_Attribute, -- 13.3(69), K(36) A_Compose_Attribute, -- A.5.3(24), K(38) A_Constrained_Attribute, -- 3.7.2(3), J.4(2), K(42) A_Copy_Sign_Attribute, -- A.5.3(51), K(44) A_Count_Attribute, -- 9.9(5), K(48) A_Definite_Attribute, -- 12.5.1(23), K(50) A_Delta_Attribute, -- 3.5.10(3), K(52) A_Denorm_Attribute, -- A.5.3(9), K(54) A_Digits_Attribute, -- 3.5.8(2), 3.5.10(7), K(56), K(58) An_Exponent_Attribute, -- A.5.3(18), K(60) An_External_Tag_Attribute, -- 13.3(75), K(64) A_First_Attribute, -- 3.5(12), 3.6.2(3), K(68), K(70) A_First_Bit_Attribute, -- 13.5.2(3), K(72) A_Floor_Attribute, -- A.5.3(30), K(74) A_Fore_Attribute, -- 3.5.10(4), K(78) A_Fraction_Attribute, -- A.5.3(21), K(80) An_Identity_Attribute, -- 11.4.1(9), C.7.1(12), K(84), K(86) An_Image_Attribute, -- 3.5(35), K(88) An_Input_Attribute, -- 13.13.2(22), 13.13.2(32), K(92), K(96) A_Last_Attribute, -- 3.5(13), 3.6.2(5), K(102), K(104) A_Last_Bit_Attribute, -- 13.5.2(4), K(106) A_Leading_Part_Attribute, -- A.5.3(54), K(108) A_Length_Attribute, -- 3.6.2(9), K(117) A_Machine_Attribute, -- A.5.3(60), K(119) A_Machine_Emax_Attribute, -- A.5.3(8), K(123) A_Machine_Emin_Attribute, -- A.5.3(7), K(125) A_Machine_Mantissa_Attribute, -- A.5.3(6), K(127) A_Machine_Overflows_Attribute, -- A.5.3(12), A.5.4(4), K(129), K(131) A_Machine_Radix_Attribute, -- A.5.3(2), A.5.4(2), K(133), K(135) A_Machine_Rounds_Attribute, -- A.5.3(11), A.5.4(3), K(137), K(139) A_Max_Attribute, -- 3.5(19), K(141) A_Max_Size_In_Storage_Elements_Attribute,-- 13.11.1(3), K(145) A_Min_Attribute, -- 3.5(16), K(147) A_Model_Attribute, -- A.5.3(68), G.2.2(7), K(151) A_Model_Emin_Attribute, -- A.5.3(65), G.2.2(4), K(155) A_Model_Epsilon_Attribute, -- A.5.3(66), K(157) A_Model_Mantissa_Attribute, -- A.5.3(64), G.2.2(3), K(159) A_Model_Small_Attribute, -- A.5.3(67), K(161) A_Modulus_Attribute, -- 3.5.4(17), K(163) An_Output_Attribute, -- 13.13.2(19), 13.13.2(29), K(165), K(169) A_Partition_ID_Attribute, -- E.1(9), K(173) A_Pos_Attribute, -- 3.5.5(2), K(175) A_Position_Attribute, -- 13.5.2(2), K(179) A_Pred_Attribute, -- 3.5(25), K(181) A_Range_Attribute, -- 3.5(14), 3.6.2(7), K(187), K(189) A_Read_Attribute, -- 13.13.2(6), 13.13.2(14), K(191), K(195) A_Remainder_Attribute, -- A.5.3(45), K(199) A_Round_Attribute, -- 3.5.10(12), K(203) A_Rounding_Attribute, -- A.5.3(36), K(207) A_Safe_First_Attribute, -- A.5.3(71), G.2.2(5), K(211) A_Safe_Last_Attribute, -- A.5.3(72), G.2.2(6), K(213) A_Scale_Attribute, -- 3.5.10(11), K(215) A_Scaling_Attribute, -- A.5.3(27), K(217) A_Signed_Zeros_Attribute, -- A.5.3(13), K(221) A_Size_Attribute, -- 13.3(40), 13.3(45), K(223), K(228) A_Small_Attribute, -- 3.5.10(2), K(230) A_Storage_Pool_Attribute, -- 13.11(13), K(232) A_Storage_Size_Attribute, -- 13.3(60), 13.11(14), J.9(2), K(234), -- K(236) A_Succ_Attribute, -- 3.5(22), K(238) A_Tag_Attribute, -- 3.9(16), 3.9(18), K(242), K(244) A_Terminated_Attribute, -- 9.9(3), K(246) A_Truncation_Attribute, -- A.5.3(42), K(248) An_Unbiased_Rounding_Attribute,-- A.5.3(39), K(252) An_Unchecked_Access_Attribute, -- 13.10(3), H.4(18), K(256) A_Val_Attribute, -- 3.5.5(5), K(258) A_Valid_Attribute, -- 13.9.2(3), H(6), K(262) A_Value_Attribute, -- 3.5(52), K(264) A_Version_Attribute, -- E.3(3), K(268) A_Wide_Image_Attribute, -- 3.5(28), K(270) A_Wide_Value_Attribute, -- 3.5(40), K(274) A_Wide_Width_Attribute, -- 3.5(38), K(278) A_Width_Attribute, -- 3.5(39), K(280) A_Write_Attribute, -- 13.13.2(3), 13.13.2(11), K(282), K(286) An_Implementation_Defined_Attribute, -- Vendor Annex M An_Unknown_Attribute); ------------------------------------------------------------------------------ -- Enumerations for Asis.Statements ------------------------------------------------------------------------------ ------------------------------------------------------------------------------ -- Statement_Kinds - classifications of Ada statements -- Literals -- Ada RM ------------------------------------------------------------------------------ type Statement_Kinds is ( Not_An_Statement, A_Null_Statement, -- 5.1 An_Assignment_Statement, -- 5.2 An_If_Statement, -- 5.3 A_Case_Statement, -- 5.4 A_Loop_Statement, -- 5.5 A_While_Loop_Statement, -- 5.5 A_For_Loop_Statement, -- 5.5 A_Block_Statement, -- 5.6 An_Exit_Statement, -- 5.7 A_Goto_Statement, -- 5.8 A_Procedure_Call_Statement, -- 6.4 A_Return_Statement, -- 6.5 An_Accept_Statement, -- 9.5.2 An_Entry_Call_Statement, -- 9.5.3 A_Requeue_Statement, -- 9.5.4 A_Requeue_Statement_With_Abort, -- 9.5.4 A_Delay_Until_Statement, -- 9.6 A_Delay_Relative_Statement, -- 9.6 A_Selective_Accept_Statement, -- 9.7.2 A_Timed_Entry_Call_Statement, -- 9.7.3 A_Conditional_Entry_Call_Statement, -- 9.7.3 An_Asynchronous_Select_Statement, -- 9.7.4 An_Abort_Statement, -- 9.8 A_Raise_Statement, -- 11.3 A_Code_Statement); -- 13.8 ------------------------------------------------------------------------------ -- Alternative_Kinds -- -- Elements that are An_Alternative represent two forms of Alternative_Kinds: -- -- 1) The first form separates if_statements, case_statements, or -- select_statements into the execution path alternatives provided by the -- syntactical structure of the statements. Each statement path alternative -- encloses either a sequence_of_statements, or a select_alternative. -- Lterals of the first form are members of the subtype A_Path_Alternative and -- have names ending in "_Path_Alternative". -- -- 2) The second form identifies a select_alternative which in turn encloses -- either a sequence_of_statements or a terminate_alternative. Literals of -- the second form are members of the subtype A_Select_Alternative and are -- An_Accept_Alternative, A_Delay_Alternative, and A_Terminate_Alternative. -- -- The terminate_alternative (terminate;) is not a statement, so it is -- represented as one of the Alternative_Kinds rather than A_Statement. This -- allows queries that return a select_alternative to return a single element -- rather than a list of statements within which the terminate_alternative -- would clash. -- -- Two additional alternatives defined in Ada 95, entry_call_alternative and -- triggering_alternative, are treated by ASIS as a sequence_of_statements and -- are not represented by Alternative_Kinds. This allows queries that accept -- them to directly provide the sequence_of_statements and avoid the extra step -- of returning An_Alternative. The terminate_alternative is not possible in -- either of these, so there is no conflict. -- ------------------------------------------------------------------------------ -- Alternative_Kinds -- Literals -- Ada RM ------------------------------------------------------------------------------ type Alternative_Kinds is ( Not_An_Alternative, An_If_Path_Alternative, -- 5.3: -- if condition then -- sequence_of_statements An_Elsif_Path_Alternative, -- 5.3: -- elsif condition then -- sequence_of_statements An_Else_Path_Alternative, -- 5.3, 9.7.1: -- else sequence_of_statements A_Case_Path_Alternative, -- 5.4: -- when discrete_choice_list => -- sequence_of_statements A_Select_Path_Alternative, -- 9.7.1: -- select [guard] select_alternative -- 9.7.2, 9.7.3: -- select entry_call_alternative -- 9.7.4: -- select triggering_alternative An_Or_Path_Alternative, -- 9.7.1: -- or [guard] select_alternative -- 9.7.2: -- or delay_alternative A_Then_Abort_Path_Alternative, -- 9.7.4 -- then abort sequence_of_statements An_Accept_Alternative, -- 9.7.1: -- accept_statement [sequence_of_statements] A_Delay_Alternative, -- 9.7.1 -- delay_statement [sequence_of_statements] A_Terminate_Alternative); -- 9.7.1 -- terminate; subtype A_Path_Alternative is Alternative_Kinds range An_If_Path_Alternative .. A_Then_Abort_Path_Alternative; subtype A_Select_Alternative is Alternative_Kinds range An_Accept_Alternative .. A_Terminate_Alternative; ------------------------------------------------------------------------------ -- Enumerations for Asis.Clauses ------------------------------------------------------------------------------ ------------------------------------------------------------------------------ -- Clause_Kinds -- Literals -- Ada RM -> Subordinate Kinds ------------------------------------------------------------------------------ type Clause_Kinds is ( Not_A_Clause, A_Use_Package_Clause, -- 8.4 A_Use_Type_Clause, -- 8.4 A_With_Clause, -- 10.1.2 A_Representation_Clause, -- 13.1 -> Representation_Clause_Kinds A_Component_Clause); -- 13.5.3 ------------------------------------------------------------------------------ -- Representation_Clause_Kinds - varieties of representation clauses -- Literals -- Ada RM ------------------------------------------------------------------------------ type Representation_Clause_Kinds is ( Not_A_Representation_Clause, An_Attribute_Definition_Clause, -- 13.3.1 An_Enumeration_Representation_Clause, -- 13.4 A_Record_Representation_Clause, -- 13.5.3 An_At_Clause); -- N.7 end ASIS_Element_Kinds; Section 4. Specification of package Asis_Unit_Kinds package ASIS_Unit_Kinds is ------------------------------------------------------------------------------ -- ASIS.Element_Kinds -- ASIS 95 Version 2.0.B -- June 1995 -- -- Enumeration types describing the various kinds of units. -- --|95------------------------------------------------------------------------- --|95 package ASIS_Unit_Kinds is new ------------------------------------------------------------------------------ -- Enumerations for Asis.Compilation_Units ------------------------------------------------------------------------------ -- --|95------------------------------------------------------------------------- --|95 type Unit_Kinds has been expanded. ------------------------------------------------------------------------------ -- Unit_Kinds - the varieties of compilation units ------------------------------------------------------------------------------ type Unit_Kinds is ( Not_A_Unit, -- A nil unit kind value. A_Procedure, A_Function, A_Package, A_Generic_Procedure, A_Generic_Function, A_Generic_Package, A_Procedure_Instance, A_Function_Instance, A_Package_Instance, A_Procedure_Renaming, A_Function_Renaming, A_Package_Renaming, A_Generic_Procedure_Renaming, A_Generic_Function_Renaming, A_Generic_Package_Renaming, A_Procedure_Body, A_Function_Body, A_Package_Body, A_Subunit, A_Nonexistent_Declaration, -- A unit that does not exist but is: -- 1) mentioned in a with clause of -- another unit or, -- 2) a required corresponding -- library_unit_declaration A_Nonexistent_Body, -- A unit that does not exist but is: -- 1) known to be a corresponding -- subunit or, -- 2) a required corresponding -- library_unit_body An_Unknown_Unit); -- An indeterminable or protected unit --|95------------------------------------------------------------------------- --|95 subtype declarations for Unit_Kinds are new. subtype A_Subprogram is Unit_Kinds range A_Procedure .. A_Function; subtype A_Subprogram_Renaming is Unit_Kinds range A_Procedure_Renaming .. A_Function_Renaming; subtype A_Generic is Unit_Kinds range A_Generic_Procedure .. A_Generic_Package; subtype A_Generic_Instance is Unit_Kinds range A_Procedure_Instance .. A_Package_Instance; subtype A_Subprogram_Body is Unit_Kinds range A_Procedure_Body .. A_Package_Body; subtype A_Generic_Renaming is Unit_Kinds range A_Generic_Procedure_Renaming .. A_Generic_Package_Renaming; --|95------------------------------------------------------------------------- --|95 type Unit_Trait_Kinds is new ------------------------------------------------------------------------------ -- Unit_Trait_Kinds - classification of public, private, body, and subunit. ------------------------------------------------------------------------------ type Unit_Trait_Kinds is ( -- 10.1.1 Not_A_Unit_Trait, -- A nil, nonexistent or unknown unit trait A_Public_Unit, -- library_unit_declaration or -- library_unit_renaming_declaration A_Private_Unit, -- private library_unit_declaration or -- private library_unit_renaming_declaration A_Unit_Body, -- library_unit_body A_Separate_Unit); -- subunit --|95------------------------------------------------------------------------- --|95 type Unit_State_Kinds is new. ------------------------------------------------------------------------------ -- Unit_State_Kinds - classification of the state of units contained in a -- library. ------------------------------------------------------------------------------ type Unit_State_Kinds is ( Not_A_State, -- The state of a nil or unknown unit A_Consistent_Unit, -- Consistent with all other units on which it -- semantically depends. Meets all legality -- rules within and across unit boundaries. An_Inconsistent_Unit, -- Not consistent with one or more units on -- which it semantically depends. Meets all -- legality rules within itself, but not -- across unit boundaries. A_Syntactically_Legal_Unit, -- Meets only the syntax rules A_Nonexistent_Unit); -- the state of a nonexistent unit ------------------------------------------------------------------------------ -- Unit_Origins - classification of possible unit origination ------------------------------------------------------------------------------ type Unit_Origins is ( Not_A_Unit_Origin, -- The origin of a nil or nonexistent unit A_Predefined_Unit, -- Ada predefined units defined in -- Annex A. These include packages -- Standard, Interfaces, System, -- Ada.Calendar, Ada.Text_Io, etc. A_Compiler_Predefined_Unit, -- Vendor specific library units, eg. -- runtime support packages, string -- libraries, etc. It is not required -- that any vendor supplied units have -- this origin. This is a suggestion. -- Vendors might provide, for example, -- precompiled versions of public -- domain software would have -- A_User_Defined_Unit origin. A_User_Defined_Unit); -- Neither A_Predefined_Unit or -- A_Compiler_Predefined_Unit ------------------------------------------------------------------------------ -- Relation_Kinds - classification of unit relationships --|95------------------------------------------------------------------------- --|95 Added Ancestors and Descendants literals to Relation_Kinds. --|95------------------------------------------------------------------------- --|95 Relation_Kinds: The Definition of Supporters now includes parent units. --|95------------------------------------------------------------------------- --|95 Relation_Kinds: The definition of Dependents now includes child units. --|95------------------------------------------------------------------------- --|95 Relation_Kinds: The definition of Family now includes descendants. --|95------------------------------------------------------------------------- --|95 Relation_Kinds: The definition of Extended_Family now includes --|95 descendants and ancestors. ------------------------------------------------------------------------------ type Relation_Kinds is ( Ancestors, Descendants, ---------------------------------------------------------------------- -- Definition: ANCESTORS of a unit; DESCENDANTS of a unit -- -- Ancestors of a library unit are itself, its parent, its parent's -- parent, and so on. (Standard is an ancestor of every library unit). -- -- The Descendants relation is the inverse of the ancestor relation. -- See Ada 95 RM 10.1.1(11). ---------------------------------------------------------------------- Direct_Supporters, Supporters, ---------------------------------------------------------------------- -- Definition: SUPPORTERS of a unit -- -- Supporters of a compilation unit are units on which it semantically -- depends. See Ada 95 RM 10.1.4(26). -- -- A parent declaration is a Direct_Supporter of its child units. -- -- A parent declaration is a Supporter of its grandchild units. -- -- Each library unit mentioned in the with clauses of a compilation unit -- is a Direct_Supporter of that compilation unit. -- -- A library unit is a Direct_Supporter of its corresponding library unit -- body. -- -- The parent body of a subunit is a Direct_Supporter of the subunit. -- -- The supporters relation is transitive--units that support library -- units with'ed by a compilation unit are (indirect) supporters of that -- compilation unit. Direct_Supporters is a non-transitive relation. -- All Direct_Supporters of a unit are also Supporters of that unit. -- -- The package Standard is a Supporter of every unit, but is not -- considered to be a Direct_Supporter unless it is mentioned in a with -- clause. -- -- For example: -- If A withs B and B withs C. -- Then C directly supports B, B directly supports A, -- C indirectly supports A, and -- both B and C are supporters of A. -- ---------------------------------------------------------------------- Direct_Dependents, Dependents, ---------------------------------------------------------------------- -- Definition: DEPENDENTS of a unit -- -- Dependents of a compilation unit are all the compilation units that -- depend semantically on it. -- -- Child units are Direct_Dependents of their parent unit. -- -- A compilation unit that mentions other library units in its with -- clauses is one of the Direct_Dependents of those library units. -- -- A unit body is a Direct_Dependent of its corresponding library unit -- declaration. -- -- A subunit is a Direct_Dependent of its parent body. -- -- The Dependents relation is transitive; Dependents of a unit include the -- unit's Direct_Dependents, those unit's Direct_Dependents, and so on. -- A unit that depends on a given unit also (indirectly) depends on the -- given unit's Supporters. Direct_Dependents is a non-transitive relation. -- All Direct_Dependents of a unit are also Dependents of that unit. -- -- For example: -- If A withs B and B withs C -- then A directly depends on B, B directly depends on C, -- A indirectly depends on C, and -- both A and B are dependents of C. -- -- Dependencies between compilation units may also be introduced by -- inline inclusions and for certain compiler optimizations. -- The results of these interfaces are intended to reflect all of -- these considerations. See Ada 95 RM 10.1.1(22-26) and 10.1.4(7). ---------------------------------------------------------------------- Family, ---------------------------------------------------------------------- -- Definition: FAMILY of a unit -- -- The family of a given unit is defined as the set of compilation -- units that comprise the given unit's declaration, body, ancestors, -- descendants, and subunits (and subunits of subunits, etc.). ---------------------------------------------------------------------- Extended_Family); ---------------------------------------------------------------------- -- Definition: EXTENDED FAMILY of a unit; CLOSURE of a unit -- -- The extended family of a given unit is defined as the set of all -- the Ada units ultimately needed by that unit to form a partition. -- See (Ada 95 RM 10.2(2-7)). -- -- The term closure is commonly used with similar meaning. -- -- For example: -- Assume the body of A has a subunit A.S and the declaration of A has -- a child unit A.Z. -- If A withs B and B withs C and C does not with a library unit. -- Then the extended family of A is: -- library unit C -- library unit body C (if required) -- library unit B -- library unit body B (if required) -- library unit A -- child library unit A.Z -- library unit body A -- subunit A.S -- ---------------------------------------------------------------------- end ASIS_Unit_Kinds; Section 5. Specification of package Asis_Errors package ASIS_Errors is ------------------------------------------------------------------------------ -- ASIS_Errors -- ASIS 95 Version 2.0.B -- June 1995 -- -- This enumeration type describes the various kinds of errors. -- --|95------------------------------------------------------------------------- --|95 package ASIS_Errors is a new ASIS package ------------------------------------------------------------------------------ -- ASIS reports all operational errors by raising an exception. Whenever an -- ASIS implementation raises one of the exceptions declared in package -- Asis.Exceptions, it will previously have set the Asis.Environment Status -- and Diagnosis values to indicate the cause of the error. The possible -- values for Status are indicated here along with suggestions for the -- associated contents of the Diagnosis string. -- -- ASIS applications are encouraged to follow this same convention whenever -- they explicitly raise any ASIS exception--always record a Status and -- Diagnosis prior to raising the exception. ------------------------------------------------------------------------------ type Error_Kinds is ( Not_An_Error, -- No error is presently recorded Value_Error, -- Routine argument value invalid Initialization_Error, -- ASIS is uninitialized Environment_Error, -- ASIS could not initialize Parameter_Error, -- Bad Parameter given to Initialize Capacity_Error, -- Implementation overloaded Name_Error, -- Library/object not found Use_Error, -- Library/object not use/open-able Data_Error, -- Library/object bad/invalid/corrupt Storage_Error, -- Storage_Error suppressed Obsolete_Reference_Error, -- Semantic reference is obsolete Unhandled_Exception_Error, -- Unexpected exception suppressed Not_Implemented_Error, -- Functionality not implemented Internal_Error); -- Implementation internal failure end ASIS_Errors;