=================================================
ADA 2005 FEATURES LIST Current as of May 10, 2006
=================================================

Copyright (c) 2004-2006, AdaCore

This file contains a complete list of Ada 2005 features that have been
implemented in version 5.05 of GNAT. Generally, these features are only
available if the -gnat05 (Ada 2005 features enabled) flag is set. The exception
is for new pragmas and attributes and restrictions which are unconditionally
available since the Ada 95 RM allows the addition of new pragmas, attributes
and restrictions (there are exceptions, which are documented in the individual
descriptions).

An ISO date (YYYY-MM-DD) appears in parentheses after the description line.
This date shows the implementation date of the feature. Any wavefront
subsequent to this date will contain the indicated feature, as will any
subsequent releases. A date of 0000-00-00 means that GNAT has always
implemented the feature, or implemented it as soon as it appeared as a
binding interpretation. All the entries are ordered by the AI number.

NF-A05-D827-003 AI-085 Operations on Stream_IO (2004-11-10)

  In Ada 2005 a call to Reset without the mode parameter is equivalent to a
  call to Reset with the current mode of the file. In addition, the beginning
  and end of the file mentioned in the description of the semantics of Reset
  designate the beginning and end of the external file.

NF-A05-D827-004 AI-147 Optimization of controlled types (0000-00-00)

  This AI specifies the context in which it is legal to eliminate certain
  calls to Initialize, Adjust and Finalize. In particular, temporary anonymous
  objects may not require the execution of calls to Initialize/Finalize pairs
  unless Initialize is user-defined.

NF-A05-DC16-022 AI-161 Default-initialized objects (2006-04-20)

  This AI introduces a new pragma Preelaborable_Initialization which greatly
  extends the utility of both predefined and user defined private types in
  preelaborated clients. For example, variables of type System.Address can
  now be declared in a package that has pragma Preelaborate.

NF-A05-DC16-024 AI-167 Validity check after unchecked conversion (2004-12-17)

  This AI ensures that it is not erroneous to do an unchecked conversion
  producing an invalid value, followed by a 'Valid check on the result. In fact
  it has always been the case that GNAT guarantees this to work (the 'Valid
  check would not be much use otherwise!)

NF-A05-D827-005 AI-195 Streams: 'Input and initialization (2005-05-18)

  This AI completes the definition of streams covering the following list of
  topics:

    1) When the predefined Input attribute creates an object, this object
       undergoes default initialization and finalization.

    2) For the purposes of checking legality rules, it is necessary to
       determine whether a stream-oriented attribute has been specified for
       limited type (13.13.2(9/1) and 13.13.2(36/1)). This is done by applying
       the normal visibility rules to the attribute definition clause.

    3) For a limited tagged type T, if Read is available then T'Input is
       available, even if it is not specified. Similarly, if Write is available
       then T'Output is available. T'Class'Read, T'Class'Write, T'Class'Input
       and T'Class'Output are available only if they are specified or the
       corresponding specific attribute is available somewhere within the same
       list of declarations as T.

    4) The predefined Read attribute for composite types with defaulted
       discriminants ensure that, if exceptions are raised by the Read
       attribute for some discriminant, the discriminants of the actual object
       passed to Read are not modified.

    5) The predefined Read attribute for composite types with defaulted
       discriminants raises Constraint_Error if the discriminants found in the
       stream differ from those of the actual parameter to Read, and this
       parameter is constrained.

    6) If S is a subtype of an abstract type, an attribute_reference for
       S'Input is illegal.

NF-A05-DC16-027 AI-196 Assignment and tag-indeterminate calls (2004-12-23)

  For the assignment of the result of a tag-indeterminate dispatching call to a
  target of a class-wide type, the controlling tag value for the call is now
  defined by the tag of the target.

NF-A05-DC16-028 AI-200 Generic formal subprograms and dispatching (2004-12-16)

  This AI revises the definition of primitive operations to make it clear that
  subprograms in a generic unit that override the primitive subprograms of a
  formal tagged type are not primitives of the formal type (or the actual type
  in an instantiation), and hence are not dispatching operations. This applies
  both to formal subprograms and subprograms occuring later in the generic
  specification. GNAT already implemented this intent correctly, so there will
  be no effect on users from this change to the revised rule (RM95-3.2.3(7)).

NF-A05-D827-008 AI-214 Distinct names for subunits/child units (2004-12-08)

  This AI allows compilers to reject an attempt to put child unit and subunit
  with the same expanded name into a compilation environment. In fact GNAT does
  permit this (via the parameter Subunit_File_Name of the Source_File_Name
  configuration pragma), but otherwise does reject it if this is not used.

NF-A05-E508-026 AI-216 Pragma Unchecked_Union (2006-01-02)

  This AI adds a pragma for mapping C unions to Ada records with no run-time
  discriminant. Several Ada-83 compilers, including GNAT Pro implemented a
  preliminary version of this pragma. The new implementation is completely
  upwards compatible with that earlier implementation, but includes new
  features (for example, the ability to have multiple components in a member
  of the union).

NF-A05-C715-013 AI-217 Limited with clauses (2003-10-31)

  Context clause that allows mutual recursion among types declared in separate
  packages (types that contain references to each other as components, and
  primitive operations with references to one another as parameters).

NF-A05-DC16-029 AI-218 Accidental overloading when overriding (2005-03-09)

  To prevent accidental overloading when an explicit subprogram overrides an
  inherited operation, an overriding indicator can be added to a subprogram
  declaration, renaming, or instantiation. If the indicator is Overriding, the
  subprogram must override an inherited operation at the point of declaration.
  If the indicator is Not Overriding, the subprogram must not override either
  at the point of declaration or later (this last clause covers the case when
  the inherited operation becomes visible after the subprogram declaration, as
  when inherited through a full view).

