@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, 2008 Free Software Foundation, Inc.
Permission is granted to copy, distribute and/or modify this document
under the terms of the GNU Free Documentation License, Version 1.2
@end copying
@titlepage
-
@title GNAT Reference Manual
-@subtitle GNAT, The GNU Ada 95 Compiler
-@subtitle GCC version @value{version-GCC}
+@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
* 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 Extend_System::
* Pragma External::
* Pragma External_Name_Casing::
+* Pragma Fast_Math::
+* Pragma Favor_Top_Level::
* Pragma Finalize_Storage_Only::
* Pragma Float_Representation::
* Pragma Ident::
+* Pragma Implemented_By_Entry::
+* Pragma Implicit_Packing::
* Pragma Import_Exception::
* Pragma Import_Function::
* Pragma Import_Object::
* 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 Optimize_Alignment::
* Pragma Passive::
* Pragma Persistent_BSS::
* Pragma Polling::
* Pragma Psect_Object::
* Pragma Pure_Function::
* Pragma Restriction_Warnings::
+* Pragma Shared::
* Pragma Source_File_Name::
* Pragma Source_File_Name_Project::
* Pragma Source_Reference::
* 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 Unmodified::
* 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::
* Mechanism_Code::
* Null_Parameter::
* Object_Size::
+* Old::
* Passed_By_Reference::
+* Pool_Address::
* Range_Length::
* Safe_Emax::
* 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.Characters.Latin_9 (a-chlat9.ads)::
* Ada.Characters.Wide_Latin_1 (a-cwila1.ads)::
* Ada.Characters.Wide_Latin_9 (a-cwila9.ads)::
-* Ada.Characters.Wide_Wide_Latin_1 (a-czila1.ads)::
-* Ada.Characters.Wide_Wide_Latin_9 (a-czila9.ads)::
-* Ada.Command_Line.Remove (a-colire.ads)::
+* Ada.Characters.Wide_Wide_Latin_1 (a-chzla1.ads)::
+* Ada.Characters.Wide_Wide_Latin_9 (a-chzla9.ads)::
* Ada.Command_Line.Environment (a-colien.ads)::
+* Ada.Command_Line.Remove (a-colire.ads)::
+* Ada.Command_Line.Response_File (a-clrefi.ads)::
* Ada.Direct_IO.C_Streams (a-diocst.ads)::
* Ada.Exceptions.Is_Null_Occurrence (a-einuoc.ads)::
+* Ada.Exceptions.Last_Chance_Handler (a-elchha.ads)::
* Ada.Exceptions.Traceback (a-exctra.ads)::
* Ada.Sequential_IO.C_Streams (a-siocst.ads)::
* Ada.Streams.Stream_IO.C_Streams (a-ssicst.ads)::
* Ada.Strings.Wide_Unbounded.Wide_Text_IO (a-swuwti.ads)::
* Ada.Strings.Wide_Wide_Unbounded.Wide_Wide_Text_IO (a-szuzti.ads)::
* Ada.Text_IO.C_Streams (a-tiocst.ads)::
+* Ada.Wide_Characters.Unicode (a-wichun.ads)::
* Ada.Wide_Text_IO.C_Streams (a-wtcstr.ads)::
+* Ada.Wide_Wide_Characters.Unicode (a-zchuni.ads)::
* Ada.Wide_Wide_Text_IO.C_Streams (a-ztcstr.ads)::
* GNAT.Altivec (g-altive.ads)::
* GNAT.Altivec.Conversions (g-altcon.ads)::
* GNAT.Bubble_Sort (g-bubsor.ads)::
* GNAT.Bubble_Sort_A (g-busora.ads)::
* GNAT.Bubble_Sort_G (g-busorg.ads)::
+* GNAT.Byte_Order_Mark (g-byorma.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.Current_Exception (g-curexc.ads)::
* GNAT.Debug_Pools (g-debpoo.ads)::
* GNAT.Debug_Utilities (g-debuti.ads)::
+* GNAT.Decode_String (g-decstr.ads)::
+* GNAT.Decode_UTF8_String (g-deutst.ads)::
* GNAT.Directory_Operations (g-dirope.ads)::
+* GNAT.Directory_Operations.Iteration (g-diopit.ads)::
* GNAT.Dynamic_HTables (g-dynhta.ads)::
* GNAT.Dynamic_Tables (g-dyntab.ads)::
+* GNAT.Encode_String (g-encstr.ads)::
+* GNAT.Encode_UTF8_String (g-enutst.ads)::
* GNAT.Exception_Actions (g-excact.ads)::
* GNAT.Exception_Traces (g-exctra.ads)::
* GNAT.Exceptions (g-except.ads)::
* GNAT.Most_Recent_Exception (g-moreex.ads)::
* GNAT.OS_Lib (g-os_lib.ads)::
* GNAT.Perfect_Hash_Generators (g-pehage.ads)::
+* GNAT.Random_Numbers (g-rannum.ads)::
* GNAT.Regexp (g-regexp.ads)::
* GNAT.Registry (g-regist.ads)::
* GNAT.Regpat (g-regpat.ads)::
* GNAT.Secondary_Stack_Info (g-sestin.ads)::
* GNAT.Semaphores (g-semaph.ads)::
+* GNAT.Serial_Communications (g-sercom.ads)::
+* GNAT.SHA1 (g-sha1.ads)::
* GNAT.Signals (g-signal.ads)::
* GNAT.Sockets (g-socket.ads)::
* GNAT.Source_Info (g-souinf.ads)::
-* GNAT.Spell_Checker (g-speche.ads)::
+* GNAT.Spelling_Checker (g-speche.ads)::
+* GNAT.Spelling_Checker_Generic (g-spchge.ads)::
* GNAT.Spitbol.Patterns (g-spipat.ads)::
* GNAT.Spitbol (g-spitbo.ads)::
* GNAT.Spitbol.Table_Boolean (g-sptabo.ads)::
* GNAT.Threads (g-thread.ads)::
* GNAT.Traceback (g-traceb.ads)::
* GNAT.Traceback.Symbolic (g-trasym.ads)::
+* GNAT.UTF_32 (g-utf_32.ads)::
+* GNAT.UTF_32_Spelling_Checker (g-u3spch.ads)::
+* GNAT.Wide_Spelling_Checker (g-wispch.ads)::
* GNAT.Wide_String_Split (g-wistsp.ads)::
+* GNAT.Wide_Wide_Spelling_Checker (g-zspche.ads)::
* GNAT.Wide_Wide_String_Split (g-zistsp.ads)::
* Interfaces.C.Extensions (i-cexten.ads)::
* Interfaces.C.Streams (i-cstrea.ads)::
* Interfaces.CPP (i-cpp.ads)::
-* Interfaces.Os2lib (i-os2lib.ads)::
-* Interfaces.Os2lib.Errors (i-os2err.ads)::
-* Interfaces.Os2lib.Synchronization (i-os2syn.ads)::
-* Interfaces.Os2lib.Threads (i-os2thr.ads)::
* Interfaces.Packed_Decimal (i-pacdec.ads)::
* Interfaces.VxWorks (i-vxwork.ads)::
* Interfaces.VxWorks.IO (i-vxwoio.ads)::
* System.Assertions (s-assert.ads)::
* System.Memory (s-memory.ads)::
* System.Partition_Interface (s-parint.ads)::
+* System.Pool_Global (s-pooglo.ads)::
+* System.Pool_Local (s-pooloc.ads)::
* System.Restrictions (s-restri.ads)::
* System.Rident (s-rident.ads)::
* System.Task_Info (s-tasinf.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 95 Reference Manual::
+* 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 @ref{Compiling Different Versions of Ada,,, gnat_ugn,
+@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
@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
@code{Option flags}
@item
-@file{File Names}, @samp{button names}, and @samp{field names}.
+@file{File names}, @samp{button names}, and @samp{field names}.
@item
-@code{Variables}.
+@code{Variables}, @env{environment variables}, and @var{metasyntactic
+variables}.
@item
@emph{Emphasis}.
@itemize @bullet
@item
-@cite{GNAT User's Guide}, which provides information on how to use
-the GNAT compiler system.
+@xref{Top, @value{EDITION} User's Guide, About This Guide, gnat_ugn,
+@value{EDITION} User's Guide}, which provides information on how to use the
+GNAT compiler system.
@item
@cite{Ada 95 Reference Manual}, which contains all reference
@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
+of these implementation-defined pragmas, which can be used to extend
and enhance the functionality of the compiler. This section of the GNAT
Reference Manual describes these additional pragmas.
-Note that any program using these pragmas may not be portable to other
+Note that any program using these pragmas might not be portable to other
compilers (although GNAT implements this set of pragmas on all
platforms). Therefore if portability to other compilers is an important
consideration, the use of these pragmas should be minimized.
* 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 Extend_System::
* Pragma External::
* Pragma External_Name_Casing::
+* Pragma Fast_Math::
+* Pragma Favor_Top_Level::
* Pragma Finalize_Storage_Only::
* Pragma Float_Representation::
* Pragma Ident::
+* Pragma Implemented_By_Entry::
+* Pragma Implicit_Packing::
* Pragma Import_Exception::
* Pragma Import_Function::
* Pragma Import_Object::
* 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 Optimize_Alignment::
* Pragma Passive::
* Pragma Persistent_BSS::
* Pragma Polling::
* Pragma Psect_Object::
* Pragma Pure_Function::
* Pragma Restriction_Warnings::
+* Pragma Shared::
* Pragma Source_File_Name::
* Pragma Source_File_Name_Project::
* Pragma Source_Reference::
* 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 Unmodified::
* 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
@noindent
This pragma is used to annotate programs. @var{identifier} identifies
-the type of annotation. GNAT verifies this is an identifier, but does
+the type of annotation. GNAT verifies that it is an identifier, but does
not otherwise analyze it. The @var{arg} argument
can be either a string literal or an
expression. String literals are assumed to be of type
type of the expression is either @code{Standard.Boolean}, or any type derived
from this standard type.
-If assertions are disabled (switch @code{-gnata} not used), then there
-is no effect (and in particular, any side effects from the expression
-are suppressed). More precisely it is not quite true that the pragma
-has no effect, since the expression is analyzed, and may cause types
-to be frozen if they are mentioned here for the first time.
+If assertions are disabled (switch @option{-gnata} not used), then there
+is no run-time effect (and in particular, any side effects from the
+expression will not occur at run time). (The expression is still
+analyzed at compile time, and may cause types to be frozen if they are
+mentioned here for the first time).
If assertions are enabled, then the given expression is tested, and if
it is @code{False} then @code{System.Assertions.Raise_Assert_Failure} is called
which results in the raising of @code{Assert_Failure} with the given message.
-If the boolean expression has side effects, these side effects will turn
-on and off with the setting of the assertions mode, resulting in
-assertions that have an effect on the program. You should generally
-avoid side effects in the expression arguments of this pragma. However,
-the expressions are analyzed for semantic correctness whether or not
-assertions are enabled, so turning assertions on and off cannot affect
-the legality of a program.
+You should generally avoid side effects in the expression arguments of
+this pragma, because these side effects will turn on and off with the
+setting of the assertions mode, resulting in assertions that have an
+effect on the program. However, the expressions are analyzed for
+semantic correctness whether or not assertions are enabled, so turning
+assertions on and off cannot affect the legality of a program.
@node Pragma Ast_Entry
@unnumberedsec Pragma Ast_Entry
@itemize @bullet
@item
-The size of the record type does not exceed@*@var{static_integer_expression}.
+The size of the record type does not exceed the value specified for
+@code{Max_Size}.
@item
The record type has @code{Convention C}.
@item
@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 that 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).
+
@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
+of fields. The @var{Size} argument
is syntax checked in GNAT, but otherwise ignored.
@code{Common_Object} is not supported on all platforms. If no
indicating that the necessary attribute for implementation of this
pragma is not available.
-@node Pragma Compile_Time_Warning
-@unnumberedsec Pragma Compile_Time_Warning
-@findex Compile_Time_Warning
+@node Pragma Compile_Time_Error
+@unnumberedsec Pragma Compile_Time_Error
+@findex Compile_Time_Error
@noindent
Syntax:
@smallexample @c ada
-pragma Compile_Time_Warning
+pragma Compile_Time_Error
(boolean_EXPRESSION, static_string_EXPRESSION);
@end smallexample
@noindent
-This pragma can be used to generate additional compile time warnings. It
-is particularly useful in generics, where warnings can be issued for
+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
+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, a warning message is generated using
+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
+@noindent
+Syntax:
+
+@smallexample @c ada
+pragma Compile_Time_Warning
+ (boolean_EXPRESSION, static_string_EXPRESSION);
+@end smallexample
+
+@noindent
+Same as pragma Compile_Time_Error, except a warning is issued instead
+of an error message. Note that if this pragma is used in a package that
+is with'ed by a client, the client will get the warning even though it
+is issued by a with'ed package (normally warnings in with'ed units are
+suppressed, but this is a special exception to that rule).
+
+One typical use is within a generic where compile time known characteristics
+of formal parameters are tested, and warnings given appropriately. Another use
+with a first parameter of True is to warn a client about use of a package,
+for example that it is not fully implemented.
+
@node Pragma Complete_Representation
@unnumberedsec Pragma Complete_Representation
@findex Complete_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:
-
-@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.
+This pragma is now obsolete has has no effect because GNAT generates
+the same object layout than the G++ compiler.
-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:
-
-@smallexample @c ada
-pragma CPP_Vtable (
- [Entity =>] ENTITY,
- [Vtable_Ptr =>] vtable_ENTITY,
- [Entry_Count =>] static_integer_EXPRESSION);
-@end smallexample
+This pragma is now obsolete has has no effect because GNAT generates
+the same object layout than the G++ compiler.
-@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
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}
+pragmas can be enabled either by use of the command line switch @option{-gnata}
or by use of the configuration pragma @code{Debug_Policy}.
@node Pragma Debug_Policy
@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
+This pragma overrides the effect of the @option{-gnata} switch on the
command line.
@node Pragma Detect_Blocking
pragma. If the parameter is @code{Dynamic},
then the dynamic elaboration
model described in the Ada Reference Manual is used, as though
-the @code{-gnatE} switch had been specified on the command
+the @option{-gnatE} switch had been specified on the command
line. If the parameter is @code{Static}, then the default GNAT static
model is used. This configuration pragma overrides the setting
of the command line. For full details on the elaboration models
-used by the GNAT compiler, see section ``Elaboration Order
-Handling in GNAT'' in the @cite{GNAT User's Guide}.
+used by the GNAT compiler, see @ref{Elaboration Order Handling in GNAT,,,
+gnat_ugn, @value{EDITION} User's Guide}.
@node Pragma Eliminate
@unnumberedsec Pragma Eliminate
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,
- [, [External =>] EXTERNAL_SYMBOL,]
+ [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
pragma applies. If more than one function name exists of this name in
the declarative part you must use the @code{Parameter_Types} and
@code{Result_Type} parameters is mandatory to achieve the required
-unique designation. @var{subtype_ mark}s in these parameters must
+unique designation. @var{subtype_mark}s in these parameters must
exactly match the subtypes in the corresponding function specification,
using positional notation to match parameters with subtype marks.
The form with an @code{'Access} attribute can be used to match an
@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
definition. Note that such a package is a child of @code{System}
and thus is considered part of the implementation. To compile
it you will have to use the appropriate switch for compiling
-system units. See the GNAT User's Guide for details.
+system units. @xref{Top, @value{EDITION} User's Guide, About This
+Guide,, gnat_ugn, @value{EDITION} User's Guide}, for details.
@node Pragma External
@unnumberedsec Pragma External
@smallexample @c ada
pragma External (
[ Convention =>] convention_IDENTIFIER,
- [ Entity =>] local_NAME
+ [ Entity =>] LOCAL_NAME
[, [External_Name =>] static_string_EXPRESSION ]
[, [Link_Name =>] static_string_EXPRESSION ]);
@end smallexample
@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
@noindent
to enforce the upper casing of all external symbols.
+@node Pragma Fast_Math
+@unnumberedsec Pragma Fast_Math
+@findex Fast_Math
+@noindent
+Syntax:
+
+@smallexample @c ada
+pragma Fast_Math;
+@end smallexample
+
+@noindent
+This is a configuration pragma which activates a mode in which speed is
+considered more important for floating-point operations than absolutely
+accurate adherence to the requirements of the standard. Currently the
+following operations are affected:
+
+@table @asis
+@item Complex Multiplication
+The normal simple formula for complex multiplication can result in intermediate
+overflows for numbers near the end of the range. The Ada standard requires that
+this situation be detected and corrected by scaling, but in Fast_Math mode such
+cases will simply result in overflow. Note that to take advantage of this you
+must instantiate your own version of @code{Ada.Numerics.Generic_Complex_Types}
+under control of the pragma, rather than use the preinstantiated versions.
+@end table
+
+@node Pragma Favor_Top_Level
+@unnumberedsec Pragma Favor_Top_Level
+@findex Favor_Top_Level
+@noindent
+Syntax:
+
+@smallexample @c ada
+pragma Favor_Top_Level (type_NAME);
+@end smallexample
+
+@noindent
+The named type must be an access-to-subprogram type. This pragma is an
+efficiency hint to the compiler, regarding the use of 'Access or
+'Unrestricted_Access on nested (non-library-level) subprograms. The
+pragma means that nested subprograms are not used with this type, or
+are rare, so that the generated code should be efficient in the
+top-level case. When this pragma is used, dynamically generated
+trampolines may be used on some targets for nested subprograms.
+See also the No_Implicit_Dynamic_Code restriction.
+
@node Pragma Finalize_Storage_Only
@unnumberedsec Pragma Finalize_Storage_Only
@findex Finalize_Storage_Only
Syntax:
@smallexample @c ada
-pragma Finalize_Storage_Only (first_subtype_local_NAME);
+pragma Finalize_Storage_Only (first_subtype_LOCAL_NAME);
@end smallexample
@noindent
be @code{IEEE_Float} and the pragma has no effect. On OpenVMS, the
argument may be @code{VAX_Float} to specify the use of the VAX float
format for the floating-point types in Standard. This requires that
-the standard runtime libraries be recompiled. See the
-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 standard runtime libraries be recompiled. @xref{The GNAT Run-Time
+Library Builder gnatlbr,,, gnat_ugn, @value{EDITION} User's Guide
+OpenVMS}, for a description of the @code{GNAT LIBRARY} command.
The two argument form specifies the representation to be used for
the specified floating-point type. On all systems other than OpenVMS,
maintain compatibility with this compiler, you should obey this length
limit.
+@node Pragma Implemented_By_Entry
+@unnumberedsec Pragma Implemented_By_Entry
+@findex Implemented_By_Entry
+@noindent
+Syntax:
+
+@smallexample @c ada
+pragma Implemented_By_Entry (LOCAL_NAME);
+@end smallexample
+
+@noindent
+This is a representation pragma which applies to protected, synchronized and
+task interface primitives. If the pragma is applied to primitive operation Op
+of interface Iface, it is illegal to override Op in a type that implements
+Iface, with anything other than an entry.
+
+@smallexample @c ada
+type Iface is protected interface;
+procedure Do_Something (Object : in out Iface) is abstract;
+pragma Implemented_By_Entry (Do_Something);
+
+protected type P is new Iface with
+ procedure Do_Something; -- Illegal
+end P;
+
+task type T is new Iface with
+ entry Do_Something; -- Legal
+end T;
+@end smallexample
+
+@noindent
+NOTE: The pragma is still in its design stage by the Ada Rapporteur Group. It
+is intended to be used in conjunction with dispatching requeue statements as
+described in AI05-0030. Should the ARG decide on an official name and syntax,
+this pragma will become language-defined rather than GNAT-specific.
+
+@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,
- [, [External =>] EXTERNAL_SYMBOL,]
+ [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,
- [, [External =>] EXTERNAL_SYMBOL],
+ [Internal =>] LOCAL_NAME
+ [, [External =>] EXTERNAL_SYMBOL]
[, [Size =>] EXTERNAL_SYMBOL]);
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}
Note that pragma @code{Initialize_Scalars} is particularly useful in
conjunction with the enhanced validity checking that is now provided
in GNAT, which checks for invalid values under more conditions.
-Using this feature (see description of the @code{-gnatV} flag in the
+Using this feature (see description of the @option{-gnatV} flag in the
users guide) in conjunction with pragma @code{Initialize_Scalars}
provides a powerful new tool to assist in the detection of problems
caused by uninitialized variables.
@noindent
Similar to pragma @code{Inline} except that inlining is not subject to
-the use of option @code{-gnatn} and the inlining happens regardless of
+the use of option @option{-gnatn} and the inlining happens regardless of
whether this option is used.
@node Pragma Inline_Generic
@smallexample @c ada
pragma Interface (
[Convention =>] convention_identifier,
- [Entity =>] local_NAME
- [, [External_Name =>] static_string_expression],
+ [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
@smallexample @c ada
pragma Linker_Alias (
- [Entity =>] local_NAME
+ [Entity =>] LOCAL_NAME,
[Target =>] static_string_EXPRESSION);
@end smallexample
@noindent
-@var{local_NAME} must refer to an object that is declared at the library
+@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
+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
+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
+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}.
+only if @code{pragma Weak_External} has been applied to @var{LOCAL_NAME}.
@smallexample @c ada
-- Example of the use of pragma Linker_Alias
@end smallexample
@noindent
-@var{procedure_local_NAME} must refer to a parameterless procedure that
+@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
@end smallexample
@noindent
-@var{procedure_local_NAME} must refer to a parameterless procedure that
+@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
@smallexample @c ada
pragma Linker_Section (
- [Entity =>] local_NAME
+ [Entity =>] LOCAL_NAME,
[Section =>] static_string_EXPRESSION);
@end smallexample
@noindent
-@var{local_NAME} must refer to an object that is declared at the library
+@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}
+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
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}
+inappropriate section (e.g.@: a modified variable into the @code{.text}
section). See also @code{pragma Persistent_BSS}.
@smallexample @c ada
@code{digits} specified in the range 7 through 15.
For further details on this pragma, see the
@cite{DEC Ada Language Reference Manual}, section 3.5.7b. Note that to use
-this pragma, the standard runtime libraries must be recompiled. See the
-description of the @code{GNAT LIBRARY} command in the OpenVMS version
-of the GNAT User's Guide for details on the use of this command.
+this pragma, the standard runtime libraries must be recompiled.
+@xref{The GNAT Run-Time Library Builder gnatlbr,,, gnat_ugn,
+@value{EDITION} User's Guide OpenVMS}, for a description of the
+@code{GNAT LIBRARY} command.
@node Pragma Machine_Attribute
@unnumberedsec Pragma Machine_Attribute
@smallexample @c ada
pragma Machine_Attribute (
- [Attribute_Name =>] string_EXPRESSION,
- [Entity =>] local_NAME);
+ [Entity =>] LOCAL_NAME,
+ [Attribute_Name =>] static_string_EXPRESSION
+ [, [Info =>] static_string_EXPRESSION] );
@end smallexample
@noindent
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 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.
+@code{__attribute__((@var{attribute_name}))} (if @var{info} is not
+specified) or @code{__attribute__((@var{attribute_name}(@var{info})))}
+in GNU C, where @code{@var{attribute_name}} is recognized by the
+target macro @code{TARGET_ATTRIBUTE_TABLE} which is defined for each
+machine. The optional parameter @var{info} is transformed into an
+identifier, which may make this pragma unusable for some attributes
+(parameter of some attributes must be a number or a string).
+@xref{Target Attributes,, Defining target-specific uses of
+@code{__attribute__}, gccint, GNU Compiler Colletion (GCC) Internals},
+further information. It is not possible to specify
+attributes defined by other languages, only attributes defined by the
+machine the code is intended to run on.
+
+@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 interference 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 @{, procedure_local_NAME@});
+pragma No_Return (procedure_LOCAL_NAME @{, procedure_LOCAL_NAME@});
@end smallexample
@noindent
-Each @var{procedure_local_NAME} argument 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.
In addition, if the procedure contains any implicit returns from falling
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.
+in which it must be suppressed, see @ref{Optimization and Strict
+Aliasing,,, gnat_ugn, @value{EDITION} User's Guide}.
@node Pragma Normalize_Scalars
@unnumberedsec Pragma Normalize_Scalars
Syntax:
@smallexample @c ada
-pragma Obsolescent [(static_string_EXPRESSION [,Ada_05])];
+pragma Obsolescent
+ (Entity => NAME [, static_string_EXPRESSION [,Ada_05]]);
@end smallexample
@noindent
-This pragma can occur immediately following a subprogram
-declaration and 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 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 it indicates that the entire package is considered
+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 second parameter is present (which must be exactly
+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.
+(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 Optimize_Alignment
+@unnumberedsec Pragma Optimize_Alignment
+@findex Optimize_Alignment
+@cindex Alignment, default settings
+@noindent
+Syntax:
+
+@smallexample @c ada
+pragma Optimize_Alignment (TIME | SPACE | OFF);
+@end smallexample
+
+@noindent
+This is a configuration pragma which affects the choice of default alignments
+for types where no alignment is explicitly specified. There is a time/space
+trade-off in the selection of these values. Large alignments result in more
+efficient code, at the expense of larger data space, since sizes have to be
+increased to match these alignments. Smaller alignments save space, but the
+access code is slower. The normal choice of default alignments (which is what
+you get if you do not use this pragma, or if you use an argument of OFF),
+tries to balance these two requirements.
+
+Specifying SPACE causes smaller default alignments to be chosen in two cases.
+First any packed record is given an alignment of 1. Second, if a size is given
+for the type, then the alignment is chosen to avoid increasing this size. For
+example, consider:
+
+@smallexample @c ada
+ type R is record
+ X : Integer;
+ Y : Character;
+ end record;
+
+ for R'Size use 5*8;
+@end smallexample
+
+@noindent
+In the default mode, this type gets an alignment of 4, so that access to the
+Integer field X are efficient. But this means that objects of the type end up
+with a size of 8 bytes. This is a valid choice, since sizes of objects are
+allowed to be bigger than the size of the type, but it can waste space if for
+example fields of type R appear in an enclosing record. If the above type is
+compiled in @code{Optimize_Alignment (Space)} mode, the alignment is set to 1.
+
+Specifying TIME causes larger default alignments to be chosen in the case of
+small types with sizes that are not a power of 2. For example, consider:
+
+@smallexample @c ada
+ type R is record
+ A : Character;
+ B : Character;
+ C : Boolean;
+ end record;
+
+ pragma Pack (R);
+ for R'Size use 17;
+@end smallexample
+
+@noindent
+The default alignment for this record is normally 1, but if this type is
+compiled in @code{Optimize_Alignment (Time)} mode, then the alignment is set
+to 4, which wastes space for objects of the type, since they are now 4 bytes
+long, but results in more efficient access when the whole record is referenced.
+
+As noted above, this is a configuration pragma, and there is a requirement
+that all units in a partition be compiled with a consistent setting of the
+optimization setting. This would normally be achieved by use of a configuration
+pragma file containing the appropriate setting. The exception to this rule is
+that predefined units in the GNAT library (that is, members of the Ada, System,
+Interfaces, GNAT hierarchies) ignore the setting of this pragma, and thus the
+consistency requirement does not apply to them.
@node Pragma Passive
@unnumberedsec Pragma Passive
Syntax:
@smallexample @c ada
-pragma Passive ([Semaphore | No]);
+pragma Passive [(Semaphore | No)];
@end smallexample
@noindent
Syntax:
@smallexample @c ada
-pragma Persistent_BSS [local_NAME]
+pragma Persistent_BSS [(LOCAL_NAME)]
@end smallexample
@noindent
@code{Poll} in this file makes a call to the appropriate runtime routine
to test for an abort condition.
-Note that polling can also be enabled by use of the @code{-gnatP} switch. See
-the @cite{GNAT User's Guide} for details.
+Note that polling can also be enabled by use of the @option{-gnatP} switch.
+@xref{Switches for gcc,,, gnat_ugn, @value{EDITION} User's Guide}, for
+details.
@node Pragma Profile (Ravenscar)
@unnumberedsec Pragma Profile (Ravenscar)
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
@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
generates a warning message rather than an error message
if the restriction is violated.
+@node Pragma Shared
+@unnumberedsec Pragma Shared
+@findex Shared
+
+@noindent
+This pragma is provided for compatibility with Ada 83. The syntax and
+semantics are identical to pragma Atomic.
+
@node Pragma Source_File_Name
@unnumberedsec Pragma Source_File_Name
@findex Source_File_Name
@ref{Pragma Source_File_Name_Project}.
For more details on the use of the @code{Source_File_Name} pragma,
-see the sections ``Using Other File Names'' and
-``Alternative File Naming Schemes'' in the @cite{GNAT User's Guide}.
+@xref{Using Other File Names,,, gnat_ugn, @value{EDITION} User's Guide},
+and @ref{Alternative File Naming Schemes,,, gnat_ugn, @value{EDITION}
+User's Guide}.
@node Pragma Source_File_Name_Project
@unnumberedsec Pragma Source_File_Name_Project
information). @var{string_literal} is a static string constant that
specifies the file name to be used in error messages and debugging
information. This is most notably used for the output of @code{gnatchop}
-with the @code{-r} switch, to make sure that the original unchopped
+with the @option{-r} switch, to make sure that the original unchopped
source file is the one referred to.
The second argument must be a string literal, it cannot be a static
@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
The form with a string literal specifies which style options are to be
activated. These are additive, so they apply in addition to any previously
set style check options. The codes for the options are the same as those
-used in the @code{-gnaty} switch to @code{gcc} or @code{gnatmake}.
+used in the @option{-gnaty} switch to @command{gcc} or @command{gnatmake}.
For example the following two methods can be used to enable
layout checking:
@noindent
The form ALL_CHECKS activates all standard checks (its use is equivalent
-to the use of the @code{gnaty} switch with no options. See GNAT User's
-Guide for details.
+to the use of the @code{gnaty} switch with no options. @xref{Top,
+@value{EDITION} User's Guide, About This Guide, gnat_ugn,
+@value{EDITION} User's Guide}, for details.
The forms with @code{Off} and @code{On}
can be used to temporarily disable style checks
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, @xref{Optimization and Strict
+Aliasing,,, gnat_ugn, @value{EDITION} User's Guide}.
+
@node Pragma Universal_Data
@unnumberedsec Pragma Universal_Data
@findex Universal_Data
of this pragma is also available by applying the -univ switch on the
compilations of units where universal addressing of the data is desired.
+@node Pragma Unmodified
+@unnumberedsec Pragma Unmodified
+@findex Unmodified
+@cindex Warnings, unmodified
+@noindent
+Syntax:
+
+@smallexample @c ada
+pragma Unmodified (LOCAL_NAME @{, LOCAL_NAME@});
+@end smallexample
+
+@noindent
+This pragma signals that the assignable entities (variables,
+@code{out} parameters, @code{in out} parameters) whose names are listed are
+deliberately not assigned in the current source unit. This
+suppresses warnings about the
+entities being referenced but not assigned, and in addition a warning will be
+generated if one of these entities is in fact assigned in the
+same unit as the pragma (or in the corresponding body, or one
+of its subunits).
+
+This is particularly useful for clearly signaling that a particular
+parameter is not modified, even though the spec suggests that it might
+be.
+
@node Pragma Unreferenced
@unnumberedsec Pragma Unreferenced
@findex Unreferenced
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. Note that in the case of accept formals, the pragma
Unreferenced may appear immediately after the keyword @code{do} which
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 and unreferenced entities within these 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.
activated. The validity checks are first set to include only the default
reference manual settings, and then a string of letters in the string
specifies the exact set of options required. The form of this string
-is exactly as described for the @code{-gnatVx} compiler switch (see the
+is exactly as described for the @option{-gnatVx} compiler switch (see the
GNAT users guide for details). For example the following two methods
can be used to enable validity checking for mode @code{in} and
@code{in out} subprogram parameters:
Syntax:
@smallexample @c ada
-pragma Volatile (local_NAME);
+pragma Volatile (LOCAL_NAME);
@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 static_string_EXPRESSION argument provides more precise
+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:
+full details see @ref{Warning Message Control,,, gnat_ugn, @value{EDITION}
+User's Guide}.
@smallexample
-a turn on all optional warnings (except d,h,l)
-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 s/e)
-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
-r turn on warnings for redundant construct
-R turn off warnings for redundant construct
-s suppress all warnings
-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
-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
+a turn on all optional warnings (except d h l .o)
+A turn off all optional warnings
+.a* turn on warnings for failing assertions
+.A turn off warnings for failing assertions
+b turn on warnings for bad fixed value (not multiple of small)
+B* turn off warnings for bad fixed value (not multiple of small)
+c turn on warnings for constant conditional
+C* turn off warnings for constant conditional
+.c turn on warnings for unrepped components
+.C* turn off warnings for unrepped components
+d turn on warnings for implicit dereference
+D* turn off warnings for implicit dereference
+e treat all warnings as errors
+f turn on warnings for unreferenced formal
+F* turn off warnings for unreferenced formal
+g* turn on warnings for unrecognized pragma
+G turn off warnings for unrecognized pragma
+h turn on warnings for hiding variable
+H* turn off warnings for hiding variable
+i* turn on warnings for implementation unit
+I turn off warnings for implementation unit
+j turn on warnings for obsolescent (annex J) feature
+J* turn off warnings for obsolescent (annex J) feature
+k turn on warnings on constant variable
+K* turn off warnings on constant variable
+l turn on warnings for missing elaboration pragma
+L* turn off warnings for missing elaboration pragma
+m turn on warnings for variable assigned but not read
+M* turn off warnings for variable assigned but not read
+n* normal warning mode (cancels -gnatws/-gnatwe)
+o* turn on warnings for address clause overlay
+O turn off warnings for address clause overlay
+.o turn on warnings for out parameters assigned but not read
+.O* turn off warnings for out parameters assigned but not read
+p turn on warnings for ineffective pragma Inline in frontend
+P* turn off warnings for ineffective pragma Inline in frontend
+q* turn on warnings for questionable missing parentheses
+Q turn off warnings for questionable missing parentheses
+r turn on warnings for redundant construct
+R* turn off warnings for redundant construct
+.r turn on warnings for object renaming function
+.R* turn off warnings for object renaming function
+s suppress all warnings
+t turn on warnings for tracking deleted code
+T* turn off warnings for tracking deleted code
+u turn on warnings for unused entity
+U* turn off warnings for unused entity
+v* turn on warnings for unassigned variable
+V turn off warnings for unassigned variable
+w* turn on warnings for wrong low bound assumption
+W turn off warnings for wrong low bound assumption
+x* turn on warnings for export/import
+X turn off warnings for export/import
+.x turn on warnings for non-local exceptions
+.X* turn off warnings for non-local exceptions
+y* turn on warnings for Ada 2005 incompatibility
+Y turn off warnings for Ada 2005 incompatibility
+z* turn on convention/size/align warnings for unchecked conversion
+Z turn off convention/size/align warnings for unchecked conversion
+* indicates default in above list
@end smallexample
@noindent
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.
+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);
+@dots{} 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
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
+@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
+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.
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 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 @samp{h}, @samp{u},
+@samp{s}, @samp{e}, @samp{8}, or @samp{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::
* Mechanism_Code::
* Null_Parameter::
* Object_Size::
+* Old::
* Passed_By_Reference::
+* Pool_Address::
* Range_Length::
* Safe_Emax::
* 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
integer field, and so the default size of record objects for this type
will be 64 (8 bytes).
-The @code{@var{type}'Object_Size} attribute
-has been added to GNAT to allow the
-default object size of a type to be easily determined. For example,
-@code{Natural'Object_Size} is 32, and
-@code{Rec'Object_Size} (for the record type in the above example) will be
-64. Note also that, unlike the situation with the
-@code{Size} attribute as defined in the Ada RM, the
-@code{Object_Size} attribute can be specified individually
-for different subtypes. For example:
+@node Old
+@unnumberedsec Old
+@cindex Capturing Old values
+@cindex Postconditions
+@noindent
+The attribute Prefix'Old can be used within a
+subprogram to refer to the value of the prefix on entry. So for
+example if you have an argument of a record type X called Arg1,
+you can refer to Arg1.Field'Old which yields the value of
+Arg1.Field on entry. The implementation simply involves generating
+an object declaration which captures the value on entry. Any
+prefix is allowed except one of a limited type (since limited
+types cannot be copied to capture their values).
+
+The following example shows the use of 'Old to implement
+a test of a postcondition:
@smallexample @c ada
-type R is new Integer;
-subtype R1 is R range 1 .. 10;
-subtype R2 is R range 1 .. 10;
-for R2'Object_Size use 8;
-@end smallexample
+with Old_Pkg;
+procedure Old is
+begin
+ Old_Pkg.Incr;
+end Old;
-@noindent
-In this example, @code{R'Object_Size} and @code{R1'Object_Size} are both
-32 since the default object size for a subtype is the same as the object size
-for the parent subtype. This means that objects of type @code{R}
-or @code{R1} will
-by default be 32 bits (four bytes). But objects of type
-@code{R2} will be only
-8 bits (one byte), since @code{R2'Object_Size} has been set to 8.
+package Old_Pkg is
+ procedure Incr;
+end Old_Pkg;
+
+package body Old_Pkg is
+ Count : Natural := 0;
+
+ procedure Incr is
+ begin
+ ... code manipulating the value of Count
+
+ pragma Assert (Count = Count'Old + 1);
+ end Incr;
+end Old_Pkg;
+@end smallexample
@node Passed_By_Reference
@unnumberedsec Passed_By_Reference
passed by copy in calls. For scalar types, the result is always @code{False}
and is static. For non-scalar types, the result is non-static.
+@node Pool_Address
+@unnumberedsec Pool_Address
+@cindex Parameters, when passed by reference
+@findex Pool_Address
+@noindent
+@code{@var{X}'Pool_Address} for any object @var{X} returns the address
+of X within its storage pool. This is the same as
+@code{@var{X}'Address}, except that for an unconstrained array whose
+bounds are allocated just before the first component,
+@code{@var{X}'Pool_Address} returns the address of those bounds,
+whereas @code{@var{X}'Address} returns the address of the first
+component.
+
+Here, we are interpreting ``storage pool'' broadly to mean ``wherever
+the object is allocated'', which could be a user-defined storage pool,
+the global heap, on the stack, or in a static memory area. For an
+object created by @code{new}, @code{@var{Ptr.all}'Pool_Address} is
+what is passed to @code{Allocate} and returned from @code{Deallocate}.
+
@node Range_Length
@unnumberedsec Range_Length
@findex Range_Length
@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
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 exercised if it is used to create pointers to unconstrained
@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
@end smallexample
@item
-Rebuild the GNAT run-time library as documented in the
-@cite{GNAT User's Guide}
+Rebuild the GNAT run-time library as documented in
+@ref{GNAT and Libraries,,, gnat_ugn, @value{EDITION} User's Guide}.
@end enumerate
@unnumberedsec A.1(52): Names of Predefined Numeric Types
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
length. See 2.2(15).
@end cartouche
@noindent
-The maximum line length is 255 characters an the maximum length of a
+The maximum line length is 255 characters and the maximum length of a
lexical element is also 255 characters.
@sp 1
@sp 1
@cartouche
@noindent
-@strong{27}. Whether or not two non overlapping parts of a composite
+@strong{27}. Whether or not two non-overlapping parts of a composite
object are independently addressable, in the case where packing, record
layout, or @code{Component_Size} is specified for the object. See
9.10(1).
@end cartouche
@noindent
A compilation is represented by a sequence of files presented to the
-compiler in a single invocation of the @code{gcc} command.
+compiler in a single invocation of the @command{gcc} command.
@sp 1
@cartouche
If the partition contains no main program, or if the main program is in
a language other than Ada, then GNAT
-provides the binder options @code{-z} and @code{-n} respectively, and in
+provides the binder options @option{-z} and @option{-n} respectively, and in
this case a list of units can be explicitly supplied to the binder for
inclusion in the partition (all units needed by these units will also
be included automatically). For full details on the use of these
-options, refer to the @cite{GNAT User's Guide} sections on Binding
-and Linking.
+options, refer to @ref{The GNAT Make Program gnatmake,,, gnat_ugn,
+@value{EDITION} User's Guide}.
@sp 1
@cartouche
@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
@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
@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 and membership tests and 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 the predefined attributes on class-wide objects.) 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. The following example indicates
-constructs that violate this restriction.
+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
with Pkg; use Pkg;
procedure Example is
procedure Test (O : T'Class) is
- N : Natural := O'Size; -- Error: Dispatching call
+ 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
+ Q (DT (O)); -- OK : Type conversion plus direct call
else
P (O); -- Error: Dispatching call
end if;
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
@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
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
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
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
causes two separate arguments @code{-labc} and @code{-ldef} to be passed to the
linker. The order of linker options is preserved for a given unit. The final
list of options passed to the linker is in reverse order of the elaboration
-order. For example, linker options fo a body always appear before the options
+order. For example, linker options for a body always appear before the options
from the corresponding package spec.
@sp 1
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 @code{Var}
+has a task type, the image for this task will have the form @code{Var_@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, e.g.@: @code{Group(5)_@var{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
The metrics information for GNAT depends on the performance of the
underlying operating system. The sources of the run-time for tasking
-implementation, together with the output from @code{-gnatG} can be
+implementation, together with the output from @option{-gnatG} can be
used to determine the exact sequence of operating systems calls made
to implement various tasking constructs. Together with appropriate
information on the performance of the underlying operating system,
@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
@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
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
+You can also use the @option{-d} binder switch to modify the default stack
size.
For access types, the @code{Storage_Size} clause specifies the maximum
@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
Since the misconception that Bit_Order automatically deals with all
endian-related incompatibilities is a common one, the specification of
a component field that is an integral number of bytes will always
-generate a warning. This warning may be suppressed using
-@code{pragma Suppress} if desired. The following section contains additional
+generate a warning. This warning may be suppressed using @code{pragma
+Warnings (Off)} if desired. The following section contains additional
details regarding the issue of byte ordering.
@node Effect of Bit_Order on Byte Ordering
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;
there are no limitations on placement of such components, and they
may start and end at arbitrary bit boundaries.
-If the component size is not a power of 2 (e.g. 3 or 5), then
+If the component size is not a power of 2 (e.g.@: 3 or 5), then
an array of this type longer than 64 bits must always be placed on
on a storage unit (byte) boundary and occupy an integral number
of storage units (bytes). Any component clause that does not
@end smallexample
@noindent
-For the unsigned case, where all values are non negative, the values must
+For the unsigned case, where all values are nonnegative, the values must
be in the range:
@smallexample @c ada
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
@section Determining the Representations chosen by GNAT
@cindex Representation, determination of
-@cindex @code{-gnatR} switch
+@cindex @option{-gnatR} switch
@noindent
Although the descriptions in this section are intended to be complete, it is
used to answer the second question, but it is often easier to just see
what the compiler does.
-For this purpose, GNAT provides the option @code{-gnatR}. If you compile
+For this purpose, GNAT provides the option @option{-gnatR}. If you compile
with this option, then the compiler will output information on the actual
representations chosen, in a format similar to source representation
clauses. For example, if we compile the package:
@end smallexample
@noindent
-using the switch @code{-gnatR} we obtain the following output:
+using the switch @option{-gnatR} we obtain the following output:
@smallexample
Representation information for unit q
@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
+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)
@item Ada.Decimal (F.2)
This package provides constants describing the range of decimal numbers
implemented, and also a decimal divide routine (analogous to the COBOL
-verb DIVIDE .. GIVING .. REMAINDER ..)
+verb DIVIDE @dots{} GIVING @dots{} REMAINDER @dots{})
@item Ada.Direct_IO (A.8.4)
This package provides input-output using a model of a set of records of
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::
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
+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.
@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:
@end smallexample
@noindent
-where the xxx bits correspond to the left-padded bits of the
+where the @var{xxx} bits correspond to the left-padded bits of the
16-bit character value. Note that all lower half ASCII characters
are represented as ASCII bytes and all upper half characters and
other wide characters are represented as sequences of upper-half
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
@end smallexample
@noindent
-where the xxx bits correspond to the left-padded bits of the
+where the @var{xxx} bits correspond to the left-padded bits of the
21-bit character value. Note that all lower half ASCII characters
are represented as ASCII bytes and all upper half characters and
other wide characters are represented as sequences of upper-half
@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
-- If text_translation_required is true, then the following
-- functions may be used to dynamically switch a file from
-- binary to text mode or vice versa. These functions have
- -- no effect if text_translation_required is false (i.e. in
+ -- no effect if text_translation_required is false (i.e.@: in
-- normal UNIX mode). Use fileno to get a stream handle.
procedure set_binary_mode (handle : int);
procedure set_text_mode (handle : int);
* Ada.Characters.Latin_9 (a-chlat9.ads)::
* Ada.Characters.Wide_Latin_1 (a-cwila1.ads)::
* Ada.Characters.Wide_Latin_9 (a-cwila9.ads)::
-* Ada.Characters.Wide_Wide_Latin_1 (a-czila1.ads)::
-* Ada.Characters.Wide_Wide_Latin_9 (a-czila9.ads)::
-* Ada.Command_Line.Remove (a-colire.ads)::
+* Ada.Characters.Wide_Wide_Latin_1 (a-chzla1.ads)::
+* Ada.Characters.Wide_Wide_Latin_9 (a-chzla9.ads)::
* Ada.Command_Line.Environment (a-colien.ads)::
+* Ada.Command_Line.Remove (a-colire.ads)::
+* Ada.Command_Line.Response_File (a-clrefi.ads)::
* Ada.Direct_IO.C_Streams (a-diocst.ads)::
* Ada.Exceptions.Is_Null_Occurrence (a-einuoc.ads)::
+* Ada.Exceptions.Last_Chance_Handler (a-elchha.ads)::
* Ada.Exceptions.Traceback (a-exctra.ads)::
* Ada.Sequential_IO.C_Streams (a-siocst.ads)::
* Ada.Streams.Stream_IO.C_Streams (a-ssicst.ads)::
* Ada.Strings.Wide_Unbounded.Wide_Text_IO (a-swuwti.ads)::
* Ada.Strings.Wide_Wide_Unbounded.Wide_Wide_Text_IO (a-szuzti.ads)::
* Ada.Text_IO.C_Streams (a-tiocst.ads)::
+* Ada.Wide_Characters.Unicode (a-wichun.ads)::
* Ada.Wide_Text_IO.C_Streams (a-wtcstr.ads)::
+* Ada.Wide_Wide_Characters.Unicode (a-zchuni.ads)::
* Ada.Wide_Wide_Text_IO.C_Streams (a-ztcstr.ads)::
* GNAT.Altivec (g-altive.ads)::
* GNAT.Altivec.Conversions (g-altcon.ads)::
* GNAT.Bubble_Sort (g-bubsor.ads)::
* GNAT.Bubble_Sort_A (g-busora.ads)::
* GNAT.Bubble_Sort_G (g-busorg.ads)::
+* GNAT.Byte_Order_Mark (g-byorma.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.Case_Util (g-casuti.ads)::
* GNAT.CGI (g-cgi.ads)::
* GNAT.CGI.Cookie (g-cgicoo.ads)::
* GNAT.Command_Line (g-comlin.ads)::
* GNAT.Compiler_Version (g-comver.ads)::
* GNAT.Ctrl_C (g-ctrl_c.ads)::
+* GNAT.CRC32 (g-crc32.ads)::
* GNAT.Current_Exception (g-curexc.ads)::
* GNAT.Debug_Pools (g-debpoo.ads)::
* GNAT.Debug_Utilities (g-debuti.ads)::
+* GNAT.Decode_String (g-decstr.ads)::
+* GNAT.Decode_UTF8_String (g-deutst.ads)::
* GNAT.Directory_Operations (g-dirope.ads)::
+* GNAT.Directory_Operations.Iteration (g-diopit.ads)::
* GNAT.Dynamic_HTables (g-dynhta.ads)::
* GNAT.Dynamic_Tables (g-dyntab.ads)::
+* GNAT.Encode_String (g-encstr.ads)::
+* GNAT.Encode_UTF8_String (g-enutst.ads)::
* GNAT.Exception_Actions (g-excact.ads)::
* GNAT.Exception_Traces (g-exctra.ads)::
* GNAT.Exceptions (g-except.ads)::
* GNAT.Most_Recent_Exception (g-moreex.ads)::
* GNAT.OS_Lib (g-os_lib.ads)::
* GNAT.Perfect_Hash_Generators (g-pehage.ads)::
+* GNAT.Random_Numbers (g-rannum.ads)::
* GNAT.Regexp (g-regexp.ads)::
* GNAT.Registry (g-regist.ads)::
* GNAT.Regpat (g-regpat.ads)::
* GNAT.Secondary_Stack_Info (g-sestin.ads)::
* GNAT.Semaphores (g-semaph.ads)::
+* GNAT.Serial_Communications (g-sercom.ads)::
+* GNAT.SHA1 (g-sha1.ads)::
* GNAT.Signals (g-signal.ads)::
* GNAT.Sockets (g-socket.ads)::
* GNAT.Source_Info (g-souinf.ads)::
-* GNAT.Spell_Checker (g-speche.ads)::
+* GNAT.Spelling_Checker (g-speche.ads)::
+* GNAT.Spelling_Checker_Generic (g-spchge.ads)::
* GNAT.Spitbol.Patterns (g-spipat.ads)::
* GNAT.Spitbol (g-spitbo.ads)::
* GNAT.Spitbol.Table_Boolean (g-sptabo.ads)::
* GNAT.Spitbol.Table_VString (g-sptavs.ads)::
* GNAT.Strings (g-string.ads)::
* GNAT.String_Split (g-strspl.ads)::
-* GNAT.UTF_32 (g-utf_32.ads)::
* GNAT.Table (g-table.ads)::
* GNAT.Task_Lock (g-tasloc.ads)::
* GNAT.Threads (g-thread.ads)::
* GNAT.Traceback (g-traceb.ads)::
* GNAT.Traceback.Symbolic (g-trasym.ads)::
+* GNAT.UTF_32 (g-utf_32.ads)::
+* GNAT.UTF_32_Spelling_Checker (g-u3spch.ads)::
+* GNAT.Wide_Spelling_Checker (g-wispch.ads)::
* GNAT.Wide_String_Split (g-wistsp.ads)::
+* GNAT.Wide_Wide_Spelling_Checker (g-zspche.ads)::
* GNAT.Wide_Wide_String_Split (g-zistsp.ads)::
* Interfaces.C.Extensions (i-cexten.ads)::
* Interfaces.C.Streams (i-cstrea.ads)::
* Interfaces.CPP (i-cpp.ads)::
-* Interfaces.Os2lib (i-os2lib.ads)::
-* Interfaces.Os2lib.Errors (i-os2err.ads)::
-* Interfaces.Os2lib.Synchronization (i-os2syn.ads)::
-* Interfaces.Os2lib.Threads (i-os2thr.ads)::
* Interfaces.Packed_Decimal (i-pacdec.ads)::
* Interfaces.VxWorks (i-vxwork.ads)::
* Interfaces.VxWorks.IO (i-vxwoio.ads)::
* System.Assertions (s-assert.ads)::
* System.Memory (s-memory.ads)::
* System.Partition_Interface (s-parint.ads)::
+* System.Pool_Global (s-pooglo.ads)::
+* System.Pool_Local (s-pooloc.ads)::
* System.Restrictions (s-restri.ads)::
* System.Rident (s-rident.ads)::
* System.Task_Info (s-tasinf.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})
-@cindex @code{Ada.Characters.Wide_Wide_Latin_1} (@file{a-czila1.ads})
+@node Ada.Characters.Wide_Wide_Latin_1 (a-chzla1.ads)
+@section @code{Ada.Characters.Wide_Wide_Latin_1} (@file{a-chzla1.ads})
+@cindex @code{Ada.Characters.Wide_Wide_Latin_1} (@file{a-chzla1.ads})
@cindex Latin_1 constants for Wide_Wide_Character
@noindent
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})
-@cindex @code{Ada.Characters.Wide_Wide_Latin_9} (@file{a-czila9.ads})
+@node Ada.Characters.Wide_Wide_Latin_9 (a-chzla9.ads)
+@section @code{Ada.Characters.Wide_Wide_Latin_9} (@file{a-chzla9.ads})
+@cindex @code{Ada.Characters.Wide_Wide_Latin_9} (@file{a-chzla9.ads})
@cindex Latin_9 constants for Wide_Wide_Character
@noindent
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.Environment (a-colien.ads)
+@section @code{Ada.Command_Line.Environment} (@file{a-colien.ads})
+@cindex @code{Ada.Command_Line.Environment} (@file{a-colien.ads})
+@cindex Environment entries
+
+@noindent
+This child of @code{Ada.Command_Line}
+provides a mechanism for obtaining environment values on systems
+where this concept makes sense.
@node Ada.Command_Line.Remove (a-colire.ads)
@section @code{Ada.Command_Line.Remove} (@file{a-colire.ads})
to further calls on the subprograms in @code{Ada.Command_Line} will not
see the removed argument.
-@node Ada.Command_Line.Environment (a-colien.ads)
-@section @code{Ada.Command_Line.Environment} (@file{a-colien.ads})
-@cindex @code{Ada.Command_Line.Environment} (@file{a-colien.ads})
-@cindex Environment entries
+@node Ada.Command_Line.Response_File (a-clrefi.ads)
+@section @code{Ada.Command_Line.Response_File} (@file{a-clrefi.ads})
+@cindex @code{Ada.Command_Line.Response_File} (@file{a-clrefi.ads})
+@cindex Response file for command line
+@cindex Command line, response file
+@cindex Command line, handling long command lines
@noindent
-This child of @code{Ada.Command_Line}
-provides a mechanism for obtaining environment values on systems
-where this concept makes sense.
+This child of @code{Ada.Command_Line} provides a mechanism facilities for
+getting command line arguments from a text file, called a "response file".
+Using a response file allow passing a set of arguments to an executable longer
+than the maximum allowed by the system on the command line.
@node Ada.Direct_IO.C_Streams (a-diocst.ads)
@section @code{Ada.Direct_IO.C_Streams} (@file{a-diocst.ads})
exception occurrence (@code{Null_Occurrence}) without raising
an exception.
+@node Ada.Exceptions.Last_Chance_Handler (a-elchha.ads)
+@section @code{Ada.Exceptions.Last_Chance_Handler} (@file{a-elchha.ads})
+@cindex @code{Ada.Exceptions.Last_Chance_Handler} (@file{a-elchha.ads})
+@cindex Null_Occurrence, testing for
+
+@noindent
+This child subprogram is used for handling otherwise unhandled
+exceptions (hence the name last chance), and perform clean ups before
+terminating the program. Note that this subprogram never returns.
+
@node Ada.Exceptions.Traceback (a-exctra.ads)
@section @code{Ada.Exceptions.Traceback} (@file{a-exctra.ads})
@cindex @code{Ada.Exceptions.Traceback} (@file{a-exctra.ads})
extracted from a file opened on the Ada side, and an Ada file
can be constructed from a stream opened on the C side.
+@node Ada.Wide_Characters.Unicode (a-wichun.ads)
+@section @code{Ada.Wide_Characters.Unicode} (@file{a-wichun.ads})
+@cindex @code{Ada.Wide_Characters.Unicode} (@file{a-wichun.ads})
+@cindex Unicode categorization, Wide_Character
+
+@noindent
+This package provides subprograms that allow categorization of
+Wide_Character values according to Unicode categories.
+
@node Ada.Wide_Text_IO.C_Streams (a-wtcstr.ads)
@section @code{Ada.Wide_Text_IO.C_Streams} (@file{a-wtcstr.ads})
@cindex @code{Ada.Wide_Text_IO.C_Streams} (@file{a-wtcstr.ads})
extracted from a file opened on the Ada side, and an Ada file
can be constructed from a stream opened on the C side.
+@node Ada.Wide_Wide_Characters.Unicode (a-zchuni.ads)
+@section @code{Ada.Wide_Wide_Characters.Unicode} (@file{a-zchuni.ads})
+@cindex @code{Ada.Wide_Wide_Characters.Unicode} (@file{a-zchuni.ads})
+@cindex Unicode categorization, Wide_Wide_Character
+
+@noindent
+This package provides subprograms that allow categorization of
+Wide_Wide_Character values according to Unicode categories.
+
@node Ada.Wide_Wide_Text_IO.C_Streams (a-ztcstr.ads)
@section @code{Ada.Wide_Wide_Text_IO.C_Streams} (@file{a-ztcstr.ads})
@cindex @code{Ada.Wide_Wide_Text_IO.C_Streams} (@file{a-ztcstr.ads})
if the procedures can be inlined, at the expense of duplicating code for
multiple instantiations.
+@node GNAT.Byte_Order_Mark (g-byorma.ads)
+@section @code{GNAT.Byte_Order_Mark} (@file{g-byorma.ads})
+@cindex @code{GNAT.Byte_Order_Mark} (@file{g-byorma.ads})
+@cindex UTF-8 representation
+@cindex Wide characte representations
+
+@noindent
+Provides a routine which given a string, reads the start of the string to
+see whether it is one of the standard byte order marks (BOM's) which signal
+the encoding of the string. The routine includes detection of special XML
+sequences for various UCS input formats.
+
+@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)
@noindent
Provide a debugging storage pools that helps tracking memory corruption
-problems. See section ``Finding memory problems with GNAT Debug Pool'' in
-the @cite{GNAT User's Guide}.
+problems. @xref{The GNAT Debug Pool Facility,,, gnat_ugn,
+@value{EDITION} User's Guide}.
@node GNAT.Debug_Utilities (g-debuti.ads)
@section @code{GNAT.Debug_Utilities} (@file{g-debuti.ads})
to and from string images of address values. Supports both C and Ada formats
for hexadecimal literals.
+@node GNAT.Decode_String (g-decstr.ads)
+@section @code{GNAT.Decode_String} (@file{g-decstr.ads})
+@cindex @code{GNAT.Decode_String} (@file{g-decstr.ads})
+@cindex Decoding strings
+@cindex String decoding
+@cindex Wide character encoding
+@cindex UTF-8
+@cindex Unicode
+
+@noindent
+A generic package providing routines for decoding wide character and wide wide
+character strings encoded as sequences of 8-bit characters using a specified
+encoding method. Includes validation routines, and also routines for stepping
+to next or previous encoded character in an encoded string.
+Useful in conjunction with Unicode character coding. Note there is a
+preinstantiation for UTF-8. See next entry.
+
+@node GNAT.Decode_UTF8_String (g-deutst.ads)
+@section @code{GNAT.Decode_UTF8_String} (@file{g-deutst.ads})
+@cindex @code{GNAT.Decode_UTF8_String} (@file{g-deutst.ads})
+@cindex Decoding strings
+@cindex Decoding UTF-8 strings
+@cindex UTF-8 string decoding
+@cindex Wide character decoding
+@cindex UTF-8
+@cindex Unicode
+
+@noindent
+A preinstantiation of GNAT.Decode_Strings for UTF-8 encoding.
+
@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
the current directory, making new directories, and scanning the files in a
directory.
+@node GNAT.Directory_Operations.Iteration (g-diopit.ads)
+@section @code{GNAT.Directory_Operations.Iteration} (@file{g-diopit.ads})
+@cindex @code{GNAT.Directory_Operations.Iteration} (@file{g-diopit.ads})
+@cindex Directory operations iteration
+
+@noindent
+A child unit of GNAT.Directory_Operations providing additional operations
+for iterating through directories.
+
@node GNAT.Dynamic_HTables (g-dynhta.ads)
@section @code{GNAT.Dynamic_HTables} (@file{g-dynhta.ads})
@cindex @code{GNAT.Dynamic_HTables} (@file{g-dynhta.ads})
dynamic instances of the table, while an instantiation of
@code{GNAT.Table} creates a single instance of the table type.
+@node GNAT.Encode_String (g-encstr.ads)
+@section @code{GNAT.Encode_String} (@file{g-encstr.ads})
+@cindex @code{GNAT.Encode_String} (@file{g-encstr.ads})
+@cindex Encoding strings
+@cindex String encoding
+@cindex Wide character encoding
+@cindex UTF-8
+@cindex Unicode
+
+@noindent
+A generic package providing routines for encoding wide character and wide
+wide character strings as sequences of 8-bit characters using a specified
+encoding method. Useful in conjunction with Unicode character coding.
+Note there is a preinstantiation for UTF-8. See next entry.
+
+@node GNAT.Encode_UTF8_String (g-enutst.ads)
+@section @code{GNAT.Encode_UTF8_String} (@file{g-enutst.ads})
+@cindex @code{GNAT.Encode_UTF8_String} (@file{g-enutst.ads})
+@cindex Encoding strings
+@cindex Encoding UTF-8 strings
+@cindex UTF-8 string encoding
+@cindex Wide character encoding
+@cindex UTF-8
+@cindex Unicode
+
+@noindent
+A preinstantiation of GNAT.Encode_Strings for UTF-8 encoding.
+
@node GNAT.Exception_Actions (g-excact.ads)
@section @code{GNAT.Exception_Actions} (@file{g-excact.ads})
@cindex @code{GNAT.Exception_Actions} (@file{g-excact.ads})
hashcode are in the same order. These hashing functions are very
convenient for use with realtime applications.
+@node GNAT.Random_Numbers (g-rannum.ads)
+@section @code{GNAT.Random_Numbers} (@file{g-rannum.ads})
+@cindex @code{GNAT.Random_Numbers} (@file{g-rannum.ads})
+@cindex Random number generation
+
+@noindent
+Provides random number capabilities which extend those available in the
+standard Ada library and are more convenient to use.
+
@node GNAT.Regexp (g-regexp.ads)
@section @code{GNAT.Regexp} (@file{g-regexp.ads})
@cindex @code{GNAT.Regexp} (@file{g-regexp.ads})
@noindent
Provides classic counting and binary semaphores using protected types.
+@node GNAT.Serial_Communications (g-sercom.ads)
+@section @code{GNAT.Serial_Communications} (@file{g-sercom.ads})
+@cindex @code{GNAT.Serial_Communications} (@file{g-sercom.ads})
+@cindex Serial_Communications
+
+@noindent
+Provides a simple interface to send and receive data over a serial
+port. This is only supported on GNU/Linux and Windows.
+
+@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})
Provides subprograms that give access to source code information known at
compile time, such as the current file name and line number.
-@node GNAT.Spell_Checker (g-speche.ads)
-@section @code{GNAT.Spell_Checker} (@file{g-speche.ads})
-@cindex @code{GNAT.Spell_Checker} (@file{g-speche.ads})
+@node GNAT.Spelling_Checker (g-speche.ads)
+@section @code{GNAT.Spelling_Checker} (@file{g-speche.ads})
+@cindex @code{GNAT.Spelling_Checker} (@file{g-speche.ads})
@cindex Spell checking
@noindent
Provides a function for determining whether one string is a plausible
near misspelling of another string.
+@node GNAT.Spelling_Checker_Generic (g-spchge.ads)
+@section @code{GNAT.Spelling_Checker_Generic} (@file{g-spchge.ads})
+@cindex @code{GNAT.Spelling_Checker_Generic} (@file{g-spchge.ads})
+@cindex Spell checking
+
+@noindent
+Provides a generic function that can be instantiated with a string type for
+determining whether one string is a plausible near misspelling of another
+string.
+
@node GNAT.Spitbol.Patterns (g-spipat.ads)
@section @code{GNAT.Spitbol.Patterns} (@file{g-spipat.ads})
@cindex @code{GNAT.Spitbol.Patterns} (@file{g-spipat.ads})
to the resulting slices. This package is instantiated from
@code{GNAT.Array_Split}.
-@node GNAT.UTF_32 (g-utf_32.ads)
-@section @code{GNAT.UTF_32} (@file{g-table.ads})
-@cindex @code{GNAT.UTF_32} (@file{g-table.ads})
-@cindex Wide character codes
-
-@noindent
-This is a package intended to be used in conjunction with the
-@code{Wide_Character} type in Ada 95 and the
-@code{Wide_Wide_Character} type in Ada 2005 (available
-in @code{GNAT} in Ada 2005 mode). This package contains
-Unicode categorization routines, as well as lexical
-categorization routines corresponding to the Ada 2005
-lexical rules for identifiers and strings, and also a
-lower case to upper case fold routine corresponding to
-the Ada 2005 rules for identifier equivalence.
-
@node GNAT.Table (g-table.ads)
@section @code{GNAT.Table} (@file{g-table.ads})
@cindex @code{GNAT.Table} (@file{g-table.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})
@cindex @code{GNAT.Traceback.Symbolic} (@file{g-trasym.ads})
@cindex Trace back facilities
+@node GNAT.UTF_32 (g-utf_32.ads)
+@section @code{GNAT.UTF_32} (@file{g-table.ads})
+@cindex @code{GNAT.UTF_32} (@file{g-table.ads})
+@cindex Wide character codes
+
+@noindent
+This is a package intended to be used in conjunction with the
+@code{Wide_Character} type in Ada 95 and the
+@code{Wide_Wide_Character} type in Ada 2005 (available
+in @code{GNAT} in Ada 2005 mode). This package contains
+Unicode categorization routines, as well as lexical
+categorization routines corresponding to the Ada 2005
+lexical rules for identifiers and strings, and also a
+lower case to upper case fold routine corresponding to
+the Ada 2005 rules for identifier equivalence.
+
+@node GNAT.UTF_32_Spelling_Checker (g-u3spch.ads)
+@section @code{GNAT.Wide_Spelling_Checker} (@file{g-u3spch.ads})
+@cindex @code{GNAT.Wide_Spelling_Checker} (@file{g-u3spch.ads})
+@cindex Spell checking
+
@noindent
-Provides symbolic traceback information that includes the subprogram
-name and line number information.
+Provides a function for determining whether one wide wide string is a plausible
+near misspelling of another wide wide string, where the strings are represented
+using the UTF_32_String type defined in System.Wch_Cnv.
+
+@node GNAT.Wide_Spelling_Checker (g-wispch.ads)
+@section @code{GNAT.Wide_Spelling_Checker} (@file{g-wispch.ads})
+@cindex @code{GNAT.Wide_Spelling_Checker} (@file{g-wispch.ads})
+@cindex Spell checking
+
+@noindent
+Provides a function for determining whether one wide string is a plausible
+near misspelling of another wide string.
@node GNAT.Wide_String_Split (g-wistsp.ads)
@section @code{GNAT.Wide_String_Split} (@file{g-wistsp.ads})
to the resulting slices. This package is instantiated from
@code{GNAT.Array_Split}.
+@node GNAT.Wide_Wide_Spelling_Checker (g-zspche.ads)
+@section @code{GNAT.Wide_Wide_Spelling_Checker} (@file{g-zspche.ads})
+@cindex @code{GNAT.Wide_Wide_Spelling_Checker} (@file{g-zspche.ads})
+@cindex Spell checking
+
+@noindent
+Provides a function for determining whether one wide wide string is a plausible
+near misspelling of another wide wide string.
+
@node GNAT.Wide_Wide_String_Split (g-zistsp.ads)
@section @code{GNAT.Wide_Wide_String_Split} (@file{g-zistsp.ads})
@cindex @code{GNAT.Wide_Wide_String_Split} (@file{g-zistsp.ads})
is primarily intended to be used in connection with automated tools
for the generation of C++ interfaces.
-@node Interfaces.Os2lib (i-os2lib.ads)
-@section @code{Interfaces.Os2lib} (@file{i-os2lib.ads})
-@cindex @code{Interfaces.Os2lib} (@file{i-os2lib.ads})
-@cindex Interfacing, to OS/2
-@cindex OS/2 interfacing
-
-@noindent
-This package provides interface definitions to the OS/2 library.
-It is a thin binding which is a direct translation of the
-various @file{<bse@.h>} files.
-
-@node Interfaces.Os2lib.Errors (i-os2err.ads)
-@section @code{Interfaces.Os2lib.Errors} (@file{i-os2err.ads})
-@cindex @code{Interfaces.Os2lib.Errors} (@file{i-os2err.ads})
-@cindex OS/2 Error codes
-@cindex Interfacing, to OS/2
-@cindex OS/2 interfacing
-
-@noindent
-This package provides definitions of the OS/2 error codes.
-
-@node Interfaces.Os2lib.Synchronization (i-os2syn.ads)
-@section @code{Interfaces.Os2lib.Synchronization} (@file{i-os2syn.ads})
-@cindex @code{Interfaces.Os2lib.Synchronization} (@file{i-os2syn.ads})
-@cindex Interfacing, to OS/2
-@cindex Synchronization, OS/2
-@cindex OS/2 synchronization primitives
-
-@noindent
-This is a child package that provides definitions for interfacing
-to the @code{OS/2} synchronization primitives.
-
-@node Interfaces.Os2lib.Threads (i-os2thr.ads)
-@section @code{Interfaces.Os2lib.Threads} (@file{i-os2thr.ads})
-@cindex @code{Interfaces.Os2lib.Threads} (@file{i-os2thr.ads})
-@cindex Interfacing, to OS/2
-@cindex Thread control, OS/2
-@cindex OS/2 thread interfacing
-
-@noindent
-This is a child package that provides definitions for interfacing
-to the @code{OS/2} thread primitives.
-
@node Interfaces.Packed_Decimal (i-pacdec.ads)
@section @code{Interfaces.Packed_Decimal} (@file{i-pacdec.ads})
@cindex @code{Interfaces.Packed_Decimal} (@file{i-pacdec.ads})
is used primarily in a distribution context when using Annex E
with @code{GLADE}.
+@node System.Pool_Global (s-pooglo.ads)
+@section @code{System.Pool_Global} (@file{s-pooglo.ads})
+@cindex @code{System.Pool_Global} (@file{s-pooglo.ads})
+@cindex Storage pool, global
+@cindex Global storage pool
+
+@noindent
+This package provides a storage pool that is equivalent to the default
+storage pool used for access types for which no pool is specifically
+declared. It uses malloc/free to allocate/free and does not attempt to
+do any automatic reclamation.
+
+@node System.Pool_Local (s-pooloc.ads)
+@section @code{System.Pool_Local} (@file{s-pooloc.ads})
+@cindex @code{System.Pool_Local} (@file{s-pooloc.ads})
+@cindex Storage pool, local
+@cindex Local storage pool
+
+@noindent
+This package provides a storage pool that is intended for use with locally
+defined access types. It uses malloc/free for allocate/free, and maintains
+a list of allocated blocks, so that all storage allocated for the pool can
+be freed automatically when the pool is finalized.
+
@node System.Restrictions (s-restri.ads)
@section @code{System.Restrictions} (@file{s-restri.ads})
@cindex @code{System.Restrictions} (@file{s-restri.ads})
@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 95 Reference Manual::
+* 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
The two features are similar, and both are closely related to the mechanism
provided by the asm instruction in the GNU C compiler. Full understanding
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''.
+instruction, see @ref{Extended Asm,, Assembler Instructions with C Expression
+Operands, gcc, Using the GNU Compiler Collection (GCC)}.
Calls to the function @code{Asm} and the procedure @code{Asm} have identical
semantic restrictions and effects as described below. Both are provided so
optimizations with respect to the instruction specified should be
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.
+used. @xref{Extended Asm,, Assembler Instructions with C Expression Operands,
+gcc, Using the GNU Compiler Collection (GCC)}, for the full description.
+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
@cindex pragma @code{Shared_Passive}
the purpose of designating shared passive packages.
This allows the use of passive partitions in the
-context described in the Ada Reference Manual; i.e. for communication
+context described in the Ada Reference Manual; i.e., for communication
between separate partitions of a distributed application using the
features in Annex E.
@cindex Annex E
needed. The only requirement is that the two programs have a
common shared file system. It is even possible for programs
running on different machines with different architectures
-(e.g. different endianness) to communicate via the data in
+(e.g.@: different endianness) to communicate via the data in
a passive partition.
@item Persistence between program runs
Cr_Var1 (4) := 11;
for I in Cr_Var2'range loop
- Cr_Var2 (I) := =-1;
+ Cr_Var2 (I) := -1;
end loop;
@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 95 Reference Manual
-@section Strict Conformance to the Ada 95 Reference Manual
+@node Strict Conformance to the Ada Reference Manual
+@section Strict Conformance to the Ada Reference Manual
@noindent
-The dynamic semantics defined by the Ada 95 Reference Manual impose a set of
+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 95 Reference Manual. However, there are three checks that are not enabled
+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 95 Reference Manual can be achieved by adding
+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
Project files specify the options to be used when building a system.
Project files can specify global settings for all tools,
as well as tool-specific settings.
-See the chapter on project files in the GNAT Users guide for examples of use.
+@xref{Examples of Project Files,,, gnat_ugn, @value{EDITION} User's Guide},
+for examples of use.
@menu
* Reserved Words::
@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:
A typed_variable can only be declare once.
@noindent
-a non typed variable can be declared multiple times.
+a non-typed variable can be declared multiple times.
@noindent
Before the completion of its first declaration, the value of variable
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 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.
+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 single file name of a
+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.
+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" or "restricted".
+"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
the exported symbols of the object files of the interfaces. Additional symbols
in the object files are not added to the symbol file.
+"direct": The attribute Library_Symbol_File must be defined and must designate
+an existing file in the object directory. This symbol file is passed directly
+to the underlying linker without any symbol processing.
+
@item Main
Expression must be a list of strings that are legal file names.
These file names designate existing compilation units in the source directory
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}
@table @code
@item Switches
-This is a single attribute with a string list value. Each non empty string
+This is a single attribute with a string list value. Each nonempty string
in the list is an option when invoking @code{gnatls}.
@end table
@item Communication_Protocol
This is a simple string attribute. Its value is the name of the protocol
to use to communicate with the target in a cross-compilation environment,
-e.g. @code{"wtx"} or @code{"vxworks"}.
+e.g.@: @code{"wtx"} or @code{"vxworks"}.
@item Compiler_Command
This is an associative array attribute, whose domain is a language name. Its
@item VCS_Kind
This is a simple attribute. Its value is a string used to specify the
-Version Control System (VCS) to be used for this project, e.g CVS, RCS
+Version Control System (VCS) to be used for this project, e.g.@: CVS, RCS
ClearCase or Perforce.
@item VCS_File_Check
This is a simple attribute. Its value is a string that specifies
the command used by the VCS to check the validity of a 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
