GNAT IMPLEMENTED FEATURES LIST
Current as of 08/18/97

Here is the list of implemented and not implemented features, including
a full description of implementation-defined pragmas and attributes. For
information on how to use GNAT, see the GNAT User Guide. For a more
detailed description of the GNAT system, see the GNAT Reference Manual.

Latest features in GNAT version 3.10
====================================

   Generic units are now compiled. This allows proper handling of some
   complex order of elaboration issues. If you are using gnatmake, then
   generics will be compiled automatically. If you are not using
   gnatmake (e.g. you are using a makefile with make), you may need to
   adjust your build procedures to accomodate this new requirement

   A new tool, gnatls, provides capabilities for listing the units in a
   given compilation environment, together with their status.

   A new set of GNAT library units provides full SPITBOL compatible pattern
   matching capabilities, as well as associative tables and some other
   useful SPITBOL-inspired features. See files g-spitbo.ads, g-spipat.ads,
   g-sptabo.ads, g-sptain.ads, g-stunst.ads.

   A new GNAT unit g-debuti.ads provides some standard debugging utilities
   and capabilities.

   A new Ada child, see a-suteio.ads, provides Text_IO capabilities for
   the Ada.Strings.Unbounded.Unbounded_String type.

   A function File_Exists has been added to GNAT.IO_Aux to test if a
   file exists (without having to open it).

   Deferred constants may now be completed using pragma Import so that
   the value of the constant is supplied by an external unit in some
   language other than Ada.

   A number of missing semantic checks have been added. Most notably, GNAT
   now correctly requires conversions from the anonymous type corresponding
   to an access parameter to a named access type and properly disallows use
   of null literals for anonymous access types.

   A new set of warning messages now allows full diagnosis of possible access
   before elaboration problems at compile time. By systematically eliminating
   the warning messages, it is feasible to ensure that a large application
   cannot possibly run into an access before elaboration, and to ensure this
   in a portable manner.

   The binder now generates a far more friendly elaboration order. In the
   default mode, it guarantees a successful elaboration order, and gives
   an error message if this guarantee is not possible.

   A new attribute, applicable to library units, x'elaborated, returns a
   Boolean value indicating whether X has been elaborated. It is always
   true for preelaborated, pure and predefined units, and also for units
   for which Elaborate_Body is specified. Otherwise it determines if the
   body of the specified unit has been elaborated yet. This is primarily
   intended for use by the compiler itself in checking for access before
   elaboration, but it can be used by user programs.

   The error messages for the case of an operator with incorrectly typed
   operands have been enhanced to give more information about the errors.

   Two tools, gnatpsta and gnatpsys, can be used to generate source language
   representations of packages Standard and System, including all relevant
   constants in numeric form. These are generated by actually looking at
   what the values are (so they are guaranteed to give correct results).

   A new convention Stubbed is available. A stubbed subprogram will cause
   Program_Error to be raised on any call. Furthermore, if you use convention
   Stubbed in a pragma Import, then no body need be supplied for the
   subprogram.

   Entry families constrained by task discriminants are now implemented (this
   combination of features had been overlooked, and was not yet tested by the
   ACVC suite).

   A new function GNAT.OS_Lib.Is_Writable_File determines if a given file
   exists and is writable.

   Pragma Discard_Names is now respected for enumeration types, so that the
   image tables are actually discarded if the pragma applies. 

   A new feature in gnatmake causes any write protected ali files to be
   treated like system files, i.e. when using -f, they will not be recompiled
   unless the -a switch is also used. This allows user libraries to have the
   same status as the Ada runtime library.

   A new switch (-i for in place) for gnatmake requests that gnatmake put
   ali files and object files back in the same place they were found, so
   that gnatmake can be used to automatically update a multi-directory
   program structure.

   Ada.Task_Identification.Image now returns a meaningful image for a task
   based on the variable name used to create the task. This name is also
   available while debugging (via the call interface). The generation of
   these names can be suppressed by using pragma Discard_Names with no
   argument.

   The gnatchop utility now detects and rejects attempts to generate more
   than one copy of a file with the same name unless -w is specified. This
   is particularly useful when using file name krunching, because it means
   that cases of multiple units crunching to the same name are detected.

   In the Solaris version, foreign threads (those created outside Ada) are
   now recognized automatically and converted to Ada tasks for proper
   treatment by the Ada runtime as Ada tasks.

   The switch -gnatN now properly enables possible inlining for all
   subprograms, as though pragma Inline had been specified for every
   possible subprogram. This may improve code quality, but note that
   very large amounts of memory may be needed to compile with this switch.

   The Ada aware features of GDB have been substantially enhanced. GDB now
   understands more Ada data structures. A new command break exception allows
   convenient breakpoints on specified or all exceptions. On many targets,
   tasking handling is greatly improved. A new command info tasks lists the
   status of all tasks in the system. For details see the new GDB manual,
   included in the release, that contains an enhanced section on debugging
   of Ada code.

   Two choices of threads libraries are now offered on Solaris and Linux.
   On Solaris there is a choice of using native Solaris threads or FSU
   threads with the default being native threads.
   On Linux there is a choice of using FSU threads or native Linuxthreads
   with the default being FSU threads.

   On AIX there is a timeslicing option for tasking using the pragma
   Time_Slice. This is using FSU threads.

   The GNAT runtime library now consists of a single archive file, libgnat.a,
   rather than a collection of individual object modules as was the case
   in previous versions of GNAT.

   The adainclude directory is now located at the same level as the adalib
   directory, and the GNU include directory. The adainclude directory was
   formerly at the same level as the bin directory.