NF-A05-D827-012 AI-220 Subprograms withing private units (0000-00-00)

  A subprogram body without a distinct subprogram declaration is considered a
  declaration (and not a body) for the purposes of checking 10.1.2(8).

NF-A05-E508-005 AI-221 Default_Bit_Order is static (1999-10-16)

  Default_Bit_Order is now static in both Ada 2005 and Ada 95. As can be seen
  from the date, this has been implemented a long time ago in GNAT.

NF-A05-C604-015 AI-224 Pragma Unsuppress (0000-00-00)

  This pragma has been implemented for a long time in GNAT. It undoes the
  effect of a previous pragma Suppress, or compiler switch suppressing checks
  (-gnatp).

NF-A05-F111-005 AI-229 Accessibility rule and generics (2006-01-13)

  The expression P'Access (where P denotes a subprogram declared in a generic
  unit) is illegal within the generic body (or the body of a child unit of the
  generic) if the ultimate ancestor of the expected access type is a generic
  formal type or is not declared within the generic unit.

NF-A05-C826-009 AI-230 Generalized use of anonymous access types (2004-02-01)

  This feature allows more general use of anonymous access types. It allow the
  flexibility of implicit conversion and run-time accessibility checking to be
  used in more contexts, including as components and in object renamings.

NF-A05-D328-001 AI-231 Access-to-constant, non-null access types (2004-03-29)

  Parameters and discriminants of an anonymous access-to-constant type are
  introduced. Non-controlling access parameters and access discriminants are
  changed to allow having null value by default, but allow null to be excluded
  explicitly. Null-excluding subtypes of a named access type are also
  introduced.

NF-A05-D827-013 AI-235 Resolution of 'Access (0000-00-00)

  The prefix type of 'Access (and 'Unchecked_Access) can be used to resolve the
  expected access type.

NF-A05-DC16-030 AI-239 Inherited default expressions (2005-01-10)

  When a primitive subprogram of a tagged type is inherited, a default
  expression given by tag-indeterminate function call is treated as if the
  default expression is of the derived type. This means that when a subprogram
  call is made to the derived subprogram using the default, it will effectively
  dispatch and invoke the corresponding primitive function of the derived type.

NF-A05-E501-001 AI-241 Testing for null exception occurrence (2005-05-02)

  The original Ada 95 RM specifies that a call to function Exeption_Identity in
  da.Exceptions must raise Constraint_Error if the argument is the null
  occurrence. This means that this function cannot conveniently be used to test
  for the null occurrence. This AI requires that in Ada 2005 (and also in
  amended Ada 95), such call returns Null_Id instead of raising an exception.

NF-A05-DC16-032 AI-242 Surprising behavior of Update (2004-12-27)

  The Update procedure in Interfaces.C.Strings that takes a string parameter
  had the unexpected and unintended effect of truncating the result just past
  the inserted string. This was definitely not intended, and this AI documents
  the appropriate fix. In GNAT, we have fixed this in both Ada 95 and Ada 2005
  mode, since it seems like a clear error.

NF-A05-E508-009 AI-243 Status of subunit of a subunit (0000-00-00)

  A subunit of a subunit of L is also defined to be subunit of L (this was
  previously unclear in the RM). This applies to both Ada 95 and Ada 2005, and
  affects the legality of some cases of withing private units from sub-units.
  GNAT has always implemented this.

NF-A05-8218-003 AI-246 View conversions for by-reference arrays (2005-04-29)

  This AI forbids view conversion between limited arrays whose components may
  have incompatible representation clauses. This is a language gap that was
  addressed two years ago by the ARG. GNAT treated this as a warning, because
  several ACATS tests used this now illegal construct. The ACATS suite has been
  updated and GNAT now diagnoses the error.

NF-A05-D127-008 AI-249 Profile pragma (2004-02-06)

  Pragma Profile has been implemented. The only allowed arguments are Ravenscar
  (equivalent to pragma Ravenscar, which is now considered obsolescent), and
  Restricted, (equivalent to pragma Restricted_Run_Time, which is now
  considered obsolescent).

NF-A05-D714-003 AI-251 Abstract interface types (2005-05-06)

  Ada 2005 adds "interface" types to the standard as a kind of componentless
  abstract tagged type. A tagged type may be derived from one or more such
  interfaces as well as possibly from one tagged type; this provides a limited
  form of multiple inheritance. Dispatching calls through the primitives of an
  interface dispatch to code bodies associated with specific tagged types that
  are derived from that interface.

NF-A05-D605-001 AI-252 Object.Operation notation (2004-07-22)

  The new notation allows object-oriented programming model that is based on
  applying operations to objects, rather than selecting operations from a
  package and then applying them to parameters.

NF-A05-D401-011 AI-254 Anonymous access to subprogram types (2004-04-21)

  Anonymous access to subprogram types increase flexibility of manipulating an
  access to a subprogram and in particular allow an access to a subprogram at
  any level to be passed as an actual parameter to a protected or non-protected
  subprogram

NF-A05-DC16-033 AI-255 Renaming of subcomponent of generic in out (2004-12-17)

  This AI confirms that the rule against renaming of components that depend on
  a discriminant applies to an in out generic parameter, even when its subtype
  is constrained.

NF-A05-EC07-040 AI-257 Restrictions for implementation entities (0000-00-00)

  This AI adds the new restrictions No_Implementation_Attributes and
  No_Implementation_Pragmas, preventing the use of implementation defined
  attributes and pragmas. These were copied from GNAT, and have always been
  been implemented in GNAT.

