xgnatugn.adb: Allow dots to be used in ug_words (-gnatw.c and -gnatw.C)

2007-04-20  Vincent Celier  <celier@adacore.com>
	    Robert Dewar  <dewar@adacore.com>

	* xgnatugn.adb: Allow dots to be used in ug_words (-gnatw.c and
	-gnatw.C)

	* gnat_ugn.texi: Fix ordering of -g switch for gnatmake
	Document gnatbind switch -a
	(case Constructions): Document that variables declarations are allowed
	for previously declared variables.
	Fix external lib project example
	-gnatg: Indicate new VMS qualifier /GNAT_INTERNAL
	Indicate that "#if not X or Y then" is not allowed in input files to
	gnatprep.
	Document gnatw.x and gnatw.X warning flags
	Mention -Winline switch to activate warnings when back-end inlining is
	ineffective.
	Add gnatcheck rule descriptions
	Describe how to use the GNAT driver to call a tool on a closure.
	Describe how to run project-wide checks or metrics.
	Document gnatbind's -R option
	Updated to account for Ada 2005 support

	* gnat_rm.texi (Case Construction): Allow variable declarations for
	previously declared variables.
	(Representation Clauses and Pragmas): Lift restriction on alignment
	clauses for record types.
	(Ada.Characters.*): Fix typo in reference to A.3.3(27).
	Document No_Exception_Propagation restriction
	Document No_Body pragma
	Updated to account for Ada 2005 support; corrected some typos
	(Implementation Defined Pragmas): Document pragma Universal_Aliasing.

	* gnat-style.texi: Make it clear that we never use mode IN for
	procedures or functions

	* ug_words: Add entries for -gnatw.x and -gnatw.X
	Add entries for -gnatw.c/.C

From-SVN: r125475

gcc/ada/gnat-style.texi

@@ -7,7 +7,7 @@
 @c                                                                            o
 @c                     G N A T   C O D I N G   S T Y L E                      o
 @c                                                                            o
-@c                     Copyright (C) 1992-2005, AdaCore                       o
+@c                     Copyright (C) 1992-2007, AdaCore                       o
 @c                                                                            o
 @c  GNAT is free software;  you can  redistribute it  and/or modify it under  o
 @c  terms of the  GNU General Public License as published  by the Free Soft-  o
@@ -43,13 +43,13 @@
 @titlefont{GNAT Coding Style:}
 @sp 1
 @title @hfill A Guide for GNAT Developers
-@subtitle GNAT, The GNU Ada 95 Compiler
+@subtitle GNAT, The GNU Ada Compiler
 @versionsubtitle
 @author Ada Core Technologies, Inc.
 @page
 @vskip 0pt plus 1filll
 
-Copyright @copyright{} 1995-2005, Free Software Foundation
+Copyright @copyright{} 1995-2007, Free Software Foundation
 
 Permission is granted to copy, distribute and/or modify this document
 under the terms of the GNU Free Documentation License, Version 1.1
@@ -73,7 +73,7 @@ GNAT Coding Style@*
 A Guide for GNAT Developers
 @sp 2
 @noindent
-GNAT, The GNU Ada 95 Compiler@*
+GNAT, The GNU Ada Compiler@*
 
 @noindent
 Permission is granted to copy, distribute and/or modify this document
@@ -640,7 +640,7 @@ is a blank line before the @code{begin} keyword:
 @itemize @bullet
 
 @item
-Do not write the @code{in} for parameters, especially in functions:
+Do not write the @code{in} for parameters.
 
 @smallexample @c adanocomment
       function Length (S : String) return Integer;

gcc/ada/gnat_rm.texi

@@ -8,7 +8,7 @@
 @c                                                                            o
 @c                              G N A T _ RM                                  o
 @c                                                                            o
-@c              Copyright (C) 1995-2006 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
@@ -18,6 +18,9 @@
 @setfilename gnat_rm.info
 
 @set EDITION GNAT
+@set DEFAULTLANGUAGEVERSION Ada 2005
+@set NONDEFAULTLANGUAGEVERSION Ada 95
+
 @settitle GNAT Reference Manual
 
 @setchapternewpage odd
@@ -31,7 +34,7 @@
 @end direntry
 
 @copying
