@c o
@c G N A T _ RM o
@c o
-@c Copyright (C) 1995-2005 Free Software Foundation o
+@c Copyright (C) 1995-2007, Free Software Foundation o
@c o
@c o
@c GNAT is maintained by Ada Core Technologies Inc (http://www.gnat.com). o
@setfilename gnat_rm.info
-@set FSFEDITION
+@set EDITION GNAT
+@set DEFAULTLANGUAGEVERSION Ada 2005
+@set NONDEFAULTLANGUAGEVERSION Ada 95
@settitle GNAT Reference Manual
@end direntry
@copying
-Copyright @copyright{} 1995-2004, Free Software Foundation
+Copyright @copyright{} 1995-2007, Free Software Foundation
Permission is granted to copy, distribute and/or modify this document
under the terms of the GNU Free Documentation License, Version 1.2
@end copying
@titlepage
-
@title GNAT Reference Manual
-@subtitle GNAT, The GNU Ada 95 Compiler
-@subtitle GCC version @value{version-GCC}
-@author Ada Core Technologies, Inc.
-
+@subtitle GNAT, The GNU Ada Compiler
+@versionsubtitle
+@author AdaCore
@page
@vskip 0pt plus 1filll
GNAT Reference Manual
@noindent
-GNAT, The GNU Ada 95 Compiler@*
+GNAT, The GNU Ada Compiler@*
GCC version @value{version-GCC}@*
@noindent
-Ada Core Technologies, Inc.
+AdaCore
@menu
* About This Guide::
* Pragma Ada_83::
* Pragma Ada_95::
* Pragma Ada_05::
+* Pragma Ada_2005::
* Pragma Annotate::
* Pragma Assert::
* Pragma Ast_Entry::
* Pragma C_Pass_By_Copy::
+* Pragma Check_Name::
* Pragma Comment::
* Pragma Common_Object::
+* Pragma Compile_Time_Error::
* Pragma Compile_Time_Warning::
+* Pragma Complete_Representation::
* Pragma Complex_Representation::
* Pragma Component_Alignment::
* Pragma Convention_Identifier::
* Pragma CPP_Virtual::
* Pragma CPP_Vtable::
* Pragma Debug::
+* Pragma Debug_Policy::
* Pragma Detect_Blocking::
* Pragma Elaboration_Checks::
* Pragma Eliminate::
* Pragma Finalize_Storage_Only::
* Pragma Float_Representation::
* Pragma Ident::
+* Pragma Implicit_Packing::
* Pragma Import_Exception::
* Pragma Import_Function::
* Pragma Import_Object::
* Pragma License::
* Pragma Link_With::
* Pragma Linker_Alias::
+* Pragma Linker_Constructor::
+* Pragma Linker_Destructor::
* Pragma Linker_Section::
* Pragma Long_Float::
* Pragma Machine_Attribute::
+* Pragma Main::
* Pragma Main_Storage::
+* Pragma No_Body::
* Pragma No_Return::
+* Pragma No_Strict_Aliasing ::
* Pragma Normalize_Scalars::
* Pragma Obsolescent::
* Pragma Passive::
+* Pragma Persistent_BSS::
* Pragma Polling::
* Pragma Profile (Ravenscar)::
* Pragma Profile (Restricted)::
-* Pragma Propagate_Exceptions::
* Pragma Psect_Object::
* Pragma Pure_Function::
* Pragma Restriction_Warnings::
* Pragma Stream_Convert::
* Pragma Style_Checks::
* Pragma Subtitle::
+* Pragma Suppress::
* Pragma Suppress_All::
* Pragma Suppress_Exception_Locations::
* Pragma Suppress_Initialization::
* Pragma Task_Info::
* Pragma Task_Name::
* Pragma Task_Storage::
-* Pragma Thread_Body::
* Pragma Time_Slice::
* Pragma Title::
* Pragma Unchecked_Union::
* Pragma Unimplemented_Unit::
+* Pragma Universal_Aliasing ::
* Pragma Universal_Data::
* Pragma Unreferenced::
+* Pragma Unreferenced_Objects::
* Pragma Unreserve_All_Interrupts::
* Pragma Unsuppress::
* Pragma Use_VADS_Size::
* Pragma Volatile::
* Pragma Warnings::
* Pragma Weak_External::
+* Pragma Wide_Character_Encoding::
Implementation Defined Attributes
* Elab_Body::
* Elab_Spec::
* Emax::
+* Enabled::
* Enum_Rep::
* Epsilon::
* Fixed_Value::
* Safe_Large::
* Small::
* Storage_Unit::
+* Stub_Type::
* Target_Name::
* Tick::
* To_Address::
* Wide_Wide_Text_IO::
* Stream_IO::
* Shared Files::
+* Filenames encoding::
* Open Modes::
* Operations on C Streams::
* Interfacing to C Streams::
* Ada.Text_IO.C_Streams (a-tiocst.ads)::
* Ada.Wide_Text_IO.C_Streams (a-wtcstr.ads)::
* Ada.Wide_Wide_Text_IO.C_Streams (a-ztcstr.ads)::
+* GNAT.Altivec (g-altive.ads)::
+* GNAT.Altivec.Conversions (g-altcon.ads)::
+* GNAT.Altivec.Vector_Operations (g-alveop.ads)::
+* GNAT.Altivec.Vector_Types (g-alvety.ads)::
+* GNAT.Altivec.Vector_Views (g-alvevi.ads)::
* GNAT.Array_Split (g-arrspl.ads)::
* GNAT.AWK (g-awk.ads)::
* GNAT.Bounded_Buffers (g-boubuf.ads)::
* GNAT.Bubble_Sort (g-bubsor.ads)::
* GNAT.Bubble_Sort_A (g-busora.ads)::
* GNAT.Bubble_Sort_G (g-busorg.ads)::
+* GNAT.Byte_Swapping (g-bytswa.ads)::
* GNAT.Calendar (g-calend.ads)::
* GNAT.Calendar.Time_IO (g-catiio.ads)::
* GNAT.Case_Util (g-casuti.ads)::
* GNAT.Regpat (g-regpat.ads)::
* GNAT.Secondary_Stack_Info (g-sestin.ads)::
* GNAT.Semaphores (g-semaph.ads)::
+* GNAT.SHA1 (g-sha1.ads)::
* GNAT.Signals (g-signal.ads)::
* GNAT.Sockets (g-socket.ads)::
* GNAT.Source_Info (g-souinf.ads)::
* GNAT Implementation of Shared Passive Packages::
* Code Generation for Array Aggregates::
* The Size of Discriminated Records with Default Discriminants::
+* Strict Conformance to the Ada Reference Manual::
Project File Reference
@node About This Guide
@unnumbered About This Guide
-@ifclear PROEDITION
@noindent
This manual contains useful information in writing programs using the
-GNAT compiler. It includes information on implementation dependent
-characteristics of GNAT, including all the information required by Annex
-M of the standard.
-@end ifclear
-
-@ifset PROEDITION
-@noindent
-This manual contains useful information in writing programs using the
-GNAT Pro compiler. It includes information on implementation dependent
-characteristics of GNAT Pro, including all the information required by Annex
-M of the standard.
-@end ifset
-
-Ada 95 is designed to be highly portable.
+@value{EDITION} compiler. It includes information on implementation dependent
+characteristics of @value{EDITION}, including all the information required by
+Annex M of the Ada language standard.
+
+@value{EDITION} implements Ada 95 and Ada 2005, and it may also be invoked in
+Ada 83 compatibility mode.
+By default, @value{EDITION} assumes @value{DEFAULTLANGUAGEVERSION},
+but you can override with a compiler switch
+to explicitly specify the language version.
+(Please refer to the section ``Compiling Different Versions of Ada'', in
+@cite{@value{EDITION} User's Guide}, for details on these switches.)
+Throughout this manual, references to ``Ada'' without a year suffix
+apply to both the Ada 95 and Ada 2005 versions of the language.
+
+Ada is designed to be highly portable.
In general, a program will have the same effect even when compiled by
different compilers on different platforms.
-However, since Ada 95 is designed to be used in a
+However, since Ada is designed to be used in a
wide variety of applications, it also contains a number of system
dependent features to be used in interfacing to the external world.
@cindex Implementation-dependent features
@ref{Obsolescent Features} documents implementation dependent features,
including pragmas and attributes, which are considered obsolescent, since
there are other preferred ways of achieving the same results. These
-obsolescent forms are retained for backwards compatibilty.
+obsolescent forms are retained for backwards compatibility.
@end itemize
-@cindex Ada 95 ISO/ANSI Standard
+@cindex Ada 95 Language Reference Manual
+@cindex Ada 2005 Language Reference Manual
@noindent
-This reference manual assumes that you are familiar with Ada 95
-language, as described in the International Standard
-ANSI/ISO/IEC-8652:1995, Jan 1995.
+This reference manual assumes a basic familiarity with the Ada 95 language, as
+described in the International Standard ANSI/ISO/IEC-8652:1995,
+January 1995.
+It does not require knowledge of the new features introduced by Ada 2005,
+(officially known as ISO/IEC 8652:1995 with Technical Corrigendum 1
+and Amendment 1).
+Both reference manuals are included in the GNAT documentation
+package.
@node Conventions
@unnumberedsec Conventions
@item
@cite{Ada 95 Annotated Reference Manual}, which is an annotated version
-of the standard reference manual cited above. The annotations describe
+of the Ada 95 standard. The annotations describe
detailed aspects of the design decision, and in particular contain useful
sections on Ada 83 compatibility.
@item
+@cite{Ada 2005 Reference Manual}, which contains all reference
+material for the Ada 2005 programming language.
+
+@item
+@cite{Ada 2005 Annotated Reference Manual}, which is an annotated version
+of the Ada 2005 standard. The annotations describe
+detailed aspects of the design decision, and in particular contain useful
+sections on Ada 83 and Ada 95 compatibility.
+
+@item
@cite{DEC Ada, Technical Overview and Comparison on DIGITAL Platforms},
which contains specific information on compatibility between GNAT and
DEC Ada 83 systems.
@chapter Implementation Defined Pragmas
@noindent
-Ada 95 defines a set of pragmas that can be used to supply additional
+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 95 Reference
+implemented in GNAT and work as described in the Ada Reference
Manual.
-In addition, Ada 95 allows implementations to define additional pragmas
+In addition, Ada allows implementations to define additional pragmas
whose meaning is defined by the implementation. GNAT provides a number
of these implementation-dependent pragmas which can be used to extend
and enhance the functionality of the compiler. This section of the GNAT
* Pragma Ada_83::
* Pragma Ada_95::
* Pragma Ada_05::
+* Pragma Ada_2005::
* Pragma Annotate::
* Pragma Assert::
* Pragma Ast_Entry::
* Pragma C_Pass_By_Copy::
+* Pragma Check_Name::
* Pragma Comment::
* Pragma Common_Object::
+* Pragma Compile_Time_Error::
* Pragma Compile_Time_Warning::
+* Pragma Complete_Representation::
* Pragma Complex_Representation::
* Pragma Component_Alignment::
* Pragma Convention_Identifier::
* Pragma CPP_Virtual::
* Pragma CPP_Vtable::
* Pragma Debug::
+* Pragma Debug_Policy::
* Pragma Detect_Blocking::
* Pragma Elaboration_Checks::
* Pragma Eliminate::
* Pragma Finalize_Storage_Only::
* Pragma Float_Representation::
* Pragma Ident::
+* Pragma Implicit_Packing::
* Pragma Import_Exception::
* Pragma Import_Function::
* Pragma Import_Object::
* Pragma License::
* Pragma Link_With::
* Pragma Linker_Alias::
+* Pragma Linker_Constructor::
+* Pragma Linker_Destructor::
* Pragma Linker_Section::
* Pragma Long_Float::
* Pragma Machine_Attribute::
+* Pragma Main::
* Pragma Main_Storage::
+* Pragma No_Body::
* Pragma No_Return::
+* Pragma No_Strict_Aliasing::
* Pragma Normalize_Scalars::
* Pragma Obsolescent::
* Pragma Passive::
+* Pragma Persistent_BSS::
* Pragma Polling::
* Pragma Profile (Ravenscar)::
* Pragma Profile (Restricted)::
-* Pragma Propagate_Exceptions::
* Pragma Psect_Object::
* Pragma Pure_Function::
* Pragma Restriction_Warnings::
* Pragma Stream_Convert::
* Pragma Style_Checks::
* Pragma Subtitle::
+* Pragma Suppress::
* Pragma Suppress_All::
* Pragma Suppress_Exception_Locations::
* Pragma Suppress_Initialization::
* Pragma Task_Info::
* Pragma Task_Name::
* Pragma Task_Storage::
-* Pragma Thread_Body::
* Pragma Time_Slice::
* Pragma Title::
* Pragma Unchecked_Union::
* Pragma Unimplemented_Unit::
+* Pragma Universal_Aliasing ::
* Pragma Universal_Data::
* Pragma Unreferenced::
+* Pragma Unreferenced_Objects::
* Pragma Unreserve_All_Interrupts::
* Pragma Unsuppress::
* Pragma Use_VADS_Size::
* Pragma Volatile::
* Pragma Warnings::
* Pragma Weak_External::
+* Pragma Wide_Character_Encoding::
@end menu
@node Pragma Abort_Defer
which it applies, regardless of the mode set by the command line
switches. In Ada 83 mode, GNAT attempts to be as compatible with
the syntax and semantics of Ada 83, as defined in the original Ada
-83 Reference Manual as possible. In particular, the new Ada 95
-keywords are not recognized, optional package bodies are allowed,
+83 Reference Manual as possible. In particular, the keywords added by Ada 95
+(and Ada 2005) are not recognized, optional package bodies are allowed,
and generics may name types with unknown discriminants without using
the @code{(<>)} notation. In addition, some but not all of the additional
restrictions of Ada 83 are enforced.
Ada 83 mode is intended for two purposes. Firstly, it allows existing
-legacy Ada 83 code to be compiled and adapted to GNAT with less effort.
+Ada 83 code to be compiled and adapted to GNAT with less effort.
Secondly, it aids in keeping code backwards compatible with Ada 83.
However, there is no guarantee that code that is processed correctly
by GNAT in Ada 83 mode will in fact compile and execute with an Ada
itself uses Ada 2005 features, but which is intended to be usable from
either Ada 83 or Ada 95 programs.
+@node Pragma Ada_2005
+@unnumberedsec Pragma Ada_2005
+@findex Ada_2005
+@noindent
+Syntax:
+@smallexample @c ada
+pragma Ada_2005;
+@end smallexample
+
+@noindent
+This configuration pragma is a synonym for pragma Ada_05 and has the
+same syntax and effect.
+
@node Pragma Annotate
@unnumberedsec Pragma Annotate
@findex Annotate
@code{Import} and @code{Export} pragmas, which allow specification of
passing mechanisms on a parameter by parameter basis.
+@node Pragma Check_Name
+@unnumberedsec Pragma Check_Name
+@cindex Defining check names
+@cindex Check names, defining
+@findex Check_Name
+@noindent
+Syntax:
+@smallexample @c ada
+pragma Check_Name (check_name_IDENTIFIER);
+@end smallexample
+
+@noindent
+This is a configuration pragma which defines a new implementation
+defined check name (unless IDENTIFIER matches one of the predefined
+check names, in which case the pragma has no effect). Check names
+are global to a partition, so if two more more configuration pragmas
+are present in a partition mentioning the same name, only one new
+check name is introduced.
+
+An implementation defined check name introduced with this pragma may
+be used in only three contexts: @code{pragma Suppress},
+@code{pragma Unsuppress},
+and as the prefix of a @code{Check_Name'Enabled} attribute reference. For
+any of these three cases, the check name must be visible. A check
+name is visible if it is in the configuration pragmas applying to
+the current unit, or if it appears at the start of any unit that
+is part of the dependency set of the current unit (e.g. units that
+are mentioned in @code{with} clauses.
+
+Normally the default mechanism for passing C convention records to C
@node Pragma Comment
@unnumberedsec Pragma Comment
@findex Comment
@smallexample @c ada
pragma Common_Object (
- [Internal =>] LOCAL_NAME,
+ [Internal =>] local_NAME,
[, [External =>] EXTERNAL_SYMBOL]
[, [Size =>] EXTERNAL_SYMBOL] );
This pragma enables the shared use of variables stored in overlaid
linker areas corresponding to the use of @code{COMMON}
in Fortran. The single
-object @var{local_name} is assigned to the area designated by
+object @var{local_NAME} is assigned to the area designated by
the @var{External} argument.
You may define a record to correspond to a series
of fields. The @var{size} argument
indicating that the necessary attribute for implementation of this
pragma is not available.
+@node Pragma Compile_Time_Error
+@unnumberedsec Pragma Compile_Time_Error
+@findex Compile_Time_Error
+@noindent
+Syntax:
+
+@smallexample @c ada
+pragma Compile_Time_Error
+ (boolean_EXPRESSION, static_string_EXPRESSION);
+@end smallexample
+
+@noindent
+This pragma can be used to generate additional compile time
+error messages. It
+is particularly useful in generics, where errors can be issued for
+specific problematic instantiations. The first parameter is a boolean
+expression. The pragma is effective only if the value of this expression
+is known at compile time, and has the value True. The set of expressions
+whose values are known at compile time includes all static boolean
+expressions, and also other values which the compiler can determine
+at compile time (e.g. the size of a record type set by an explicit
+size representation clause, or the value of a variable which was
+initialized to a constant and is known not to have been modified).
+If these conditions are met, an error message is generated using
+the value given as the second argument. This string value may contain
+embedded ASCII.LF characters to break the message into multiple lines.
+
@node Pragma Compile_Time_Warning
@unnumberedsec Pragma Compile_Time_Warning
@findex Compile_Time_Warning
the value given as the second argument. This string value may contain
embedded ASCII.LF characters to break the message into multiple lines.
+@node Pragma Complete_Representation
+@unnumberedsec Pragma Complete_Representation
+@findex Complete_Representation
+@noindent
+Syntax:
+
+@smallexample @c ada
+pragma Complete_Representation;
+@end smallexample
+
+@noindent
+This pragma must appear immediately within a record representation
+clause. Typical placements are before the first component clause
+or after the last component clause. The effect is to give an error
+message if any component is missing a component clause. This pragma
+may be used to ensure that a record representation clause is
+complete, and that this invariant is maintained if fields are
+added to the record in the future.
+
@node Pragma Complex_Representation
@unnumberedsec Pragma Complex_Representation
@findex Complex_Representation
@smallexample @c ada
pragma Complex_Representation
- ([Entity =>] LOCAL_NAME);
+ ([Entity =>] local_NAME);
@end smallexample
@noindent
@smallexample @c ada
pragma Component_Alignment (
[Form =>] ALIGNMENT_CHOICE
- [, [Name =>] type_LOCAL_NAME]);
+ [, [Name =>] type_local_NAME]);
ALIGNMENT_CHOICE ::=
Component_Size
@end table
@noindent
-If the @code{Name} parameter is present, @var{type_local_name} must
+If the @code{Name} parameter is present, @var{type_local_NAME} must
refer to a local record or array type, and the specified alignment
choice applies to the specified type. The use of
@code{Component_Alignment} together with a pragma @code{Pack} causes the
Syntax:
@smallexample @c ada
-pragma CPP_Class ([Entity =>] LOCAL_NAME);
+pragma CPP_Class ([Entity =>] local_NAME);
@end smallexample
@noindent
-The argument denotes an entity in the current declarative region
-that is declared as a tagged or untagged 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 (and only if) the type is tagged, at least one component in the
-record must be of type @code{Interfaces.CPP.Vtable_Ptr}, corresponding
-to the C++ Vtable (or Vtables in the case of multiple inheritance) used
-for dispatching.
+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.
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}).
+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.
Pragma @code{CPP_Class} is intended primarily for automatic generation
using an automatic binding generator tool.
See @ref{Interfacing to C++} for related information.
+Note: Pragma @code{CPP_Class} is currently obsolete. It is supported
+for backward compatibility but its functionality is available
+using pragma @code{Import} with @code{Convention} = @code{CPP}.
+
@node Pragma CPP_Constructor
@unnumberedsec Pragma CPP_Constructor
@cindex Interfacing with C++
Syntax:
@smallexample @c ada
-pragma CPP_Constructor ([Entity =>] LOCAL_NAME);
+pragma CPP_Constructor ([Entity =>] local_NAME
+ [, [External_Name =>] static_string_EXPRESSION ]
+ [, [Link_Name =>] static_string_EXPRESSION ]);
@end smallexample
@noindent
This pragma identifies an imported function (imported in the usual way
-with pragma @code{Import}) as corresponding to a C++
-constructor. The argument is a name that must have been
-previously mentioned in a pragma @code{Import}
-with @code{Convention} = @code{CPP}, and must be of one of the following
-forms:
+with pragma @code{Import}) as corresponding to a C++ constructor. If
+@code{External_Name} and @code{Link_Name} are not specified then the
+@code{Entity} argument is a name that must have been previously mentioned
+in a pragma @code{Import} with @code{Convention} = @code{CPP}. Such name
+must be of one of the following forms:
@itemize @bullet
@item
@cindex Interfacing to C++
@findex CPP_Virtual
@noindent
-Syntax:
+This pragma is now obsolete has has no effect because GNAT generates
+the same object layout than the G++ compiler.
-@smallexample @c ada
-pragma CPP_Virtual
- [Entity =>] ENTITY,
- [, [Vtable_Ptr =>] vtable_ENTITY,]
- [, [Position =>] static_integer_EXPRESSION]);
-@end smallexample
-
-@noindent
-This pragma serves the same function as pragma @code{Import} in that
-case of a virtual function imported from C++. The @var{Entity} argument
-must be a
-primitive subprogram of a tagged type to which pragma @code{CPP_Class}
-applies. The @var{Vtable_Ptr} argument specifies
-the Vtable_Ptr component which contains the
-entry for this virtual function. The @var{Position} argument
-is the sequential number
-counting virtual functions for this Vtable starting at 1.
-
-The @code{Vtable_Ptr} and @code{Position} arguments may be omitted if
-there is one Vtable_Ptr present (single inheritance case) and all
-virtual functions are imported. In that case the compiler can deduce both
-these values.
-
-No @code{External_Name} or @code{Link_Name} arguments are required for a
-virtual function, since it is always accessed indirectly via the
-appropriate Vtable entry.
-
-Pragma @code{CPP_Virtual} is intended primarily for automatic generation
-using an automatic binding generator tool.
See @ref{Interfacing to C++} for related information.
@node Pragma CPP_Vtable
@cindex Interfacing with C++
@findex CPP_Vtable
@noindent
-Syntax:
+This pragma is now obsolete has has no effect because GNAT generates
+the same object layout than the G++ compiler.
-@smallexample @c ada
-pragma CPP_Vtable (
- [Entity =>] ENTITY,
- [Vtable_Ptr =>] vtable_ENTITY,
- [Entry_Count =>] static_integer_EXPRESSION);
-@end smallexample
-
-@noindent
-Given a record to which the pragma @code{CPP_Class} applies,
-this pragma can be specified for each component of type
-@code{CPP.Interfaces.Vtable_Ptr}.
-@var{Entity} is the tagged type, @var{Vtable_Ptr}
-is the record field of type @code{Vtable_Ptr}, and @var{Entry_Count} is
-the number of virtual functions on the C++ side. Not all of these
-functions need to be imported on the Ada side.
-
-You may omit the @code{CPP_Vtable} pragma if there is only one
-@code{Vtable_Ptr} component in the record and all virtual functions are
-imported on the Ada side (the default value for the entry count in this
-case is simply the total number of virtual functions).
-
-Pragma @code{CPP_Vtable} is intended primarily for automatic generation
-using an automatic binding generator tool.
See @ref{Interfacing to C++} for related information.
@node Pragma Debug
Syntax:
@smallexample @c ada
-pragma Debug (PROCEDURE_CALL_WITHOUT_SEMICOLON);
+pragma Debug ([CONDITION, ]PROCEDURE_CALL_WITHOUT_SEMICOLON);
PROCEDURE_CALL_WITHOUT_SEMICOLON ::=
PROCEDURE_NAME
@end smallexample
@noindent
-The argument has the syntactic form of an expression, meeting the
-syntactic requirements for pragmas.
+The procedure call argument has the syntactic form of an expression, meeting
+the syntactic requirements for pragmas.
+
+If debug pragmas are not enabled or if the condition is present and evaluates
+to False, this pragma has no effect. If debug pragmas are enabled, the
+semantics of the pragma is exactly equivalent to the procedure call statement
+corresponding to the argument with a terminating semicolon. Pragmas are
+permitted in sequences of declarations, so you can use pragma @code{Debug} to
+intersperse calls to debug procedures in the middle of declarations. Debug
+pragmas can be enabled either by use of the command line switch @code{-gnata}
+or by use of the configuration pragma @code{Debug_Policy}.
-If assertions are not enabled on the command line, this pragma has no
-effect. If asserts are enabled, the semantics of the pragma is exactly
-equivalent to the procedure call statement corresponding to the argument
-with a terminating semicolon. Pragmas are permitted in sequences of
-declarations, so you can use pragma @code{Debug} to intersperse calls to
-debug procedures in the middle of declarations.
+@node Pragma Debug_Policy
+@unnumberedsec Pragma Debug_Policy
+@findex Debug_Policy
+@noindent
+Syntax:
+
+@smallexample @c ada
+pragma Debug_Policy (CHECK | IGNORE);
+@end smallexample
+
+@noindent
+If the argument is @code{CHECK}, then pragma @code{DEBUG} is enabled.
+If the argument is @code{IGNORE}, then pragma @code{DEBUG} is ignored.
+This pragma overrides the effect of the @code{-gnata} switch on the
+command line.
@node Pragma Detect_Blocking
@unnumberedsec Pragma Detect_Blocking
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
+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
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.
+
@node Pragma Export_Exception
@unnumberedsec Pragma Export_Exception
@cindex OpenVMS
@smallexample @c ada
pragma Export_Exception (
- [Internal =>] LOCAL_NAME,
+ [Internal =>] local_NAME,
[, [External =>] EXTERNAL_SYMBOL,]
[, [Form =>] Ada | VMS]
[, [Code =>] static_integer_EXPRESSION]);
@smallexample @c ada
pragma Export_Function (
- [Internal =>] LOCAL_NAME,
+ [Internal =>] local_NAME,
[, [External =>] EXTERNAL_SYMBOL]
[, [Parameter_Types =>] PARAMETER_TYPES]
[, [Result_Type =>] result_SUBTYPE_MARK]
MECHANISM_NAME ::=
Value
| Reference
+| Descriptor [([Class =>] CLASS_NAME)]
+
+CLASS_NAME ::= ubs | ubsb | uba | s | sb | a
@end smallexample
@noindent
@cindex OpenVMS
@cindex Passing by descriptor
-Note that passing by descriptor is not supported, even on the OpenVMS
-ports of GNAT@.
+Passing by descriptor is supported only on the OpenVMS ports of GNAT@.
@cindex Suppressing external name
Special treatment is given if the EXTERNAL is an explicit null
@smallexample @c ada
pragma Export_Object
- [Internal =>] LOCAL_NAME,
+ [Internal =>] local_NAME,
[, [External =>] EXTERNAL_SYMBOL]
[, [Size =>] EXTERNAL_SYMBOL]
@smallexample @c ada
pragma Export_Procedure (
- [Internal =>] LOCAL_NAME
+ [Internal =>] local_NAME
[, [External =>] EXTERNAL_SYMBOL]
[, [Parameter_Types =>] PARAMETER_TYPES]
[, [Mechanism =>] MECHANISM]);
MECHANISM_NAME ::=
Value
| Reference
+| Descriptor [([Class =>] CLASS_NAME)]
+
+CLASS_NAME ::= ubs | ubsb | uba | s | sb | a
@end smallexample
@noindent
@cindex OpenVMS
@cindex Passing by descriptor
-Note that passing by descriptor is not supported, even on the OpenVMS
-ports of GNAT@.
+Passing by descriptor is supported only on the OpenVMS ports of GNAT@.
@cindex Suppressing external name
Special treatment is given if the EXTERNAL is an explicit null
@smallexample @c ada
pragma Export_Valued_Procedure (
- [Internal =>] LOCAL_NAME
+ [Internal =>] local_NAME
[, [External =>] EXTERNAL_SYMBOL]
[, [Parameter_Types =>] PARAMETER_TYPES]
[, [Mechanism =>] MECHANISM]);
MECHANISM_NAME ::=
Value
| Reference
+| Descriptor [([Class =>] CLASS_NAME)]
+
+CLASS_NAME ::= ubs | ubsb | uba | s | sb | a
@end smallexample
@noindent
This pragma is identical to @code{Export_Procedure} except that the
-first parameter of @var{local_name}, which must be present, must be of
+first parameter of @var{local_NAME}, which must be present, must be of
mode @code{OUT}, and externally the subprogram is treated as a function
with this parameter as the result of the function. GNAT provides for
this capability to allow the use of @code{OUT} and @code{IN OUT}
@cindex OpenVMS
@cindex Passing by descriptor
-Note that passing by descriptor is not supported, even on the OpenVMS
-ports of GNAT@.
+Passing by descriptor is supported only on the OpenVMS ports of GNAT@.
@cindex Suppressing external name
Special treatment is given if the EXTERNAL is an explicit null
This pragma is used to provide backwards compatibility with other
implementations that extend the facilities of package @code{System}. In
GNAT, @code{System} contains only the definitions that are present in
-the Ada 95 RM@. However, other implementations, notably the DEC Ada 83
+the Ada RM@. However, other implementations, notably the DEC Ada 83
implementation, provide many extensions to package @code{System}.
For each such implementation accommodated by this pragma, GNAT provides a
@table @asis
@item Implicit external names
Implicit external names are derived from identifiers. The most common case
-arises when a standard Ada 95 Import or Export pragma is used with only two
+arises when a standard Ada Import or Export pragma is used with only two
arguments, as in:
@smallexample @c ada
@end smallexample
@noindent
-Since Ada is a case insensitive language, the spelling of the identifier in
+Since Ada is a case-insensitive language, the spelling of the identifier in
the Ada source program does not provide any information on the desired
casing of the external name, and so a convention is needed. In GNAT the
default treatment is that such names are converted to all lower case
@item Explicit external names
Explicit external names are given as string literals. The most common case
-arises when a standard Ada 95 Import or Export pragma is used with three
+arises when a standard Ada Import or Export pragma is used with three
arguments, as in:
@smallexample @c ada
Syntax:
@smallexample @c ada
-pragma Finalize_Storage_Only (first_subtype_LOCAL_NAME);
+pragma Finalize_Storage_Only (first_subtype_local_NAME);
@end smallexample
@noindent
Syntax:
@smallexample @c ada
-pragma Float_Representation (FLOAT_REP);
+pragma Float_Representation (FLOAT_REP[, float_type_LOCAL_NAME]);
FLOAT_REP ::= VAX_Float | IEEE_Float
@end smallexample
@noindent
-This pragma
+In the one argument form, this pragma is a configuration pragma which
allows control over the internal representation chosen for the predefined
floating point types declared in the packages @code{Standard} and
@code{System}. On all systems other than OpenVMS, the argument must
description of the @code{GNAT LIBRARY} command in the OpenVMS version
of the GNAT Users Guide for details on the use of this command.
+The two argument form specifies the representation to be used for
+the specified floating-point type. On all systems other than OpenVMS,
+the argument must
+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, as follows:
+
+@itemize @bullet
+@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.
+@item
+For digits values from 10 to 15, F float format will be used.
+@item
+Digits values above 15 are not allowed.
+@end itemize
+
@node Pragma Ident
@unnumberedsec Pragma Ident
@findex Ident
maintain compatibility with this compiler, you should obey this length
limit.
+@node Pragma Implicit_Packing
+@unnumberedsec Pragma Implicit_Packing
+@findex Implicit_Packing
+@noindent
+Syntax:
+
+@smallexample @c ada
+pragma Implicit_Packing;
+@end smallexample
+
+@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:
+
+@smallexample @c ada
+type R is array (0 .. 7) of Boolean;
+for R'Size use 8;
+@end smallexample
+
+@noindent
+In accordance with the recommendation in the RM (RM 13.3(53)), a Size clause
+does not change the layout of a composite object. So the Size clause in the
+above example is normally rejected, since the default layout of the array uses
+8-bit components, and thus the array requires a minimum of 64 bits.
+
+If this declaration is compiled in a region of code covered by an occurrence
+of the configuration pragma Implicit_Packing, then the Size clause in this
+and similar examples will cause implicit packing and thus be accepted. For
+this implicit packing to occur, the type in question must be an array of small
+components whose size is known at compile time, and the Size clause must
+specify the exact size that corresponds to the length of the array multiplied
+by the size in bits of the component type.
+@cindex Array packing
+
@node Pragma Import_Exception
@unnumberedsec Pragma Import_Exception
@cindex OpenVMS
@smallexample @c ada
pragma Import_Exception (
- [Internal =>] LOCAL_NAME,
+ [Internal =>] local_NAME,
[, [External =>] EXTERNAL_SYMBOL,]
[, [Form =>] Ada | VMS]
[, [Code =>] static_integer_EXPRESSION]);
@smallexample @c ada
pragma Import_Function (
- [Internal =>] LOCAL_NAME,
+ [Internal =>] local_NAME,
[, [External =>] EXTERNAL_SYMBOL]
[, [Parameter_Types =>] PARAMETER_TYPES]
[, [Result_Type =>] SUBTYPE_MARK]
@smallexample @c ada
pragma Import_Object
- [Internal =>] LOCAL_NAME,
+ [Internal =>] local_NAME,
[, [External =>] EXTERNAL_SYMBOL],
[, [Size =>] EXTERNAL_SYMBOL]);
@smallexample @c ada
pragma Import_Procedure (
- [Internal =>] LOCAL_NAME,
+ [Internal =>] local_NAME,
[, [External =>] EXTERNAL_SYMBOL]
[, [Parameter_Types =>] PARAMETER_TYPES]
[, [Mechanism =>] MECHANISM]
@smallexample @c ada
pragma Import_Valued_Procedure (
- [Internal =>] LOCAL_NAME,
+ [Internal =>] local_NAME,
[, [External =>] EXTERNAL_SYMBOL]
[, [Parameter_Types =>] PARAMETER_TYPES]
[, [Mechanism =>] MECHANISM]
@noindent
This pragma is identical to @code{Import_Procedure} except that the
-first parameter of @var{local_name}, which must be present, must be of
+first parameter of @var{local_NAME}, which must be present, must be of
mode @code{OUT}, and externally the subprogram is treated as a function
with this parameter as the result of the function. The purpose of this
capability is to allow the use of @code{OUT} and @code{IN OUT}
@smallexample @c ada
pragma Interface (
[Convention =>] convention_identifier,
- [Entity =>] local_name
+ [Entity =>] local_NAME
[, [External_Name =>] static_string_expression],
[, [Link_Name =>] static_string_expression]);
@end smallexample
@noindent
This pragma is identical in syntax and semantics to
-the standard Ada 95 pragma @code{Import}. It is provided for compatibility
+the standard Ada pragma @code{Import}. It is provided for compatibility
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
@smallexample @c ada
pragma Interface_Name (
- [Entity =>] LOCAL_NAME
+ [Entity =>] local_NAME
[, [External_Name =>] static_string_EXPRESSION]
[, [Link_Name =>] static_string_EXPRESSION]);
@end smallexample
Syntax:
@smallexample @c ada
-pragma Interrupt_Handler (procedure_LOCAL_NAME);
+pragma Interrupt_Handler (procedure_local_NAME);
@end smallexample
@noindent
Syntax:
@smallexample @c ada
-pragma Keep_Names ([On =>] enumeration_first_subtype_LOCAL_NAME);
+pragma Keep_Names ([On =>] enumeration_first_subtype_local_NAME);
@end smallexample
@noindent
-The @var{LOCAL_NAME} argument
+The @var{local_NAME} argument
must refer to an enumeration first subtype
in the current declarative part. The effect is to retain the enumeration
literal names for use by @code{Image} and @code{Value} even if a global
This is used for a unit licensed under the GNAT modified GPL that includes
a special exception paragraph that specifically permits the inclusion of
the unit in programs without requiring the entire program to be released
-under the GPL@. This is the license used for the GNAT run-time which ensures
-that the run-time can be used freely in any program without GPL concerns.
+under the GPL@.
@item Restricted
This is used for a unit that is restricted in that it is not permitted to
@smallexample @c ada
pragma Linker_Alias (
- [Entity =>] LOCAL_NAME
- [Alias =>] static_string_EXPRESSION);
+ [Entity =>] local_NAME
+ [Target =>] static_string_EXPRESSION);
+@end smallexample
+
+@noindent
+@var{local_NAME} must refer to an object that is declared at the library
+level. This pragma establishes the given entity as a linker alias for the
+given target. It is equivalent to @code{__attribute__((alias))} in GNU C
+and causes @var{local_NAME} to be emitted as an alias for the symbol
+@var{static_string_EXPRESSION} in the object file, that is to say no space
+is reserved for @var{local_NAME} by the assembler and it will be resolved
+to the same address as @var{static_string_EXPRESSION} by the linker.
+
+The actual linker name for the target must be used (e.g. the fully
+encoded name with qualification in Ada, or the mangled name in C++),
+or it must be declared using the C convention with @code{pragma Import}
+or @code{pragma Export}.
+
+Not all target machines support this pragma. On some of them it is accepted
+only if @code{pragma Weak_External} has been applied to @var{local_NAME}.
+
+@smallexample @c ada
+-- Example of the use of pragma Linker_Alias
+
+package p is
+ i : Integer := 1;
+ pragma Export (C, i);
+
+ new_name_for_i : Integer;
+ pragma Linker_Alias (new_name_for_i, "i");
+end p;
+@end smallexample
+
+@node Pragma Linker_Constructor
+@unnumberedsec Pragma Linker_Constructor
+@findex Linker_Constructor
+@noindent
+Syntax:
+
+@smallexample @c ada
+pragma Linker_Constructor (procedure_LOCAL_NAME);
@end smallexample
@noindent
-This pragma establishes a linker alias for the given named entity. For
-further details on the exact effect, consult the GCC manual.
+@var{procedure_local_NAME} must refer to a parameterless procedure that
+is declared at the library level. A procedure to which this pragma is
+applied will be treated as an initialization routine by the linker.
+It is equivalent to @code{__attribute__((constructor))} in GNU C and
+causes @var{procedure_LOCAL_NAME} to be invoked before the entry point
+of the executable is called (or immediately after the shared library is
+loaded if the procedure is linked in a shared library), in particular
+before the Ada run-time environment is set up.
+
+Because of these specific contexts, the set of operations such a procedure
+can perform is very limited and the type of objects it can manipulate is
+essentially restricted to the elementary types. In particular, it must only
+contain code to which pragma Restrictions (No_Elaboration_Code) applies.
+
+This pragma is used by GNAT to implement auto-initialization of shared Stand
+Alone Libraries, which provides a related capability without the restrictions
+listed above. Where possible, the use of Stand Alone Libraries is preferable
+to the use of this pragma.
+
+@node Pragma Linker_Destructor
+@unnumberedsec Pragma Linker_Destructor
+@findex Linker_Destructor
+@noindent
+Syntax:
+
+@smallexample @c ada
+pragma Linker_Destructor (procedure_LOCAL_NAME);
+@end smallexample
+
+@noindent
+@var{procedure_local_NAME} must refer to a parameterless procedure that
+is declared at the library level. A procedure to which this pragma is
+applied will be treated as a finalization routine by the linker.
+It is equivalent to @code{__attribute__((destructor))} in GNU C and
+causes @var{procedure_LOCAL_NAME} to be invoked after the entry point
+of the executable has exited (or immediately before the shared library
+is unloaded if the procedure is linked in a shared library), in particular
+after the Ada run-time environment is shut down.
+
+See @code{pragma Linker_Constructor} for the set of restrictions that apply
+because of these specific contexts.
@node Pragma Linker_Section
@unnumberedsec Pragma Linker_Section
@smallexample @c ada
pragma Linker_Section (
- [Entity =>] LOCAL_NAME
+ [Entity =>] local_NAME
[Section =>] static_string_EXPRESSION);
@end smallexample
@noindent
-This pragma specifies the name of the linker section for the given entity.
-For further details on the exact effect, consult the GCC manual.
+@var{local_NAME} must refer to an object that is declared at the library
+level. This pragma specifies the name of the linker section for the given
+entity. It is equivalent to @code{__attribute__((section))} in GNU C and
+causes @var{local_NAME} to be placed in the @var{static_string_EXPRESSION}
+section of the executable (assuming the linker doesn't rename the section).
+
+The compiler normally places library-level objects in standard sections
+depending on their type: procedures and functions generally go in the
+@code{.text} section, initialized variables in the @code{.data} section
+and uninitialized variables in the @code{.bss} section.
+
+Other, special sections may exist on given target machines to map special
+hardware, for example I/O ports or flash memory. This pragma is a means to
+defer the final layout of the executable to the linker, thus fully working
+at the symbolic level with the compiler.
+
+Some file formats do not support arbitrary sections so not all target
+machines support this pragma. The use of this pragma may cause a program
+execution to be erroneous if it is used to place an entity into an
+inappropriate section (e.g. a modified variable into the @code{.text}
+section). See also @code{pragma Persistent_BSS}.
+
+@smallexample @c ada
+-- Example of the use of pragma Linker_Section
+
+package IO_Card is
+ Port_A : Integer;
+ pragma Volatile (Port_A);
+ pragma Linker_Section (Port_A, ".bss.port_a");
+
+ Port_B : Integer;
+ pragma Volatile (Port_B);
+ pragma Linker_Section (Port_B, ".bss.port_b");
+end IO_Card;
+@end smallexample
@node Pragma Long_Float
@unnumberedsec Pragma Long_Float
@smallexample @c ada
pragma Machine_Attribute (
[Attribute_Name =>] string_EXPRESSION,
- [Entity =>] LOCAL_NAME);
+ [Entity =>] local_NAME);
@end smallexample
@noindent
-Machine dependent attributes can be specified for types and/or
-declarations. Currently only subprogram entities are supported. This
-pragma is semantically equivalent to
+Machine-dependent attributes can be specified for types and/or
+declarations. This pragma is semantically equivalent to
@code{__attribute__((@var{string_expression}))} in GNU C,
where @code{@var{string_expression}} is
-recognized by the GNU C macros @code{VALID_MACHINE_TYPE_ATTRIBUTE} and
-@code{VALID_MACHINE_DECL_ATTRIBUTE} which are defined in the
-configuration header file @file{tm.h} for each machine. See the GCC
-manual for further information.
+recognized by the target macro @code{TARGET_ATTRIBUTE_TABLE} which is
+defined for each machine. See the GCC manual for 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.
+
+@node Pragma Main
+@unnumberedsec Pragma Main
+@cindex OpenVMS
+@findex Main
+@noindent
+Syntax:
+
+@smallexample @c ada
+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
+@end smallexample
+
+@noindent
+This pragma is provided for compatibility with OpenVMS VAX Systems. It has
+no effect in GNAT, other than being syntax checked.
@node Pragma Main_Storage
@unnumberedsec Pragma Main_Storage
MAIN_STORAGE_OPTION ::=
[WORKING_STORAGE =>] static_SIMPLE_EXPRESSION
| [TOP_GUARD =>] static_SIMPLE_EXPRESSION
-
@end smallexample
@noindent
no effect in GNAT, other than being syntax checked. Note that the pragma
also has no effect in DEC Ada 83 for OpenVMS Alpha Systems.
+@node Pragma No_Body
+@unnumberedsec Pragma No_Body
+@findex No_Body
+@noindent
+Syntax:
+
+@smallexample @c ada
+pragma No_Body;
+@end smallexample
+
+@noindent
+There are a number of cases in which a package spec does not require a body,
+and in fact a body is not permitted. GNAT will not permit the spec to be
+compiled if there is a body around. The pragma No_Body allows you to provide
+a body file, even in a case where no body is allowed. The body file must
+contain only comments and a single No_Body pragma. This is recognized by
+the compiler as indicating that no body is logically present.
+
+This is particularly useful during maintenance when a package is modified in
+such a way that a body needed before is no longer needed. The provision of a
+dummy body with a No_Body pragma ensures that there is no inteference from
+earlier versions of the package body.
+
@node Pragma No_Return
@unnumberedsec Pragma No_Return
@findex No_Return
Syntax:
@smallexample @c ada
-pragma No_Return (procedure_LOCAL_NAME);
+pragma No_Return (procedure_local_NAME @{, procedure_local_NAME@});
@end smallexample
@noindent
-@var{procedure_local_NAME} must refer to one or more procedure
+Each @var{procedure_local_NAME} argument must refer to one or more procedure
declarations in the current declarative part. A procedure to which this
-pragma is applied may not contain any explicit @code{return} statements,
-and also may not contain any implicit return statements from falling off
-the end of a statement sequence. One use of this pragma is to identify
-procedures whose only purpose is to raise an exception.
-
-Another use of this pragma is to suppress incorrect warnings about
-missing returns in functions, where the last statement of a function
+pragma is applied may not contain any explicit @code{return} statements.
+In addition, if the procedure contains any implicit returns from falling
+off the end of a statement sequence, then execution of that implicit
+return will cause Program_Error to be raised.
+
+One use of this pragma is to identify procedures whose only purpose is to raise
+an exception. Another use of this pragma is to suppress incorrect warnings
+about missing returns in functions, where the last statement of a function
statement sequence is a call to such a procedure.
+Note that in Ada 2005 mode, this pragma is part of the language, and is
+identical in effect to the pragma as implemented in Ada 95 mode.
+
+@node Pragma No_Strict_Aliasing
+@unnumberedsec Pragma No_Strict_Aliasing
+@findex No_Strict_Aliasing
+@noindent
+Syntax:
+
+@smallexample @c ada
+pragma No_Strict_Aliasing [([Entity =>] type_LOCAL_NAME)];
+@end smallexample
+
+@noindent
+@var{type_LOCAL_NAME} must refer to an access type
+declaration in the current declarative part. The effect is to inhibit
+strict aliasing optimization for the given type. The form with no
+arguments is a configuration pragma which applies to all access types
+declared in units to which the pragma applies. For a detailed
+description of the strict aliasing optimization, and the situations
+in which it must be suppressed, see section
+``Optimization and Strict Aliasing'' in the @value{EDITION} User's Guide.
+
@node Pragma Normalize_Scalars
@unnumberedsec Pragma Normalize_Scalars
@findex Normalize_Scalars
Syntax:
@smallexample @c ada
-pragma Obsolescent [(static_string_EXPRESSION)];
+pragma Obsolescent
+ (Entity => NAME [, static_string_EXPRESSION [,Ada_05]]);
@end smallexample
@noindent
-This pragma must occur immediately following a subprogram
-declaration. It indicates that the associated function or procedure
+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.
+
+This pragma is used to indicate that the named entity
is considered obsolescent and should not be used. Typically this is
used when an API must be modified by eventually removing or modifying
-existing subprograms. The pragma can be used at an intermediate stage
-when the subprogram is still present, but will be removed later.
+existing subprograms or other entities. The pragma can be used at an
+intermediate stage when the entity is still present, but will be
+removed later.
-The effect of this pragma is to output a warning message that the
+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 a parameter is present, then a second
+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).
+
+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
+pragma indicates that the entire package is considered
+obsolescent. In this case a client @code{with}'ing such a package
+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
+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
+in the predefined library where subprograms or packages
+have become defined as obsolescent in Ada 2005
+(e.g. in Ada.Characters.Handling), but may be used anywhere.
+
+The following examples show typical uses of this pragma:
+
+@smallexample @c ada
+package p is
+ pragma Obsolescent
+ (Entity => p, "use pp instead of p");
+end p;
+
+package q is
+ procedure q2;
+ pragma Obsolescent
+ (Entity => q2, "use q2new instead");
+
+ type R is new integer;
+ pragma Obsolescent
+ (Entity => R, "use RR in Ada 2005", Ada_05);
+
+ type M is record
+ F1 : Integer;
+ F2 : Integer;
+ pragma Obsolescent (Entity => F2);
+ F3 : Integer;
+ end record;
+
+ type E is (a, bc, 'd', quack);
+ pragma Obsolescent (Entity => bc)
+ pragma Obsolescent (Entity => 'd')
+
+ function "+"
+ (a, b : character) return character;
+ pragma Obsolescent (Entity => "+");
+end;
+@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).
@node Pragma Passive
@unnumberedsec Pragma Passive
Syntax:
@smallexample @c ada
-pragma Passive ([Semaphore | No]);
+pragma Passive [(Semaphore | No)];
@end smallexample
@noindent
optimized. GNAT does not attempt to optimize any tasks in this manner
(since protected objects are available in place of passive tasks).
+@node Pragma Persistent_BSS
+@unnumberedsec Pragma Persistent_BSS
+@findex Persistent_BSS
+@noindent
+Syntax:
+
+@smallexample @c ada
+pragma Persistent_BSS [(local_NAME)]
+@end smallexample
+
+@noindent
+This pragma allows selected objects to be placed in the @code{.persistent_bss}
+section. On some targets the linker and loader provide for special
+treatment of this section, allowing a program to be reloaded without
+affecting the contents of this data (hence the name persistent).
+
+There are two forms of usage. If an argument is given, it must be the
+local name of a library level object, with no explicit initialization
+and whose type is potentially persistent. If no argument is given, then
+the pragma is a configuration pragma, and applies to all library level
+objects with no explicit initialization of potentially persistent types.
+
+A potentially persistent type is a scalar type, or a non-tagged,
+non-discriminated record, all of whose components have no explicit
+initialization and are themselves of a potentially persistent type,
+or an array, all of whose constraints are static, and whose component
+type is potentially persistent.
+
+If this pragma is used on a target where this feature is not supported,
+then the pragma will be ignored. See also @code{pragma Linker_Section}.
+
@node Pragma Polling
@unnumberedsec Pragma Polling
@findex Polling
definition of the ``Ravenscar Profile'' for limited tasking, devised and
published by the @cite{International Real-Time Ada Workshop}, 1997,
and whose most recent description is available at
-@url{ftp://ftp.openravenscar.org/openravenscar/ravenscar00.pdf}.
+@url{http://www-users.cs.york.ac.uk/~burns/ravenscar.ps}.
The original definition of the profile was revised at subsequent IRTAW
meetings. It has been included in the ISO
version of the run time that provides improved performance for the
limited set of tasking functionality permitted by this set of restrictions.
-@node Pragma Propagate_Exceptions
-@unnumberedsec Pragma Propagate_Exceptions
-@findex Propagate_Exceptions
-@cindex Zero Cost Exceptions
-@noindent
-Syntax:
-
-@smallexample @c ada
-pragma Propagate_Exceptions (subprogram_LOCAL_NAME);
-@end smallexample
-
-@noindent
-This pragma indicates that the given entity, which is the name of an
-imported foreign-language subprogram may receive an Ada exception,
-and that the exception should be propagated. It is relevant only if
-zero cost exception handling is in use, and is thus never needed if
-the alternative @code{longjmp} / @code{setjmp} implementation of
-exceptions is used (although it is harmless to use it in such cases).
-
-The implementation of fast exceptions always properly propagates
-exceptions through Ada code, as described in the Ada Reference Manual.
-However, this manual is silent about the propagation of exceptions
-through foreign code. For example, consider the
-situation where @code{P1} calls
-@code{P2}, and @code{P2} calls @code{P3}, where
-@code{P1} and @code{P3} are in Ada, but @code{P2} is in C@.
-@code{P3} raises an Ada exception. The question is whether or not
-it will be propagated through @code{P2} and can be handled in
-@code{P1}.
-
-For the @code{longjmp} / @code{setjmp} implementation of exceptions,
-the answer is always yes. For some targets on which zero cost exception
-handling is implemented, the answer is also always yes. However, there
-are some targets, notably in the current version all x86 architecture
-targets, in which the answer is that such propagation does not
-happen automatically. If such propagation is required on these
-targets, it is mandatory to use @code{Propagate_Exceptions} to
-name all foreign language routines through which Ada exceptions
-may be propagated.
-
@node Pragma Psect_Object
@unnumberedsec Pragma Psect_Object
@findex Psect_Object
@smallexample @c ada
pragma Psect_Object (
- [Internal =>] LOCAL_NAME,
+ [Internal =>] local_NAME,
[, [External =>] EXTERNAL_SYMBOL]
[, [Size =>] EXTERNAL_SYMBOL]);
Syntax:
@smallexample @c ada
-pragma Pure_Function ([Entity =>] function_LOCAL_NAME);
+pragma Pure_Function ([Entity =>] function_local_NAME);
@end smallexample
@noindent
disambiguate cases of overloading where some but not all functions
in a set of overloaded functions are to be designated as pure.
+If pragma @code{Pure_Function} is applied to a library level function, the
+function is also considered pure from an optimization point of view, but the
+unit is not a Pure unit in the categorization sense. So for example, a function
+thus marked is free to @code{with} non-pure units.
+
@node Pragma Restriction_Warnings
@unnumberedsec Pragma Restriction_Warnings
@findex Restriction_Warnings
@smallexample @c ada
pragma Stream_Convert (
- [Entity =>] type_LOCAL_NAME,
+ [Entity =>] type_local_NAME,
[Read =>] function_NAME,
[Write =>] function_NAME);
@end smallexample
@end smallexample
@noindent
-The specifications of the referenced functions, as given in the Ada 95
+The specifications of the referenced functions, as given in the Ada
Reference Manual are:
@smallexample @c ada
@smallexample @c ada
pragma Style_Checks (string_LITERAL | ALL_CHECKS |
- On | Off [, LOCAL_NAME]);
+ On | Off [, local_NAME]);
@end smallexample
@noindent
This pragma is recognized for compatibility with other Ada compilers
but is ignored by GNAT@.
+@node Pragma Suppress
+@unnumberedsec Pragma Suppress
+@findex Suppress
+@noindent
+Syntax:
+
+@smallexample @c ada
+pragma Suppress (Identifier [, [On =>] Name]);
+@end smallexample
+
+@noindent
+This is a standard pragma, and supports all the check names required in
+the RM. It is included here because GNAT recognizes one additional check
+name: @code{Alignment_Check} which can be used to suppress alignment checks
+on addresses used in address clauses. Such checks can also be suppressed
+by suppressing range checks, but the specific use of @code{Alignment_Check}
+allows suppression of alignment checks without suppressing other range checks.
+
@node Pragma Suppress_All
@unnumberedsec Pragma Suppress_All
@findex Suppress_All
@smallexample @c ada
pragma Task_Storage (
- [Task_Type =>] LOCAL_NAME,
+ [Task_Type =>] local_NAME,
[Top_Guard =>] static_integer_EXPRESSION);
@end smallexample
@code{Storage_Size} attribute definition clause is allowed for a task
type.
-@node Pragma Thread_Body
-@unnumberedsec Pragma Thread_Body
-@findex Thread_Body
-Syntax:
-
-@smallexample @c ada
-pragma Thread_Body (
- [Entity =>] LOCAL_NAME,
- [[Secondary_Stack_Size =>] static_integer_EXPRESSION)];
-@end smallexample
-
-@noindent
-This pragma specifies that the subprogram whose name is given as the
-@code{Entity} argument is a thread body, which will be activated
-by being called via its Address from foreign code. The purpose is
-to allow execution and registration of the foreign thread within the
-Ada run-time system.
-
-See the library unit @code{System.Threads} for details on the expansion of
-a thread body subprogram, including the calls made to subprograms
-within System.Threads to register the task. This unit also lists the
-targets and runtime systems for which this pragma is supported.
-
-A thread body subprogram may not be called directly from Ada code, and
-it is not permitted to apply the Access (or Unrestricted_Access) attributes
-to such a subprogram. The only legitimate way of calling such a subprogram
-is to pass its Address to foreign code and then make the call from the
-foreign code.
-
-A thread body subprogram may have any parameters, and it may be a function
-returning a result. The convention of the thread body subprogram may be
-set in the usual manner using @code{pragma Convention}.
-
-The secondary stack size parameter, if given, is used to set the size
-of secondary stack for the thread. The secondary stack is allocated as
-a local variable of the expanded thread body subprogram, and thus is
-allocated out of the main thread stack size. If no secondary stack
-size parameter is present, the default size (from the declaration in
-@code{System.Secondary_Stack} is used.
-
@node Pragma Time_Slice
@unnumberedsec Pragma Time_Slice
@findex Time_Slice
Syntax:
@smallexample @c ada
-pragma Unchecked_Union (first_subtype_LOCAL_NAME);
+pragma Unchecked_Union (first_subtype_local_NAME);
@end smallexample
@noindent
-This pragma is used to declare that the specified type should be represented
-in a manner
-equivalent to a C union type, and is intended only for use in
-interfacing with C code that uses union types. In Ada terms, the named
-type must obey the following rules:
-
-@itemize @bullet
-@item
-It is a non-tagged non-limited record type.
-@item
-It has a single discrete discriminant with a default value.
-@item
-The component list consists of a single variant part.
-@item
-Each variant has a component list with a single component.
-@item
-No nested variants are allowed.
-@item
-No component has an explicit default value.
-@item
-No component has a non-static constraint.
-@end itemize
-
-@noindent
-In addition, given a type that meets the above requirements, the
-following restrictions apply to its use throughout the program:
-
-@itemize @bullet
-@item
-The discriminant name can be mentioned only in an aggregate.
-@item
-No subtypes may be created of this type.
-@item
-The type may not be constrained by giving a discriminant value.
-@item
-The type cannot be passed as the actual for a generic formal with a
-discriminant.
-@end itemize
-
-@noindent
-Equality and inequality operations on @code{unchecked_unions} are not
-available, since there is no discriminant to compare and the compiler
-does not even know how many bits to compare. It is implementation
-dependent whether this is detected at compile time as an illegality or
-whether it is undetected and considered to be an erroneous construct. In
-GNAT, a direct comparison is illegal, but GNAT does not attempt to catch
-the composite case (where two composites are compared that contain an
-unchecked union component), so such comparisons are simply considered
-erroneous.
-
-The layout of the resulting type corresponds exactly to a C union, where
-each branch of the union corresponds to a single variant in the Ada
-record. The semantics of the Ada program is not changed in any way by
-the pragma, i.e.@: provided the above restrictions are followed, and no
-erroneous incorrect references to fields or erroneous comparisons occur,
-the semantics is exactly as described by the Ada reference manual.
-Pragma @code{Suppress (Discriminant_Check)} applies implicitly to the
-type and the default convention is C.
+This pragma is used to specify a representation of a record type that is
+equivalent to a C union. It was introduced as a GNAT implementation defined
+pragma in the GNAT Ada 95 mode. Ada 2005 includes an extended version of this
+pragma, making it language defined, and GNAT fully implements this extended
+version in all language modes (Ada 83, Ada 95, and Ada 2005). For full
+details, consult the Ada 2005 Reference Manual, section B.3.3.
@node Pragma Unimplemented_Unit
@unnumberedsec Pragma Unimplemented_Unit
The abort only happens if code is being generated. Thus you can use
specs of unimplemented packages in syntax or semantic checking mode.
+@node Pragma Universal_Aliasing
+@unnumberedsec Pragma Universal_Aliasing
+@findex Universal_Aliasing
+@noindent
+Syntax:
+
+@smallexample @c ada
+pragma Universal_Aliasing [([Entity =>] type_LOCAL_NAME)];
+@end smallexample
+
+@noindent
+@var{type_LOCAL_NAME} must refer to a type declaration in the current
+declarative part. The effect is to inhibit strict type-based aliasing
+optimization for the given type. In other words, the effect is as though
+access types designating this type were subject to pragma No_Strict_Aliasing.
+For a detailed description of the strict aliasing optimization, and the
+situations in which it must be suppressed, see section
+``Optimization and Strict Aliasing'' in the @value{EDITION} User's Guide.
+
@node Pragma Universal_Data
@unnumberedsec Pragma Universal_Data
@findex Universal_Data
Syntax:
@smallexample @c ada
-pragma Unreferenced (local_Name @{, local_Name@});
+pragma Unreferenced (local_NAME @{, local_NAME@});
+pragma Unreferenced (library_unit_NAME @{, library_unit_NAME@});
@end smallexample
@noindent
objects declared only for their initialization or finalization side
effects.
-If @code{local_Name} identifies more than one matching homonym in the
+If @code{local_NAME} identifies more than one matching homonym in the
current scope, then the entity most recently declared is the one to which
-the pragma applies.
+the pragma applies. Note that in the case of accept formals, the pragma
+Unreferenced may appear immediately after the keyword @code{do} which
+allows the indication of whether or not accept formals are referenced
+or not to be given individually for each accept statement.
The left hand side of an assignment does not count as a reference for the
purpose of this pragma. Thus it is fine to assign to an entity for which
pragma Unreferenced is given.
+Note that if a warning is desired for all calls to a given subprogram,
+regardless of whether they occur in the same unit as the subprogram
+declaration, then this pragma should not be used (calls from another
+unit would not be flagged); pragma Obsolescent can be used instead
+for this purpose, see @xref{Pragma Obsolescent}.
+
+The second form of pragma @code{Unreferenced} is used within a context
+clause. In this case the arguments must be unit names of units previously
+mentioned in @code{with} clauses (similar to the usage of pragma
+@code{Elaborate_All}. The effect is to suppress warnings about unreferenced
+units.
+
+@node Pragma Unreferenced_Objects
+@unnumberedsec Pragma Unreferenced_Objects
+@findex Unreferenced_Objects
+@cindex Warnings, unreferenced
+@noindent
+Syntax:
+
+@smallexample @c ada
+pragma Unreferenced_Objects (local_subtype_NAME @{, local_subtype_NAME@});
+@end smallexample
+
+@noindent
+This pragma signals that for the types or subtypes whose names are
+listed, objects which are declared with one of these types or subtypes may
+not be referenced, and if no references appear, no warnings are given.
+
+This is particularly useful for objects which are declared solely for their
+initialization and finalization effect. Such variables are sometimes referred
+to as RAII variables (Resource Acquisition Is Initialization). Using this
+pragma on the relevant type (most typically a limited controlled type), the
+compiler will automatically suppress unwanted warnings about these variables
+not being referenced.
+
@node Pragma Unreserve_All_Interrupts
@unnumberedsec Pragma Unreserve_All_Interrupts
@findex Unreserve_All_Interrupts
This is a configuration pragma. In a unit to which it applies, any use
of the 'Size attribute is automatically interpreted as a use of the
'VADS_Size attribute. Note that this may result in incorrect semantic
-processing of valid Ada 95 programs. This is intended to aid in the
-handling of legacy code which depends on the interpretation of Size
+processing of valid Ada 95 or Ada 2005 programs. This is intended to aid in
+the handling of existing code which depends on the interpretation of Size
as implemented in the VADS compiler. See description of the VADS_Size
attribute for further details.
@end smallexample
@noindent
-This pragma is defined by the Ada 95 Reference Manual, and the GNAT
+This pragma is defined by the Ada Reference Manual, and the GNAT
implementation is fully conformant with this definition. The reason it
is mentioned in this section is that a pragma of the same name was supplied
-in some Ada 83 compilers, including DEC Ada 83. The Ada 95 implementation
-of pragma Volatile is upwards compatible with the implementation in
-Dec Ada 83.
+in some Ada 83 compilers, including DEC Ada 83. The Ada 95 / Ada 2005
+implementation of pragma Volatile is upwards compatible with the
+implementation in DEC Ada 83.
@node Pragma Warnings
@unnumberedsec Pragma Warnings
Syntax:
@smallexample @c ada
-pragma Warnings (On | Off [, LOCAL_NAME]);
+pragma Warnings (On | Off);
+pragma Warnings (On | Off, local_NAME);
+pragma Warnings (static_string_EXPRESSION);
+pragma Warnings (On | Off, static_string_EXPRESSION);
@end smallexample
@noindent
pragma, then no warning messages are output, regardless of the
setting of the command line switches.
-The form with a single argument is a configuration pragma.
+The form with a single argument may be used as a configuration pragma.
-If the @var{local_name} parameter is present, warnings are suppressed for
+If the @var{local_NAME} parameter is present, warnings are suppressed for
the specified entity. This suppression is effective from the point where
it occurs till the end of the extended scope of the variable (similar to
the scope of @code{Suppress}).
+The form with a single static_string_EXPRESSION argument provides more precise
+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
+full details see the GNAT Users Guide:
+
+@smallexample
+a turn on all optional warnings (except d,h,l)
+A turn off all optional warnings
+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
+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
+p turn on warnings for ineffective pragma Inline
+P turn off warnings for ineffective pragma Inline
+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
+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
+y turn on warnings for Ada 2005 incompatibility
+Y turn off warnings for Ada 2005 incompatibility
+z turn on size/align warnings for unchecked conversion
+Z turn off size/align warnings for unchecked conversion
+@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
+cumulative. Initially the set of warnings is the standard default set
+as possibly modified by compiler switches. Then each pragma Warning
+modifies this set of warnings as specified. This form of the pragma may
+also be used as a configuration pragma.
+
+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).
+
+The pattern may start with an asterisk, which matches otherwise unmatched
+characters at the start of the message, and it may also end with an asterisk
+which matches otherwise unmatched characters at the end of the message. For
+example, the string "*alignment*" could be used to match any warnings about
+alignment problems. Within the string, the sequence "*" can be used to match
+any sequence of characters enclosed in quotation marks. No other regular
+expression notations are permitted. All characters other than asterisk in
+these three specific cases are treated as literal characters in the match.
+
+There are two ways to use this pragma. The OFF form can be used as a
+configuration pragma. The effect is to suppress all warnings (if any)
+that match the pattern string throughout the compilation.
+
+The second usage is to suppress a warning locally, and in this case, two
+pragmas must appear in sequence:
+
+@smallexample @c ada
+pragma Warnings (Off, Pattern);
+.. code where given warning is to be suppressed
+pragma Warnings (On, Pattern);
+@end smallexample
+
+@noindent
+In this usage, the pattern string must match in the Off and On pragmas,
+and at least one matching warning must be suppressed.
+
@node Pragma Weak_External
@unnumberedsec Pragma Weak_External
@findex Weak_External
Syntax:
@smallexample @c ada
-pragma Weak_External ([Entity =>] LOCAL_NAME);
+pragma Weak_External ([Entity =>] local_NAME);
+@end smallexample
+
+@noindent
+@var{local_NAME} must refer to an object that is declared at the library
+level. This pragma specifies that the given entity should be marked as a
+weak symbol for the linker. It is equivalent to @code{__attribute__((weak))}
+in GNU C and causes @var{local_NAME} to be emitted as a weak symbol instead
+of a regular symbol, that is to say a symbol that does not have to be
+resolved by the linker if used in conjunction with a pragma Import.
+
+When a weak symbol is not resolved by the linker, its address is set to
+zero. This is useful in writing interfaces to external modules that may
+or may not be linked in the final executable, for example depending on
+configuration settings.
+
+If a program references at run time an entity to which this pragma has been
+applied, and the corresponding symbol was not resolved at link time, then
+the execution of the program is erroneous. It is not erroneous to take the
+Address of such an entity, for example to guard potential references,
+as shown in the example below.
+
+Some file formats do not support weak symbols so not all target machines
+support this pragma.
+
+@smallexample @c ada
+-- Example of the use of pragma Weak_External
+
+package External_Module is
+ key : Integer;
+ pragma Import (C, key);
+ pragma Weak_External (key);
+ function Present return boolean;
+end External_Module;
+
+with System; use System;
+package body External_Module is
+ function Present return boolean is
+ begin
+ return key'Address /= System.Null_Address;
+ end Present;
+end External_Module;
+@end smallexample
+
+@node Pragma Wide_Character_Encoding
+@unnumberedsec Pragma Wide_Character_Encoding
+@findex Wide_Character_Encoding
+@noindent
+Syntax:
+
+@smallexample @c ada
+pragma Wide_Character_Encoding (IDENTIFIER | CHARACTER_LITERAL);
@end smallexample
@noindent
-This pragma specifies that the given entity should be marked as a weak
-external (one that does not have to be resolved) for the linker. For
-further details, consult the GCC manual.
+This pragma specifies the wide character encoding to be used in program
+source text appearing subsequently. It is a configuration pragma, but may
+also be used at any point that a pragma is allowed, and it is permissible
+to have more than one such pragma in a file, allowing multiple encodings
+to appear within the same file.
+
+The argument can be an identifier or a character literal. In the identifier
+case, it is one of @code{HEX}, @code{UPPER}, @code{SHIFT_JIS},
+@code{EUC}, @code{UTF8}, or @code{BRACKETS}. In the character literal
+case it is correspondingly one of the characters h,u,s,e,8,b.
+
+Note that when the pragma is used within a file, it affects only the
+encoding within that file, and does not affect withed units, specs,
+or subunits.
@node Implementation Defined Attributes
@chapter Implementation Defined Attributes
-Ada 95 defines (throughout the Ada 95 reference manual,
-summarized in annex K),
+Ada defines (throughout the Ada reference manual,
+summarized in Annex K),
a set of attributes that provide useful additional functionality in all
areas of the language. These language defined attributes are implemented
-in GNAT and work as described in the Ada 95 Reference Manual.
+in GNAT and work as described in the Ada Reference Manual.
-In addition, Ada 95 allows implementations to define additional
+In addition, Ada allows implementations to define additional
attributes whose meaning is defined by the implementation. GNAT provides
a number of these implementation-dependent attributes which can be used
to extend and enhance the functionality of the compiler. This section of
* Elab_Body::
* Elab_Spec::
* Emax::
+* Enabled::
* Enum_Rep::
* Epsilon::
* Fixed_Value::
* Safe_Large::
* Small::
* Storage_Unit::
+* Stub_Type::
* Target_Name::
* Tick::
* To_Address::
@cindex Address of subprogram code
@noindent
The @code{'Address}
-attribute may be applied to subprograms in Ada 95, but the
-intended effect from the Ada 95 reference manual seems to be to provide
+attribute may be applied to subprograms in Ada 95 and Ada 2005, but the
+intended effect seems to be to provide
an address value which can be used to call the subprogram by means of
an address clause as in the following example:
@noindent
A call to @code{L} is then expected to result in a call to @code{K}@.
In Ada 83, where there were no access-to-subprogram values, this was
-a common work around for getting the effect of an indirect call.
+a common work-around for getting the effect of an indirect call.
GNAT implements the above use of @code{Address} and the technique
illustrated by the example code works correctly.
the Ada 83 reference manual for an exact description of the semantics of
this attribute.
+@node Enabled
+@unnumberedsec Enabled
+@findex Enabled
+@noindent
+The @code{Enabled} attribute allows an application program to check at compile
+time to see if the designated check is currently enabled. The prefix is a
+simple identifier, referencing any predefined check name (other than
+@code{All_Checks}) or a check name introduced by pragma Check_Name. If
+no argument is given for the attribute, the check is for the general state
+of the check, if an argument is given, then it is an entity name, and the
+check indicates whether an @code{Suppress} or @code{Unsuppress} has been
+given naming the entity (if not, then the argument is ignored).
+
+Note that instantiations inherit the check status at the point of the
+instantiation, so a useful idiom is to have a library package that
+introduces a check name with @code{pragma Check_Name}, and then contains
+generic packages or subprograms which use the @code{Enabled} attribute
+to see if the check is enabled. A user of this package can then issue
+a @code{pragma Suppress} or @code{pragma Unsuppress} before instantiating
+the package or subprogram, controlling whether the check will be present.
+
@node Enum_Rep
@unnumberedsec Enum_Rep
@cindex Representation of enums
or integer types. Note that if @code{Enum_Rep} is used on a modular
type whose upper bound exceeds the upper bound of the largest signed
integer type, and the argument is a variable, so that the universal
-integer calculation is done at run-time, then the call to @code{Enum_Rep}
+integer calculation is done at run time, then the call to @code{Enum_Rep}
may raise @code{Constraint_Error}.
@node Epsilon
@code{R2} will be only
8 bits (one byte), since @code{R2'Object_Size} has been set to 8.
+Although @code{Object_Size} does properly reflect the default object size
+value, it is not necessarily the case that all objects will be of this size
+in a case where it is not specified explicitly. The compiler is free to
+increase the size and alignment of stand alone objects to improve efficiency
+of the generated code and sometimes does so in the case of large composite
+objects. If the size of a stand alone object is critical to the
+application, it should be specified explicitly.
+
@node Passed_By_Reference
@unnumberedsec Passed_By_Reference
@cindex Parameters, when passed by reference
@cindex Ada 83 attributes
@findex Small
@noindent
-The @code{Small} attribute is defined in Ada 95 only for fixed-point types.
+The @code{Small} attribute is defined in Ada 95 (and Ada 2005) only for
+fixed-point types.
GNAT also allows this attribute to be applied to floating-point types
for compatibility with Ada 83. See
the Ada 83 reference manual for an exact description of the semantics of
@code{Standard'Storage_Unit} (@code{Standard} is the only permissible
prefix) provides the same value as @code{System.Storage_Unit}.
+@node Stub_Type
+@unnumberedsec Stub_Type
+@findex Stub_Type
+@noindent
+The GNAT implementation of remote access-to-classwide types is
+organized as described in AARM section E.4 (20.t): a value of an RACW type
+(designating a remote object) is represented as a normal access
+value, pointing to a "stub" object which in turn contains the
+necessary information to contact the designated remote object. A
+call on any dispatching operation of such a stub object does the
+remote call, if necessary, using the information in the stub object
+to locate the target partition, etc.
+
+For a prefix @code{T} that denotes a remote access-to-classwide type,
+@code{T'Stub_Type} denotes the type of the corresponding stub objects.
+
+By construction, the layout of @code{T'Stub_Type} is identical to that of
+type @code{RACW_Stub_Type} declared in the internal implementation-defined
+unit @code{System.Partition_Interface}. Use of this attribute will create
+an implicit dependency on this unit.
+
@node Target_Name
@unnumberedsec Target_Name
@findex Target_Name
construction of values of the floating-point attributes from the file
@file{ttypef.ads}, but may also be used by user programs.
+For example, the following program prints the first 50 digits of pi:
+
+@smallexample @c ada
+with Text_IO; use Text_IO;
+with Ada.Numerics;
+procedure Pi is
+begin
+ Put (Ada.Numerics.Pi'Universal_Literal_String);
+end;
+@end smallexample
+
@node Unrestricted_Access
@unnumberedsec Unrestricted_Access
@cindex @code{Access}, unrestricted
other implementations, the use of static chains for inner level
subprograms means that @code{Unrestricted_Access} applied to a
subprogram yields a value that can be called as long as the subprogram
-is in scope (normal Ada 95 accessibility rules restrict this usage).
+is in scope (normal Ada accessibility rules restrict this usage).
It is possible to use @code{Unrestricted_Access} for any type, but care
-must be excercised if it is used to create pointers to unconstrained
+must be exercised if it is used to create pointers to unconstrained
objects. In this case, the resulting pointer has the same scope as the
context of the attribute, and may not be returned to some enclosing
scope. For instance, a function cannot use @code{Unrestricted_Access}
@node Implementation Advice
@chapter Implementation Advice
@noindent
-The main text of the Ada 95 Reference Manual describes the required
-behavior of all Ada 95 compilers, and the GNAT compiler conforms to
+The main text of the Ada Reference Manual describes the required
+behavior of all Ada compilers, and the GNAT compiler conforms to
these requirements.
-In addition, there are sections throughout the Ada 95
-reference manual headed
-by the phrase ``implementation advice''. These sections are not normative,
-i.e.@: they do not specify requirements that all compilers must
+In addition, there are sections throughout the Ada Reference Manual headed
+by the phrase ``Implementation advice''. These sections are not normative,
+i.e., they do not specify requirements that all compilers must
follow. Rather they provide advice on generally desirable behavior. You
may wonder why they are not requirements. The most typical answer is
that they describe behavior that seems generally desirable, but cannot
be provided on all systems, or which may be undesirable on some systems.
As far as practical, GNAT follows the implementation advice sections in
-the Ada 95 Reference Manual. This chapter contains a table giving the
+the Ada Reference Manual. This chapter contains a table giving the
reference manual section number, paragraph number and several keywords
for each advice. Each entry consists of the text of the advice followed
by the GNAT interpretation of this advice. Most often, this simply says
Affects semantics
@item CPP_Constructor
Affects semantics
-@item CPP_Virtual
-Affects semantics
-@item CPP_Vtable
-Affects semantics
@item Debug
Affects semantics
@item Interface_Name
@code{Size} clause on a composite subtype should not affect the
internal layout of components.
@end cartouche
-Followed.
+Followed. But note that this can be overridden by use of the implementation
+pragma Implicit_Packing in the case of packed arrays.
@sp 1
@cartouche
the given hardware architecture should be provided directly in
@code{Interfaces}.
@end cartouche
-Followed. An additional package not defined
-in the Ada 95 Reference Manual is @code{Interfaces.CPP}, used
+Followed. An additional package not defined
+in the Ada Reference Manual is @code{Interfaces.CPP}, used
for interfacing to C++.
@sp 1
@noindent
In addition to the implementation dependent pragmas and attributes, and
-the implementation advice, there are a number of other features of Ada
-95 that are potentially implementation dependent. These are mentioned
-throughout the Ada 95 Reference Manual, and are summarized in annex M@.
+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@.
A requirement for conforming Ada compilers is that they provide
documentation describing how the implementation deals with each of these
You can use this chapter as a guide to minimizing implementation
dependent features in your programs if portability to other compilers
and other operating systems is an important consideration. The numbers
-in each section below correspond to the paragraph number in the Ada 95
+in each section below correspond to the paragraph number in the Ada
Reference Manual.
@sp 1
@end cartouche
@noindent
The first constraint on ordering is that it meets the requirements of
-chapter 10 of the Ada 95 Reference Manual. This still leaves some
+Chapter 10 of the Ada Reference Manual. This still leaves some
implementation dependent choices, which are resolved by first
-elaborating bodies as early as possible (i.e.@: in preference to specs
+elaborating bodies as early as possible (i.e., in preference to specs
where there is a choice), and second by evaluating the immediate with
clauses of a unit to determine the probably best choice, and
third by elaborating in alphabetical order of unit names
@item
@code{ppp} is the Process Id value as a decimal integer (this line is
-present only if the Process Id is non-zero). Currently we are
+present only if the Process Id is nonzero). Currently we are
not making use of this field.
@item
@strong{42}. Implementation-defined check names. See 11.5(27).
@end cartouche
@noindent
-No implementation-defined check names are supported.
+The implementation defined check name Alignment_Check controls checking of
+address clause values for proper alignment (that is, the address supplied
+must be consistent with the alignment of the type).
+
+In addition, a user program can add implementation-defined check names
+by means of the pragma Check_Name.
@sp 1
@cartouche
@end cartouche
@noindent
Unchecked conversion between types of the same size
-and results in an uninterpreted transmission of the bits from one type
+results in an uninterpreted transmission of the bits from one type
to the other. If the types are of unequal sizes, then in the case of
discrete types, a shorter source is first zero or sign extended as
necessary, and a shorter target is simply truncated on the left.
to ensure that the alignment requirements of the target are met, then
a pointer is constructed to the source value, and the result is obtained
by dereferencing this pointer after converting it to be a pointer to the
-target type.
+target type. Unchecked conversions where the target subtype is an
+unconstrained array are not permitted. If the target alignment is
+greater than the source alignment, then a copy of the result is
+made with appropriate alignment
@sp 1
@cartouche
where the certification protocol requires the use of short-circuit
(and then, or else) forms for all composite boolean operations.
+@item No_Dispatching_Calls
+@findex No_Dispatching_Calls
+This restriction ensures at compile time that the code generated by the
+compiler involves no dispatching calls. The use of this restriction allows the
+safe use of record extensions, classwide membership tests and other classwide
+features not involving implicit dispatching. This restriction ensures that
+the code contains no indirect calls through a dispatching mechanism. Note that
+this includes internally-generated calls created by the compiler, for example
+in the implementation of class-wide objects assignments. The
+membership test is allowed in the presence of this restriction, because its
+implementation requires no dispatching.
+This restriction is comparable to the official Ada restriction
+@code{No_Dispatch} except that it is a bit less restrictive in that it allows
+all classwide constructs that do not imply dispatching.
+The following example indicates constructs that violate this restriction.
+
+@smallexample
+package Pkg is
+ type T is tagged record
+ Data : Natural;
+ end record;
+ procedure P (X : T);
+
+ type DT is new T with record
+ More_Data : Natural;
+ end record;
+ procedure Q (X : DT);
+end Pkg;
+
+with Pkg; use Pkg;
+procedure Example is
+ procedure Test (O : T'Class) is
+ N : Natural := O'Size;-- Error: Dispatching call
+ C : T'Class := O; -- Error: implicit Dispatching Call
+ begin
+ if O in DT'Class then -- OK : Membership test
+ Q (DT (O)); -- OK : Type conversion plus direct call
+ else
+ P (O); -- Error: Dispatching call
+ end if;
+ end Test;
+
+ Obj : DT;
+begin
+ P (Obj); -- OK : Direct call
+ P (T (Obj)); -- OK : Type conversion plus direct call
+ P (T'Class (Obj)); -- Error: Dispatching call
+
+ Test (Obj); -- OK : Type conversion
+
+ if Obj in T'Class then -- OK : Membership test
+ null;
+ end if;
+end Example;
+@end smallexample
+
@item No_Dynamic_Attachment
@findex No_Dynamic_Attachment
This restriction ensures that there is no call to any of the operations
The parameter is a C null-terminated string representing a message to be
associated with the exception (typically the source location of the raise
- statement generated by the compiler). The Line parameter when non-zero
+ statement generated by the compiler). The Line parameter when nonzero
represents the line number in the source program where the raise occurs.
-@item No_Exception_Streams
-@findex No_Exception_Streams
+@item No_Exception_Propagation
+@findex No_Exception_Propagation
+This restriction guarantees that exceptions are never propagated to an outer
+subprogram scope). The only case in which an exception may be raised is when
+the handler is statically in the same subprogram, so that the effect of a raise
+is essentially like a goto statement. Any other raise statement (implicit or
+explicit) will be considered unhandled. Exception handlers are allowed, but may
+not contain an exception occurrence identifier (exception choice). In addition
+use of the package GNAT.Current_Exception is not permitted, and reraise
+statements (raise with no operand) are not permitted.
+
+@item No_Exception_Registration
+@findex No_Exception_Registration
This restriction ensures at compile time that no stream operations for
types Exception_Id or Exception_Occurrence are used. This also makes it
impossible to pass exceptions to or from a partition with this restriction
conditional. Note that this check does not include run time constraint
checks, which on some targets may generate implicit conditionals as
well. To control the latter, constraint checks can be suppressed in the
-normal manner.
+normal manner. Constructs generating implicit conditionals include comparisons
+of composite objects and the Max/Min attributes.
@item No_Implicit_Dynamic_Code
@findex No_Implicit_Dynamic_Code
This restriction prevents the compiler from building ``trampolines''.
This is a structure that is built on the stack and contains dynamic
-code to be executed at run time. A trampoline is needed to indirectly
-address a nested subprogram (that is a subprogram that is not at the
-library level). The restriction prevents the use of any of the
-attributes @code{Address}, @code{Access} or @code{Unrestricted_Access}
-being applied to a subprogram that is not at the library level.
+code to be executed at run time. On some targets, a trampoline is
+built for the following features: @code{Access},
+@code{Unrestricted_Access}, or @code{Address} of a nested subprogram;
+nested task bodies; primitive operations of nested tagged types.
+Trampolines do not work on machines that prevent execution of stack
+data. For example, on windows systems, enabling DEP (data execution
+protection) will cause trampolines to raise an exception.
@item No_Implicit_Loops
@findex No_Implicit_Loops
implicit @code{for} loops, either by modifying
the generated code where possible,
or by rejecting any construct that would otherwise generate an implicit
-@code{for} loop.
+@code{for} loop. If this restriction is active, it is possible to build
+large array aggregates with all static components without generating an
+intermediate temporary, and without generating a loop to initialize individual
+components..Otherwise, a loop is created for arrays larger than about 5000
+scalar components.
@item No_Initialize_Scalars
@findex No_Initialize_Scalars
except that violations are caught at compile time and cause an error message
to be output either by the compiler or binder.
-@item No_Wide_Characters
-@findex No_Wide_Characters
-This restriction ensures at compile time that no uses of the types
-@code{Wide_Character} or @code{Wide_String} or corresponding wide
-wide types
-appear, and that no wide or wide wide string or character literals
-appear in the program (that is literals representing characters not in
-type @code{Character}.
-
@item Static_Priorities
@findex Static_Priorities
This restriction ensures at compile time that all priority expressions
the case that preelaborable units will meet the restrictions, with
the exception of large aggregates initialized with an others_clause,
and exception declarations (which generate calls to a run-time
-registry procedure). Note that this restriction is enforced on
+registry procedure). This restriction is enforced on
a unit by unit basis, it need not be obeyed consistently
throughout a partition.
+In the case of aggregates with others, if the aggregate has a dynamic
+size, there is no way to eliminate the elaboration code (such dynamic
+bounds would be incompatible with @code{Preelaborate} in any case). If
+the bounds are static, then use of this restriction actually modifies
+the code choice of the compiler to avoid generating a loop, and instead
+generate the aggregate statically if possible, no matter how many times
+the data for the others clause must be repeatedly generated.
+
+It is not possible to precisely document
+the constructs which are compatible with this restriction, since,
+unlike most other restrictions, this is not a restriction on the
+source code, but a restriction on the generated object code. For
+example, if the source contains a declaration:
+
+@smallexample
+ Val : constant Integer := X;
+@end smallexample
+
+@noindent
+where X is not a static constant, it may be possible, depending
+on complex optimization circuitry, for the compiler to figure
+out the value of X at compile time, in which case this initialization
+can be done by the loader, and requires no initialization code. It
+is not possible to document the precise conditions under which the
+optimizer can figure this out.
+
+Note that this the implementation of this restriction requires full
+code generation. If it is used in conjunction with "semantics only"
+checking, then some cases of violations may be missed.
+
@item No_Entry_Queue
@findex No_Entry_Queue
This restriction is a declaration that any protected entry compiled in
@findex No_Implementation_Attributes
This restriction checks at compile time that no GNAT-defined attributes
are present. With this restriction, the only attributes that can be used
-are those defined in the Ada 95 Reference Manual.
+are those defined in the Ada Reference Manual.
@item No_Implementation_Pragmas
@findex No_Implementation_Pragmas
This restriction checks at compile time that no GNAT-defined pragmas
are present. With this restriction, the only pragmas that can be used
-are those defined in the Ada 95 Reference Manual.
+are those defined in the Ada Reference Manual.
@item No_Implementation_Restrictions
@findex No_Implementation_Restrictions
This restriction checks at compile time that no GNAT-defined restriction
identifiers (other than @code{No_Implementation_Restrictions} itself)
are present. With this restriction, the only other restriction identifiers
-that can be used are those defined in the Ada 95 Reference Manual.
+that can be used are those defined in the Ada Reference Manual.
+
+@item No_Wide_Characters
+@findex No_Wide_Characters
+This restriction ensures at compile time that no uses of the types
+@code{Wide_Character} or @code{Wide_String} or corresponding wide
+wide types
+appear, and that no wide or wide wide string or character literals
+appear in the program (that is literals representing characters not in
+type @code{Character}.
@end table
is to be passed by copy rather than reference.
@item COBOL
COBOL
-@item CPP
+@item C_Plus_Plus (or CPP)
C++
@item Default
Treated the same as C
attribute. See C.7.1(7).
@end cartouche
@noindent
-The result of this attribute is an 8-digit hexadecimal string
-representing the virtual address of the task control block.
-
+The result of this attribute is a string that identifies
+the object or component that denotes a given task. If a variable Var has a task
+type, the image for this task will have the form Var_XXXXXXXX, where the
+suffix
+is the hexadecimal representation of the virtual address of the corresponding
+task control block. If the variable is an array of tasks, the image of each
+task will have the form of an indexed component indicating the position of a
+given task in the array, eg. Group(5)_XXXXXXX. If the task is a
+component of a record, the image of the task will have the form of a selected
+component. These rules are fully recursive, so that the image of a task that
+is a subcomponent of a composite object corresponds to the expression that
+designates this task.
+@noindent
+If a task is created by an allocator, its image depends on the context. If the
+allocator is part of an object declaration, the rules described above are used
+to construct its image, and this image is not affected by subsequent
+assignments. If the allocator appears within an expression, the image
+includes only the name of the task type.
+@noindent
+If the configuration pragma Discard_Names is present, or if the restriction
+No_Implicit_Heap_Allocation is in effect, the image reduces to
+the numeric suffix, that is to say the hexadecimal representation of the
+virtual address of the control block of the task.
@sp 1
@cartouche
@noindent
@noindent
@c SGI info:
@ignore
-Tasks map to IRIX threads, and the dispatching policy is as defied by
+Tasks map to IRIX threads, and the dispatching policy is as defined by
the IRIX implementation of threads.
@end ignore
The policy is the same as that of the underlying threads implementation.
@end cartouche
@noindent
The ceiling priority of protected objects of the type
-@code{System.Interrupt_Priority'Last} as described in the Ada 95
+@code{System.Interrupt_Priority'Last} as described in the Ada
Reference Manual D.3(10),
@sp 1
@strong{101}. Implementation-defined queuing policies. See D.4(1).
@end cartouche
@noindent
-There are no implementation-defined queueing policies.
+There are no implementation-defined queuing policies.
@sp 1
@cartouche
result type is @code{False}. See G.2.1(13).
@end cartouche
@noindent
-Infinite and Nan values are produced as dictated by the IEEE
+Infinite and NaN values are produced as dictated by the IEEE
floating-point standard.
+Note that on machines that are not fully compliant with the IEEE
+floating-point standard, such as Alpha, the @option{-mieee} compiler flag
+must be used for achieving IEEE confirming behavior (although at the cost
+of a significant performance penalty), so infinite and NaN values are
+properly generated.
+
@sp 1
@cartouche
@noindent
@section Rotate_Left
@cindex Rotate_Left
@noindent
-In standard Ada 95, the @code{Rotate_Left} function is available only
+In standard Ada, the @code{Rotate_Left} function is available only
for the predefined modular types in package @code{Interfaces}. However, in
GNAT it is possible to define a Rotate_Left function for a user
defined modular type or any signed integer type as in this example:
@end itemize
@noindent
-An alignment clause may
-always specify a larger alignment than the default value, up to some
-maximum value dependent on the target (obtainable by using the
-attribute reference @code{Standard'Maximum_Alignment}).
-The only case where
-it is permissible to specify a smaller alignment than the default value
-is for a record with a record representation clause.
-In this case, packable fields for which a component clause is
-given still result in a default alignment corresponding to the original
-type, but this may be overridden, since these components in fact only
-require an alignment of one byte. For example, given
+An alignment clause may specify a larger alignment than the default value
+up to some maximum value dependent on the target (obtainable by using the
+attribute reference @code{Standard'Maximum_Alignment}). It may also specify
+a smaller alignment than the default value, for example
@smallexample @c ada
type V is record
A : Integer;
end record;
- for V use record
- A at 0 range 0 .. 31;
- end record;
-
for V'alignment use 1;
@end smallexample
@noindent
@cindex Alignment, default
The default alignment for the type @code{V} is 4, as a result of the
-Integer field in the record, but since this field is placed with a
-component clause, it is permissible, as shown, to override the default
-alignment of the record with a smaller value.
+Integer field in the record, but it is permissible, as shown, to
+override the default alignment of the record with a smaller value.
@node Size Clauses
@section Size Clauses
@noindent
Then @code{Default_Stack_Size} can be defined in a global package, and
-modified as required. Any tasks requiring stack sizes different from the
+modified as required. Any tasks requiring stack sizes different from the
default can have an appropriate alternative reference in the pragma.
+You can also use the @code{-d} binder switch to modify the default stack
+size.
+
For access types, the @code{Storage_Size} clause specifies the maximum
space available for allocation of objects of the type. If this space is
exceeded then @code{Storage_Error} will be raised by an allocation attempt.
@cindex Size, of objects
@noindent
-In Ada 95, @code{T'Size} for a type @code{T} is the minimum number of bits
-required to hold values of type @code{T}. Although this interpretation was
-allowed in Ada 83, it was not required, and this requirement in practice
-can cause some significant difficulties. For example, in most Ada 83
-compilers, @code{Natural'Size} was 32. However, in Ada 95,
+In Ada 95 and Ada 2005, @code{T'Size} for a type @code{T} is the minimum
+number of bits required to hold values of type @code{T}.
+Although this interpretation was allowed in Ada 83, it was not required,
+and this requirement in practice can cause some significant difficulties.
+For example, in most Ada 83 compilers, @code{Natural'Size} was 32.
+However, in Ada 95 and Ada 2005,
@code{Natural'Size} is
typically 31. This means that code may change in behavior when moving
-from Ada 83 to Ada 95. For example, consider:
+from Ada 83 to Ada 95 or Ada 2005. For example, consider:
@smallexample @c ada
type Rec is record;
@noindent
In the above code, since the typical size of @code{Natural} objects
is 32 bits and @code{Natural'Size} is 31, the above code can cause
-unexpected inefficient packing in Ada 95, and in general there are
-cases where the fact that the object size can exceed the
+unexpected inefficient packing in Ada 95 and Ada 2005, and in general
+there are cases where the fact that the object size can exceed the
size of the type causes surprises.
To help get around this problem GNAT provides two implementation
@end smallexample
@noindent
-Note: the entries marked ``3*'' are not actually specified by the Ada 95 RM,
-but it seems in the spirit of the RM rules to allocate the minimum number
-of bits (here 3, given the range for @code{x2})
+Note: the entries marked ``3*'' are not actually specified by the Ada
+Reference Manual, but it seems in the spirit of the RM rules to allocate
+the minimum number of bits (here 3, given the range for @code{x2})
known to be large enough to hold the given range of values.
So far, so good, but GNAT has to obey the RM rules, so the question is
@cindex Component_Size Clause
@noindent
-Normally, the value specified in a component clause must be consistent
+Normally, the value specified in a component size clause must be consistent
with the subtype of the array component with regard to size and alignment.
In other words, the value specified must be at least equal to the size
of this subtype, and must be a multiple of the alignment value.
Of course access to the components of such an array is considerably
less efficient than if the natural component size of 32 is used.
+Note that there is no point in giving both a component size clause
+and a pragma Pack for the same array type. if such duplicate
+clauses are given, the pragma Pack will be ignored.
+
@node Bit_Order Clauses
@section Bit_Order Clauses
@cindex Bit_Order Clause
and the size of the array @code{ar} will be exactly 40 bits.
Note that in some cases this rather fierce approach to packing can produce
-unexpected effects. For example, in Ada 95, type Natural typically has a
-size of 31, meaning that if you pack an array of Natural, you get 31-bit
+unexpected effects. For example, in Ada 95 and Ada 2005,
+subtype @code{Natural} typically has a size of 31, meaning that if you
+pack an array of @code{Natural}, you get 31-bit
close packing, which saves a few bits, but results in far less efficient
access. Since many other Ada compilers will ignore such a packing request,
GNAT will generate a warning on some uses of pragma @code{Pack} that it guesses
since typically @code{Natural'Size} is 32 in Ada 83, and in any case most
Ada 83 compilers did not attempt 31 bit packing.
-In Ada 95, @code{Natural'Size} is required to be 31. Furthermore, GNAT really
-does pack 31-bit subtype to 31 bits. This may result in a substantial
-unintended performance penalty when porting legacy Ada 83 code. To help
-prevent this, GNAT generates a warning in such cases. If you really want 31
-bit packing in a case like this, you can set the component size explicitly:
+In Ada 95 and Ada 2005, @code{Natural'Size} is required to be 31. Furthermore,
+GNAT really does pack 31-bit subtype to 31 bits. This may result in a
+substantial unintended performance penalty when porting legacy Ada 83 code.
+To help prevent this, GNAT generates a warning in such cases. If you really
+want 31 bit packing in a case like this, you can set the component size
+explicitly:
@smallexample @c ada
type Arr is array (1 .. 32) of Natural;
checks (at compile time if possible, generating a warning, or at execution
time with a run-time check) that the alignment is appropriate. If the
run-time check fails, then @code{Program_Error} is raised. This run-time
-check is suppressed if range checks are suppressed, or if
+check is suppressed if range checks are suppressed, or if the special GNAT
+check Alignment_Check is suppressed, or if
@code{pragma Restrictions (No_Elaboration_Code)} is in effect.
+Finally, GNAT does not permit overlaying of objects of controlled types or
+composite types containing a controlled component. In most cases, the compiler
+can detect an attempt at such overlays and will generate a warning at compile
+time and a Program_Error exception at run time.
+
@findex Export
An address clause cannot be given for an exported object. More
understandably the real restriction is that objects with an address
and @code{B} become aliased to one another via the
address clause. This use of address clauses to overlay
variables, achieving an effect similar to unchecked
-conversion was erroneous in Ada 83, but in Ada 95
+conversion was erroneous in Ada 83, but in Ada 95 and Ada 2005
the effect is implementation defined. Furthermore, the
-Ada 95 RM specifically recommends that in a situation
+Ada RM specifically recommends that in a situation
like this, @code{B} should be subject to the following
implementation advice (RM 13.3(19)):
consistent with C@. This means that specifying convention C (for example)
has no effect.
-There are three exceptions to this general rule:
+There are four exceptions to this general rule:
@itemize @bullet
Ada enumeration type, then the size is modified as necessary (usually to
32 bits) to be consistent with the C convention for enum values.
+Note that this treatment applies only to types. If Convention C is given for
+an enumeration object, where the enumeration type is not Convention C, then
+Object_Size bits are allocated. For example, for a normal enumeration type,
+with less than 256 elements, only 8 bits will be allocated for the object.
+Since this may be a surprise in terms of what C expects, GNAT will issue a
+warning in this situation. The warning can be suppressed by giving an explicit
+size clause specifying the desired size.
+
@item Convention C/Fortran and Boolean types
In C, the usual convention for boolean values, that is values used for
conditions, is that zero represents false, and nonzero values represent
values generated by GNAT, the conventional value 1 will be used for True, but
when one of these values is read, any nonzero value is treated as True.
+@item Access types on OpenVMS
+For 64-bit OpenVMS systems, access types (other than those for unconstrained
+arrays) are 64-bits long. An exception to this rule is for the case of
+C-convention access types where there is no explicit size clause present (or
+inherited for derived types). In this case, GNAT chooses to make these
+pointers 32-bits, which provides an easier path for migration of 32-bit legacy
+code. size clause specifying 64-bits must be used to obtain a 64-bit pointer.
+
@end itemize
@node Determining the Representations chosen by GNAT
@chapter Standard Library Routines
@noindent
-The Ada 95 Reference Manual contains in Annex A a full description of an
+The Ada Reference Manual contains in Annex A a full description of an
extensive set of standard library routines that can be used in any Ada
program, and which must be provided by all Ada compilers. They are
analogous to the standard C library used by C programs.
GNAT implements all of the facilities described in annex A, and for most
-purposes the description in the Ada 95
-reference manual, or appropriate Ada
+purposes the description in the Ada Reference Manual, or appropriate Ada
text book, will be sufficient for making use of these facilities.
-In the case of the input-output facilities, @xref{The Implementation of
-Standard I/O}, gives details on exactly how GNAT interfaces to the
-file system. For the remaining packages, the Ada 95 reference manual
+In the case of the input-output facilities,
+@xref{The Implementation of Standard I/O},
+gives details on exactly how GNAT interfaces to the
+file system. For the remaining packages, the Ada Reference Manual
should be sufficient. The following is a list of the packages included,
together with a brief description of the functionality that is provided.
For completeness, references are included to other predefined library
-routines defined in other sections of the Ada 95 reference manual (these are
-cross-indexed from annex A).
+routines defined in other sections of the Ada Reference Manual (these are
+cross-indexed from Annex A).
@table @code
@item Ada (A.2)
A pointer other than a pointer to an unconstrained array type may be
converted to and from System.Address. Such usage is common in Ada 83
programs, but note that Ada.Address_To_Access_Conversions is the
-preferred method of performing such conversions in Ada 95. Neither
+preferred method of performing such conversions in Ada 95 and Ada 2005.
+Neither
unchecked conversion nor Ada.Address_To_Access_Conversions should be
used in conjunction with pointers to unconstrained objects, since
the bounds information cannot be handled correctly in this case.
@noindent
GNAT implements all the required input-output facilities described in
-A.6 through A.14. These sections of the Ada 95 reference manual describe the
+A.6 through A.14. These sections of the Ada Reference Manual describe the
required behavior of these packages from the Ada point of view, and if
you are writing a portable Ada program that does not need to know the
exact manner in which Ada maps to the outside world when it comes to
reading or writing external files, then you do not need to read this
chapter. As long as your files are all regular files (not pipes or
devices), and as long as you write and read the files only from Ada, the
-description in the Ada 95 reference manual is sufficient.
+description in the Ada Reference Manual is sufficient.
However, if you want to do input-output to pipes or other devices, such
as the keyboard or screen, or if the files you are dealing with are
* Wide_Wide_Text_IO::
* Stream_IO::
* Shared Files::
+* Filenames encoding::
* Open Modes::
* Operations on C Streams::
* Interfacing to C Streams::
@end itemize
@noindent
-There is no internal buffering of any kind at the Ada library level. The
-only buffering is that provided at the system level in the
-implementation of the C library routines that support streams. This
-facilitates shared use of these streams by mixed language programs.
+There is no internal buffering of any kind at the Ada library level. The only
+buffering is that provided at the system level in the implementation of the
+library routines that support streams. This facilitates shared use of these
+streams by mixed language programs. Note though that system level buffering is
+explicitly enabled at elaboration of the standard I/O packages and that can
+have an impact on mixed language programs, in particular those using I/O before
+calling the Ada elaboration routine (e.g. adainit). It is recommended to call
+the Ada elaboration routine before performing any I/O or when impractical,
+flush the common I/O streams and in particular Standard_Output before
+elaborating the Ada code.
@node FORM Strings
@section FORM Strings
@smallexample
SHARED=[YES|NO]
-WCEM=[n|h|u|s\e]
+WCEM=[n|h|u|s|e|8|b]
@end smallexample
@noindent
clearly incorrect, since there is only one element in the file, and that
element is the string @code{hello!}.
-In Ada 95, this kind of behavior can be legitimately achieved using
-Stream_IO, and this is the preferred mechanism. In particular, the above
-program fragment rewritten to use Stream_IO will work correctly.
+In Ada 95 and Ada 2005, this kind of behavior can be legitimately achieved
+using Stream_IO, and this is the preferred mechanism. In particular, the
+above program fragment rewritten to use Stream_IO will work correctly.
@node Text_IO
@section Text_IO
the file unless an explicit @code{New_Page} operation was performed
before closing the file.
-A canonical Text_IO file that is a regular file, i.e.@: not a device or a
-pipe, can be read using any of the routines in Text_IO@. The
-semantics in this case will be exactly as defined in the Ada 95 reference
-manual and all the routines in Text_IO are fully implemented.
+A canonical Text_IO file that is a regular file (i.e., not a device or a
+pipe) can be read using any of the routines in Text_IO@. The
+semantics in this case will be exactly as defined in the Ada Reference
+Manual, and all the routines in Text_IO are fully implemented.
A text file that does not meet the requirements for a canonical Text_IO
file has one of the following:
e.g.@: @code{["C1"]} for lower case a. However, on output, brackets notation
is only used for wide characters with a code greater than @code{16#FF#}.
+Note that brackets coding is not normally used in the context of
+Wide_Text_IO or Wide_Wide_Text_IO, since it is really just designed as
+a portable way of encoding source files. In the context of Wide_Text_IO
+or Wide_Wide_Text_IO, it can only be used if the file does not contain
+any instance of the left bracket character other than to encode wide
+character values using the brackets encoding method. In practice it is
+expected that some standard wide character encoding method such
+as UTF-8 will be used for text input output.
+
+If brackets notation is used, then any occurrence of a left bracket
+in the input file which is not the start of a valid wide character
+sequence will cause Constraint_Error to be raised. It is possible to
+encode a left bracket as ["5B"] and Wide_Text_IO and Wide_Wide_Text_IO
+input will interpret this as a left bracket.
+
+However, when a left bracket is output, it will be output as a left bracket
+and not as ["5B"]. We make this decision because for normal use of
+Wide_Text_IO for outputting messages, it is unpleasant to clobber left
+brackets. For example, if we write:
+
+@smallexample
+ Put_Line ("Start of output [first run]");
+@end smallexample
+
+@noindent
+we really do not want to have the left bracket in this message clobbered so
+that the output reads:
+
+@smallexample
+ Start of output ["5B"]first run]
+@end smallexample
+
+@noindent
+In practice brackets encoding is reasonably useful for normal Put_Line use
+since we won't get confused between left brackets and wide character
+sequences in the output. But for input, or when files are written out
+and read back in, it really makes better sense to use one of the standard
+encoding methods such as UTF-8.
+
@end table
@noindent
-For the coding schemes other than Hex and Brackets encoding,
+For the coding schemes other than UTF-8, Hex, or Brackets encoding,
not all wide character
values can be represented. An attempt to output a character that cannot
be represented using the encoding scheme for the file causes
@noindent
A stream file is a sequence of bytes, where individual elements are
-written to the file as described in the Ada 95 reference manual. The type
+written to the file as described in the Ada Reference Manual. The type
@code{Stream_Element} is simply a byte. There are two ways to read or
write a stream file.
@section Shared Files
@noindent
-Section A.14 of the Ada 95 Reference Manual allows implementations to
+Section A.14 of the Ada Reference Manual allows implementations to
provide a wide variety of behavior if an attempt is made to access the
same external file with two or more internal files.
If the form parameter @samp{shared=yes} appears in the form string for
each of two or more files opened using the same full name, the same
stream is shared between these files, and the semantics are as described
-in Ada 95 Reference Manual, Section A.14.
+in Ada Reference Manual, Section A.14.
@end itemize
@noindent
One common use of file sharing in Ada 83 is the use of instantiations of
Sequential_IO on the same file with different types, to achieve
heterogeneous input-output. Although this approach will work in GNAT if
-@samp{shared=yes} is specified, it is preferable in Ada 95 to use Stream_IO
+@samp{shared=yes} is specified, it is preferable in Ada to use Stream_IO
for this purpose (using the stream attributes)
+@node Filenames encoding
+@section Filenames encoding
+
+@noindent
+An encoding form parameter can be used to specify the filename
+encoding @samp{encoding=@var{xxx}}.
+
+@itemize @bullet
+@item
+If the form parameter @samp{encoding=utf8} appears in the form string, the
+filename must be encoded in UTF-8.
+
+@item
+If the form parameter @samp{encoding=8bits} appears in the form
+string, the filename must be a standard 8bits string.
+@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.
+
@node Open Modes
@section Open Modes
* Ada.Text_IO.C_Streams (a-tiocst.ads)::
* Ada.Wide_Text_IO.C_Streams (a-wtcstr.ads)::
* Ada.Wide_Wide_Text_IO.C_Streams (a-ztcstr.ads)::
+* GNAT.Altivec (g-altive.ads)::
+* GNAT.Altivec.Conversions (g-altcon.ads)::
+* GNAT.Altivec.Vector_Operations (g-alveop.ads)::
+* GNAT.Altivec.Vector_Types (g-alvety.ads)::
+* GNAT.Altivec.Vector_Views (g-alvevi.ads)::
* GNAT.Array_Split (g-arrspl.ads)::
* GNAT.AWK (g-awk.ads)::
* GNAT.Bounded_Buffers (g-boubuf.ads)::
* GNAT.Bubble_Sort (g-bubsor.ads)::
* GNAT.Bubble_Sort_A (g-busora.ads)::
* GNAT.Bubble_Sort_G (g-busorg.ads)::
+* GNAT.Byte_Swapping (g-bytswa.ads)::
* GNAT.Calendar (g-calend.ads)::
* GNAT.Calendar.Time_IO (g-catiio.ads)::
* GNAT.CRC32 (g-crc32.ads)::
* GNAT.Regpat (g-regpat.ads)::
* GNAT.Secondary_Stack_Info (g-sestin.ads)::
* GNAT.Semaphores (g-semaph.ads)::
+* GNAT.SHA1 (g-sha1.ads)::
* GNAT.Signals (g-signal.ads)::
* GNAT.Sockets (g-socket.ads)::
* GNAT.Source_Info (g-souinf.ads)::
few modifications required for @code{Latin-9}
The provision of such a package
is specifically authorized by the Ada Reference Manual
-(RM A.3(27)).
+(RM A.3.3(27)).
@node Ada.Characters.Wide_Latin_1 (a-cwila1.ads)
@section @code{Ada.Characters.Wide_Latin_1} (@file{a-cwila1.ads})
types of the constants being @code{Wide_Character}
instead of @code{Character}. The provision of such a package
is specifically authorized by the Ada Reference Manual
-(RM A.3(27)).
+(RM A.3.3(27)).
@node Ada.Characters.Wide_Latin_9 (a-cwila9.ads)
@section @code{Ada.Characters.Wide_Latin_9} (@file{a-cwila1.ads})
types of the constants being @code{Wide_Character}
instead of @code{Character}. The provision of such a package
is specifically authorized by the Ada Reference Manual
-(RM A.3(27)).
+(RM A.3.3(27)).
@node Ada.Characters.Wide_Wide_Latin_1 (a-czila1.ads)
@section @code{Ada.Characters.Wide_Wide_Latin_1} (@file{a-czila1.ads})
types of the constants being @code{Wide_Wide_Character}
instead of @code{Character}. The provision of such a package
is specifically authorized by the Ada Reference Manual
-(RM A.3(27)).
+(RM A.3.3(27)).
@node Ada.Characters.Wide_Wide_Latin_9 (a-czila9.ads)
@section @code{Ada.Characters.Wide_Wide_Latin_9} (@file{a-czila9.ads})
types of the constants being @code{Wide_Wide_Character}
instead of @code{Character}. The provision of such a package
is specifically authorized by the Ada Reference Manual
-(RM A.3(27)).
+(RM A.3.3(27)).
@node Ada.Command_Line.Remove (a-colire.ads)
@section @code{Ada.Command_Line.Remove} (@file{a-colire.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 GNAT.Altivec (g-altive.ads)
+@section @code{GNAT.Altivec} (@file{g-altive.ads})
+@cindex @code{GNAT.Altivec} (@file{g-altive.ads})
+@cindex AltiVec
+
+@noindent
+This is the root package of the GNAT AltiVec binding. It provides
+definitions of constants and types common to all the versions of the
+binding.
+
+@node GNAT.Altivec.Conversions (g-altcon.ads)
+@section @code{GNAT.Altivec.Conversions} (@file{g-altcon.ads})
+@cindex @code{GNAT.Altivec.Conversions} (@file{g-altcon.ads})
+@cindex AltiVec
+
+@noindent
+This package provides the Vector/View conversion routines.
+
+@node GNAT.Altivec.Vector_Operations (g-alveop.ads)
+@section @code{GNAT.Altivec.Vector_Operations} (@file{g-alveop.ads})
+@cindex @code{GNAT.Altivec.Vector_Operations} (@file{g-alveop.ads})
+@cindex AltiVec
+
+@noindent
+This package exposes the Ada interface to the AltiVec operations on
+vector objects. A soft emulation is included by default in the GNAT
+library. The hard binding is provided as a separate package. This unit
+is common to both bindings.
+
+@node GNAT.Altivec.Vector_Types (g-alvety.ads)
+@section @code{GNAT.Altivec.Vector_Types} (@file{g-alvety.ads})
+@cindex @code{GNAT.Altivec.Vector_Types} (@file{g-alvety.ads})
+@cindex AltiVec
+
+@noindent
+This package exposes the various vector types part of the Ada binding
+to AltiVec facilities.
+
+@node GNAT.Altivec.Vector_Views (g-alvevi.ads)
+@section @code{GNAT.Altivec.Vector_Views} (@file{g-alvevi.ads})
+@cindex @code{GNAT.Altivec.Vector_Views} (@file{g-alvevi.ads})
+@cindex AltiVec
+
+@noindent
+This package provides public 'View' data types from/to which private
+vector representations can be converted via
+GNAT.Altivec.Conversions. This allows convenient access to individual
+vector elements and provides a simple way to initialize vector
+objects.
@node GNAT.Array_Split (g-arrspl.ads)
@section @code{GNAT.Array_Split} (@file{g-arrspl.ads})
if the procedures can be inlined, at the expense of duplicating code for
multiple instantiations.
+@node GNAT.Byte_Swapping (g-bytswa.ads)
+@section @code{GNAT.Byte_Swapping} (@file{g-bytswa.ads})
+@cindex @code{GNAT.Byte_Swapping} (@file{g-bytswa.ads})
+@cindex Byte swapping
+@cindex Endian
+
+@noindent
+General routines for swapping the bytes in 2-, 4-, and 8-byte quantities.
+Machine-specific implementations are available in some cases.
+
@node GNAT.Calendar (g-calend.ads)
@section @code{GNAT.Calendar} (@file{g-calend.ads})
@cindex @code{GNAT.Calendar} (@file{g-calend.ads})
@cite{Communications of the ACM}, Vol.@: 31 No.@: 8, pp.@: 1008-1013,
Aug.@: 1988. Sarwate, D.V@.
-@noindent
-Provides an extended capability for formatted output of time values with
-full user control over the format. Modeled on the GNU Date specification.
-
@node GNAT.Case_Util (g-casuti.ads)
@section @code{GNAT.Case_Util} (@file{g-casuti.ads})
@cindex @code{GNAT.Case_Util} (@file{g-casuti.ads})
@noindent
Provides access to information on the current exception that has been raised
-without the need for using the Ada-95 exception choice parameter specification
-syntax. This is particularly useful in simulating typical facilities for
+without the need for using the Ada 95 / Ada 2005 exception choice parameter
+specification syntax.
+This is particularly useful in simulating typical facilities for
obtaining information about exceptions provided by Ada 83 compilers.
@node GNAT.Debug_Pools (g-debpoo.ads)
for hexadecimal literals.
@node GNAT.Directory_Operations (g-dirope.ads)
-@section @code{GNAT.Directory_Operations} (g-dirope.ads)
-@cindex @code{GNAT.Directory_Operations} (g-dirope.ads)
+@section @code{GNAT.Directory_Operations} (@file{g-dirope.ads})
+@cindex @code{GNAT.Directory_Operations} (@file{g-dirope.ads})
@cindex Directory operations
@noindent
probe (perfect property). The hash table size corresponds to the exact
size of the key set and no larger (minimal property). The key set has to
be know in advance (static property). The hash functions are also order
-preservering. If w2 is inserted after w1 in the generator, their
+preserving. If w2 is inserted after w1 in the generator, their
hashcode are in the same order. These hashing functions are very
convenient for use with realtime applications.
@noindent
Provides classic counting and binary semaphores using protected types.
+@node GNAT.SHA1 (g-sha1.ads)
+@section @code{GNAT.SHA1} (@file{g-sha1.ads})
+@cindex @code{GNAT.SHA1} (@file{g-sha1.ads})
+@cindex Secure Hash Algorithm SHA-1
+
+@noindent
+Implements the SHA-1 Secure Hash Algorithm as described in RFC 3174.
+
@node GNAT.Signals (g-signal.ads)
@section @code{GNAT.Signals} (@file{g-signal.ads})
@cindex @code{GNAT.Signals} (@file{g-signal.ads})
@cindex Threads, foreign
@noindent
-Provides facilities for creating and destroying threads with explicit calls.
-These threads are known to the GNAT run-time system. These subprograms are
-exported C-convention procedures intended to be called from foreign code.
-By using these primitives rather than directly calling operating systems
-routines, compatibility with the Ada tasking run-time is provided.
+Provides facilities for dealing with foreign threads which need to be known
+by the GNAT run-time system. Consult the documentation of this package for
+further details if your program has threads that are created by a non-Ada
+environment which then accesses Ada code.
@node GNAT.Traceback (g-traceb.ads)
@section @code{GNAT.Traceback} (@file{g-traceb.ads})
@noindent
Provides symbolic traceback information that includes the subprogram
-name and line number information.
+name and line number information. Note that this capability is not available
+on all targets, see g-trasym.ads for list of supported targets.
@node GNAT.Wide_String_Split (g-wistsp.ads)
@section @code{GNAT.Wide_String_Split} (@file{g-wistsp.ads})
@node System.Partition_Interface (s-parint.ads)
@section @code{System.Partition_Interface} (@file{s-parint.ads})
@cindex @code{System.Partition_Interface} (@file{s-parint.ads})
-@cindex Partition intefacing functions
+@cindex Partition interfacing functions
@noindent
This package provides facilities for partition interfacing. It
@cindex Run-time restrictions access
@noindent
-This package provides facilities for accessing at run-time
+This package provides facilities for accessing at run time
the status of restrictions specified at compile time for
the partition. Information is available both with regard
to actual restrictions specified, and with regard to
@node Interfacing to Other Languages
@chapter Interfacing to Other Languages
@noindent
-The facilities in annex B of the Ada 95 Reference Manual are fully
+The facilities in annex B of the Ada Reference Manual are fully
implemented in GNAT, and in addition, a full interface to C++ is
provided.
generator tool is supplied with GNAT though.
Using these pragmas it is possible to achieve complete
-inter-operability between Ada tagged types and C class definitions.
+inter-operability between Ada tagged types and C++ class definitions.
See @ref{Implementation Defined Pragmas}, for more details.
@table @code
-@item pragma CPP_Class ([Entity =>] @var{local_name})
+@item pragma CPP_Class ([Entity =>] @var{local_NAME})
The argument denotes an entity in the current declarative region that is
-declared as a tagged or untagged record type. It indicates that the type
+declared as a tagged or untagged 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.
-@item pragma CPP_Constructor ([Entity =>] @var{local_name})
+Note: Pragma @code{CPP_Class} is currently obsolete. It is supported
+for backward compatibility but its functionality is available
+using pragma @code{Import} with @code{Convention} = @code{CPP}.
+
+@item pragma CPP_Constructor ([Entity =>] @var{local_NAME})
This pragma identifies an imported function (imported in the usual way
with pragma @code{Import}) as corresponding to a C++ constructor.
-
-@item pragma CPP_Vtable @dots{}
-One @code{CPP_Vtable} pragma can be present for each component of type
-@code{CPP.Interfaces.Vtable_Ptr} in a record to which pragma @code{CPP_Class}
-applies.
@end table
@node Interfacing to COBOL
@noindent
Interfacing to COBOL is achieved as described in section B.4 of
-the Ada 95 reference manual.
+the Ada Reference Manual.
@node Interfacing to Fortran
@section Interfacing to Fortran
@noindent
Interfacing to Fortran is achieved as described in section B.5 of the
-reference manual. The pragma @code{Convention Fortran}, applied to a
+Ada Reference Manual. The pragma @code{Convention Fortran}, applied to a
multi-dimensional array causes the array to be stored in column-major
order as required for convenient interface to Fortran.
It is possible to specify the convention @code{Ada} in a pragma
@code{Import} or pragma @code{Export}. However this refers to
the calling conventions used by GNAT, which may or may not be
-similar enough to those used by some other Ada 83 or Ada 95
+similar enough to those used by some other Ada 83 / Ada 95 / Ada 2005
compiler to allow interoperation.
If arguments types are kept simple, and if the foreign compiler generally
@chapter Specialized Needs Annexes
@noindent
-Ada 95 defines a number of specialized needs annexes, which are not
+Ada 95 and Ada 2005 define a number of Specialized Needs Annexes, which are not
required in all implementations. However, as described in this chapter,
-GNAT implements all of these special needs annexes:
+GNAT implements all of these annexes:
@table @asis
@item Systems Programming (Annex C)
@item Numerics (Annex G)
The Numerics Annex is fully implemented.
-@item Safety and Security (Annex H)
-The Safety and Security annex is fully implemented.
+@item Safety and Security / High-Integrity Systems (Annex H)
+The Safety and Security Annex (termed the High-Integrity Systems Annex
+in Ada 2005) is fully implemented.
@end table
@node Implementation of Specific Ada Features
* GNAT Implementation of Shared Passive Packages::
* Code Generation for Array Aggregates::
* The Size of Discriminated Records with Default Discriminants::
+* Strict Conformance to the Ada Reference Manual::
@end menu
@node Machine Code Insertions
@section Machine Code Insertions
+@cindex Machine Code insertions
@noindent
Package @code{Machine_Code} provides machine code support as described
-in the Ada 95 Reference Manual in two separate forms:
+in the Ada Reference Manual in two separate forms:
@itemize @bullet
@item
Machine code statements, consisting of qualified expressions that
and use of the facilities in this package requires understanding the asm
instruction as described in @cite{Using the GNU Compiler Collection (GCC)}
by Richard Stallman. The relevant section is titled ``Extensions to the C
-Language Family'' -> ``Assembler Instructions with C Expression Operands''.
+Language Family'' @result{} ``Assembler Instructions with C Expression
+Operands''.
Calls to the function @code{Asm} and the procedure @code{Asm} have identical
semantic restrictions and effects as described below. Both are provided so
suppressed, and that in particular, for an instruction that has outputs,
the instruction will still be generated, even if none of the outputs are
used. See the full description in the GCC manual for further details.
+Generally it is strongly advisable to use Volatile for any ASM statement
+that is missing either input or output operands, or when two or more ASM
+statements appear in sequence, to avoid unwanted optimizations. A warning
+is generated if this advice is not followed.
The @code{Asm} subprograms may be used in two ways. First the procedure
forms can be used anywhere a procedure call would be valid, and
@menu
* Static constant aggregates with static bounds::
-* Constant aggregates with an unconstrained nominal types::
+* Constant aggregates with unconstrained nominal types::
* Aggregates with static bounds::
* Aggregates with non-static bounds::
* Aggregates in assignment statements::
@end menu
@noindent
-Aggregate have a rich syntax and allow the user to specify the values of
+Aggregates have a rich syntax and allow the user to specify the values of
complex data structures by means of a single construct. As a result, the
code generated for aggregates can be quite complex and involve loops, case
statements and multiple assignments. In the simplest cases, however, the
compiler will recognize aggregates whose components and constraints are
fully static, and in those cases the compiler will generate little or no
executable code. The following is an outline of the code that GNAT generates
-for various aggregate constructs. For further details, the user will find it
+for various aggregate constructs. For further details, you will find it
useful to examine the output produced by the -gnatG flag to see the expanded
-source that is input to the code generator. The user will also want to examine
+source that is input to the code generator. You may also want to examine
the assembly code generated at various levels of optimization.
The code generated for aggregates depends on the context, the component values,
For the declarations:
@smallexample @c ada
type One_Dim is array (1..10) of integer;
- ar0 : constant One_Dim := ( 1, 2, 3, 4, 5, 6, 7, 8, 9, 0);
+ ar0 : constant One_Dim := (1, 2, 3, 4, 5, 6, 7, 8, 9, 0);
@end smallexample
@noindent
The same is true for constant aggregates with named associations:
@smallexample @c ada
- Cr1 : constant One_Dim := (4 => 16, 2 => 4, 3 => 9, 1=> 1);
+ Cr1 : constant One_Dim := (4 => 16, 2 => 4, 3 => 9, 1 => 1, 5 .. 10 => 0);
Cr3 : constant One_Dim := (others => 7777);
@end smallexample
Zero2: constant two_dim := (others => (others => 0));
@end smallexample
-@node Constant aggregates with an unconstrained nominal types
-@subsection Constant aggregates with an unconstrained nominal types
+@node Constant aggregates with unconstrained nominal types
+@subsection Constant aggregates with unconstrained nominal types
@noindent
In such cases the aggregate itself establishes the subtype, so that
object. The declarations
@smallexample @c ada
- Cr_Var1 : One_Dim := (2, 5, 7, 11);
+ Cr_Var1 : One_Dim := (2, 5, 7, 11, 0, 0, 0, 0, 0, 0);
Cr_Var2 : One_Dim := (others > -1);
@end smallexample
would have
been stored as a pointer to a dynamic string). Following the principle that
dynamic storage management should never be introduced implicitly,
-an Ada95 compiler should reserve the full size for an unconstrained declared
+an Ada compiler should reserve the full size for an unconstrained declared
object, and place it on the stack.
This maximum size approach
say) must be consistent, so it is imperative that the object, once created,
remain invariant.
+@node Strict Conformance to the Ada Reference Manual
+@section Strict Conformance to the Ada Reference Manual
+
+@noindent
+The dynamic semantics defined by the Ada Reference Manual impose a set of
+run-time checks to be generated. By default, the GNAT compiler will insert many
+run-time checks into the compiled code, including most of those required by the
+Ada Reference Manual. However, there are three checks that are not enabled
+in the default mode for efficiency reasons: arithmetic overflow checking for
+integer operations (including division by zero), checks for access before
+elaboration on subprogram calls, and stack overflow checking (most operating
+systems do not perform this check by default).
+
+Strict conformance to the Ada Reference Manual can be achieved by adding
+three compiler options for overflow checking for integer operations
+(@option{-gnato}), dynamic checks for access-before-elaboration on subprogram
+calls and generic instantiations (@option{-gnatE}), and stack overflow
+checking (@option{-fstack-check}).
+Note that the result of a floating point arithmetic operation in overflow and
+invalid situations, when the @code{Machine_Overflows} attribute of the result
+type is @code{False}, is to generate IEEE NaN and infinite values. This is the
+case for machines compliant with the IEEE floating-point standard, but on
+machines that are not fully compliant with this standard, such as Alpha, the
+@option{-mieee} compiler flag must be used for achieving IEEE confirming
+behavior (although at the cost of a significant performance penalty), so
+infinite and and NaN values are properly generated.
@node Project File Reference
@section Reserved Words
@noindent
-All Ada95 reserved words are reserved in project files, and cannot be used
+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:
@section Lexical Elements
@noindent
-Rules for identifiers are the same as in Ada95. Identifiers
+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 Ada95.
+Comments have the same form as in Ada.
@noindent
Syntax:
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
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
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, and must be writable.
+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.
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.
Expression must be a string list. Each string designates
a programming language that is known to GNAT. The strings are case-insensitive.
-@item Locally_Removed_Files
-This attribute is legal only in a project file that extends another.
-Expression must be a list of strings that are legal file names.
-Each file name must designate a source that would normally be 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.
@end table
@node Attribute References
@section Case Construction
@noindent
-A case construction supports attribute declarations that depend on the value of
-a previously declared variable.
+A case construction supports attribute and variable declarations that depend
+on the value of a previously declared variable.
Syntax:
@smallexample
case_item ::=
@b{when} discrete_choice_list =>
- @{case_construction | attribute_declaration | empty_declaration@}
+ @{case_construction |
+ attribute_declaration |
+ variable_declaration |
+ empty_declaration@}
discrete_choice_list ::=
string_literal @{| string_literal@} |
@end smallexample
@noindent
+Inside a case construction, variable declarations must be for variables that
+have already been declared before the case construction.
+
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}
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..
+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
-settings specified by Default_Switches.
+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.
-
-@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.
@end table
@subsection package Builder
@table @code
@item Default_Switches
-As above.
+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
-As above.
+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
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, defined over
-compilation unit names. The image is a string that is the name of the
-executable file corresponding to the main source file index.
+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 a suffix to be added to
+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
@table @code
@item Switches
-As above.
+This is a single attribute with a string list value. Each non empty string
+in the list is an option when invoking @code{gnatls}.
@end table
@subsection package Binder
@table @code
@item Default_Switches
-As above.
-@item Switches
-As above.
+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
@table @code
@item Default_Switches
-As above
-@item Switches
-As above.
+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.
+
@end table
@subsection package Cross_Reference
@table @code
@item Default_Switches
-As above.
-@item Switches
-As above.
+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
@table @code
@item Default_Switches
-As above.
-@item Switches
-As above.
+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
@table @code
@item Default_switches
-As above.
-@item Switches
-As above.
+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
+
+@subsection package gnatstub
+
+@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}:
+
+@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
+
+@subsection package Eliminate
+
+@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}:
+
+@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
+
+@subsection package Metrics
+
+@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}:
+
+@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
@subsection package IDE
predefined path; e.g., @code{"gnatls"}, @code{"powerpc-wrs-vxworks-gnatls"}.
@item VCS_Kind
-This is a simple atribute. Is value is a string used to specify the
+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.
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
@node Package Renamings
OSDN Git Service