NF-A05-DC16-034 AI-258 Behavior of To_C for null string (2004-12-17)

  This AI deals with the anomolous case of a call made to Interfaces.C.To_C
  with a null string and Append_Nul false. This routine is supposed to return a
  string with a lower bound of zero, but that is impossible in this case, since
  the index type is unsigned. The resolution is that this should raise
  Constraint_Error. Previously GNAT returned a string with bounds 1..0, but
  that clearly violated the required lower bound of zero.

NF-A05-E508-004 AI-259 Atomic/Volatile accesses cannot be combined (0000-00-00)

  This AI adds implementation advice requiring that atomic and volatile
  accesses not be combined, that volatile accesses load or store only the bits
  of the object, and that atomic accesses generate a single instruction. GNAT
  has always followed this advice.

NF-A05-DC16-035 AI-260-02 Abstract formal subprograms (2005-03-29)

  Formal subprograms can now be declared as abstract if they have a tagged
  formal parameter or tagged result. The actual for such a subprogram must be a
  primitive dispatching operation, and all calls to the formal subprogram from
  within an instance have dispatching semantics. There is a predefined generic
  unit called Generic_Dispatching_Constructor that can be instantiated with a
  dispatching constructor function, providing "factory" capability that can
  construct a tagged object when given a tag and other parameter information.
  An application of this features is to redefine stream attributes such
  'Class'Input to support alternative tag representations. Also as part of the
  implementation of this AI, the package Ada.Tags has been extended with a
  function Parent_Tag and a constant No_Tag.

NF-A05-CC18-003 AI-262 Private-with clause (2004-05-24)

  The context clause "private with" allows withing of private units in visible
  unit specifications. It does not make the unit available in the visible part
  of package.

NF-A05-DC16-037 AI-266-02 Task termination procedure (2005-11-29)

  This AI provides the mechanisms for associating protected procedures with
  tasks, in such as way that these procedures are invoked when tasks are about
  to terminate (either normally, as a result of an unhandled exception or due
  to abort). It helps mitigating the hazard of tasks terminating silently.

NF-A05-DC16-038 AI-267 Fast Float-to-Integer conversion (2005-11-05)

  This AI provides a new attribute Machine_Rounding for float types, that
  provides similar functionality to Rounding, except that the treatment of
  numbers exactly mid-way between two integers can go to either near-by integer
  (the result is implementation defined). For now GNAT provides the same
  semantics for Machine_Rounding as for Rounding.

NF-A05-DC16-039 AI-268 Rounding of real static expressions (2004-12-28)

  A literal reading of the wording of the Ada 95 standard appears to require
  that static float values exactly half way between two machine numbers are to
  be rounded in biased manner (away from zero), and hence treated differently
  from non-static environments where typical IEEE compatible systems do
  non-biased rounding. This is corrected in Ada 2005, where the rounding is
  implementation defined, with a recommendation to round the same way at
  compile time as at execution time. In fact GNAT Pro already follows this
  recommendation, even in Ada 95 mode, since it seems a clearly preferable
  approach.

NF-A05-DC16-041 AI-270 Stream_Size attribute (2005-01-05)

  The Stream_Size attribute can be used to control the size of the elementary
  type object written into stream. This is significant because different
  compilers can choose a different base type for the same type definition. This
  makes Ada programs more interoperable by giving the ability to control
  precisely external representation of stream objects.

NF-A05-E508-003 AI-272 Slices of atomic arrays (0000-00-00)

  This AI notes that, despite the fact that a strict reading of the RM says
  otherwise, slices of atomic arrays are not necessarily atomic (e.g. an array
  of four characters can be declared atomic, but that does not mean a slice of
  3 characters of this array can be treated atomically). GNAT has always taken
  this viewpoint.

NF-A05-DC16-042 AI-279 Tag read by T'Class'Input (0000-00-00)

  If Internal_Tag is applied to a tagged type that is not yet frozen, then a
  Tag_Error exception is raised. The AI also covers some other cases of bad
  usage of Internal_Tag, all of which are fully implemented by GNAT.

NF-A05-DC16-044 AI-283 Stream files truncated by close/reset (2004-12-25)

  This AI specifies that Close and Reset on a stream file should not truncate
  the file. In practice, although strictly required by the Ada 95 RM, this was
  an obvious mistake, and GNAT has always done the right thing here (which is
  not to truncate the file).

NF-A05-E103-003 AI-284 New reserved words (2005-01-13)

  Use of the identifiers "interface", "overriding", or "synchronized" is not
  permitted, since these are new reserved words in Ada 2005.

NF-A05-DC16-045 AI-285 Wide_Wide_Character type (2005-02-03)

  This is a major addition, including the run-time types Wide_Wide_Character
  and Wide_Wide_String corresponding to full 10646 multi-plane Unicode (32-bit
  characters). A set of several dozen new packages support these new types, and
  several existing packages are extended. In addition, wide wide characters are
  useable in character literals, string literals, and identifiers.

NF-A05-E505-003 AI-286 Assert and Assertion_Policy pragmas (2005-05-06)

  The Ada 2005 form of the Assert pragma is upwards compatible with the form
  implemented by GNAT. The only addition is the optional pragma argument
  identifiers (Check and Message). The Assertion_Policy pragma allows control
  of whether Assert pragmas at the source level.

