====================================================
GNAT NEW FEATURES LIST for Versions 3.13 and Earlier
====================================================

Copyright (c) 2000, Ada Core Technologies


This file contains a list of the features in versions of
GNAT up to and including version 3.13. A full description
of all GNAT features can be found in the GNAT User Guide
and the GNAT Reference Manual.

Latest features in GNAT version 3.13a (4.13a-v)
===============================================

  GNAT version 3.13a includes the first release of GLIDE, the new integrated
  development environment that builds on and extends our previous tools work.
  GLIDE provides a fully integrated editor and debugger environment, and
  supports multiple graphical debuggers, including a new improved gdbtk
  and a version of ddd adapted for use with GNAT.

  The GLIDE editor (which uses ada-mode for Emacs) includes many
  new features. Among them are:

     Gnatdist configuration files are automatically edited in Ada-mode.

     Support for big projects with hundreds of directories by getting rid of
     the command line length limit on some systems, as well as easier ways to
     enter a long list of directories in the project file.

     The cross-references to and within the standard runtime are
     automatically handled.

     Full contextual menus are provided with the right mouse button.

     Multiple exception files for automatic casing can now be specified, for
     instance one system-wide, one project-wide and a user-specific one.

     The project file editor is displayed through tabbed dialogs, with full
     contextual help on the fields.

     Indentation is now easier to configure since the ada-mode can explain
     which variable was used to indent a specific line.

  The package GNAT.Regpat has been enhanced to provide an almost full support
  for Perl-like regular expressions, including several new constructs.

  On unix systems, it is now possible to install GNAT at any location
  without setting any environment variable.

  A warning is issued for the use of Import/Export_Valued_Procedure if
  the default Ada convention is used, since it makes no sense to use
  convention Ada for such a procedure, the only point of the feature
  is to interface with foreign convention procedures. This prevents
  hard to find errors resulting in incorrect behavior at run time.

  A new style switch -gnatyn (STANDARD_CASING in the VMS version) checks
  that all entities from package Standard are cased in a manner consistent
  with the way this package is presented in the Ada Reference Manual.

  A simple way of interfacing with C++ is now documented in the user's
  guide and has been added to the examples directory.

  A new gnatmake switch (-s) causes recompilation of a file if its
  compilation options (e.g. optimization level) have changed.

  A new gnatdll switch (-k) removed Stdcall @nn suffix from the
  import library's exported names.

  A new GNAT library package (GNAT.Float_Control in file g-flocon.ads)
  provides an interface for resetting the floating-point processor into
  the required mode.

  A new GNAT library package (GNAT.Exceptions in file g-except.ads)
  provides a mechanism for raising predefined exceptions with messages
  from Pure units.

  A new pragma, Suppress_Debug_Info, provides for suppressing debugging
  information for selected entities.

  Additional optimization circuits in aggregate handling result in many
  more aggregate assignments being handled in place, instead of generating
  an extra temporary.

  The GNAT Reference manual now contains summary documentation of the GNAT
  library routines. The primary documentation is still in the specs of the
  relevant packages, but the document summarizes what facilities are
  available.

  The package Ada.Strings.Unbounded.Text_IO is now documented in the
  GNAT reference manual.

  A new package Ada.Strings.Wide_Unbounded.Wide_Text_IO has been added
  to provide Wide_Text_IO facilities for Unbounded_Wide_String.

  The -mlongcall switch as well as the __shortcall__ attribute is now provided
  on all powerpc ports. See the GCC documentation for more details.

  The Linker_Options pragma can now take multiple options, which are
  guaranteed to apear in the sequence given in the pragma.

  The gnatbind -E option (stack tracebacks) is now supported under
  Windows NT.

  New switches -gnatwa and -gnatwA are available to turn all
  optional warnings on/off respectively.

  The syntax for the -gnatw warning switch now allows a string of
  options after the w. For example -gnatwaLe turns on all optional
  warnings except elaboration warnings and considers warnings to be
  errors.

  The generated code for many slice assignments has been improved, resulting
  in considerably improved execution time on most targets.

  The generated code for multi-dimensional arrays has been improved,
  significantly improving performance in many situations.

  The compiler now does a much more effective job of suppressing checks
  in array references in loops where the arrays involved are parameters
  that are unconstrained array types, or pointers to unconstrained arrays.

  On VxWorks cross-compilers, a new package called Interfaces.VxWorks provides
  provides a limited binding to the VxWorks API. In particular, it interfaces
  with the VxWorks hardware interrupt facilities.

  The package GNAT.Regexp no longer has any size limitation, and can handle
  complex regular expressions.

  A new warning switch -gnatwc turns on warnings for relational and
  membership operators appearing in statements (e.g. if statements)
  whose results are known at compile time to be always true or
  always false.

  A new pragma Style_Checks allows selection of style checks in a manner
  similar to the existing compiler switch, and also allows the style
  checks to be temporarily turned off and then turned back on again.

  The binary releases now contain the necessary headers to compile the
  C files in the runtime without having to do a full build of GNAT from
  sources.

  Makefile.adalib now also recompiles the C part of the GNAT run time,
  providing the ability to rebuild completely the GNAT libraries with the
  binary distribution.

  Makefile.adalib is now available for cross compilers, as well as the
  native versions of GNAT

  The -gnatwu switch now also provides warnings about possible access to
  uninitialized out parameters.

  The -gnatyk switch (check identifier casing) error messages now contain
  a source location reference to the definition of the relevant identifier.

  It is now permissible to specify the non-default Bit_Order for record
  subtypes. Component clauses for such types must either specify an
  integral number of bytes, or the component must lie entirely within
  one byte. Note that, in accordance with the RM, no reordering of bytes
  is done, the only effect is to renumber bits. This feature is therefore
  only of limited use in dealing with big/little-endian interfacing.

  Default_Bit_Order is now static. This is strictly a violation of the RM
  requirement that it be non-static, but everyone agrees this was a mistake,
  and an AI is expected to "fix" this mistake. Other Ada 95 compilers are
  already consistent with this modified interpreation of the RM.

  Florist has been ported to Solaris 7 and HP-UX 11.00

  GNAT now fully supports HP-UX 11.00, including a dual tasking run time
  that provides access to the DCE run time for compatibility with HP-UX 10.20,
  and to the POSIX pthread run time.

  Interrupt handling on HP-UX has been rewritten to provide a more powerful
  and less restrictive signal handling. In particular, the signals SIGIO and
  SIGPIPE can now be handled via Ada.Interrupts.

  The listing generated by the -gnatR switch now includes alignment values
  for array and record types.

  The NT version of GNAT now generates object files that are fully compatible
  with the standard Microsoft linker, so this linker can be used instead of
  the GNU ld program to build NT executables.

  The default stack size on NT for tasking program has been reduced to 8Mb
  (instead of 32Mb). This increase the default maximum number of tasks
  from approximately 60 to a value around 250.

  The gnathtml tool can now read the list of files to convert from a file,
  eliminating the command line length problem on some systems.

  The parent type of derived types is now recorded in the cross-reference
  section of the ali files. The new ali format is backward compatible with
  the previous one.

  The gnatfind and gnatxref tools have been extended to display the parent
  type of derived types. Furthermore gnatfind is now able to display the full
  type derivation informations for a specific type.

  Shared libraries are now provided as an option (via the -shared gnatbind
  switch) on four additional targets: Solaris x86, Solaris sparc, Linux and
  SCO UnixWare.

  New restrictions No_Implicit_Conditionals and No_Implicit_Loops have
  been added for greater control over generated code. This is particularly
  useful in a safety-critical/certification environment using GNORT (GNAT
  with no run time)

  The performance of the elementary trigononmetric functions has been
  substantially improved.

  A new section has been added to the GNAT Reference Manual providing
  a complete description of the set of representation pragmas and
  pragmas that are accepted by GNAT, and their effect.

  The implementation of the ASIS Data Decomposition Annex is now complete,
  with all queries fully supported.

  More static checking is now done for pragma Restrictions (No_Recursion),
  and most common cases are now detected and flagged as illegalities.

  A new package GNAT.Calendar is provided. It deals with Hour, Minute,
  Seconds, Day_Of_Week, Day_In_Year, Week_In_Year. There is also two
  functions to do conversions between Duration and C timeval struct.

  A new package GNAT.Calendar.Time_IO is provided. This package implements
  formatted output of Ada.Calendar.Time. The format string uses a format
  similar to the one used by the date UNIX command.

  The gnatdll tool now accepts the -I switch to search source and
  object files in specified directories.

  The optimization of checks has been significantly improved, and many
  unnecessary checks, particularly in connection with type conversions and
  the use of the pos operator, have been removed.

  The traceback stored in the exception occurrence (using the gnatbind -E
  switch) now gives accurate values in the case of a reraise.

  The structure used to hold task data has been split to allow restricted
  tasking implementations to use less storage for each task created.

  Enumeration representation clauses for types derived from Boolean
  are now fully supported.

  Variable shift instructions are now generated for multiplications or
  divisions by powers of 2 (e.g. x * 2 ** y, where y is Natural).

  External symbol names and debugging symbols are now more fully qualified.
  This avoids some peculiar naming conflicts for example in the case where
  there is a child package and nested package with the same name, and also
  improves the behavior of gdb when fully qualified names are given.

  An extended form of the Source_File_Name pragma permits handling the
  unusual case where a subunit and child unit have identical qualified
  names. This is unusual, but is allowed by the rules of the language,
  although both versions cannot appear in a single partition.

  The OpenVMS version of GNAT now fully supports the use of mixed-case
  external names. This solves a number of compatibility problems in
  this area, which could show up as unexpected duplicate names.

  A new pragma External_Name_Casing is provided for controlling the
  casing of external names. This is primarily for use in OpenVMS systems,
  but is available in all implementations.

  A new pragma Extensions_Allowed (ON | OFF) is provided for local control
  of whether language extensions are allowed. This pragma may also be used
  as a configuration pragma (e.g. in the gnat.adc file) to control the use
  of extensions for a series of compilations.

  The -gnatwu flag now separately checks specs to make sure that a with in
  a spec is now actually used in the spec. If the with is used only in the
  body, the warning suggests moving it to the body.

  The renaming of a constant was implemented as the declaration of a local
  variable whose initial value was the constant being renamed. This avoids
  an indirection, but is inefficient if the constant being renamed is large.
  This optimization is now restricted to objects that fit in registers.

