Copyright @copyright{} 1995-2008, Free Software Foundation, Inc.
Permission is granted to copy, distribute and/or modify this document
-under the terms of the GNU Free Documentation License, Version 1.2 or
+under the terms of the GNU Free Documentation License, Version 1.3 or
any later version published by the Free Software Foundation; with no
Invariant Sections, with the Front-Cover Texts being ``GNAT Reference
Manual'', and with no Back-Cover Texts. A copy of the license is
* Interfacing to Other Languages::
* Specialized Needs Annexes::
* Implementation of Specific Ada Features::
-* Project File Reference::
+* Implementation of Ada 2012 Features::
* Obsolescent Features::
* GNU Free Documentation License::
* Index::
* Pragma Ada_95::
* Pragma Ada_05::
* Pragma Ada_2005::
+* Pragma Ada_12::
+* Pragma Ada_2012::
* Pragma Annotate::
* Pragma Assert::
+* Pragma Assume_No_Invalid_Values::
* Pragma Ast_Entry::
* Pragma C_Pass_By_Copy::
* Pragma Check::
* Pragma Common_Object::
* Pragma Compile_Time_Error::
* Pragma Compile_Time_Warning::
+* Pragma Compiler_Unit::
* Pragma Complete_Representation::
* Pragma Complex_Representation::
* Pragma Component_Alignment::
* Pragma Export_Value::
* Pragma Export_Valued_Procedure::
* Pragma Extend_System::
+* Pragma Extensions_Allowed::
* Pragma External::
* Pragma External_Name_Casing::
* Pragma Fast_Math::
* Pragma Finalize_Storage_Only::
* Pragma Float_Representation::
* Pragma Ident::
-* Pragma Implemented_By_Entry::
+* Pragma Implemented::
* Pragma Implicit_Packing::
* Pragma Import_Exception::
* Pragma Import_Function::
* Pragma Interface_Name::
* Pragma Interrupt_Handler::
* Pragma Interrupt_State::
+* Pragma Invariant::
* Pragma Keep_Names::
* Pragma License::
* Pragma Link_With::
* Pragma Normalize_Scalars::
* Pragma Obsolescent::
* Pragma Optimize_Alignment::
+* Pragma Ordered::
* Pragma Passive::
* Pragma Persistent_BSS::
* Pragma Polling::
* Pragma Pure_Function::
* Pragma Restriction_Warnings::
* Pragma Shared::
+* Pragma Short_Circuit_And_Or::
+* Pragma Short_Descriptors::
* Pragma Source_File_Name::
* Pragma Source_File_Name_Project::
* Pragma Source_Reference::
* Pragma Task_Info::
* Pragma Task_Name::
* Pragma Task_Storage::
+* Pragma Thread_Local_Storage::
* Pragma Time_Slice::
* Pragma Title::
* Pragma Unchecked_Union::
* AST_Entry::
* Bit::
* Bit_Position::
+* Compiler_Version::
* Code_Address::
* Default_Bit_Order::
* Elaborated::
* Passed_By_Reference::
* Pool_Address::
* Range_Length::
+* Result::
* Safe_Emax::
* Safe_Large::
* Small::
* Wide_Text_IO::
* Wide_Wide_Text_IO::
* Stream_IO::
+* Text Translation::
* Shared Files::
* Filenames encoding::
* Open Modes::
* Ada.Strings.Wide_Unbounded.Wide_Text_IO (a-swuwti.ads)::
* Ada.Strings.Wide_Wide_Unbounded.Wide_Wide_Text_IO (a-szuzti.ads)::
* Ada.Text_IO.C_Streams (a-tiocst.ads)::
+* Ada.Text_IO.Reset_Standard_Files (a-tirsfi.ads)::
* Ada.Wide_Characters.Unicode (a-wichun.ads)::
* Ada.Wide_Text_IO.C_Streams (a-wtcstr.ads)::
+* Ada.Wide_Text_IO.Reset_Standard_Files (a-wrstfi.ads)::
* Ada.Wide_Wide_Characters.Unicode (a-zchuni.ads)::
* Ada.Wide_Wide_Text_IO.C_Streams (a-ztcstr.ads)::
+* Ada.Wide_Wide_Text_IO.Reset_Standard_Files (a-zrstfi.ads)::
* GNAT.Altivec (g-altive.ads)::
* GNAT.Altivec.Conversions (g-altcon.ads)::
* GNAT.Altivec.Vector_Operations (g-alveop.ads)::
* GNAT.IO (g-io.ads)::
* GNAT.IO_Aux (g-io_aux.ads)::
* GNAT.Lock_Files (g-locfil.ads)::
+* GNAT.MBBS_Discrete_Random (g-mbdira.ads)::
+* GNAT.MBBS_Float_Random (g-mbflra.ads)::
* GNAT.MD5 (g-md5.ads)::
* GNAT.Memory_Dump (g-memdum.ads)::
* GNAT.Most_Recent_Exception (g-moreex.ads)::
* GNAT.Semaphores (g-semaph.ads)::
* GNAT.Serial_Communications (g-sercom.ads)::
* GNAT.SHA1 (g-sha1.ads)::
+* GNAT.SHA224 (g-sha224.ads)::
+* GNAT.SHA256 (g-sha256.ads)::
+* GNAT.SHA384 (g-sha384.ads)::
+* GNAT.SHA512 (g-sha512.ads)::
* GNAT.Signals (g-signal.ads)::
* GNAT.Sockets (g-socket.ads)::
* GNAT.Source_Info (g-souinf.ads)::
* GNAT.Spitbol.Table_Boolean (g-sptabo.ads)::
* GNAT.Spitbol.Table_Integer (g-sptain.ads)::
* GNAT.Spitbol.Table_VString (g-sptavs.ads)::
+* GNAT.SSE (g-sse.ads)::
+* GNAT.SSE.Vector_Types (g-ssvety.ads)::
* GNAT.Strings (g-string.ads)::
* GNAT.String_Split (g-strspl.ads)::
* GNAT.Table (g-table.ads)::
* System.Pool_Local (s-pooloc.ads)::
* System.Restrictions (s-restri.ads)::
* System.Rident (s-rident.ads)::
+* System.Strings.Stream_Ops (s-ststop.ads)::
* System.Task_Info (s-tasinf.ads)::
* System.Wch_Cnv (s-wchcnv.ads)::
* System.Wch_Con (s-wchcon.ads)::
* The Size of Discriminated Records with Default Discriminants::
* Strict Conformance to the Ada Reference Manual::
-Project File Reference
+Implementation of Ada 2012 Features
Obsolescent Features
other features.
@item
-@ref{Project File Reference}, presents the syntax and semantics
-of project files.
+@ref{Implementation of Ada 2012 Features}, describes the status of the
+GNAT implementation of the Ada 2012 language standard.
@item
@ref{Obsolescent Features} documents implementation dependent features,
@noindent
Ada defines a set of pragmas that can be used to supply additional
information to the compiler. These language defined pragmas are
-implemented in GNAT and work as described in the Ada Reference
-Manual.
+implemented in GNAT and work as described in the Ada Reference Manual.
In addition, Ada allows implementations to define additional pragmas
whose meaning is defined by the implementation. GNAT provides a number
* Pragma Ada_95::
* Pragma Ada_05::
* Pragma Ada_2005::
+* Pragma Ada_12::
+* Pragma Ada_2012::
* Pragma Annotate::
* Pragma Assert::
+* Pragma Assume_No_Invalid_Values::
* Pragma Ast_Entry::
* Pragma C_Pass_By_Copy::
* Pragma Check::
* Pragma Common_Object::
* Pragma Compile_Time_Error::
* Pragma Compile_Time_Warning::
+* Pragma Compiler_Unit::
* Pragma Complete_Representation::
* Pragma Complex_Representation::
* Pragma Component_Alignment::
* Pragma Export_Value::
* Pragma Export_Valued_Procedure::
* Pragma Extend_System::
+* Pragma Extensions_Allowed::
* Pragma External::
* Pragma External_Name_Casing::
* Pragma Fast_Math::
* Pragma Finalize_Storage_Only::
* Pragma Float_Representation::
* Pragma Ident::
-* Pragma Implemented_By_Entry::
+* Pragma Implemented::
* Pragma Implicit_Packing::
* Pragma Import_Exception::
* Pragma Import_Function::
* Pragma Interface_Name::
* Pragma Interrupt_Handler::
* Pragma Interrupt_State::
+* Pragma Invariant::
* Pragma Keep_Names::
* Pragma License::
* Pragma Link_With::
* Pragma Normalize_Scalars::
* Pragma Obsolescent::
* Pragma Optimize_Alignment::
+* Pragma Ordered::
* Pragma Passive::
* Pragma Persistent_BSS::
* Pragma Polling::
* Pragma Pure_Function::
* Pragma Restriction_Warnings::
* Pragma Shared::
+* Pragma Short_Circuit_And_Or::
+* Pragma Short_Descriptors::
* Pragma Source_File_Name::
* Pragma Source_File_Name_Project::
* Pragma Source_Reference::
* Pragma Task_Info::
* Pragma Task_Name::
* Pragma Task_Storage::
+* Pragma Thread_Local_Storage::
* Pragma Time_Slice::
* Pragma Title::
* Pragma Unchecked_Union::
@noindent
A configuration pragma that establishes Ada 2005 mode for the unit to which
it applies, regardless of the mode set by the command line switches.
-This mode is set automatically for the @code{Ada} and @code{System}
-packages and their children, so you need not specify it in these
-contexts. This pragma is useful when writing a reusable component that
+This pragma is useful when writing a reusable component that
itself uses Ada 2005 features, but which is intended to be usable from
either Ada 83 or Ada 95 programs.
This configuration pragma is a synonym for pragma Ada_05 and has the
same syntax and effect.
+@node Pragma Ada_12
+@unnumberedsec Pragma Ada_12
+@findex Ada_12
+@noindent
+Syntax:
+@smallexample @c ada
+pragma Ada_12;
+@end smallexample
+
+@noindent
+A configuration pragma that establishes Ada 2012 mode for the unit to which
+it applies, regardless of the mode set by the command line switches.
+This mode is set automatically for the @code{Ada} and @code{System}
+packages and their children, so you need not specify it in these
+contexts. This pragma is useful when writing a reusable component that
+itself uses Ada 2012 features, but which is intended to be usable from
+Ada 83, Ada 95, or Ada 2005 programs.
+
+@node Pragma Ada_2012
+@unnumberedsec Pragma Ada_2012
+@findex Ada_2005
+@noindent
+Syntax:
+@smallexample @c ada
+pragma Ada_2012;
+@end smallexample
+
+@noindent
+This configuration pragma is a synonym for pragma Ada_12 and has the
+same syntax and effect.
+
@node Pragma Annotate
@unnumberedsec Pragma Annotate
@findex Annotate
@noindent
Syntax:
@smallexample @c ada
-pragma Annotate (IDENTIFIER @{, ARG@});
+pragma Annotate (IDENTIFIER [,IDENTIFIER] @{, ARG@});
ARG ::= NAME | EXPRESSION
@end smallexample
@noindent
This pragma is used to annotate programs. @var{identifier} identifies
the type of annotation. GNAT verifies that it is an identifier, but does
-not otherwise analyze it. The @var{arg} argument
-can be either a string literal or an
-expression. String literals are assumed to be of type
-@code{Standard.String}. Names of entities are simply analyzed as entity
-names. All other expressions are analyzed as expressions, and must be
+not otherwise analyze it. The second optional identifier is also left
+unanalyzed, and by convention is used to control the action of the tool to
+which the annotation is addressed. The remaining @var{arg} arguments
+can be either string literals or more generally expressions.
+String literals are assumed to be either of type
+@code{Standard.String} or else @code{Wide_String} or @code{Wide_Wide_String}
+depending on the character literals they contain.
+All other kinds of arguments are analyzed as expressions, and must be
unambiguous.
The analyzed pragma is retained in the tree, but not otherwise processed
semantic correctness whether or not assertions are enabled, so turning
assertions on and off cannot affect the legality of a program.
+@node Pragma Assume_No_Invalid_Values
+@unnumberedsec Pragma Assume_No_Invalid_Values
+@findex Assume_No_Invalid_Values
+@cindex Invalid representations
+@cindex Invalid values
+@noindent
+Syntax:
+@smallexample @c ada
+pragma Assume_No_Invalid_Values (On | Off);
+@end smallexample
+
+@noindent
+This is a configuration pragma that controls the assumptions made by the
+compiler about the occurrence of invalid representations (invalid values)
+in the code.
+
+The default behavior (corresponding to an Off argument for this pragma), is
+to assume that values may in general be invalid unless the compiler can
+prove they are valid. Consider the following example:
+
+@smallexample @c ada
+V1 : Integer range 1 .. 10;
+V2 : Integer range 11 .. 20;
+...
+for J in V2 .. V1 loop
+ ...
+end loop;
+@end smallexample
+
+@noindent
+if V1 and V2 have valid values, then the loop is known at compile
+time not to execute since the lower bound must be greater than the
+upper bound. However in default mode, no such assumption is made,
+and the loop may execute. If @code{Assume_No_Invalid_Values (On)}
+is given, the compiler will assume that any occurrence of a variable
+other than in an explicit @code{'Valid} test always has a valid
+value, and the loop above will be optimized away.
+
+The use of @code{Assume_No_Invalid_Values (On)} is appropriate if
+you know your code is free of uninitialized variables and other
+possible sources of invalid representations, and may result in
+more efficient code. A program that accesses an invalid representation
+with this pragma in effect is erroneous, so no guarantees can be made
+about its behavior.
+
+It is peculiar though permissible to use this pragma in conjunction
+with validity checking (-gnatVa). In such cases, accessing invalid
+values will generally give an exception, though formally the program
+is erroneous so there are no guarantees that this will always be the
+case, and it is recommended that these two options not be used together.
+
@node Pragma Ast_Entry
@unnumberedsec Pragma Ast_Entry
@cindex OpenVMS
@noindent
Syntax:
@smallexample @c ada
-pragma Check_Policy ([Name =>] Identifier, POLICY_IDENTIFIER);
+pragma Check_Policy
+ ([Name =>] Identifier,
+ [Policy =>] POLICY_IDENTIFIER);
POLICY_IDENTIFIER ::= On | Off | Check | Ignore
@end smallexample
with a first parameter of True is to warn a client about use of a package,
for example that it is not fully implemented.
+@node Pragma Compiler_Unit
+@unnumberedsec Pragma Compiler_Unit
+@findex Compiler_Unit
+@noindent
+Syntax:
+
+@smallexample @c ada
+pragma Compiler_Unit;
+@end smallexample
+
+@noindent
+This pragma is intended only for internal use in the GNAT run-time library.
+It indicates that the unit is used as part of the compiler build. The effect
+is to disallow constructs (raise with message, conditional expressions etc)
+that would cause trouble when bootstrapping using an older version of GNAT.
+For the exact list of restrictions, see the compiler sources and references
+to Is_Compiler_Unit.
+
@node Pragma Complete_Representation
@unnumberedsec Pragma Complete_Representation
@findex Complete_Representation
@noindent
would allow the use of the convention identifier @code{Fortran77} in
subsequent code, avoiding the need to modify the sources. As another
-example, you could use this to parametrize convention requirements
+example, you could use this to parameterize convention requirements
according to systems. Suppose you needed to use @code{Stdcall} on
windows systems, and @code{C} on some other system, then you could
define a convention identifier @code{Library} and use a single
@noindent
The argument denotes an entity in the current declarative region that is
-declared as a tagged record type. It indicates that the type corresponds
-to an externally declared C++ class type, and is to be laid out the same
-way that C++ would lay out the type.
+declared as a record type. It indicates that the type corresponds to an
+externally declared C++ class type, and is to be laid out the same way
+that C++ would lay out the type. If the C++ class has virtual primitives
+then the record must be declared as a tagged record type.
Types for which @code{CPP_Class} is specified do not have assignment or
equality operators defined (such operations can be imported or declared
as subprograms as required). Initialization is allowed only by constructor
functions (see pragma @code{CPP_Constructor}). Such types are implicitly
limited if not explicitly declared as limited or derived from a limited
-type, and a warning is issued in that case.
+type, and an error is issued in that case.
Pragma @code{CPP_Class} is intended primarily for automatic generation
using an automatic binding generator tool.
@itemize @bullet
@item
+@code{function @var{Fname} return @var{T}}
+
+@itemize @bullet
+@item
@code{function @var{Fname} return @var{T}'Class}
@item
-@code{function @var{Fname} (@dots{}) return @var{T}'Class}
+@code{function @var{Fname} (@dots{}) return @var{T}}
@end itemize
-@noindent
-where @var{T} is a tagged type to which the pragma @code{CPP_Class} applies.
-
-The first form is the default constructor, used when an object of type
-@var{T} is created on the Ada side with no explicit constructor. Other
-constructors (including the copy constructor, which is simply a special
-case of the second form in which the one and only argument is of type
-@var{T}), can only appear in two contexts:
-
-@itemize @bullet
-@item
-On the right side of an initialization of an object of type @var{T}.
@item
-In an extension aggregate for an object of a type derived from @var{T}.
+@code{function @var{Fname} (@dots{}) return @var{T}'Class}
@end itemize
@noindent
-Although the constructor is described as a function that returns a value
-on the Ada side, it is typically a procedure with an extra implicit
-argument (the object being initialized) at the implementation
-level. GNAT issues the appropriate call, whatever it is, to get the
-object properly initialized.
-
-In the case of derived objects, you may use one of two possible forms
-for declaring and creating an object:
-
-@itemize @bullet
-@item @code{New_Object : Derived_T}
-@item @code{New_Object : Derived_T := (@var{constructor-call with} @dots{})}
-@end itemize
+where @var{T} is a limited record type imported from C++ with pragma
+@code{Import} and @code{Convention} = @code{CPP}.
-@noindent
-In the first case the default constructor is called and extension fields
-if any are initialized according to the default initialization
-expressions in the Ada declaration. In the second case, the given
-constructor is called and the extension aggregate indicates the explicit
-values of the extension fields.
+The first two forms import the default constructor, used when an object
+of type @var{T} is created on the Ada side with no explicit constructor.
+The latter two forms cover all the non-default constructors of the type.
+See the GNAT users guide for details.
If no constructors are imported, it is impossible to create any objects
-on the Ada side. If no default constructor is imported, only the
-initialization forms using an explicit call to a constructor are
-permitted.
+on the Ada side and the type is implicitly declared abstract.
Pragma @code{CPP_Constructor} is intended primarily for automatic generation
using an automatic binding generator tool.
See @ref{Interfacing to C++} for more related information.
+Note: The use of functions returning class-wide types for constructors is
+currently obsolete. They are supported for backward compatibility. The
+use of functions returning the type T leave the Ada sources more clear
+because the imported C++ constructors always return an object of type T;
+that is, they never return an object whose type is a descendant of type T.
+
@node Pragma CPP_Virtual
@unnumberedsec Pragma CPP_Virtual
@cindex Interfacing to C++
Syntax:
@smallexample @c ada
-pragma Eliminate (
- [Unit_Name =>] IDENTIFIER |
- SELECTED_COMPONENT);
+pragma Eliminate (UNIT_NAME, ENTITY, Source_Location => SOURCE_TRACE)
-pragma Eliminate (
- [Unit_Name =>] IDENTIFIER |
- SELECTED_COMPONENT,
- [Entity =>] IDENTIFIER |
- SELECTED_COMPONENT |
- STRING_LITERAL
- [,OVERLOADING_RESOLUTION]);
+UNIT_NAME ::= IDENTIFIER |
+ SELECTED_COMPONENT,
-OVERLOADING_RESOLUTION ::= PARAMETER_AND_RESULT_TYPE_PROFILE |
- SOURCE_LOCATION
+ENTITY ::= IDENTIFIER |
+ SELECTED_COMPONENT,
-PARAMETER_AND_RESULT_TYPE_PROFILE ::= PROCEDURE_PROFILE |
- FUNCTION_PROFILE
+SOURCE_TRACE ::= SOURCE_REFERENCE |
+ SOURCE_REFERENCE LBRACKET SOURCE_TRACE RBRACKET
-PROCEDURE_PROFILE ::= Parameter_Types => PARAMETER_TYPES
+LBRACKET ::= [
+RBRACKET ::= ]
-FUNCTION_PROFILE ::= [Parameter_Types => PARAMETER_TYPES,]
- Result_Type => result_SUBTYPE_NAME]
+SOURCE_REFERENCE ::= FILE_NAME : LINE_NUMBER
-PARAMETER_TYPES ::= (SUBTYPE_NAME @{, SUBTYPE_NAME@})
-SUBTYPE_NAME ::= STRING_VALUE
-
-SOURCE_LOCATION ::= Source_Location => SOURCE_TRACE
-SOURCE_TRACE ::= STRING_VALUE
-
-STRING_VALUE ::= STRING_LITERAL @{& STRING_LITERAL@}
+FILE_NAME ::= STRING_LITERAL
+LINE_NUMBER ::= INTEGER_LITERAL
@end smallexample
@noindent
-This pragma indicates that the given entity is not used outside the
-compilation unit it is defined in. The entity must be an explicitly declared
-subprogram; this includes generic subprogram instances and
-subprograms declared in generic package instances.
-
-If the entity to be eliminated is a library level subprogram, then
-the first form of pragma @code{Eliminate} is used with only a single argument.
-In this form, the @code{Unit_Name} argument specifies the name of the
-library level unit to be eliminated.
-
-In all other cases, both @code{Unit_Name} and @code{Entity} arguments
-are required. If item is an entity of a library package, then the first
-argument specifies the unit name, and the second argument specifies
-the particular entity. If the second argument is in string form, it must
-correspond to the internal manner in which GNAT stores entity names (see
-compilation unit Namet in the compiler sources for details).
-
-The remaining parameters (OVERLOADING_RESOLUTION) are optionally used
-to distinguish between overloaded subprograms. If a pragma does not contain
-the OVERLOADING_RESOLUTION parameter(s), it is applied to all the overloaded
-subprograms denoted by the first two parameters.
-
-Use PARAMETER_AND_RESULT_TYPE_PROFILE to specify the profile of the subprogram
-to be eliminated in a manner similar to that used for the extended
-@code{Import} and @code{Export} pragmas, except that the subtype names are
-always given as strings. At the moment, this form of distinguishing
-overloaded subprograms is implemented only partially, so we do not recommend
-using it for practical subprogram elimination.
-
-Note that in case of a parameterless procedure its profile is represented
-as @code{Parameter_Types => ("")}
-
-Alternatively, the @code{Source_Location} parameter is used to specify
-which overloaded alternative is to be eliminated by pointing to the
-location of the DEFINING_PROGRAM_UNIT_NAME of this subprogram in the
-source text. The string literal (or concatenation of string literals)
-given as SOURCE_TRACE must have the following format:
+This pragma indicates that the given entity is not used in the program
+to be compiled and built. The entity must be an explicitly declared
+subprogram; this includes generic subprogram instances and
+subprograms declared in generic package instances. @code{Unit_Name}
+must be the name of the compilation unit in which the entity is declared.
-@smallexample @c ada
-SOURCE_TRACE ::= SOURCE_LOCATION@{LBRACKET SOURCE_LOCATION RBRACKET@}
-
-LBRACKET ::= [
-RBRACKET ::= ]
-
-SOURCE_LOCATION ::= FILE_NAME:LINE_NUMBER
-FILE_NAME ::= STRING_LITERAL
-LINE_NUMBER ::= DIGIT @{DIGIT@}
-@end smallexample
-
-SOURCE_TRACE should be the short name of the source file (with no directory
-information), and LINE_NUMBER is supposed to point to the line where the
-defining name of the subprogram is located.
-
-For the subprograms that are not a part of generic instantiations, only one
-SOURCE_LOCATION is used. If a subprogram is declared in a package
-instantiation, SOURCE_TRACE contains two SOURCE_LOCATIONs, the first one is
-the location of the (DEFINING_PROGRAM_UNIT_NAME of the) instantiation, and the
-second one denotes the declaration of the corresponding subprogram in the
-generic package. This approach is recursively used to create SOURCE_LOCATIONs
-in case of nested instantiations.
+The @code{Source_Location} argument is used to resolve overloading
+in case more then one callable entity with the same name is declared
+in the given compilation unit. Each file name must be the short name of the
+source file (with no directory information).
+If an entity is not declared in
+a generic instantiation (this includes generic subprogram instances),
+the source trace includes only one source
+reference. If an entity is declared inside a generic instantiation,
+its source trace starts from the source location in the instantiation and
+ends with the source location of the declaration of the corresponding
+entity in the generic
+unit. This approach is recursively used in case of nested instantiations:
+the leftmost element of the
+source trace is the location of the outermost instantiation, the next
+element is the location of the next (first nested) instantiation in the
+code of the corresponding generic unit, and so on.
The effect of the pragma is to allow the compiler to eliminate
the code or data associated with the named entity. Any reference to
-an eliminated entity outside the compilation unit it is defined in,
-causes a compile time or link time error.
+an eliminated entity outside the compilation unit where it is defined
+causes a compile-time or link-time error.
The intention of pragma @code{Eliminate} is to allow a program to be compiled
-in a system independent manner, with unused entities eliminated, without
-the requirement of modifying the source text. Normally the required set
+in a system-independent manner, with unused entities eliminated, without
+needing to modify the source text. Normally the required set
of @code{Eliminate} pragmas is constructed automatically using the gnatelim
tool. Elimination of unused entities local to a compilation unit is
automatic, without requiring the use of pragma @code{Eliminate}.
-Note that the reason this pragma takes string literals where names might
-be expected is that a pragma @code{Eliminate} can appear in a context where the
-relevant names are not visible.
+Any source file change that removes, splits, or
+adds lines may make the set of Eliminate pragmas invalid because their
+@code{Source_Location} argument values may get out of date.
-Note that any change in the source files that includes removing, splitting of
-adding lines may make the set of Eliminate pragmas using SOURCE_LOCATION
-parameter illegal.
-
-It is legal to use pragma Eliminate where the referenced entity is a
-dispatching operation, but it is not clear what this would mean, since
-in general the call does not know which entity is actually being called.
-Consequently, a pragma Eliminate for a dispatching operation is ignored.
+Pragma Eliminate may be used where the referenced entity is a
+dispatching operation. In this case all the subprograms to which the
+given operation can dispatch are considered to be unused (are never called
+as a result of a direct or a dispatching call).
@node Pragma Export_Exception
@unnumberedsec Pragma Export_Exception
definition. Note that such a package is a child of @code{System}
and thus is considered part of the implementation. To compile
it you will have to use the appropriate switch for compiling
-system units. @xref{Top, @value{EDITION} User's Guide, About This
-Guide,, gnat_ugn, @value{EDITION} User's Guide}, for details.
+system units.
+@xref{Top, @value{EDITION} User's Guide, About This Guide, gnat_ugn, @value{EDITION} User's Guide},
+for details.
+
+@node Pragma Extensions_Allowed
+@unnumberedsec Pragma Extensions_Allowed
+@cindex Ada Extensions
+@cindex GNAT Extensions
+@findex Extensions_Allowed
+@noindent
+Syntax:
+
+@smallexample @c ada
+pragma Extensions_Allowed (On | Off);
+@end smallexample
+
+@noindent
+This configuration pragma enables or disables the implementation
+extension mode (the use of Off as a parameter cancels the effect
+of the @option{-gnatX} command switch).
+
+In extension mode, the latest version of the Ada language is
+implemented (currently Ada 2012), and in addition a small number
+of GNAT specific extensions are recognized as follows:
+
+@table @asis
+@item Constrained attribute for generic objects
+The @code{Constrained} attribute is permitted for objects of
+generic types. The result indicates if the corresponding actual
+is constrained.
+
+@end table
@node Pragma External
@unnumberedsec Pragma External
be @code{IEEE_Float} and the pragma has no effect. On OpenVMS, the
argument may be @code{VAX_Float} to specify the use of the VAX float
format for the floating-point types in Standard. This requires that
-the standard runtime libraries be recompiled. @xref{The GNAT Run-Time
-Library Builder gnatlbr,,, gnat_ugn, @value{EDITION} User's Guide
-OpenVMS}, for a description of the @code{GNAT LIBRARY} command.
+the standard runtime libraries be recompiled.
The two argument form specifies the representation to be used for
the specified floating-point type. On all systems other than OpenVMS,
@item
For digits values up to 6, F float format will be used.
@item
-For digits values from 7 to 9, G float format will be used.
+For digits values from 7 to 9, D float format will be used.
@item
-For digits values from 10 to 15, F float format will be used.
+For digits values from 10 to 15, G float format will be used.
@item
Digits values above 15 are not allowed.
@end itemize
maintain compatibility with this compiler, you should obey this length
limit.
-@node Pragma Implemented_By_Entry
-@unnumberedsec Pragma Implemented_By_Entry
-@findex Implemented_By_Entry
+@node Pragma Implemented
+@unnumberedsec Pragma Implemented
+@findex Implemented
@noindent
Syntax:
@smallexample @c ada
-pragma Implemented_By_Entry (LOCAL_NAME);
+pragma Implemented (procedure_LOCAL_NAME, implementation_kind);
+
+implementation_kind ::= By_Entry | By_Protected_Procedure | By_Any
@end smallexample
@noindent
-This is a representation pragma which applies to protected, synchronized and
-task interface primitives. If the pragma is applied to primitive operation Op
-of interface Iface, it is illegal to override Op in a type that implements
-Iface, with anything other than an entry.
+This is an Ada 2012 representation pragma which applies to protected, task
+and synchronized interface primitives. The use of pragma Implemented provides
+a way to impose a static requirement on the overriding opreration by adhering
+to one of the three implementation kids: entry, protected procedure or any of
+the above.
@smallexample @c ada
-type Iface is protected interface;
-procedure Do_Something (Object : in out Iface) is abstract;
-pragma Implemented_By_Entry (Do_Something);
+type Synch_Iface is synchronized interface;
+procedure Prim_Op (Obj : in out Iface) is abstract;
+pragma Implemented (Prim_Op, By_Protected_Procedure);
-protected type P is new Iface with
- procedure Do_Something; -- Illegal
-end P;
+protected type Prot_1 is new Synch_Iface with
+ procedure Prim_Op; -- Legal
+end Prot_1;
-task type T is new Iface with
- entry Do_Something; -- Legal
-end T;
+protected type Prot_2 is new Synch_Iface with
+ entry Prim_Op; -- Illegal
+end Prot_2;
+
+task type Task_Typ is new Synch_Iface with
+ entry Prim_Op; -- Illegal
+end Task_Typ;
@end smallexample
@noindent
-NOTE: The pragma is still in its design stage by the Ada Rapporteur Group. It
-is intended to be used in conjunction with dispatching requeue statements as
-described in AI05-0030. Should the ARG decide on an official name and syntax,
-this pragma will become language-defined rather than GNAT-specific.
+When applied to the procedure_or_entry_NAME of a requeue statement, pragma
+Implemented determines the runtime behavior of the requeue. Implementation kind
+By_Entry guarantees that the action of requeueing will procede from an entry to
+another entry. Implementation kind By_Protected_Procedure transforms the
+requeue into a dispatching call, thus eliminating the chance of blocking. Kind
+By_Any shares the behavior of By_Entry and By_Protected_Procedure depending on
+the target's overriding subprogram kind.
@node Pragma Implicit_Packing
@unnumberedsec Pragma Implicit_Packing
@noindent
This is a configuration pragma that requests implicit packing for packed
arrays for which a size clause is given but no explicit pragma Pack or
-specification of Component_Size is present. Consider this example:
+specification of Component_Size is present. It also applies to records
+where no record representation clause is present. Consider this example:
@smallexample @c ada
type R is array (0 .. 7) of Boolean;
by the size in bits of the component type.
@cindex Array packing
+Similarly, the following example shows the use in the record case
+
+@smallexample @c ada
+type r is record
+ a, b, c, d, e, f, g, h : boolean;
+ chr : character;
+end record;
+for r'size use 16;
+@end smallexample
+
+@noindent
+Without a pragma Pack, each Boolean field requires 8 bits, so the
+minimum size is 72 bits, but with a pragma Pack, 16 bits would be
+sufficient. The use of pragma Implciit_Packing allows this record
+declaration to compile without an explicit pragma Pack.
@node Pragma Import_Exception
@unnumberedsec Pragma Import_Exception
@cindex OpenVMS
with Ada 83. The definition is upwards compatible both with pragma
@code{Interface} as defined in the Ada 83 Reference Manual, and also
with some extended implementations of this pragma in certain Ada 83
-implementations.
+implementations. The only difference between pragma @code{Interface}
+and pragma @code{Import} is that there is special circuitry to allow
+both pragmas to appear for the same subprogram entity (normally it
+is illegal to have multiple @code{Import} pragmas. This is useful in
+maintaining Ada 83/Ada 95 compatibility and is compatible with other
+Ada 83 compilers.
@node Pragma Interface_Name
@unnumberedsec Pragma Interface_Name
Syntax:
@smallexample @c ada
-pragma Interrupt_State (Name => value, State => SYSTEM | RUNTIME | USER);
+pragma Interrupt_State
+ ([Name =>] value,
+ [State =>] SYSTEM | RUNTIME | USER);
@end smallexample
@noindent
Pragma @code{Interrupt_State} provides a general mechanism for overriding
such uses of interrupts. It subsumes the functionality of pragma
@code{Unreserve_All_Interrupts}. Pragma @code{Interrupt_State} is not
-available on OS/2, Windows or VMS. On all other platforms than VxWorks,
+available on Windows or VMS. On all other platforms than VxWorks,
it applies to signals; on VxWorks, it applies to vectored hardware interrupts
and may be used to mark interrupts required by the board support package
as reserved.
with an application's runtime behavior in the cases of the synchronous signals,
and in the case of the signal used to implement the @code{abort} statement.
+@node Pragma Invariant
+@unnumberedsec Pragma Invariant
+@findex Invariant
+@noindent
+Syntax:
+
+@smallexample @c ada
+pragma Invariant
+ ([Entity =>] private_type_LOCAL_NAME,
+ [Check =>] EXPRESSION
+ [,[Message =>] String_Expression]);
+@end smallexample
+
+@noindent
+This pragma provides exactly the same capabilities as the Invariant aspect
+defined in AI05-0146-1, and in the Ada 2012 Reference Manual. The Invariant
+aspect is fully implemented in Ada 2012 mode, but since it requires the use
+of the aspect syntax, which is not available exception in 2012 mode, it is
+not possible to use the Invariant aspect in earlier versions of Ada. However
+the Invariant pragma may be used in any version of Ada.
+
+The pragma must appear within the visible part of the package specification,
+after the type to which its Entity argument appears. As with the Invariant
+aspect, the Check expression is not analyzed until the end of the visible
+part of the package, so it may contain forward references. The Message
+argument, if present, provides the exception message used if the invariant
+is violated. If no Message parameter is provided, a default message that
+identifies the line on which the pragma appears is used.
+
+It is permissible to have multiple Invariants for the same type entity, in
+which case they are and'ed together. It is permissible to use this pragma
+in Ada 2012 mode, but you cannot have both an invariant aspect and an
+invariant pragma for the same entity.
+
+For further details on the use of this pragma, see the Ada 2012 documentation
+of the Invariant aspect.
+
@node Pragma Keep_Names
@unnumberedsec Pragma Keep_Names
@findex Keep_Names
For further details on this pragma, see the
@cite{DEC Ada Language Reference Manual}, section 3.5.7b. Note that to use
this pragma, the standard runtime libraries must be recompiled.
-@xref{The GNAT Run-Time Library Builder gnatlbr,,, gnat_ugn,
-@value{EDITION} User's Guide OpenVMS}, for a description of the
-@code{GNAT LIBRARY} command.
@node Pragma Machine_Attribute
@unnumberedsec Pragma Machine_Attribute
pragma Machine_Attribute (
[Entity =>] LOCAL_NAME,
[Attribute_Name =>] static_string_EXPRESSION
- [, [Info =>] static_string_EXPRESSION] );
+ [, [Info =>] static_EXPRESSION] );
@end smallexample
@noindent
@code{__attribute__((@var{attribute_name}))} (if @var{info} is not
specified) or @code{__attribute__((@var{attribute_name}(@var{info})))}
in GNU C, where @code{@var{attribute_name}} is recognized by the
-target macro @code{TARGET_ATTRIBUTE_TABLE} which is defined for each
-machine. The optional parameter @var{info} is transformed into an
-identifier, which may make this pragma unusable for some attributes
-(parameter of some attributes must be a number or a string).
-@xref{Target Attributes,, Defining target-specific uses of
-@code{__attribute__}, gccint, GNU Compiler Colletion (GCC) Internals},
-further information. It is not possible to specify
-attributes defined by other languages, only attributes defined by the
-machine the code is intended to run on.
+compiler middle-end or the @code{TARGET_ATTRIBUTE_TABLE} machine
+specific macro. A string literal for the optional parameter @var{info}
+is transformed into an identifier, which may make this pragma unusable
+for some attributes. @xref{Target Attributes,, Defining target-specific
+uses of @code{__attribute__}, gccint, GNU Compiler Collection (GCC)
+Internals}, further information.
@node Pragma Main
@unnumberedsec Pragma Main
(MAIN_OPTION [, MAIN_OPTION]);
MAIN_OPTION ::=
- [STACK_SIZE =>] static_integer_EXPRESSION
-| [TASK_STACK_SIZE_DEFAULT =>] static_integer_EXPRESSION
-| [TIME_SLICING_ENABLED =>] static_boolean_EXPRESSION
+ [Stack_Size =>] static_integer_EXPRESSION
+| [Task_Stack_Size_Default =>] static_integer_EXPRESSION
+| [Time_Slicing_Enabled =>] static_boolean_EXPRESSION
@end smallexample
@noindent
Syntax:
@smallexample @c ada
-pragma Obsolescent
- (Entity => NAME [, static_string_EXPRESSION [,Ada_05]]);
+pragma Obsolescent;
+
+pragma Obsolescent (
+ [Message =>] static_string_EXPRESSION
+[,[Version =>] Ada_05]]);
+
+pragma Obsolescent (
+ [Entity =>] NAME
+[,[Message =>] static_string_EXPRESSION
+[,[Version =>] Ada_05]] );
@end smallexample
@noindent
This pragma can occur immediately following a declaration of an entity,
-including the case of a record component, and usually the Entity name
-must match the name of the entity declared by this declaration.
-Alternatively, the pragma can immediately follow an
-enumeration type declaration, where the entity argument names one of the
-enumeration literals.
+including the case of a record component. If no Entity argument is present,
+then this declaration is the one to which the pragma applies. If an Entity
+parameter is present, it must either match the name of the entity in this
+declaration, or alternatively, the pragma can immediately follow an enumeration
+type declaration, where the Entity argument names one of the enumeration
+literals.
This pragma is used to indicate that the named entity
is considered obsolescent and should not be used. Typically this is
intermediate stage when the entity is still present, but will be
removed later.
-The effect of this pragma is to output a warning message on
-a call to a program thus marked that the
-subprogram is obsolescent if the appropriate warning option in the
-compiler is activated. If the string parameter is present, then a second
-warning message is given containing this text.
-In addition, a call to such a program is considered a violation of
-pragma Restrictions (No_Obsolescent_Features).
+The effect of this pragma is to output a warning message on a reference to
+an entity thus marked that the subprogram is obsolescent if the appropriate
+warning option in the compiler is activated. If the Message parameter is
+present, then a second warning message is given containing this text. In
+addition, a reference to the eneity is considered to be a violation of pragma
+Restrictions (No_Obsolescent_Features).
This pragma can also be used as a program unit pragma for a package,
in which case the entity name is the name of the package, and the
violates the restriction, and the @code{with} statement is
flagged with warnings if the warning option is set.
-If the optional third parameter is present (which must be exactly
+If the Version parameter is present (which must be exactly
the identifier Ada_05, no other argument is allowed), then the
indication of obsolescence applies only when compiling in Ada 2005
mode. This is primarily intended for dealing with the situations
@smallexample @c ada
package p is
- pragma Obsolescent
- (Entity => p, "use pp instead of p");
+ pragma Obsolescent (p, Message => "use pp instead of p");
end p;
package q is
procedure q2;
- pragma Obsolescent
- (Entity => q2, "use q2new instead");
+ pragma Obsolescent ("use q2new instead");
type R is new integer;
pragma Obsolescent
- (Entity => R, "use RR in Ada 2005", Ada_05);
+ (Entity => R,
+ Message => "use RR in Ada 2005",
+ Version => Ada_05);
type M is record
F1 : Integer;
F2 : Integer;
- pragma Obsolescent (Entity => F2);
+ pragma Obsolescent;
F3 : Integer;
end record;
@end smallexample
@noindent
-In an earlier version of GNAT, the Entity parameter was not required,
-and this form is still accepted for compatibility purposes. If the
-Entity parameter is omitted, then the pragma applies to the declaration
-immediately preceding the pragma (this form cannot be used for the
-enumeration literal case).
+Note that, as for all pragmas, if you use a pragma argument identifier,
+then all subsequent parameters must also use a pragma argument identifier.
+So if you specify "Entity =>" for the Entity argument, and a Message
+argument is present, it must be preceded by "Message =>".
@node Pragma Optimize_Alignment
@unnumberedsec Pragma Optimize_Alignment
latter are compiled by default in pragma Optimize_Alignment (Off) mode if no
pragma appears at the start of the file.
+@node Pragma Ordered
+@unnumberedsec Pragma Ordered
+@findex Ordered
+@findex pragma @code{Ordered}
+@noindent
+Syntax:
+
+@smallexample @c ada
+pragma Ordered (enumeration_first_subtype_LOCAL_NAME);
+@end smallexample
+
+@noindent
+Most enumeration types are from a conceptual point of view unordered.
+For example, consider:
+
+@smallexample @c ada
+type Color is (Red, Blue, Green, Yellow);
+@end smallexample
+
+@noindent
+By Ada semantics @code{Blue > Red} and @code{Green > Blue},
+but really these relations make no sense; the enumeration type merely
+specifies a set of possible colors, and the order is unimportant.
+
+For unordered enumeration types, it is generally a good idea if
+clients avoid comparisons (other than equality or inequality) and
+explicit ranges. (A @emph{client} is a unit where the type is referenced,
+other than the unit where the type is declared, its body, and its subunits.)
+For example, if code buried in some client says:
+
+@smallexample @c ada
+if Current_Color < Yellow then ...
+if Current_Color in Blue .. Green then ...
+@end smallexample
+
+@noindent
+then the client code is relying on the order, which is undesirable.
+It makes the code hard to read and creates maintenance difficulties if
+entries have to be added to the enumeration type. Instead,
+the code in the client should list the possibilities, or an
+appropriate subtype should be declared in the unit that declares
+the original enumeration type. E.g., the following subtype could
+be declared along with the type @code{Color}:
+
+@smallexample @c ada
+subtype RBG is Color range Red .. Green;
+@end smallexample
+
+@noindent
+and then the client could write:
+
+@smallexample @c ada
+if Current_Color in RBG then ...
+if Current_Color = Blue or Current_Color = Green then ...
+@end smallexample
+
+@noindent
+However, some enumeration types are legitimately ordered from a conceptual
+point of view. For example, if you declare:
+
+@smallexample @c ada
+type Day is (Mon, Tue, Wed, Thu, Fri, Sat, Sun);
+@end smallexample
+
+@noindent
+then the ordering imposed by the language is reasonable, and
+clients can depend on it, writing for example:
+
+@smallexample @c ada
+if D in Mon .. Fri then ...
+if D < Wed then ...
+@end smallexample
+
+@noindent
+The pragma @option{Ordered} is provided to mark enumeration types that
+are conceptually ordered, alerting the reader that clients may depend
+on the ordering. GNAT provides a pragma to mark enumerations as ordered
+rather than one to mark them as unordered, since in our experience,
+the great majority of enumeration types are conceptually unordered.
+
+The types @code{Boolean}, @code{Character}, @code{Wide_Character},
+and @code{Wide_Wide_Character}
+are considered to be ordered types, so each is declared with a
+pragma @code{Ordered} in package @code{Standard}.
+
+Normally pragma @code{Ordered} serves only as documentation and a guide for
+coding standards, but GNAT provides a warning switch @option{-gnatw.u} that
+requests warnings for inappropriate uses (comparisons and explicit
+subranges) for unordered types. If this switch is used, then any
+enumeration type not marked with pragma @code{Ordered} will be considered
+as unordered, and will generate warnings for inappropriate uses.
+
+For additional information please refer to the description of the
+@option{-gnatw.u} switch in the @value{EDITION} User's Guide.
+
@node Pragma Passive
@unnumberedsec Pragma Passive
@findex Passive
The @code{Postcondition} pragma allows specification of automatic
postcondition checks for subprograms. These checks are similar to
assertions, but are automatically inserted just prior to the return
-statements of the subprogram with which they are associated.
-Furthermore, the boolean expression which is the condition which
+statements of the subprogram with which they are associated (including
+implicit returns at the end of procedure bodies and associated
+exception handlers).
+
+In addition, the boolean expression which is the condition which
must be true may contain references to function'Result in the case
of a function to refer to the returned value.
by the compiler, but are ignored at run-time even if postcondition
checking is enabled.
-
-
@node Pragma Profile (Ravenscar)
@unnumberedsec Pragma Profile (Ravenscar)
@findex Ravenscar
example (where a table of previous calls is kept and consulted to
avoid re-computation).
+Note also that the normal rules excluding optimization of subprograms
+in pure units (when parameter types are descended from System.Address,
+or when the full view of a parameter type is limited), do not apply
+for the Pure_Function case. If you explicitly specify Pure_Function,
+the compiler may optimize away calls with identical arguments, and
+if that results in unexpected behavior, the proper action is not to
+use the pragma for subprograms that are not (conceptually) pure.
+
@findex Pure
Note: Most functions in a @code{Pure} package are automatically pure, and
there is no need to use pragma @code{Pure_Function} for such functions. One
This pragma is provided for compatibility with Ada 83. The syntax and
semantics are identical to pragma Atomic.
+@node Pragma Short_Circuit_And_Or
+@unnumberedsec Pragma Short_Circuit_And_Or
+@findex Short_Circuit_And_Or
+
+@noindent
+This configuration pragma causes any occurrence of the AND operator applied to
+operands of type Standard.Boolean to be short-circuited (i.e. the AND operator
+is treated as if it were AND THEN). Or is similarly treated as OR ELSE. This
+may be useful in the context of certification protocols requiring the use of
+short-circuited logical operators. If this configuration pragma occurs locally
+within the file being compiled, it applies only to the file being compiled.
+There is no requirement that all units in a partition use this option.
+
+@node Pragma Short_Descriptors
+@unnumberedsec Pragma Short_Descriptors
+@findex Short_Descriptors
+@noindent
+Syntax:
+
+@smallexample @c ada
+pragma Short_Descriptors
+@end smallexample
+
+@noindent
+In VMS versions of the compiler, this configuration pragma causes all
+occurrences of the mechanism types Descriptor[_xxx] to be treated as
+Short_Descriptor[_xxx]. This is helpful in porting legacy applications from a
+32-bit environment to a 64-bit environment. This pragma is ignored for non-VMS
+versions.
+
@node Pragma Source_File_Name
@unnumberedsec Pragma Source_File_Name
@findex Source_File_Name
@smallexample @c ada
pragma Source_File_Name (
[Unit_Name =>] unit_NAME,
- Spec_File_Name => STRING_LITERAL);
+ Spec_File_Name => STRING_LITERAL,
+ [Index => INTEGER_LITERAL]);
pragma Source_File_Name (
[Unit_Name =>] unit_NAME,
- Body_File_Name => STRING_LITERAL);
+ Body_File_Name => STRING_LITERAL,
+ [Index => INTEGER_LITERAL]);
@end smallexample
@noindent
the second argument is required, and indicates whether this is the file
name for the spec or for the body.
+The optional Index argument should be used when a file contains multiple
+units, and when you do not want to use @code{gnatchop} to separate then
+into multiple files (which is the recommended procedure to limit the
+number of recompilations that are needed when some sources change).
+For instance, if the source file @file{source.ada} contains
+
+@smallexample @c ada
+package B is
+...
+end B;
+
+with B;
+procedure A is
+begin
+ ..
+end A;
+@end smallexample
+
+you could use the following configuration pragmas:
+
+@smallexample @c ada
+pragma Source_File_Name
+ (B, Spec_File_Name => "source.ada", Index => 1);
+pragma Source_File_Name
+ (A, Body_File_Name => "source.ada", Index => 2);
+@end smallexample
+
+Note that the @code{gnatname} utility can also be used to generate those
+configuration pragmas.
+
Another form of the @code{Source_File_Name} pragma allows
the specification of patterns defining alternative file naming schemes
to apply to all files.
@smallexample @c ada
pragma Source_File_Name
- (Spec_File_Name => STRING_LITERAL
- [,Casing => CASING_SPEC]
- [,Dot_Replacement => STRING_LITERAL]);
+ ( [Spec_File_Name =>] STRING_LITERAL
+ [,[Casing =>] CASING_SPEC]
+ [,[Dot_Replacement =>] STRING_LITERAL]);
pragma Source_File_Name
- (Body_File_Name => STRING_LITERAL
- [,Casing => CASING_SPEC]
- [,Dot_Replacement => STRING_LITERAL]);
+ ( [Body_File_Name =>] STRING_LITERAL
+ [,[Casing =>] CASING_SPEC]
+ [,[Dot_Replacement =>] STRING_LITERAL]);
pragma Source_File_Name
- (Subunit_File_Name => STRING_LITERAL
- [,Casing => CASING_SPEC]
- [,Dot_Replacement => STRING_LITERAL]);
+ ( [Subunit_File_Name =>] STRING_LITERAL
+ [,[Casing =>] CASING_SPEC]
+ [,[Dot_Replacement =>] STRING_LITERAL]);
CASING_SPEC ::= Lowercase | Uppercase | Mixedcase
@end smallexample
@end smallexample
@noindent
-The effect is that if the value of an unbounded string is written to a
-stream, then the representation of the item in the stream is in the same
-format used for @code{Standard.String}, and this same representation is
-expected when a value of this type is read from the stream.
+The effect is that if the value of an unbounded string is written to a stream,
+then the representation of the item in the stream is in the same format that
+would be used for @code{Standard.String'Output}, and this same representation
+is expected when a value of this type is read from the stream. Note that the
+value written always includes the bounds, even for Unbounded_String'Write,
+since Unbounded_String is not an array type.
@node Pragma Style_Checks
@unnumberedsec Pragma Style_Checks
The form ALL_CHECKS activates all standard checks (its use is equivalent
to the use of the @code{gnaty} switch with no options. @xref{Top,
@value{EDITION} User's Guide, About This Guide, gnat_ugn,
-@value{EDITION} User's Guide}, for details.
+@value{EDITION} User's Guide}, for details.)
+
+Note: the behavior is slightly different in GNAT mode (@option{-gnatg} used).
+In this case, ALL_CHECKS implies the standard set of GNAT mode style check
+options (i.e. equivalent to -gnatyg).
The forms with @code{Off} and @code{On}
can be used to temporarily disable style checks
by suppressing range checks, but the specific use of @code{Alignment_Check}
allows suppression of alignment checks without suppressing other range checks.
+Note that pragma Suppress gives the compiler permission to omit
+checks, but does not require the compiler to omit checks. The compiler
+will generate checks if they are essentially free, even when they are
+suppressed. In particular, if the compiler can prove that a certain
+check will necessarily fail, it will generate code to do an
+unconditional ``raise'', even if checks are suppressed. The compiler
+warns in this case.
+
+Of course, run-time checks are omitted whenever the compiler can prove
+that they will not fail, whether or not checks are suppressed.
+
@node Pragma Suppress_All
@unnumberedsec Pragma Suppress_All
@findex Suppress_All
@end smallexample
@noindent
-This pragma can only appear immediately following a compilation
-unit. The effect is to apply @code{Suppress (All_Checks)} to the unit
-which it follows. This pragma is implemented for compatibility with DEC
-Ada 83 usage. The use of pragma @code{Suppress (All_Checks)} as a normal
-configuration pragma is the preferred usage in GNAT@.
+This pragma can appear anywhere within a unit.
+The effect is to apply @code{Suppress (All_Checks)} to the unit
+in which it appears. This pragma is implemented for compatibility with DEC
+Ada 83 usage where it appears at the end of a unit, and for compatibility
+with Rational Ada, where it appears as a program unit pragma.
+The use of the standard Ada pragma @code{Suppress (All_Checks)}
+as a normal configuration pragma is the preferred usage in GNAT@.
@node Pragma Suppress_Exception_Locations
@unnumberedsec Pragma Suppress_Exception_Locations
@code{Storage_Size} attribute definition clause is allowed for a task
type.
+@node Pragma Thread_Local_Storage
+@unnumberedsec Pragma Thread_Local_Storage
+@findex Thread_Local_Storage
+@cindex Task specific storage
+@cindex TLS (Thread Local Storage)
+Syntax:
+
+@smallexample @c ada
+pragma Thread_Local_Storage ([Entity =>] LOCAL_NAME);
+@end smallexample
+
+@noindent
+This pragma specifies that the specified entity, which must be
+a variable declared in a library level package, is to be marked as
+"Thread Local Storage" (@code{TLS}). On systems supporting this (which
+include Solaris, GNU/Linux and VxWorks 6), this causes each thread
+(and hence each Ada task) to see a distinct copy of the variable.
+
+The variable may not have default initialization, and if there is
+an explicit initialization, it must be either @code{null} for an
+access variable, or a static expression for a scalar variable.
+This provides a low level mechanism similar to that provided by
+the @code{Ada.Task_Attributes} package, but much more efficient
+and is also useful in writing interface code that will interact
+with foreign threads.
+
+If this pragma is used on a system where @code{TLS} is not supported,
+then an error message will be generated and the program will be rejected.
+
@node Pragma Time_Slice
@unnumberedsec Pragma Time_Slice
@findex Time_Slice
control over which warnings are active. The string is a list of letters
specifying which warnings are to be activated and which deactivated. The
code for these letters is the same as the string used in the command
-line switch controlling warnings. The following is a brief summary. For
+line switch controlling warnings. For a brief summary, use the gnatmake
+command with no arguments, which will generate usage information containing
+the list of warnings switches supported. For
full details see @ref{Warning Message Control,,, gnat_ugn, @value{EDITION}
User's Guide}.
-@smallexample
-a turn on all optional warnings (except d h l .o)
-A turn off all optional warnings
-.a* turn on warnings for failing assertions
-.A turn off warnings for failing assertions
-b turn on warnings for bad fixed value (not multiple of small)
-B* turn off warnings for bad fixed value (not multiple of small)
-c turn on warnings for constant conditional
-C* turn off warnings for constant conditional
-.c turn on warnings for unrepped components
-.C* turn off warnings for unrepped components
-d turn on warnings for implicit dereference
-D* turn off warnings for implicit dereference
-e treat all warnings as errors
-f turn on warnings for unreferenced formal
-F* turn off warnings for unreferenced formal
-g* turn on warnings for unrecognized pragma
-G turn off warnings for unrecognized pragma
-h turn on warnings for hiding variable
-H* turn off warnings for hiding variable
-i* turn on warnings for implementation unit
-I turn off warnings for implementation unit
-j turn on warnings for obsolescent (annex J) feature
-J* turn off warnings for obsolescent (annex J) feature
-k turn on warnings on constant variable
-K* turn off warnings on constant variable
-l turn on warnings for missing elaboration pragma
-L* turn off warnings for missing elaboration pragma
-m turn on warnings for variable assigned but not read
-M* turn off warnings for variable assigned but not read
-n* normal warning mode (cancels -gnatws/-gnatwe)
-o* turn on warnings for address clause overlay
-O turn off warnings for address clause overlay
-.o turn on warnings for out parameters assigned but not read
-.O* turn off warnings for out parameters assigned but not read
-p turn on warnings for ineffective pragma Inline in frontend
-P* turn off warnings for ineffective pragma Inline in frontend
-q* turn on warnings for questionable missing parentheses
-Q turn off warnings for questionable missing parentheses
-r turn on warnings for redundant construct
-R* turn off warnings for redundant construct
-.r turn on warnings for object renaming function
-.R* turn off warnings for object renaming function
-s suppress all warnings
-t turn on warnings for tracking deleted code
-T* turn off warnings for tracking deleted code
-u turn on warnings for unused entity
-U* turn off warnings for unused entity
-v* turn on warnings for unassigned variable
-V turn off warnings for unassigned variable
-w* turn on warnings for wrong low bound assumption
-W turn off warnings for wrong low bound assumption
-x* turn on warnings for export/import
-X turn off warnings for export/import
-.x turn on warnings for non-local exceptions
-.X* turn off warnings for non-local exceptions
-y* turn on warnings for Ada 2005 incompatibility
-Y turn off warnings for Ada 2005 incompatibility
-z* turn on convention/size/align warnings for unchecked conversion
-Z turn off convention/size/align warnings for unchecked conversion
-* indicates default in above list
-@end smallexample
-
@noindent
The specified warnings will be in effect until the end of the program
or another pragma Warnings is encountered. The effect of the pragma is
The fourth form, with an On|Off parameter and a string, is used to
control individual messages, based on their text. The string argument
is a pattern that is used to match against the text of individual
-warning messages (not including the initial "warnings: " tag).
+warning messages (not including the initial "warning: " tag).
-The pattern may contain asterisks which match zero or more characters in
+The pattern may contain asterisks, which match zero or more characters in
the message. For example, you can use
@code{pragma Warnings (Off, "*bits of*unused")} to suppress the warning
message @code{warning: 960 bits of "a" unused}. No other regular
In this usage, the pattern string must match in the Off and On pragmas,
and at least one matching warning must be suppressed.
+Note: the debug flag -gnatd.i (@code{/NOWARNINGS_PRAGMAS} in VMS) can be
+used to cause the compiler to entirely ignore all WARNINGS pragmas. This can
+be useful in checking whether obsolete pragmas in existing programs are hiding
+real problems.
+
+Note: pragma Warnings does not affect the processing of style messages. See
+separate entry for pragma Style_Checks for control of style messages.
+
@node Pragma Weak_External
@unnumberedsec Pragma Weak_External
@findex Weak_External
* AST_Entry::
* Bit::
* Bit_Position::
+* Compiler_Version::
* Code_Address::
* Default_Bit_Order::
* Elaborated::
* Passed_By_Reference::
* Pool_Address::
* Range_Length::
+* Ref::
+* Result::
* Safe_Emax::
* Safe_Large::
* Small::
@unnumberedsec Bit_Position
@findex Bit_Position
@noindent
-@code{@var{R.C}'Bit}, where @var{R} is a record object and C is one
+@code{@var{R.C}'Bit_Position}, where @var{R} is a record object and C is one
of the fields of the record type, yields the bit
offset within the record contains the first bit of
storage allocated for the object. The value of this attribute is of the
@var{C} and is independent of the alignment of
the containing record @var{R}.
+@node Compiler_Version
+@unnumberedsec Compiler_Version
+@findex Compiler_Version
+@noindent
+@code{Standard'Compiler_Version} (@code{Standard} is the only allowed
+prefix) yields a static string identifying the version of the compiler
+being used to compile the unit containing the attribute reference. A
+typical result would be something like "GNAT Pro 6.3.0w (20090221)".
+
@node Code_Address
@unnumberedsec Code_Address
@findex Code_Address
@cindex Representation of enums
@findex Enum_Val
@noindent
-For every enumeration subtype @var{S}, @code{@var{S}'Enum_Rep} denotes a
+For every enumeration subtype @var{S}, @code{@var{S}'Enum_Val} denotes a
function with the following spec:
@smallexample @c ada
-function @var{S}'Enum_Rep (Arg : @i{Universal_Integer)
+function @var{S}'Enum_Val (Arg : @i{Universal_Integer)
return @var{S}'Base};
@end smallexample
@end smallexample
@noindent
-will have a size of 40 (that is @code{Rec'Size} will be 40. The
+will have a size of 40 (that is @code{Rec'Size} will be 40). The
alignment will be 4, because of the
integer field, and so the default size of record objects for this type
will be 64 (8 bytes).
@cindex Postconditions
@noindent
The attribute Prefix'Old can be used within a
-subprogram to refer to the value of the prefix on entry. So for
+subprogram body or within a precondition or
+postcondition pragma. The effect is to
+refer to the value of the prefix on entry. So for
example if you have an argument of a record type X called Arg1,
you can refer to Arg1.Field'Old which yields the value of
Arg1.Field on entry. The implementation simply involves generating
an object declaration which captures the value on entry. Any
prefix is allowed except one of a limited type (since limited
-types cannot be copied to capture their values) or a local variable
-(since it does not exist at subprogram entry time).
+types cannot be copied to capture their values) or an expression
+which references a local variable
+(since local variables do not exist at subprogram entry time).
The following example shows the use of 'Old to implement
a test of a postcondition:
applied to the index subtype of a one dimensional array always gives the
same result as @code{Range} applied to the array itself.
+@node Ref
+@unnumberedsec Ref
+@findex Ref
+@noindent
+The @code{System.Address'Ref}
+(@code{System.Address} is the only permissible prefix)
+denotes a function identical to
+@code{System.Storage_Elements.To_Address} except that
+it is a static attribute. See @ref{To_Address} for more details.
+
+@node Result
+@unnumberedsec Result
+@findex Result
+@noindent
+@code{@var{function}'Result} can only be used with in a Postcondition pragma
+for a function. The prefix must be the name of the corresponding function. This
+is used to refer to the result of the function in the postcondition expression.
+For a further discussion of the use of this attribute and examples of its use,
+see the description of pragma Postcondition.
+
@node Safe_Emax
@unnumberedsec Safe_Emax
@cindex Ada 83 attributes
the number as defined in the original source. This allows the user
program to access the actual text of named numbers without intermediate
conversions and without the need to enclose the strings in quotes (which
-would preclude their use as numbers). This is used internally for the
-construction of values of the floating-point attributes from the file
-@file{ttypef.ads}, but may also be used by user programs.
+would preclude their use as numbers).
For example, the following program prints the first 50 digits of pi:
for Y'Address use X'Address;>>
@end smallexample
-
@sp 1
@cartouche
An implementation need not support a specification for the @code{Size}
@cindex Stream oriented attributes
The XDR implementation is provided as an alternative body of the
@code{System.Stream_Attributes} package, in the file
-@file{s-strxdr.adb} in the GNAT library.
-There is no @file{s-strxdr.ads} file.
+@file{s-stratt-xdr.adb} in the GNAT library.
+There is no @file{s-stratt-xdr.ads} file.
In order to install the XDR implementation, do the following:
@enumerate
@item Replace the default implementation of the
@code{System.Stream_Attributes} package with the XDR implementation.
For example on a Unix platform issue the commands:
@smallexample
-$ mv s-stratt.adb s-strold.adb
-$ mv s-strxdr.adb s-stratt.adb
+$ mv s-stratt.adb s-stratt-default.adb
+$ mv s-stratt-xdr.adb s-stratt.adb
@end smallexample
@item
@chapter Implementation Defined Characteristics
@noindent
-In addition to the implementation dependent pragmas and attributes, and
-the implementation advice, there are a number of other Ada features
-that are potentially implementation dependent. These are mentioned
-throughout the Ada Reference Manual, and are summarized in annex M@.
+In addition to the implementation dependent pragmas and attributes, and the
+implementation advice, there are a number of other Ada features that are
+potentially implementation dependent and are designated as
+implementation-defined. These are mentioned throughout the Ada Reference
+Manual, and are summarized in Annex M@.
A requirement for conforming Ada compilers is that they provide
documentation describing how the implementation deals with each of these
-issues. In this chapter, you will find each point in annex M listed
+issues. In this chapter, you will find each point in Annex M listed
followed by a description in italic font of how GNAT
@c SGI info:
@ignore
@sp 1
@cartouche
@noindent
+@strong{53}. The semantics of operations on invalid representations.
+See 13.9.2(10-11).
+@end cartouche
+@noindent
+For assignments and other operations where the use of invalid values cannot
+result in erroneous behavior, the compiler ignores the possibility of invalid
+values. An exception is raised at the point where an invalid value would
+result in erroneous behavior. For example executing:
+
+@smallexample @c ada
+procedure invalidvals is
+ X : Integer := -1;
+ Y : Natural range 1 .. 10;
+ for Y'Address use X'Address;
+ Z : Natural range 1 .. 10;
+ A : array (Natural range 1 .. 10) of Integer;
+begin
+ Z := Y; -- no exception
+ A (Z) := 3; -- exception raised;
+end;
+@end smallexample
+
+@noindent
+As indicated, an exception is raised on the array assignment, but not
+on the simple assignment of the invalid negative value from Y to Z.
+
+@sp 1
+@cartouche
+@noindent
@strong{53}. The manner of choosing a storage pool for an access type
when @code{Storage_Pool} is not specified for the type. See 13.11(17).
@end cartouche
@item No_Direct_Boolean_Operators
@findex No_Direct_Boolean_Operators
-This restriction ensures that no logical (and/or/xor) or comparison
-operators are used on operands of type Boolean (or any type derived
+This restriction ensures that no logical (and/or/xor) are used on
+operands of type Boolean (or any type derived
from Boolean). This is intended for use in safety critical programs
where the certification protocol requires the use of short-circuit
(and then, or else) forms for all composite boolean operations.
@item No_Streams
@findex No_Streams
This restriction ensures at compile/bind time that there are no
-stream objects created (and therefore no actual stream operations).
+stream objects created and no use of stream attributes.
This restriction does not forbid dependences on the package
@code{Ada.Streams}. So it is permissible to with
@code{Ada.Streams} (or another package that does so itself)
-as long as no actual stream objects are created.
+as long as no actual stream objects are created and no
+stream attributes are used.
+
+Note that the use of restriction allows optimization of tagged types,
+since they do not need to worry about dispatching stream operations.
+To take maximum advantage of this space-saving optimization, any
+unit declaring a tagged type should be compiled with the restriction,
+though this is not required.
@item No_Task_Attributes_Package
@findex No_Task_Attributes_Package
@code{Numerics.Float_Random.Max_Image_Width}. See A.5.2(27).
@end cartouche
@noindent
-Maximum image width is 649, see library file @file{a-numran.ads}.
+Maximum image width is 6864, see library file @file{s-rannum.ads}.
@sp 1
@cartouche
@code{Numerics.Discrete_Random.Max_Image_Width}. See A.5.2(27).
@end cartouche
@noindent
-Maximum image width is 80, see library file @file{a-nudira.ads}.
+Maximum image width is 6864, see library file @file{s-rannum.ads}.
@sp 1
@cartouche
A.5.2(32).
@end cartouche
@noindent
-The algorithm is documented in the source files @file{a-numran.ads} and
-@file{a-numran.adb}.
+The algorithm is the Mersenne Twister, as documented in the source file
+@file{s-rannum.adb}. This version of the algorithm has a period of
+2**19937-1.
@sp 1
@cartouche
state. See A.5.2(38).
@end cartouche
@noindent
-See the documentation contained in the file @file{a-numran.adb}.
+The value returned by the Image function is the concatenation of
+the fixed-width decimal representations of the 624 32-bit integers
+of the state vector.
@sp 1
@cartouche
Annex is not supported. See A.5.3(72).
@end cartouche
@noindent
-See the source file @file{ttypef.ads} for the values of all numeric
-attributes.
+Run the compiler with @option{-gnatS} to produce a listing of package
+@code{Standard}, has the values of all numeric attributes.
@sp 1
@cartouche
@sp 1
@cartouche
@noindent
-@strong{74}. Implementation-defined convention names. See B.1(11).
+@strong{74}. The interpretation of the @code{Form} parameter in procedure
+@code{Create_Directory}. See A.16(56).
@end cartouche
@noindent
-The following convention names are supported
+The @code{Form} parameter is not used.
+
+@sp 1
+@cartouche
+@noindent
+@strong{75}. The interpretation of the @code{Form} parameter in procedure
+@code{Create_Path}. See A.16(60).
+@end cartouche
+@noindent
+The @code{Form} parameter is not used.
+
+@sp 1
+@cartouche
+@noindent
+@strong{76}. The interpretation of the @code{Form} parameter in procedure
+@code{Copy_File}. See A.16(68).
+@end cartouche
+@noindent
+The @code{Form} parameter is case-insensitive.
+
+Two fields are recognized in the @code{Form} parameter:
@table @code
-@item Ada
-Ada
-@item Assembler
-Assembly language
-@item Asm
-Synonym for Assembler
-@item Assembly
-Synonym for Assembler
-@item C
-C
-@item C_Pass_By_Copy
-Allowed only for record types, like C, but also notes that record
+
+@item preserve=<value>
+
+@item mode=<value>
+
+@end table
+
+@noindent
+<value> starts immediately after the character '=' and ends with the
+character immediately preceding the next comma (',') or with the last
+character of the parameter.
+
+The only possible values for preserve= are:
+
+@table @code
+
+@item no_attributes
+Do not try to preserve any file attributes. This is the default if no
+preserve= is found in Form.
+
+@item all_attributes
+Try to preserve all file attributes (timestamps, access rights).
+
+@item timestamps
+Preserve the timestamp of the copied file, but not the other file attributes.
+
+@end table
+
+@noindent
+The only possible values for mode= are:
+
+@table @code
+
+@item copy
+Only do the copy if the destination file does not already exist. If it already
+exists, Copy_File fails.
+
+@item overwrite
+Copy the file in all cases. Overwite an already existing destination file.
+
+@item append
+Append the original file to the destination file. If the destination file does
+not exist, the destination file is a copy of the source file. When mode=append,
+the field preserve=, if it exists, is not taken into account.
+
+@end table
+
+@noindent
+If the Form parameter includes one or both of the fields and the value or
+values are incorrect, Copy_file fails with Use_Error.
+
+Examples of correct Forms:
+
+@smallexample
+Form => "preserve=no_attributes,mode=overwrite" (the default)
+Form => "mode=append"
+Form => "mode=copy, preserve=all_attributes"
+@end smallexample
+
+@noindent
+Examples of incorrect Forms
+
+@smallexample
+Form => "preserve=junk"
+Form => "mode=internal, preserve=timestamps"
+@end smallexample
+
+@sp 1
+@cartouche
+@noindent
+@strong{77}. Implementation-defined convention names. See B.1(11).
+@end cartouche
+@noindent
+The following convention names are supported
+
+@table @code
+@item Ada
+Ada
+@item Assembler
+Assembly language
+@item Asm
+Synonym for Assembler
+@item Assembly
+Synonym for Assembler
+@item C
+C
+@item C_Pass_By_Copy
+Allowed only for record types, like C, but also notes that record
is to be passed by copy rather than reference.
@item COBOL
COBOL
@sp 1
@cartouche
@noindent
-@strong{75}. The meaning of link names. See B.1(36).
+@strong{78}. The meaning of link names. See B.1(36).
@end cartouche
@noindent
Link names are the actual names used by the linker.
@sp 1
@cartouche
@noindent
-@strong{76}. The manner of choosing link names when neither the link
+@strong{79}. The manner of choosing link names when neither the link
name nor the address of an imported or exported entity is specified. See
B.1(36).
@end cartouche
@sp 1
@cartouche
@noindent
-@strong{77}. The effect of pragma @code{Linker_Options}. See B.1(37).
+@strong{80}. The effect of pragma @code{Linker_Options}. See B.1(37).
@end cartouche
@noindent
The string passed to @code{Linker_Options} is presented uninterpreted as
@sp 1
@cartouche
@noindent
-@strong{78}. The contents of the visible part of package
+@strong{81}. The contents of the visible part of package
@code{Interfaces} and its language-defined descendants. See B.2(1).
@end cartouche
@noindent
@sp 1
@cartouche
@noindent
-@strong{79}. Implementation-defined children of package
+@strong{82}. Implementation-defined children of package
@code{Interfaces}. The contents of the visible part of package
@code{Interfaces}. See B.2(11).
@end cartouche
@sp 1
@cartouche
@noindent
-@strong{80}. The types @code{Floating}, @code{Long_Floating},
+@strong{83}. The types @code{Floating}, @code{Long_Floating},
@code{Binary}, @code{Long_Binary}, @code{Decimal_ Element}, and
@code{COBOL_Character}; and the initialization of the variables
@code{Ada_To_COBOL} and @code{COBOL_To_Ada}, in
@sp 1
@cartouche
@noindent
-@strong{81}. Support for access to machine instructions. See C.1(1).
+@strong{84}. Support for access to machine instructions. See C.1(1).
@end cartouche
@noindent
See documentation in file @file{s-maccod.ads} in the distributed library.
@sp 1
@cartouche
@noindent
-@strong{82}. Implementation-defined aspects of access to machine
+@strong{85}. Implementation-defined aspects of access to machine
operations. See C.1(9).
@end cartouche
@noindent
@sp 1
@cartouche
@noindent
-@strong{83}. Implementation-defined aspects of interrupts. See C.3(2).
+@strong{86}. Implementation-defined aspects of interrupts. See C.3(2).
@end cartouche
@noindent
Interrupts are mapped to signals or conditions as appropriate. See
@sp 1
@cartouche
@noindent
-@strong{84}. Implementation-defined aspects of pre-elaboration. See
+@strong{87}. Implementation-defined aspects of pre-elaboration. See
C.4(13).
@end cartouche
@noindent
@sp 1
@cartouche
@noindent
-@strong{85}. The semantics of pragma @code{Discard_Names}. See C.5(7).
+@strong{88}. The semantics of pragma @code{Discard_Names}. See C.5(7).
@end cartouche
@noindent
Pragma @code{Discard_Names} causes names of enumeration literals to
@sp 1
@cartouche
@noindent
-@strong{86}. The result of the @code{Task_Identification.Image}
+@strong{89}. The result of the @code{Task_Identification.Image}
attribute. See C.7.1(7).
@end cartouche
@noindent
@sp 1
@cartouche
@noindent
-@strong{87}. The value of @code{Current_Task} when in a protected entry
+@strong{90}. The value of @code{Current_Task} when in a protected entry
or interrupt handler. See C.7.1(17).
@end cartouche
@noindent
@sp 1
@cartouche
@noindent
-@strong{88}. The effect of calling @code{Current_Task} from an entry
+@strong{91}. The effect of calling @code{Current_Task} from an entry
body or interrupt handler. See C.7.1(19).
@end cartouche
@noindent
@sp 1
@cartouche
@noindent
-@strong{89}. Implementation-defined aspects of
+@strong{92}. Implementation-defined aspects of
@code{Task_Attributes}. See C.7.2(19).
@end cartouche
@noindent
@sp 1
@cartouche
@noindent
-@strong{90}. Values of all @code{Metrics}. See D(2).
+@strong{93}. Values of all @code{Metrics}. See D(2).
@end cartouche
@noindent
The metrics information for GNAT depends on the performance of the
@sp 1
@cartouche
@noindent
-@strong{91}. The declarations of @code{Any_Priority} and
+@strong{94}. The declarations of @code{Any_Priority} and
@code{Priority}. See D.1(11).
@end cartouche
@noindent
@sp 1
@cartouche
@noindent
-@strong{92}. Implementation-defined execution resources. See D.1(15).
+@strong{95}. Implementation-defined execution resources. See D.1(15).
@end cartouche
@noindent
There are no implementation-defined execution resources.
@sp 1
@cartouche
@noindent
-@strong{93}. Whether, on a multiprocessor, a task that is waiting for
+@strong{96}. Whether, on a multiprocessor, a task that is waiting for
access to a protected object keeps its processor busy. See D.2.1(3).
@end cartouche
@noindent
@sp 1
@cartouche
@noindent
-@strong{94}. The affect of implementation defined execution resources
+@strong{97}. The affect of implementation defined execution resources
on task dispatching. See D.2.1(9).
@end cartouche
@noindent
@sp 1
@cartouche
@noindent
-@strong{95}. Implementation-defined @code{policy_identifiers} allowed
+@strong{98}. Implementation-defined @code{policy_identifiers} allowed
in a pragma @code{Task_Dispatching_Policy}. See D.2.2(3).
@end cartouche
@noindent
@sp 1
@cartouche
@noindent
-@strong{96}. Implementation-defined aspects of priority inversion. See
+@strong{99}. Implementation-defined aspects of priority inversion. See
D.2.2(16).
@end cartouche
@noindent
@sp 1
@cartouche
@noindent
-@strong{97}. Implementation defined task dispatching. See D.2.2(18).
+@strong{100}. Implementation defined task dispatching. See D.2.2(18).
@end cartouche
@noindent
@c SGI info:
@sp 1
@cartouche
@noindent
-@strong{98}. Implementation-defined @code{policy_identifiers} allowed
+@strong{101}. Implementation-defined @code{policy_identifiers} allowed
in a pragma @code{Locking_Policy}. See D.3(4).
@end cartouche
@noindent
@sp 1
@cartouche
@noindent
-@strong{99}. Default ceiling priorities. See D.3(10).
+@strong{102}. Default ceiling priorities. See D.3(10).
@end cartouche
@noindent
The ceiling priority of protected objects of the type
@sp 1
@cartouche
@noindent
-@strong{100}. The ceiling of any protected object used internally by
+@strong{103}. The ceiling of any protected object used internally by
the implementation. See D.3(16).
@end cartouche
@noindent
@sp 1
@cartouche
@noindent
-@strong{101}. Implementation-defined queuing policies. See D.4(1).
+@strong{104}. Implementation-defined queuing policies. See D.4(1).
@end cartouche
@noindent
There are no implementation-defined queuing policies.
@sp 1
@cartouche
@noindent
-@strong{102}. On a multiprocessor, any conditions that cause the
+@strong{105}. On a multiprocessor, any conditions that cause the
completion of an aborted construct to be delayed later than what is
specified for a single processor. See D.6(3).
@end cartouche
@sp 1
@cartouche
@noindent
-@strong{103}. Any operations that implicitly require heap storage
+@strong{106}. Any operations that implicitly require heap storage
allocation. See D.7(8).
@end cartouche
@noindent
@sp 1
@cartouche
@noindent
-@strong{104}. Implementation-defined aspects of pragma
+@strong{107}. Implementation-defined aspects of pragma
@code{Restrictions}. See D.7(20).
@end cartouche
@noindent
@sp 1
@cartouche
@noindent
-@strong{105}. Implementation-defined aspects of package
+@strong{108}. Implementation-defined aspects of package
@code{Real_Time}. See D.8(17).
@end cartouche
@noindent
@sp 1
@cartouche
@noindent
-@strong{106}. Implementation-defined aspects of
+@strong{109}. Implementation-defined aspects of
@code{delay_statements}. See D.9(8).
@end cartouche
@noindent
@sp 1
@cartouche
@noindent
-@strong{107}. The upper bound on the duration of interrupt blocking
+@strong{110}. The upper bound on the duration of interrupt blocking
caused by the implementation. See D.12(5).
@end cartouche
@noindent
@sp 1
@cartouche
@noindent
-@strong{108}. The means for creating and executing distributed
+@strong{111}. The means for creating and executing distributed
programs. See E(5).
@end cartouche
@noindent
@sp 1
@cartouche
@noindent
-@strong{109}. Any events that can result in a partition becoming
+@strong{112}. Any events that can result in a partition becoming
inaccessible. See E.1(7).
@end cartouche
@noindent
@sp 1
@cartouche
@noindent
-@strong{110}. The scheduling policies, treatment of priorities, and
+@strong{113}. The scheduling policies, treatment of priorities, and
management of shared resources between partitions in certain cases. See
E.1(11).
@end cartouche
@sp 1
@cartouche
@noindent
-@strong{111}. Events that cause the version of a compilation unit to
+@strong{114}. Events that cause the version of a compilation unit to
change. See E.3(5).
@end cartouche
@noindent
@sp 1
@cartouche
@noindent
-@strong{112}. Whether the execution of the remote subprogram is
+@strong{115}. Whether the execution of the remote subprogram is
immediately aborted as a result of cancellation. See E.4(13).
@end cartouche
@noindent
@sp 1
@cartouche
@noindent
-@strong{113}. Implementation-defined aspects of the PCS@. See E.5(25).
+@strong{116}. Implementation-defined aspects of the PCS@. See E.5(25).
@end cartouche
@noindent
See the GLADE reference manual for a full description of all implementation
@sp 1
@cartouche
@noindent
-@strong{114}. Implementation-defined interfaces in the PCS@. See
+@strong{117}. Implementation-defined interfaces in the PCS@. See
E.5(26).
@end cartouche
@noindent
@sp 1
@cartouche
@noindent
-@strong{115}. The values of named numbers in the package
+@strong{118}. The values of named numbers in the package
@code{Decimal}. See F.2(7).
@end cartouche
@noindent
@sp 1
@cartouche
@noindent
-@strong{116}. The value of @code{Max_Picture_Length} in the package
+@strong{119}. The value of @code{Max_Picture_Length} in the package
@code{Text_IO.Editing}. See F.3.3(16).
@end cartouche
@noindent
@sp 1
@cartouche
@noindent
-@strong{117}. The value of @code{Max_Picture_Length} in the package
+@strong{120}. The value of @code{Max_Picture_Length} in the package
@code{Wide_Text_IO.Editing}. See F.3.4(5).
@end cartouche
@noindent
@sp 1
@cartouche
@noindent
-@strong{118}. The accuracy actually achieved by the complex elementary
+@strong{121}. The accuracy actually achieved by the complex elementary
functions and by other complex arithmetic operations. See G.1(1).
@end cartouche
@noindent
@sp 1
@cartouche
@noindent
-@strong{119}. The sign of a zero result (or a component thereof) from
+@strong{122}. The sign of a zero result (or a component thereof) from
any operator or function in @code{Numerics.Generic_Complex_Types}, when
@code{Real'Signed_Zeros} is True. See G.1.1(53).
@end cartouche
@sp 1
@cartouche
@noindent
-@strong{120}. The sign of a zero result (or a component thereof) from
+@strong{123}. The sign of a zero result (or a component thereof) from
any operator or function in
@code{Numerics.Generic_Complex_Elementary_Functions}, when
@code{Real'Signed_Zeros} is @code{True}. See G.1.2(45).
@sp 1
@cartouche
@noindent
-@strong{121}. Whether the strict mode or the relaxed mode is the
+@strong{124}. Whether the strict mode or the relaxed mode is the
default. See G.2(2).
@end cartouche
@noindent
@sp 1
@cartouche
@noindent
-@strong{122}. The result interval in certain cases of fixed-to-float
+@strong{125}. The result interval in certain cases of fixed-to-float
conversion. See G.2.1(10).
@end cartouche
@noindent
@sp 1
@cartouche
@noindent
-@strong{123}. The result of a floating point arithmetic operation in
+@strong{126}. The result of a floating point arithmetic operation in
overflow situations, when the @code{Machine_Overflows} attribute of the
result type is @code{False}. See G.2.1(13).
@end cartouche
@sp 1
@cartouche
@noindent
-@strong{124}. The result interval for division (or exponentiation by a
+@strong{127}. The result interval for division (or exponentiation by a
negative exponent), when the floating point hardware implements division
as multiplication by a reciprocal. See G.2.1(16).
@end cartouche
@sp 1
@cartouche
@noindent
-@strong{125}. The definition of close result set, which determines the
+@strong{128}. The definition of close result set, which determines the
accuracy of certain fixed point multiplications and divisions. See
G.2.3(5).
@end cartouche
@sp 1
@cartouche
@noindent
-@strong{126}. Conditions on a @code{universal_real} operand of a fixed
+@strong{129}. Conditions on a @code{universal_real} operand of a fixed
point multiplication or division for which the result shall be in the
perfect result set. See G.2.3(22).
@end cartouche
@sp 1
@cartouche
@noindent
-@strong{127}. The result of a fixed point arithmetic operation in
+@strong{130}. The result of a fixed point arithmetic operation in
overflow situations, when the @code{Machine_Overflows} attribute of the
result type is @code{False}. See G.2.3(27).
@end cartouche
@sp 1
@cartouche
@noindent
-@strong{128}. The result of an elementary function reference in
+@strong{131}. The result of an elementary function reference in
overflow situations, when the @code{Machine_Overflows} attribute of the
result type is @code{False}. See G.2.4(4).
@end cartouche
@sp 1
@cartouche
@noindent
-@strong{129}. The value of the angle threshold, within which certain
+@strong{132}. The value of the angle threshold, within which certain
elementary functions, complex arithmetic operations, and complex
elementary functions yield results conforming to a maximum relative
error bound. See G.2.4(10).
@sp 1
@cartouche
@noindent
-@strong{130}. The accuracy of certain elementary functions for
+@strong{133}. The accuracy of certain elementary functions for
parameters beyond the angle threshold. See G.2.4(10).
@end cartouche
@noindent
@sp 1
@cartouche
@noindent
-@strong{131}. The result of a complex arithmetic operation or complex
+@strong{134}. The result of a complex arithmetic operation or complex
elementary function reference in overflow situations, when the
@code{Machine_Overflows} attribute of the corresponding real type is
@code{False}. See G.2.6(5).
@sp 1
@cartouche
@noindent
-@strong{132}. The accuracy of certain complex arithmetic operations and
+@strong{135}. The accuracy of certain complex arithmetic operations and
certain complex elementary functions for parameters (or components
thereof) beyond the angle threshold. See G.2.6(8).
@end cartouche
@sp 1
@cartouche
@noindent
-@strong{133}. Information regarding bounded errors and erroneous
+@strong{136}. Information regarding bounded errors and erroneous
execution. See H.2(1).
@end cartouche
@noindent
@sp 1
@cartouche
@noindent
-@strong{134}. Implementation-defined aspects of pragma
+@strong{137}. Implementation-defined aspects of pragma
@code{Inspection_Point}. See H.3.2(8).
@end cartouche
@noindent
@sp 1
@cartouche
@noindent
-@strong{135}. Implementation-defined aspects of pragma
+@strong{138}. Implementation-defined aspects of pragma
@code{Restrictions}. See H.4(25).
@end cartouche
@noindent
@sp 1
@cartouche
@noindent
-@strong{136}. Any restrictions on pragma @code{Restrictions}. See
+@strong{139}. Any restrictions on pragma @code{Restrictions}. See
H.4(27).
@end cartouche
@noindent
require four-byte alignment, and the Y component will be one byte. In this
case @code{R'Value_Size} will be 40 (bits) since this is the minimum size
required to store a value of this type, and for example, it is permissible
-to have a component of type R in an outer record whose component size is
+to have a component of type R in an outer array whose component size is
specified to be 48 bits. However, @code{R'Object_Size} will be 64 (bits),
since it must be rounded up so that this value is a multiple of the
alignment (4 bytes = 32 bits).
build the type @code{Complex} and @code{Imaginary}.
@item Ada.Numerics.Discrete_Random
-This package provides a random number generator suitable for generating
-random integer values from a specified range.
+This generic package provides a random number generator suitable for generating
+uniformly distributed values of a specified discrete subtype.
@item Ada.Numerics.Float_Random
This package provides a random number generator suitable for generating
-uniformly distributed floating point values.
+uniformly distributed floating point values in the unit interval.
@item Ada.Numerics.Generic_Complex_Elementary_Functions
This is a generic version of the package that provides the
@code{Character} and @code{String}.
@end table
-
-
@node The Implementation of Standard I/O
@chapter The Implementation of Standard I/O
* Wide_Text_IO::
* Wide_Wide_Text_IO::
* Stream_IO::
+* Text Translation::
* Shared Files::
* Filenames encoding::
* Open Modes::
@noindent
where letters may be in upper or lower case, and there are no spaces
between values. The order of the entries is not important. Currently
-there are two keywords defined.
+the following keywords defined.
@smallexample
+TEXT_TRANSLATION=[YES|NO]
SHARED=[YES|NO]
WCEM=[n|h|u|s|e|8|b]
+ENCODING=[UTF8|8BITS]
@end smallexample
@noindent
manner described for stream attributes.
@end itemize
+@node Text Translation
+@section Text Translation
+
+@noindent
+@samp{Text_Translation=@var{xxx}} may be used as the Form parameter
+passed to Text_IO.Create and Text_IO.Open:
+@samp{Text_Translation=@var{Yes}} is the default, which means to
+translate LF to/from CR/LF on Windows systems.
+@samp{Text_Translation=@var{No}} disables this translation; i.e. it
+uses binary mode. For output files, @samp{Text_Translation=@var{No}}
+may be used to create Unix-style files on
+Windows. @samp{Text_Translation=@var{xxx}} has no effect on Unix
+systems.
+
@node Shared Files
@section Shared Files
@end itemize
In the absence of a @samp{encoding=@var{xxx}} form parameter, the
-value UTF-8 is used. This encoding form parameter is only supported on
-the Windows platform. On the other Operating Systems the runtime is
-supporting UTF-8 natively.
+encoding is controlled by the @samp{GNAT_CODE_PAGE} environment
+variable. And if not set @samp{utf8} is assumed.
+
+@table @samp
+@item CP_ACP
+The current system Windows ANSI code page.
+@item CP_UTF8
+UTF-8 encoding
+@end table
+
+This encoding form parameter is only supported on the Windows
+platform. On the other Operating Systems the run-time is supporting
+UTF-8 natively.
@node Open Modes
@section Open Modes
-- Standard C functions --
--------------------------
-- The functions selected below are ones that are
- -- available in DOS, OS/2, UNIX and Xenix (but not
- -- necessarily in ANSI C). These are very thin interfaces
+ -- available in UNIX (but not necessarily in ANSI C).
+ -- These are very thin interfaces
-- which copy exactly the C headers. For more
-- documentation on these functions, see the Microsoft C
-- "Run-Time Library Reference" (Microsoft Press, 1990,
* Ada.Strings.Wide_Unbounded.Wide_Text_IO (a-swuwti.ads)::
* Ada.Strings.Wide_Wide_Unbounded.Wide_Wide_Text_IO (a-szuzti.ads)::
* Ada.Text_IO.C_Streams (a-tiocst.ads)::
+* Ada.Text_IO.Reset_Standard_Files (a-tirsfi.ads)::
* Ada.Wide_Characters.Unicode (a-wichun.ads)::
* Ada.Wide_Text_IO.C_Streams (a-wtcstr.ads)::
+* Ada.Wide_Text_IO.Reset_Standard_Files (a-wrstfi.ads)::
* Ada.Wide_Wide_Characters.Unicode (a-zchuni.ads)::
* Ada.Wide_Wide_Text_IO.C_Streams (a-ztcstr.ads)::
+* Ada.Wide_Wide_Text_IO.Reset_Standard_Files (a-zrstfi.ads)::
* GNAT.Altivec (g-altive.ads)::
* GNAT.Altivec.Conversions (g-altcon.ads)::
* GNAT.Altivec.Vector_Operations (g-alveop.ads)::
* GNAT.IO (g-io.ads)::
* GNAT.IO_Aux (g-io_aux.ads)::
* GNAT.Lock_Files (g-locfil.ads)::
+* GNAT.MBBS_Discrete_Random (g-mbdira.ads)::
+* GNAT.MBBS_Float_Random (g-mbflra.ads)::
* GNAT.MD5 (g-md5.ads)::
* GNAT.Memory_Dump (g-memdum.ads)::
* GNAT.Most_Recent_Exception (g-moreex.ads)::
* GNAT.Semaphores (g-semaph.ads)::
* GNAT.Serial_Communications (g-sercom.ads)::
* GNAT.SHA1 (g-sha1.ads)::
+* GNAT.SHA224 (g-sha224.ads)::
+* GNAT.SHA256 (g-sha256.ads)::
+* GNAT.SHA384 (g-sha384.ads)::
+* GNAT.SHA512 (g-sha512.ads)::
* GNAT.Signals (g-signal.ads)::
* GNAT.Sockets (g-socket.ads)::
* GNAT.Source_Info (g-souinf.ads)::
* GNAT.Spitbol.Table_Boolean (g-sptabo.ads)::
* GNAT.Spitbol.Table_Integer (g-sptain.ads)::
* GNAT.Spitbol.Table_VString (g-sptavs.ads)::
+* GNAT.SSE (g-sse.ads)::
+* GNAT.SSE.Vector_Types (g-ssvety.ads)::
* GNAT.Strings (g-string.ads)::
* GNAT.String_Split (g-strspl.ads)::
* GNAT.Table (g-table.ads)::
* System.Pool_Local (s-pooloc.ads)::
* System.Restrictions (s-restri.ads)::
* System.Rident (s-rident.ads)::
+* System.Strings.Stream_Ops (s-ststop.ads)::
* System.Task_Info (s-tasinf.ads)::
* System.Wch_Cnv (s-wchcnv.ads)::
* System.Wch_Con (s-wchcon.ads)::
extracted from a file opened on the Ada side, and an Ada file
can be constructed from a stream opened on the C side.
+@node Ada.Text_IO.Reset_Standard_Files (a-tirsfi.ads)
+@section @code{Ada.Text_IO.Reset_Standard_Files} (@file{a-tirsfi.ads})
+@cindex @code{Ada.Text_IO.Reset_Standard_Files} (@file{a-tirsfi.ads})
+@cindex @code{Text_IO} resetting standard files
+
+@noindent
+This procedure is used to reset the status of the standard files used
+by Ada.Text_IO. This is useful in a situation (such as a restart in an
+embedded application) where the status of the files may change during
+execution (for example a standard input file may be redefined to be
+interactive).
+
@node Ada.Wide_Characters.Unicode (a-wichun.ads)
@section @code{Ada.Wide_Characters.Unicode} (@file{a-wichun.ads})
@cindex @code{Ada.Wide_Characters.Unicode} (@file{a-wichun.ads})
extracted from a file opened on the Ada side, and an Ada file
can be constructed from a stream opened on the C side.
+@node Ada.Wide_Text_IO.Reset_Standard_Files (a-wrstfi.ads)
+@section @code{Ada.Wide_Text_IO.Reset_Standard_Files} (@file{a-wrstfi.ads})
+@cindex @code{Ada.Wide_Text_IO.Reset_Standard_Files} (@file{a-wrstfi.ads})
+@cindex @code{Wide_Text_IO} resetting standard files
+
+@noindent
+This procedure is used to reset the status of the standard files used
+by Ada.Wide_Text_IO. This is useful in a situation (such as a restart in an
+embedded application) where the status of the files may change during
+execution (for example a standard input file may be redefined to be
+interactive).
+
@node Ada.Wide_Wide_Characters.Unicode (a-zchuni.ads)
@section @code{Ada.Wide_Wide_Characters.Unicode} (@file{a-zchuni.ads})
@cindex @code{Ada.Wide_Wide_Characters.Unicode} (@file{a-zchuni.ads})
extracted from a file opened on the Ada side, and an Ada file
can be constructed from a stream opened on the C side.
+@node Ada.Wide_Wide_Text_IO.Reset_Standard_Files (a-zrstfi.ads)
+@section @code{Ada.Wide_Wide_Text_IO.Reset_Standard_Files} (@file{a-zrstfi.ads})
+@cindex @code{Ada.Wide_Wide_Text_IO.Reset_Standard_Files} (@file{a-zrstfi.ads})
+@cindex @code{Wide_Wide_Text_IO} resetting standard files
+
+@noindent
+This procedure is used to reset the status of the standard files used
+by Ada.Wide_Wide_Text_IO. This is useful in a situation (such as a
+restart in an embedded application) where the status of the files may
+change during execution (for example a standard input file may be
+redefined to be interactive).
+
@node GNAT.Altivec (g-altive.ads)
@section @code{GNAT.Altivec} (@file{g-altive.ads})
@cindex @code{GNAT.Altivec} (@file{g-altive.ads})
Provides a general interface for using files as locks. Can be used for
providing program level synchronization.
+@node GNAT.MBBS_Discrete_Random (g-mbdira.ads)
+@section @code{GNAT.MBBS_Discrete_Random} (@file{g-mbdira.ads})
+@cindex @code{GNAT.MBBS_Discrete_Random} (@file{g-mbdira.ads})
+@cindex Random number generation
+
+@noindent
+The original implementation of @code{Ada.Numerics.Discrete_Random}. Uses
+a modified version of the Blum-Blum-Shub generator.
+
+@node GNAT.MBBS_Float_Random (g-mbflra.ads)
+@section @code{GNAT.MBBS_Float_Random} (@file{g-mbflra.ads})
+@cindex @code{GNAT.MBBS_Float_Random} (@file{g-mbflra.ads})
+@cindex Random number generation
+
+@noindent
+The original implementation of @code{Ada.Numerics.Float_Random}. Uses
+a modified version of the Blum-Blum-Shub generator.
+
@node GNAT.MD5 (g-md5.ads)
@section @code{GNAT.MD5} (@file{g-md5.ads})
@cindex @code{GNAT.MD5} (@file{g-md5.ads})
@cindex Secure Hash Algorithm SHA-1
@noindent
-Implements the SHA-1 Secure Hash Algorithm as described in RFC 3174.
+Implements the SHA-1 Secure Hash Algorithm as described in FIPS PUB 180-3
+and RFC 3174.
+
+@node GNAT.SHA224 (g-sha224.ads)
+@section @code{GNAT.SHA224} (@file{g-sha224.ads})
+@cindex @code{GNAT.SHA224} (@file{g-sha224.ads})
+@cindex Secure Hash Algorithm SHA-224
+
+@noindent
+Implements the SHA-224 Secure Hash Algorithm as described in FIPS PUB 180-3.
+
+@node GNAT.SHA256 (g-sha256.ads)
+@section @code{GNAT.SHA256} (@file{g-sha256.ads})
+@cindex @code{GNAT.SHA256} (@file{g-sha256.ads})
+@cindex Secure Hash Algorithm SHA-256
+
+@noindent
+Implements the SHA-256 Secure Hash Algorithm as described in FIPS PUB 180-3.
+
+@node GNAT.SHA384 (g-sha384.ads)
+@section @code{GNAT.SHA384} (@file{g-sha384.ads})
+@cindex @code{GNAT.SHA384} (@file{g-sha384.ads})
+@cindex Secure Hash Algorithm SHA-384
+
+@noindent
+Implements the SHA-384 Secure Hash Algorithm as described in FIPS PUB 180-3.
+
+@node GNAT.SHA512 (g-sha512.ads)
+@section @code{GNAT.SHA512} (@file{g-sha512.ads})
+@cindex @code{GNAT.SHA512} (@file{g-sha512.ads})
+@cindex Secure Hash Algorithm SHA-512
+
+@noindent
+Implements the SHA-512 Secure Hash Algorithm as described in FIPS PUB 180-3.
@node GNAT.Signals (g-signal.ads)
@section @code{GNAT.Signals} (@file{g-signal.ads})
a variable length string type, giving an implementation of general
maps from strings to strings.
+@node GNAT.SSE (g-sse.ads)
+@section @code{GNAT.SSE} (@file{g-sse.ads})
+@cindex @code{GNAT.SSE} (@file{g-sse.ads})
+
+@noindent
+Root of a set of units aimed at offering Ada bindings to a subset of
+the Intel(r) Streaming SIMD Extensions with GNAT on the x86 family of
+targets. It exposes vector component types together with a general
+introduction to the binding contents and use.
+
+@node GNAT.SSE.Vector_Types (g-ssvety.ads)
+@section @code{GNAT.SSE.Vector_Types} (@file{g-ssvety.ads})
+@cindex @code{GNAT.SSE.Vector_Types} (@file{g-ssvety.ads})
+
+@noindent
+SSE vector types for use with SSE related intrinsics.
+
@node GNAT.Strings (g-string.ads)
@section @code{GNAT.Strings} (@file{g-string.ads})
@cindex @code{GNAT.Strings} (@file{g-string.ads})
since the necessary instantiation is included in
package System.Restrictions.
+@node System.Strings.Stream_Ops (s-ststop.ads)
+@section @code{System.Strings.Stream_Ops} (@file{s-ststop.ads})
+@cindex @code{System.Strings.Stream_Ops} (@file{s-ststop.ads})
+@cindex Stream operations
+@cindex String stream operations
+
+@noindent
+This package provides a set of stream subprograms for standard string types.
+It is intended primarily to support implicit use of such subprograms when
+stream attributes are applied to string types, but the subprograms in this
+package can be used directly by application programs.
+
@node System.Task_Info (s-tasinf.ads)
@section @code{System.Task_Info} (@file{s-tasinf.ads})
@cindex @code{System.Task_Info} (@file{s-tasinf.ads})
the services offered by the underlying kernel to the semantics expected
by GNARL@.
-Whatever the underlying OS (VxWorks, UNIX, OS/2, Windows NT, etc.) the
+Whatever the underlying OS (VxWorks, UNIX, Windows, etc.) the
key point is that each Ada task is mapped on a thread in the underlying
kernel. For example, in the case of VxWorks, one Ada task = one VxWorks task.
a temporary (created either by the front-end or the code generator) and then
that temporary will be copied onto the target.
-
@node The Size of Discriminated Records with Default Discriminants
@section The Size of Discriminated Records with Default Discriminants
infinite and and NaN values are properly generated.
-@node Project File Reference
-@chapter Project File Reference
+@node Implementation of Ada 2012 Features
+@chapter Implementation of Ada 2012 Features
+@cindex Ada 2012 implementation status
+
+This chapter contains a complete list of Ada 2012 features that have been
+implemented as of GNAT version 6.4. Generally, these features are only
+available if the @option{-gnat12} (Ada 2012 features enabled) flag is set
+@cindex @option{-gnat12} option
+or if the configuration pragma @code{Ada_2012} is used.
+@cindex pragma @code{Ada_2012}
+@cindex configuration pragma @code{Ada_2012}
+@cindex @code{Ada_2012} configuration pragma
+However, new pragmas, attributes, and restrictions are
+unconditionally available, since the Ada 95 standard allows the addition of
+new pragmas, attributes, and restrictions (there are exceptions, which are
+documented in the individual descriptions), and also certain packages
+were made available in earlier versions of Ada.
+
+An ISO date (YYYY-MM-DD) appears in parentheses on 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.
+
+Each feature corresponds to an Ada Issue (``AI'') approved by the Ada
+standardization group (ISO/IEC JTC1/SC22/WG9) for inclusion in Ada 2012.
+The features are ordered based on the relevant sections of the Ada
+Reference Manual (``RM''). When a given AI relates to multiple points
+in the RM, the earliest is used.
+
+A complete description of the AIs may be found in
+@url{www.ada-auth.org/ai05-summary.html}.
-@noindent
-This chapter describes the syntax and semantics of project files.
-Project files specify the options to be used when building a system.
-Project files can specify global settings for all tools,
-as well as tool-specific settings.
-@xref{Examples of Project Files,,, gnat_ugn, @value{EDITION} User's Guide},
-for examples of use.
+@itemize @bullet
-@menu
-* Reserved Words::
-* Lexical Elements::
-* Declarations::
-* Empty declarations::
-* Typed string declarations::
-* Variables::
-* Expressions::
-* Attributes::
-* Project Attributes::
-* Attribute References::
-* External Values::
-* Case Construction::
-* Packages::
-* Package Renamings::
-* Projects::
-* Project Extensions::
-* Project File Elaboration::
-@end menu
+@item
+@emph{AI-0176 Quantified expressions (2010-09-29)}
+@cindex AI-0176 (Ada 2012 feature)
-@node Reserved Words
-@section Reserved Words
+@noindent
+ Both universally and existentially quantified expressions are implemented.
+ They use the new syntax for iterators proposed in AI05-139-2, as well as
+ the standard Ada loop syntax.
@noindent
-All Ada reserved words are reserved in project files, and cannot be used
-as variable names or project names. In addition, the following are
-also reserved in project files:
+ RM References: 1.01.04 (12) 2.09 (2/2) 4.04 (7) 4.05.09 (0)
-@itemize
-@item @code{extends}
+@item
+@emph{AI-0079 Allow @i{other_format} characters in source (2010-07-10)}
+@cindex AI-0079 (Ada 2012 feature)
-@item @code{external}
+@noindent
+ Wide characters in the unicode category @i{other_format} are now allowed in
+ source programs between tokens, but not within a token such as an identifier.
-@item @code{project}
+@noindent
+ RM References: 2.01 (4/2) 2.02 (7)
-@end itemize
+@item
+@emph{AI-0091 Do not allow @i{other_format} in identifiers (0000-00-00)}
+@cindex AI-0091 (Ada 2012 feature)
-@node Lexical Elements
-@section Lexical Elements
+@noindent
+ Wide characters in the unicode category @i{other_format} are not permitted
+ within an identifier, since this can be a security problem. The error
+ message for this case has been improved to be more specific, but GNAT has
+ never allowed such characters to appear in identifiers.
@noindent
-Rules for identifiers are the same as in Ada. Identifiers
-are case-insensitive. Strings are case sensitive, except where noted.
-Comments have the same form as in Ada.
+ RM References: 2.03 (3.1/2) 2.03 (4/2) 2.03 (5/2) 2.03 (5.1/2) 2.03 (5.2/2) 2.03 (5.3/2) 2.09 (2/2)
+
+@item
+@emph{AI-0100 Placement of pragmas (2010-07-01)}
+@cindex AI-0100 (Ada 2012 feature)
@noindent
-Syntax:
+ This AI is an earlier version of AI-163. It simplifies the rules
+ for legal placement of pragmas. In the case of lists that allow pragmas, if
+ the list may have no elements, then the list may consist solely of pragmas.
-@smallexample
-simple_name ::=
- identifier
+@noindent
+ RM References: 2.08 (7)
-name ::=
- simple_name @{. simple_name@}
-@end smallexample
+@item
+@emph{AI-0163 Pragmas in place of null (2010-07-01)}
+@cindex AI-0163 (Ada 2012 feature)
-@node Declarations
-@section Declarations
+@noindent
+ A statement sequence may be composed entirely of pragmas. It is no longer
+ necessary to add a dummy @code{null} statement to make the sequence legal.
@noindent
-Declarations introduce new entities that denote types, variables, attributes,
-and packages. Some declarations can only appear immediately within a project
-declaration. Others can appear within a project or within a package.
+ RM References: 2.08 (7) 2.08 (16)
-Syntax:
-@smallexample
-declarative_item ::=
- simple_declarative_item |
- typed_string_declaration |
- package_declaration
-simple_declarative_item ::=
- variable_declaration |
- typed_variable_declaration |
- attribute_declaration |
- case_construction |
- empty_declaration
-@end smallexample
+@item
+@emph{AI-0080 ``View of'' not needed if clear from context (0000-00-00)}
+@cindex AI-0080 (Ada 2012 feature)
-@node Empty declarations
-@section Empty declarations
+@noindent
+ This is an editorial change only, described as non-testable in the AI.
-@smallexample
-empty_declaration ::=
- @b{null} ;
-@end smallexample
+@noindent
+ RM References: 3.01 (7)
-An empty declaration is allowed anywhere a declaration is allowed.
-It has no effect.
-@node Typed string declarations
-@section Typed string declarations
+@item
+@emph{AI-0183 Aspect specifications (2010-08-16)}
+@cindex AI-0183 (Ada 2012 feature)
+
+@noindent
+ Aspect specifications have been fully implemented except for pre and post-
+ conditions, and type invariants, which have their own separate AI's. All
+ forms of declarations listed in the AI are supported. The following is a
+ list of the aspects supported (with GNAT implementation aspects marked)
+
+@multitable {@code{Preelaborable_Initialization}} {--GNAT}
+@item @code{Ada_2005} @tab -- GNAT
+@item @code{Ada_2012} @tab -- GNAT
+@item @code{Address} @tab
+@item @code{Alignment} @tab
+@item @code{Atomic} @tab
+@item @code{Atomic_Components} @tab
+@item @code{Bit_Order} @tab
+@item @code{Component_Size} @tab
+@item @code{Discard_Names} @tab
+@item @code{External_Tag} @tab
+@item @code{Favor_Top_Level} @tab -- GNAT
+@item @code{Inline} @tab
+@item @code{Inline_Always} @tab -- GNAT
+@item @code{Invariant} @tab
+@item @code{Machine_Radix} @tab
+@item @code{No_Return} @tab
+@item @code{Object_Size} @tab -- GNAT
+@item @code{Pack} @tab
+@item @code{Persistent_BSS} @tab -- GNAT
+@item @code{Post} @tab
+@item @code{Pre} @tab
+@item @code{Predicate} @tab
+@item @code{Preelaborable_Initialization} @tab
+@item @code{Pure_Function} @tab -- GNAT
+@item @code{Shared} @tab -- GNAT
+@item @code{Size} @tab
+@item @code{Storage_Pool} @tab
+@item @code{Storage_Size} @tab
+@item @code{Stream_Size} @tab
+@item @code{Suppress} @tab
+@item @code{Suppress_Debug_Info} @tab -- GNAT
+@item @code{Unchecked_Union} @tab
+@item @code{Universal_Aliasing} @tab -- GNAT
+@item @code{Unmodified} @tab -- GNAT
+@item @code{Unreferenced} @tab -- GNAT
+@item @code{Unreferenced_Objects} @tab -- GNAT
+@item @code{Unsuppress} @tab
+@item @code{Value_Size} @tab -- GNAT
+@item @code{Volatile} @tab
+@item @code{Volatile_Components}
+@item @code{Warnings} @tab -- GNAT
+@end multitable
+
+@noindent
+ Note that for aspects with an expression, e.g. @code{Size}, the expression is
+ treated like a default expression (visibility is analyzed at the point of
+ occurrence of the aspect, but evaluation of the expression occurs at the
+ freeze point of the entity involved.
+
+@noindent
+ RM References: 3.02.01 (3) 3.02.02 (2) 3.03.01 (2/2) 3.08 (6)
+ 3.09.03 (1.1/2) 6.01 (2/2) 6.07 (2/2) 9.05.02 (2/2) 7.01 (3) 7.03
+ (2) 7.03 (3) 9.01 (2/2) 9.01 (3/2) 9.04 (2/2) 9.04 (3/2)
+ 9.05.02 (2/2) 11.01 (2) 12.01 (3) 12.03 (2/2) 12.04 (2/2) 12.05 (2)
+ 12.06 (2.1/2) 12.06 (2.2/2) 12.07 (2) 13.01 (0.1/2) 13.03 (5/1)
+ 13.03.01 (0)
-@noindent
-Typed strings are sequences of string literals. Typed strings are the only
-named types in project files. They are used in case constructions, where they
-provide support for conditional attribute definitions.
-Syntax:
-@smallexample
-typed_string_declaration ::=
- @b{type} <typed_string_>_simple_name @b{is}
- ( string_literal @{, string_literal@} );
-@end smallexample
+@item
+@emph{AI-0128 Inequality is a primitive operation (0000-00-00)}
+@cindex AI-0128 (Ada 2012 feature)
@noindent
-A typed string declaration can only appear immediately within a project
-declaration.
+ If an equality operator ("=") is declared for a type, then the implicitly
+ declared inequality operator ("/=") is a primitive operation of the type.
+ This is the only reasonable interpretation, and is the one always implemented
+ by GNAT, but the RM was not entirely clear in making this point.
-All the string literals in a typed string declaration must be distinct.
+@noindent
+ RM References: 3.02.03 (6) 6.06 (6)
-@node Variables
-@section Variables
+@item
+@emph{AI-0003 Qualified expressions as names (2010-07-11)}
+@cindex AI-0003 (Ada 2012 feature)
@noindent
-Variables denote values, and appear as constituents of expressions.
+ In Ada 2012, a qualified expression is considered to be syntatically a name,
+ meaning that constructs such as @code{A'(F(X)).B} are now legal. This is
+ useful in disambiguating some cases of overloading.
-@smallexample
-typed_variable_declaration ::=
- <typed_variable_>simple_name : <typed_string_>name := string_expression ;
+@noindent
+ RM References: 3.03 (11) 3.03 (21) 4.01 (2) 4.04 (7) 4.07 (3)
+ 5.04 (7)
-variable_declaration ::=
- <variable_>simple_name := expression;
-@end smallexample
+@item
+@emph{AI-0120 Constant instance of protected object (0000-00-00)}
+@cindex AI-0120 (Ada 2012 feature)
@noindent
-The elaboration of a variable declaration introduces the variable and
-assigns to it the value of the expression. The name of the variable is
-available after the assignment symbol.
+ This is an RM editorial change only. The section that lists objects that are
+ constant failed to include the current instance of a protected object
+ within a protected function. This has always been treated as a constant
+ in GNAT.
@noindent
-A typed_variable can only be declare once.
+ RM References: 3.03 (21)
+
+@item
+@emph{AI-0008 General access to constrained objects (0000-00-00)}
+@cindex AI-0008 (Ada 2012 feature)
@noindent
-a non-typed variable can be declared multiple times.
+ The wording in the RM implied that if you have a general access to a
+ constrained object, it could be used to modify the discriminants. This was
+ obviously not intended. @code{Constraint_Error} should be raised, and GNAT
+ has always done so in this situation.
@noindent
-Before the completion of its first declaration, the value of variable
-is the null string.
+ RM References: 3.03 (23) 3.10.02 (26/2) 4.01 (9) 6.04.01 (17) 8.05.01 (5/2)
+
-@node Expressions
-@section Expressions
+@item
+@emph{AI-0093 Additional rules use immutably limited (0000-00-00)}
+@cindex AI-0093 (Ada 2012 feature)
@noindent
-An expression is a formula that defines a computation or retrieval of a value.
-In a project file the value of an expression is either a string or a list
-of strings. A string value in an expression is either a literal, the current
-value of a variable, an external value, an attribute reference, or a
-concatenation operation.
+ This is an editorial change only, to make more widespread use of the Ada 2012
+ ``immutably limited''.
-Syntax:
+@noindent
+ RM References: 3.03 (23.4/3)
-@smallexample
-expression ::=
- term @{& term@}
-term ::=
- string_literal |
- string_list |
- <variable_>name |
- external_value |
- attribute_reference
-string_literal ::=
- (same as Ada)
+@item
+@emph{AI-0096 Deriving from formal private types (2010-07-20)}
+@cindex AI-0096 (Ada 2012 feature)
-string_list ::=
- ( <string_>expression @{ , <string_>expression @} )
-@end smallexample
+@noindent
+ In general it is illegal for a type derived from a formal limited type to be
+ nonlimited. This AI makes an exception to this rule: derivation is legal
+ if it appears in the private part of the generic, and the formal type is not
+ tagged. If the type is tagged, the legality check must be applied to the
+ private part of the package.
-@subsection Concatenation
@noindent
-The following concatenation functions are defined:
+ RM References: 3.04 (5.1/2) 6.02 (7)
-@smallexample @c ada
- function "&" (X : String; Y : String) return String;
- function "&" (X : String_List; Y : String) return String_List;
- function "&" (X : String_List; Y : String_List) return String_List;
-@end smallexample
-@node Attributes
-@section Attributes
+@item
+@emph{AI-0181 Soft hyphen is a non-graphic character (2010-07-23)}
+@cindex AI-0181 (Ada 2012 feature)
@noindent
-An attribute declaration defines a property of a project or package. This
-property can later be queried by means of an attribute reference.
-Attribute values are strings or string lists.
+ From Ada 2005 on, soft hyphen is considered a non-graphic character, which
+ means that it has a special name (@code{SOFT_HYPHEN}) in conjunction with the
+ @code{Image} and @code{Value} attributes for the character types. Strictly
+ speaking this is an inconsistency with Ada 95, but in practice the use of
+ these attributes is so obscure that it will not cause problems.
-Some attributes are associative arrays. These attributes are mappings whose
-domain is a set of strings. These attributes are declared one association
-at a time, by specifying a point in the domain and the corresponding image
-of the attribute. They may also be declared as a full associative array,
-getting the same associations as the corresponding attribute in an imported
-or extended project.
-
-Attributes that are not associative arrays are called simple attributes.
+@noindent
+ RM References: 3.05.02 (2/2) A.01 (35/2) A.03.03 (21)
-Syntax:
-@smallexample
-attribute_declaration ::=
- full_associative_array_declaration |
- @b{for} attribute_designator @b{use} expression ;
-full_associative_array_declaration ::=
- @b{for} <associative_array_attribute_>simple_name @b{use}
- <project_>simple_name [ . <package_>simple_Name ] ' <attribute_>simple_name ;
+@item
+@emph{AI-0182 Additional forms for @code{Character'Value} (0000-00-00)}
+@cindex AI-0182 (Ada 2012 feature)
-attribute_designator ::=
- <simple_attribute_>simple_name |
- <associative_array_attribute_>simple_name ( string_literal )
-@end smallexample
+@noindent
+ This AI allows @code{Character'Value} to accept the string @code{'?'} where
+ @code{?} is any character including non-graphic control characters. GNAT has
+ always accepted such strings. It also allows strings such as
+ @code{HEX_00000041} to be accepted, but GNAT does not take advantage of this
+ permission and raises @code{Constraint_Error}, as is certainly still
+ permitted.
@noindent
-Some attributes are project-specific, and can only appear immediately within
-a project declaration. Others are package-specific, and can only appear within
-the proper package.
+ RM References: 3.05 (56/2)
-The expression in an attribute definition must be a string or a string_list.
-The string literal appearing in the attribute_designator of an associative
-array attribute is case-insensitive.
-@node Project Attributes
-@section Project Attributes
+@item
+@emph{AI-0214 Defaulted discriminants for limited tagged (2010-10-01)}
+@cindex AI-0214 (Ada 2012 feature)
@noindent
-The following attributes apply to a project. All of them are simple
-attributes.
+ Ada 2012 relaxes the restriction that forbids discriminants of tagged types
+ to have default expressions by allowing them when the type is limited. It
+ is often useful to define a default value for a discriminant even though
+ it can't be changed by assignment.
-@table @code
-@item Object_Dir
-Expression must be a path name. The attribute defines the
-directory in which the object files created by the build are to be placed. If
-not specified, object files are placed in the project directory.
-
-@item Exec_Dir
-Expression must be a path name. The attribute defines the
-directory in which the executables created by the build are to be placed.
-If not specified, executables are placed in the object directory.
-
-@item Source_Dirs
-Expression must be a list of path names. The attribute
-defines the directories in which the source files for the project are to be
-found. If not specified, source files are found in the project directory.
-If a string in the list ends with "/**", then the directory that precedes
-"/**" and all of its subdirectories (recursively) are included in the list
-of source directories.
-
-@item Excluded_Source_Dirs
-Expression must be a list of strings. Each entry designates a directory that
-is not to be included in the list of source directories of the project.
-This is normally used when there are strings ending with "/**" in the value
-of attribute Source_Dirs.
-
-@item Source_Files
-Expression must be a list of file names. The attribute
-defines the individual files, in the project directory, which are to be used
-as sources for the project. File names are path_names that contain no directory
-information. If the project has no sources the attribute must be declared
-explicitly with an empty list.
-
-@item Excluded_Source_Files (Locally_Removed_Files)
-Expression must be a list of strings that are legal file names.
-Each file name must designate a source that would normally be a source file
-in the source directories of the project or, if the project file is an
-extending project file, inherited by the current project file. It cannot
-designate an immediate source that is not inherited. Each of the source files
-in the list are not considered to be sources of the project file: they are not
-inherited. Attribute Locally_Removed_Files is obsolescent, attribute
-Excluded_Source_Files is preferred.
-
-@item Source_List_File
-Expression must a single path name. The attribute
-defines a text file that contains a list of source file names to be used
-as sources for the project
-
-@item Library_Dir
-Expression must be a path name. The attribute defines the
-directory in which a library is to be built. The directory must exist, must
-be distinct from the project's object directory, and must be writable.
-
-@item Library_Name
-Expression must be a string that is a legal file name,
-without extension. The attribute defines a string that is used to generate
-the name of the library to be built by the project.
-
-@item Library_Kind
-Argument must be a string value that must be one of the
-following @code{"static"}, @code{"dynamic"} or @code{"relocatable"}. This
-string is case-insensitive. If this attribute is not specified, the library is
-a static library. Otherwise, the library may be dynamic or relocatable. This
-distinction is operating-system dependent.
-
-@item Library_Version
-Expression must be a string value whose interpretation
-is platform dependent. On UNIX, it is used only for dynamic/relocatable
-libraries as the internal name of the library (the @code{"soname"}). If the
-library file name (built from the @code{Library_Name}) is different from the
-@code{Library_Version}, then the library file will be a symbolic link to the
-actual file whose name will be @code{Library_Version}.
-
-@item Library_Interface
-Expression must be a string list. Each element of the string list
-must designate a unit of the project.
-If this attribute is present in a Library Project File, then the project
-file is a Stand-alone Library_Project_File.
-
-@item Library_Auto_Init
-Expression must be a single string "true" or "false", case-insensitive.
-If this attribute is present in a Stand-alone Library Project File,
-it indicates if initialization is automatic when the dynamic library
-is loaded.
-
-@item Library_Options
-Expression must be a string list. Indicates additional switches that
-are to be used when building a shared library.
-
-@item Library_GCC
-Expression must be a single string. Designates an alternative to "gcc"
-for building shared libraries.
-
-@item Library_Src_Dir
-Expression must be a path name. The attribute defines the
-directory in which the sources of the interfaces of a Stand-alone Library will
-be copied. The directory must exist, must be distinct from the project's
-object directory and source directories of all projects in the project tree,
-and must be writable.
-
-@item Library_Src_Dir
-Expression must be a path name. The attribute defines the
-directory in which the ALI files of a Library will
-be copied. The directory must exist, must be distinct from the project's
-object directory and source directories of all projects in the project tree,
-and must be writable.
-
-@item Library_Symbol_File
-Expression must be a single string. Its value is the single file name of a
-symbol file to be created when building a stand-alone library when the
-symbol policy is either "compliant", "controlled" or "restricted",
-on platforms that support symbol control, such as VMS. When symbol policy
-is "direct", then a file with this name must exist in the object directory.
-
-@item Library_Reference_Symbol_File
-Expression must be a single string. Its value is the path name of a
-reference symbol file that is read when the symbol policy is either
-"compliant" or "controlled", on platforms that support symbol control,
-such as VMS, when building a stand-alone library. The path may be an absolute
-path or a path relative to the project directory.
-
-@item Library_Symbol_Policy
-Expression must be a single string. Its case-insensitive value can only be
-"autonomous", "default", "compliant", "controlled", "restricted" or "direct".
-
-This attribute is not taken into account on all platforms. It controls the
-policy for exported symbols and, on some platforms (like VMS) that have the
-notions of major and minor IDs built in the library files, it controls
-the setting of these IDs.
-
-"autonomous" or "default": exported symbols are not controlled.
-
-"compliant": if attribute Library_Reference_Symbol_File is not defined, then
-it is equivalent to policy "autonomous". If there are exported symbols in
-the reference symbol file that are not in the object files of the interfaces,
-the major ID of the library is increased. If there are symbols in the
-object files of the interfaces that are not in the reference symbol file,
-these symbols are put at the end of the list in the newly created symbol file
-and the minor ID is increased.
-
-"controlled": the attribute Library_Reference_Symbol_File must be defined.
-The library will fail to build if the exported symbols in the object files of
-the interfaces do not match exactly the symbol in the symbol file.
-
-"restricted": The attribute Library_Symbol_File must be defined. The library
-will fail to build if there are symbols in the symbol file that are not in
-the exported symbols of the object files of the interfaces. Additional symbols
-in the object files are not added to the symbol file.
-
-"direct": The attribute Library_Symbol_File must be defined and must designate
-an existing file in the object directory. This symbol file is passed directly
-to the underlying linker without any symbol processing.
-
-@item Main
-Expression must be a list of strings that are legal file names.
-These file names designate existing compilation units in the source directory
-that are legal main subprograms.
-
-When a project file is elaborated, as part of the execution of a gnatmake
-command, one or several executables are built and placed in the Exec_Dir.
-If the gnatmake command does not include explicit file names, the executables
-that are built correspond to the files specified by this attribute.
-
-@item Externally_Built
-Expression must be a single string. Its value must be either "true" of "false",
-case-insensitive. The default is "false". When the value of this attribute is
-"true", no attempt is made to compile the sources or to build the library,
-when the project is a library project.
-
-@item Main_Language
-This is a simple attribute. Its value is a string that specifies the
-language of the main program.
-
-@item Languages
-Expression must be a string list. Each string designates
-a programming language that is known to GNAT. The strings are case-insensitive.
+@noindent
+ RM References: 3.07 (9.1/2) 3.07.02 (3)
-@end table
-@node Attribute References
-@section Attribute References
+@item
+@emph{AI-0102 Some implicit conversions are illegal (0000-00-00)}
+@cindex AI-0102 (Ada 2012 feature)
@noindent
-Attribute references are used to retrieve the value of previously defined
-attribute for a package or project.
-Syntax:
-@smallexample
-attribute_reference ::=
- attribute_prefix ' <simple_attribute_>simple_name [ ( string_literal ) ]
-
-attribute_prefix ::=
- @b{project} |
- <project_simple_name | package_identifier |
- <project_>simple_name . package_identifier
-@end smallexample
+ It is illegal to assign an anonymous access constant to an anonymous access
+ variable. The RM did not have a clear rule to prevent this, but GNAT has
+ always generated an error for this usage.
@noindent
-If an attribute has not been specified for a given package or project, its
-value is the null string or the empty list.
+ RM References: 3.07 (16) 3.07.01 (9) 6.04.01 (6) 8.06 (27/2)
-@node External Values
-@section External Values
-@noindent
-An external value is an expression whose value is obtained from the command
-that invoked the processing of the current project file (typically a
-gnatmake command).
+@item
+@emph{AI-0158 Generalizing membership tests (2010-09-16)}
+@cindex AI-0158 (Ada 2012 feature)
-Syntax:
-@smallexample
-external_value ::=
- @b{external} ( string_literal [, string_literal] )
-@end smallexample
+@noindent
+ This AI extends the syntax of membership tests to simplify complex conditions
+ that can be expressed as membership in a subset of values of any type. It
+ introduces syntax for a list of expressions that may be used in loop contexts
+ as well.
@noindent
-The first string_literal is the string to be used on the command line or
-in the environment to specify the external value. The second string_literal,
-if present, is the default to use if there is no specification for this
-external value either on the command line or in the environment.
+ RM References: 3.08.01 (5) 4.04 (3) 4.05.02 (3) 4.05.02 (5) 4.05.02 (27)
+
-@node Case Construction
-@section Case Construction
+@item
+@emph{AI-0173 Testing if tags represent abstract types (2010-07-03)}
+@cindex AI-0173 (Ada 2012 feature)
@noindent
-A case construction supports attribute and variable declarations that depend
-on the value of a previously declared variable.
+ The function @code{Ada.Tags.Type_Is_Abstract} returns @code{True} if invoked
+ with the tag of an abstract type, and @code{False} otherwise.
-Syntax:
-@smallexample
-case_construction ::=
- @b{case} <typed_variable_>name @b{is}
- @{case_item@}
- @b{end case} ;
+@noindent
+ RM References: 3.09 (7.4/2) 3.09 (12.4/2)
-case_item ::=
- @b{when} discrete_choice_list =>
- @{case_construction |
- attribute_declaration |
- variable_declaration |
- empty_declaration@}
-discrete_choice_list ::=
- string_literal @{| string_literal@} |
- @b{others}
-@end smallexample
+
+@item
+@emph{AI-0076 function with controlling result (0000-00-00)}
+@cindex AI-0076 (Ada 2012 feature)
+
+@noindent
+ This is an editorial change only. The RM defines calls with controlling
+ results, but uses the term ``function with controlling result'' without an
+ explicit definition.
@noindent
-Inside a case construction, variable declarations must be for variables that
-have already been declared before the case construction.
+ RM References: 3.09.02 (2/2)
-All choices in a choice list must be distinct. The choice lists of two
-distinct alternatives must be disjoint. Unlike Ada, the choice lists of all
-alternatives do not need to include all values of the type. An @code{others}
-choice must appear last in the list of alternatives.
-@node Packages
-@section Packages
+@item
+@emph{AI-0126 Dispatching with no declared operation (0000-00-00)}
+@cindex AI-0126 (Ada 2012 feature)
@noindent
-A package provides a grouping of variable declarations and attribute
-declarations to be used when invoking various GNAT tools. The name of
-the package indicates the tool(s) to which it applies.
-Syntax:
+ This AI clarifies dispatching rules, and simply confirms that dispatching
+ executes the operation of the parent type when there is no explicitly or
+ implicitly declared operation for the descendant type. This has always been
+ the case in all versions of GNAT.
-@smallexample
-package_declaration ::=
- package_spec | package_renaming
+@noindent
+ RM References: 3.09.02 (20/2) 3.09.02 (20.1/2) 3.09.02 (20.2/2)
-package_spec ::=
- @b{package} package_identifier @b{is}
- @{simple_declarative_item@}
- @b{end} package_identifier ;
-package_identifier ::=
- @code{Naming} | @code{Builder} | @code{Compiler} | @code{Binder} |
- @code{Linker} | @code{Finder} | @code{Cross_Reference} |
- @code{gnatls} | @code{IDE} | @code{Pretty_Printer}
-@end smallexample
+@item
+@emph{AI-0097 Treatment of abstract null extension (2010-07-19)}
+@cindex AI-0097 (Ada 2012 feature)
-@subsection Package Naming
+@noindent
+ The RM as written implied that in some cases it was possible to create an
+ object of an abstract type, by having an abstract extension inherit a non-
+ abstract constructor from its parent type. This mistake has been corrected
+ in GNAT and in the RM, and this construct is now illegal.
@noindent
-The attributes of a @code{Naming} package specifies the naming conventions
-that apply to the source files in a project. When invoking other GNAT tools,
-they will use the sources in the source directories that satisfy these
-naming conventions.
+ RM References: 3.09.03 (4/2)
-The following attributes apply to a @code{Naming} package:
-@table @code
-@item Casing
-This is a simple attribute whose value is a string. Legal values of this
-string are @code{"lowercase"}, @code{"uppercase"} or @code{"mixedcase"}.
-These strings are themselves case insensitive.
+@item
+@emph{AI-0203 Extended return cannot be abstract (0000-00-00)}
+@cindex AI-0203 (Ada 2012 feature)
@noindent
-If @code{Casing} is not specified, then the default is @code{"lowercase"}.
+ A return_subtype_indication cannot denote an abstract subtype. GNAT has never
+ permitted such usage.
-@item Dot_Replacement
-This is a simple attribute whose string value satisfies the following
-requirements:
+@noindent
+ RM References: 3.09.03 (8/3)
-@itemize @bullet
-@item It must not be empty
-@item It cannot start or end with an alphanumeric character
-@item It cannot be a single underscore
-@item It cannot start with an underscore followed by an alphanumeric
-@item It cannot contain a dot @code{'.'} if longer than one character
-@end itemize
+
+@item
+@emph{AI-0198 Inheriting abstract operators (0000-00-00)}
+@cindex AI-0198 (Ada 2012 feature)
@noindent
-If @code{Dot_Replacement} is not specified, then the default is @code{"-"}.
+ This AI resolves a conflict between two rules involving inherited abstract
+ operations and predefined operators. If a derived numeric type inherits
+ an abstract operator, it overrides the predefined one. This interpretation
+ was always the one implemented in GNAT.
-@item Spec_Suffix
-This is an associative array attribute, defined on language names,
-whose image is a string that must satisfy the following
-conditions:
+@noindent
+ RM References: 3.09.03 (4/3)
-@itemize @bullet
-@item It must not be empty
-@item It cannot start with an alphanumeric character
-@item It cannot start with an underscore followed by an alphanumeric character
-@end itemize
+@item
+@emph{AI-0073 Functions returning abstract types (2010-07-10)}
+@cindex AI-0073 (Ada 2012 feature)
@noindent
-For Ada, the attribute denotes the suffix used in file names that contain
-library unit declarations, that is to say units that are package and
-subprogram declarations. If @code{Spec_Suffix ("Ada")} is not
-specified, then the default is @code{".ads"}.
+ This AI covers a number of issues regarding returning abstract types. In
+ particular generic fucntions cannot have abstract result types or access
+ result types designated an abstract type. There are some other cases which
+ are detailed in the AI. Note that this binding interpretation has not been
+ retrofitted to operate before Ada 2012 mode, since it caused a significant
+ number of regressions.
-For C and C++, the attribute denotes the suffix used in file names that
-contain prototypes.
+@noindent
+ RM References: 3.09.03 (8) 3.09.03 (10) 6.05 (8/2)
-@item Body_Suffix
-This is an associative array attribute defined on language names,
-whose image is a string that must satisfy the following
-conditions:
-@itemize @bullet
-@item It must not be empty
-@item It cannot start with an alphanumeric character
-@item It cannot start with an underscore followed by an alphanumeric character
-@item It cannot be a suffix of @code{Spec_Suffix}
-@end itemize
+@item
+@emph{AI-0070 Elaboration of interface types (0000-00-00)}
+@cindex AI-0070 (Ada 2012 feature)
@noindent
-For Ada, the attribute denotes the suffix used in file names that contain
-library bodies, that is to say units that are package and subprogram bodies.
-If @code{Body_Suffix ("Ada")} is not specified, then the default is
-@code{".adb"}.
+ This is an editorial change only, there are no testable consequences short of
+ checking for the absence of generated code for an interface declaration.
-For C and C++, the attribute denotes the suffix used in file names that contain
-source code.
+@noindent
+ RM References: 3.09.04 (18/2)
-@item Separate_Suffix
-This is a simple attribute whose value satisfies the same conditions as
-@code{Body_Suffix}.
-This attribute is specific to Ada. It denotes the suffix used in file names
-that contain separate bodies. If it is not specified, then it defaults to same
-value as @code{Body_Suffix ("Ada")}.
+@item
+@emph{AI-0208 Characteristics of incomplete views (0000-00-00)}
+@cindex AI-0208 (Ada 2012 feature)
-@item Spec
-This is an associative array attribute, specific to Ada, defined over
-compilation unit names. The image is a string that is the name of the file
-that contains that library unit. The file name is case sensitive if the
-conventions of the host operating system require it.
+@noindent
+ The wording in the Ada 2005 RM concerning characteristics of incomplete views
+ was incorrect and implied that some programs intended to be legal were now
+ illegal. GNAT had never considered such programs illegal, so it has always
+ implemented the intent of this AI.
-@item Body
-This is an associative array attribute, specific to Ada, defined over
-compilation unit names. The image is a string that is the name of the file
-that contains the library unit body for the named unit. The file name is case
-sensitive if the conventions of the host operating system require it.
+@noindent
+ RM References: 3.10.01 (2.4/2) 3.10.01 (2.6/2)
-@item Specification_Exceptions
-This is an associative array attribute defined on language names,
-whose value is a list of strings.
-This attribute is not significant for Ada.
+@item
+@emph{AI-0162 Incomplete type completed by partial view (2010-09-15)}
+@cindex AI-0162 (Ada 2012 feature)
-For C and C++, each string in the list denotes the name of a file that
-contains prototypes, but whose suffix is not necessarily the
-@code{Spec_Suffix} for the language.
+@noindent
+ Incomplete types are made more useful by allowing them to be completed by
+ private types and private extensions.
-@item Implementation_Exceptions
-This is an associative array attribute defined on language names,
-whose value is a list of strings.
+@noindent
+ RM References: 3.10.01 (2.5/2) 3.10.01 (2.6/2) 3.10.01 (3) 3.10.01 (4/2)
-This attribute is not significant for Ada.
-For C and C++, each string in the list denotes the name of a file that
-contains source code, but whose suffix is not necessarily the
-@code{Body_Suffix} for the language.
-@end table
-The following attributes of package @code{Naming} are obsolescent. They are
-kept as synonyms of other attributes for compatibility with previous versions
-of the Project Manager.
+@item
+@emph{AI-0098 Anonymous subprogram access restrictions (0000-00-00)}
+@cindex AI-0098 (Ada 2012 feature)
-@table @code
-@item Specification_Suffix
-This is a synonym of @code{Spec_Suffix}.
+@noindent
+ An unintentional omission in the RM implied some inconsistent restrictions on
+ the use of anonymous access to subprogram values. These restrictions were not
+ intentional, and have never been enforced by GNAT.
-@item Implementation_Suffix
-This is a synonym of @code{Body_Suffix}.
+@noindent
+ RM References: 3.10.01 (6) 3.10.01 (9.2/2)
-@item Specification
-This is a synonym of @code{Spec}.
-@item Implementation
-This is a synonym of @code{Body}.
-@end table
+@item
+@emph{AI-0199 Aggregate with anonymous access components (2010-07-14)}
+@cindex AI-0199 (Ada 2012 feature)
-@subsection package Compiler
+@noindent
+ A choice list in a record aggregate can include several components of
+ (distinct) anonymous access types as long as they have matching designated
+ subtypes.
@noindent
-The attributes of the @code{Compiler} package specify the compilation options
-to be used by the underlying compiler.
+ RM References: 4.03.01 (16)
-@table @code
-@item Default_Switches
-This is an associative array attribute. Its
-domain is a set of language names. Its range is a string list that
-specifies the compilation options to be used when compiling a component
-written in that language, for which no file-specific switches have been
-specified.
-
-@item Switches
-This is an associative array attribute. Its domain is
-a set of file names. Its range is a string list that specifies the
-compilation options to be used when compiling the named file. If a file
-is not specified in the Switches attribute, it is compiled with the
-options specified by Default_Switches of its language, if defined.
-
-@item Local_Configuration_Pragmas.
-This is a simple attribute, whose
-value is a path name that designates a file containing configuration pragmas
-to be used for all invocations of the compiler for immediate sources of the
-project.
-@end table
-@subsection package Builder
+@item
+@emph{AI-0220 Needed components for aggregates (0000-00-00)}
+@cindex AI-0220 (Ada 2012 feature)
@noindent
-The attributes of package @code{Builder} specify the compilation, binding, and
-linking options to be used when building an executable for a project. The
-following attributes apply to package @code{Builder}:
+ This AI addresses a wording problem in the RM that appears to permit some
+ complex cases of aggregates with non-static discriminants. GNAT has always
+ implemented the intended semantics.
-@table @code
-@item Default_Switches
-This is an associative array attribute. Its
-domain is a set of language names. Its range is a string list that
-specifies options to be used when building a main
-written in that language, for which no file-specific switches have been
-specified.
-
-@item Switches
-This is an associative array attribute. Its domain is
-a set of file names. Its range is a string list that specifies
-options to be used when building the named main file. If a main file
-is not specified in the Switches attribute, it is built with the
-options specified by Default_Switches of its language, if defined.
-
-@item Global_Configuration_Pragmas
-This is a simple attribute, whose
-value is a path name that designates a file that contains configuration pragmas
-to be used in every build of an executable. If both local and global
-configuration pragmas are specified, a compilation makes use of both sets.
-
-
-@item Executable
-This is an associative array attribute. Its domain is
-a set of main source file names. Its range is a simple string that specifies
-the executable file name to be used when linking the specified main source.
-If a main source is not specified in the Executable attribute, the executable
-file name is deducted from the main source file name.
-This attribute has no effect if its value is the empty string.
-
-@item Executable_Suffix
-This is a simple attribute whose value is the suffix to be added to
-the executables that don't have an attribute Executable specified.
-@end table
+@noindent
+ RM References: 4.03.01 (17)
-@subsection package Gnatls
+@item
+@emph{AI-0147 Conditional expressions (2009-03-29)}
+@cindex AI-0147 (Ada 2012 feature)
@noindent
-The attributes of package @code{Gnatls} specify the tool options to be used
-when invoking the library browser @command{gnatls}.
-The following attributes apply to package @code{Gnatls}:
+ Conditional expressions are permitted. The form of such an expression is:
-@table @code
-@item Switches
-This is a single attribute with a string list value. Each nonempty string
-in the list is an option when invoking @code{gnatls}.
-@end table
+@smallexample
+ (@b{if} @i{expr} @b{then} @i{expr} @{@b{elsif} @i{expr} @b{then} @i{expr}@} [@b{else} @i{expr}])
+@end smallexample
-@subsection package Binder
+ The parentheses can be omitted in contexts where parentheses are present
+ anyway, such as subprogram arguments and pragma arguments. If the @b{else}
+ clause is omitted, @b{else True} is assumed;
+ thus @code{(@b{if} A @b{then} B)} is a way to conveniently represent
+ @emph{(A implies B)} in standard logic.
@noindent
-The attributes of package @code{Binder} specify the options to be used
-when invoking the binder in the construction of an executable.
-The following attributes apply to package @code{Binder}:
+ RM References: 4.03.03 (15) 4.04 (1) 4.04 (7) 4.05.07 (0) 4.07 (2)
+ 4.07 (3) 4.09 (12) 4.09 (33) 5.03 (3) 5.03 (4) 7.05 (2.1/2)
-@table @code
-@item Default_Switches
-This is an associative array attribute. Its
-domain is a set of language names. Its range is a string list that
-specifies options to be used when binding a main
-written in that language, for which no file-specific switches have been
-specified.
-
-@item Switches
-This is an associative array attribute. Its domain is
-a set of file names. Its range is a string list that specifies
-options to be used when binding the named main file. If a main file
-is not specified in the Switches attribute, it is bound with the
-options specified by Default_Switches of its language, if defined.
-@end table
-@subsection package Linker
+@item
+@emph{AI-0037 Out-of-range box associations in aggregate (0000-00-00)}
+@cindex AI-0037 (Ada 2012 feature)
@noindent
-The attributes of package @code{Linker} specify the options to be used when
-invoking the linker in the construction of an executable.
-The following attributes apply to package @code{Linker}:
+ This AI confirms that an association of the form @code{Indx => <>} in an
+ array aggregate must raise @code{Constraint_Error} if @code{Indx}
+ is out of range. The RM specified a range check on other associations, but
+ not when the value of the association was defaulted. GNAT has always inserted
+ a constraint check on the index value.
-@table @code
-@item Default_Switches
-This is an associative array attribute. Its
-domain is a set of language names. Its range is a string list that
-specifies options to be used when linking a main
-written in that language, for which no file-specific switches have been
-specified.
-
-@item Switches
-This is an associative array attribute. Its domain is
-a set of file names. Its range is a string list that specifies
-options to be used when linking the named main file. If a main file
-is not specified in the Switches attribute, it is linked with the
-options specified by Default_Switches of its language, if defined.
-
-@item Linker_Options
-This is a string list attribute. Its value specifies additional options that
-be given to the linker when linking an executable. This attribute is not
-used in the main project, only in projects imported directly or indirectly.
+@noindent
+ RM References: 4.03.03 (29)
-@end table
-@subsection package Cross_Reference
+@item
+@emph{AI-0123 Composability of equality (2010-04-13)}
+@cindex AI-0123 (Ada 2012 feature)
@noindent
-The attributes of package @code{Cross_Reference} specify the tool options
-to be used
-when invoking the library tool @command{gnatxref}.
-The following attributes apply to package @code{Cross_Reference}:
+ Equality of untagged record composes, so that the predefined equality for a
+ composite type that includes a component of some untagged record type
+ @code{R} uses the equality operation of @code{R} (which may be user-defined
+ or predefined). This makes the behavior of untagged records identical to that
+ of tagged types in this respect.
-@table @code
-@item Default_Switches
-This is an associative array attribute. Its
-domain is a set of language names. Its range is a string list that
-specifies options to be used when calling @command{gnatxref} on a source
-written in that language, for which no file-specific switches have been
-specified.
-
-@item Switches
-This is an associative array attribute. Its domain is
-a set of file names. Its range is a string list that specifies
-options to be used when calling @command{gnatxref} on the named main source.
-If a source is not specified in the Switches attribute, @command{gnatxref} will
-be called with the options specified by Default_Switches of its language,
-if defined.
-@end table
-
-@subsection package Finder
+ This change is an incompatibility with previous versions of Ada, but it
+ corrects a non-uniformity that was often a source of confusion. Analysis of
+ a large number of industrial programs indicates that in those rare cases
+ where a composite type had an untagged record component with a user-defined
+ equality, either there was no use of the composite equality, or else the code
+ expected the same composability as for tagged types, and thus had a bug that
+ would be fixed by this change.
@noindent
-The attributes of package @code{Finder} specify the tool options to be used
-when invoking the search tool @command{gnatfind}.
-The following attributes apply to package @code{Finder}:
+ RM References: 4.05.02 (9.7/2) 4.05.02 (14) 4.05.02 (15) 4.05.02 (24)
+ 8.05.04 (8)
-@table @code
-@item Default_Switches
-This is an associative array attribute. Its
-domain is a set of language names. Its range is a string list that
-specifies options to be used when calling @command{gnatfind} on a source
-written in that language, for which no file-specific switches have been
-specified.
-
-@item Switches
-This is an associative array attribute. Its domain is
-a set of file names. Its range is a string list that specifies
-options to be used when calling @command{gnatfind} on the named main source.
-If a source is not specified in the Switches attribute, @command{gnatfind} will
-be called with the options specified by Default_Switches of its language,
-if defined.
-@end table
-@subsection package Pretty_Printer
+@item
+@emph{AI-0088 The value of exponentiation (0000-00-00)}
+@cindex AI-0088 (Ada 2012 feature)
@noindent
-The attributes of package @code{Pretty_Printer}
-specify the tool options to be used
-when invoking the formatting tool @command{gnatpp}.
-The following attributes apply to package @code{Pretty_Printer}:
+ This AI clarifies the equivalence rule given for the dynamic semantics of
+ exponentiation: the value of the operation can be obtained by repeated
+ multiplication, but the operation can be implemented otherwise (for example
+ using the familiar divide-by-two-and-square algorithm, even if this is less
+ accurate), and does not imply repeated reads of a volatile base.
-@table @code
-@item Default_switches
-This is an associative array attribute. Its
-domain is a set of language names. Its range is a string list that
-specifies options to be used when calling @command{gnatpp} on a source
-written in that language, for which no file-specific switches have been
-specified.
-
-@item Switches
-This is an associative array attribute. Its domain is
-a set of file names. Its range is a string list that specifies
-options to be used when calling @command{gnatpp} on the named main source.
-If a source is not specified in the Switches attribute, @command{gnatpp} will
-be called with the options specified by Default_Switches of its language,
-if defined.
-@end table
+@noindent
+ RM References: 4.05.06 (11)
-@subsection package gnatstub
+@item
+@emph{AI-0188 Case expressions (2010-01-09)}
+@cindex AI-0188 (Ada 2012 feature)
@noindent
-The attributes of package @code{gnatstub}
-specify the tool options to be used
-when invoking the tool @command{gnatstub}.
-The following attributes apply to package @code{gnatstub}:
+ Case expressions are permitted. This allows use of constructs such as:
+@smallexample
+ X := (@b{case} Y @b{is when} 1 => 2, @b{when} 2 => 3, @b{when others} => 31)
+@end smallexample
-@table @code
-@item Default_switches
-This is an associative array attribute. Its
-domain is a set of language names. Its range is a string list that
-specifies options to be used when calling @command{gnatstub} on a source
-written in that language, for which no file-specific switches have been
-specified.
-
-@item Switches
-This is an associative array attribute. Its domain is
-a set of file names. Its range is a string list that specifies
-options to be used when calling @command{gnatstub} on the named main source.
-If a source is not specified in the Switches attribute, @command{gnatpp} will
-be called with the options specified by Default_Switches of its language,
-if defined.
-@end table
+@noindent
+ RM References: 4.05.07 (0) 4.05.08 (0) 4.09 (12) 4.09 (33)
-@subsection package Eliminate
+@item
+@emph{AI-0104 Null exclusion and uninitialized allocator (2010-07-15)}
+@cindex AI-0104 (Ada 2012 feature)
@noindent
-The attributes of package @code{Eliminate}
-specify the tool options to be used
-when invoking the tool @command{gnatelim}.
-The following attributes apply to package @code{Eliminate}:
+ The assignment @code{Ptr := @b{new not null} Some_Ptr;} will raise
+ @code{Constraint_Error} because the default value of the allocated object is
+ @b{null}. This useless construct is illegal in Ada 2012.
-@table @code
-@item Default_switches
-This is an associative array attribute. Its
-domain is a set of language names. Its range is a string list that
-specifies options to be used when calling @command{gnatelim} on a source
-written in that language, for which no file-specific switches have been
-specified.
-
-@item Switches
-This is an associative array attribute. Its domain is
-a set of file names. Its range is a string list that specifies
-options to be used when calling @command{gnatelim} on the named main source.
-If a source is not specified in the Switches attribute, @command{gnatelim} will
-be called with the options specified by Default_Switches of its language,
-if defined.
-@end table
+@noindent
+ RM References: 4.08 (2)
-@subsection package Metrics
+@item
+@emph{AI-0157 Allocation/Deallocation from empty pool (2010-07-11)}
+@cindex AI-0157 (Ada 2012 feature)
@noindent
-The attributes of package @code{Metrics}
-specify the tool options to be used
-when invoking the tool @command{gnatmetric}.
-The following attributes apply to package @code{Metrics}:
+ Allocation and Deallocation from an empty storage pool (i.e. allocation or
+ deallocation of a pointer for which a static storage size clause of zero
+ has been given) is now illegal and is detected as such. GNAT
+ previously gave a warning but not an error.
-@table @code
-@item Default_switches
-This is an associative array attribute. Its
-domain is a set of language names. Its range is a string list that
-specifies options to be used when calling @command{gnatmetric} on a source
-written in that language, for which no file-specific switches have been
-specified.
-
-@item Switches
-This is an associative array attribute. Its domain is
-a set of file names. Its range is a string list that specifies
-options to be used when calling @command{gnatmetric} on the named main source.
-If a source is not specified in the Switches attribute, @command{gnatmetric}
-will be called with the options specified by Default_Switches of its language,
-if defined.
-@end table
+@noindent
+ RM References: 4.08 (5.3/2) 13.11.02 (4) 13.11.02 (17)
-@subsection package IDE
+@item
+@emph{AI-0179 Statement not required after label (2010-04-10)}
+@cindex AI-0179 (Ada 2012 feature)
@noindent
-The attributes of package @code{IDE} specify the options to be used when using
-an Integrated Development Environment such as @command{GPS}.
+ It is not necessary to have a statement following a label, so a label
+ can appear at the end of a statement sequence without the need for putting a
+ null statement afterwards, but it is not allowable to have only labels and
+ no real statements in a statement sequence.
-@table @code
-@item Remote_Host
-This is a simple attribute. Its value is a string that designates the remote
-host in a cross-compilation environment, to be used for remote compilation and
-debugging. This field should not be specified when running on the local
-machine.
+@noindent
+ RM References: 5.01 (2)
-@item Program_Host
-This is a simple attribute. Its value is a string that specifies the
-name of IP address of the embedded target in a cross-compilation environment,
-on which the program should execute.
-
-@item Communication_Protocol
-This is a simple string attribute. Its value is the name of the protocol
-to use to communicate with the target in a cross-compilation environment,
-e.g.@: @code{"wtx"} or @code{"vxworks"}.
-
-@item Compiler_Command
-This is an associative array attribute, whose domain is a language name. Its
-value is string that denotes the command to be used to invoke the compiler.
-The value of @code{Compiler_Command ("Ada")} is expected to be compatible with
-gnatmake, in particular in the handling of switches.
-
-@item Debugger_Command
-This is simple attribute, Its value is a string that specifies the name of
-the debugger to be used, such as gdb, powerpc-wrs-vxworks-gdb or gdb-4.
-
-@item Default_Switches
-This is an associative array attribute. Its indexes are the name of the
-external tools that the GNAT Programming System (GPS) is supporting. Its
-value is a list of switches to use when invoking that tool.
-
-@item Gnatlist
-This is a simple attribute. Its value is a string that specifies the name
-of the @command{gnatls} utility to be used to retrieve information about the
-predefined path; e.g., @code{"gnatls"}, @code{"powerpc-wrs-vxworks-gnatls"}.
-
-@item VCS_Kind
-This is a simple attribute. Its value is a string used to specify the
-Version Control System (VCS) to be used for this project, e.g.@: CVS, RCS
-ClearCase or Perforce.
-
-@item VCS_File_Check
-This is a simple attribute. Its value is a string that specifies the
-command used by the VCS to check the validity of a file, either
-when the user explicitly asks for a check, or as a sanity check before
-doing the check-in.
-
-@item VCS_Log_Check
-This is a simple attribute. Its value is a string that specifies
-the command used by the VCS to check the validity of a log file.
-
-@item VCS_Repository_Root
-The VCS repository root path. This is used to create tags or branches
-of the repository. For subversion the value should be the @code{URL}
-as specified to check-out the working copy of the repository.
-
-@item VCS_Patch_Root
-The local root directory to use for building patch file. All patch chunks
-will be relative to this path. The root project directory is used if
-this value is not defined.
-@end table
+@item
+@emph{AI-139-2 Syntactic sugar for iterators (2010-09-29)}
+@cindex AI-139-2 (Ada 2012 feature)
-@node Package Renamings
-@section Package Renamings
+@noindent
+ The new syntax for iterating over arrays and containers is now implemented.
+ Iteration over containers is for now limited to read-only iterators. Only
+ default iterators are supported, with the syntax: @code{@b{for} Elem @b{of} C}.
@noindent
-A package can be defined by a renaming declaration. The new package renames
-a package declared in a different project file, and has the same attributes
-as the package it renames.
-Syntax:
+ RM References: 5.05
+
+@item
+@emph{AI-0134 Profiles must match for full conformance (0000-00-00)}
+@cindex AI-0134 (Ada 2012 feature)
+
+@noindent
+ For full conformance, the profiles of anonymous-access-to-subprogram
+ parameters must match. GNAT has always enforced this rule.
+
+@noindent
+ RM References: 6.03.01 (18)
+
+@item
+@emph{AI-0207 Mode conformance and access constant (0000-00-00)}
+@cindex AI-0207 (Ada 2012 feature)
+
+@noindent
+ This AI confirms that access_to_constant indication must match for mode
+ conformance. This was implemented in GNAT when the qualifier was originally
+ introduced in Ada 2005.
+
+@noindent
+ RM References: 6.03.01 (16/2)
+
+
+@item
+@emph{AI-0046 Null exclusion match for full conformance (2010-07-17)}
+@cindex AI-0046 (Ada 2012 feature)
+
+@noindent
+ For full conformance, in the case of access parameters, the null exclusion
+ must match (either both or neither must have @code{@b{not null}}).
+
+@noindent
+ RM References: 6.03.02 (18)
+
+
+@item
+@emph{AI-0118 The association of parameter associations (0000-00-00)}
+@cindex AI-0118 (Ada 2012 feature)
+
+@noindent
+ This AI clarifies the rules for named associations in subprogram calls and
+ generic instantiations. The rules have been in place since Ada 83.
+
+@noindent
+ RM References: 6.04.01 (2) 12.03 (9)
+
+
+@item
+@emph{AI-0196 Null exclusion tests for out parameters (0000-00-00)}
+@cindex AI-0196 (Ada 2012 feature)
+
+@noindent
+ Null exclusion checks are not made for @code{@b{out}} parameters when
+ evaluating the actual parameters. GNAT has never generated these checks.
+
+@noindent
+ RM References: 6.04.01 (13)
+
+@item
+@emph{AI-0015 Constant return objects (0000-00-00)}
+@cindex AI-0015 (Ada 2012 feature)
+
+@noindent
+ The return object declared in an @i{extended_return_statement} may be
+ declared constant. This was always intended, and GNAT has always allowed it.
+
+@noindent
+ RM References: 6.05 (2.1/2) 3.03 (10/2) 3.03 (21) 6.05 (5/2)
+ 6.05 (5.7/2)
+
+
+@item
+@emph{AI-0032 Extended return for class-wide functions (0000-00-00)}
+@cindex AI-0032 (Ada 2012 feature)
+
+@noindent
+ If a function returns a class-wide type, the object of an extended return
+ statement can be declared with a specific type that is covered by the class-
+ wide type. This has been implemented in GNAT since the introduction of
+ extended returns. Note AI-0103 complements this AI by imposing matching
+ rules for constrained return types.
+
+@noindent
+ RM References: 6.05 (5.2/2) 6.05 (5.3/2) 6.05 (5.6/2) 6.05 (5.8/2)
+ 6.05 (8/2)
+
+@item
+@emph{AI-0103 Static matching for extended return (2010-07-23)}
+@cindex AI-0103 (Ada 2012 feature)
+
+@noindent
+ If the return subtype of a function is an elementary type or a constrained
+ type, the subtype indication in an extended return statement must match
+ statically this return subtype.
+
+@noindent
+ RM References: 6.05 (5.2/2)
+
+
+@item
+@emph{AI-0058 Abnormal completion of an extended return (0000-00-00)}
+@cindex AI-0058 (Ada 2012 feature)
+
+@noindent
+ The RM had some incorrect wording implying wrong treatment of abnormal
+ completion in an extended return. GNAT has always implemented the intended
+ correct semantics as described by this AI.
+
+@noindent
+ RM References: 6.05 (22/2)
+
+
+@item
+@emph{AI-0050 Raising Constraingt_Errpr early for function call (0000-00-00)}
+@cindex AI-0050 (Ada 2012 feature)
+
+@noindent
+ The implementation permissions for raising @code{Constraing_Error} early on a function call when it was clear an exception would be raised were over-permissive and allowed mishandling of discriminants in some cases. GNAT did
+ not take advantage of these incorrect permissions in any case.
+
+@noindent
+ RM References: 6.05 (24/2)
+
+
+@item
+@emph{AI-0125 Nonoverridable operations of an ancestor (2010-09-28)}
+@cindex AI-0125 (Ada 2012 feature)
+
+@noindent
+ In Ada 2012, the declaration of a primitive operation of a type extension
+ or private extension can also override an inherited primitive that is not
+ visible at the point of this declaration.
+
+@noindent
+ RM References: 7.03.01 (6) 8.03 (23) 8.03.01 (5/2) 8.03.01 (6/2)
+
+@item
+@emph{AI-0062 Null exclusions and deferred constants (0000-00-00)}
+@cindex AI-0062 (Ada 2012 feature)
+
+@noindent
+ A full constant may have a null exclusion even if its associated deferred
+ constant does not. GNAT has always allowed this.
+
+@noindent
+ RM References: 7.04 (6/2) 7.04 (7.1/2)
+
+
+@item
+@emph{AI-0178 Incomplete views are limited (0000-00-00)}
+@cindex AI-0178 (Ada 2012 feature)
+
+@noindent
+ This AI clarifies the role of incomplete views and plugs an omission in the
+ RM. GNAT always correctly restricted the use of incomplete views and types.
+
+@noindent
+ RM References: 7.05 (3/2) 7.05 (6/2)
+
+@item
+@emph{AI-0087 Actual for formal nonlimited derived type (2010-07-15)}
+@cindex AI-0087 (Ada 2012 feature)
+
+@noindent
+ The actual for a formal nonlimited derived type cannot be limited. In
+ particular, a formal derived type that extends a limited interface but which
+ is not explicitly limited cannot be instantiated with a limited type.
+
+@noindent
+ RM References: 7.05 (5/2) 12.05.01 (5.1/2)
+
+@item
+@emph{AI-0099 Tag determines whether finalization needed (0000-00-00)}
+@cindex AI-0099 (Ada 2012 feature)
+
+@noindent
+ This AI clarifies that ``needs finalization'' is part of dynamic semantics,
+ and therefore depends on the run-time charateristics of an object (i.e. its
+ tag) and not on its nominal type. As the AI indicates: ``we do not expect
+ this to affect any implementation''.
+
+@noindent
+ RM References: 7.06.01 (6) 7.06.01 (7) 7.06.01 (8) 7.06.01 (9/2)
+
+
+
+@item
+@emph{AI-0064 Redundant finalization rule (0000-00-00)}
+@cindex AI-0064 (Ada 2012 feature)
+
+@noindent
+ This is an editorial change only. The intended behavior is already checked
+ by an existing ACATS test, which GNAT has always executed correctly.
+
+@noindent
+ RM References: 7.06.01 (17.1/1)
+
+@item
+@emph{AI-0026 Missing rules for Unchecked_Union (2010-07-07)}
+@cindex AI-0026 (Ada 2012 feature)
+
+@noindent
+ Record representation clauses concerning Unchecked_Union types cannot mention
+ the discriminant of the type. The type of a component declared in the variant
+ part of an Unchecked_Union cannot be controlled, have controlled components,
+ nor have protected or task parts. If an Unchecked_Union type is declared
+ within the body of a generic unit or its descendants, then the type of a
+ component declared in the variant part cannot be a formal private type or a
+ formal private extension declared within the same generic unit.
+
+@noindent
+ RM References: 7.06 (9.4/2) B.03.03 (9/2) B.03.03 (10/2)
+
+
+@item
+@emph{AI-0205 Extended return declares visible name (0000-00-00)}
+@cindex AI-0205 (Ada 2012 feature)
+
+@noindent
+ This AI corrects a simple omission in the RM. Return objects have always
+ been visible within an extended return statement.
+
+@noindent
+ RM References: 8.03 (17)
+
+
+@item
+@emph{AI-0042 Overriding versus implemented-by (0000-00-00)}
+@cindex AI-0042 (Ada 2012 feature)
+
+@noindent
+ This AI fixes a wording gap in the RM. An operation of a synchronized
+ interface can be implemented by a protected or task entry, but the abstract
+ operation is not being overridden in the usual sense, and it must be stated
+ separately that this implementation is legal. This has always been the case
+ in GNAT.
+
+@noindent
+ RM References: 9.01 (9.2/2) 9.04 (11.1/2)
+
+@item
+@emph{AI-0030 Requeue on synchronized interfaces (2010-07-19)}
+@cindex AI-0030 (Ada 2012 feature)
+
+@noindent
+ Requeue is permitted to a protected, synchronized or task interface primitive
+ providing it is known that the overriding operation is an entry. Otherwise
+ the requeue statement has the same effect as a procedure call. Use of pragma
+ @code{Implemented} provides a way to impose a static requirement on the
+ overriding operation by adhering to one of the implementation kinds: entry,
+ protected procedure or any of the above.
+
+@noindent
+ RM References: 9.05 (9) 9.05.04 (2) 9.05.04 (3) 9.05.04 (5)
+ 9.05.04 (6) 9.05.04 (7) 9.05.04 (12)
+
+
+@item
+@emph{AI-0201 Independence of atomic object components (2010-07-22)}
+@cindex AI-0201 (Ada 2012 feature)
+
+@noindent
+ If an Atomic object has a pragma @code{Pack} or a @code{Component_Size}
+ attribute, then individual components may not be addressable by independent
+ tasks. However, if the representation clause has no effect (is confirming),
+ then independence is not compromised. Furthermore, in GNAT, specification of
+ other appropriately addressable component sizes (e.g. 16 for 8-bit
+ characters) also preserves independence. GNAT now gives very clear warnings
+ both for the declaration of such a type, and for any assignment to its components.
+
+@noindent
+ RM References: 9.10 (1/3) C.06 (22/2) C.06 (23/2)
+
+@item
+@emph{AI-0009 Pragma Independent[_Components] (2010-07-23)}
+@cindex AI-0009 (Ada 2012 feature)
+
+@noindent
+ This AI introduces the new pragmas @code{Independent} and
+ @code{Independent_Components},
+ which control guaranteeing independence of access to objects and components.
+ The AI also requires independence not unaffected by confirming rep clauses.
+
+@noindent
+ RM References: 9.10 (1) 13.01 (15/1) 13.02 (9) 13.03 (13) C.06 (2)
+ C.06 (4) C.06 (6) C.06 (9) C.06 (13) C.06 (14)
+
+
+@item
+@emph{AI-0072 Task signalling using 'Terminated (0000-00-00)}
+@cindex AI-0072 (Ada 2012 feature)
+
+@noindent
+ This AI clarifies that task signalling for reading @code{'Terminated} only
+ occurs if the result is True. GNAT semantics has always been consistent with
+ this notion of task signalling.
+
+@noindent
+ RM References: 9.10 (6.1/1)
+
+@item
+@emph{AI-0108 Limited incomplete view and discriminants (0000-00-00)}
+@cindex AI-0108 (Ada 2012 feature)
+
+@noindent
+ This AI confirms that an incomplete type from a limited view does not have
+ discriminants. This has always been the case in GNAT.
+
+@noindent
+ RM References: 10.01.01 (12.3/2)
+
+@item
+@emph{AI-0129 Limited views and incomplete types (0000-00-00)}
+@cindex AI-0129 (Ada 2012 feature)
+
+@noindent
+ This AI clarifies the description of limited views: a limited view of a
+ package includes only one view of a type that has an incomplete declaration
+ and a full declaration (there is no possible ambiguity in a client package).
+ This AI also fixes an omission: a nested package in the private part has no
+ limited view. GNAT always implemented this correctly.
+
+@noindent
+ RM References: 10.01.01 (12.2/2) 10.01.01 (12.3/2)
+
+
+
+@item
+@emph{AI-0077 Limited withs and scope of declarations (0000-00-00)}
+@cindex AI-0077 (Ada 2012 feature)
+
+@noindent
+ This AI clarifies that a declaration does not include a context clause,
+ and confirms that it is illegal to have a context in which both a limited
+ and a nonlimited view of a package are accessible. Such double visibility
+ was always rejected by GNAT.
+
+@noindent
+ RM References: 10.01.02 (12/2) 10.01.02 (21/2) 10.01.02 (22/2)
+
+@item
+@emph{AI-0122 Private with and children of generics (0000-00-00)}
+@cindex AI-0122 (Ada 2012 feature)
+
+@noindent
+ This AI clarifies the visibility of private children of generic units within
+ instantiations of a parent. GNAT has always handled this correctly.
+
+@noindent
+ RM References: 10.01.02 (12/2)
+
+
+
+@item
+@emph{AI-0040 Limited with clauses on descendant (0000-00-00)}
+@cindex AI-0040 (Ada 2012 feature)
+
+@noindent
+ This AI confirms that a limited with clause in a child unit cannot name
+ an ancestor of the unit. This has always been checked in GNAT.
+
+@noindent
+ RM References: 10.01.02 (20/2)
+
+@item
+@emph{AI-0132 Placement of library unit pragmas (0000-00-00)}
+@cindex AI-0132 (Ada 2012 feature)
+
+@noindent
+ This AI fills a gap in the description of library unit pragmas. The pragma
+ clearly must apply to a library unit, even if it does not carry the name
+ of the enclosing unit. GNAT has always enforced the required check.
+
+@noindent
+ RM References: 10.01.05 (7)
+
+
+@item
+@emph{AI-0034 Categorization of limited views (0000-00-00)}
+@cindex AI-0034 (Ada 2012 feature)
+
+@noindent
+ The RM makes certain limited with clauses illegal because of categorization
+ considerations, when the corresponding normal with would be legal. This is
+ not intended, and GNAT has always implemented the recommended behavior.
+
+@noindent
+ RM References: 10.02.01 (11/1) 10.02.01 (17/2)
+
+
+@item
+@emph{AI-0035 Inconsistencies with Pure units (0000-00-00)}
+@cindex AI-0035 (Ada 2012 feature)
+
+@noindent
+ This AI remedies some inconsistencies in the legality rules for Pure units.
+ Derived access types are legal in a pure unit (on the assumption that the
+ rule for a zero storage pool size has been enforced on the ancestor type).
+ The rules are enforced in generic instances and in subunits. GNAT has always
+ implemented the recommended behavior.
+
+@noindent
+ RM References: 10.02.01 (15.1/2) 10.02.01 (15.4/2) 10.02.01 (15.5/2) 10.02.01 (17/2)
+
+
+@item
+@emph{AI-0219 Pure permissions and limited parameters (2010-05-25)}
+@cindex AI-0219 (Ada 2012 feature)
+
+@noindent
+ This AI refines the rules for the cases with limited parameters which do not
+ allow the implementations to omit ``redundant''. GNAT now properly conforms
+ to the requirements of this binding interpretation.
+
+@noindent
+ RM References: 10.02.01 (18/2)
+
+@item
+@emph{AI-0043 Rules about raising exceptions (0000-00-00)}
+@cindex AI-0043 (Ada 2012 feature)
+
+@noindent
+ This AI covers various omissions in the RM regarding the raising of
+ exceptions. GNAT has always implemented the intended semantics.
+
+@noindent
+ RM References: 11.04.01 (10.1/2) 11 (2)
+
+
+@item
+@emph{AI-0200 Mismatches in formal package declarations (0000-00-00)}
+@cindex AI-0200 (Ada 2012 feature)
+
+@noindent
+ This AI plugs a gap in the RM which appeared to allow some obviously intended
+ illegal instantiations. GNAT has never allowed these instantiations.
+
+@noindent
+ RM References: 12.07 (16)
+
+
+@item
+@emph{AI-0112 Detection of duplicate pragmas (2010-07-24)}
+@cindex AI-0112 (Ada 2012 feature)
+
+@noindent
+ This AI concerns giving names to various representation aspects, but the
+ practical effect is simply to make the use of duplicate
+ @code{Atomic}[@code{_Components}],
+ @code{Volatile}[@code{_Components}] and
+ @code{Independent}[@code{_Components}] pragmas illegal, and GNAT
+ now performs this required check.
+
+@noindent
+ RM References: 13.01 (8)
+
+@item
+@emph{AI-0106 No representation pragmas on generic formals (0000-00-00)}
+@cindex AI-0106 (Ada 2012 feature)
+
+@noindent
+ The RM appeared to allow representation pragmas on generic formal parameters,
+ but this was not intended, and GNAT has never permitted this usage.
+
+@noindent
+ RM References: 13.01 (9.1/1)
+
+
+@item
+@emph{AI-0012 Pack/Component_Size for aliased/atomic (2010-07-15)}
+@cindex AI-0012 (Ada 2012 feature)
+
+@noindent
+ It is now illegal to give an inappropriate component size or a pragma
+ @code{Pack} that attempts to change the component size in the case of atomic
+ or aliased components. Previously GNAT ignored such an attempt with a
+ warning.
+
+@noindent
+ RM References: 13.02 (6.1/2) 13.02 (7) C.06 (10) C.06 (11) C.06 (21)
+
+
+@item
+@emph{AI-0039 Stream attributes cannot be dynamic (0000-00-00)}
+@cindex AI-0039 (Ada 2012 feature)
+
+@noindent
+ The RM permitted the use of dynamic expressions (such as @code{ptr.@b{all})}
+ for stream attributes, but these were never useful and are now illegal. GNAT
+ has always regarded such expressions as illegal.
+
+@noindent
+ RM References: 13.03 (4) 13.03 (6) 13.13.02 (38/2)
+
+
+@item
+@emph{AI-0095 Address of intrinsic subprograms (0000-00-00)}
+@cindex AI-0095 (Ada 2012 feature)
+
+@noindent
+ The prefix of @code{'Address} cannot statically denote a subprogram with
+ convention @code{Intrinsic}. The use of the @code{Address} attribute raises
+ @code{Program_Error} if the prefix denotes a subprogram with convention
+ @code{Intrinsic}.
+
+@noindent
+ RM References: 13.03 (11/1)
+
+
+@item
+@emph{AI-0116 Alignment of class-wide objects (0000-00-00)}
+@cindex AI-0116 (Ada 2012 feature)
+
+@noindent
+ This AI requires that the alignment of a class-wide object be no greater
+ than the alignment of any type in the class. GNAT has always followed this
+ recommendation.
+
+@noindent
+ RM References: 13.03 (29) 13.11 (16)
+
+
+@item
+@emph{AI-0146 Type invariants (2009-09-21)}
+@cindex AI-0146 (Ada 2012 feature)
+
+@noindent
+ Type invariants may be specified for private types using the aspect notation.
+ Aspect @code{Invariant} may be specified for any private type,
+ @code{Invariant'Class} can
+ only be specified for tagged types, and is inherited by any descendent of the
+ tagged types. The invariant is a boolean expression that is tested for being
+ true in the following situations: conversions to the private type, object
+ declarations for the private type that are default initialized, and
+ [@b{in}] @b{out}
+ parameters and returned result on return from any primitive operation for
+ the type that is visible to a client.
+
+@noindent
+ RM References: 13.03.03 (00)
+
+@item
+@emph{AI-0078 Relax Unchecked_Conversion alignment rules (0000-00-00)}
+@cindex AI-0078 (Ada 2012 feature)
+
+@noindent
+ In Ada 2012, compilers are required to support unchecked conversion where the
+ target alignment is a multiple of the source alignment. GNAT always supported
+ this case (and indeed all cases of differing alignments, doing copies where
+ required if the alignment was reduced).
+
+@noindent
+ RM References: 13.09 (7)
+
+
+@item
+@emph{AI-0195 Invalid value handling is implementation defined (2010-07-03)}
+@cindex AI-0195 (Ada 2012 feature)
+
+@noindent
+ The handling of invalid values is now designated to be implementation
+ defined. This is a documentation change only, requiring Annex M in the GNAT
+ Reference Manual to document this handling.
+ In GNAT, checks for invalid values are made
+ only when necessary to avoid erroneous behavior. Operations like assignments
+ which cannot cause erroneous behavior ignore the possibility of invalid
+ values and do not do a check. The date given above applies only to the
+ documentation change, this behavior has always been implemented by GNAT.
+
+@noindent
+ RM References: 13.09.01 (10)
+
+@item
+@emph{AI-0193 Alignment of allocators (2010-09-16)}
+@cindex AI-0193 (Ada 2012 feature)
+
+@noindent
+ This AI introduces a new attribute @code{Max_Alignment_For_Allocation},
+ analogous to @code{Max_Size_In_Storage_Elements}, but for alignment instead
+ of size.
+
+@noindent
+ RM References: 13.11 (16) 13.11 (21) 13.11.01 (0) 13.11.01 (1)
+ 13.11.01 (2) 13.11.01 (3)
+
+
+@item
+@emph{AI-0177 Parameterized expressions (2010-07-10)}
+@cindex AI-0177 (Ada 2012 feature)
+
+@noindent
+ The new Ada 2012 notion of parameterized expressions is implemented. The form
+ is:
@smallexample
-package_renaming ::==
- @b{package} package_identifier @b{renames}
- <project_>simple_name.package_identifier ;
+ @i{function specification} @b{is} (@i{expression})
@end smallexample
@noindent
-The package_identifier of the renamed package must be the same as the
-package_identifier. The project whose name is the prefix of the renamed
-package must contain a package declaration with this name. This project
-must appear in the context_clause of the enclosing project declaration,
-or be the parent project of the enclosing child project.
+ This is exactly equivalent to the
+ corresponding function body that returns the expression, but it can appear
+ in a package spec. Note that the expression must be parenthesized.
-@node Projects
-@section Projects
+@noindent
+ RM References: 13.11.01 (3/2)
+
+@item
+@emph{AI-0033 Attach/Interrupt_Handler in generic (2010-07-24)}
+@cindex AI-0033 (Ada 2012 feature)
@noindent
-A project file specifies a set of rules for constructing a software system.
-A project file can be self-contained, or depend on other project files.
-Dependencies are expressed through a context clause that names other projects.
+ Neither of these two pragmas may appear within a generic template, because
+ the generic might be instantiated at other than the library level.
-Syntax:
+@noindent
+ RM References: 13.11.02 (16) C.03.01 (7/2) C.03.01 (8/2)
-@smallexample
-project ::=
- context_clause project_declaration
-project_declaration ::=
- simple_project_declaration | project_extension
+@item
+@emph{AI-0161 Restriction No_Default_Stream_Attributes (2010-09-11)}
+@cindex AI-0161 (Ada 2012 feature)
-simple_project_declaration ::=
- @b{project} <project_>simple_name @b{is}
- @{declarative_item@}
- @b{end} <project_>simple_name;
+@noindent
+ A new restriction @code{No_Default_Stream_Attributes} prevents the use of any
+ of the default stream attributes for elementary types. If this restriction is
+ in force, then it is necessary to provide explicit subprograms for any
+ stream attributes used.
-context_clause ::=
- @{with_clause@}
+@noindent
+ RM References: 13.12.01 (4/2) 13.13.02 (40/2) 13.13.02 (52/2)
-with_clause ::=
- [@b{limited}] @b{with} path_name @{ , path_name @} ;
+@item
+@emph{AI-0194 Value of Stream_Size attribute (0000-00-00)}
+@cindex AI-0194 (Ada 2012 feature)
-path_name ::=
- string_literal
-@end smallexample
+@noindent
+ The @code{Stream_Size} attribute returns the default number of bits in the
+ stream representation of the given type.
+ This value is not affected by the presence
+ of stream subprogram attributes for the type. GNAT has always implemented
+ this interpretation.
@noindent
-A path name denotes a project file. A path name can be absolute or relative.
-An absolute path name includes a sequence of directories, in the syntax of
-the host operating system, that identifies uniquely the project file in the
-file system. A relative path name identifies the project file, relative
-to the directory that contains the current project, or relative to a
-directory listed in the environment variable ADA_PROJECT_PATH.
-Path names are case sensitive if file names in the host operating system
-are case sensitive.
+ RM References: 13.13.02 (1.2/2)
-The syntax of the environment variable ADA_PROJECT_PATH is a list of
-directory names separated by colons (semicolons on Windows).
+@item
+@emph{AI-0109 Redundant check in S'Class'Input (0000-00-00)}
+@cindex AI-0109 (Ada 2012 feature)
-A given project name can appear only once in a context_clause.
+@noindent
+ This AI is an editorial change only. It removes the need for a tag check
+ that can never fail.
-It is illegal for a project imported by a context clause to refer, directly
-or indirectly, to the project in which this context clause appears (the
-dependency graph cannot contain cycles), except when one of the with_clause
-in the cycle is a @code{limited with}.
+@noindent
+ RM References: 13.13.02 (34/2)
-@node Project Extensions
-@section Project Extensions
+@item
+@emph{AI-0007 Stream read and private scalar types (0000-00-00)}
+@cindex AI-0007 (Ada 2012 feature)
@noindent
-A project extension introduces a new project, which inherits the declarations
-of another project.
-Syntax:
-@smallexample
+ The RM as written appeared to limit the possibilities of declaring read
+ attribute procedures for private scalar types. This limitation was not
+ intended, and has never been enforced by GNAT.
-project_extension ::=
- @b{project} <project_>simple_name @b{extends} path_name @b{is}
- @{declarative_item@}
- @b{end} <project_>simple_name;
-@end smallexample
+@noindent
+ RM References: 13.13.02 (50/2) 13.13.02 (51/2)
+
+
+@item
+@emph{AI-0065 Remote access types and external streaming (0000-00-00)}
+@cindex AI-0065 (Ada 2012 feature)
+
+@noindent
+ This AI clarifies the fact that all remote access types support external
+ streaming. This fixes an obvious oversight in the definition of the
+ language, and GNAT always implemented the intended correct rules.
+
+@noindent
+ RM References: 13.13.02 (52/2)
+
+@item
+@emph{AI-0019 Freezing of primitives for tagged types (0000-00-00)}
+@cindex AI-0019 (Ada 2012 feature)
+
+@noindent
+ The RM suggests that primitive subprograms of a specific tagged type are
+ frozen when the tagged type is frozen. This would be an incompatible change
+ and is not intended. GNAT has never attempted this kind of freezing and its
+ behavior is consistent with the recommendation of this AI.
+
+@noindent
+ RM References: 13.14 (2) 13.14 (3/1) 13.14 (8.1/1) 13.14 (10) 13.14 (14) 13.14 (15.1/2)
+
+@item
+@emph{AI-0017 Freezing and incomplete types (0000-00-00)}
+@cindex AI-0017 (Ada 2012 feature)
+
+@noindent
+ So-called ``Taft-amendment types'' (i.e., types that are completed in package
+ bodies) are not frozen by the occurrence of bodies in the
+ enclosing declarative part. GNAT always implemented this properly.
@noindent
-The project extension declares a child project. The child project inherits
-all the declarations and all the files of the parent project, These inherited
-declaration can be overridden in the child project, by means of suitable
-declarations.
+ RM References: 13.14 (3/1)
-@node Project File Elaboration
-@section Project File Elaboration
+
+@item
+@emph{AI-0060 Extended definition of remote access types (0000-00-00)}
+@cindex AI-0060 (Ada 2012 feature)
+
+@noindent
+ This AI extends the definition of remote access types to include access
+ to limited, synchronized, protected or task class-wide interface types.
+ GNAT already implemented this extension.
+
+@noindent
+ RM References: A (4) E.02.02 (9/1) E.02.02 (9.2/1) E.02.02 (14/2) E.02.02 (18)
+
+@item
+@emph{AI-0114 Classification of letters (0000-00-00)}
+@cindex AI-0114 (Ada 2012 feature)
+
+@noindent
+ The code points 170 (@code{FEMININE ORDINAL INDICATOR}),
+ 181 (@code{MICRO SIGN}), and
+ 186 (@code{MASCULINE ORDINAL INDICATOR}) are technically considered
+ lower case letters by Unicode.
+ However, they are not allowed in identifiers, and they
+ return @code{False} to @code{Ada.Characters.Handling.Is_Letter/Is_Lower}.
+ This behavior is consistent with that defined in Ada 95.
+
+@noindent
+ RM References: A.03.02 (59) A.04.06 (7)
+
+
+@item
+@emph{AI-0185 Ada.Wide_[Wide_]Characters.Handling (2010-07-06)}
+@cindex AI-0185 (Ada 2012 feature)
+
+@noindent
+ Two new packages @code{Ada.Wide_[Wide_]Characters.Handling} provide
+ classification functions for @code{Wide_Character} and
+ @code{Wide_Wide_Character}, as well as providing
+ case folding routines for @code{Wide_[Wide_]Character} and
+ @code{Wide_[Wide_]String}.
+
+@noindent
+ RM References: A.03.05 (0) A.03.06 (0)
+
+
+@item
+@emph{AI-0031 Add From parameter to Find_Token (2010-07-25)}
+@cindex AI-0031 (Ada 2012 feature)
+
+@noindent
+ A new version of @code{Find_Token} is added to all relevant string packages,
+ with an extra parameter @code{From}. Instead of starting at the first
+ character of the string, the search for a matching Token starts at the
+ character indexed by the value of @code{From}.
+ These procedures are available in all versions of Ada
+ but if used in versions earlier than Ada 2012 they will generate a warning
+ that an Ada 2012 subprogram is being used.
+
+@noindent
+ RM References: A.04.03 (16) A.04.03 (67) A.04.03 (68/1) A.04.04 (51)
+ A.04.05 (46)
+
+
+@item
+@emph{AI-0056 Index on null string returns zero (0000-00-00)}
+@cindex AI-0056 (Ada 2012 feature)
+
+@noindent
+ The wording in the Ada 2005 RM implied an incompatible handling of the
+ @code{Index} functions, resulting in raising an exception instead of
+ returning zero in some situations.
+ This was not intended and has been corrected.
+ GNAT always returned zero, and is thus consistent with this AI.
+
+@noindent
+ RM References: A.04.03 (56.2/2) A.04.03 (58.5/2)
+
+
+@item
+@emph{AI-0137 String encoding package (2010-03-25)}
+@cindex AI-0137 (Ada 2012 feature)
+
+@noindent
+ The packages @code{Ada.Strings.UTF_Encoding}, together with its child
+ packages, @code{Conversions}, @code{Strings}, @code{Wide_Strings},
+ and @code{Wide_Wide_Strings} have been
+ implemented. These packages (whose documentation can be found in the spec
+ files @file{a-stuten.ads}, @file{a-suenco.ads}, @file{a-suenst.ads},
+ @file{a-suewst.ads}, @file{a-suezst.ads}) allow encoding and decoding of
+ @code{String}, @code{Wide_String}, and @code{Wide_Wide_String}
+ values using UTF coding schemes (including UTF-8, UTF-16LE, UTF-16BE, and
+ UTF-16), as well as conversions between the different UTF encodings. With
+ the exception of @code{Wide_Wide_Strings}, these packages are available in
+ Ada 95 and Ada 2005 mode as well as Ada 2012 mode.
+ The @code{Wide_Wide_Strings package}
+ is available in Ada 2005 mode as well as Ada 2012 mode (but not in Ada 95
+ mode since it uses @code{Wide_Wide_Character}).
+
+@noindent
+ RM References: A.04.11
+
+@item
+@emph{AI-0038 Minor errors in Text_IO (0000-00-00)}
+@cindex AI-0038 (Ada 2012 feature)
+
+@noindent
+ These are minor errors in the description on three points. The intent on
+ all these points has always been clear, and GNAT has always implemented the
+ correct intended semantics.
+
+@noindent
+ RM References: A.10.05 (37) A.10.07 (8/1) A.10.07 (10) A.10.07 (12) A.10.08 (10) A.10.08 (24)
+
+@item
+@emph{AI-0044 Restrictions on container instantiations (0000-00-00)}
+@cindex AI-0044 (Ada 2012 feature)
+
+@noindent
+ This AI places restrictions on allowed instantiations of generic containers.
+ These restrictions are not checked by the compiler, so there is nothing to
+ change in the implementation. This affects only the RM documentation.
@noindent
-A project file is processed as part of the invocation of a gnat tool that
-uses the project option. Elaboration of the process file consists in the
-sequential elaboration of all its declarations. The computed values of
-attributes and variables in the project are then used to establish the
-environment in which the gnat tool will execute.
+ RM References: A.18 (4/2) A.18.02 (231/2) A.18.03 (145/2) A.18.06 (56/2) A.18.08 (66/2) A.18.09 (79/2) A.18.26 (5/2) A.18.26 (9/2)
+
+@item
+@emph{AI-0127 Adding Locale Capabilities (2010-09-29)}
+@cindex AI-0127 (Ada 2012 feature)
+
+@noindent
+ This package provides an interface for identifying the current locale.
+
+@noindent
+ RM References: A.19 A.19.01 A.19.02 A.19.03 A.19.05 A.19.06
+ A.19.07 A.19.08 A.19.09 A.19.10 A.19.11 A.19.12 A.19.13
+
+
+
+@item
+@emph{AI-0002 Export C with unconstrained arrays (0000-00-00)}
+@cindex AI-0002 (Ada 2012 feature)
+
+@noindent
+ The compiler is not required to support exporting an Ada subprogram with
+ convention C if there are parameters or a return type of an unconstrained
+ array type (such as @code{String}). GNAT allows such declarations but
+ generates warnings. It is possible, but complicated, to write the
+ corresponding C code and certainly such code would be specific to GNAT and
+ non-portable.
+
+@noindent
+ RM References: B.01 (17) B.03 (62) B.03 (71.1/2)
+
+
+@item
+@emph{AI-0216 No_Task_Hierarchy forbids local tasks (0000-00-00)}
+@cindex AI-0216 (Ada 2012 feature)
+
+@noindent
+ It is clearly the intention that @code{No_Task_Hierarchy} is intended to
+ forbid tasks declared locally within subprograms, or functions returning task
+ objects, and that is the implementation that GNAT has always provided.
+ However the language in the RM was not sufficiently clear on this point.
+ Thus this is a docmentation change in the RM only.
+
+@noindent
+ RM References: D.07 (3/3)
+
+@item
+@emph{AI-0211 No_Relative_Delays forbids Set_Handler use (2010-07-09)}
+@cindex AI-0211 (Ada 2012 feature)
+
+@noindent
+ The restriction @code{No_Relative_Delays} forbids any calls to the subprogram
+ @code{Ada.Real_Time.Timing_Events.Set_Handler}.
+
+@noindent
+ RM References: D.07 (5) D.07 (10/2) D.07 (10.4/2) D.07 (10.7/2)
+
+@item
+@emph{AI-0190 pragma Default_Storage_Pool (2010-09-15)}
+@cindex AI-0190 (Ada 2012 feature)
+
+@noindent
+ This AI introduces a new pragma @code{Default_Storage_Pool}, which can be
+ used to control storage pools globally.
+ In particular, you can force every access
+ type that is used for allocation (@b{new}) to have an explicit storage pool,
+ or you can declare a pool globally to be used for all access types that lack
+ an explicit one.
+
+@noindent
+ RM References: D.07 (8)
+
+@item
+@emph{AI-0189 No_Allocators_After_Elaboration (2010-01-23)}
+@cindex AI-0189 (Ada 2012 feature)
+
+@noindent
+ This AI introduces a new restriction @code{No_Allocators_After_Elaboration},
+ which says that no dynamic allocation will occur once elaboration is
+ completed.
+ In general this requires a run-time check, which is not required, and which
+ GNAT does not attempt. But the static cases of allocators in a task body or
+ in the body of the main program are detected and flagged at compile or bind
+ time.
+
+@noindent
+ RM References: D.07 (19.1/2) H.04 (23.3/2)
+
+@item
+@emph{AI-0171 Pragma CPU and Ravenscar Profile (2010-09-24)}
+@cindex AI-0171 (Ada 2012 feature)
+
+@noindent
+ A new package @code{System.Multiprocessors} is added, together with the
+ definition of pragma @code{CPU} for controlling task affinity. A new no
+ dependence restriction, on @code{System.Multiprocessors.Dispatching_Domains},
+ is added to the Ravenscar profile.
+
+@noindent
+ RM References: D.13.01 (4/2) D.16
+
+
+@item
+@emph{AI-0210 Correct Timing_Events metric (0000-00-00)}
+@cindex AI-0210 (Ada 2012 feature)
+
+@noindent
+ This is a documentation only issue regarding wording of metric requirements,
+ that does not affect the implementation of the compiler.
+
+@noindent
+ RM References: D.15 (24/2)
+
+
+@item
+@emph{AI-0206 Remote types packages and preelaborate (2010-07-24)}
+@cindex AI-0206 (Ada 2012 feature)
+
+@noindent
+ Remote types packages are now allowed to depend on preelaborated packages.
+ This was formerly considered illegal.
+
+@noindent
+ RM References: E.02.02 (6)
+
+
+
+@item
+@emph{AI-0152 Restriction No_Anonymous_Allocators (2010-09-08)}
+@cindex AI-0152 (Ada 2012 feature)
+
+@noindent
+ Restriction @code{No_Anonymous_Allocators} prevents the use of allocators
+ where the type of the returned value is an anonymous access type.
+
+@noindent
+ RM References: H.04 (8/1)
+@end itemize
+
@node Obsolescent Features
@chapter Obsolescent Features
OSDN Git Service
