CVS difference for ais/ai-00285.txt

Differences between 1.18 and version 1.19
Log of other versions for file ais/ai-00285.txt

--- ais/ai-00285.txt	2004/09/04 01:13:44	1.18
+++ ais/ai-00285.txt	2004/10/05 22:49:09	1.19
@@ -1,5 +1,96 @@
-!standard A.3.2(49)                                    04-08-27  AI95-00285/09
+!standard 2.1(1)                                      04-09-27  AI95-00285/10
+!standard 2.1(2)
+!standard 2.1(3)
+!standard 2.1(4)
+!standard 2.1(5)
+!standard 2.1(7)
+!standard 2.1(8)
+!standard 2.1(9)
+!standard 2.1(10)
+!standard 2.1(11)
+!standard 2.1(12)
+!standard 2.1(13)
+!standard 2.1(14)
+!standard 2.1(15)
+!standard 2.1(16)
+!standard 2.1(17)
+!standard 0.3(32)
+!standard 0.3(34)
+!standard 1.1.4(14)
+!standard 2.2(03)
+!standard 2.2(04)
+!standard 2.2(05)
+!standard 2.2(08)
+!standard 2.2(09)
+!standard 2.3(02)
+!standard 2.3(03)
+!standard 2.3(05)
+!standard 2.6(06)
+!standard 3.5(28)
+!standard 3.5(29)
+!standard 3.5(34)
+!standard 3.5(37)
+!standard 3.5(40)
+!standard 3.5(41)
+!standard 3.5(42)
+!standard 3.5(43)
+!standard 3.5(44)
+!standard 3.5(45)
+!standard 3.5(51)
+!standard 3.5(55)
+!standard 3.5(56)
+!standard 3.5(59)
+!standard 3.5.2(2)
+!standard 3.5.2(3)
+!standard 3.5.2(4)
+!standard 3.5.2(5)
+!standard 3.6.3(2)
+!standard 3.6.3(4)
+!standard A.1(36)
+!standard A.1(42)
+!standard A.1(49)
+!standard A.3(1)
+!standard A.3.2(13)
+!standard A.3.2(14)
+!standard A.3.2(16)
+!standard A.3.2(18)
+!standard A.3.2(42)
+!standard A.3.2(43)
+!standard A.3.2(44)
+!standard A.3.2(45)
+!standard A.3.2(46)
+!standard A.3.2(47)
+!standard A.3.2(48)
+!standard A.3.2(49)
+!standard A.4(1)
+!standard A.4.1(4)
+!standard A.4.8(1)
+!standard A.6(1)
+!standard A.7(4)
+!standard A.7(10)
+!standard A.7(13)
+!standard A.7(15)
+!standard A.11(00)
+!standard A.11(01)
+!standard A.11(02)
+!standard A.11(03)
+!standard A.12(01)
+!standard A.12.4(01)
+!standard B.3(39)
+!standard B.3(40)
+!standard B.3(60)
+!standard C.5(07)
+!standard F(04)
+!standard F.3(01)
+!standard F.3(06)
+!standard F.3(19)
+!standard F.3(20)
+!standard F.3.5(01)
+!standard G.1.5(01)
+!standard H.4(20)
 !class amendment 02-01-23
+!status Amendment 200Y 04-09-27
+!status ARG Approved 8-0-1  04-09-17
 !status work item 02-09-24
 !status received 02-01-15
 !priority Medium
@@ -198,44 +289,38 @@
 changing the definition of space or blank, so characters like NO-BREAK SPACE or
 IDEOGRAPHIC SPACE are not considered to be space or blank in this context.
 