-Copyright @copyright{} 1995-2004, Free Software Foundation
+Copyright @copyright{} 1995-2007, Free Software Foundation
 
 Permission is granted to copy, distribute and/or modify this document
 under the terms of the GNU Free Documentation License, Version 1.2
@@ -44,9 +47,9 @@ entitled ``GNU Free Documentation License''.
 
 @titlepage
 @title GNAT Reference Manual
-@subtitle GNAT, The GNU Ada 95 Compiler
+@subtitle GNAT, The GNU Ada Compiler
 @versionsubtitle
-@author Ada Core Technologies, Inc.
+@author AdaCore
 @page
 @vskip 0pt plus 1filll
 
@@ -62,7 +65,7 @@ entitled ``GNU Free Documentation License''.
 GNAT Reference Manual
 
 @noindent
-GNAT, The GNU Ada 95 Compiler@*
+GNAT, The GNU Ada Compiler@*
 GCC version @value{version-GCC}@*
 
 @noindent
@@ -156,6 +159,7 @@ Implementation Defined Pragmas
 * Pragma Long_Float::
 * Pragma Machine_Attribute::
 * Pragma Main_Storage::
+* Pragma No_Body::
 * Pragma No_Return::
 * Pragma No_Strict_Aliasing ::
 * Pragma Normalize_Scalars::
@@ -181,11 +185,11 @@ Implementation Defined Pragmas
 * Pragma Task_Info::
 * Pragma Task_Name::
 * Pragma Task_Storage::
-* Pragma Thread_Body::
 * Pragma Time_Slice::
 * Pragma Title::
 * Pragma Unchecked_Union::
 * Pragma Unimplemented_Unit::
+* Pragma Universal_Aliasing ::
 * Pragma Universal_Data::
 * Pragma Unreferenced::
 * Pragma Unreferenced_Objects::
@@ -410,7 +414,7 @@ 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::
 
 Project File Reference
 
@@ -426,26 +430,26 @@ Index
 @node About This Guide
 @unnumbered About This Guide
 
-@ifclear PROEDITION
-@noindent
-This manual contains useful information in writing programs using the
-GNAT compiler.  It includes information on implementation dependent
-characteristics of GNAT, including all the information required by Annex
-M of the standard.
-@end ifclear
-
-@ifset PROEDITION
 @noindent
 This manual contains useful information in writing programs using the
