⟦2ce3a0b71⟧

TextFile

with Ada_Program;
package Type_Information is

    --
    --    The use of this system is subject to the software license terms and
    --    conditions agreed upon between Rational and the Customer.
    --
    --               Copyright 1987, 1988, 1989, 1990 by Rational.
    --
    --                          RESTRICTED RIGHTS LEGEND
    --
    --    Use, duplication, or disclosure by the Government is subject to
    --    restrictions as set forth in subdivision (b)(3)(ii) of the Rights in
    --    Technical Data and Computer Software clause at 52.227-7013.
    --
    --
    --                Rational
    --                3320 Scott Boulevard
    --                Santa Clara, California 95054
    --
    --   PROPRIETARY AND CONFIDENTIAL INFORMATION OF RATIONAL;
    --   USE OR COPYING WITHOUT EXPRESS WRITTEN AUTHORIZATION
    --   IS STRICTLY PROHIBITED.  THIS MATERIAL IS PROTECTED AS
    --   AN UNPUBLISHED WORK UNDER THE U.S. COPYRIGHT ACT OF
    --   1976.  CREATED 1987, 1988, 1989, 1990.  ALL RIGHTS RESERVED.
    --


    -- Local Renaming:

    subtype Declaration is Ada_Program.Declaration;
    subtype Name_Expression is Ada_Program.Expression;
    subtype Expression is Ada_Program.Expression;
    subtype Identifier_Reference is Ada_Program.Identifier_Reference;
    subtype Statement is Ada_Program.Statement;
    subtype Task_Specification is Ada_Program.Type_Definition;
    subtype Type_Definition is Ada_Program.Type_Definition;

    subtype Association_Iterator is Ada_Program.Association_Iterator;
    subtype Choice_Iterator is Ada_Program.Choice_Iterator;
    subtype Declarative_Part_Iterator is
       Ada_Program.
          Declaration_Or_Context_Clause_Or_Representation_Clause_Or_Pragma_Iterator;
    subtype Name_Iterator is Ada_Program.Name_Iterator;
    ---------------------------------------------------------------


    type Type_Definition_Kinds is (A_Subtype_Indication,  
                                   An_Enumeration_Type_Definition,  
                                   An_Integer_Type_Definition,  
                                   A_Float_Type_Definition,  
                                   A_Fixed_Type_Definition,  
                                   An_Array_Type_Definition,  
                                   A_Record_Type_Definition,  
                                   An_Access_Type_Definition,  
                                   A_Derived_Type_Definition,  
                                   A_Task_Type_Definition,  
                                   A_Private_Type_Definition,  
                                   A_Limited_Private_Type_Definition,  
                                   Not_A_Type_Definition);

    function Kind (A_Type_Definition : Type_Definition)
                  return Type_Definition_Kinds;

    function Parent_Declaration (Type_Def : Type_Definition) return Declaration;
    -- Returns the declaration associated with the type definition, if
    -- any is available.  Anonymous types for example have no associated
    -- declaration.

    function Base_Type (Type_Def : Type_Definition) return Type_Definition;
    -- Returns the base type of the specified type definition as per LRM 3.3.
    -- All subtypes are constraints applied to some base type.  This function
    -- returns that base type.

    function Type_Structure (Type_Def : Type_Definition) return Type_Definition;
    -- Returns the type structure from which the specified type definition has
    -- been derived.  This function will unwind recursive derivations until the
    -- type definition derives a new representation or is no longer derived.
    -- This function is different from GROUND_TYPE only for enumerations or
    -- records that have derivations with rep specs.

    function Ground_Type (Type_Def : Type_Definition) return Type_Definition;
    -- This function recursively unwinds all type derivations and subtyping
    -- to arrive at a type definition which is neither a derived type or a
    -- subtype.

    function Last_Constraint
                (Type_Def : Type_Definition) return Type_Definition;
    -- This function recursively unwinds subtyping to arrive at a type
    -- definition which is either the base_type or imposes constraints.

    function Is_Predefined (Type_Def : Type_Definition) return Boolean;
    -- returns true if the type definition is one of:
    -- Boolean, Character, String, Integer, Natural, Positive, Float

    function Is_Universal (Type_Def : Type_Definition) return Boolean;
    -- returns true if the type definition is a universal integer,
    -- universal fixed or universal float.

    subtype Subtype_Indication is Type_Definition;
    subtype Enumeration_Type_Definition is Type_Definition;
    subtype Integer_Type_Definition is Type_Definition;
    subtype Float_Type_Definition is Type_Definition;
    subtype Fixed_Type_Definition is Type_Definition;
    subtype Array_Type_Definition is Type_Definition;
    subtype Record_Type_Definition is Type_Definition;
    subtype Access_Type_Definition is Type_Definition;
    subtype Derived_Type_Definition is Type_Definition;
    subtype Task_Type_Definition is Type_Definition;


    ---------------------------------------------------------------
    -- TYPE CONSTRAINTS:

    subtype Type_Constraint is Ada_Program.Element;
    subtype Discrete_Range_Iterator is Ada_Program.Element_Iterator;
    subtype Discriminant_Association_Iterator is Ada_Program.Element_Iterator;

    type Type_Constraint_Kinds is (A_Simple_Range,  
                                   A_Range_Attribute,  
                                   A_Floating_Point_Constraint,  
                                   A_Fixed_Point_Constraint,  
                                   An_Index_Constraint,  
                                   A_Discriminant_Constraint,  
                                   Not_A_Constraint);

    function Constraint_Kind (A_Constraint : Type_Constraint)
                             return Type_Constraint_Kinds;

    function Discrete_Ranges (Of_Index_Constraint : Type_Constraint)
                             return Discrete_Range_Iterator;
    -- Returns the list of Discrete_Range components of an Index_Constraint

    function Discriminant_Associations
                (Of_Discriminant_Constraint : Type_Constraint)
                return Discriminant_Association_Iterator;
    -- Returns the list of discriminant associations of
    -- a Discriminant_Constraint.


    -------------------------------------------------------------------
    -- DISCRETE RANGES:

    subtype Discrete_Range is Ada_Program.Element;  -- LRM 3.6

    type Range_Kinds is (A_Simple_Range,  
                         A_Range_Attribute,  
                         A_Subtype_Indication,  
                         Not_A_Range);

    function Range_Kind (A_Discrete_Range : Discrete_Range) return Range_Kinds;

    subtype Range_Info is Ada_Program.Element;

    procedure Bounds (A_Range : Range_Info;  
                      Lower, Upper : out Expression);
    -- This procedure returns the simple expression for the
    -- upper and lower bounds of a range if one is present
    -- NIL_ELEMENTs otherwise.

    -- Note that range attributes are expressions and can be analyzed
    -- by using the attribute operations in NAMES_AND_EXPRESSIONS.


    ---------------------------------------------------------------
    -- CHOICES:

    subtype Choice is Ada_Program.Element;

    type Choice_Kinds is (A_Simple_Expression,  
                          A_Discrete_Range,  
                          Others_Choice,  
                          An_Identifier_Reference,  
                          Not_A_Choice);

    function Choice_Kind (A_Choice : Choice) return Choice_Kinds;

    function Choice_Expression (A_Choice : Choice) return Expression;

    function Choice_Range (A_Choice : Choice) return Discrete_Range;

    function Choice_Identifier (A_Choice : Choice) return Identifier_Reference;


    ---------------------------------------------------------------
    -- SUBTYPE_INDICATIONS & TYPE_MARKS - LRM 3.3.2

    function Type_Mark (A_Subtype_Indication : Subtype_Indication)
                       return Name_Expression;
    -- Returns the type mark of a subtype indication.
    -- The NAMES_AND_EXPRESSION package provides selectors to do further
    -- decomposition.

    function Constraint (A_Subtype_Indication : Subtype_Indication)
                        return Type_Constraint;
    -- Returns the constraint applied to the subtype indication.  A nil
    -- element is returned if no constraint is present.


    ---------------------------------------------------------------
    -- ENUMERATION TYPES - LRM 3.5.1

    function Enumeration_Literals
                (Enumeration_Type : Enumeration_Type_Definition)
                return Name_Iterator;
    -- Returns a list of the literals declared an enumeration type
    -- declaration.  Each of these elements has a Name.


    ---------------------------------------------------------------
    -- INTEGER TYPES - LRM 3.5.4

    function Integer_Constraint
                (Integer_Type : Integer_Type_Definition) return Range_Info;
    -- Returns the range constraint on the integer type declaration.


    ---------------------------------------------------------------
    -- REAL TYPES - LRM 3.5.6

    function Digits_Accuracy_Definition
                (Floating_Point_Type : Float_Type_Definition) return Expression;
    -- Returns the digits accuracy definition of a floating point type
    -- definition or floating point constraint.

    function Floating_Point_Constraint
                (Floating_Point_Type : Float_Type_Definition) return Range_Info;
    -- Returns the range constraint of a floating point type declaration.

    function Delta_Accuracy_Definition
                (Fixed_Point_Type : Fixed_Type_Definition) return Expression;
    -- Returns the delta accuracy definition of a fixed point type definition
    -- or fixed point constraint.

    function Fixed_Point_Constraint
                (Fixed_Point_Type : Fixed_Type_Definition) return Range_Info;
    -- Returns the range constraint of the fixed point type definition.


    ---------------------------------------------------------------
    -- ARRAY TYPES - LRM 3.6

    function Is_Constrained_Array
                (Array_Type : Array_Type_Definition) return Boolean;

    function Index_Constraints (Constrained_Array_Type : Array_Type_Definition)
                               return Discrete_Range_Iterator;
    -- Returns a list of the discrete range constraints for an
    -- constrained array type declaration.

    function Index_Subtype_Definitions
                (Unconstrained_Array_Type : Array_Type_Definition)
                return Name_Iterator;
    -- Returns a list of the Index_Subtypes (Type_Marks) for an
    -- unconstrained array type declaration.

    function Component_Type (Array_Type : Array_Type_Definition)
                            return Subtype_Indication;
    -- Returns the specification of the array component type.


    ---------------------------------------------------------------
    -- DISCRIMINANTS - LRM 3.7.1

    subtype Type_Definition_Or_Declaration is Ada_Program.Element;
    subtype Discriminant_Iterator is Ada_Program.Element_Iterator;

    function Is_Discriminated
                (A_Type : Type_Definition_Or_Declaration) return Boolean;
    -- This function applies to private, limited private, incomplete or
    -- record types.  It returns True if this type has discriminants.
    -- It may be applied to type declaration to handle the case of
    -- incomplete types.

    function Discriminants (A_Type : Type_Definition_Or_Declaration)
                           return Discriminant_Iterator;
    -- Returns a list of discriminants of the type.  These elements may
    -- then be manipulated with the functions provided in package
    -- Declarations.


    ---------------------------------------------------------------
    -- RECORD TYPES - LRM 3.7

    subtype Record_Component is Ada_Program.Element;
    subtype Record_Component_Or_Pragma_Iterator is Ada_Program.Element_Iterator;
    subtype Variant is Ada_Program.Element;
    subtype Variant_Or_Pragma_Iterator is Ada_Program.Element_Iterator;

    function Record_Components (Record_Type : Record_Type_Definition)
                               return Record_Component_Or_Pragma_Iterator;
    -- Returns a list of the record components of the record declaration.

    type Component_Kinds is (A_Null_Component,  
                             A_Variable_Component,  
                             A_Variant_Part_Component,  
                             Not_A_Component);
    -- A component can be a Variable, NULL or Variant_Part.
    -- A Null_Component is a NIL_ELEMENT.
    -- The operations on Variables can be used to decompose Variable_Components.

    function Component_Kind
                (Component : Record_Component) return Component_Kinds;

    function Associated_Discriminant
                (Variant_Part : Record_Component) return Identifier_Reference;

    function Variant_Item_List (Variant_Part : Record_Component)
                               return Variant_Or_Pragma_Iterator;
    -- Returns a list of variants that make up the record component.

    function Variant_Choices (Variant_Item : Variant) return Choice_Iterator;
    -- Returns a list of the 'WHEN <choice> | <choice>' choices.
    -- Use the above CHOICES queries to extract further information.

    function Inner_Record_Components (Variant_Item : Variant)
                                     return Record_Component_Or_Pragma_Iterator;
    -- Returns a list of the record components of the inner record declaration.
    -- Use Component_Kind to analyze further.


    ---------------------------------------------------------------
    -- ACCESS TYPES - LRM 3.8

    function Access_To (Access_Type : Access_Type_Definition)
                       return Subtype_Indication;
    -- Returns the subtype indication associated with the access type.


    ---------------------------------------------------------------
    -- DERIVED TYPES - LRM 3.4

    function Derived_From (Derived_Type : Derived_Type_Definition)
                          return Subtype_Indication;
    -- Returns the subtype indication associated with the derived type.


    ---------------------------------------------------------------
    -- TASK TYPE DEFINITIONS
    -- LRM Chapter 9

    function Task_Components (Task_Spec : Task_Specification)
                             return Declarative_Part_Iterator;
    -- Returns a list of entry declarations, representation clauses
    -- and pragmas in a task specification. The list is in order of appearance.
    -- The operations on subprogram declarations can be used to
    -- decompose task entries.

    pragma Subsystem (Design_Facility, Closed);
    pragma Module_Name (4, 3577);
    pragma Bias_Key (27);
end Type_Information;
DataMuseum.dk

Rational R1000/400 Tapes

⟦2ce3a0b71⟧ TextFile

Derivation

TextFile