Latest features in GNAT version 3.09
====================================

   (see complete list for 3.08, since for all cases except NT, 3.08 was
    skipped in the version sequencing)

   A new pragma Pure_Function allows an individual function to be specified
   as Pure, see documentation in the GNAT reference manual for full details.

   Address clauses now are much more flexible. In previous versions, GNAT
   rejected any address clause not required to be implemented, in accordance
   with the implementation permission in section 13.1(22) of the RM. Now
   far more cases are accepted and correctly processed as follows:

      1. All address clauses for variables of any elementary type (i.e.
         scalars and access types) are permitted.

      2. All address clauses for non-initialized variables are permitted

      3. An address clause for an initialized variable of a composite
         type is accepted if any calls to operators or functions are to
         pure subprograms (i.e. either declared in a pure unit, or declared
         pure using the pragma Pure_Function), and all operands are literals,
         or constants defined prior to the variable to which the address
         clause applies.

   In practice this should mean that nearly all address clauses are now
   accepted. Note that To_Address is a pure function.

   For the VMS version only, pragma AST_Entry and the corresponding
   attribute are now fully implemented.

   Exception_Message now returns the name of the exception, together with
   the exception message if there is one (in previous versions of GNAT,
   this function yielded a null string).

Latest features in GNAT version 3.08
====================================

   Unchecked conversion is now allowed for all definite types, including
   discriminated records with default discriminants. In addition, it is
   now permissible to convert from an unconstrained array type (but still
   not allowed to convert to an unconstrained array type, since no bounds
   information would be available).

   The storage management in the compiler has been considerably improved
   allowing larger programs to compile in a given virtual memory size.

   The pragmas Linker_Alias, Linker_Section and Weak_External have been
   added that give full access to the corresponding gcc features. With these
   additions, GNAT has all the capabilities of GNU-C with regard to specifying
   implementation dependent attributes.

   The attributes Large and Safe_Large now apply to fixed-point types as well
   as to floating-point types. With these additions, GNAT now implements the
   full set of Ada 83 attributes.

   The pragma Complex_Representation specifies that a record of two floats
   is to be laid out the same way as a complex value in Fortran.

   Biased representation is implemented for all discrete types. This means
   that values are stored with the lower bound value subtracted. For instance
   the range 10 .. 13 can be fit into 2 bits, with 10 .. 13 represented as
   0 .. 2. Biased representation can be specified for subtypes, using the
   Size or Value_Size attribute to specify a size that requires biasing, or
   for objects, by specifying size, or for components, by specifying the
   component size using a component clause, and finally for array components
   by specifying a component size for the array. Biased representation is
   never selected by default. The only way that biased representation is used
   is if a size specification would otherwise have been rejected, but a biased
   representation can allow the specified size to be honored.

   The binder has been enhanced to generate more a more friendly binding
   order, i.e. one more likely to avoid access before elaboration. In
   addition a new switch -h for the binder (-h for horrible) chooses a
   deliberately bad elaboration order, which can be useful for testing
   code that is supposed to be portable.

   The Version and Body_Version attributes are no longer based on time stamps,
   but rather on the contents of the source files themselves. This has two
   important advantages. First the values are the same on different targets,
   facilitating heterogenous distribution. Second, trivial changes (changes
   in layout, capitalization of keywords/identifiers, or comments) do not
   affect the version number.

   The binder now uses version numbers as well as time stamps. This means
   that the binder will not force recompilation for trivial changes (as
   described above), giving a limited form of smart recompilation.