Latest features in GNAT version 3.12a1/3.12a2 (4.12a-v)
========================================================

  Enum_Rep can now be applied to integer types and objects. This allows its
  use on (<>) formal discrete types in generic packages and subprograms.

  A preliminary version of the Data Decomposition Annex is now available
  for use in ASIS. This preliminary version supports only the simple type
  model, and does not yet allow queries with Portable_Data arguments.

  The -gnatR switch can now be used in conjunction with the -gnatc switch
  to obtain representation information without requiring a full compile.

Latest features in GNAT version 3.12a (4.12a-v)
===============================================

  The standard GNAT library (on Unix systems) now contains a Makefile
  called Makefile.adalib which allows recompilation of the runtime
  with different compilation options or different configuration
  pragmas.

  GNAT now handles C, C++ and Fortran convention boolean types specially.
  In all these cases, zero/non-zero semantics is used, so that any
  non-zero value is treated as equivalent to True. This means that
  the implementation of Interfaces.Fortran.LOGICAL is more accurate,
  and provides a convenient way of importing C int values used as
  boolean values.

  GNORT now permits the use of allocators and it is also possible to
  explicitly raise Program_Error. These calls are supported by user
  defined subprograms. See GNORT documentation for full details.

  A new package, GNAT.Current_Exception is provided for access to the
  current exception name and information. This is provided for compatibility
  with other Ada 83 compilers. See g-curexc.ads for a full description of
  this package.

  A new gnatbind option, -shared, enables the use of a shared GNAT library
  when available (currently DEC Unix, SGI IRIX and OpenVMS).
  Static GNAT library is the default on all targets but VMS and SGI IRIX.

  A new tool is provided, gnatdll. This is an NT/Win9x specific tool
  to help in constructing DLLs.

  Complete rewrite of the section of NT/Win9x specific features and
  documentation of the GNAT technology in this area. This section now
  clearly explains and documents how to use the NT/Win9x specific
  features of the GNAT technology.

  The compiler is now built with options -gnatpn instead of -gnata.
  This means that the front end of the compiler is considerably
  faster, up to 2-3 times faster in some cases. The cases where you
  will see the biggest speed up are in -gnatc compilations with no
  code generation, or if very large specs are with'ed from smaller
  units.

  If pragma Suppress is used in the gnat.adc file, this now properly
  suppresses exceptions in all files compiled in the presence of this
  gnat.adc file (Suppress pragmas in gnat.adc were previously ignored,
  which is in accordance with the RM, but certainly not what is wanted!)

  On Digital Unix 4.0D, the run time now takes advantage of the full
  range of priorities (0 .. 63).

  In -gnatc mode, an existing up to date ali file is no longer destroyed.
  In particular this means that the -gnatc -gnatt compilations used by
  ASIS do not destroy existing ali files.

  A new switch -gnaty activates style checking features in the compiler.
  These roughly correspond to the checking done by the special internal
  -gnatg flag, except that -gnaty allows extensive choice of which checks
  are to be performed, and also allows parametrization, e.g. of the indent
  level that is enforced.

  The handling of aggregates has been optimized in many cases, generating
  more efficient code and less memory usage.

  The binder now generates an Ada package as the main program by default
  instead of a C program. The generated files are called b~xxx.ads/adb,
  where xxx is the name of the main program. The -C switch for both
  gnatbind and gnatlink can be used to get the old behavior of generating
  the main program in C.

  The compilation switches are now stored in the ali file (lines starting
  with A). This is used to implement the corresponding ASIS option to
  retrieve the command line arguments.

  A new pragma Finalize_Storage_Only has been implemented. It indicates
  that a Finalize routine is present only for the purposes of releasing
  storage, and that thus the Finalize call can be omitted in some cases
  (e.g. for objects declared at the library level).

  A function and a procedure to retreive the current working directory
  have been added in g-dirope.ad[sb].

  Gcov, a test coverage program is now distributed with GNAT. See the gcc
  documentation for its use.

  pragma Task_Info is now available for AiX and can be used to specify the
  scheduling contention scope of each Ada task.

  New switches -nostdinc and -nostdlib for gnatmake and gnatbind. New
  switch -nostdinc for gcc/gnat1 and gnatls. -nostdinc turns off looking
  for sources in the system default directory. -nostdlib turns off looking
  for library files in the system default directory.

  [VMS] Wildcard directory specifications accepted and expanded in /SEARCH
  qualifiers and ADA_{INCLUDE,OBJECTS}_PATH logicals.

  Add support for Windows NT Resources. Under NT there are two new tools.
  RCL the resource compiler and res2coff to convert a binary resources
  file to a coff object file to be linked with a program.

  A new package GNAT.Traceback provides non-symbolic tracebacks at
  run time on Solaris and Linux.

  A new package GNAT.Traceback.Symbolic provides symbolic tracebacks at
  run time on Solaris and Linux.

  A new package GNAT.Regpat implements the full V7 regular expression
  matching, including such features as anchors, and is thus a more
  complete implementation than that in GNAT.Regexp, which is retained
  for compatibility (and is in any case more appropriate for certain
  functions).

  The packages Calendar and Ada.Real_Time for the NT/Win9x implementation now
  use a high resolution clock providing a resolution of 1 micro-sec.

  A new convention DLL has been added to simplify the development of DLL's
  using the NT/Win9x port of GNAT..

  The convention Stdcall is now available for variables as well as
  subprograms for the NT/Win9x port of GNAT.

  A restricted version of the run time is now provided. This version of
  the run time is automatically used if the appropriate set of restrictions
  is used. A new pragma Restricted_Run_Time sets this set of restrictions.
  The restricted run-time is more efficient for the set of allowed operations.

  A new pragma Ravenscar establishes the set of restrictions that corresponds
  with the Ravenscar profile for limited tasking. This is a more restrictive
  set than Restricted_Run_Time, so use of pragma Ravenscar will also cause the
  restricted run time to be used.

  A new restriction identifier No_Complex_Barriers has been added which
  causes barriers to be restricted to simple boolean variables declared
  within the protected type. This is one of the Ravenscar restrictions.

  A new restriction identifier No_Select_Statements has been added which
  completely eliminates the use of select statements. This is one of the
  Ravenscar restrictions

  The list of switches printed out when the -gnath option is used now includes
  common gcc switches.

  The handling of protected objects with no entries has been simplified and
  optimized.

  A new switch -gnatR causes the compiler to output representation information
  for declared arrays and records.

  A new switch -gnatD causes the compiler to generate files with names
  x.dg (where x is the source file name) that contain the expanded (-gnatG)
  code and to force debugging information to refer to these files. This
  allows source level debugging using the expanded code.

  The package GNAT.Command_Line has been updated to handle sections on
  the command line, as in gnatmake (-largs, -bargs, ...). There is also
  a new character '!' to specify that a switch must have a parameter, and
  that there must be no space between the two. Finally, a new special switch
  '*' has been created, to match any item on the command line.

  Shared passive partitions are fully implemented, including support for
  protected objects that provide global locking capability. The implementation
  allows the use of shared passive partitions to communicate between separate
  programs as well as between partitions of a single distibuted program, and
  also provides for automatic persistance from one run to another.

  A new flag -O for gnatbind gives a complete list of objects that are
  needed by the Ada part of the program.

  The sorting packages GNAT.Heap_Sort_A, GNAT.Heap_Sort_G, GNAT.Bubble_Sort_A
  and GNAT. Bubble_Sort_G use subtype Natural instead of Positive for the
  number of items to sort, so it is no longer an error to sort an empty
  range of items.

  A new package GNAT.Threads (in files g-thread.ads/adb) provides a general
  facility for foreign code (e.g. written in C) to create threads in a
  manner known to the Ada run-time system, so that these threads can
  freely call Ada code that uses explicit or implicit tasking constructs.

  The Assert pragma now permits expressions of types derived from Boolean
  instead of requiring Standard.Boolean itself.

  A new flag -z for gnatmake and gnatbind allows the more convenient
  compilation/binding/linking of an Ada program without a main subprogram.
  The execution of such a program is identical to the one of the program
  with an empty main subprogram with a "with" clause on the main package.

  The output format of gnatxref has been modified to be in columnar
  format so that it is easier to read.

  The gnatfind utility now accepts wild cards in the file name to allow
  a set of files to be searched, and this works on all operating systems.

  The gnatprep utility now supports boolean expressions (and, or, and
  then, or else, =, 'Defined), and has a new command line switch to
  define symbols.

  A new optimization circuit removes many subscript checks in loops in
  the cases where the range of the loop can be determined to be in range
  of the subscript.

  The location (file and line number) at which an exception was raised now
  appears by default in the exception message, and the message for an
  unhandled exception includes this information.

  Zero cost exceptions are now implemented in DEC Unix and on SGI Irix.
  On these two targets, zero cost exception handling is the standard
  default. You can select longjmp/setjmp exception handling (smaller
  executables) by using the -gnatL switch on all compilations including
  the library units. The switch -gnatZ can be used to enable zero cost
  exceptions on certain other targets including NT, but these are partial
  implementations in which exceptions cannot be propagated through C
  code (but for all Ada programs, this will work correctly).

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

  24-bit packed components are now permitted in GNORT mode provided that
  the alignment of the component type is explicitly set to 1.

  A new attribute System'To_Address (X) has exactly the same result value
  as System.Storage_Elements.To_Address (X), except that the result is a
  static value if the input value is static, allowing its use in a package
  to which pragma Preelaborate applies.

  It is now permissible to declare library variables whose nominal type is
  unconstrained String in GNORT mode if the initializing expression is a
  string literal.

The WITH TYPE Clause
---------------------

  The WITH TYPE clause has been implemented. This is a language
  extension that has been proposed repeatedly by programmers who need
  to model mutually dependent record types, that is to say pairs of types
  where each has a component that is an access to the other. This structure
  is common in C++ and Java libraries. Without the WITH TYPE clause, the
  only way to obtain this effect in Ada is to define the types in the same
  package. The WITH TYPE clause simplifies the creation of bindings to such
  libraries. Given the importance of such bindings, the Ada Rapporteur Group
  is discussing the introduction of the WITH TYPE clause the first
  standardized extension to Ada95. The current GNAT implementation may
  differ slightly from the final, WG9-approved version, but is very close
  in syntax and semantics to what is currently being proposed.

  Syntax:
      WITH_TYPE_CLAUSE ::=
         with type type_NAME is access | with type type_NAME is tagged

  Legality rules:
    The type_NAME must be an expanded name whose prefix denotes a package.
    The visible part of that package must contain a type declaration whose
    defining_identifier has the given name (the imported type). If the keyword
    "access" is present, the declaration must be an access declaration. If
    keyword "tagged" is present, the declaration must be a tagged type decla-
    ration, a type extension, or a tagged private type declaration.

    Within the client unit, the imported type can only be used in component
    declarations, in formal parameter specifications, and to declare access
    types and classwide types. The name of its enclosing package can only be
    used as the prefix of a expanded name that denotes the imported type.

  Compilation rules:
    The WITH TYPE clause does not create a semantic dependency between the
    importing and the exporting package.  This is what allows the declaration
    of distinct packages with mutually dependent types, and WITH TYPE clauses
    referencing one another.

  Usage:
    By default, GNAT does not support any language extensions (no validated
    compiler is allowed to, after all). In order to enable the use of the
    WITH TYPE clause, the GNAT flag -gnatX must be specified.

Latest features in GNAT version 3.11b2
======================================

  This version contains corrections for a number of bugs discovered
  during testing of 3.11b and 3.11b1, and is the current official 3.11b
  release. The following gives details on the corrected errors. The
  tracking numbers here are our internal tracking numbers and can be
  ignored (unless you were the customer submitting the problem, in
  which case you can take this as confirmation that the problem is
  fixed in 3.11b2).

  5629-001
    Incorrect code generated when optimization enabled (-O1 or -O2) in presence
    of pragma Pure. The precise conditions were a formal of access type, where
    two calls had the same access value. The code generator assumed that this
    meant that the referenced value was the same.

  5721-018 (NT specific)
    The new library function "popen" was not working properly. This affected
    the use of the tool gnatmem on NT only.

  5724-001
    Missing symbols at link time when using the Storage_Pool mechanism in a
    generic or through a renaming. Spurious messages were generated for renaming
    declaration that rename a Storage_Pool, and for instantiations where an
    actual parameter is a Storage_Pool. Affects Ada 95 Booch components.

  5724-006
    Various problems with the gnathtml tool:
      - Only one entry appeared in the index for overloaded subprograms
      - Tab characters in the source (HT) prevented the correct
        cross-references from being generated.
      - Cross-references were not generated for user defined operators.

  5808-002
    Incorrect compilation errors related to visibility and separate units.
    Spurious visibility error when a package body contains two stubs and a
    use clause for one of the corresponding packages.

  5808-009
    Not enough space deallocated when using user-defined storage pools if
    the allocation of a derived type is done through a pointer to class wide
    type. For instance type T is tagged null record;

             type Ptr is access T'Class;
             For Ptr'Storage_Pool use My_Pool;
             ....
             x: Ptr := new Derived_From_T; -- allocates 10 bytes in My_Pool
             ....
             Free (x);                     -- only deallocates 4 bytes


  5815-015
    Improper Program_Error raised at runtime during elaboration of
    a deeply nested generic instantiation.

    Problem affected instances where the generic body appears in a
    separately compiled instance.

           generic
              ...
           package outer is
                generic
                  ...
                package inner is .. end inner;
           end outer;

           package outer_instance is new outer (..);

           with outer_instance;
           package bug is
              package inner_instance is new outer_instance.inner (...);
           end bug;

  5816-001
    The -gnatG switch resulted in an infinite loop at compile time.

  5827-002
    Incorrect compilation errors due to limited types not recognized as aliased.

    The error affected the compilation of declarations such as
    the following:

    package P is
       type T is tagged limited private;
    private
       function Op (O : access T) return Integer;
       type T is
          tagged limited record
             I : Integer := Op (T'Access);  -  spurious error on this line
          end record;
    end P;

    The attribute reference to 'access was incorrectly rejected because the
    current occurrence of T was not recognized as being aliased.

  5827-005
    Incomplete listing generated by -gnatl for a source file with multiple
    compilation units when there was an error in the first compilation unit
    (subsequent compilation units, and the message complaining about them,
    did not appear in the listing.

  5829-001
    Improper compilation errors related to package renaming & child units.
    Given a unit, a child, and a grandchild, and a renaming of the first,
    a spurious error was given for a with clause for the grandchild where
    the parent unit used the renaming of that ancestor rather than the
    ancestor itself.

  5830-001
    Wrong value computed for some literals with large negative exponents.
    error only occurred for values in the vicinity of 10 ** (-40).

  5830-004
    Problem with renaming of classwide objects. When the renamed object is
    from a derived type and the renaming has a class-wide type, the last
    components were not always initialized properly.

Latest features in GNAT version 3.11b (4.11b-v)
===============================================

  The Windows NT/Windows 95 GNAT compiler no longer has any cygwin32
  based components. The only remaining cygwin32 based tool distributed
  is make. All the others tools (debugger, linker, assembler...) have
  been built totally using the mingw32 system. (Microsoft C library).

  A null rendezvous body (do null; end) is now handled more efficiently
  (it is treated as though no body were present).

  The use of package Ada.Calendar and the use of delay statements do
  not depend on the tasking run-time (and on a thread library) any more.
  This means smaller and simpler executables for non-tasking programs.

  pragma Task_Info is now available for Digital Unix 4.0D and can be
  used to specify on which processor a given Ada task should run.

  pragma Task_Info is also available for Solaris and can be used to
  specify the relationship between tasks and lightweight processes
  (LWP's), and between LWP's and processors.

  A new pragma Suppress_Initialization can be used to suppress all
  initialization (both implicit and explicit) for the given type.

  Tight packing (with no padding bits) of arrays was formerly implemented
  only up to element sizes of 32 bits. GNAT now provides tight packing
  up to 64 bits.

  A new attribute VADS_Size provides a size attribute that is intended
  to be compatible with the results provided by the Size attribute
  on VADS compilers (VADS is a trademark of Rational Software Inc).

  A corresponding configuration pragma Use_VADS_Size causes any Size
  attribute in the source to be interpreted as though it were VADS_Size.
  This pragma and the corresponding attribute are intended to ease the
  porting of large VADS programs that rely on the specific values of
  Size returned by VADS.

  Many additional tests for unassigned variables have been added,
  resulting in additional warning messages. For example, these checks
  are now performed on variables declared within nested blocks.

  This version of GNAT uses the new GCC 2.8 release. The effect should
  mostly be transparent, but the new version of GCC contains many code
  generation fixes and improvements.

  The compiler generates additional encodings for GDB, and together with
  the latest version of GDB, essentially all Ada data structures are now
  handled correctly by GDB.

  In the VMS version, GDB recognizes the VAX floating-point formats
  automatically.

  A new tool, gnatelim, allows for the elimination of unused subprograms.
  This is an ASIS based tool, that can be used on any GNAT target.

  A new tool, gnatstub, allows for the automatic creation of stubs from
  specifications. This is an ASIS based tool that can be used on any GNAT
  target.

  A new tool, gnatmem, provides a method for systematically detecting memory
  leaks that arise from dynamic allocations with no corresponding free
  operation.

  A complete version of ASIS is now available for this version of
  GNAT. This is a separately supported product. Contact sales@gnat.com
  for full details.

  The number of cases in which aggregates are treated statically at compile
  time is significantly increased, leading to faster and smaller code, as
  well as improved compile time for programs with large aggregates.

  Internal variables are now eliminated from the debugging information,
  leading to a reduction in the size of generated debugging data.

  A new restriction identifier No_Elaboration_Code ensures
  that a compilation does not generate any executable elaboration
  code. This is different from pragma Preelaborate in both directions,
  there are preelaborable packages that generate executable elaboration
  code, and there are packages which are not preealborable in the RM
  sense that generate no elaboration code.

  A new pragma Unreserve_All_Interrupts allows an implementation to
  specify that normally reserved interrupts (e.g. SIGINT for handling
  Ctrl-C) are to be unreserved, so that the application program may
  handle these interrupts as it pleases.

  Many examples of unnecessary generation of internal "actual" subtypes
  have been suppressed, resulting in more efficient code, particularly
  at lower optimization levels, and also in speeded up compilation.

  The GNAT package GNAT.Htable has been enhanced. A Remove procedure
  has been added to Simple_Htable, and an iterator interface allowing
  retrieval of all elements of the table has been added to both
  Simple_HTable and Static_HTable. These additions have been done in
  an upwards compatible manner, so existing clients should not be
  affected.

  A new package GNAT.Table has been added which provides a simple
  extensible array abstraction. As usual, this is completely documented
  in the spec, which can  be found in file g-table.ads.

  A new implementation dependent attribute R.C'Bit_Position, where
  R is a record object and C is one of its fields returns the
  bit offset of the start of field C from the start of the record
  as a universal integer.

  The Address attribute is now fully implemented for references involving
  elements of bit packed arrays (formerly this was not permitted).

  The efficiency (both space and time) of code for multiple concatenations
  (where three or more values are concatenated) has been improved.

  The Unrestricted_Access attribute is now allowed even for pool-specific
  access types (i.e. those declared without ALL or CONSTANT) keywords.
  This is consistent with the intent of this attribute, which is that
  it be essentially equivalent to the use of 'Address followed by an
  unchecked conversion to the access type.

  In a number of situations, allocators are now handled statically at
  compile time. Notably if an allocator is at the outer level in
  elaboration code, then it can typically be handled statically.

  A new attribute Code_Address is provided. It applies only to subprogram
  entities, and it returns the address of the start of the code for the
  subprogram. This is often, but not always, the same value as returned
  by 'Address. Examples where it may differ are when the 'Address value
  points to a descriptor, such as the "trampoline" used to call nested
  procedures on some architectures. Generally the 'Address value is the
  one to use for calling subprogram (via typical Ada 83 tricks for making
  the address be used for the call). Code_Address always yields the
  starting address of the contiguous code for the subprogram.

  A warning is now generated for address clauses that are intended to
  overlay two entities, when the type of the entities includes an
  initialization. In such cases, the initialization of the entity for
  which the address clause is given will affect (i.e. destroy) the
  variable that it overlays, unless the entity is labelled with a
  pragma Import. A clear warning is now emitted for this common
  and useful, but potentially dangerous, programming idiom.

  The Ident pragma now permits a general static string expression, rather
  than just a string literal. This is an upwards compatible extension.

  A new attribute Has_Discriminants may be applied to a type and yields
  true if the given type has Discriminants. It can be used with generic
  types to indicate if the corresponding actual type has discriminants.

  A new warning switch -gnatwu causes warnings about unused entities
  and with'ed units to be generated. This facility replaces the use
  of -x1 and -x2 switches in gnatf. It is more convenient than the
  use of gnatf (since it is embedded into the compiler), and also
  more complete and accurate, since a number of gnatf bugs have been
  corrected in this new implementation of this warning feature.

  Warning messages are now generated if an unchecked conversion is used
  to convert an access type to another access type with more strict
  alignment requirements (since this can generate pointers whose
  designated object does not meet the alignment requirements of the
  generated code using this access type).

  The UTF-8 encoding scheme for wide characters is now supported both
  by the compiler (-gnatW8) and for Wide_Text_IO files (WCEM=8). The
  default wide character encoding for Wide_Text_IO files is now set to
  the wide character encoding specified for the main program source.

  Gnatmake behaves exactly in the same way whether or not
  the .adb extension is omitted on the main source file. In
  particular, it searches the path to look for the main program
  if no directory is included, but a file extension is present
  (See gnatmake section in gnat_ug for details).

  Objdump has been added to the binary distribution.  Objdump can be
  used in conjuction with compiling with -g -S to view code in accordance
  with pragma Reviewable.

  An Ada-aware version of binutils utility addr2line has been added to
  the binary distribution.

  A new package GNAT.Regexp (in files g-regexp.ads and g-regexp.adb)
  provides a complete facility for string matching using Unix-style
  regular expression syntax.

  A new package GNAT.Directory_Operations (in files g-dirope.ads and
  g-dirope.adb) provides operations on directories, including opening,
  reading, and changing the current directory.

  A new package GNAT.Command_Line (in files g-comlin.ads and g-comlin.adb)
  provides a high level interface for scanning command line switches,
  parameters and file names (including wild card expansion).

  GNAT now generates by default cross-reference information in the
  generated ali files (this can be suppressed with the -gnatx switch).
  This information is used by the four following capabilities. Note
  that this capability replaces the now obsolete gnatf format.

    A new tool gnatfind can be used to quickly locate declarations or
    all references to a specified entity or entities. This utility uses
    the new cross-reference information in the ali files.

    A new tool gnatxref can be used to generate complete cross-reference
    reports. This utility uses the new cross-reference information in the
    ali files.

    A perl script gnathtml provides the capability of converting sources
    to html, including the generation of links using the new cross-
    reference information in the ali files. Keywords and comments are
    appropriately highlighted.

    A new version of GNAPSE (the GNAT version of EMACS with Ada support)
    includes an interface to the cross-reference information in the ali
    files to quickly locate declarations and references.

  There is a new version of gnatchop with enhanced functionality,
  including the ability to chop multiple files, and a special
  "compilation" mode that provides optional handling for configuration
  pragmas according to the procedures in the RM.

  The new version of gnatchop now respects an existing Source_Reference
  pragma in the input file, and when used with -r generates
  Source_Reference pragmas in the output file that refer to the
  original input file. This is particularly convenient when using
  gnatprep and gnatchop together to process a file with multiple
  units and preprocessing statements.

  The unit System.Machine_Code (in file s-maccod.ads) is now declared
  Pure, allowing the use of machine code intrinsics in pure units.

Latest features in GNAT version 3.11a (4.11a-v)
===============================================

  The main program generated by the binder can now optionally be
  generated in Ada rather than in C. To activate this option, use
  the -A switch in both the gnatbind and gnatlink steps.

  The compiler now generates far more information on complex data
  types in -g mode for use by the debugger. For best results make
  sure you have the latest GDB. The current GDB is 4.16.gnat.1.15.1.

  A new pragma Eliminate is available which specifies that certain
  declarations are to be eliminated from the program. This is in
  preparation for a new tool gnatelim, not available yet, which will
  provide for removal of unused declarations and subprograms.

  A new pragma Stream_Convert allows a unit to provide for proper
  handling of stream attributes for a type if they are used, without
  unconditionally incurring the overhead of dragging in all the stuff
  for handling streams (which is what happens if the stream attributes
  are defined in the conventional manner).

  The gnatchop utility now detects the case where the file to be chopped
  contains multiple copies of the same unit, and if so, does not write
  any files unless -w is specified (in which case the last copy is the
  one to be written).

  Attach_Handler and Interrupt_Handler capabilities are now fully
  implemented on all targets as appropriate to the target.

  The "info tasks" under the latest ada-aware GDB now gives additional
  information on the state of tasks.

  A new unit g-tasloc provides an inexpensive global locking capability
  for creating critical regions with reduced overhead compared to
  implementing this lock in pure Ada code.

  The runtime has been extensively reworked. A number of timing windows
  have been eliminated, and many small errors have been caught and fixed.
  The result should be generally improved reliability in the tasking
  implementation, especially in the multi-processing case.

  The "old GNULLI" routines have been entirely eliminated, since all
  targets are now using the new low-level interface ("new GNULLI").
  The result is an improved interface, which solves a number of problems,
  and also a significant reduction in the number of target dependent
  tasking files.

  In the NT version, we have the general capability of installing
  bindings at the time that the system is installed, and the standard
  distribution takes advantage of this feature to offer the option of
  installing a version of the Win32 bindings.

  An archive is used for the standard library distribution on all
  implementations, including OS/2. This improves linker performance
  and reduces the number of individual files in the installation.

  A run time task that was previously systematically created is now elaborated
  only for programs that use Asynchronous Transfer of Control constructs.
  This means that a tasking program will use less resources (threads and
  memory) and that the start up will be faster.

  The run time now properly and explicitly shut down all the tasks before
  exiting. This avoids some target specific problems like hanging and
  system errors.

  Two functions Errno and Set_Errno have been added to GNAT.OS_Lib to get and
  set the task-safe errno.

  The GNAT makefile is now more portable, since it avoids the use of
  Unix specific features, in favor of using GNUMAKE on all targets. This
  makes integration of the OS/2 and VMS versions more straightforward.

  Note that entries for versions of GNAT earlier than 3.01 have now been
  eliminated from this file, since they are entirely out of date at this
  stage.

  Calling and receiving stubs for the distributed systems annex are now
  generated directly as object files; the plain-Ada intermediate phase
  has been suppressed. The compilation time has been dramatically reduced
  for distributed programs containing a large number of RCI packages.

  Remote access to subprograms and generic RCI packages are now fully
  implemented.

  The incorrect attempt to use directory separators in the file name
  argument of a Source_File_Name pragma is now properly diagnosed.

  The timed entry call and selective wait with delay alternative tasking
  constructs have been highly improved in term of efficiency and reliability.

  On the AIX version, it is now possible to choose between native threads,
  and simulated threads for the tasking. Default is now native threads.

  On the NT version, a fast locking mechanism is now used that improves
  performance for tasking applications.

  The NT version now allows linking with resources on NT as well as
  on Win 95 and Win 98.

  On AIX, Digital Unix and HPUX versions, gnatlink will now automatically
  utilize the system dependent linker option to read the set of object files
  from a named file rather than the command line in cases where the linker
  cannot handle the length of the object list. These particular OS systems
  had fairly short allowable linker lines.

  The Enum_Rep attribute can now be applied directly to an object of an
  enumeration type, or to a non-overloaded enumeration literal name.

Latest features in GNAT version 3.10 (4.01v)
============================================

  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
