home *** CD-ROM | disk | FTP | other *** search
/ Fresh Fish 6 / FreshFish_September1994.bin / bbs / gnu / gnat-1.80-src.lha / GNU / src / amiga / gnat-1.80 / features < prev    next >
Encoding:
Text File  |  1994-06-23  |  14.0 KB  |  372 lines
  1. GNAT IMPLEMENTED FEATURES LIST
  2. Current as of 5/10/94
  3.  
  4. Here is the list of implemented and not implemented features. A more precise
  5. description of the GNAT system is provided in the file 'gnat-intro', which is
  6. part of the GNAT distribution.
  7.  
  8. Features added since GNAT version 1.78
  9. =======================================================================
  10.    The list of features has been reorganized into one list according
  11.    to the reference manual. Things listed are implemented unless specifically
  12.    listed as not being implemented.
  13.  
  14.    Some limited tasking on the Sparc SunOS version only. OS/2 version to 
  15.    follow in a few weeks. (See more detailed list of tasking features below)
  16.  
  17.    More complete documentation of cross referencer (see gnat-intro for details)
  18.  
  19.    access discriminants
  20.    derived enumeration types (exception from type Character)
  21.  
  22.    gnatsplit tool --  to deal with files containing several compilation units.
  23.  
  24.    gkrunch utility
  25.       8 character file names for RTL files to help GNAT on DOS and OS/2
  26.       running under the FAT.
  27.  
  28.    Generic Renaming
  29.  
  30.    Min and Max attributes
  31.  
  32.    Intrinsic Functions (see section in gnat-intro for more details)
  33.  
  34.    String Handling
  35.       The Package Strings
  36.       The Package Strings.Maps
  37.       Fixed-Length String Handling
  38.       Bounded-Length String Handling
  39.       Unbounded-Length String Handling
  40.       String-Handling Sets and Mappings
  41.  
  42. =======================================================================
  43. Status of Features
  44. ------------------
  45.  
  46. The parser is a full Ada9X parser, which implements the Ada 9X language
  47. as defined by version 4.0 of the Draft International Standard. Semantic
  48. analysis and code generation are in constant evolution.
  49.  
  50.   2. Lexical Elements
  51.      2.1 Character Set
  52.      2.2 Lexical Elements, Separators, and Delimiters
  53.      2.3 Identifiers
  54.      2.4 Numeric Literals
  55.          2.4.1 Decimal Literals
  56.          2.4.2 Based Literals
  57.      2.5 Character Literals
  58.      2.6 String Literals
  59.      2.7 Comments
  60.      2.8 Pragmas
  61.          see Appendix B listing for status of Pragmas
  62.      2.9 Reserved Words
  63.  
  64.   3. Declarations and Types
  65.   3.1 Declarations
  66.   3.2 Types and Subtypes
  67.       3.2.1 Type Declarations
  68.       3.2.2 Subtype Declarations
  69.       3.3 Objects and Named Numbers
  70.           3.3.1 Object Declarations
  71.           3.3.2 Number Declarations
  72.       3.4 Derived types and Classes
  73.           3.4.1 Derivation Classes
  74.           Derived types from private types (not implemented yet)
  75.       3.5 Scalar Types
  76.            Attribute 'Base 'Min 'Max
  77.           3.5.1 Enumeration Types
  78.              attributes (first, last, range, pos, val, image)
  79.           3.5.2 Character Types
  80.               attributes (first, last, range, pos, val, image)
  81.           3.5.3 Boolean Types
  82.           3.5.4 Integer Types
  83.               attributes (first, last, range, pos, val, image)
  84.               Modular Types
  85.           3.5.7 Floating Point Types
  86.           3.5.8 Operations of Floating Point Types
  87.               attributes -- see the list below attached with Appendix A
  88.    
  89.           3.5.9 Fixed Point Types                (not implemented yet)
  90.           3.5.10 Operations of Fixed Point Types (not implemented yet)
  91.  
  92.       3.6 Array Types
  93.           3.6.1 Index Constraints and Discrete Ranges
  94.           3.6.2 Operations of Array Types
  95.                 attributes first, last, range, length
  96.           3.6.3 String Types
  97.    
  98.       3.7 Discriminants
  99.           3.7.1 Discriminant Constraints
  100.           3.7.2 Operations of Discriminanted Types
  101.    
  102.       3.8 Record types
  103.           3.8.1 Variant Parts and Discrete Choices
  104.    
  105.        3.9 Tagged Types and Type Extensions
  106.           3.9.1 Type Extensions
  107.           3.9.2 Dispatching Operations and Subprograms
  108.           3.9.3 Abstract Types and Subprograms
  109.                 attribute 'Class
  110.    
  111.        3.10 Access Types
  112.           3.10.1 Incomplete Type Declarations
  113.           3.10.2 Operations of Access Types
  114.                  Access to subprograms
  115.                   attribute 'Access
  116.                  accessibility checks (not implemented yet)
  117.   4. Names and Expressions
  118.      4.1 Names
  119.          4.1.1 Indexed Components
  120.          4.1.2 Slices
  121.          4.1.3 Selected Components
  122.          4.2 Literals
  123.      4.3 Aggregates
  124.          4.3.1 Record Aggregates
  125.            aggregates for tagged types (not implemented yet)
  126.  
  127.          4.3.3 Array Aggregates
  128.      Exponentiation
  129.      Expressions (all forms)
  130.             static and dynamic concatenation
  131.          type conversions  (except array conversions)
  132.          membership tests, conversion with class-wide types
  133.     
  134.    5. Statements
  135.       5.1 Simple and Compound Statements - Sequences of Statements
  136.       5.2 Assignment Statements
  137.       5.3 If Statements
  138.       5.4 Case Statements
  139.       5.5 Loop Statements
  140.       5.6 Block Statements
  141.       5.7 Exit Statements
  142.       5.8 Goto Statements
  143.     
  144.    6. Subprograms
  145.       6.1 Subprogram Declarations
  146.       6.2 Formal Parameter Modes
  147.       6.3 Subprogram Bodies
  148.           (6.3.1 No Conformance Rules yet)
  149.           (6.3.2 No Inline Expansion of Subprograms yet)
  150.       6.4 Subprogram Calls
  151.           6.4.1 Parameter Associations
  152.       6.5 Return Statements
  153.       6.6 Overloading of Operators
  154.      
  155.    7. Packages
  156.       7.1 Package Specifications and Declarations
  157.       7.2 Package Bodies
  158.       7.3 Private Types (no private extension yet)
  159.       7.3.1 Operations of Private Types
  160.       7.4 Deferred Constants
  161.       7.5 Limited Types
  162.       7.6 User-Defined Assignment and Finalization (simple cases)
  163.           7.6.1 Completion and Finalization (simple cases)
  164.  
  165.    8. Visibility Rules
  166.       8.1 Declarative Region
  167.       8.2 Scope of Declarations
  168.       8.3 Visibility
  169.       8.4 Use Clauses
  170.       8.5 Renaming Declarations
  171.           8.5.1 Object Renaming Declarations
  172.           8.5.2 Exception Renaming Declarations
  173.           8.5.3 Package Renaming Declarations
  174.           8.5.4 Subprogram Renaming Declarations
  175.           8.5.5 Generic Renaming Declarations
  176.       8.6 The Context of Overload Resolution
  177.  
  178.    9. Tasks and Synchronization (Currently on Sparc SunOS verion only)
  179.       9.1 Task Units and Task Objects (and access to task)
  180.       9.2 Task Execution - Task Activation
  181.       9.3 Task Dependence - Termination of Tasks
  182.       9.4 Protected Units and Protected Objects (not implemented)
  183.       9.5 Intertask Communication
  184.           9.5.1 Protected Subprograms (not implemented)
  185.           9.5.2 Entries and Accept Statements (and entry families)
  186.           9.5.3 Entry Calls
  187.           9.5.4 Requeue Statements (not implemented)
  188.       9.6 Delay Statements, Duration, and Time (not implemented)
  189.       9.7 Select Statements
  190.           9.7.1 Selective Accept
  191.           9.7.2 Timed Entry Calls (not implemented)
  192.           9.7.3 Conditional Entry Calls
  193.           9.7.4 Asynchronous Transfer of Control (not implemented)
  194.       9.8 Abort of a Task - Abort of a Sequence of Statements (not implemented)
  195.       9.9 Task and Entry Attributes
  196.           Callable, Count,  Terminated (not implemented)
  197.       9.10 Shared Variables (not implemented)
  198.  
  199.       package Calendar (not implemented yet)
  200.  
  201.    10. Program Structure and Compilation Issues
  202.        10.1 Separate Compilation
  203.            10.1.1 Compilation Units - Library Units
  204.                   (including child units)
  205.            10.1.2 Context Clauses - With Clauses
  206.            10.1.3 Subunits of Compilation Units
  207.            10.1.4 The Compilation Process
  208.            10.1.5 Pragmas and Compilations
  209.            10.1.6 Environment-Level Visibility Rules
  210.         10.2 Program Execution
  211.            10.2.1 Elaboration Control
  212.               (pragmas Elaborate and Elaborate_All)
  213.  
  214.     11. Exceptions
  215.         11.1 Exception Declarations
  216.         11.2 Exception Handlers (package Ada.Exceptions not implemented yet)
  217.         11.3 Raise Statements
  218.         11.4 Exception Handling
  219.         11.5 Suppressing Checks
  220.         11.6 Exceptions and Optimization
  221.  
  222.         limited constraint checking on integer/enumeration types under the
  223.         following catagories:
  224.           Index Checks
  225.           Access Checks
  226.           Range Checks
  227.             Initial values in object declarations.
  228.             Assignment
  229.             parameter passing of IN parameters
  230.             type conversions
  231.  
  232.          No constraint checking on floating point types or modular types.
  233.  
  234.     12. Generic Units
  235.         12.1 Generic Declarations
  236.         12.2 Generic Bodies
  237.         12.3 Generic Instantiation
  238.              Instantiations of decimal types (not implemented yet)
  239.              Instantiations of modular types (not implemented yet)
  240.         12.4 Formal Objects
  241.         12.5 Formal Types
  242.             12.5.1 Formal Private and Derived Types
  243.             12.5.2 Formal Scalar Types
  244.             12.5.3 Formal Array Types
  245.             12.5.4 Formal Access Types
  246.         12.6 Formal Subprograms
  247.         12.7 Formal Packages
  248.  
  249.     13. Representation Clauses and Implementation-Dependent Features
  250.        13.1 Representation Items
  251.        13.2 Pragma Pack (implemented for records but not arrays)
  252.        13.3 Representation Attributes
  253.             Address and Size supported; other attributes not implemented
  254.            13.3.1 Attribute Definition Clauses
  255.        13.4 Enumeration Representation Clauses (not implemented yet)
  256.        13.5 Record Layout (not implemented yet)
  257.            13.5.1 Storage Place Attributes
  258.            13.5.2 Bit Ordering
  259.            13.5.3 Record Representation Clauses
  260.        13.6 Change of Representation
  261.        13.7 The Package System
  262.            13.7.1 The Package System.Storage_Elements
  263.        13.8 Machine Code Insertions (not implemented yet)
  264.        13.9 Unchecked Type Conversions
  265.            13.9.1 The Valid Attribute (not implemented yet)
  266.        13.10 Unchecked Access Value Creation
  267.        13.11 Storage Management (not implemented yet)
  268.            13.11.1 The Max_Size_In_Storage_Elements Attribute
  269.            13.11.2 Unchecked Storage Deallocation
  270.            13.11.3 Pragma Controlled
  271.        13.12 Pragma Restrictions
  272.        13.13 Representation Determination
  273.  
  274.     14. Input-Output
  275.        14.1 External Files and File Objects
  276.        14.2 Sequential and Direct Files               (not implemented)
  277.            14.2.1 The Generic Package Sequential_IO   (not implemented)
  278.            14.2.2 File Management                     (not implemented)
  279.            14.2.3 Sequential Input-Output Operations  (not implemented)
  280.            14.2.4 The Generic Package Direct_IO       (not implemented)
  281.            14.2.5 Direct Input-Output Operations      (not implemented)
  282.            14.2.6 The Generic Package Storage_IO
  283.  
  284.        14.3 Text Input-Output
  285.            14.3.1 The Package Text_IO
  286.            14.3.2 Text File Management
  287.            14.3.3 Default Input and Output Files
  288.            14.3.4 Specification of Line and Page Lengths
  289.            14.3.5 Operations on Columns, Lines, and Pages
  290.            14.3.6 Get and Put Procedures
  291.            14.3.7 Input-Output of Characters and Strings
  292.            14.3.8 Input-Output for Integer
  293.                     implemented for type Integer, and Long_Integer if
  294.                     its size is the same as Integer on the particular machine.
  295.                     Not implemented for Long_Long_Integer.
  296.                   Input-Output for Modular Types (not implemented)
  297.            14.3.9 Input-Output for Real Types
  298.                   Input-Output for Float Types (implemented for Float but
  299.                   not Long_Float and Long_Long_Float)
  300.                   Input-Output for Fixed Point Types (not implemented)
  301.                   Also no bounds checking on result.
  302.  
  303.                   Decimal_IO (not implemented yet)
  304.            14.3.10 Input-Output for Enumeration Types
  305.  
  306.        14.4 Wide Text Input-Output                            (not implemented)
  307.        14.5 Stream Input-Output                               (not implemented)
  308.            14.5.1 Stream-Oriented Attributes of Specific Types   ("")
  309.            14.5.2 Stream-Oriented Attributes of Class-Wide Types ("")
  310.            14.5.3 The Package Streams                            ("")
  311.            14.5.4 The Package Streams.Stream_IO                  ("")
  312.  
  313.        14.6 Exceptions in Input-Output
  314.        14.7 File Sharing
  315.  
  316.     A. Core Language-Defined Attributes
  317.  
  318.        A.1 Attributes of Floating Point Types
  319.            Ada 83 attributes:
  320.               digits, epsilon, machine_emax, machine_emin, machine_mantissa,
  321.               machine_overflows, machine_radix, machine_rounds, mantissa,
  322.               safe_emax, safe_large, safe_small
  323.            Ada 9X attributes:
  324.               denorm, emax, large, model_emax, model_emin, model_mantissa,
  325.               model_epsilon, model_small, safe_first, safe_last, signed_zeroes
  326.  
  327.        A.2 Attributes of Fixed Point Typess (not implemented yet)
  328.  
  329.      B. Core Language-Defined Pragmas
  330.         List
  331.         Page
  332.         Optimize               (not implemented)
  333.         Preelaborate           (not implemented)
  334.         Pure                   (not implemented)
  335.         Inline                 (not implemented)
  336.         Elaborate_All
  337.         Elaboate_Body
  338.         Suppress
  339.         Pack                   (not implemented)
  340.         Controlled             (not implemented)
  341.         Restrictions           (not implemented)
  342.         Import
  343.         Export                 (not implemented)
  344.         Convention
  345.  
  346.      C. Predefined Language Environment
  347.  
  348.         C.1 The Package Standard
  349.         C.2 The Package Ada
  350.         C.3 Character Handling
  351.             C.3.1 The Package Characters
  352.             C.3.2 The Package Characters.Latin_1
  353.         C.4 String Handling
  354.             C.4.1 The Package Strings
  355.             C.4.2 The Package Strings.Maps
  356.             C.4.3 Fixed-Length String Handling
  357.             C.4.4 Bounded-Length String Handling
  358.             C.4.5 Unbounded-Length String Handling
  359.             C.4.6 String-Handling Sets and Mappings
  360.             C.4.7 Wide_String Handling                 (not implemented)
  361.         C.5 The Numerics Packages
  362.             C.5.1 Elementary Functions
  363.             C.5.2 Random Number Generation
  364.  
  365.       Annex G. Systems Programming   (not implemented yet)
  366.       Annex H. Real-Time Systems     (not implemented yet)
  367.       Annex I. Distributed Systems   (not implemented yet)
  368.       Annex J. Information Systems   (not implemented yet)
  369.       Annex K. Numerics              (not implemented yet)
  370.         A preliminary version of ada.numerics.generics_complex_functions is
  371.         available, though not extensively tested yet.
  372.