-GNAT Pro compiler.  It includes information on implementation dependent
-characteristics of GNAT Pro, including all the information required by Annex
-M of the standard.
-@end ifset
-
-Ada 95 is designed to be highly portable.
+@value{EDITION} compiler.  It includes information on implementation dependent
+characteristics of @value{EDITION}, including all the information required by
+Annex M of the Ada language standard.
+
+@value{EDITION} implements Ada 95 and Ada 2005, and it may also be invoked in
+Ada 83 compatibility mode.
+By default, @value{EDITION} assumes @value{DEFAULTLANGUAGEVERSION},
+but you can override with a compiler switch
+to explicitly specify the language version.
+(Please refer to the section ``Compiling Different Versions of Ada'', in
+@cite{@value{EDITION} User's Guide}, for details on these switches.)
+Throughout this manual, references to ``Ada'' without a year suffix
+apply to both the Ada 95 and Ada 2005 versions of the language.
+
+Ada is designed to be highly portable.
 In general, a program will have the same effect even when compiled by
 different compilers on different platforms.
-However, since Ada 95 is designed to be used in a
+However, since Ada is designed to be used in a
 wide variety of applications, it also contains a number of system
 dependent features to be used in interfacing to the external world.
 @cindex Implementation-dependent features
@@ -542,11 +546,17 @@ obsolescent forms are retained for backwards compatibility.
 
 @end itemize
 
-@cindex Ada 95 ISO/ANSI Standard
+@cindex Ada 95 Language Reference Manual
+@cindex Ada 2005 Language Reference Manual
 @noindent
-This reference manual assumes that you are familiar with Ada 95
-language, as described in the International Standard
-ANSI/ISO/IEC-8652:1995, Jan 1995.
+This reference manual assumes a basic familiarity with the Ada 95 language, as
+described in the International Standard ANSI/ISO/IEC-8652:1995,
+January 1995.
+It does not require knowledge of the new features introduced by Ada 2005,
+(officially known as ISO/IEC 8652:1995 with Technical Corrigendum 1
+and Amendment 1).
+Both reference manuals are included in the GNAT documentation
+package.
 
 @node Conventions
 @unnumberedsec Conventions
@@ -607,11 +617,21 @@ material for the Ada 95 programming language.
 
 @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.
@@ -627,12 +647,12 @@ compiler system.
 @chapter Implementation Defined Pragmas
 
 @noindent
-Ada 95 defines a set of pragmas that can be used to supply additional
+Ada defines a set of pragmas that can be used to supply additional
 information to the compiler.  These language defined pragmas are
-implemented in GNAT and work as described in the Ada 95 Reference
+implemented in GNAT and work as described in the Ada Reference
 Manual.
 
-In addition, Ada 95 allows implementations to define additional pragmas
+In addition, Ada allows implementations to define additional pragmas
 whose meaning is defined by the implementation.  GNAT provides a number
 of these implementation-dependent pragmas which can be used to extend
 and enhance the functionality of the compiler.  This section of the GNAT
@@ -704,6 +724,7 @@ consideration, the use of these pragmas should be minimized.
 * Pragma Long_Float::
 * Pragma Machine_Attribute::
 * Pragma Main_Storage::
+* Pragma No_Body::
 * Pragma No_Return::
 * Pragma No_Strict_Aliasing::
 * Pragma Normalize_Scalars::
@@ -729,11 +750,11 @@ consideration, the use of these pragmas should be minimized.
 * Pragma Task_Info::
 * Pragma Task_Name::
 * Pragma Task_Storage::
-* Pragma Thread_Body::
 * Pragma Time_Slice::
 * Pragma Title::
 * Pragma Unchecked_Union::
 * Pragma Unimplemented_Unit::
+* Pragma Universal_Aliasing ::
 * Pragma Universal_Data::
 * Pragma Unreferenced::
 * Pragma Unreferenced_Objects::
@@ -778,14 +799,14 @@ A configuration pragma that establishes Ada 83 mode for the unit to
 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
@@ -1056,7 +1077,7 @@ pragma Compile_Time_Error
 @noindent
 This pragma can be used to generate additional compile time
 error messages. It
-is particularly useful in generics, where errrs can be issued for
+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
@@ -1269,7 +1290,9 @@ 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}).
+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.
@@ -1647,6 +1670,9 @@ MECHANISM_ASSOCIATION ::=
 MECHANISM_NAME ::=
   Value
 | Reference
+| Descriptor [([Class =>] CLASS_NAME)]
+
+CLASS_NAME ::= ubs | ubsb | uba | s | sb | a
 @end smallexample
 
 @noindent
@@ -1676,8 +1702,7 @@ anonymous access parameter.
 
 @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
@@ -1746,6 +1771,9 @@ MECHANISM_ASSOCIATION ::=
 MECHANISM_NAME ::=
   Value
 | Reference
+| Descriptor [([Class =>] CLASS_NAME)]
+
+CLASS_NAME ::= ubs | ubsb | uba | s | sb | a
 @end smallexample
 
 @noindent
@@ -1760,8 +1788,7 @@ pragma that specifies the desired foreign convention.
 
 @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
@@ -1826,6 +1853,9 @@ MECHANISM_ASSOCIATION ::=
 MECHANISM_NAME ::=
   Value
 | Reference
+| Descriptor [([Class =>] CLASS_NAME)]
+
+CLASS_NAME ::= ubs | ubsb | uba | s | sb | a
 @end smallexample
 
 @noindent
@@ -1845,8 +1875,7 @@ pragma that specifies the desired foreign convention.
 
 @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
@@ -1870,7 +1899,7 @@ pragma Extend_System ([Name =>] IDENTIFIER);
 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
@@ -1944,7 +1973,7 @@ with Import and Export pragmas.  There are two cases to consider:
 @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
@@ -1952,7 +1981,7 @@ arguments, as in:
 @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
@@ -1968,7 +1997,7 @@ specified using an identifier rather than a string.
 
 @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