-SC22/WG14 is considering the inclusion of support for Unicode 16- and 32-bit
-characters in C. Their proposal is presented in ISO/IEC TR 19769
-(http://std.dkuug.dk/JTC1/SC22/WG14/www/docs/n1040.pdf). At the time of this
-writing, this technical report is in the FDIS ballot stage. In order to provide
+SC22/WG14 is planning to include support for Unicode 16- and 32-bit characters
+in C. Their proposal is presented in ISO/IEC TR 19769:2004
+(http://std.dkuug.dk/JTC1/SC22/WG14/www/docs/n1040.pdf). In order to provide
 compatibility with the upcoming C standard, new types are added to Interfaces.C
 that correspond to C char16_t and char32_t. It is recognized that adding new
 declarations to predefined units can cause incompatibilities, but it is thought
 that the new identifiers are unlikely to conflict with existing code.
 
-<<Open Issue #1>>
+There has been considerable discussion in the ARG regarding the best reference
+material to use for this AI. ISO/IEC 10646:2003, ISO/IEC TR 10176 (4th edition)
+and Unicode 4.0 are all relevant. To clarify the matter, we presented an
+earlier version of this AI (version 8) to the September 2004 SC22 plenary
+meeting in Jeju, Korea (document N3758). SC22 passed the following resolution:
+
+"Resolution 04-15: Coded Character Sets: JTC 1/SC 22 agrees that the proposed
+implementation of coded character set support described in document N 3758
+agrees with the principles for coded character set support previously adopted by
+SC 22, notably resolution 02-24. JTC 1/SC 22 instructs WG 9 to consider
+referencing ISO/IEC TR 10176 Annex A in the revision of the Ada language
+standard."
 
-Some countries have expressed concern about referencing Unicode in the Ada
-standard. It must be noted that ISO/IEC 10646:2003 *does* reference version 4.0
-of the Unicode standard, including in normative text. In order to avoid direct
-references to Unicode in the wording below, I am referencing the various
-documents indirectly through ISO/IEC 10646:2003. The Unicode documents that are
-needed for this AI are (1) the character categorization database and (2) the
-case folding table. It would be possible to state the categorization and folding
-rules explicitly in the RM, but that would add a few pages of incomprehensible
-gibberish that would be hard to maintain.
-
-Another option would be to reference annex A of ISO/IEC TR 10176:2002. However
-there are two issues with this approach. The first one is that this annex is
-based on Unicode 3.0, so there would probably be inconsistencies with ISO/IEC
-10646:2003. The second is that this TR (with contains guidelines for the
-preparation of language standards) is completely at odd with the way the Ada RM
-is written. If we reference one bit of it, it begs the question: why are we not
-complying with the entire document?
+The AARM note in section 2.1(4-14) of the wording explains why we decided to
+use ISO/IEC 10646:2003 and Unicode 4.0 instead of ISO/IEC TR 10176.
 
-
 !wording
 
-In (32) change:
+In Introduction (32) change:
 
 ... Character, [and Wide_Character]{Wide_Character, and Wide_Wide_Character} ...
 
 
-In (34) change:
+In Introduction (34) change:
 
 ... String [and Wide_String]{, Wide_String, and Wide_Wide_String} ...
 
@@ -334,18 +419,88 @@
 (LINE FEED(LF)), 16#0B# (LINE TABULATION), 16#0C# (FORM FEED(FF)), 16#0D#
 (CARRIAGE RETURN(CR)), 16#85# (NEXT LINE(NEL)), and the characters in categories
 separator_line and separator_paragraph.  The names mentioned in parenthese in
-this list are *not* defined by ISO/IEC 10646; they are only used for convenience
-in this International Standard.
+this list are not defined by ISO/IEC 10646:2003; they are only used for
+convenience in this International Standard.
 
 graphic_character
 Any character which is not in the categories other_control, other_private_use,
 other_surrogate, other_format, format_effector, and whose code position is
 neither 16#FFFE# nor 16#FFFF#.
 
+
+AARM NOTE
+
+We considered basing the definition of lexical elements on Annex A of ISO/IEC
+TR 10176 (4th edition), which lists the characters which should be supported in
+identifiers for all programming languages, but we finally decided against this
+option. Note that it is not our intent to diverge from ISO/IEC TR 10176,
+except to the extent that ISO/IEC TR 10176 itself diverges from ISO/IEC
+10646:2003 (which is the case at the time of this writing).
+
+More precisely, we intend to align strictly with ISO/IEC 10646:2003. It must be
+noted that ISO/IEC TR 10176 is a Technical Report while ISO/IEC 10646:2003 is a
+Standard. If one has to make a choice, one should conform with the Standard
+rather than with the Technical Report. And, it turns out that one *must* make a
+choice because there are important differences between the two:
+
+o  ISO/IEC TR 10176 is still based on ISO/IEC 10646:2000 while ISO/IEC
+10646:2003 has already been published for a year.
+
+o  There are considerable differences between the two editions of ISO/IEC 10646,
+notably in supporting characters beyond the BMP (this might be significant for
+some languages, e.g. Korean).
+
+o  ISO/IEC TR 10176 is a moving target. It is in its fourth edition already, and
+nevertheless needs additional revision to catch up with ISO/IEC 10646:2003. We
+cannot afford to revise the Ada language and the vendors cannot afford to change
+the compilers each time ISO/IEC TR 10176 changes. And we cannot afford to delay
+the adoption of our amendment until ISO/IEC TR 10176 has been revised; we would
+run out of interest, money, and the ISO time table before then.
+
+o  ISO/IEC TR 10176 does not define case conversion tables, which are essential
+for a case-insensitive language like Ada. To get case conversion tables, we
+would have to reference either ISO/IEC 10646:2003 or Unicode, or we would have
+to invent our own.
+
+For the purpose of defining the lexical elements of the language, we need
+character properties like categorization, as well as case conversion tables.
+These are mentioned in ISO/IEC 10646:2003 as useful for implementations, with a
+reference to Unicode. Machine-readable tables are available on the web at URLs:
+
+http://www.unicode.org/Public/4.0-Update/UnicodeData-4.0.0.txt
+http://www.unicode.org/Public/4.0-Update/CaseFolding-4.0.0.txt
+
+with an explanatory document found at URL:
+
+http://www.unicode.org/Public/4.0-Update/UCD-4.0.0.html
+
+The actual text of the standard only makes specific references to the
+corresponding clauses of ISO/IEC 10646:2003, not to Unicode.
+
+END AARM NOTE
+
+
+Change 2.1(15):
+
+Replace the leading sentence by:
+The following names are used when referring to certain characters
+(the first name is that given in ISO/IEC 10646:2003):
+
+Replace "symbol" by "graphic symbol" in the column headers.
+
+Delete the last four characters (Ada doesn't use brackets).
+
+Add  !  Exclamation Mark and %  Percent Sign to the table.
+
+Replace the AARM Note:
 
-Delete 2.1(15).
+This table serves to show the correspondence between ISO 10646
+names and the graphic symbols (glphys) used in this International Standard.
+These are the characters that play a special role in the syntax of Ada.
 
 
+Delete 2.1(16).
+
 Delete 2.1(17).
 
 
@@ -360,28 +515,10 @@
 
 o   Character Tabulation is a separator except within a comment.
 
-
-Replace 2.2(8-9) by:
-
-A delimiter is either one of the characters whose name is:
 
-o   AMPERSAND
-o   APOSTROPHE
-o   LEFT PARENTHESIS
-o   RIGHT PARENTHESIS
-o   ASTERISK
-o   PLUS SIGN
-o   COMMA
-o   HYPHEN-MINUS
-o   FULL STOP
-o   SOLIDUS
-o   COLON
-o   SEMICOLON
-o   LESS-THAN SIGN
-o   EQUALS SIGN
-o   GREATER-THAN SIGN
-o   VERTICAL LINE
+Replace 2.2(8) by:
 
+A delimiter is either one of the following characters:
 
 Replace 2.3(2-3) by:
 
@@ -467,7 +604,7 @@
 For the evaluation of a call on S'Wide_Wide_Value for an enumeration subtype S,
 if the sequence of characters of the parameter (ignoring leading and trailing
 spaces) has the syntax of an enumeration literal and if it corresponds to a
-literal of the type of S (or corresponds to the result of S'Wide_Image for a
+literal of the type of S (or corresponds to the result of S'Wide_Wide_Image for a
 nongraphic character of the type), the result is the corresponding enumeration
 value; otherwise Constraint_Error is raised.
 
@@ -498,7 +635,7 @@
 corresponds to the result of S'Wide_Image for a value of the type), the result
 is the corresponding enumeration value; otherwise Constraint_Error is raised.
 For a numeric subtype S, the evaluation of a call on S'Wide_Value with Arg of
-type String is equivalent to a call on S'Wide_Wide_Value for a corresponding
+type Wide_String is equivalent to a call on S'Wide_Wide_Value for a corresponding
 Arg of type Wide_Wide_String.
 
 
@@ -526,8 +663,15 @@
 Wide_Wide_Image, Value, Wide_Value, and Wide_Wide_Value}
 
 
-Add after 3.5.2(3):
+Replace 3.5.2(3) with:
 
+The predefined type Wide_Character is a character type whose values correspond
+to the 65536 code positions of the ISO/IEC 10646:2003 Basic Multilingual Plane (BMP).
+Each of the graphic characters of the BMP has a corresponding character_literal
+in Wide_Character. The first 256 values of Wide_Character have the same
+character_literal or language-defined name as defined for Character.
+Each of the graphic_characters have a corresponding character_literal.
+
 The predefined type Wide_Wide_Character is a character type whose values
 correspond to the 2147483648 code positions of the ISO/IEC 10646:2003 character
 set. Each of the graphic_characters has a corresponding character_literal in
@@ -599,7 +743,7 @@
 
 In A.3.2(13) change:
 
-... between {Wide_Wide_Character, } Wide_Character ...
+... between {Wide_Wide_Character, } Wide_Character{,} ...
 
 
 Add after A.3.2(14):
@@ -716,7 +860,7 @@
 
 In A.4(1) change:
 
-... both String [and Wide_String]{, Wide_String, and Wide_Wide_String} ...
+... [both] String [and Wide_String]{, Wide_String, and Wide_Wide_String} ...
 
 
 Add after A.4.1(4):
@@ -726,7 +870,7 @@
 
 Add after A.4.7 a new section, A.4.8:
 
-A.4.7 Wide_Wide_String Handling
+A.4.8 Wide_Wide_String Handling
 
 Facilities for handling strings of Wide_Wide_Character elements are found in
 the packages Strings.Wide_Wide_Maps, Strings.Wide_Wide_Fixed,
@@ -808,9 +952,11 @@
 
 The context clause for each of the packages Strings.Wide_Wide_Fixed,
 Strings.Wide_Wide_Bounded, and Strings.Wide_Wide_Unbounded identifies
-Strings.Wide_Wide_Maps instead of Strings.Maps. For each of the packages
+Strings.Wide_Wide_Maps instead of Strings.Maps.
+
+For each of the packages
 Strings.Fixed, Strings.Bounded, Strings.Unbounded, and Strings.Maps.Constants
-the corresponding wide string package has the same contents except that
+the corresponding wide wide string package has the same contents except that
 
 o   Wide_Wide_Space replaces Space
 o   Wide_Wide_Character replaces Character
@@ -828,9 +974,11 @@
 o   Wide_Wide_String_Access replaces String_Access
 o   To_Unbounded_Wide_Wide_String replaces To_Unbounded_String
 
-The following additional declaration is present in
+The following additional declarations are present in
 Strings.Wide_Wide_Maps.Wide_Wide_Constants:
 
+   Character_Set : constant Wide_Wide_Maps.Wide_Wide_Character_Set;
+   -- Contains each Wide_Wide_Character value WC such that Characters.Handling.Is_Character(WC) is True
    Wide_Character_Set : constant Wide_Wide_Maps.Wide_Wide_Character_Set;
    -- Contains each Wide_Wide_Character value WWC such that
    -- Characters.Handling.Is_Wide_Character (WWC) is True
@@ -944,22 +1092,22 @@
    pragma Pack(char16_array);
 
    function Is_Nul_Terminated (Item : in char16_array) return Boolean;
-   function To_C (Item : in Wide_String;
+   function To_C (Item       : in Wide_String;
                   Append_Nul : in Boolean := True)
       return char16_array;
 
-   function To_Ada (Item : in char16_array;
+   function To_Ada (Item     : in char16_array;
                     Trim_Nul : in Boolean := True)
       return Wide_String;
 
-   procedure To_C (Item : in Wide_String;
-                   Target : out char16_array;
-                   Count : out size_t;
+   procedure To_C (Item       : in Wide_String;
+                   Target     : out char16_array;
+                   Count      : out size_t;
                    Append_Nul : in Boolean := True);
 
-   procedure To_Ada (Item : in char16_array;
-                     Target : out Wide_String;
-                     Count : out Natural;
+   procedure To_Ada (Item     : in char16_array;
+                     Target   : out Wide_String;
+                     Count    : out Natural;
                      Trim_Nul : in Boolean := True);
 
    type char32_t is <implementation-defined character type>;
@@ -974,22 +1122,22 @@
    pragma Pack(char32_array);
 
    function Is_Nul_Terminated (Item : in char32_array) return Boolean;
-   function To_C (Item : in Wide_Wide_String;
+   function To_C (Item       : in Wide_Wide_String;
                   Append_Nul : in Boolean := True)
       return char32_array;
 
-   function To_Ada (Item : in char32_array;
+   function To_Ada (Item     : in char32_array;
                     Trim_Nul : in Boolean := True)
       return Wide_Wide_String;
 
-   procedure To_C (Item : in Wide_Wide_String;
-                   Target : out char32_array;
-                   Count : out size_t;
+   procedure To_C (Item       : in Wide_Wide_String;
+                   Target     : out char32_array;
+                   Count      : out size_t;
                    Append_Nul : in Boolean := True);
 
-   procedure To_Ada (Item : in char32_array;
-                     Target : out Wide_Wide_String;
-                     Count : out Natural;
+   procedure To_Ada (Item     : in char32_array;
+                     Target   : out Wide_Wide_String;
+                     Count    : out Natural;
                      Trim_Nul : in Boolean := True);
 
 
@@ -1013,22 +1161,22 @@
    To_C and To_Ada provide the mappings between the Ada and C 16-bit character
    types.
 
-   function To_C (Item : in Wide_String;
+   function To_C (Item       : in Wide_String;
                   Append_Nul : in Boolean := True)
       return char16_array;
 
-   function To_Ada (Item : in char16_array;
+   function To_Ada (Item     : in char16_array;
                     Trim_Nul : in Boolean := True)
       return Wide_String;
 
-   procedure To_C (Item : in Wide_String;
-                   Target : out char16_array;
-                   Count : out size_t;
+   procedure To_C (Item       : in Wide_String;
+                   Target     : out char16_array;
+                   Count      : out size_t;
                    Append_Nul : in Boolean := True);
 
-   procedure To_Ada (Item : in char16_array;
-                     Target : out Wide_String;
-                     Count : out Natural;
+   procedure To_Ada (Item     : in char16_array;
+                     Target   : out Wide_String;
+                     Count    : out Natural;
                      Trim_Nul : in Boolean := True);
 
       The To_C and To_Ada subprograms that convert between Wide_String and
@@ -1047,22 +1195,22 @@
    To_C and To_Ada provide the mappings between the Ada and C 32-bit character
    types.
 
-   function To_C (Item : in Wide_Wide_String;
+   function To_C (Item       : in Wide_Wide_String;
                   Append_Nul : in Boolean := True)
       return char32_array;
 
-   function To_Ada (Item : in char32_array;
+   function To_Ada (Item     : in char32_array;
                     Trim_Nul : in Boolean := True)
       return Wide_Wide_String;
 
-   procedure To_C (Item : in Wide_Wide_String;
-                   Target : out char32_array;
-                   Count : out size_t;
+   procedure To_C (Item       : in Wide_Wide_String;
+                   Target     : out char32_array;
+                   Count      : out size_t;
                    Append_Nul : in Boolean := True);
 
-   procedure To_Ada (Item : in char32_array;
-                     Target : out Wide_Wide_String;
-                     Count : out Natural;
+   procedure To_Ada (Item     : in char32_array;
+                     Target   : out Wide_Wide_String;
+                     Count    : out Natural;
                      Trim_Nul : in Boolean := True);
 
       The To_C and To_Ada subprograms that convert between Wide_Wide_String and
@@ -1085,12 +1233,6 @@
 Wide_Wide_Text_IO.Editing} ...
 
 
-In F.3(1) change:
-
-... Text_IO.Editing [and Wide_Text_IO.Editing]{, Wide_Text_IO.Editing, and
-Wide_Wide_Text_IO.Editing} ...
-
-
 At the beginning of F.3(1) change:
 
 The child packages Text_IO.Editing [and Wide_Text_IO.Editing]{,
@@ -1111,8 +1253,8 @@
 
 In F.3(20) change:
 
-... Text_IO.Editing [and Wide_Text_IO.Editing]{, Wide_Text_IO.Editing, and
-Wide_Wide_Text_IO.Editing} ...
+... [both for]{all of} Text_IO.Editing [and Wide_Text_IO.Editing]{,
+Wide_Text_IO.Editing, and Wide_Wide_Text_IO.Editing} ...
 
 
 Add a new section after F.3.4:
@@ -1148,7 +1290,7 @@
 Text_IO.Complex_IO by systematically replacing Text_IO by Wide_Wide_Text_IO and
 String by Wide_Wide_String; the description of its behavior is obtained by
 additionally replacing references to particular characters (commas,
-parentheses, etc.) by those for the corresponding wide characters.
+parentheses, etc.) by those for the corresponding wide wide characters.
 
 
 In H.4(20) change:
@@ -1164,6 +1306,1560 @@
 See proposal.
 
 !example
+
+An example would show identifiers using characters from the CJKV ideographs or
+from non-Latin alphabets (Cyrillic, Greek, Arabic, etc.). But that's hard to do
+in a Latin-1, plain text file...
+
+!comment Introduction clause
+!corrigendum 0.3(32)
+
+@drepl
+An enumeration type defines an ordered set of distinct enumeration literals,
+for example a list of states or an alphabet of characters. The enumeration
+types Boolean, Character, and Wide_Character are predefined.
+@dby
+An enumeration type defines an ordered set of distinct enumeration literals,
+for example a list of states or an alphabet of characters. The enumeration
+types Boolean, Character, Wide_Character, and Wide_Wide_Character are
+predefined.
+
+!comment Introduction clause
+!corrigendum 0.3(34)
+
+@drepl
+Composite types allow definitions of structured objects with related
+components. The composite types in the language include arrays and records. An
+array is an object with indexed components of the same type. A record is an
+object with named components of possibly different types. Task and protected
+types are also forms of composite types. The array types String and Wide_String
+are predefined.
+@dby
+Composite types allow definitions of structured objects with related
+components. The composite types in the language include arrays and records. An
+array is an object with indexed components of the same type. A record is an
+object with named components of possibly different types. Task and protected
+types are also forms of composite types. The array types String, Wide_String,
+and Wide_Wide_String are predefined.
+
+
+!corrigendum 1.1.4(14)
+
+@dinsa
+@xbullet<If the name of any syntactic category starts with an italicized part,
+it is equivalent to the category name without the italicized part. The
+italicized part is intended to convey some semantic information. For example
+@i<subtype_>@fa<name> and @i<task_>@fa<name> are both equivalent to @fa<name> alone.>
+@dinst
+The terminals of the grammar, including reserved words, punctuation and
+components of lexical elements, are exclusively made of the characters whose
+code position is between 16#20# and 16#7E#, inclusively. For example, the
+character E in the definition of exponent is the character whose name is "LATIN
+CAPITAL LETTER E", not "GREEK CAPITAL LETTER EPSILON".
+
+
+!corrigendum 2.1(1)
+
+@drepl
+The only characters allowed outside of @fa<comment>s are the
+@fa<graphic_character>s and @fa<format_effector>s.
+@dby
+The characters whose code position is 16#FFFE# or 16#FFFF# are not allowed
+anywhere in the text of a program. The characters in categories
+@fa<other_control>, @fa<other_private_use>, and @fa<other_surrogate> are only
+allowed in comments.
+
+!corrigendum 2.1(2)
+
+@ddel
+@xcode<@fa<character ::= graphic_character | format_effector | other_control_function>>
+
+!corrigendum 2.1(3)
+
+@ddel
+@xcode<@fa<graphic_character ::= identifier_letter | digit | space_character | special_character>>
+
+
+!corrigendum 2.1(4)
+
+@drepl
+The character repertoire for the text of an Ada program consists of the
+collection of characters called the Basic Multilingual Plane (BMP) of the ISO
+10646 Universal Multiple-Octet Coded Character Set, plus a set of
+@fa<format_effector>s and, in comments only, a set of
+@fa<other_control_function>s; the coded representation for these characters is
+implementation defined (it need not be a representation defined within
+ISO-10646-1).
+@dby
+The character repertoire for the text of an Ada program consists of the
+collection of characters described by the ISO/IEC 10646:2003 Universal
+Multiple-Octet Coded Character Set. The coded representation for these
+characters is implementation defined (it need not be a representation defined
+within ISO/IEC 10646:2003).
+
+The semantics of an Ada program whose text is not in Normalization Form KC (as
+defined by section 24 of ISO/IEC 10646:2003) are implementation-defined.
+
+!corrigendum 2.1(5)
+
+@drepl
+The description of the language definition in this International Standard uses
+the graphic symbols defined for Row 00: Basic Latin and Row 00: Latin-1
+Supplement of the ISO 10646 BMP; these correspond to the graphic symbols of ISO
+8859-1 (Latin-1); no graphic symbols are used in this International Standard
+for characters outside of Row 00 of the BMP. The actual set of graphic symbols
+used by an implementation for the visual representation of the text of an Ada
+program is not specified.
+@dby
+The description of the language definition in this International Standard uses
+the character properties General Category and Decimal Digit Value of the
+documents referenced by the note in section 1 of ISO/IEC 10646:2003. The actual
+set of graphic symbols used by an implementation for the visual representation
+of the text of an Ada program is not specified.
+
+!corrigendum 2.1(7)
+
+@ddel
+@xhang<@xterm<@fa<identifier_letter>>
+@fa<upper_case_identifier_letter | lower_case_identifier_letter>>
+
+!corrigendum 2.1(8)
+
+@drepl
+@xhang<@xterm<@fa<upper_case_identifier_letter>>
+Any character of Row 00 of ISO 10646 BMP whose name begins ``Latin Capital Letter''.>
+@dby
+@xhang<@xterm<@fa<letter_uppercase>>
+Any character whose General Category is defined to be "Letter, Uppercase".>
+
+!corrigendum 2.1(9)
+
+@drepl
+@xhang<@xterm<@fa<lower_case_identifier_letter>>
+Any character of Row 00 of ISO 10646 BMP whose name begins ``Latin Small Letter''.>
+@dby
+@xhang<@xterm<@fa<letter_lowercase>>
+Any character whose General Category is defined to be "Letter, Lowercase".>
+
+@xhang<@xterm<@fa<letter_titlecase>>
+Any character whose General Category is defined to be "Letter, Titlecase".>
+
+@xhang<@xterm<@fa<letter_modifier>>
+Any character whose General Category is defined to be "Letter, Modifier".>
+
+@xhang<@xterm<@fa<letter_other>>
+Any character whose General Category is defined to be "Letter, Other".>
+
+@xhang<@xterm<@fa<mark_non_spacing>>
+Any character whose General Category is defined to be "Mark, Non-Spacing".>
+
+@xhang<@xterm<@fa<mark_spacing_combining>>
+Any character whose General Category is defined to be "Mark, Spacing Combining".>
+
+!corrigendum 2.1(10)
+
+@drepl
+@xhang<@xterm<@fa<digit>>
+One of the characters 0, 1, 2, 3, 4, 5, 6, 7, 8, or 9.>
+@dby
+@xhang<@xterm<@fa<number_decimal_digit>>
+Any character whose General Category is defined to be "Number, Decimal Digit".>
+
+@xhang<@xterm<@fa<number_letter>>
+Any character whose General Category is defined to be "Number, Letter".>
+
+!corrigendum 2.1(11)
+
+@ddel
+@xhang<@xterm<@fa<space_character>>
+The character of ISO 10646 BMP named ``Space''.>
+
+!corrigendum 2.1(12)
+
+@drepl
+@xhang<@xterm<@fa<special_character>>
+Any character of the ISO 10646 BMP that is not reserved for a control function,
+and is not the @fa<space_character>, an @fa<identifier_letter>, or a
+@fa<digit>.>
+@dby
+@xhang<@xterm<@fa<other_control>>
+Any character whose General Category is defined to be "Other, Control".>
+
+@xhang<@xterm<@fa<other_format>>
+Any character whose General Category is defined to be "Other, Format".>
+
+@xhang<@xterm<@fa<other_private_use>>
+Any character whose General Category is defined to be "Other, Private Use".>
+
+@xhang<@xterm<@fa<other_surrogate>>
+Any character whose General Category is defined to be "Other, Surrogate".>
+
+@xhang<@xterm<@fa<punctuation_connector>>
+Any character whose General Category is defined to be "Punctuation, Connector".>
+
+@xhang<@xterm<@fa<separator_space>>
+Any character whose General Category is defined to be "Separator, Space".>
+
+@xhang<@xterm<@fa<separator_line>>
+Any character whose General Category is defined to be "Separator, Line".>
+
+@xhang<@xterm<@fa<separator_paragraph>>
+Any character whose General Category is defined to be "Separator, Paragraph".>
+
+!corrigendum 2.1(13)
+
+@drepl
+@xhang<@xterm<@fa<format_effector>>
+The control functions of ISO 6429 called character tabulation (HT), line
+tabulation (VT), carriage return (CR), line feed (LF), and form feed (FF).
+@dby
+@xhang<@xterm<@fa<format_effector>>
+The characters whose code position is 16#09# (CHARACTER TABULATION), 16#0A#
+(LINE FEED(LF)), 16#0B# (LINE TABULATION), 16#0C# (FORM FEED(FF)), 16#0D#
+(CARRIAGE RETURN(CR)), 16#85# (NEXT LINE(NEL)), and the characters in
+categories @fa<separator_line> and @fa<separator_paragraph>.  The names
+mentioned in parenthese in this list are not defined by ISO/IEC 10646:2003;
+they are only used for convenience in this International Standard.
+
+!corrigendum 2.1(14)
+
+@drepl
+@xhang<@xterm<@fa<other_control_function>>
+Any control function, other than a @fa<format_effector>, that is allowed in a
+comment; the set of @fa<other_control_function>s allowed in comments is
+implementation defined.>
+@dby
+@xhang<@xterm<@fa<graphic_character>>
+Any character which is not in the categories @fa<other_control>,
+@fa<other_private_use>, @fa<other_surrogate>, @fa<other_format>,
+@fa<format_effector>, and whose code position is neither 16#FFFE# nor
+16#FFFF#.>
+
+!corrigendum 2.1(15)
+
+@drepl
+The following names are used when referring to certain @fa<special_character>s:
+@dby
+The following names are used when referring to certain characters (the first
+name is that given in ISO/IEC 10646:2003):
+
+!comment I'm not going to try to update the table here, as it would be very
+!comment difficult to format properly. Moreover, there is nothing important
+!comment wrong with it. I'll make the suggested changes as editorial
+!comment corrections in the Standard.
+
+!corrigendum 2.1(16)
+
+@ddel
+In a nonstandard mode, the implementation may support a different character
+repertoire; in particular, the set of characters that are considered
+@fa<identifier_letter>s can be extended or changed to conform to local
+conventions.
+
+!corrigendum 2.1(17)
+
+@ddel
+@xindent<@s9<1  Every code position of ISO 10646 BMP that is not reserved for a
+control function is defined to be a graphic_character by this International
+Standard. This includes all code positions other than 0000 - 001F, 007F -
+009F, and FFFE - FFFF.>>
+
+!corrigendum 2.2(3)
+
+@drepl
+In some cases an explicit @i<separator> is required to separate adjacent
+lexical elements. A separator is any of a space character, a format effector,
+or the end of a line, as follows:
+@dby
+In some cases an explicit @i<separator> is required to separate adjacent
+lexical elements. A separator is any of a @fa<separator_space>, a
+@fa<format_effector> or the end of a line, as follows:
+
+!corrigendum 2.2(4)
+
+@drepl
+@xbullet<A space character is a separator except within a @fa<comment>,
+a @fa<string_literal>, or a @fa<character_literal>.>
+@dby
+@xbullet<A @fa<separator_space> is a separator except within a @fa<comment>, a
+@fa<string_literal>, or a @fa<character_literal>.>
+
+!corrigendum 2.2(5)
+
+@drepl
+@xbullet<Character tabulation (HT) is a separator except within a @fa<comment>.>
+@dby
+@xbullet<Character Tabulation is a separator except within a @fa<comment>.>
+
+!corrigendum 2.2(8)
+
+@drepl
+A delimiter is either one of the following special characters:
+@dby
+A delimiter is either one of the following characters:
+
+!corrigendum 2.3(02)
+
+@drepl
+@xcode<@fa<identifier ::=
+   identifier_letter {[underline] letter_or_digit}>>
+@dby
+@xcode<@fa<identifier_start ::= letter_uppercase |
+                     letter_lowercase |
+                     letter_titlecase |
+                     letter_modifier |
+                     letter_other |
+                     number_letter
+identifier_extend ::= identifier_start |
+                      mark_non_spacing |
+                      mark_spacing_combining |
+                      number_decimal_digit |
+                      other_format
+identifier ::= identifier_start {[punctuation_connector] identifier_extend}>>
+
+!corrigendum 2.3(03)
+
+@ddel
+@xcode<@fa<letter_or_digit ::= identifier_letter | digit>>
+
+!corrigendum 2.3(05)
+
+@drepl
+All characters of an @fa<identifier> are significant, including any underline
+character. @fa<Identifier>s differing only in the use of corresponding upper
+and lower case letters are considered the same.
+@dby
+Two @fa<identifier>s are considered the same if they consist of same sequence of
+characters after applying the following transformations (in this order):
+
+@xbullet<The characters in category @fa<other_format> are eliminated.>
+
+@xbullet<Full case folding, as defined by documents referenced in the note in
+section 1 of ISO/IEC 10646:2003, is applied to obtain the uppercase version
+of each character.>
+
+!corrigendum 2.6(06)
+
+@dinsa
+A @i<null string literal> is a @fa<string_literal> with no @fa<string_element>s
+between the quotation marks.
+@dinst
+No modification is performed on the sequence of characters in a
+@fa<string_literal>.
+
+
+!corrigendum 3.5(28)
+
+@drepl
+@xhang<@xterm<S'Wide_Image>
+S'Wide_Image denotes a function with the following specification:>
+@dby
+@xhang<@xterm<S'Wide_Wide_Image>
+S'Wide_Wide_Image denotes a function with the following specification:>
+
+!corrigendum 3.5(29)
+
+@drepl
+@xcode<        @b<function> S'Wide_Image(@i<Arg> : S'Base)
+          @b<return> Wide_String>
+@dby
+@xcode<        @b<function> S'Wide_Wide_Image(@i<Arg> : S'Base)
+          @b<return> Wide_Wide_String>
+
+!corrigendum 3.5(34)
+
+@dinsa
+@xindent<The image of a fixed point value is a decimal real literal best
+approximating the value (rounded away from zero if halfway between) with a
+single leading character that is either a minus sign or a space, one or more
+digits before the decimal point (with no redundant leading zeros), a decimal
+point, and S'Aft (see 3.5.10) digits after the decimal point.>
+@dinss
+@xhang<@xterm<S'Wide_Image>
+S'Wide_Image denotes a function with the following specification:>
+
+@xcode<        @b<function> S'Wide_Image(@i<Arg> : S'Base)
+          @b<return> Wide_String>
+
+@xindent<The function returns an image of the value of @i<Arg> as a Wide_String. The lower
+bound of the result is one. The image has the same sequence of character as
+defined for S'Wide_Wide_Image if all the graphic characters are defined in
+Wide_Character; otherwise the sequence of characters is implementation defined
+(but no shorter than that of S'Wide_Wide_Image for the same value of @i<Arg>).>
+
+!corrigendum 3.5(37)
+
+@drepl
+@xindent<The function returns an image of the value of @i<Arg> as a String. The
+lower bound of the result is one. The image has the same sequence of graphic
+characters as that defined for S'Wide_Image if all the graphic characters are
+defined in Character; otherwise the sequence of characters is implementation
+defined (but no shorter than that of S'Wide_Image for the same value of @i<Arg>).>
+@dby
+@xindent<The function returns an image of the value of @i<Arg> as a String. The
+lower bound of the result is one. The image has the same sequence of character
+as defined for S'Wide_Wide_Image if all the graphic characters are defined in
+Character; otherwise the sequence of characters is implementation defined (but
+no shorter than that of S'Wide_Wide_Image for the same value of @i<Arg>).>
+
+@xhang<@xterm<S'Wide_Wide_Width>
+S'Wide_Wide_Width denotes the maximum length of a Wide_Wide_String returned by
+S'Wide_Wide_Image over all the values of S. It denotes zero for a subtype that
+has a null range. Its type is @i<universal_integer>.>
+
+!corrigendum 3.5(40)
+
+@drepl
+@xhang<@xterm<S'Wide_Value>
+S'Wide_Value denotes a function with the following specification:>
+@dby
+@xhang<@xterm<S'Wide_Wide_Value>
+S'Wide_Wide_Value denotes a function with the following specification:>
+
+!corrigendum 3.5(41)
+
+@drepl
+@xcode<        @b<function> S'Wide_Value(@i<Arg> : Wide_String)
+          @b<return> S'Base>
+@dby
+@xcode<        @b<function> S'Wide_Wide_Value(@i<Arg> : Wide_Wide_String)
+          @b<return> S'Base>
+
+!corrigendum 3.5(42)
+
+@drepl
+@xindent<This function returns a value given an image of the value as a
+Wide_String, ignoring any leading or trailing spaces.>
+@dby
+@xindent<This function returns a value given an image of the value as a
+Wide_Wide_String, ignoring any leading or trailing spaces.>
+
+!corrigendum 3.5(43)
+
+@drepl
+@xindent<For the evaluation of a call on S'Wide_Value for an enumeration subtype S,
+if the sequence of characters of the parameter (ignoring leading and trailing
+spaces) has the syntax of an enumeration literal and if it corresponds to a
+literal of the type of S (or corresponds to the result of S'Wide_Image
+for a nongraphic character of the type), the result is the corresponding
+enumeration value; otherwise Constraint_Error is raised.>
+@dby
+@xindent<For the evaluation of a call on S'Wide_Wide_Value for an enumeration subtype S,
+if the sequence of characters of the parameter (ignoring leading and trailing
+spaces) has the syntax of an enumeration literal and if it corresponds to a
+literal of the type of S (or corresponds to the result of S'Wide_Wide_Image
+for a nongraphic character of the type), the result is the corresponding
+enumeration value; otherwise Constraint_Error is raised.>
+
+!corrigendum 3.5(44)
+
+@drepl
+@xindent<For the evaluation of a call on S'Wide_Value (or S'Value) for an integer
+subtype S, if the sequence of characters of the parameter (ignoring leading and
+trailing spaces) has the syntax of an integer literal, with an optional leading
+sign character (plus or minus for a signed type; only plus for a modular type),
+and the corresponding numeric value belongs to the base range of the type of S,
+then that value is the result; otherwise Constraint_Error is raised.>
+@dby
+@xindent<For the evaluation of a call on S'Wide_Wide_Value for an integer subtype S, if
+the sequence of characters of the parameter (ignoring leading and trailing
+spaces) has the syntax of an integer literal, with an optional leading sign
+character (plus or minus for a signed type; only plus for a modular type), and
+the corresponding numeric value belongs to the base range of the type of S,
+then that value is the result; otherwise Constraint_Error is raised.>
+
+!corrigendum 3.5(45)
+
+@drepl
+@xindent<For the evaluation of a call on S'Wide_Value (or S'Value) for a real
+subtype S, if the sequence of characters of the parameter (ignoring leading and
+trailing spaces) has the syntax of one of the following:>
+@dby
+@xindent<For the evaluation of a call on S'Wide_Wide_Value for a real subtype
+S, if the sequence of characters of the parameter (ignoring leading and
+trailing spaces) has the syntax of one of the following:>
+
+!corrigendum 3.5(51)
+
+@dinsa
+@xindent<with an optional leading sign character (plus or minus), and if the
+corresponding numeric value belongs to the base range of the type of S, then
+that value is the result; otherwise Constraint_Error is raised. The sign of a
+zero value is preserved (positive if none has been specified) if S'Signed_Zeros
+is True.>
+@dinss
+@xhang<@xterm<S'Wide_Value>
+S'Wide_Value denotes a function with the following specification:>
+
+@xcode<        @b<function> S'Wide_Value(@i<Arg> : Wide_String)
+          @b<return> S'Base>
+
+@xindent<This function returns a value given an image of the value as a
+Wide_String, ignoring any leading or trailing spaces. For the evaluation of a
+call on S'Wide_Value for an enumeration subtype S, if the sequence of
+characters of the parameter (ignoring leading and trailing spaces) has the
+syntax of an enumeration literal and if it corresponds to a literal of the type
+of S (or corresponds to the result of S'Wide_Image for a value of the type),
+the result is the corresponding enumeration value; otherwise Constraint_Error
+is raised. For a numeric subtype S, the evaluation of a call on S'Wide_Value
+with @i<Arg> of type Wide_String is equivalent to a call on S'Wide_Wide_Value for a
+corresponding @i<Arg> of type Wide_Wide_String.>
+
+!corrigendum 3.5(55)
+
+@drepl
+@xindent<For the evaluation of a call on S'Value for an enumeration subtype S,
+if the sequence of characters of the parameter (ignoring leading and trailing
+spaces) has the syntax of an enumeration literal and if it corresponds to a
+literal of the type of S (or corresponds to the result of S'Image for a value
+of the type), the result is the corresponding enumeration value; otherwise
+Constraint_Error is raised. For a numeric subtype S, the evaluation of a call
+on S'Value with @i<Arg> of type String is equivalent to a call on S'Wide_Value for
+a corresponding @i<Arg> of type Wide_String.>
+@dby
+@xindent<For the evaluation of a call on S'Value for an enumeration subtype S,
+if the sequence of characters of the parameter (ignoring leading and trailing
+spaces) has the syntax of an enumeration literal and if it corresponds to a
+literal of the type of S (or corresponds to the result of S'Image for a value
+of the type), the result is the corresponding enumeration value; otherwise
+Constraint_Error is raised. For a numeric subtype S, the evaluation of a call
+on S'Value with @i<Arg> of type String is equivalent to a call on S'Wide_Wide_Value
+for a corresponding @i<Arg> of type Wide_Wide_String.>
+
+
+!corrigendum 3.5(56)
+
+@drepl
+An implementation may extend the Wide_Value, Value, Wide_Image, and Image
+attributes of a floating point type to support special values such as
+infinities and NaNs.
+@dby
+An implementation may extend the Wide_Wide_Value, Wide_Value, Value,
+Wide_Wide_Image, Wide_Image, and Image attributes of a floating point type to
+support special values such as infinities and NaNs.
+
+!corrigendum 3.5(59)
+
+@drepl
+@xindent<@s9<21  For any value V (including any nongraphic character) of an
+enumeration subtype S, S'Value(S'Image(V)) equals V, as does
+S'Wide_Value(S'Wide_Image(V)). Neither expression ever raises
+Constraint_Error.>>
+@dby
+@xindent<@s9<21  For any value V (including any nongraphic character) of an
+enumeration subtype S, S'Value(S'Image(V)) equals V, as do
+S'Wide_Value(S'Wide_Image(V)) and S'Wide_Wide_Value(S'Wide_Wide_Image(V)).
+Neither expression ever raises Constraint_Error.>>
+
+
+!corrigendum 3.5.2(2)
+
+@drepl
+The predefined type Character is a character type whose values correspond to
+the 256 code positions of Row 00 (also known as Latin-1) of the ISO 10646 Basic
+Multilingual Plane (BMP). Each of the graphic characters of Row 00 of the BMP
+has a corresponding @fa<character_literal> in Character. Each of the nongraphic
+positions of Row 00 (0000-001F and 007F-009F) has a corresponding
+language-defined name, which is not usable as an enumeration literal, but which
+is usable with the attributes (Wide_)Image and (Wide_)Value; these names are
+given in the definition of type Character in A.1, ``The Package Standard'', but
+are set in @fa<italics>.
+@dby
+The predefined type Character is a character type whose values correspond to
+the 256 code positions of Row 00 (also known as Latin-1) of the ISO/IEC 10646:2003 Basic
+Multilingual Plane (BMP). Each of the graphic characters of Row 00 of the BMP
+has a corresponding @fa<character_literal> in Character. Each of the nongraphic
+positions of Row 00 (0000-001F and 007F-009F) has a corresponding
+language-defined name, which is not usable as an enumeration literal, but which
+is usable with the attributes Image, Wide_Image,
+Wide_Wide_Image, Value, Wide_Value, and Wide_Wide_Value; these names are
+given in the definition of type Character in A.1, ``The Package Standard'', but
+are set in @fa<italics>.
+
+!corrigendum 3.5.2(3)
+
+@drepl
+The predefined type Wide_Character is a character type whose values correspond
+to the 65536 code positions of the ISO 10646 Basic Multilingual Plane (BMP).
+Each of the graphic characters of the BMP has a corresponding @fa<character_literal>
+in Wide_Character. The first 256 values of Wide_Character have the same
+@fa<character_literal> or language-defined name as defined for Character. The last 2
+values of Wide_Character correspond to the nongraphic positions FFFE and FFFF
+of the BMP, and are assigned the language-defined names @i<FFFE> and @i<FFFF>. As with
+the other language-defined names for nongraphic characters, the names FFFE and
+FFFF are usable only with the attributes (Wide_)Image and (Wide_)Value; they
+are not usable as enumeration literals. All other values of Wide_Character are
+considered graphic characters, and have a corresponding @fa<character_literal>.
+@dby
+The predefined type Wide_Character is a character type whose values correspond
+to the 65536 code positions of the ISO/IEC 10646:2003 Basic Multilingual Plane (BMP).
+Each of the graphic characters of the BMP has a corresponding @fa<character_literal>
+in Wide_Character. The first 256 values of Wide_Character have the same
+@fa<character_literal> or language-defined name as defined for Character.
+Each of the @fa<graphic_character>s has a corresponding @fa<character_literal>.
+
+The predefined type Wide_Wide_Character is a character type whose values
+correspond to the 2147483648 code positions of the ISO/IEC 10646:2003 character
+set. Each of the @fa<graphic_character>s has a corresponding @fa<character_literal>
+in Wide_Wide_Character. The first 65536 values of Wide_Wide_Character have the
+same @fa<character_literal> or language-defined name as defined for
+Wide_Character.
+
+In types Wide_Character and Wide_Wide_Character, the characters whose code
+positions are 16#FFFE# and 16#FFFF# are assigned the language-defined names FFFE
+and FFFF. The other characters whose code position is larger than 16#FF# and
+which are not @fa<graphic_character>s have language-defined names which are formed by
+appending to the string "Character_" the representation of their code position
+in hexadecimal as eight extended digits. As with other language-defined names,
+these names are usable only with the attributes (Wide_)Wide_Image and
+(Wide_)Wide_Value; they are not usable as enumeration literals.
+
+!corrigendum 3.5.2(4)
+
+@drepl
+In a nonstandard mode, an implementation may provide other interpretations for
+the predefined types Character and Wide_Character, to conform to local
+conventions.
+@dby
+In a nonstandard mode, an implementation may provide other interpretations for
+the predefined types Character, Wide_Character, and Wide_Wide_Character to
+conform to local conventions.
+
+!corrigendum 3.5.2(5)
+
+@ddel
+If an implementation supports a mode with alternative interpretations for
+Character and Wide_Character, the set of graphic characters of Character should
+nevertheless remain a proper subset of the set of graphic characters of
+Wide_Character. Any character set ``localizations'' should be reflected in the
+results of the subprograms defined in the language-defined package
+Characters.Handling (see A.3) available in such a mode. In a mode with an
+alternative interpretation of Character, the implementation should also support
+a corresponding change in what is a legal @fa<identifier_letter>.
+
+!corrigendum 3.6.3(2)
+
+@drepl
+There are two predefined string types, String and Wide_String, each indexed by
+values of the predefined subtype Positive; these are declared in the visible
+part of package Standard:
+@dby
+There are three predefined string types, String, Wide_String, and
+Wide_Wide_String, each indexed by the value of the predefined subtype Positive;
+these are declared in the visible part of package Standard:
+
+!corrigendum 3.6.3(4)
+
+@drepl
+@xcode<@b<type> String @b<is array> (Positive @b<range> <@>) @b<of> Character;
+@b<type> Wide_String @b<is array> (Positive @b<range> <@>) @b<of> Wide_Character;>
+@dby
+@xcode<@b<type> String @b<is array> (Positive @b<range> <@>) @b<of> Character;
+@b<type> Wide_String @b<is array> (Positive @b<range> <@>) @b<of> Wide_Character;
+@b<type> Wide_Wide_String @b<is array> (Positive @b<range> <@>) @b<of> Wide_Wide_Character;>
+
+!corrigendum A.1(36)
+
+@drepl
+@xcode<   -- @ft<@i<The predefined operators for the type Character are the same as for>>
+   -- @ft<@i<any enumeration type.>>
+
+   -- @ft<@i<The declaration of type Wide_Character is based on the standard ISO 10646 BMP character set.>>
+   -- @ft<@i<The first 256 positions have the same contents as type Character. See 3.5.2.>>
+
+   @b<type> Wide_Character @b<is> (@i<nul>, @i<soh> ... @i<FFFE>, @i<FFFF>);
+
+   @b<package> ASCII @b<is> ... @b<end> ASCII;  --@ft<@i<Obsolescent; see J.5>>>
+@dby
+@xcode<   -- @ft<@i<The predefined operators for the type Character are the same as for>>
+   -- @ft<@i<any enumeration type.>>
+
+   -- @ft<@i<The declaration of type Wide_Character is based on the standard ISO 10646 BMP character set.>>
+   -- @ft<@i<The first 256 positions have the same contents as type Character. See 3.5.2.>>
+
+   @b<type> Wide_Character @b<is> (@i<nul>, @i<soh> ... @i<FFFE>, @i<FFFF>);
+
+   -- @ft<@i<The declaration of type Wide_Wide_Character is based on the full>>
+   -- @ft<@i<ISO/IEC 10646:2003 character set. The first 2 ** 16 positions have the>>
+   -- @ft<@i<same contents as type Wide_Character. See 3.5.2.>>
+
+   @b<type> Wide_Wide_Character @b<is> (@i<nul>, @i<soh> ... @i<FFFE>, @i<FFFF>, ...);
+
+   @b<package> ASCII @b<is> ... @b<end> ASCII;  --@ft<@i<Obsolescent; see J.5>>>
+
+
+!corrigendum A.1(42)
+
+@dinsa
+@xcode<   -- @ft<@i<The predefined operators for this type correspond to those for String>>>
+@dinss
+@xcode<    @b<type> Wide_Wide_String @b<is array> (Positive @b<range> <@>) of Wide_Wide_Character;
+    @b<pragma> Pack (Wide_Wide_String);
+
+    -- @ft<@i<The predefined operators for this type correspond to those for String.>>>
+
+!corrigendum A.1(49)
+
+@drepl
+In each of the types Character and Wide_Character, the character literals for
+the space character (position 32) and the non-breaking space character
+(position 160) correspond to different values. Unless indicated otherwise, each
+occurrence of the character literal ' ' in this International Standard refers
+to the space character. Similarly, the character literals for hyphen (position
+45) and soft hyphen (position 173) correspond to different values. Unless
+indicated otherwise, each occurrence of the character literal '-' in this
+International Standard refers to the hyphen character.
+@dby
+In each of the types Character, Wide_Character, and Wide_Wide_Character, the
+character literals for the space character (position 32) and the non-breaking
+space character (position 160) correspond to different values. Unless indicated
+otherwise, each occurrence of the character literal ' ' in this International
+Standard refers to the space character. Similarly, the character literals for
+hyphen (position 45) and soft hyphen (position 173) correspond to different
+values. Unless indicated otherwise, each occurrence of the character literal
+'-' in this International Standard refers to the hyphen character.
+
+!corrigendum A.3(1)
+
+@drepl
+This clause presents the packages related to character processing: an empty
+pure package Characters and child packages Characters.Handling and
+Characters.Latin_1. The package Characters.Handling provides classification and
+conversion functions for Character data, and some simple functions for dealing
+with Wide_Character data. The child package Characters.Latin_1 declares a set
+of constants initialized to values of type Character.
+@dby
+This clause presents the packages related to character processing: an empty
+pure package Characters and child packages Characters.Handling and
+Characters.Latin_1. The package Characters.Handling provides classification and
+conversion functions for Character data, and some simple functions for dealing
+with Wide_Character and Wide_Wide_Character data. The child package
+Characters.Latin_1 declares a set of constants initialized to values of type
+Character.
+
+!corrigendum A.3.2(13)
+
+@drepl
+@xcode<   --@ft<@i<Classifications of and conversions between Wide_Character and Character.>>>
+@dby
+@xcode<   --@ft<@i<Classifications of and conversions between Wide_Wide_Character, Wide_Character, and Character.>>>
+
+
+!corrigendum A.3.2(14)
+
+@dinsa
+@xcode<   @b<function> Is_Character (Item : @b<in> Wide_Character) @b<return> Boolean;
+   @b<function> Is_String    (Item : @b<in> Wide_String)    @b<return> Boolean;>
+@dinst
+@xcode<   @b<function> Is_Character (Item : @b<in> Wide_Wide_Character) @b<return> Boolean;
+   @b<function> Is_String    (Item : @b<in> Wide_Wide_String)    @b<return> Boolean;
+   @b<function> Is_Wide_Character (Item : @b<in> Wide_Wide_Character) @b<return> Boolean;
+   @b<function> Is_Wide_String    (Item : @b<in> Wide_Wide_String)    @b<return> Boolean;>
+
+!corrigendum A.3.2(16)
+
+@dinsa
+@xcode<   @b<function> To_String    (Item       : @b<in> Wide_String;
+                        Substitute : @b<in> Character := ' ')
+   @b<return> String;>
+@dinst
+@xcode<   @b<function> To_Character (Item :       @b<in> Wide_Wide_Character;
+                          Substitute : @b<in> Character := ' ') @b<return> Character;
+   @b<function> To_String    (Item :       @b<in> Wide_Wide_String;
+                          Substitute : @b<in> Character := ' ') @b<return> String;>
+
+
+!corrigendum A.3.2(18)
+
+@dinsa
+@xcode<   @b<function> To_Wide_String    (Item : @b<in> String)    @b<return> Wide_String;>
+@dinss
+@xcode<   @b<function> To_Wide_Character (Item :       @b<in> Wide_Wide_Character;
+                               Substitute : @b<in> Wide_Character := ' ')
+                               @b<return> Wide_Character;
+
+   @b<function> To_Wide_String    (Item :       @b<in> Wide_Wide_String;
+                               Substitute : @b<in> Wide_Character := ' ')
+                               @b<return> Wide_String;
+
+   @b<function> To_Wide_Wide_Character (Item : @b<in> Character)
+         @b<return> Wide_Wide_Character;
+
+   @b<function> To_Wide_Wide_String    (Item : @b<in> String)
+         @b<return> Wide_Wide_String;
+
+   @b<function> To_Wide_Wide_Character (Item : @b<in> Wide_Character)
+         @b<return> Wide_Wide_Character;
+
+   @b<function> To_Wide_Wide_String    (Item : @b<in> Wide_String)
+         @b<return> Wide_Wide_String;>
+
+
+!corrigendum A.3.2(42)
+
+@drepl
+The following set of functions test Wide_Character values for membership in
+Character, or convert between corresponding characters of Wide_Character and
+Character.
+@dby
+The following functions test Wide_Wide_Character or Wide_Character values for
+membership in Wide_Character or Character, or convert between corresponding
+characters of Wide_Wide_Character, Wide_Character, and Character.
+
+!corrigendum A.3.2(43)
+
+@drepl
+@xhang<@xterm<Is_Character>
+Returns True if Wide_Character'Pos(Item) <= Character'Pos(Character'Last).>
+@dby
+@xcode<@b<function> Is_Character (Item : @b<in> Wide_Character) @b<return> Boolean;>
+@xindent<Returns True if Wide_Character'Pos(Item) <= Character'Pos(Character'Last).>
+
+@xcode<@b<function> Is_Character (Item : @b<in> Wide_Wide_Character) @b<return> Boolean;>
+@xindent<Returns True if Wide_Wide_Character'Pos(Item) <= Character'Pos(Character'Last).>
+
+@xcode<@b<function> Is_Wide_Character (Item : @b<in> Wide_Wide_Character) @b<return> Boolean;>
+@xindent<Returns True if Wide_Wide_Character'Pos(Item) <=
+Wide_Character'Pos(Wide_Character'Last).>
+
+!corrigendum A.3.2(44)
+
+@drepl
+@xhang<@xterm<Is_String>
+Returns True if Is_Character(Item(I)) is True for each I in Item'Range.>
+@dby
+@xcode<@b<function> Is_String (Item : @b<in> Wide_String)      @b<return> Boolean;
+@b<function> Is_String (Item : @b<in> Wide_Wide_String) @b<return> Boolean;>
+@xindent<Returns True if Is_Character(Item(I)) is True for each I in Item'Range.>
+
+@xcode<@b<function> Is_Wide_String (Item : @b<in> Wide_Wide_String) @b<return> Boolean;>
+@xindent<Returns True if Is_Wide_Character(Item(I)) is True for each I in Item'Range.>
+
+
+!corrigendum A.3.2(45)
+
+@drepl
+@xhang<@xterm<To_Character>
+Returns the Character corresponding to Item if Is_Character(Item), and returns the Substitute Character otherwise.>
+@dby
+@xcode<@b<function> To_Character (Item :       @b<in> Wide_Character;
+                       Substitute : @b<in> Character := ' ') @b<return> Character;
+@b<function> To_Character (Item :       @b<in> Wide_Wide_Character;
+                       Substitute : @b<in> Character := ' ') @b<return> Character;>
+@xindent<Returns the Character corresponding to Item if Is_Character(Item), and returns
+the Substitute Character otherwise.>
+
+@xcode<@b<function> To_Wide_Character (Item : @b<in> Character) @b<return> Wide_Character;>
+@xindent<Returns the Wide_Character X such that Character'Pos(Item) = Wide_Character'Pos
+(X).>
+
+@xcode<@b<function> To_Wide_Character (Item :       @b<in> Wide_Wide_Character;
+                            Substitute : @b<in> Wide_Character := ' ')
+                            @b<return> Wide_Character;>
+@xindent<Returns the Wide_Character corresponding to Item if Is_Wide_Character(Item),
+and returns the Substitute Wide_Character otherwise.>
+
+@xcode<@b<function> To_Wide_Wide_Character (Item : @b<in> Character) return
+    Wide_Wide_Character;>
+@xindent<Returns the Wide_Wide_Character X such that Character'Pos(Item) =
+Wide_Wide_Character'Pos (X).>
+
+@xcode<@b<function> To_Wide_Wide_Character (Item : @b<in> Wide_Character)
+                                 @b<return> Wide_Wide_Character;>
+@xindent<Returns the Wide_Wide_Character X such that Wide_Character'Pos(Item) =
+Wide_Wide_Character'Pos (X).>
+
+!corrigendum A.3.2(46)
+
+@drepl
+@xhang<@xterm<To_String>
+Returns the String whose range is 1..Item'Length and each of whose elements is given by To_Character of the corresponding element in Item.>
+@dby
+@xcode<@b<function> To_String (Item :       @b<in> Wide_String;
+                    Substitute : @b<in> Character := ' ') @b<return> String;
+@b<function> To_String (Item :       @b<in> Wide_Wide_String;
+                    Substitute : @b<in> Character := ' ') @b<return> String;>
+@xindent<Returns the String whose range is 1..Item'Length and each of whose elements is
+given by To_Character of the corresponding element in Item.>
+
+@xcode<@b<function> To_Wide_String (Item : @b<in> String) @b<return> Wide_String;>
+@xindent<Returns the Wide_String whose range is 1..Item'Length and each of whose
+elements is given by To_Wide_Character of the corresponding element @b<in> Item.>
+
+@xcode<@b<function> To_Wide_String (Item :       @b<in> Wide_Wide_String;
+                         Substitute : @b<in> Wide_Character := ' ')
+                         @b<return> Wide_String;>
+@xindent<Returns the Wide_String whose range is 1..Item'Length and each of whose
+elements is given by To_Wide_Character of the corresponding element @b<in> Item
+with the given Substitute Wide_Character.>
+
+@xcode<@b<function> To_Wide_Wide_String (Item : @b<in> String) @b<return> Wide_Wide_String;
+@b<function> To_Wide_Wide_String (Item : @b<in> Wide_String) @b<return> Wide_Wide_String;>
+@xindent<Returns the Wide_Wide_String whose range is 1..Item'Length and each of whose
+elements is given by To_Wide_Wide_Character of the corresponding element in
+Item.>
+
+
+
+!corrigendum A.3.2(47)
+
+@ddel
+@xhang<@xterm<To_Wide_Character>
+Returns the Wide_Character X such that Character'Pos(Item) = Wide_Character'Pos(X).>
+
+
+!corrigendum A.3.2(48)
+
+@ddel
+@xhang<@xterm<To_Wide_String
+Returns the Wide_String whose range is 1..Item'Length and each of whose elements is given by To_Wide_Character of the corresponding element in Item.>
+
+
+!corrigendum A.3.2(49)
+
+@ddel
+If an implementation provides a localized definition of Character or
+Wide_Character, then the effects of the subprograms in Characters.Handling
+should reflect the localizations. See also 3.5.2.
+
+!corrigendum A.4(1)
+
+@drepl
+This clause presents the specifications of the package Strings and several
+child packages, which provide facilities for dealing with string data.
+Fixed-length, bounded-length, and unbounded-length strings are supported, for
+both String and Wide_String. The string-handling subprograms include searches
+for pattern strings and for characters in program-specified sets, translation
+(via a character-to-character mapping), and transformation (replacing,
+inserting, overwriting, and deleting of substrings).
+@dby
+This clause presents the specifications of the package Strings and several
+child packages, which provide facilities for dealing with string data.
+Fixed-length, bounded-length, and unbounded-length strings are supported, for
+String, Wide_String, and Wide_Wide_String. The string-handling subprograms include searches
+for pattern strings and for characters in program-specified sets, translation
+(via a character-to-character mapping), and transformation (replacing,
+inserting, overwriting, and deleting of substrings).
+
+!corrigendum A.4.1(4)
+
+@drepl
+@xcode<   Space      : @b<constant> Character      := ' ';
+   Wide_Space : @b<constant> Wide_Character := ' ';>
+
+@dby
+@xcode<   Space      : @b<constant> Character      := ' ';
+   Wide_Space : @b<constant> Wide_Character := ' ';
+   Wide_Wide_Space : @b<constant> Wide_Wide_Character := ' ';>
+
+
+!corrigendum A.4.7(46)
+
+@drepl
+@xcode<   Character_Set : @b<constant> Wide_Maps.Wide_Character_Set;
+   -- @ft<@i<Contains each Wide_Character value WC such that Characters.Is_Character(WC) is True>>>
+@dby
+@xcode<   Character_Set : @b<constant> Wide_Maps.Wide_Character_Set;
+   -- @ft<@i<Contains each Wide_Character value WC such that Characters.Handling.Is_Character(WC) is True>>>
+
+!comment Updated for AI-161 change.
+!corrigendum A.4.8(01)
+
+@dinsc
+Facilities for handling strings of Wide_Wide_Character elements are found in
+the packages Strings.Wide_Wide_Maps, Strings.Wide_Wide_Fixed,
+Strings.Wide_Wide_Bounded, Strings.Wide_Wide_Unbounded, and
+Strings.Wide_Wide_Maps.Wide_Wide_Constants. They provide the same
+string-handling operations as the corresponding packages for strings of
+Character elements.
+
+@i<@s8<Static Semantics>>
+
+The package Strings.Wide_Wide_Maps has the following declaration.
+
+@xcode<@b<package> Ada.Strings.Wide_Wide_Maps @b<is>
+   @b<pragma> Preelaborate(Wide_Wide_Maps);
+
+   -- Representation for a set of Wide_Wide_Character values:
+   @b<type> Wide_Wide_Character_Set @b<is private>;
+   @b<pragma> Preelaborable_Initialization(Wide_Wide_Character_Set);
+
+   Null_Set : @b<constant> Wide_Wide_Character_Set;
+
+   @b<type> Wide_Wide_Character_Range @b<is>
+      @b<record>
+         Low : Wide_Wide_Character;
+         High : Wide_Wide_Character;
+      @b<end record>;
+   -- @ft<@i<Represents Wide_Wide_Character range Low..High>>
+
+   @b<type> Wide_Wide_Character_Ranges @b<is array> (Positive @b<range> <@>)
+         @b<of> Wide_Wide_Character_Range;
+
+   @b<function> To_Set (Ranges : @b<in> Wide_Wide_Character_Ranges)
+         @b<return> Wide_Wide_Character_Set;
+
+   @b<function> To_Set (Span : @b<in> Wide_Wide_Character_Range)
+         @b<return> Wide_Wide_Character_Set;
+
+   @b<function> To_Ranges (Set : @b<in> Wide_Wide_Character_Set)
+         @b<return> Wide_Wide_Character_Ranges;
+
+   @b<function> "=" (Left, Right : @b<in> Wide_Wide_Character_Set) @b<return> Boolean;
+
+   @b<function> "@b<not>" (Right : @b<in> Wide_Wide_Character_Set)
+         @b<return> Wide_Wide_Character_Set;
+   @b<function> "@b<and>" (Left, Right : @b<in> Wide_Wide_Character_Set)
+         @b<return> Wide_Wide_Character_Set;
+   @b<function> "@b<or>" (Left, Right : @b<in> Wide_Wide_Character_Set)
+         @b<return> Wide_Wide_Character_Set;
+   @b<function> "@b<xor>" (Left, Right : @b<in> Wide_Wide_Character_Set)
+         @b<return> Wide_Wide_Character_Set;
+   @b<function> "-" (Left, Right : @b<in> Wide_Wide_Character_Set)
+         @b<return> Wide_Wide_Character_Set;
+
+   @b<function> Is_In (Element : @b<in> Wide_Wide_Character;
+                   Set : @b<in> Wide_Wide_Character_Set)
+         @b<return> Boolean;
+
+   @b<function> Is_Subset (Elements : @b<in> Wide_Wide_Character_Set;
+                       Set : @b<in> Wide_Wide_Character_Set)
+         @b<return> Boolean;
+
+   @b<function> "<=" (Left : @b<in> Wide_Wide_Character_Set;
+                  Right : @b<in> Wide_Wide_Character_Set)
+         @b<return> Boolean renames Is_Subset;
+
+   -- @ft<@i<Alternative representation for a set of Wide_Wide_Character values:>>
+   sub@b<type> Wide_Wide_Character_Sequence @b<is> Wide_Wide_String;
+
+   @b<function> To_Set (Sequence : @b<in> Wide_Wide_Character_Sequence)
+         @b<return> Wide_Wide_Character_Set;
+
+   @b<function> To_Set (Singleton : @b<in> Wide_Wide_Character)
+         @b<return> Wide_Wide_Character_Set;
+
+   @b<function> To_Sequence (Set : @b<in> Wide_Wide_Character_Set)
+         @b<return> Wide_Wide_Character_Sequence;
+
+   -- @ft<@i<Representation for a Wide_Wide_Character to Wide_Wide_Character>>
+   -- @ft<@i<mapping:>>
+   @b<type> Wide_Wide_Character_Mapping @b<is private>;
+   @b<pragma> Preelaborable_Initialization(Wide_Wide_Character_Mapping);
+
+   @b<function> Value (Map : @b<in> Wide_Wide_Character_Mapping;
+                   Element : @b<in> Wide_Wide_Character)
+         @b<return> Wide_Wide_Character;
+
+   Identity : @b<constant> Wide_Wide_Character_Mapping;
+
+   @b<function> To_Mapping (From, To : @b<in> Wide_Wide_Character_Sequence)
+         @b<return> Wide_Wide_Character_Mapping;
+
+   @b<function> To_Domain (Map : @b<in> Wide_Wide_Character_Mapping)
+         @b<return> Wide_Wide_Character_Sequence;
+
+   @b<function> To_Range (Map : @b<in> Wide_Wide_Character_Mapping)
+         @b<return> Wide_Wide_Character_Sequence;
+
+   @b<type> Wide_Wide_Character_Mapping_Function @b<is>
+         @b<access function> (From : @b<in> Wide_Wide_Character)
+         @b<return> Wide_Wide_Character;
+
+@b<private>
+   ... -- @ft<@i<not specified by the language>>
+@b<end> Ada.Strings.Wide_Wide_Maps;>
+
+The context clause for each of the packages Strings.Wide_Wide_Fixed,
+Strings.Wide_Wide_Bounded, and Strings.Wide_Wide_Unbounded identifies
+Strings.Wide_Wide_Maps instead of Strings.Maps.
+
+For each of the packages
+Strings.Fixed, Strings.Bounded, Strings.Unbounded, and Strings.Maps.Constants
+the corresponding wide wide string package has the same contents except that
+
+@xbullet<Wide_Wide_Space replaces Space>
+@xbullet<Wide_Wide_Character replaces Character>
+@xbullet<Wide_Wide_String replaces String>
+@xbullet<Wide_Wide_Character_Set replaces Character_Set>
+@xbullet<Wide_Wide_Character_Mapping replaces Character_Mapping>
+@xbullet<Wide_Wide_Character_Mapping_Function replaces Character_Mapping_Function>
+@xbullet<Wide_Wide_Maps replaces Maps>
+@xbullet<Bounded_Wide_Wide_String replaces Bounded_String>
+@xbullet<Null_Bounded_Wide_Wide_String replaces Null_Bounded_String>
+@xbullet<To_Bounded_Wide_Wide_String replaces To_Bounded_String>
+@xbullet<To_Wide_Wide_String replaces To_String>
+@xbullet<Unbounded_Wide_Wide_String replaces Unbounded_String>
+@xbullet<Null_Unbounded_Wide_Wide_String replaces Null_Unbounded_String>
+@xbullet<Wide_Wide_String_Access replaces String_Access>
+@xbullet<To_Unbounded_Wide_Wide_String replaces To_Unbounded_String>
+
+The following additional declarations is present in
+Strings.Wide_Wide_Maps.Wide_Wide_Constants:
+
+@xcode<   Character_Set : @b<constant> Wide_Wide_Maps.Wide_Wide_Character_Set;
+   -- @ft<@i<Contains each Wide_Wide_Character value WC such that>>
+   -- @ft<@i<Characters.Handling.Is_Character(WC) is True>>
+   Wide_Character_Set : @b<constant> Wide_Wide_Maps.Wide_Wide_Character_Set;
+   -- @ft<@i<Contains each Wide_Wide_Character value WWC such that>>
+   --@ft<@i< Characters.Handling.Is_Wide_Character(WWC) is True>>>
+
+@xindent<@s9<NOTES@hr
+14  If a null Wide_Wide_Character_Mapping_Function is passed to any of the
+Wide_Wide_String handling subprograms, Constraint_Error is propagated.>>
+
+!corrigendum A.6(01)
+
+@drepl
+Input-output is provided through language-defined packages, each of which is a
+child of the root package Ada. The generic packages Sequential_IO and Direct_IO
+define input-output operations applicable to files containing elements of a
+given type. The generic package Storage_IO supports reading from and writing to
+an in-memory buffer. Additional operations for text input-output are supplied
+in the packages Text_IO and Wide_Text_IO. Heterogeneous input-output is
+provided through the child packages Streams.Stream_IO and Text_IO.Text_Streams
+(see also 13.13). The package IO_Exceptions defines the exceptions needed by
+the predefined input-output packages.
+@dby
+Input-output is provided through language-defined packages, each of which is a
+child of the root package Ada. The generic packages Sequential_IO and Direct_IO
+define input-output operations applicable to files containing elements of a
+given type. The generic package Storage_IO supports reading from and writing to
+an in-memory buffer. Additional operations for text input-output are supplied
+in the packages Text_IO, Wide_Text_IO, and Wide_Wide_Text_IO. Heterogeneous
+input-output is provided through the child packages Streams.Stream_IO and
+Text_IO.Text_Streams (see also 13.13). The package IO_Exceptions defines the
+exceptions needed by the predefined input-output packages.
+
+!corrigendum A.7(04)
+
+@drepl
+Input-output for direct access files is likewise defined by a generic package
+called Direct_IO. Input-output in human-readable form is defined by the
+(nongeneric) packages Text_IO for Character and String data, and Wide_Text_IO
+for Wide_Character and Wide_String data. Input-output for files containing
+streams of elements representing values of possibly different types is defined
+by means of the (nongeneric) package Streams.Stream_IO.
+@dby
+Input-output for direct access files is likewise defined by a generic package
+called Direct_IO. Input-output in human-readable form is defined by the
+(nongeneric) packages Text_IO for Character and String data, Wide_Text_IO
+for Wide_Character and Wide_String data, and Wide_Wide_Text_IO for
+Wide_Wide_Character and Wide_Wide_String data. Input-output for files
+containing streams of elements representing values of possibly different types
+is defined by means of the (nongeneric) package Streams.Stream_IO.
+
+!corrigendum A.7(10)
+
+@drepl
+@xcode<@b<type> File_Mode @b<is> (In_File, Out_File, Append_File);
+--  @ft<@i<for Sequential_IO, Text_IO, Wide_Text_IO, and Stream_IO>>>
+@dby
+@xcode<@b<type> File_Mode @b<is> (In_File, Out_File, Append_File);
+--  @ft<@i<for Sequential_IO, Text_IO, Wide_Text_IO, Wide_Wide_Text_IO, and Stream_IO>>>
+
+!corrigendum A.7(13)
+
+@drepl
+Several file management operations are common to Sequential_IO, Direct_IO,
+Text_IO, and Wide_Text_IO. These operations are described in subclause A.8.2
+for sequential and direct files. Any additional effects concerning text
+input-output are described in subclause A.10.2.
+@dby
+Several file management operations are common to Sequential_IO, Direct_IO,
+Text_IO, Wide_Text_IO, and Wide_Wide_Text_IO. These operations are described in
+subclause A.8.2 for sequential and direct files. Any additional effects
+concerning text input-output are described in subclause A.10.2.
+
+!corrigendum A.7(15)
+
+@drepl
+@xindent<@s9<18  Each instantiation of the generic packages Sequential_IO and
+Direct_IO declares a different type File_Type. In the case of Text_IO,
+Wide_Text_IO, and Streams.Stream_IO, the corresponding type File_Type is
+unique.>>
+@drepl
+@xindent<@s9<18  Each instantiation of the generic packages Sequential_IO and
+Direct_IO declares a different type File_Type. In the case of Text_IO,
+Wide_Text_IO, Wide_Wide_Text_IO, and Streams.Stream_IO, the corresponding type
+File_Type is unique.>>
+
+
+!corrigendum A.11(00)
+
+@drepl
+Wide Text Input-Output
+@dby
+Wide Text Input-Output and Wide Wide Text Input-Output
+
+!corrigendum A.11(01)
+
+@drepl
+The package Wide_Text_IO provides facilities for input and output in
+human-readable form. Each file is read or written sequentially, as a sequence
+of wide characters grouped into lines, and as a sequence of lines grouped into
+pages.
+@dby
+The packages Wide_Text_IO and Wide_Wide_Text_IO provide facilities for input
+and output in human-readable form. Each file is read or written sequentially,
+as a sequence of wide characters (or wide wide characters) grouped into lines,
+and as a sequence of lines grouped into pages.
+
+!corrigendum A.11(02)
+
+@drepl
+The specification of package Wide_Text_IO is the same as that for Text_IO,
+except that in each Get, Look_Ahead, Get_Immediate, Get_Line, Put, and Put_Line
+procedure, any occurrence of Character is replaced by Wide_Character, and any
+occurrence of String is replaced by Wide_String.
+@dby
+The specification of package Wide_Text_IO is the same as that for Text_IO,
+except that in each Get, Look_Ahead, Get_Immediate, Get_Line, Put, and Put_Line
+procedure, any occurrence of Character is replaced by Wide_Character, and any
+occurrence of String is replaced by Wide_String. Nongeneric equivalents of
+Wide_Text_IO.Integer_IO and Wide_Text_IO.Float_IO are provided (as for Text_IO)
+for each predefined numeric type, with names such as Ada.Integer_Wide_Text_IO,
+Ada.Long_Integer_Wide_Text_IO, Ada.Float_Wide_Text_IO,
+Ada.Long_Float_Wide_Text_IO.
+
+!corrigendum A.11(03)
+
+@drepl
+Nongeneric equivalents of Wide_Text_IO.Integer_IO and Wide_Text_IO.Float_IO are
+provided (as for Text_IO) for each predefined numeric type, with names such as
+Ada.Integer_Wide_Text_IO, Ada.Long_Integer_Wide_Text_IO,
+Ada.Float_Wide_Text_IO, Ada.Long_Float_Wide_Text_IO.
+@dby
+The specification of package Wide_Wide_Text_IO is the same as that for Text_IO,
+except that in each Get, Look_Ahead, Get_Immediate, Get_Line, Put, and Put_Line
+procedure, any occurrence of Character is replaced by Wide_Wide_Character, and
+any occurrence of String is replaced by Wide_Wide_String. Nongeneric
+equivalents of Wide_Wide_Text_IO.Integer_IO and Wide_Wide_Text_IO.Float_IO are
+provided (as for Text_IO) for each predefined numeric type, with names such as
+Ada.Integer_Wide_Wide_Text_IO, Ada.Long_Integer_Wide_Wide_Text_IO,
+Ada.Float_Wide_Wide_Text_IO, Ada.Long_Float_Wide_Wide_Text_IO.
+
+!corrigendum A.12(01)
+
+@drepl
+The packages Streams.Stream_IO, Text_IO.Text_Streams, and
+Wide_Text_IO.Text_Streams provide stream-oriented operations on files.
+@dby
+The packages Streams.Stream_IO, Text_IO.Text_Streams,
+Wide_Text_IO.Text_Streams, and Wide_Wide_Text_IO.Text_Streams provide
+stream-oriented operations on files.
+
+!corrigendum A.12.4(01)
+
+@dinsc
+The package Wide_Wide_Text_IO.Text_Streams provides a function for treating a
+wide wide text file as a stream.
+
+@i<@s8<Static Semantics>>
+
+The library package Wide_Wide_Text_IO.Text_Streams has the following
+declaration:
+
+@xcode<@b<with> Ada.Streams;
+@b<package> Ada.Wide_Wide_Text_IO.Text_Streams @b<is>
+   @b<type> Stream_Access @b<is access all> Streams.Root_Stream_Type'Class;
+   @b<function> Stream (File : @b<in> File_Type) @b<return> Stream_Access;
+@b<end> Ada.Wide_Wide_Text_IO.Text_Streams;>
+
+The Stream function has the same effect as the corresponding function in
+Streams.Stream_IO.
+
+
+!corrigendum B.3(39)
+
+@dinsa
+@xcode<   @b<procedure> To_Ada (Item     : @b<in> wchar_array;
+                     Target   : @b<out> Wide_String;
+                     Count    : @b<out> Natural;
+                     Trim_Nul : @b<in> Boolean := True);>
+@dinss
+@xcode<   -- @ft<@i<ISO/IEC 10646:2003 compatible types defined by SC22/WG14 document N1010.>>
+
+   @b<type> char16_t @b<is> @ft<@i<<implementation-defined character type@>>>;
+
+   char16_nul : @b<constant> char16_t := @ft<@i<<implementation-defined>>;
+
+   @b<function> To_C (Item : @b<in> Wide_Character) @b<return> char16_t;
+   @b<function> To_Ada (Item : @b<in> char16_t) @b<return> Wide_Character;
+
+   @b<type> char16_array @b<is array> (size_t @b<range> <@>) @b<of aliased> char16_t;
+
+   @b<pragma> Pack(char16_array);
+
+   @b<function> Is_Nul_Terminated (Item : @b<in> char16_array) @b<return> Boolean;
+   @b<function> To_C (Item       : @b<in> Wide_String;
+                  Append_Nul : @b<in> Boolean := True)
+      @b<return> char16_array;
+
+   @b<function> To_Ada (Item     : @b<in> char16_array;
+                    Trim_Nul : @b<in> Boolean := True)
+      @b<return> Wide_String;
+
+   @b<procedure> To_C (Item       : @b<in> Wide_String;
+                   Target     : @b<out> char16_array;
+                   Count      : @b<out> size_t;
+                   Append_Nul : @b<in> Boolean := True);
+
+   @b<procedure> To_Ada (Item     : @b<in> char16_array;
+                     Target   : @b<out> Wide_String;
+                     Count    : @b<out> Natural;
+                     Trim_Nul : @b<in> Boolean := True);
+
+   @b<type> char32_t @b<is> @ft<@i<<implementation-defined character type@>>>;
+
+   char32_nul : @b<constant> char32_t := @ft<@i<<implementation-defined>>;
+
+   @b<function> To_C (Item : @b<in> Wide_Wide_Character) @b<return> char32_t;
+   @b<function> To_Ada (Item : @b<in> char32_t) @b<return> Wide_Wide_Character;
+
+   @b<type> char32_array @b<is array> (size_t @b<range> <@>) @b<of aliased> char32_t;
+
+   @b<pragma> Pack(char32_array);
+
+   @b<function> Is_Nul_Terminated (Item : @b<in> char32_array) @b<return> Boolean;
+   @b<function> To_C (Item       : @b<in> Wide_Wide_String;
+                  Append_Nul : @b<in> Boolean := True)
+      @b<return> char32_array;
+
+   @b<function> To_Ada (Item     : @b<in> char32_array;
+                    Trim_Nul : @b<in> Boolean := True)
+      @b<return> Wide_Wide_String;
+
+   @b<procedure> To_C (Item       : @b<in> Wide_Wide_String;
+                   Target     : @b<out> char32_array;
+                   Count      : @b<out> size_t;
+                   Append_Nul : @b<in> Boolean := True);
+
+   @b<procedure> To_Ada (Item     : @b<in> char32_array;
+                     Target   : @b<out> Wide_Wide_String;
+                     Count    : @b<out> Natural;
+                     Trim_Nul : @b<in> Boolean := True);>
+
+
+!corrigendum B.3(43)
+
+@drepl
+The types int, short, long, unsigned, ptrdiff_t, size_t, double, char, and
+wchar_t correspond respectively to the C types having the same names. The types
+signed_char, unsigned_short, unsigned_long, unsigned_char, C_float, and
+long_double correspond respectively to the C types signed char, unsigned short,
+unsigned long, unsigned char, float, and long double.
+@dby
+The types int, short, long, unsigned, ptrdiff_t, size_t, double, char,
+wchar_t, char16_t, and char32_t correspond respectively to the C types having
+the same names. The types signed_char, unsigned_short, unsigned_long,
+unsigned_char, C_float, and long_double correspond respectively to the C types
+signed char, unsigned short, unsigned long, unsigned char, float, and long
+double.
+
+!corrigendum B.3(60)
+
+@dinsa
+@xindent<The To_C and To_Ada subprograms that convert between Wide_String and
+wchar_array have analogous effects to the To_C and To_Ada subprograms that
+convert between String and char_array, except that wide_nul is used instead of
+nul.>
+@dinss
+@xcode<@b<function> Is_Nul_Terminated (Item : @b<in> char16_array) @b<return> Boolean;>
+
+@xindent<The result of Is_Nul_Terminated is True if Item contains char16_nul,
+and is False otherwise.>
+
+@xcode<@b<function> To_C (Item : @b<in> Wide_Character) @b<return> char16_t;
+@b<function> To_Ada (Item : @b<in> char16_t ) @b<return> Wide_Character;>
+
+@xindent<To_C and To_Ada provide the mappings between the Ada and C 16-bit
+character types.>
+
+@xcode<@b<function> To_C (Item       : @b<in> Wide_String;
+               Append_Nul : @b<in> Boolean := True)
+   @b<return> char16_array;
+
+@b<function> To_Ada (Item     : @b<in> char16_array;
+                 Trim_Nul : @b<in> Boolean := True)
+   @b<return> Wide_String;
+
+@b<procedure> To_C (Item       : @b<in> Wide_String;
+                Target     : @b<out> char16_array;
+                Count      : @b<out> size_t;
+                Append_Nul : @b<in> Boolean := True);
+
+@b<procedure> To_Ada (Item     : @b<in> char16_array;
+                  Target   : @b<out> Wide_String;
+                  Count    : @b<out> Natural;
+                  Trim_Nul : @b<in> Boolean := True);>
+
+@xindent<The To_C and To_Ada subprograms that convert between Wide_String and
+char16_array have analogous effects to the To_C and To_Ada subprograms that
+convert between String and char_array, except that char16_nul is used instead
+of nul.>
+
+@xcode<@b<function> Is_Nul_Terminated (Item : @b<in> char32_array) @b<return> Boolean;>
+
+@xindent<The result of Is_Nul_Terminated is True if Item contains char16_nul,
+and is False otherwise.>
+
+@xcode<@b<function> To_C (Item : @b<in> Wide_Wide_Character) @b<return> char32_t;
+@b<function> To_Ada (Item : @b<in> char32_t ) @b<return> Wide_Wide_Character;>
+
+@xindent<To_C and To_Ada provide the mappings between the Ada and C 32-bit
+character types.>
+
+@xcode<@b<function> To_C (Item       : @b<in> Wide_Wide_String;
+               Append_Nul : @b<in> Boolean := True)
+   @b<return> char32_array;
+
+@b<function> To_Ada (Item     : @b<in> char32_array;
+                 Trim_Nul : @b<in> Boolean := True)
+   @b<return> Wide_Wide_String;
+
+@b<procedure> To_C (Item       : @b<in> Wide_Wide_String;
+                Target     : @b<out> char32_array;
+                Count      : @b<out> size_t;
+                Append_Nul : @b<in> Boolean := True);
+
+@b<procedure> To_Ada (Item     : @b<in> char32_array;
+                  Target   : @b<out> Wide_Wide_String;
+                  Count    : @b<out> Natural;
+                  Trim_Nul : @b<in> Boolean := True);>
+
+@xindent<The To_C and To_Ada subprograms that convert between Wide_Wide_String
+and char32_array have analogous effects to the To_C and To_Ada subprograms that
+convert between String and char_array, except that char32_nul is used instead
+of nul.>
+
+
+!corrigendum C.5(7)
+
+@drepl
+If the pragma applies to an enumeration type, then the semantics of the
+Wide_Image and Wide_Value attributes are implementation defined for that type;
+the semantics of Image and Value are still defined in terms of Wide_Image and
+Wide_Value. In addition, the semantics of Text_IO.Enumeration_IO are
+implementation defined. If the pragma applies to a tagged type, then the
+semantics of the Tags.Expanded_Name function are implementation defined for
+that type. If the pragma applies to an exception, then the semantics of the
+Exceptions.Exception_Name function are implementation defined for that
+exception.
+@dby
+If the pragma applies to an enumeration type, then the semantics of the
+Wide_Wide_Image and Wide_Wide_Value attributes are implementation defined for
+that type; the semantics of Image, Wide_Image, Value, and Wide_Value are still
+defined in terms of Wide_Wide_Image and Wide_Wide_Value. In addition, the
+semantics of Text_IO.Enumeration_IO are implementation defined. If the pragma
+applies to a tagged type, then the semantics of the Tags.Expanded_Name function
+are implementation defined for that type. If the pragma applies to an
+exception, then the semantics of the Exceptions.Exception_Name function are
+implementation defined for that exception.
+
+!corrigendum F(4)
+
+@drepl
+@xbullet<the child packages Text_IO.Editing and Wide_Text_IO.Editing, which
+support formatted and localized output of decimal data, based on ''picture
+String'' values.>
+@dby
+@xbullet<the child packages Text_IO.Editing, Wide_Text_IO.Editing,, and
+Wide_Wide_Text_IO.Editing which support formatted and localized output of
+decimal data, based on ''picture String'' values.>
+
+!corrigendum F.3(1)
+
+@drepl
+The child packages Text_IO.Editing and Wide_Text_IO.Editing provide localizable
+formatted text output, known as @i<edited output> , for decimal types. An edited
+output string is a function of a numeric value, program-specifiable locale
+elements, and a format control value. The numeric value is of some decimal
+type. The locale elements are:
+@dby
+The child packages Text_IO.Editing, Wide_Text_IO.Editing, and
+Wide_Wide_Text_IO.Editing provide localizable formatted text output, known as
+@i<edited output>, for decimal types. An edited output string is a function of
+a numeric value, program-specifiable locale elements, and a format control
+value. The numeric value is of some decimal type. The locale elements are:
+
+!corrigendum F.3(6)
+
+@drepl
+For Text_IO.Editing the edited output and currency strings are of type String,
+and the locale characters are of type Character. For Wide_Text_IO.Editing their
+types are Wide_String and Wide_Character, respectively.
+@dby
+For Text_IO.Editing the edited output and currency strings are of type String,
+and the locale characters are of type Character. For Wide_Text_IO.Editing their
+types are Wide_String and Wide_Character, respectively. For
+Wide_Wide_Text_IO.Editing their types are Wide_Wide_String and
+Wide_Wide_Character, respectively.
+
+!corrigendum F.3(19)
+
+@drepl
+The generic packages Text_IO.Decimal_IO and Wide_Text_IO.Decimal_IO (see
+A.10.9, ''Input-Output for Real Types'') provide text input and non-edited text
+output for decimal types.
+@dby
+The generic packages Text_IO.Decimal_IO, Wide_Text_IO.Decimal_IO, and
+Wide_Wide_Text_IO.Decimal_IO (see A.10.9, ''Input-Output for Real Types'')
+provide text input and non-edited text output for decimal types.
+
+!corrigendum F.3(20)
+
+@drepl
+@xindent<@s9<2  A picture String is of type Standard.String, both for
+Text_IO.Editing and Wide_Text_IO.Editing.>>
+@dby
+@xindent<@s9<2  A picture String is of type Standard.String, for all of
+Text_IO.Editing, Wide_Text_IO.Editing, and Wide_Wide_Text_IO.Editing.>>
+
+
+!corrigendum F.3.5(01)
+
+@dinsc
+@i<@s8<Static Semantics>>
+
+The child package Wide_Wide_Text_IO.Editing has the same contents as
+Text_IO.Editing, except that:
+
+@xbullet<each occurrence of Character is replaced by Wide_Wide_Character,>
+@xbullet<each occurrence of Text_IO is replaced by Wide_Wide_Text_IO,>
+@xbullet<the subtype of Default_Currency is Wide_Wide_String rather than String, and
+each occurrence of String in the generic package Decimal_Output is replaced
+by Wide_Wide_String.>
+
+@xindent<@s9<NOTES@hr
+6  Each of the functions Wide_Wide_Text_IO.Editing.Valid, To_Picture, and
+Pic_String has String (versus Wide_Wide_String) as its parameter or result
+subtype, since a picture String is not localizable.>>
+
+
+!corrigendum G.1.5(01)
+
+@dinsc
+@i<@s8<Static Semantics>>
+
+Implementations shall also provide the generic library package
+Wide_Wide_Text_IO.Complex_IO. Its declaration is obtained from that of
+Text_IO.Complex_IO by systematically replacing Text_IO by Wide_Wide_Text_IO and
+String by Wide_Wide_String; the description of its behavior is obtained by
+additionally replacing references to particular characters (commas,
+parentheses, etc.) by those for the corresponding wide wide characters.
+
+!corrigendum H.4(20)
+
+@drepl
+@xhang<@xterm<No_IO>
+Semantic dependence on any of the library units Sequential_IO, Direct_IO,
+Text_IO, Wide_Text_IO, or Stream_IO is not allowed.>
+@dby
+@xhang<@xterm<No_IO>
+Semantic dependence on any of the library units Sequential_IO, Direct_IO,
+Text_IO, Wide_Text_IO, Wide_Wide_Text_IO, or Stream_IO is not allowed.>
+
 
 !ACATS test
 

Questions? Ask the ACAA Technical Agent