NF-A05-CB13-007 AI-287 Aggregates for limited types (2003-12-05)

  The primary goal of this feature is to allow aggregates to be of a limited
  type, and to allow such aggregates as the explicit initial value of objects.
  For this purpose the box ("<>") can be used in place of an expression for a
  component of an aggregate to denote the corresponding default initialization.

NF-A05-DC16-046 AI-297 package Ada.Real_Time.Timing_Events (2005-12-12)

  This AI introduces a mechanism to allow user-defined procedures to be
  executed at a specified time without the need to declare a task or use
  a delay statement. The facility is defined by the type Timing_Event
  defined in package Ada.Real_Time.Timing_Events

NF-A05-DC16-048 AI-301 New I/O Subprograms (2005-02-09)

  This AI involves a collection of new I/O functions, including new index
  functions for Strings.Fixed, Strings.Bounded and Strings.Unbounded that take
  starting position (From), new Slice subprograms for bounded and unbounded
  strings, a procedure to set bounded or unbounded string, new Get_Line
  function for Text_IO, and new Unbounded_IO package for Text_IO for unbounded
  strings. All these features are also extended to Wide_String and
  Wide_Wide_String in the usual manner.

NF-A05-DA22-030 AI-302 Container packages (2005-02-02)

  The set of container packages described in this AI is added to the GNAT
  run-time library. The list is:

    Ada.Containers
    Ada.Containers.Doubly_Linked_Lists
    Ada.Containers.Generic_Anonymous_Array_Sort
    Ada.Containers.Generic_Array_Sort
    Ada.Containers.Generic_Constrained_Array_Sort
    Ada.Containers.Hash_Tables
    Ada.Containers.Hash_Tables.Generic_Keys
    Ada.Containers.Hash_Tables.Generic_Operations
    Ada.Containers.Hashed_Maps
    Ada.Containers.Hashed_Sets
    Ada.Containers.Indefinite.Doubly_Linked_Lists
    Ada.Containers.Indefinite_Hashed_Maps
    Ada.Containers.Indefinite_Hashed_Sets
    Ada.Containers.Indefinite_Ordered_Maps
    Ada.Containers.Indefinite_Ordered_Multisets
    Ada.Containers.Indefinite_Ordered_Sets
    Ada.Containers.Indefinite_Vectors
    Ada.Containers.Ordered_Maps
    Ada.Containers.Ordered_Multisets
    Ada.Containers.Ordered_Sets
    Ada.Containers.Prime_Numbers
    Ada.Containers.Red_Black_Trees
    Ada.Containers.Red_Black_Trees.Generic_Keys
    Ada.Containers.Red_Black_Trees.Generic_Operations
    Ada.Containers.Red_Black_Trees.Generic_Set_Operations
    Ada.Containers.Vectors
    Ada.Directories
    Ada.Strings.Equal_Case_Insensitive
    Ada.Strings.Hash
    Ada.Strings.Hash_Case_Insensitive
    Ada.Strings.Less_Case_Insensitive
    Ada.Strings.Unbounded.Hash
    Ada.Strings.Wide_Hash
    Ada.Strings.Wide_Unbounded.Hash

NF-A05-DC16-049 AI-303 No library-level interrupt handler check (2005-05-06)

  The Ada 95 RM explicit forbids protected objects that contain interrupt
  handlers to be declared at other than library level. This AI notes that this
  rule is redundant, because accessibility rules are already sufficient to make
  the use of such protected objects illegal. The corresponding sentence has
  been removed from the RM, and no error message is produced for the object
  declaration by itself.

NF-A05-D127-005 AI-305 No_Dynamic_Attachment (2004-04-25)

  This restriction ensures that there is no call to any of the operations
  defined in package Ada.Interrupts. This is the same as No_Dynamic_Interrupts,
  which is retained but considered obsolescent.

NF-A05-D127-007 AI-305 No_Task_Attributes_Package restriction (2004-02-04)

  This restriction ensures at compile time that there are no implicit or
  explicit dependencies on the package Ada.Task_Attributes. This is equiavlent
  to the previous No_Task_Attributes restriction, which is retained, but is
  considered obsolescent.

NF-A05-D127-011 AI-305 No_Requeue_Statements restriction (2004-01-29)

  This restriction forbids the use of requeue statements. This is equivalent to
  No_Requeue, which is retained, but which considered obsolescent.

NF-A05-D127-013 AI-305 Simple_Barriers restriction (2004-04-30)

  This restriction forbids entry barrier condition expressions other than
  boolean objects declared in the protected type which contains the entry.

NF-A05-D127-020 AI-305 pragma Detect_Blocking (2004-09-02)

  This configuration pragma forces the detection of potentially blocking
  operations in a protected operation. Program_Error is raised in this case.

NF-A05-DC16-051 AI-306 Class-wide extension aggregate expression (2005-01-12)

  This AI fixes the following language rule: "If the ancestor part of an
  aggregate is an expression, the expression must not be dynamically tagged."

NF-A05-E508-013 AI-309 Formal param usable only once (0000-00-00)

  This AI ensures that it is illegal to mention the same formal parameter of a
  generic twice, or to omit formals that do not have default values. These
  obvious rules apply in both Ada 95 and Ada 2005, and have always been
  implemented in GNAT.

NF-A05-D403-003 AI-310 Overloading ignores abstract subprograms (2005-04-29)

  This AI specifies that in processing an overloaded call, interpretations of
  abstract non-dispatching operations need not be considered for resolution.
  This rule allows resolution of overloaded calls that were ambiguous in Ada
  95. It allows the user to hide an inherited operation by declaring an
  abstract version that effectively hides the inherited one, a technique that
  is particularly useful with predefined numeric types.