Latest features in GNAT version 3.07
====================================

   GNAT now checks for the case of a body file present when the spec does
   not require a body. GNAT always diagnosed the error when the body was
   compiled, but if only the spec was compiled, the suspicious body was
   ignored. The presence of a body file when no body is allowed is now
   considered an error in Ada 95 mode, and a warning in Ada 83 mode.

   Packed arrays with bounds depending on a discriminant now work correctly

   The DEC pragmas have been implemented. Those of interest to GNAT ports
   in general are as follows (see below for full documentation)
       Common_Object
       Component_Alignment
       Export_Function
       Export_Object
       Export_Procedure
       Export_Valued_Procedure
       Import_Function
       Import_Object
       Import_Procedure
       Import_Valued_Procedure
       Suppress_All

   The DEC attributes have been implemented. Those of interest to GNAT ports
   in general are as follows (see below for full documentation)
       Bit
       Machine_Size
       Null_Parameter
       Type_Class

   Attribute Mechanism_Code allows determination of the parameter passing
   mechanism chosen by GNAT, as possibly controlled by the Import, Export
   and C_Pass_By_Copy pragmas.

   Pragma Extend_System allows transparent extension of package System to
   accomodate definitions from other implementations of Ada.

   Machine code insertions have been completely implemented. A new section
   in gnatinfo.txt describes the use. Both code statements as such, and
   also intrinsic calls are available. The latter allow interspersing
   machine instructions in Ada code. Inlining of machine code procedures
   is fully supported.

   The pragma C_Pass_By_Copy is implemented in a manner that is completely
   compatible with the Intermetrics implementation of this pragma.

   The default mechanism for passing records to foreign convention subprograms
   is now by-reference. This can be modified by either use of one of the
   DEC extended Import/Export pragmas, or by use of the C_Pass_By_Copy pragma.

   Further extended support for representation clauses, including more cases
   of misaligned fields, and non-standard layouts. Record representation
   clauses no longer require that the position of all fields be specified.

   Pragma Error_Monitoring has been removed. This pragma was not used and had
   a number of conceptual and implementation problems.

Latest features in GNAT version 3.06
====================================
   This version is available only from SGI, and is an intermediate version
   between the ACT 3.05 and 3.07 releases. Consult SGI for further details

Latest features in GNAT version 3.05
====================================

   Implement tight array packing for component sizes up to 31 bits
   Relaxation of alignment and size rules allow more record rep clauses
    to be accepted and correctly processed.
   ACVC compliance for SGI matches that of the official validation

Latest features in GNAT version 3.04
====================================

   GNAT attributes mantissa, safe_small for fixed points
   GNAT attribute small for floating point
   These attributes correspond to attributes defined in Ada 83.

   gnatlink (new utility program)

   pragma Unchecked_Union is fully implemented (see end of this document)

   More efficient execution of programs containing exception handlers
   (especially on Sun Sparc)

   Many new options to gnatmake: (see gnatinfo.txt for details)
   -aI -aO, -jnum, -k, -l, -o

   New Source & Library search path switches: (see gnatinfo.txt for details)
   -aLdir, -Adir, -aOdir, -aIdir, -Idir, -I-, -Ldir

   The DOS version has been migrated to DJGPP v2.
   Tasking is now fully functional in the DOS version.
   "Real" memory problems in the DOS version have been alleviated.

   New warnings for some infinite recursion cases

   When an Assert_Failure exception is raised, the exception is raised
   with a message, either the file name and line number by default of
   the pragma Assert, or the string explicitly supplied as the second
   parameter.

   The restriction names No_GNAT_Attributes and No_GNAT_Pragmas have
   been renamed No_Implementation_Attributes and No_Implementation_Pragmas.

   Record Representation Clauses which do not specify representations for
   all components (partial rep clauses) are now accepted by GNAT.

   Packed arrays of records are now implemented.

   The Size attribute is now handled as specified in the RM. This means
   that the value of 'Size will often be different from what it was
   before and what it was in Ada 83. Two new attributes Object_Size
   and Value_Size have been added to provide additional control.