@@ -2436,7 +2465,7 @@ pragma Interface (
 
 @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
@@ -2909,6 +2938,29 @@ This pragma is provided for compatibility with OpenVMS VAX Systems.  It has
 no effect in GNAT, other than being syntax checked.  Note that the pragma
 also has no effect in DEC Ada 83 for OpenVMS Alpha Systems.
 
+@node Pragma No_Body
+@unnumberedsec Pragma No_Body
+@findex No_Body
+@noindent
+Syntax:
+
+@smallexample @c ada
+pragma No_Body;
+@end smallexample
+
+@noindent
+There are a number of cases in which a package spec does not require a body,
+and in fact a body is not permitted. GNAT will not permit the spec to be
+compiled if there is a body around. The pragma No_Body allows you to provide
+a body file, even in a case where no body is allowed. The body file must
+contain only comments and a single No_Body pragma. This is recognized by
+the compiler as indicating that no body is logically present.
+
+This is particularly useful during maintenance when a package is modified in
+such a way that a body needed before is no longer needed. The provision of a
+dummy body with a No_Body pragma ensures that there is no inteference from
+earlier versions of the package body.
+
 @node Pragma No_Return
 @unnumberedsec Pragma No_Return
 @findex No_Return
@@ -3649,7 +3701,7 @@ pragma Stream_Convert
 @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
@@ -3925,46 +3977,6 @@ created, depending on the target.  This pragma can appear anywhere a
 @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
@@ -4026,7 +4038,7 @@ 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 RM, section B.3.3.
+details, consult the Ada 2005 Reference Manual, section B.3.3.
 
 @node Pragma Unimplemented_Unit
 @unnumberedsec Pragma Unimplemented_Unit
@@ -4048,6 +4060,25 @@ a clean manner.
 The abort only happens if code is being generated.  Thus you can use
 specs of unimplemented packages in syntax or semantic checking mode.
 
+@node Pragma Universal_Aliasing
+@unnumberedsec Pragma Universal_Aliasing
+@findex Universal_Aliasing
+@noindent
+Syntax:
+
+@smallexample @c ada
+pragma Universal_Aliasing [([Entity =>] type_LOCAL_NAME)];
+@end smallexample
+
+@noindent
+@var{type_LOCAL_NAME} must refer to a type declaration in the current
+declarative part.  The effect is to inhibit strict type-based aliasing
+optimization for the given type.  In other words, the effect is as though
+access types designating this type were subject to pragma No_Strict_Aliasing.
+For a detailed description of the strict aliasing optimization, and the
+situations in which it must be suppressed, see section
+``Optimization and Strict Aliasing'' in the @value{EDITION} User's Guide.
+
 @node Pragma Universal_Data
 @unnumberedsec Pragma Universal_Data
 @findex Universal_Data
@@ -4218,8 +4249,8 @@ pragma Use_VADS_Size;
 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.
 
@@ -4293,12 +4324,12 @@ 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
@@ -4484,7 +4515,7 @@ end External_Module;
 Syntax:
 
 @smallexample @c ada
-pragma Wide_Character_Encoding (IDENTIFIER | CHRARACTER_LITERAL);
+pragma Wide_Character_Encoding (IDENTIFIER | CHARACTER_LITERAL);
 @end smallexample
 
 @noindent
@@ -4505,13 +4536,13 @@ 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
@@ -4684,8 +4715,8 @@ the containing record @var{R}.
 @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:
 
@@ -4700,7 +4731,7 @@ pragma Import (Ada, L);
 @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.
 
@@ -5136,7 +5167,8 @@ this attribute.
 @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
@@ -5293,7 +5325,7 @@ conversion to a desired access type.  In GNAT, but not necessarily in
 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
@@ -5344,21 +5376,20 @@ prefix) provides the value @code{System.Word_Size}.
 @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
@@ -6233,7 +6264,7 @@ 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
+in the Ada Reference Manual is @code{Interfaces.CPP}, used
 for interfacing to C++.
 
 @sp 1
@@ -6792,9 +6823,9 @@ Followed.
 
 @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
@@ -6810,7 +6841,7 @@ handles the implementation dependence.
 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
@@ -7168,9 +7199,9 @@ corresponding @file{ALI} file as the input parameter to the binder.
 @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
@@ -7589,8 +7620,19 @@ must define with the following profile:
    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
@@ -7771,20 +7813,20 @@ is made to queue a second task on such an entry.
 @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
@@ -8166,7 +8208,8 @@ attribute.  See C.7.1(7).
 @noindent
 The result of this attribute is a string that identifies
 the object or component that denotes a given task. If a variable Var has a task