NF-A05-DC16-053 AI-311 Static match of scalar formal subtypes (2005-01-13)

  Ada 2005 fixes the definition of statically matching constraints. A
  constraint "statically matches" another constraint if: 1) both are null
  constraints; 2) both are static and have equal corresponding bounds or
  discriminant values; 3) both are nonstatic and result from the same
  elaboration of a constraint of a subtype_indication or the same evaluation of
  a range of a discrete subtype definition>; or 4) both are nonstatic and both
  come from the same formal type declaration

NF-A05-DC16-054 AI-312 Library level visibility generic children (0000-00-00)

  This AI corrects a small gap in the visibility rules for context clauses.
  Wording in RM95 makes a reference to Par.Child illegal in a context clause
  or in a pragma that appears as a compilation unit, if Par.Child is a generic
  child unit, because Par is not a legal prefix for an expanded name. The AI
  simply indicates that this reference is in fact legal. GNAT always treated
  such references correctly.

NF-A05-DC16-055 AI-316 Accessibility checks and value conversions (2004-12-22)

  This AI is classified as a ramification and clarifies that the rule of
  6.5(18) applies to any type conversion (including a value conversion) that
  can be used as the return expression for a return-by-reference type. This
  rule was already followed correctly by GNAT.

NF-A05-D526-004 AI-317 Partial parametrization of formal packages (2006-04-21)

  This AI extends the functionality of formal packages, by allowing them
  to be specified with a partial list of actuals, rather the all-or-none
  approach of Ada 95. A formal package can be specified with a box (<>)
  or individual generic associations can carry a box while others have
  real actuals. The visibility rules for the generic formals of formal
  packages generalize those of Ada95, namely a formal is visible in the
  enclosing generic if it is specified with a box, explicitly or implicitly.

NF-A05-DC16-057 AI-318 Limited and anonymous access return types (2006-05-10)

  This AI introduces the capability of calling functions with a limited result
  type in places that are illegal in Ada 95. Such functions can now be called
  in the initialization of limited objects, in initialized allocators, as the
  result expression of return statements, and in several other contexts. GNAT
  currently only supports limited functions whose result subtype is constrained
  and does not have task, protected, or controlled parts. Current restrictions
  on the use of this feature are flagged by the compiler. This introduces an
  incompatiblity with Ada 95 limited return-by-reference functions, which have
  been supplanted by a new feature of functions with anonymous access results.
  To ease transition, a switch (-gnatd.l) is provided to allow compilation of
  the old form of limited functions. A new form of return statement, called
  the extended return statement, that declares a distinguished return object
  and can include statements, is also added under this AI to provide additional
  flexibility for initializing function results.

NF-A05-EC05-010 AI-321 Definition of dispatching policies (0000-00-00)

  This AI is a documentation change only. As noted in the text of the AI, it
  does not change any Ada 95 semantics, so does not affect the implementation.

NF-A05-DC16-058 AI-326 Tagged incomplete types (2005-07-04)

  This AI introduces the concept of a "tagged incomplete" type, which is a type
  that has the same restrictions as an incomplete type except that it may also
  be used for a formal or actual parameter. For most types, the compiler needs
  to see the full definition to know how parameters of the type are passed.
  However, because tagged types are always passed by reference, there is no
  implementation difficulty in allowing them to be used as parameters even when
  the full definition of the type is not available.

NF-A05-EC07-026 AI-328 Preinstantiations of Complex_IO (2005-12-07)

  This AI introduces preinstantiations of Complex_IO:
    Ada.Complex_Text_IO
    Ada.Long_Complex_Text_IO
    Ada.Long_Long_Complex_Text_IO
    Ada.Short_Complex_Text_IO

NF-A05-EC07-021 AI-329 Procedures that never return (2005-12-10)

  This AI is basically an adoption of the existing GNAT pragma No_Return. There
  were three additions. First, pragma No_Return can take multiple arguments.
  Second, a missing implicit return in a No_Return procedure now generates a
  warning and raises Program_Error at run-time rather than being considered an
  error, and finally calling Raise_Exception with a null Exception_Id raises
  Constraint_Error instead of returning silently. All three features are fully
  implemented. The first two are also implemented in Ada 95 mode. The third
  affects operation in Ada 2005 mode only.

NF-A05-DC16-060 AI-331 Instantiation of generic child units (2004-12-28)

  This AI clarifies the intent of RM 10.1.1(19) that generic child unit can be
  instantiated at any level of nesting (the original wording left this
  unclear). GNAT has always implemented this properly.

NF-A05-DC16-061 AI-332 Resolution of qualified expressions (2004-12-28)

  This AI clarifies the resolution rules for qualified expressions, object
  renaming, and other constructs, for which the term "expected type" is not
  used. GNAT implements properly the intent of this AI.

NF-A05-DC16-062 AI-334 Overriding of abstract equality required (2005-03-30)

  This AI clarifies that a nonlimited, nonabstract type extension that derives
  from a type with an abstract equality operation must override its own
  implicit equality operation (which is not inherited in this case, but is a
  predefined operation of the extension). This rule was already followed
  correctly by GNAT.

NF-A05-DC16-063 AI-335 Stream attributes may be dispatching (2005-12-06)

  This AI defines the stream attributes for tagged types to be dispatching
  operations. In Ada 95, the Class versions of the stream attributes were
  defined to dispatch to non-Class attributes, but the non-Class versions
  could not be dispatched to directly.