Latest features in GNAT version 3.03
====================================

    Implement packing of multidimensional arrays

    Get_Immediate now follows the implementation advice and works as intended
    (for SGI IRIX, Sparc SunOS/Solaris, Alpha OSF1, IBM OS/2 and Linux)

    The task attributes package is now fully functional

    Warnings for unset variables, and possible access before initialization

    pragma Warnings (On | Off) allows more detailed control of warnings
    pragma Source_File_Name allows specifying non-standard file names
    pragma No_Return allows specifying a procedure that never returns
    pragma Attach_Handler    (implemented on Sparc SunOS and Sparc Solaris only)
    pragma Interrupt_Handler (implemented on Sparc SunOS and Sparc Solaris only)

Latest features in GNAT version 3.01
====================================

    pragma Normalize_Scalars
    Ada.Text_IO.Editing
    Ada.Wide_Text_IO.Editing
    Incomplete types declared in the private part that are
     completed in the package body as unconstrained arrays.
    Full implementation of stream attributes, including the
     dispatching cases for class wide types.
    Private protected operations
    Pointers to unconstrained arrays may be double or single length. Double
     ("fat") is the default size (e.g. 64 on SGI), but rep clauses or a
     foreign convention will force them to single length.
    Aggregates for composite Types with controlled components
    Objects of type with unknown discriminants
    pragma Queuing_Policy
    pragma Source_File_Name (GNAT specific)
    True multiprocessing on Sparc Solaris

Latest features in GNAT version 2.07
====================================

    Discriminant checks
    Package Ada.Exceptions
    External_Tag attribute
    Identity attribute
    Range Checks on the elaboration of a subtype_indication
    Duration is an ordinary fixed-point type with delta of one nanosecond
    Package Interfaces.COBOL
    Protected subprogram pointers
    Caller attribute
    Restriction pragma
    All restrictions in real time annex
    All restrictions in safety and security annex
    Higher resolution clocks for tasking on SunOS/Solaris

Latest features in GNAT version 2.06
====================================

    Requeue Statement involving task entries
    inter-unit inlining (enabled by -O2 -gnatn)
    aggregates for simple controlled types

Latest features in GNAT version 2.05
====================================

    Elaboration Checks
    A new switch -gnati8 specifies the use of IBM PC Code Page 850 for
     the identifier character set (this is Latin-1 a la IBM PC)
    Protected entry families
    Ada.Synchronous_Task_Control
    Attribute Storage_Pool
    Packed arrays (including packed boolean arrays)
    Accessibility checks
    -I for specifying source and object path (see gnatinfo.txt for details)
    Conditional protected entry calls
    Delay until inside select statements

Latest features in GNAT version 2.04
====================================

    GNATMAKE utility (see gnatinfo.txt for details)
    Pragma Export
    Ada.Streams.Stream_IO
    Attribute Definite
    Interrupt entries
    Input-Output for Modular Types
    Input-Output for Decimal Types
    Input-Output for Integer for type Long_Long_Integer.
    The following are now implemented in package Ada.Text_IO
      Flush
      Look_Ahead
      Get_Immediate
    Text_IO.Complex_IO
    Text_IO.Text_Streams
    Wide_Text_IO
    Wide_Text_IO.Complex_IO
    Wide_Text_IO.Text_Streams

    Note: All the I/O packages have been rewritten from the
    ground up for this release, and should completely implement all
    features of the RM. To get file sharing, allowed only if the
    files are for the same I/O package and same mode, use a form
    parameter shared=yes.

================================
= Description of GNAT Pragmas ==
================================

  See GNAT reference manual for full list of implementation defined pragmas

==========================================
= Description of GNAT-defined Attributes =
==========================================

  See GNAT reference manual for a full list of implementation defined
  attributes.

  Note that GNAT suppports the full set of Ada 83 attributes that are not
  defined in Ada 95, including the extension of Small for floating-point
  types.