-type, the image for this task will have the form Var_XXXXXXXX, where the sufffix
+type, the image for this task will have the form Var_XXXXXXXX, where the
+suffix
 is the hexadecimal representation of the virtual address of the corresponding
 task control block. If the variable is an array of tasks, the image of each
 task will have the form of an indexed component indicating the position of a
@@ -8177,8 +8220,9 @@ 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
+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
@@ -8326,7 +8370,7 @@ requesting the lock.
 @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
@@ -8860,7 +8904,7 @@ source line.
 @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:
@@ -9027,36 +9071,24 @@ strict alignment.
 @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
@@ -9361,14 +9393,15 @@ enumeration types for which a representation clause is given.
 @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;
@@ -9385,8 +9418,8 @@ from Ada 83 to Ada 95.  For example, consider:
 @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
@@ -9505,9 +9538,9 @@ subtype x6 is x2'base range 0 .. dynamic;   8               3*
 @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
@@ -9980,8 +10013,9 @@ Then the component size of @code{ar} will be set to 5 (i.e.@: to @code{r'size},
 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
@@ -10038,11 +10072,12 @@ In all commonly used Ada 83 compilers, this pragma Pack would be ignored,
 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;
@@ -10470,9 +10505,9 @@ In both of these cases, @code{A}
 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)):
 
@@ -10528,6 +10563,14 @@ are essentially of type int.  If pragma @code{Convention C} is specified for an
 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
@@ -10714,26 +10757,25 @@ the actual representation to be used.
 @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)
@@ -11077,7 +11119,8 @@ be unaligned in this case).
 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.
@@ -11218,14 +11261,14 @@ types are @code{Wide_Character} and @code{Wide_String} instead of
 
 @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
@@ -11403,9 +11446,9 @@ On some Ada implementations, this will print @code{hell}, but the program is
 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
@@ -11446,10 +11489,10 @@ or @code{Put_Line}.  There will be no @code{FF} character at the end of
 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:
@@ -12020,7 +12063,7 @@ it is possible to read beyond an end of file.
 
 @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.
 
@@ -12038,7 +12081,7 @@ manner described for stream attributes.
 @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.
 
@@ -12065,7 +12108,7 @@ multiple accesses to the same external files using separate streams.
 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
@@ -12092,7 +12135,7 @@ completely.
 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
@@ -12554,7 +12597,7 @@ RM-defined package @code{Ada.Characters.Latin_1} but with the
 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})
@@ -12568,7 +12611,7 @@ RM-defined package @code{Ada.Characters.Latin_1} but with the
 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})
@@ -12582,7 +12625,7 @@ GNAT defined package @code{Ada.Characters.Latin_9} but with the
 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})
@@ -12596,7 +12639,7 @@ RM-defined package @code{Ada.Characters.Latin_1} but with the
 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})
@@ -12610,7 +12653,7 @@ GNAT defined package @code{Ada.Characters.Latin_9} but with the
 types of the constants being @code{Wide_Wide_Character}
 instead of @code{Character}.  The provision of such a package
 is specifically authorized by the Ada Reference Manual
-(RM A.3(27)).
+(RM A.3.3(27)).
 
 @node Ada.Command_Line.Remove (a-colire.ads)
 @section @code{Ada.Command_Line.Remove} (@file{a-colire.ads})
@@ -12920,10 +12963,6 @@ of this algorithm see
 @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})
@@ -13006,8 +13045,9 @@ Provides a simple interface to handle Ctrl-C keyboard events.
 
 @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)
@@ -13033,8 +13073,8 @@ to and from string images of address values. Supports both C and Ada formats
 for hexadecimal literals.
 
 @node GNAT.Directory_Operations (g-dirope.ads)
-@section @code{GNAT.Directory_Operations} (g-dirope.ads)
-@cindex @code{GNAT.Directory_Operations} (g-dirope.ads)
+@section @code{GNAT.Directory_Operations} (@file{g-dirope.ads})
+@cindex @code{GNAT.Directory_Operations} (@file{g-dirope.ads})
 @cindex Directory operations
 
 @noindent
@@ -13514,7 +13554,8 @@ in various debugging situations.
 
 @noindent
 Provides symbolic traceback information that includes the subprogram