NF-A05-DC16-064 AI-340 New attribute Mod (2004-12-26)

  This AI introduces a new attribute Mod, available for any modular type, with
  one argument, which can be of any integer type. The result is this integer
  value mod the modulus of the modular type. This attribute is available only
  in Ada 2005 mode (-gnat05 switch). That's because mod is a reserved word, and
  it requires a change in the syntax to allow a new reserved word as an
  attribute identifier.

NF-A05-DC16-065 AI-344 Nested type extensions (2005-05-16)

  This AI relaxes the restrictions on type extensions to permit extending a
  tagged type within nested scopes, such as within subprograms, tasks and block
  statements. Checks on class-wide allocators, functions results and stream
  attributes prevent the creation of dangling references to objects of deeper
  types. The AI also introduces two new predefined operations in Ada.Tags,
  Descendant_Tag and Is_Descendant_At_Same_Level, to support checking within
  user-defined class-wide stream attributes.

NF-A05-DB24-009 AI-345 Protected and task interfaces (2005-05-06)

  This AI allows the use of interfaces with protected and task types. The
  primitive operations of the interfaces are inherited by the protected or task
  type. The overriding of the interface primitives is performed in the usual
  way, by declaring overriding primitives of the protected or task type, or by
  declaring entries or protected subprograms that override the primitive of the
  interface once it has been transformed into a "prefix" notation (AI-252).

NF-A05-DC16-066 AI-348 Null procedures (2005-04-04)

  Null procedures are declared by means of the syntax:
       <procedure_specification> is null;
  Null procedures can also appear as defaults formal subprograms, in which case
  they are intrinsic in an instance. Null procedures do not require a
  completion, and cannot be used as completions.

NF-A05-EC07-022 AI-355 Priority specific dispatching (2006-05-05)

  This AI allows specification and combining of priority specific dispatching
  policies. It allows any priority level/band to have a specific scheme
  defined. A Round_Robin_Within_Priorities dispatching policy is also defined.

NF-A05-DC16-069 AI-361 Raise with string message (2005-03-03)

  This allows the use of a "WITH string" phrase in a raise statement. The
  effect is the same as calling the routine Raise_Exception with the given
  string expression.

NF-A05-E505-004 AI-362 Recategorization of packages (2005-05-15)

  This AI recategorizes several packages as follows:

   Ada.Asynchronous_Task_Control is declared preelaborated.
   Ada.Characters.Handling is declared pure.
   Ada.Dynamic_Priorities is declared preelaborated.
   Ada.Exceptions is declared preelaborated.
   Ada.Strings.Maps is declared pure.
   Ada.Strings.Maps.Constants is declared pure.
   Ada.Synchronous_Task_Control is declared preelaborated.
   Ada.Tags is declared preelaborated.
   Ada.Task_Identification is declared preelaborated.
   System is declared pure.
   System.Storage_Elements is declared pure.

  The last two cases are allowed in Ada 95, and have always been categorized as
  Pure in GNAT. The others are recategorized as shown (only in Ada 2005 mode).

NF-A05-DC16-070 AI-363 Eliminating access types problems (2005-05-12)

  This AI disallows access subtypes for general access types that have defaults
  for their discriminants, or for any access type that completes a private view
  that has no discriminants. This allows for unconstrained heap objects, when
  the private view has no discriminants. Previously, if such a type was
  completed by a discriminated type with defaults, objects of the type could be
  freely assigned to each other, but if the objects were heap-allocated they
  had to be treated as constrained, and assignments would fail. This AI makes
  it possible to have heap-allocated objects for which a full assignment can
  change the value of the discriminant. Also, aliased objects and components
  can now generally be declared unconstrained when their type has defaulted
  discriminants, and such objects, which were constrained by their initial
  value in Ada 95, are now mutable.

NF-A05-DC16-071 AI-364 Fixed-point multiply and divide operations (2004-12-27)

  In Ada 2005, a special name resolution rule applies to user-defined
  multiplication and division operators on fixed-point types. If fixed-point
  type has such primitive operation, the predefined operator of the same name
  is not available. This rule fixes an incompatibility between Ada 83 and Ada
  95, and makes the user-defined operators easier to use.

NF-A05-DC16-072 AI-366 Relaxed rules for pure access types (2005-05-07)

  In Ada 2005, access-to-subprogram types can be declared freely in pure
  packages. In addition access-to-object types can also be declared in pure
  packages if they have no associated storage pool (the result of a
  Storage_Size clause specifying a zero collection size). The AI also notes
  that access types in generic formal parts are allowed, but these have always
  been allowed in GNAT.

NF-A05-DC16-073 AI-368 New restriction No_Obsolescent_Features (2004-12-22)

  This AI introduces a new restriction No_Obsolescent_Features, with the
  expected semantics of restricting use of Annex J features. The identifier can
  be used in pragma Restrictions or Restriction_Warnings. Note that the related
  warning -gnatwj is retained, since it is not quite the same, in that it also
  warns on use of obsolete GNAT features.

NF-A05-DC16-040 AI-369 Generic formal objects static in instance (2004-12-20)

  This AI specifies that the name of a formal object of mode in associated with
  a static actual denotes a static constant in the instance. This rules has
  always been followed by GNAT.

NF-A05-DC16-074 AI-370 Environment variables (2005-12-18)

  This AI adds a package Ada.Environment_Variables which provides functions
  to manipulate environment variables.

NF-A05-DC16-075 AI-377 Naming of generic child packages (2004-12-28)

  This AI addresses a pathological visibility issue involving the implicit
  declaration of a generic child unit that is present within an instantiation
  of its parent. Specifically, a context clause has to be rejected when an
  instance I1 of a generic unit G1 has an explicit child unit I1.G2, G1 has a
  generic child also named G2, and the context includes with_clauses for both
  I1.G2 and for G1.G2, making the implicit declaration of the generic child
  unit I1.G2 visible as well.

