GNAT IMPLEMENTED FEATURES LIST
Current as of 5/10/94

Here is the list of implemented and not implemented features. A more precise
description of the GNAT system is provided in the file 'gnat-intro', which is
part of the GNAT distribution.

Features added since GNAT version 1.78
=======================================================================
   The list of features has been reorganized into one list according
   to the reference manual. Things listed are implemented unless specifically
   listed as not being implemented.

   Some limited tasking on the Sparc SunOS version only. OS/2 version to 
   follow in a few weeks. (See more detailed list of tasking features below)

   More complete documentation of cross referencer (see gnat-intro for details)

   access discriminants
   derived enumeration types (exception from type Character)

   gnatsplit tool --  to deal with files containing several compilation units.

   gkrunch utility
      8 character file names for RTL files to help GNAT on DOS and OS/2
      running under the FAT.

   Generic Renaming

   Min and Max attributes

   Intrinsic Functions (see section in gnat-intro for more details)

   String Handling
      The Package Strings
      The Package Strings.Maps
      Fixed-Length String Handling
      Bounded-Length String Handling
      Unbounded-Length String Handling
      String-Handling Sets and Mappings

=======================================================================
Status of Features
------------------

The parser is a full Ada9X parser, which implements the Ada 9X language
as defined by version 4.0 of the Draft International Standard. Semantic
analysis and code generation are in constant evolution.

  2. Lexical Elements
     2.1 Character Set
     2.2 Lexical Elements, Separators, and Delimiters
     2.3 Identifiers
     2.4 Numeric Literals
         2.4.1 Decimal Literals
         2.4.2 Based Literals
     2.5 Character Literals
     2.6 String Literals
     2.7 Comments
     2.8 Pragmas
         see Appendix B listing for status of Pragmas
     2.9 Reserved Words

  3. Declarations and Types
  3.1 Declarations
  3.2 Types and Subtypes
      3.2.1 Type Declarations
      3.2.2 Subtype Declarations
      3.3 Objects and Named Numbers
          3.3.1 Object Declarations
          3.3.2 Number Declarations
      3.4 Derived types and Classes
          3.4.1 Derivation Classes
          Derived types from private types (not implemented yet)
      3.5 Scalar Types
           Attribute 'Base 'Min 'Max
          3.5.1 Enumeration Types
             attributes (first, last, range, pos, val, image)
          3.5.2 Character Types
              attributes (first, last, range, pos, val, image)
          3.5.3 Boolean Types
          3.5.4 Integer Types
              attributes (first, last, range, pos, val, image)
              Modular Types
          3.5.7 Floating Point Types
          3.5.8 Operations of Floating Point Types
              attributes -- see the list below attached with Appendix A
   
          3.5.9 Fixed Point Types                (not implemented yet)
          3.5.10 Operations of Fixed Point Types (not implemented yet)

      3.6 Array Types
          3.6.1 Index Constraints and Discrete Ranges
          3.6.2 Operations of Array Types
                attributes first, last, range, length
          3.6.3 String Types
   
      3.7 Discriminants
          3.7.1 Discriminant Constraints
          3.7.2 Operations of Discriminanted Types
   
      3.8 Record types
          3.8.1 Variant Parts and Discrete Choices
   
       3.9 Tagged Types and Type Extensions
          3.9.1 Type Extensions
          3.9.2 Dispatching Operations and Subprograms
          3.9.3 Abstract Types and Subprograms
                attribute 'Class
   
       3.10 Access Types
          3.10.1 Incomplete Type Declarations
          3.10.2 Operations of Access Types
                 Access to subprograms
                  attribute 'Access
  4. Names and Expressions
     4.1 Names
         4.1.1 Indexed Components
         4.1.2 Slices
         4.1.3 Selected Components
         4.2 Literals
     4.3 Aggregates
         4.3.1 Record Aggregates
           aggregates for tagged types (not implemented yet)

         4.3.3 Array Aggregates
     Exponentiation
     Expressions (all forms)
            static and dynamic concatenation
         type conversions  (except array conversions)
         membership tests, conversion with class-wide types
    
   5. Statements
      5.1 Simple and Compound Statements - Sequences of Statements
      5.2 Assignment Statements
      5.3 If Statements
      5.4 Case Statements
      5.5 Loop Statements
      5.6 Block Statements
      5.7 Exit Statements
      5.8 Goto Statements
    
   6. Subprograms
      6.1 Subprogram Declarations
      6.2 Formal Parameter Modes
      6.3 Subprogram Bodies
          (6.3.1 No Conformance Rules yet)
          (6.3.2 No Inline Expansion of Subprograms yet)
      6.4 Subprogram Calls
          6.4.1 Parameter Associations
      6.5 Return Statements
      6.6 Overloading of Operators
     
   7. Packages
      7.1 Package Specifications and Declarations
      7.2 Package Bodies
      7.3 Private Types (no private extension yet)
      7.3.1 Operations of Private Types
      7.4 Deferred Constants
      7.5 Limited Types
      7.6 User-Defined Assignment and Finalization (simple cases)
          7.6.1 Completion and Finalization (simple cases)

   8. Visibility Rules
      8.1 Declarative Region
      8.2 Scope of Declarations
      8.3 Visibility
      8.4 Use Clauses
      8.5 Renaming Declarations
          8.5.1 Object Renaming Declarations
          8.5.2 Exception Renaming Declarations
          8.5.3 Package Renaming Declarations
          8.5.4 Subprogram Renaming Declarations
          8.5.5 Generic Renaming Declarations
      8.6 The Context of Overload Resolution

   9. Tasks and Synchronization (Currently on Sparc SunOS verion only)
      9.1 Task Units and Task Objects (and access to task)
      9.2 Task Execution - Task Activation
      9.3 Task Dependence - Termination of Tasks
      9.4 Protected Units and Protected Objects (not implemented)
      9.5 Intertask Communication
          9.5.1 Protected Subprograms (not implemented)
          9.5.2 Entries and Accept Statements (and entry families)
          9.5.3 Entry Calls
          9.5.4 Requeue Statements (not implemented)
      9.6 Delay Statements, Duration, and Time (not implemented)
      9.7 Select Statements
          9.7.1 Selective Accept
          9.7.2 Timed Entry Calls (not implemented)
          9.7.3 Conditional Entry Calls
          9.7.4 Asynchronous Transfer of Control (not implemented)
      9.8 Abort of a Task - Abort of a Sequence of Statements (not implemented)
      9.9 Task and Entry Attributes
          Callable, Count,  Terminated (not implemented)
      9.10 Shared Variables (not implemented)

      package Calendar (not implemented yet)

   10. Program Structure and Compilation Issues
       10.1 Separate Compilation
           10.1.1 Compilation Units - Library Units
                  (including child units)
           10.1.2 Context Clauses - With Clauses
           10.1.3 Subunits of Compilation Units
           10.1.4 The Compilation Process
           10.1.5 Pragmas and Compilations
           10.1.6 Environment-Level Visibility Rules
        10.2 Program Execution
           10.2.1 Elaboration Control
              (pragmas Elaborate and Elaborate_All)

    11. Exceptions
        11.1 Exception Declarations
        11.2 Exception Handlers
        11.3 Raise Statements
        11.4 Exception Handling
        11.5 Suppressing Checks
        11.6 Exceptions and Optimization

        limited constraint checking on integer/enumeration types under the
        following catagories:
          Index Checks
          Access Checks
          Range Checks
            Initial values in object declarations.
            Assignment
            parameter passing of IN parameters
            type conversions

         No constraint checking on floating point types or modular types.

    12. Generic Units
        12.1 Generic Declarations
        12.2 Generic Bodies
        12.3 Generic Instantiation
             Instantiations of decimal types (not implemented yet)
             Instantiations of modular types (not implemented yet)
        12.4 Formal Objects
        12.5 Formal Types
            12.5.1 Formal Private and Derived Types
            12.5.2 Formal Scalar Types
            12.5.3 Formal Array Types
            12.5.4 Formal Access Types
        12.6 Formal Subprograms
        12.7 Formal Packages

    13. Representation Clauses and Implementation-Dependent Features
       13.1 Representation Items
       13.2 Pragma Pack (not implemented yet)
       13.3 Representation Attributes
            Address and Size supported; other attributes not implemented
           13.3.1 Attribute Definition Clauses
       13.4 Enumeration Representation Clauses (not implemented yet)
       13.5 Record Layout (not implemented yet)
           13.5.1 Storage Place Attributes
           13.5.2 Bit Ordering
           13.5.3 Record Representation Clauses
       13.6 Change of Representation
       13.7 The Package System
           13.7.1 The Package System.Storage_Elements
       13.8 Machine Code Insertions (not implemented yet)
       13.9 Unchecked Type Conversions
           13.9.1 The Valid Attribute (not implemented yet)
       13.10 Unchecked Access Value Creation
       13.11 Storage Management (not implemented yet)
           13.11.1 The Max_Size_In_Storage_Elements Attribute
           13.11.2 Unchecked Storage Deallocation
           13.11.3 Pragma Controlled
       13.12 Pragma Restrictions
       13.13 Representation Determination

    14. Input-Output
       14.1 External Files and File Objects
       14.2 Sequential and Direct Files               (not implemented)
           14.2.1 The Generic Package Sequential_IO   (not implemented)
           14.2.2 File Management                     (not implemented)
           14.2.3 Sequential Input-Output Operations  (not implemented)
           14.2.4 The Generic Package Direct_IO       (not implemented)
           14.2.5 Direct Input-Output Operations      (not implemented)
           14.2.6 The Generic Package Storage_IO

       14.3 Text Input-Output
           14.3.1 The Package Text_IO
           14.3.2 Text File Management
           14.3.3 Default Input and Output Files
           14.3.4 Specification of Line and Page Lengths
           14.3.5 Operations on Columns, Lines, and Pages
           14.3.6 Get and Put Procedures
           14.3.7 Input-Output of Characters and Strings
           14.3.8 Input-Output for Integer
                    implemented for type Integer, and Long_Integer if
                    its size is the same as Integer on the particular machine.
                    Not implemented for Long_Long_Integer.
                  Input-Output for Modular Types (not implemented)
           14.3.9 Input-Output for Real Types
                  Input-Output for Float Types (implemented for Float but
                  not Long_Float and Long_Long_Float)
                  Input-Output for Fixed Point Types (not implemented)
                  Also no bounds checking on result.

                  Decimal_IO (not implemented yet)
           14.3.10 Input-Output for Enumeration Types

       14.4 Wide Text Input-Output                            (not implemented)
       14.5 Stream Input-Output                               (not implemented)
           14.5.1 Stream-Oriented Attributes of Specific Types   ("")
           14.5.2 Stream-Oriented Attributes of Class-Wide Types ("")
           14.5.3 The Package Streams                            ("")
           14.5.4 The Package Streams.Stream_IO                  ("")

       14.6 Exceptions in Input-Output
       14.7 File Sharing
 
    A. Core Language-Defined Attributes

       A.1 Attributes of Floating Point Types
           Ada 83 attributes:
              digits, epsilon, machine_emax, machine_emin, machine_mantissa,
              machine_overflows, machine_radix, machine_rounds, mantissa,
              safe_emax, safe_large, safe_small
           Ada 9X attributes:
              denorm, emax, large, model_emax, model_emin, model_mantissa,
              model_epsilon, model_small, safe_first, safe_last, signed_zeroes

       A.2 Attributes of Fixed Point Typess (not implemented yet)

     B. Core Language-Defined Pragmas
        List
        Page
        Optimize               (not implemented)
        Preelaborate           (not implemented)
        Pure                   (not implemented)
        Inline                 (not implemented)
        Elaborate_All
        Elaboate_Body
        Suppress
        Pack                   (not implemented)
        Controlled             (not implemented)
        Restrictions           (not implemented)
        Import
        Export                 (not implemented)
        Convention
 
     C. Predefined Language Environment
 
        C.1 The Package Standard
        C.2 The Package Ada
        C.3 Character Handling
            C.3.1 The Package Characters
            C.3.2 The Package Characters.Latin_1
        C.4 String Handling
            C.4.1 The Package Strings
            C.4.2 The Package Strings.Maps
            C.4.3 Fixed-Length String Handling
            C.4.4 Bounded-Length String Handling
            C.4.5 Unbounded-Length String Handling
            C.4.6 String-Handling Sets and Mappings
            C.4.7 Wide_String Handling                 (not implemented)
        C.5 The Numerics Packages
            C.5.1 Elementary Functions
            C.5.2 Random Number Generation

      Annex G. Systems Programming   (not implemented yet)
      Annex H. Real-Time Systems     (not implemented yet)
      Annex I. Distributed Systems   (not implemented yet)
      Annex J. Information Systems   (not implemented yet)
      Annex K. Numerics              (not implemented yet)
        A preliminary version of ada.numerics.generics_complex_functions is
        available, though not extensively tested yet.