-name and line number information.
+name and line number information. Note that this capability is not available
+on all targets, see g-trasym.ads for list of supported targets.
 
 @node GNAT.Wide_String_Split (g-wistsp.ads)
 @section @code{GNAT.Wide_String_Split} (@file{g-wistsp.ads})
@@ -13755,7 +13796,7 @@ the package @code{System.Wch_Cnv}.
 @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.
 
@@ -13870,14 +13911,14 @@ with pragma @code{Import}) as corresponding to a C++ constructor.
 
 @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.
 
@@ -13887,7 +13928,7 @@ 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
@@ -13907,9 +13948,9 @@ types with fixed bounds.
 @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)
@@ -13930,8 +13971,9 @@ The Information Systems annex is fully implemented.
 @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
@@ -13947,15 +13989,16 @@ facilities.
 * 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
@@ -13971,7 +14014,8 @@ 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''.
+Language Family'' @result{} ``Assembler Instructions with C Expression
+Operands''.
 
 Calls to the function @code{Asm} and the procedure @code{Asm} have identical
 semantic restrictions and effects as described below.  Both are provided so
@@ -14546,7 +14590,7 @@ was used by some Ada83 compilers, where the @code{Name} component above
 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
@@ -14585,20 +14629,20 @@ aliasing all views of the object (which may be manipulated by different tasks,
 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
@@ -14648,7 +14692,7 @@ See the chapter on project files in the GNAT Users guide for examples of use.
 @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:
 
@@ -14665,9 +14709,9 @@ 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:
@@ -14943,17 +14987,19 @@ and must be writable.
 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
@@ -14979,6 +15025,10 @@ will fail to build if there are symbols in the symbol file that are not in
 the exported symbols of the object files of the interfaces. Additional symbols
 in the object files are not added to the symbol file.
 
+"direct": The attribute Library_Symbol_File must be defined and must designate
+an existing file in the object directory. This symbol file is passed directly
+to the underlying linker without any symbol processing.
+
 @item  Main
 Expression must be a list of strings that are legal file names.
 These file names designate existing compilation units in the source directory
@@ -15057,8 +15107,8 @@ external value either on the command line or in the environment.
 @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
@@ -15069,7 +15119,10 @@ case_construction ::=
 
 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@} |
@@ -15077,6 +15130,9 @@ discrete_choice_list ::=
 @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}

gcc/ada/ug_words

@@ -116,6 +116,8 @@ gcc -c          ^ GNAT COMPILE
 -gnatwB         ^ /WARNINGS=NO_BAD_FIXED_VALUES
 -gnatwc         ^ /WARNINGS=CONDITIONALS
 -gnatwC         ^ /WARNINGS=NOCONDITIONALS
+-gnatw.c        ^ /WARNINGS=MISSING_COMPONENT_CLAUSES
+-gnatw.C        ^ /WARNINGS=NOMISSING_COMPONENT_CLAUSES
 -gnatwd         ^ /WARNINGS=IMPLICIT_DEREFERENCE
 -gnatwD         ^ /WARNINGS=NOIMPLICIT_DEREFERENCE
 -gnatwe         ^ /WARNINGS=ERRORS
@@ -155,6 +157,8 @@ gcc -c          ^ GNAT COMPILE
 -gnatwW         ^ /WARNINGS=NOLOWBOUND_ASSUMED
 -gnatwx         ^ /WARNINGS=IMPORT_EXPORT_PRAGMAS
 -gnatwX         ^ /WARNINGS=NOIMPORT_EXPORT_PRAGMAS
+-gnatw.x        ^ /WARNINGS=LOCAL_RAISE_HANDLING
+-gnatw.X        ^ /WARNINGS=NOLOCAL_RAISE_HANDLING
 -gnatwy         ^ /WARNINGS=ADA_2005_COMPATIBILITY
 -gnatwY         ^ /WARNINGS=NOADA_2005_COMPATIBILITY
 -gnatwz         ^ /WARNINGS=UNCHECKED_CONVERSIONS

gcc/ada/xgnatugn.adb

@@ -477,7 +477,7 @@ procedure Xgnatugn is
                   Non_Word_Character : constant Natural :=
                                          Index (Source,
                                                 Word_Characters or
-                                                  To_Set (" "),
+                                                  To_Set (" ."),
                                                 Outside);
 
                begin