NF-A05-DC16-076 AI-381 Restriction No_Dependence (2004-12-30)

  This new restriction allows the specification of arbitrary packages to be
  excluded from the semantic dependencies of a partition. This new restriction
  form (No_Dependence => unit) is allowed in both the standard Restrictions
  pragma, and in the GNAT pragma Restriction_Warnings. Note that, contrary to
  the current writeup (rev 1.7) of the AI, we have implemented the so-called
  syntactic approach which does not restrict the named package to be one of the
  language predefined ones. This is still under discussion in the ARG, and we
  anticipate that this approach will be the preferred one.

NF-A05-DC16-077 AI-382 Current instance rule for access types (2005-06-08)

  This AI modifies the Ada 95 "current instance" rule that states that the name
  of a type within its own declaration, when legal, denotes the current object
  of the type, and not the type itself The new rule states that in the context
  of an anonymous access definition, the name denotes the type itself and not
  the object. This allows Ada 2005 to recover the C / Pascal notation for
  lists, without the need for incomplete type declarations:

     type Node is record
        Value : Integer;
        Next  : access Node;
        Prev  : access Node;
     end record;

NF-A05-DC16-078 AI-384 Conversion rule for access subtypes (2004-12-18)

  This AI provides a symmetric legality rule for conversions of access
  subtypes. The conversion is now legal when either designated type is
  unconstrained, at the expense of a possible constraint check.

NF-A05-DC16-079 AI-385 Stand-alone anonymous access type objects (2005-05-20)

  This AI extends the use of anonymous access types to object declarations.
  Previous AI's allowed anonymous access types to appear in renaming
  declarations and in component declarations.

NF-A05-DC16-080 AI-386 New functions returning time spans (2005-02-17)

  This adds the functions Minutes and Seconds to the package Ada.Real_Time for
  improved convenience in setting longer periods of time.

NF-A05-DC16-081 AI-388 Add Greek Pi to Ada.Numerics (2004-12-27)

  Ada.Numerics now contains an additional declaration using the greek letter pi
  as the identifier, with the same value as the previously available definition
  under the identifier Pi (which is retained). In Ada 2005 mode, wide
  characters can always appear in identifiers.

NF-A05-DC16-083 AI-391 Controlling-result functions in extensions (2005-12-19)

  This AI permits a type extension to inherit functions with controlling
  results without requiring such functions to be overridden as long as the
  extension part is null and the type declares no discriminants.

NF-A05-E508-002 AI-392 Forbid unsafe array conversions (2006-03-24)

  This AI specifies accessibility checks that must be performed on array
  conversions, when the component types are anonymous access types. The
  rule guarantee that no dangling references can be created by such
  conversions.

NF-A05-E505-002 AI-394 Restriction identifiers and Ravenscar (2005-12-06)

  This AI moves some restriction identifiers to Annex J (obsolescent features)
  and completes the definition of the Ravenscar profile.

NF-A05-E328-003 AI-395 Clarifications for Wide_[Wide_]Character (2005-04-21)

  This AI is a grab bag of changes and additions to AI 295. Included are:
  allowing other format characters in string and character literals, changes in
  language defined names to keep width to 12, forbid FFFE/FFFF in all planes,
  and provide new packages Ada.Characters.Conversions and the dummy packages
  Ada.Wide_[Wide_]Characters. In addition the names used by Image/Value for
  wide characters are made uniform and simple (Hex_hhhhhhhh). Finally, new
  packages Ada.Wide_[Wide_]Characters.Unicode are added to provide unicode
  classification functions for wide character and wide wide character. These
  are GNAT defined packages, but are defined as children of the new AI-395
  packages as recommended in the AI.

NF-A05-E508-011 AI-396 The "no hidden interfaces" rule (2005-06-07)

  This AI allows for an untagged partial view to be completed by a tagged type
  that implements at least one interface. The partial view must be either
  untagged, or descend from a type that implements the same interfaces as the
  full view.

NF-A05-E508-012 AI-397 Overriding entries and protected operations (2005-06-07)

  This AI extends the notion of overriding indicators (AI-218) to entries and
  protected subprograms. In this case an operation is said to "override" if it
  implements an operation of a parent interface, given that there is no notion
  of extending task or protected types.

NF-A05-E508-014 AI-399 Task/protected implementing interfaces (2005-05-15)

  Allow the use of single task and single protected objects implementing
  interfaces. AI-345 only allows a task or protected *type* to implement
  interfaces and this considered an unnecessary restriction because there is no
  reason to make single task or protected objects less functional than types.
  This is especially important if users want to take advantage of interfaces in
  existing code.

NF-A05-E505-001 AI-400 Wide functions in Ada.Tags/Exceptions (2005-12-20)

  Introduces functions Wide_[Wide_]Expanded_Name in package Ada.Tags and
  functions Wide_[Wide_]Exception_Name in package Ada.Exceptions.

NF-A05-F429-005 AI-403 Formal objects are not static  (2006-05-03)

  This AI specifies that for purposes of elaboration a formal object must
  be treated as non-static, and therefore cannot appear as a primary in
  a pure or preelaborable generic package.

NF-A05-E508-016 AI-404 Not null and all in access parameters (2005-05-17)

  This AI clarifies some uses of anonymous access types. The qualifier "all" is
  forbidden in the the declaration of an access parameter or access
  discriminant. A special check on access parameters that are controlling
  formals is now required when a dispatching operation renames a
  non-dispatching operation.

NF-A05-E508-017 AI-405 Scanning progenitor interfaces in Ada.Tags (2006-04-20)

  This AI adds a new subprogram to the package Ada.Tags to obtain the tag
  of all the abstract interface ancestors of a given tagged type.

NF-A05-E508-018 AI-406 Aliased objects of an anonymous access type (2005-05-20)

  This extends AI-385 (DC16-079) to allow objects of an anonymous access
  type to be aliased.

NF-A05-E508-019 AI-407 Terminology and semantics of prefixed views (2005-05-12)

  This AI clarifies the description of the Object.Op notation as described in
  AI-252. It adds a legality rule (already implemented as part of AI-252) that
  the prefixed view of such notation must be a variable if the operation has an
  out, in-out or access-to-variable first parameter.

NF-A05-E508-020 AI-408 Visibility of attribute definition clauses (0000-00-00)

  This AI corrects some mistakes in the RM concerning visibility of attribute
  definition clauses. Basically the change is to make the RM reflect the
  obvious intended rule, which has always been implemented in GNAT.

NF-A05-E508-021 AI-409 Resolution for anonymous access types (0000-00-00)

  This AI specifies matching rules for anonymous access to subprogram types.
  Overload resolution is based on type conformannce, while legality rules
  require mode or subtype conformance, depending on the context.

NF-A05-E508-023 AI-411 Equality for types derived from interfaces (2005-05-15)

  This AI is a discussion of wording only, and confirmation that every
  interface has an equality operation that is not abstract, and therefore does
  not need to be overridden by a type that implements a given interface.

NF-A05-EC07-018 AI-412 Renaming of incomplete type limited views (2006-03-12)

   This AI introduces subtypes of incomplete types and renamings of limited
   views as means of abbreviating long names in recursively dependent
   packages along with appropriate visibility rules for them. To be complete,
   the AI also introduces subtypes of non-limited withed incomplete types.

NF-A05-EC07-025 AI-414 No_Return consistency for overriding (2005-12-08)

  If a dispatching procedure has a No_Return pragma and is overridden, then
  the overriding procedure is now required to be No_Return, so that dispatching
  calls to the procedure get a consistent view.

NF-A05-EC07-028 AI-417 Lower bounds of functions in AI-400 (2005-12-20)

  Corrects an omission in AI-400 and specifies that the lower bound of results
  returned by Wide_[Wide_]Exception_Name and Wide_[Wide_]Expanded_Name is 1.

NF-A05-E720-013 AI-419 Limitedness of derived types (2005-12-07)

  This AI establishes that limitedness is not inherited from interfaces, so
  that a non-limited type can have limited progenitors. As a consequence,
  new syntax is needed to indicate that a derived type is intended to be
  limited. the keyword "limited" can now appear in derived type declarations
  and in formal derived type declarations.

NF-A05-EC07-031 AI-420 Resolution of standard operators (2006-01-19)

  This AI provides preference rules that apply to the Universal_Access
  equality declared in Standard. The visibility rules for this operator
  are intended to prevent the problems caused by the Ada 95 rules on
  the universal fixed operators, and simplify the writing of user-defined
  composite types, when they have a component of an anonymous access to
  themselves, such as linked lists.

NF-A05-EC07-033 AI-423 Renamings, objects and null exclusions (2006-04-11)

   This AI introduces two new grammar constructs dealing with object renaming
   and formal object declarations which incorporate access definitions or
   subtype marks with an optional null exclusion. The new legality rules
   require null exclusions in renamed entities or subprograms whenever the
   renamings impose such exclusions. Otherwise the renamings are not required
   to have null exclusions.

NF-A05-EC07-037 AI-426 Abnormal and invalid values from conversion (0000-00-00)

  This AI requires that Unchecked_Conversion never generate abnormal values
  for scalars. Invalid values can be generated. The point is that it is always
  safe to use 'Valid to test the validity of such results. This has always been
  the case in GNAT.

NF-A05-EB29-014 AI-428 Bounded IO (2006-01-10)

   This AI provides specs for input and output of [[Wide_[Wide_]]Bounded
   strings.

NF-A05-EC07-036 AI-430 Conventions of inherited operations (2006-03-28)

   This AI provides semantic rules concerning the consistency of conventions
   among inherited, overridden and overriding operations for a type. It
   prevents the presence of numerous conventions, declared either implicitly
   or explicitly, on a single overriding subprogram.

NF-A05-EC07-038 AI-431 Remote access-to-subprogram conversions (0000-00-00)

  This AI forbids all conversions between remote access-to-subprogram and
  local access-to-subprogrmam types. This was already implemented in GNAT
  and was actually tested by ACATS test BXE2011; the AI merely closed a gap
  in the language by explicitly adding a missing clause to prohibit the
  conversion of a local access-to-subprogram value to a remote access-to-
  subprogram type.

NF-A05-F429-006 AI-435 Storage_Pool/Size for access to subprogram (2005-04-29)

  This AI forbids the use of Storage_Pool and Storage_Size attributes for
  access-to-subprogram types. These were previously allowed, but did nothing
  useful, and they are now flagged as illegal.

NF-A05-F429-007 AI-436 Record representation for limited records (0000-00-00)

  This AI allows the use of record represenation clauses for limited record
  types. GNAT has always permitted this usage.

NF-A05-EB10-004 AI-441 Null-exclusion under Ada95 mode (2005-11-10)

  This AI allows the use of the "not-null" qualifier under Ada95 mode because
  all access parameters are "not null" in Ada 95. In addition, the first
  parameter of the stream attributes is now explicitly declared to be a not
  null access type.
