emacs-elpa-diffs
[Top][All Lists]
Advanced

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

[elpa] externals/ada-ref-man e94c605 11/18: Release ada-mode version 6.0


From: Stefan Monnier
Subject: [elpa] externals/ada-ref-man e94c605 11/18: Release ada-mode version 6.0. Release wisi version 2.0
Date: Sun, 29 Nov 2020 19:04:47 -0500 (EST)

branch: externals/ada-ref-man
commit e94c605eb296b9d140422c64c3b0ebf09f3109da
Author: Stephen Leake <stephen_leake@stephe-leake.org>
Commit: Stephen Leake <stephen_leake@stephe-leake.org>

    Release ada-mode version 6.0. Release wisi version 2.0
---
 aarm2012.info      | 69276 ++++++++++++++++++++++++++-------------------------
 arm2012.info       | 41131 +++++++++++++++---------------
 build/Makefile     |    14 +-
 build/arm_info.gpr |     1 -
 build/download.py  |     5 +-
 progs/arm_frm.adb  |     4 +-
 progs/arm_mast.adb |     4 +-
 progs/arm_rtf.adb  |     2 +-
 progs/arm_texi.adb |    26 +-
 progs/arm_texi.ads |     9 +-
 10 files changed, 55623 insertions(+), 54849 deletions(-)

diff --git a/aarm2012.info b/aarm2012.info
index 3546c2c..2b44e7e 100644
--- a/aarm2012.info
+++ b/aarm2012.info
@@ -1,4 +1,4 @@
-This is aarm2012.info, produced by texi2any version 6.4 from
+This is aarm2012.info, produced by texi2any version 6.3 from
 aarm2012.texinfo.
 
 INFO-DIR-SECTION GNU Ada tools
@@ -322,12 +322,12 @@ held responsible for identifying any or all such patent 
rights.
 
 3/3
 International Standard ISO/IEC 8652 was prepared by Joint Technical
-Committee ISO/IEC JTC 1, Information Technology Subcommittee SC22,
-Programming languages, their environments and system software
-interfaces.
+Committee ISO/IEC JTC 1, <Information Technology> Subcommittee SC22,
+<Programming languages, their environments and system software
+interfaces>.
 
 4/4
-{AI05-0299-1AI05-0299-1} This consolidated edition updates the third
+{<AI05-0299-1AI05-0299-1>} This consolidated edition updates the third
 edition (ISO/IEC 8652:2012).
 
 5.a/3
@@ -352,7 +352,7 @@ This is the Annotated Ada Reference Manual.
 Other available Ada documents include:
 
 3/3
-   * {AI95-00387-01AI95-00387-01} {AI05-0245-1AI05-0245-1} Ada 2012
+   * {<AI95-00387-01AI95-00387-01>} {<AI05-0245-1AI05-0245-1>} Ada 2012
      Rationale.  This gives an introduction to the changes and new
      features in Ada 2012, and explains the rationale behind them.
      Programmers should read this rationale before reading this Standard
@@ -360,7 +360,7 @@ Other available Ada documents include:
      available.
 
 4/1
-   * This paragraph was deleted.
+   * <This paragraph was deleted.>
 
 5/3
    * The Ada Reference Manual (RM). This is the International Standard
@@ -369,7 +369,7 @@ Other available Ada documents include:
 Design Goals
 
 6/3
-{AI95-00387-01AI95-00387-01} Ada was originally designed with three
+{<AI95-00387-01AI95-00387-01>} Ada was originally designed with three
 overriding concerns: program reliability and maintenance, programming as
 a human activity, and efficiency.  The 1995 revision to the language was
 designed to provide greater flexibility and extensibility, additional
@@ -452,7 +452,7 @@ separately compiled program unit must name the library 
units it
 requires.
 
 14
-Program Units
+<Program Units>
 
 15
 A subprogram is the basic unit for expressing an algorithm.  There are
@@ -485,7 +485,7 @@ either a single executing task or a task type permitting 
the creation of
 any number of similar tasks.
 
 19/2
-{AI95-00114-01AI95-00114-01} A protected unit is the basic unit for
+{<AI95-00114-01AI95-00114-01>} A protected unit is the basic unit for
 defining protected operations for the coordinated use of data shared
 between tasks.  Simple mutual exclusion is provided automatically, and
 more elaborate sharing protocols can be defined.  A protected operation
@@ -496,7 +496,7 @@ protected object or a protected type permitting the 
creation of several
 similar objects.
 
 20
-Declarations and Statements
+<Declarations and Statements>
 
 21
 The body of a program unit generally contains two parts: a declarative
@@ -566,7 +566,7 @@ specify the actions to be taken when the error situation 
arises.
 Exceptions can be raised explicitly by a raise statement.
 
 30
-Data Types
+<Data Types>
 
 31
 Every object in the language has a type, which characterizes a set of
@@ -575,11 +575,11 @@ are elementary types (comprising enumeration, numeric, 
and access types)
 and composite types (including array and record types).
 
 32/2
-{AI95-00285-01AI95-00285-01} {AI95-00387-01AI95-00387-01} 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.
+{<AI95-00285-01AI95-00285-01>} {<AI95-00387-01AI95-00387-01>} 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.
 
 33
 Numeric types provide a means of performing exact or approximate
@@ -590,7 +590,7 @@ point types, with relative bounds on the error.  The 
numeric types
 Integer, Float, and Duration are predefined.
 
 34/2
-{AI95-00285-01AI95-00285-01} {AI95-00387-01AI95-00387-01} Composite
+{<AI95-00285-01AI95-00285-01>} {<AI95-00387-01AI95-00387-01>} 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
@@ -636,7 +636,7 @@ is not known until run time, implicit dispatching is 
performed based on
 the tag of the operand.
 
 38.1/2
-{AI95-00387-01AI95-00387-01} Interface types provide abstract models
+{<AI95-00387-01AI95-00387-01>} Interface types provide abstract models
 from which other interfaces and types may be composed and derived.  This
 provides a reliable form of multiple inheritance.  Interface types may
 also be implemented by task types and protected types thereby enabling
@@ -650,10 +650,10 @@ limited set of index values, and records and private 
types with
 particular discriminant values.
 
 40
-Other Facilities
+<Other Facilities>
 
 41/2
-{AI95-00387-01AI95-00387-01} Aspect clauses can be used to specify the
+{<AI95-00387-01AI95-00387-01>} Aspect clauses can be used to specify the
 mapping between types and features of an underlying machine.  For
 example, the user can specify that objects of a given type must be
 represented with a given number of bits, or that the components of a
@@ -663,20 +663,20 @@ implementation-dependent aspects, including the direct 
insertion of
 machine code.
 
 42/2
-{AI95-00387-01AI95-00387-01} The predefined environment of the language
-provides for input-output and other capabilities by means of standard
-library packages.  Input-output is supported for values of user-defined
-as well as of predefined types.  Standard means of representing values
-in display form are also provided.
+{<AI95-00387-01AI95-00387-01>} The predefined environment of the
+language provides for input-output and other capabilities by means of
+standard library packages.  Input-output is supported for values of
+user-defined as well as of predefined types.  Standard means of
+representing values in display form are also provided.
 
 42.1/2
-{AI95-00387-01AI95-00387-01} The predefined standard library packages
+{<AI95-00387-01AI95-00387-01>} The predefined standard library packages
 provide facilities such as string manipulation, containers of various
 kinds (vectors, lists, maps, etc.), mathematical functions, random
 number generation, and access to the execution environment.
 
 42.2/2
-{AI95-00387-01AI95-00387-01} The specialized annexes define further
+{<AI95-00387-01AI95-00387-01>} The specialized annexes define further
 predefined library packages and facilities with emphasis on areas such
 as real-time scheduling, interrupt handling, distributed systems,
 numerical computation, and high-integrity systems.
@@ -690,11 +690,11 @@ to all types of a given class.
 
 Language Changes
 
-Paragraphs 44 through 57 have been removed as they described differences
-from the first edition of Ada (Ada 83).
+<Paragraphs 44 through 57 have been removed as they described
+differences from the first edition of Ada (Ada 83).>
 
 57.1/3
-{AI95-00387-01AI95-00387-01} This International Standard replaces the
+{<AI95-00387-01AI95-00387-01>} This International Standard replaces the
 second edition of 1995.  It modifies the previous edition by making
 changes and additions that improve the capability of the language and
 the reliability of programs written in the language.  This edition
@@ -704,7 +704,7 @@ interfacing to other languages, and both the 
object-oriented and
 real-time capabilities.
 
 57.2/3
-{AI95-00387-01AI95-00387-01} {AI05-0299-1AI05-0299-1} Significant
+{<AI95-00387-01AI95-00387-01>} {<AI05-0299-1AI05-0299-1>} Significant
 changes originating in Amendment 1 are incorporated:
 
 57.3/3
@@ -771,7 +771,7 @@ changes originating in Amendment 1 are incorporated:
      subclauses *note 6.1::, *note 11.4.2::, and *note 11.5::.
 
 57.12/3
-{AI05-0245-1AI05-0245-1} In addition, this third edition makes
+{<AI05-0245-1AI05-0245-1>} In addition, this third edition makes
 enhancements to address two important issues, namely, the particular
 problems of multiprocessor architectures, and the need to further
 increase the capabilities regarding assertions for correctness.  It also
@@ -779,7 +779,7 @@ makes additional changes and additions that improve the 
capability of
 the language and the reliability of programs written in the language.
 
 57.13/3
-{AI05-0245-1AI05-0245-1} {AI05-0299-1AI05-0299-1} The following
+{<AI05-0245-1AI05-0245-1>} {<AI05-0299-1AI05-0299-1>} The following
 significant changes with respect to the 1995 edition as amended by
 Amendment 1 are incorporated:
 
@@ -790,7 +790,7 @@ Amendment 1 are incorporated:
      13.1.1::.
 
 57.15/4
-   * {AI12-0141-1AI12-0141-1} The concept of assertions introduced in
+   * {<AI12-0141-1AI12-0141-1>} The concept of assertions introduced in
      the 2005 edition is extended with the ability to specify
      preconditions and postconditions for subprograms, and invariants
      for private types and interfaces.  The concept of constraints in
@@ -800,7 +800,7 @@ Amendment 1 are incorporated:
      subclauses *note 3.2.4::, *note 6.1.1::, and *note 7.3.2::.
 
 57.16/4
-   * {AI12-0141-1AI12-0141-1} New forms of expressions are introduced.
+   * {<AI12-0141-1AI12-0141-1>} New forms of expressions are introduced.
      These are if expressions, case expressions, quantified expressions,
      expression functions, and raise expressions.  As well as being
      useful for programming in general by avoiding the introduction of
@@ -862,18 +862,18 @@ initiate the defect correction procedure.
 Comments should use the following format:
 
 60/3
-        !topic Title summarizing comment
-        !reference Ada 2012 RMss.ss(pp)
-        !from Author Name yy-mm-dd
-        !keywords keywords related to topic
+        !topic <Title summarizing comment>
+        !reference Ada 2012 RM<ss.ss(pp)>
+        !from <Author Name yy-mm-dd>
+        !keywords <keywords related to topic>
         !discussion
 
-        text of discussion
+        <text of discussion>
 
 61/3
-where ss.ss is the clause or subclause number, pp is the paragraph
-number where applicable, and yy-mm-dd is the date the comment was sent.
-The date is optional, as is the !keywords line.
+where <ss.ss> is the clause or subclause number, <pp> is the paragraph
+number where applicable, and <yy-mm-dd> is the date the comment was
+sent.  The date is optional, as is the !keywords line.
 
 62/1
 Please use a descriptive "Subject" in your e-mail message, and limit
@@ -1174,10 +1174,10 @@ Manual, except:
      thus, the page breaks are in different places.
 
 77.1/3
-   * This paragraph was deleted.
+   * <This paragraph was deleted.>
 
 77.2/3
-   * {AI05-0299-1AI05-0299-1} The "Using this version of the Ada
+   * {<AI05-0299-1AI05-0299-1>} The "Using this version of the Ada
      Reference Manual" subclause is not included in the International
      Standard.
 
@@ -1213,7 +1213,7 @@ inserted, the paragraph numbers are of the form pp.nn, 
where pp is the
 number of the preceding paragraph, and nn is an insertion number.  For
 instance, the first paragraph inserted after paragraph 8 is numbered
 8.1, the second paragraph inserted is numbered 8.2, and so on.  Deleted
-paragraphs are indicated by the text This paragraph was deleted.
+paragraphs are indicated by the text <This paragraph was deleted.>
 Deleted paragraphs include empty paragraphs that were numbered in the
 1995 edition of the Ada Reference Manual.  Similar markings and
 numbering are used for changes to annotations.
@@ -1279,7 +1279,7 @@ File: aarm2012.info,  Node: 1,  Next: 2,  Prev: Front 
Matter,  Up: Top
 
 2.e
              * The rules of the language (and some AARM-only text) are
-               categorized, and placed under certain sub-headings that
+               categorized, and placed under certain <sub-headings> that
                indicate the category.  For example, the distinction
                between Name Resolution Rules and Legality Rules is
                particularly important, as explained in *note 8.6::.
@@ -1446,9 +1446,8 @@ File: aarm2012.info,  Node: 1,  Next: 2,  Prev: Front 
Matter,  Up: Top
           printed in a smaller font.
 
 2.mm
-          If you have trouble finding things, be sure to use the index.
-          Each defined term appears there, and also in italics, like
-          this.  Syntactic categories defined in BNF are also indexed.
+          If you have trouble finding things, be sure to use the index.        
  Each defined term appears there, and also in <italics, like
+          this>.  Syntactic categories defined in BNF are also indexed.
 
 2.nn
           A definition marked "[distributed]" is the main definition for
@@ -1470,12 +1469,12 @@ File: aarm2012.info,  Node: 1.1,  Next: 1.2,  Up: 1
 =========
 
 1/3
-{AI05-0299-1AI05-0299-1} This International Standard specifies the form
-and meaning of programs written in Ada.  Its purpose is to promote the
-portability of Ada programs to a variety of computing systems.
+{<AI05-0299-1AI05-0299-1>} This International Standard specifies the
+form and meaning of programs written in Ada.  Its purpose is to promote
+the portability of Ada programs to a variety of computing systems.
 
 2/3
-{AI05-0299-1AI05-0299-1} Ada is a programming language designed to
+{<AI05-0299-1AI05-0299-1>} Ada is a programming language designed to
 support the construction of long-lived, highly reliable software
 systems.  The language includes facilities to define packages of related
 types, objects, and operations.  The packages may be parameterized and
@@ -1490,8 +1489,8 @@ The language treats modularity in the physical sense as 
well, with a
 facility to support separate compilation.
 
 3/4
-{AI05-0269-1AI05-0269-1} {AI05-0299-1AI05-0299-1}
-{AI12-0056-1AI12-0056-1} The language provides rich support for
+{<AI05-0269-1AI05-0269-1>} {<AI05-0299-1AI05-0299-1>}
+{<AI12-0056-1AI12-0056-1>} The language provides rich support for
 real-time, concurrent programming, and includes facilities for multicore
 and multiprocessor programming.  Errors can be signaled as exceptions
 and handled explicitly.  The language also covers systems programming;
@@ -1578,11 +1577,11 @@ File: aarm2012.info,  Node: 1.1.2,  Next: 1.1.3,  Prev: 
1.1.1,  Up: 1.1
 ---------------
 
 1/3
-{AI05-0299-1AI05-0299-1} This International Standard contains thirteen
+{<AI05-0299-1AI05-0299-1>} This International Standard contains thirteen
 clauses, fifteen annexes, and an index.
 
 1.a/3
-          Discussion: {AI05-0299-1AI05-0299-1} What Ada 83 called a
+          Discussion: {<AI05-0299-1AI05-0299-1>} What Ada 83 called a
           "chapter" and Ada 95 (and Ada 2005) called a "section" is
           called a "clause" in this Standard.  Similarly, what Ada 83
           called a "section" and Ada 95 (and Ada 2005) called a "clause"
@@ -1591,10 +1590,10 @@ clauses, fifteen annexes, and an index.
           ever-changing ISO rules for drafting Standards.
 
 2
-The core of the Ada language consists of:
+The <core> of the Ada language consists of:
 
 3/3
-   * {AI05-0299-1AI05-0299-1} Clauses 1 through 13
+   * {<AI05-0299-1AI05-0299-1>} Clauses 1 through 13
 
 4
    * *note Annex A::, "*note Annex A:: Predefined Language Environment"
@@ -1606,8 +1605,8 @@ The core of the Ada language consists of:
    * *note Annex J::, "*note Annex J:: Obsolescent Features"
 
 7
-The following Specialized Needs Annexes define features that are needed
-by certain application areas:
+The following <Specialized Needs Annexes> define features that are
+needed by certain application areas:
 
 8
    * *note Annex C::, "*note Annex C:: Systems Programming"
@@ -1636,8 +1635,8 @@ informative:
    * Text under a NOTES or Examples heading.
 
 16/3
-   * {AI05-0299-1AI05-0299-1} Each subclause whose title starts with the
-     word "Example" or "Examples".
+   * {<AI05-0299-1AI05-0299-1>} Each subclause whose title starts with
+     the word "Example" or "Examples".
 
 17
 All implementations shall conform to the core language.  In addition, an
@@ -1655,8 +1654,8 @@ The following Annexes are informative:
    * *note Annex L::, "*note Annex L:: Language-Defined Pragmas"
 
 21/3
-   * {AI05-0004-1AI05-0004-1} *note Annex M::, "*note Annex M:: Summary
-     of Documentation Requirements"
+   * {<AI05-0004-1AI05-0004-1>} *note Annex M::, "*note Annex M::
+     Summary of Documentation Requirements"
 
 22
    * *note Annex N::, "*note Annex N:: Glossary"
@@ -1665,7 +1664,7 @@ The following Annexes are informative:
    * *note Annex P::, "*note Annex P:: Syntax Summary"
 
 23.1/3
-   * {AI05-0262-1AI05-0262-1} *note Annex Q::, "*note Annex Q::
+   * {<AI05-0262-1AI05-0262-1>} *note Annex Q::, "*note Annex Q::
      Language-Defined Entities"
 
 23.a
@@ -1689,11 +1688,11 @@ The following Annexes are informative:
           the functionality.
 
 23.c/2
-          {AI95-00114-01AI95-00114-01} We recommend that the
+          {<AI95-00114-01AI95-00114-01>} We recommend that the
           certification procedures allow implementations to certify the
           core language, plus any set of the Specialized Needs Annexes.
-          We recommend that implementations not be allowed to certify a
-          portion of one of the Specialized Needs Annexes, although
+          We recommend that implementations <not> be allowed to certify
+          a portion of one of the Specialized Needs Annexes, although
           implementations can, of course, provide uncertified support
           for such portions.  We have designed the Specialized Needs
           Annexes assuming that this recommendation is followed.  Thus,
@@ -1720,9 +1719,9 @@ The following Annexes are informative:
           Needs Annexes, and that the semantics of the program will not
           change.  For example, an implementation should not provide a
           package with the same name as one defined in one of the
-          Specialized Needs Annexes, but that behaves differently, even
+          Specialized Needs Annexes, but that behaves differently, <even
           if that implementation does not claim conformance to that
-          Annex.
+          Annex>.
 
 23.f
           Note that the Specialized Needs Annexes do not conflict with
@@ -1730,10 +1729,10 @@ The following Annexes are informative:
           conform to all of them.
 
 24/4
-{AI05-0299-1AI05-0299-1} {AI12-0056-1AI12-0056-1} Each clause is divided
-into subclauses that have a common structure.  Each clause and subclause
-first introduces its subject.  After the introductory text, text is
-labeled with the following headings:
+{<AI05-0299-1AI05-0299-1>} {<AI12-0056-1AI12-0056-1>} Each clause is
+divided into subclauses that have a common structure.  Each clause and
+subclause first introduces its subject.  After the introductory text,
+text is labeled with the following headings:
 
                      _Language Design Principles_
 
@@ -1744,8 +1743,8 @@ labeled with the following headings:
           explained.
 
 24.b/3
-          {AI05-0005-1AI05-0005-1} This is not part of the definition of
-          the language, and does not appear in the Ada 2012 RM.
+          {<AI05-0005-1AI05-0005-1>} This is not part of the definition
+          of the language, and does not appear in the Ada 2012 RM.
 
                                _Syntax_
 
@@ -1755,7 +1754,7 @@ labeled with the following headings:
                         _Name Resolution Rules_
 
 26/3
-{AI05-0299-1AI05-0299-1} Compile-time rules that are used in name
+{<AI05-0299-1AI05-0299-1>} Compile-time rules that are used in name
 resolution, including overload resolution.
 
 26.a
@@ -1779,7 +1778,7 @@ resolution, including overload resolution.
                            _Legality Rules_
 
 27
-Rules that are enforced at compile time. A construct is legal if it
+Rules that are enforced at compile time.  A construct is <legal> if it
 obeys all of the Legality Rules.
 
 27.a
@@ -1811,8 +1810,8 @@ A definition of the compile-time effect of each construct.
                        _Post-Compilation Rules_
 
 29
-Rules that are enforced before running a partition. A partition is legal
-if its compilation units are legal and it obeys all of the
+Rules that are enforced before running a partition.  A partition is
+legal if its compilation units are legal and it obeys all of the
 Post-Compilation Rules.
 
 29.a
@@ -1975,7 +1974,7 @@ This material is informative.
 39.c
           (Note that the semantics of a program is not the same thing as
           the behavior of the program.  Because of Ada's indeterminacy,
-          the "semantics" of a given feature describes a set of
+          the "semantics" of a given feature describes a <set> of
           behaviors that can be exhibited by that feature.  The set can
           contain more than one allowed behavior.  Thus, when we ask
           whether the semantics changes, we are asking whether the set
@@ -2048,7 +2047,7 @@ This material is informative.
           different semantics.
 
 39.n/3
-          {AI05-0005-1AI05-0005-1} Inconsistencies marked with
+          {<AI05-0005-1AI05-0005-1>} Inconsistencies marked with
           Corrigendum: are corrections to the original Ada 95 definition
           introduced by Corrigendum 1.  Inconsistencies marked with
           Amendment Correction: are corrections to the original Ada 95
@@ -2078,7 +2077,7 @@ This material is informative.
           in which a legal Ada 95 program is illegal in Ada 2005.
 
 39.q/3
-          {AI05-0005-1AI05-0005-1} As with inconsistencies,
+          {<AI05-0005-1AI05-0005-1>} As with inconsistencies,
           incompatibilities marked with Corrigendum: are corrections to
           the original Ada 95 definition introduced by Corrigendum 1.
           Incompatibilities marked with Amendment Correction: are
@@ -2109,18 +2108,18 @@ This material is informative.
           into this category.
 
 39.t/3
-          {AI05-0005-1AI05-0005-1} As with incompatibilities, extensions
-          marked with Corrigendum: are corrections to the original Ada
-          95 definition introduced by Corrigendum 1.  Extensions marked
-          with Amendment Correction: are corrections to the original Ada
-          95 definition added by Amendment 1.  Formally, these are
-          extensions allowed by Ada Issues classified as Binding
-          Interpretations.  As corrections, implementations of Ada 95
-          are allowed to implement these extensions.  Thus, these
-          strictly speaking are not extensions of Ada 95; they're part
-          of Ada 95.  Practically, however, they very well may be
-          extensions, as early Ada 95 implementations might not
-          implement the extension.  Therefore, some Ada 95
+          {<AI05-0005-1AI05-0005-1>} As with incompatibilities,
+          extensions marked with Corrigendum: are corrections to the
+          original Ada 95 definition introduced by Corrigendum 1.
+          Extensions marked with Amendment Correction: are corrections
+          to the original Ada 95 definition added by Amendment 1.
+          Formally, these are extensions allowed by Ada Issues
+          classified as Binding Interpretations.  As corrections,
+          implementations of Ada 95 are allowed to implement these
+          extensions.  Thus, these strictly speaking are not extensions
+          of Ada 95; they're part of Ada 95.  Practically, however, they
+          very well may be extensions, as early Ada 95 implementations
+          might not implement the extension.  Therefore, some Ada 95
           implementations may be able to compile the examples, while
           others might not.  In contrast, Ada 2005 compilers will always
           support the extensions.  Therefore, we document these for
@@ -2391,7 +2390,7 @@ File: aarm2012.info,  Node: 1.1.3,  Next: 1.1.4,  Prev: 
1.1.2,  Up: 1.1
 A conforming implementation shall:
 
 1.a
-          Discussion: The implementation is the software and hardware
+          Discussion: The <implementation> is the software and hardware
           that implements the language.  This includes compiler, linker,
           operating system, hardware, etc.
 
@@ -2466,7 +2465,7 @@ A conforming implementation shall:
 5.c
           Wherever in the standard the text of a language-defined
           library unit contains an italicized phrase starting with
-          "implementation-defined", the implementation's version will
+          "<implementation-defined>", the implementation's version will
           replace that phrase with some implementation-defined text that
           is syntactically legal at that place, and follows any other
           applicable rules.
@@ -2502,9 +2501,9 @@ A conforming implementation shall:
      International Standard.
 
 8
-The external effect of the execution of an Ada program is defined in
-terms of its interactions with its external environment. The following
-are defined as external interactions:
+The <external effect> of the execution of an Ada program is defined in
+terms of its interactions with its external environment.  The following
+are defined as <external interactions>:
 
 9
    * Any interaction with an external file (see *note A.7::);
@@ -2532,8 +2531,8 @@ are defined as external interactions:
           results and values returned in [in] out parameters.
 
 12.a.1/1
-          {8652/00948652/0094} {AI95-00119-01AI95-00119-01} The lack of
-          a result from a program that does not terminate is also
+          {<8652/00948652/0094>} {<AI95-00119-01AI95-00119-01>} The lack
+          of a result from a program that does not terminate is also
           included here.
 
 13
@@ -2545,7 +2544,7 @@ are defined as external interactions:
      at the time of any other interaction with the external environment.
 
 14.a/3
-          To be honest: {AI05-0229-1AI05-0229-1} Also other uses of
+          To be honest: {<AI05-0229-1AI05-0229-1>} Also other uses of
           imported and exported entities, as defined by the
           implementation, if the implementation supports such importing
           or exporting.
@@ -2572,9 +2571,9 @@ semantics of the given program.
           11.6:: is part of the standard.
 
 15.c
-          Note also that we only require "an appropriate sequence of
-          external interactions" rather than "the same sequence..."  An
-          optimizer may cause a different sequence of external
+          Note also that we only require "<an appropriate> sequence of
+          external interactions" rather than "<the same> sequence..."
+          An optimizer may cause a different sequence of external
           interactions to be produced than would be produced without the
           optimizer, so long as the new sequence still satisfies the
           requirements of the standard.  For example, optimization might
@@ -2617,7 +2616,7 @@ as specified.
           Annex.
 
 17/3
-{AI05-0229-1AI05-0229-1} An implementation conforming to this
+{<AI05-0229-1AI05-0229-1>} An implementation conforming to this
 International Standard may provide additional aspects, attributes,
 library units, and pragmas.  However, it shall not provide any aspect,
 attribute, library unit, or pragma having the same name as an aspect,
@@ -2675,13 +2674,13 @@ time.
                      _Documentation Requirements_
 
 18
-Certain aspects of the semantics are defined to be either implementation
-defined or unspecified.  In such cases, the set of possible effects is
-specified, and the implementation may choose any effect in the set.
-Implementations shall document their behavior in implementation-defined
-situations, but documentation is not required for unspecified
-situations.  The implementation-defined characteristics are summarized
-in *note M.2::.
+Certain aspects of the semantics are defined to be either
+<implementation defined> or <unspecified>.  In such cases, the set of
+possible effects is specified, and the implementation may choose any
+effect in the set.  Implementations shall document their behavior in
+implementation-defined situations, but documentation is not required for
+unspecified situations.  The implementation-defined characteristics are
+summarized in *note M.2::.
 
 18.a
           Discussion: We used to use the term "implementation dependent"
@@ -2737,7 +2736,7 @@ Annex feature at run time, it should raise Program_Error 
if feasible.
           time.
 
 20.a
-          Reason: The reason we don't require Program_Error is that
+          Reason: The reason we don't <require> Program_Error is that
           there are situations where other exceptions might make sense.
           For example, if the Real Time Systems Annex requires that the
           range of System.Priority include at least 30 values, an
@@ -2817,7 +2816,7 @@ variant of Backus-Naur Form.  In particular:
      rules are equivalent.
 
 9/2
-          {AI95-00433-01AI95-00433-01}
+          {<AI95-00433-01AI95-00433-01>}
           simple_return_statement ::= return [expression];
           simple_return_statement ::= return; | return expression;
 
@@ -2844,7 +2843,7 @@ variant of Backus-Naur Form.  In particular:
    * 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 subtype_name and task_name are both
+     information.  For example <subtype_>name and <task_>name are both
      equivalent to name alone.
 
 14.a
@@ -2856,7 +2855,7 @@ variant of Backus-Naur Form.  In particular:
           We often use "if" to mean "if and only if" in definitions.
           For example, if we define "photogenic" by saying, "A type is
           photogenic if it has the following properties...," we mean
-          that a type is photogenic if and only if it has those
+          that a type is photogenic if <and only if> it has those
           properties.  It is usually clear from the context, and adding
           the "and only if" seems too cumbersome.
 
@@ -2882,8 +2881,8 @@ variant of Backus-Naur Form.  In particular:
           not some type Duration the user might have declared.
 
 14.1/3
-{AI95-00285-01AI95-00285-01} {AI05-0004-1AI05-0004-1}
-{AI05-0262-1AI05-0262-1} The delimiters, compound delimiters, reserved
+{<AI95-00285-01AI95-00285-01>} {<AI05-0004-1AI05-0004-1>}
+{<AI05-0262-1AI05-0262-1>} The delimiters, compound delimiters, reserved
 words, and numeric_literals are exclusively made of the characters whose
 code point is between 16#20# and 16#7E#, inclusively.  The special
 characters for which names are defined in this International Standard
@@ -2897,23 +2896,23 @@ CAPITAL LETTER E", not "GREEK CAPITAL LETTER EPSILON".]
           range are required.
 
 14.2/3
-{AI95-00395-01AI95-00395-01} {AI05-0227-1AI05-0227-1}
-{AI05-0299-1AI05-0299-1} When this International Standard mentions the
+{<AI95-00395-01AI95-00395-01>} {<AI05-0227-1AI05-0227-1>}
+{<AI05-0299-1AI05-0299-1>} When this International Standard mentions the
 conversion of some character or sequence of characters to upper case, it
 means the character or sequence of characters obtained by using simple
 upper case mapping, as defined by documents referenced in the note in
 Clause 1 of ISO/IEC 10646:2011.
 
 14.e.1/3
-          This paragraph was deleted.
+          <This paragraph was deleted.>
 
 15
-A syntactic category is a nonterminal in the grammar defined in BNF
+A <syntactic category> is a nonterminal in the grammar defined in BNF
 under "Syntax."  Names of syntactic categories are set in a different
 font, like_this.
 
 16
-A construct is a piece of text (explicit or implicit) that is an
+A <construct> is a piece of text (explicit or implicit) that is an
 instance of a syntactic category defined under "Syntax".
 
 16.a
@@ -2930,21 +2929,21 @@ instance of a syntactic category defined under "Syntax".
           of that text.
 
 17
-A constituent of a construct is the construct itself, or any construct
+A <constituent> of a construct is the construct itself, or any construct
 appearing within it.
 
 18
 Whenever the run-time semantics defines certain actions to happen in an
-arbitrary order, this means that the implementation shall arrange for
+<arbitrary order>, this means that the implementation shall arrange for
 these actions to occur in a way that is equivalent to some sequential
 order, following the rules that result from that sequential order.  When
 evaluations are defined to happen in an arbitrary order, with conversion
 of the results to some subtypes, or with some run-time checks, the
 evaluations, conversions, and checks may be arbitrarily interspersed, so
 long as each expression is evaluated before converting or checking its
-value. [Note that the effect of a program can depend on the order chosen
-by the implementation.  This can happen, for example, if two actual
-parameters of a given call have side effects.]
+value.  [Note that the effect of a program can depend on the order
+chosen by the implementation.  This can happen, for example, if two
+actual parameters of a given call have side effects.]
 
 18.a
           Discussion: Programs will be more portable if their external
@@ -2999,7 +2998,7 @@ parameters of a given call have side effects.]
                      _Wording Changes from Ada 95_
 
 21.a/2
-          {AI95-00285-01AI95-00285-01} We now explicitly say that the
+          {<AI95-00285-01AI95-00285-01>} We now explicitly say that the
           lexical elements of the language (with a few exceptions) are
           made up of characters in the lower half of the Latin-1
           character set.  This is needed to avoid confusion given the
@@ -3007,21 +3006,21 @@ parameters of a given call have side effects.]
           and strings.
 
 21.b/2
-          {AI95-00395-01AI95-00395-01} We now explicitly define what the
-          Standard means by upper case, as there are many possibilities
-          for ISO 10646 characters.
+          {<AI95-00395-01AI95-00395-01>} We now explicitly define what
+          the Standard means by upper case, as there are many
+          possibilities for ISO 10646 characters.
 
 21.c/2
-          {AI95-00433-01AI95-00433-01} The example for square brackets
+          {<AI95-00433-01AI95-00433-01>} The example for square brackets
           has been changed as there is no longer a return_statement
           syntax rule.
 
                     _Wording Changes from Ada 2005_
 
 21.d/3
-          {AI05-0227-1AI05-0227-1} Correction: Upper case is defined by
-          "simple upper case mapping", because "full case folding" is a
-          mapping (mostly) to lower case.
+          {<AI05-0227-1AI05-0227-1>} Correction: Upper case is defined
+          by "simple upper case mapping", because "full case folding" is
+          a mapping (mostly) to lower case.
 
 
 File: aarm2012.info,  Node: 1.1.5,  Prev: 1.1.4,  Up: 1.1
@@ -3046,7 +3045,7 @@ categories:
      allowed, permitted, legal, or illegal belongs to this category.
      Any program that contains such an error is not a legal Ada program;
      on the other hand, the fact that a program is legal does not mean,
-     per se, that the program is free from other forms of error.
+     <per se>, that the program is free from other forms of error.
 
 4
      The rules are further classified as either compile time rules, or
@@ -3081,10 +3080,10 @@ categories:
 8
      The language rules define certain kinds of errors that need not be
      detected either prior to or during run time, but if not detected,
-     the range of possible effects shall be bounded. The errors of this
-     category are called bounded errors. The possible effects of a given
-     bounded error are specified for each such error, but in any case
-     one possible effect of a bounded error is the raising of the
+     the range of possible effects shall be bounded.  The errors of this
+     category are called <bounded errors>.  The possible effects of a
+     given bounded error are specified for each such error, but in any
+     case one possible effect of a bounded error is the raising of the
      exception Program_Error.
 
 9
@@ -3092,7 +3091,7 @@ categories:
 
 10
      In addition to bounded errors, the language rules define certain
-     kinds of errors as leading to erroneous execution.  Like bounded
+     kinds of errors as leading to <erroneous execution>.  Like bounded
      errors, the implementation need not detect such errors either prior
      to or during run time.  Unlike bounded errors, there is no
      language-specified bound on the possible effect of erroneous
@@ -3125,7 +3124,7 @@ categories:
                      _Implementation Permissions_
 
 11
-[ An implementation may provide nonstandard modes of operation.
+[ An implementation may provide <nonstandard modes> of operation.
 Typically these modes would be selected by a pragma or by a command line
 switch when the compiler is invoked.  When operating in a nonstandard
 mode, the implementation may reject compilation_units that do not
@@ -3133,8 +3132,7 @@ conform to additional requirements associated with the 
mode, such as an
 excessive number of warnings or violation of coding style guidelines.
 Similarly, in a nonstandard mode, the implementation may apply special
 optimizations or alternative algorithms that are only meaningful for
-programs that satisfy certain criteria specified by the implementation. 
-In any case, an implementation shall support a standard mode that
+programs that satisfy certain criteria specified by the implementation.In any 
case, an implementation shall support a <standard> mode that
 conforms to the requirements of this International Standard; in
 particular, in the standard mode, all legal compilation_units shall be
 accepted.]
@@ -3170,10 +3168,10 @@ should raise Program_Error.
 12.b
           Other situations that are erroneous in Ada 83 are changed to
           be bounded errors.  In particular, evaluating an uninitialized
-          scalar variable is a bounded error. The possible results are
+          scalar variable is a bounded error.  The possible results are
           to raise Program_Error (as always), or to produce a
           machine-representable value (which might not be in the subtype
-          of the variable). Violating a Range_Check or Overflow_Check
+          of the variable).  Violating a Range_Check or Overflow_Check
           raises Constraint_Error, even if the value came from an
           uninitialized variable.  This means that optimizers can no
           longer "assume" that all variables are initialized within
@@ -3200,95 +3198,96 @@ File: aarm2012.info,  Node: 1.2,  Next: 1.3,  Prev: 
1.1,  Up: 1
 ========================
 
 1/3
-{AI05-0299-1AI05-0299-1} The following documents, in whole or in part,
+{<AI05-0299-1AI05-0299-1>} The following documents, in whole or in part,
 are normatively referenced in this document and are indispensable for
 its application.  For dated references, only the edition cited applies.
 For undated references, the latest edition of the referenced document
 (including any amendments) applies.
 
 1.1/3
-{AI05-0127-2AI05-0127-2} {AI05-0299-1AI05-0299-1} ISO 639-3:2007, Codes
-for the representation of names of languages -- Part 3: Alpha-3 code for
-comprehensive coverage of languages.
+{<AI05-0127-2AI05-0127-2>} {<AI05-0299-1AI05-0299-1>} ISO 639-3:2007,
+<Codes for the representation of names of languages -- Part 3: Alpha-3
+code for comprehensive coverage of languages>.
 
 2
-ISO/IEC 646:1991, Information technology -- ISO 7-bit coded character
-set for information interchange.
+ISO/IEC 646:1991, <Information technology -- ISO 7-bit coded character
+set for information interchange>.
 
 3/2
-{AI95-00415-01AI95-00415-01} ISO/IEC 1539-1:2004, Information technology
--- Programming languages -- Fortran -- Part 1: Base language.
+{<AI95-00415-01AI95-00415-01>} ISO/IEC 1539-1:2004, <Information
+technology -- Programming languages -- Fortran -- Part 1: Base
+language>.
 
 4/2
-{AI95-00415-01AI95-00415-01} ISO/IEC 1989:2002, Information technology
--- Programming languages -- COBOL.
+{<AI95-00415-01AI95-00415-01>} ISO/IEC 1989:2002, <Information
+technology -- Programming languages -- COBOL>.
 
 4.1/3
-{AI05-0127-2AI05-0127-2} {AI05-0299-1AI05-0299-1} ISO/IEC 3166-1:2006,
-Codes for the representation of names of countries and their
-subdivisions -- Part 1: Country Codes.
+{<AI05-0127-2AI05-0127-2>} {<AI05-0299-1AI05-0299-1>} ISO/IEC
+3166-1:2006, <Codes for the representation of names of countries and
+their subdivisions -- Part 1: Country Codes>.
 
 5
-ISO/IEC 6429:1992, Information technology -- Control functions for coded
-graphic character sets.
+ISO/IEC 6429:1992, <Information technology -- Control functions for
+coded graphic character sets>.
 
 5.1/2
-{AI95-00351-01AI95-00351-01} ISO 8601:2004, Data elements and
+{<AI95-00351-01AI95-00351-01>} ISO 8601:2004, <Data elements and
 interchange formats -- Information interchange -- Representation of
-dates and times.
+dates and times>.
 
 6/3
-{AI05-0299-1AI05-0299-1} ISO/IEC 8859-1:1998, Information technology --
-8-bit single-byte coded graphic character sets -- Part 1: Latin alphabet
-No.  1.
+{<AI05-0299-1AI05-0299-1>} ISO/IEC 8859-1:1998, <Information technology
+-- 8-bit single-byte coded graphic character sets -- Part 1: Latin
+alphabet No.  1>.
 
 7/3
-{AI95-00415-01AI95-00415-01} {AI05-0266-1AI05-0266-1} ISO/IEC 9899:2011,
-Information technology -- Programming languages -- C.
+{<AI95-00415-01AI95-00415-01>} {<AI05-0266-1AI05-0266-1>} ISO/IEC
+9899:2011, <Information technology -- Programming languages -- C>.
 
 8/3
-{8652/00018652/0001} {AI95-00124-01AI95-00124-01}
-{AI95-00285-01AI95-00285-01} {AI05-0266-1AI05-0266-1} ISO/IEC
-10646:2011, Information technology -- Universal Multiple-Octet Coded
-Character Set (UCS).
+{<8652/00018652/0001>} {<AI95-00124-01AI95-00124-01>}
+{<AI95-00285-01AI95-00285-01>} {<AI05-0266-1AI05-0266-1>} ISO/IEC
+10646:2011, <Information technology -- Universal Multiple-Octet Coded
+Character Set (UCS)>.
 
 8.a.1/2
-          This paragraph was deleted.{8652/00018652/0001}
-          {AI95-00124-01AI95-00124-01} {AI95-00285-01AI95-00285-01}
+          <This paragraph was deleted.>{<8652/00018652/0001>}
+          {<AI95-00124-01AI95-00124-01>} {<AI95-00285-01AI95-00285-01>}
 
 9/3
-{AI95-00376-01AI95-00376-01} {AI05-0266-1AI05-0266-1} ISO/IEC
-14882:2011, Information technology -- Programming languages -- C++.
+{<AI95-00376-01AI95-00376-01>} {<AI05-0266-1AI05-0266-1>} ISO/IEC
+14882:2011, <Information technology -- Programming languages -- C++>.
 
 10/2
-{AI95-00285-01AI95-00285-01} ISO/IEC TR 19769:2004, Information
+{<AI95-00285-01AI95-00285-01>} ISO/IEC TR 19769:2004, <Information
 technology -- Programming languages, their environments and system
 software interfaces -- Extensions for the programming language C to
-support new character data types.
+support new character data types>.
 
 10.a
-          Discussion: POSIX, Portable Operating System Interface (POSIX)
-          -- Part 1: System Application Program Interface (API) [C
-          Language], The Institute of Electrical and Electronics
+          Discussion: POSIX, <Portable Operating System Interface
+          (POSIX) -- Part 1: System Application Program Interface (API)
+          [C Language]>, The Institute of Electrical and Electronics
           Engineers, 1990.
 
                      _Wording Changes from Ada 95_
 
 10.b/2
-          {AI95-00285-01AI95-00285-01} {AI95-00376-01AI95-00376-01}
-          {AI95-00415-01AI95-00415-01} Updated references to the most
+          {<AI95-00285-01AI95-00285-01>} {<AI95-00376-01AI95-00376-01>}
+          {<AI95-00415-01AI95-00415-01>} Updated references to the most
           recent versions of these standards.  Added C++ and time
           standards.  Added C character set technical report.
 
                     _Wording Changes from Ada 2005_
 
 10.c/3
-          {AI05-0127-2AI05-0127-2} Added language and country code
+          {<AI05-0127-2AI05-0127-2>} Added language and country code
           standards for locale support.
 
 10.d/3
-          {AI05-0266-1AI05-0266-1} Updated references to the most recent
-          versions of these standards.
+          {<AI05-0266-1AI05-0266-1>} Updated references to the most
+          recent versions of these standards.
 
 
 File: aarm2012.info,  Node: 1.3,  Prev: 1.2,  Up: 1
@@ -3297,26 +3296,27 @@ File: aarm2012.info,  Node: 1.3,  Prev: 1.2,  Up: 1
 =========================
 
 1/2
-{AI95-00415-01AI95-00415-01} Terms are defined throughout this
-International Standard, indicated by italic type.  Terms explicitly
+{<AI95-00415-01AI95-00415-01>} Terms are defined throughout this
+International Standard, indicated by <italic> type.  Terms explicitly
 defined in this International Standard are not to be presumed to refer
 implicitly to similar terms defined elsewhere.  Mathematical terms not
 defined in this International Standard are to be interpreted according
-to the CRC Concise Encyclopedia of Mathematics, Second Edition.  Other
+to the <CRC Concise Encyclopedia of Mathematics, Second Edition>.  Other
 terms not defined in this International Standard are to be interpreted
-according to the Webster's Third New International Dictionary of the
-English Language.  Informal descriptions of some terms are also given in
-*note Annex N::, "*note Annex N:: Glossary". 
+according to the <Webster's Third New International Dictionary of the
+English Language>.  Informal descriptions of some terms are also given
+in *note Annex N::, "*note Annex N:: Glossary".  
 
 1.a
           Discussion: The index contains an entry for every defined
           term.
 
 1.a.1/2
-          {AI95-00415-01AI95-00415-01} The contents of the CRC Concise
-          Encyclopedia of Mathematics, Second Edition can be accessed on
-          http://www.mathworld.com (http://www.mathworld.com).  The ISBN
-          number of the book is ISBN 1584883472.
+          {<AI95-00415-01AI95-00415-01>} The contents of the <CRC
+          Concise Encyclopedia of Mathematics, Second Edition> can be
+          accessed on http://www.mathworld.com
+          (http://www.mathworld.com).  The ISBN number of the book is
+          ISBN 1584883472.
 
 1.b
           Glossary entry: Each term defined in *note Annex N:: is marked
@@ -3324,28 +3324,28 @@ English Language.  Informal descriptions of some terms 
are also given in
 
 1.c/3
           Discussion: Here are some AARM-only definitions: The Ada
-          Rapporteur Group (ARG) interprets the Ada Reference Manual. An
-          Ada Issue (AI) is a numbered ruling from the ARG. Ada Issues
-          created for Ada 83 are denoted as "AI83", while Ada Issues
-          created for Ada 95 are denoted as "AI95" in this document.
-          Similarly, Ada Issues created for Ada 2005 are denoted as
-          "AI05" The Ada Commentary Integration Document (ACID) is an
-          edition of the Ada 83 RM in which clearly marked insertions
-          and deletions indicate the effect of integrating the approved
-          AIs. The Uniformity Rapporteur Group (URG) issued
-          recommendations intended to increase uniformity across Ada
-          implementations.  The functions of the URG have been assumed
-          by the ARG. A Uniformity Issue (UI) was a numbered
+          Rapporteur Group (ARG) interprets the Ada Reference Manual.  
+          An Ada Issue (AI) is a numbered ruling from the ARG. Ada
+          Issues created for Ada 83 are denoted as "AI83", while Ada
+          Issues created for Ada 95 are denoted as "AI95" in this
+          document.  Similarly, Ada Issues created for Ada 2005 are
+          denoted as "AI05" The Ada Commentary Integration Document
+          (ACID) is an edition of the Ada 83 RM in which clearly marked
+          insertions and deletions indicate the effect of integrating
+          the approved AIs.  The Uniformity Rapporteur Group (URG)
+          issued recommendations intended to increase uniformity across
+          Ada implementations.  The functions of the URG have been
+          assumed by the ARG. A Uniformity Issue (UI) was a numbered
           recommendation from the URG. A Defect Report and Response is
           an official query to WG9 about an error in the standard.
           Defect Reports are processed by the ARG, and are referenced
           here by their ISO numbers: 8652/nnnn.  Most changes to the Ada
           95 standard include reference(s) to the Defect Report(s) that
-          prompted the change. The Ada Conformity Assessment Test Suite
-          (ACATS) is a set of tests intended to check the conformity of
-          Ada implementations to this standard.  This set of tests was
-          previously known as the Ada Compiler Validation Capability
-          (ACVC).
+          prompted the change.  The <Ada Conformity Assessment Test
+          Suite (ACATS)> is a set of tests intended to check the
+          conformity of Ada implementations to this standard.  This set
+          of tests was previously known as the Ada Compiler Validation
+          Capability (ACVC).
 
 
 File: aarm2012.info,  Node: 2,  Next: 3,  Prev: 1,  Up: Top
@@ -3354,8 +3354,8 @@ File: aarm2012.info,  Node: 2,  Next: 3,  Prev: 1,  Up: 
Top
 ******************
 
 1/3
-{AI05-0299-1AI05-0299-1} [The text of a program consists of the texts of
-one or more compilations.  The text of a compilation is a sequence of
+{<AI05-0299-1AI05-0299-1>} [The text of a program consists of the texts
+of one or more compilations.  The text of a compilation is a sequence of
 lexical elements, each composed of characters; the rules of composition
 are given in this clause.  Pragmas, which provide certain information
 for the compiler, are also described in this clause.]
@@ -3379,32 +3379,31 @@ File: aarm2012.info,  Node: 2.1,  Next: 2.2,  Up: 2
 =================
 
 1/3
-{AI95-00285-01AI95-00285-01} {AI95-00395-01AI95-00395-01}
-{AI05-0266-1AI05-0266-1} The character repertoire for the text of an Ada
-program consists of the entire coding space described by the ISO/IEC
+{<AI95-00285-01AI95-00285-01>} {<AI95-00395-01AI95-00395-01>}
+{<AI05-0266-1AI05-0266-1>} The character repertoire for the text of an
+Ada program consists of the entire coding space described by the ISO/IEC
 10646:2011 Universal Multiple-Octet Coded Character Set.  This coding
-space is organized in planes, each plane comprising 65536 characters. 
-
+space is organized in <planes>, each plane comprising 65536 characters.
 1.a/2
-          This paragraph was deleted.{AI95-00285-01AI95-00285-01}
+          <This paragraph was deleted.>{<AI95-00285-01AI95-00285-01>}
 
 1.b/2
-          This paragraph was deleted.{AI95-00285-01AI95-00285-01}
+          <This paragraph was deleted.>{<AI95-00285-01AI95-00285-01>}
 
 1.c/3
-          Discussion: {AI95-00285-01AI95-00285-01}
-          {AI05-0266-1AI05-0266-1} It is our intent to follow the
+          Discussion: {<AI95-00285-01AI95-00285-01>}
+          {<AI05-0266-1AI05-0266-1>} It is our intent to follow the
           terminology of ISO/IEC 10646:2011 where appropriate, and to
           remain compatible with the character classifications defined
           in *note A.3::, "*note A.3:: Character Handling".
 
                                _Syntax_
 
-     Paragraphs 2 and 3 were deleted.
+     <Paragraphs 2 and 3 were deleted.>
 
 3.1/3
-     {AI95-00285-01AI95-00285-01} {AI95-00395-01AI95-00395-01}
-     {AI05-0266-1AI05-0266-1} A character is defined by this
+     {<AI95-00285-01AI95-00285-01>} {<AI95-00395-01AI95-00395-01>}
+     {<AI05-0266-1AI05-0266-1>} A character is defined by this
      International Standard for each cell in the coding space described
      by ISO/IEC 10646:2011, regardless of whether or not ISO/IEC
      10646:2011 allocates a character to that cell.
@@ -3412,9 +3411,9 @@ space is organized in planes, each plane comprising 65536 
characters.
                           _Static Semantics_
 
 4/3
-{AI95-00285-01AI95-00285-01} {AI95-00395-01AI95-00395-01}
-{AI05-0079-1AI05-0079-1} {AI05-0262-1AI05-0262-1}
-{AI05-0266-1AI05-0266-1} The coded representation for characters is
+{<AI95-00285-01AI95-00285-01>} {<AI95-00395-01AI95-00395-01>}
+{<AI05-0079-1AI05-0079-1>} {<AI05-0262-1AI05-0262-1>}
+{<AI05-0266-1AI05-0266-1>} The coded representation for characters is
 implementation defined [(it need not be a representation defined within
 ISO/IEC 10646:2011)].  A character whose relative code point in its
 plane is 16#FFFE# or 16#FFFF# is not allowed anywhere in the text of a
@@ -3426,16 +3425,16 @@ categories other_format, format_effector, and 
graphic_character.
           of an Ada program.
 
 4.b/2
-          Ramification: {AI95-00285-01AI95-00285-01} Note that this rule
-          doesn't really have much force, since the implementation can
-          represent characters in the source in any way it sees fit.
+          Ramification: {<AI95-00285-01AI95-00285-01>} Note that this
+          rule doesn't really have much force, since the implementation
+          can represent characters in the source in any way it sees fit.
           For example, an implementation could simply define that what
           seems to be an other_private_use character is actually a
           representation of the space character.
 
 4.1/3
-{AI95-00285-01AI95-00285-01} {AI05-0266-1AI05-0266-1}
-{AI05-0299-1AI05-0299-1} The semantics of an Ada program whose text is
+{<AI95-00285-01AI95-00285-01>} {<AI05-0266-1AI05-0266-1>}
+{<AI05-0299-1AI05-0299-1>} The semantics of an Ada program whose text is
 not in Normalization Form KC (as defined by Clause 21 of ISO/IEC
 10646:2011) is implementation defined.
 
@@ -3444,114 +3443,116 @@ not in Normalization Form KC (as defined by Clause 21 
of ISO/IEC
           text is not in Normalization Form KC.
 
 5/3
-{AI95-00285-01AI95-00285-01} {AI05-0266-1AI05-0266-1}
-{AI05-0299-1AI05-0299-1} The description of the language definition in
+{<AI95-00285-01AI95-00285-01>} {<AI05-0266-1AI05-0266-1>}
+{<AI05-0299-1AI05-0299-1>} The description of the language definition in
 this International Standard uses the character properties General
 Category, Simple Uppercase Mapping, Uppercase Mapping, and Special Case
 Condition of the documents referenced by the note in Clause 1 of ISO/IEC
 10646:2011.  The actual set of graphic symbols used by an implementation
 for the visual representation of the text of an Ada program is not
-specified. 
+specified.  
 
 6/3
-{AI95-00285-01AI95-00285-01} {AI05-0266-1AI05-0266-1} Characters are
+{<AI95-00285-01AI95-00285-01>} {<AI05-0266-1AI05-0266-1>} Characters are
 categorized as follows:
 
 6.a/3
-          Discussion: {AI05-0005-1AI05-0005-1} {AI05-0262-1AI05-0262-1}
-          {AI05-0266-1AI05-0266-1} Our character classification
-          considers that the cells not allocated in ISO/IEC 10646:2011
-          are graphic characters, except for those whose relative code
-          point in their plane is 16#FFFE# or 16#FFFF#.  This seems to
-          provide the best compatibility with future versions of ISO/IEC
-          10646, as future characters can already be used in Ada
-          character and string literals.
+          Discussion: {<AI05-0005-1AI05-0005-1>}
+          {<AI05-0262-1AI05-0262-1>} {<AI05-0266-1AI05-0266-1>} Our
+          character classification considers that the cells not
+          allocated in ISO/IEC 10646:2011 are graphic characters, except
+          for those whose relative code point in their plane is 16#FFFE#
+          or 16#FFFF#.  This seems to provide the best compatibility
+          with future versions of ISO/IEC 10646, as future characters
+          can already be used in Ada character and string literals.
 
 7/2
 
-               This paragraph was deleted.{AI95-00285-01AI95-00285-01}
+               <This paragraph was
+               deleted.>{<AI95-00285-01AI95-00285-01>}
 
 8/2
-{AI95-00285-01AI95-00285-01} letter_uppercase
+{<AI95-00285-01AI95-00285-01>} letter_uppercase
                Any character whose General Category is defined to be
                "Letter, Uppercase".
 
 9/2
-{AI95-00285-01AI95-00285-01} letter_lowercase
+{<AI95-00285-01AI95-00285-01>} letter_lowercase
                Any character whose General Category is defined to be
                "Letter, Lowercase".
 
 9.a/1
-          This paragraph was deleted.{8652/00018652/0001}
-          {AI95-00124-01AI95-00124-01}
+          <This paragraph was deleted.>{<8652/00018652/0001>}
+          {<AI95-00124-01AI95-00124-01>}
 
 9.1/2
-{AI95-00285-01AI95-00285-01} letter_titlecase
+{<AI95-00285-01AI95-00285-01>} letter_titlecase
                Any character whose General Category is defined to be
                "Letter, Titlecase".
 
 9.2/2
-{AI95-00285-01AI95-00285-01} letter_modifier
+{<AI95-00285-01AI95-00285-01>} letter_modifier
                Any character whose General Category is defined to be
                "Letter, Modifier".
 
 9.3/2
-{AI95-00285-01AI95-00285-01} letter_other
+{<AI95-00285-01AI95-00285-01>} letter_other
                Any character whose General Category is defined to be
                "Letter, Other".
 
 9.4/2
-{AI95-00285-01AI95-00285-01} mark_non_spacing
+{<AI95-00285-01AI95-00285-01>} mark_non_spacing
                Any character whose General Category is defined to be
                "Mark, Non-Spacing".
 
 9.5/2
-{AI95-00285-01AI95-00285-01} mark_spacing_combining
+{<AI95-00285-01AI95-00285-01>} mark_spacing_combining
                Any character whose General Category is defined to be
                "Mark, Spacing Combining".
 
 10/2
-{AI95-00285-01AI95-00285-01} number_decimal
+{<AI95-00285-01AI95-00285-01>} number_decimal
                Any character whose General Category is defined to be
                "Number, Decimal".
 
 10.1/2
-{AI95-00285-01AI95-00285-01} number_letter
+{<AI95-00285-01AI95-00285-01>} number_letter
                Any character whose General Category is defined to be
                "Number, Letter".
 
 10.2/2
-{AI95-00285-01AI95-00285-01} punctuation_connector
+{<AI95-00285-01AI95-00285-01>} punctuation_connector
                Any character whose General Category is defined to be
                "Punctuation, Connector".
 
 10.3/2
-{AI95-00285-01AI95-00285-01} other_format
+{<AI95-00285-01AI95-00285-01>} other_format
                Any character whose General Category is defined to be
                "Other, Format".
 
 11/2
-{AI95-00285-01AI95-00285-01} separator_space
+{<AI95-00285-01AI95-00285-01>} separator_space
                Any character whose General Category is defined to be
                "Separator, Space".
 
 12/2
-{AI95-00285-01AI95-00285-01} separator_line
+{<AI95-00285-01AI95-00285-01>} separator_line
                Any character whose General Category is defined to be
                "Separator, Line".
 
 12.1/2
-{AI95-00285-01AI95-00285-01} separator_paragraph
+{<AI95-00285-01AI95-00285-01>} separator_paragraph
                Any character whose General Category is defined to be
                "Separator, Paragraph".
 
 13/3
-{AI95-00285-01AI95-00285-01} {AI05-0262-1AI05-0262-1} format_effector
+{<AI95-00285-01AI95-00285-01>} {<AI05-0262-1AI05-0262-1>}
+format_effector
                The characters whose code points are 16#09# (CHARACTER
                TABULATION), 16#0A# (LINE FEED), 16#0B# (LINE
                TABULATION), 16#0C# (FORM FEED), 16#0D# (CARRIAGE
                RETURN), 16#85# (NEXT LINE), and the characters in
-               categories separator_line and separator_paragraph. 
+               categories separator_line and separator_paragraph.  
 
 13.a/2
           Discussion: ISO/IEC 10646:2003 does not define the names of
@@ -3559,42 +3560,42 @@ categorized as follows:
           ISO/IEC 6429:1992.  These are the names that we use here.
 
 13.1/2
-{AI95-00285-01AI95-00285-01} other_control
+{<AI95-00285-01AI95-00285-01>} other_control
                Any character whose General Category is defined to be
                "Other, Control", and which is not defined to be a
                format_effector.
 
 13.2/2
-{AI95-00285-01AI95-00285-01} other_private_use
+{<AI95-00285-01AI95-00285-01>} other_private_use
                Any character whose General Category is defined to be
                "Other, Private Use".
 
 13.3/2
-{AI95-00285-01AI95-00285-01} other_surrogate
+{<AI95-00285-01AI95-00285-01>} other_surrogate
                Any character whose General Category is defined to be
                "Other, Surrogate".
 
 14/3
-{AI95-00285-01AI95-00285-01} {AI95-00395-01AI95-00395-01}
-{AI05-0262-1AI05-0262-1} graphic_character
+{<AI95-00285-01AI95-00285-01>} {<AI95-00395-01AI95-00395-01>}
+{<AI05-0262-1AI05-0262-1>} graphic_character
                Any character that is not in the categories
                other_control, other_private_use, other_surrogate,
                format_effector, and whose relative code point in its
                plane is neither 16#FFFE# nor 16#FFFF#.
 
 14.a/2
-          This paragraph was deleted.
+          <This paragraph was deleted.>
 
 14.b/2
-          Discussion: {AI95-00285-01AI95-00285-01} 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
-          [January 2005]).
+          Discussion: {<AI95-00285-01AI95-00285-01>} 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 [January 2005]).
 
 14.c/2
           More precisely, we intend to align strictly with ISO/IEC
@@ -3602,8 +3603,8 @@ categorized as follows:
           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:
+          one <must> make a choice because there are important
+          differences between the two:
 
 14.d/2
              * ISO/IEC TR 10176 is still based on ISO/IEC 10646:2000
@@ -3648,13 +3649,13 @@ categorized as follows:
           Unicode.
 
 15/3
-{AI95-00285-01AI95-00285-01} {AI05-0266-1AI05-0266-1} The following
+{<AI95-00285-01AI95-00285-01>} {<AI05-0266-1AI05-0266-1>} The following
 names are used when referring to certain characters (the first name is
 that given in ISO/IEC 10646:2011): 
 
 15.a/3
-          Discussion: {AI95-00285-01AI95-00285-01}
-          {AI05-0266-1AI05-0266-1} This table serves to show the
+          Discussion: {<AI95-00285-01AI95-00285-01>}
+          {<AI05-0266-1AI05-0266-1>} This table serves to show the
           correspondence between ISO/IEC 10646:2011 names and the
           graphic symbols (glyphs) used in this International Standard.
           These are the characters that play a special role in the
@@ -3676,7 +3677,7 @@ that given in ISO/IEC 10646:2011):
                      _Implementation Requirements_
 
 16/3
-{AI05-0286-1AI05-0286-1} An Ada implementation shall accept Ada source
+{<AI05-0286-1AI05-0286-1>} An Ada implementation shall accept Ada source
 code in UTF-8 encoding, with or without a BOM (see *note A.4.11::),
 where every character is represented by its code point.  The character
 pair CARRIAGE RETURN/LINE FEED (code points 16#0D# 16#0A#) signifies a
@@ -3685,8 +3686,8 @@ format_effector other than the character whose code point 
position is
 16#09# (CHARACTER TABULATION) also signifies a single end of line.
 
 16.a/3
-          Reason: {AI05-0079-1AI05-0079-1} {AI05-0286-1AI05-0286-1} This
-          is simply requiring that an Ada implementation be able to
+          Reason: {<AI05-0079-1AI05-0079-1>} {<AI05-0286-1AI05-0286-1>}
+          This is simply requiring that an Ada implementation be able to
           directly process the ACATS, which is provided in the described
           format.  Note that files that only contain characters with
           code points in the first 128 (which is the majority of the
@@ -3716,7 +3717,7 @@ format_effector other than the character whose code point 
position is
                      _Implementation Permissions_
 
 17/3
-{AI95-00285-01AI95-00285-01} {AI05-0266-1AI05-0266-1} The categories
+{<AI95-00285-01AI95-00285-01>} {<AI05-0266-1AI05-0266-1>} The categories
 defined above, as well as case mapping and folding, may be based on an
 implementation-defined version of ISO/IEC 10646 (2003 edition or later).
 
@@ -3737,12 +3738,12 @@ implementation-defined version of ISO/IEC 10646 (2003 
edition or later).
      NOTES
 
 18/2
-     1  {AI95-00285-01AI95-00285-01} The characters in categories
+     1  {<AI95-00285-01AI95-00285-01>} The characters in categories
      other_control, other_private_use, and other_surrogate are only
      allowed in comments.
 
 19.a/3
-          This paragraph was deleted.{AI05-0286-1AI05-0286-1}
+          <This paragraph was deleted.>{<AI05-0286-1AI05-0286-1>}
 
                         _Extensions to Ada 83_
 
@@ -3753,7 +3754,7 @@ implementation-defined version of ISO/IEC 10646 (2003 
edition or later).
                      _Wording Changes from Ada 83_
 
 19.c/3
-          {AI95-00285-01AI95-00285-01} {AI05-0299-1AI05-0299-1} The
+          {<AI95-00285-01AI95-00285-01>} {<AI05-0299-1AI05-0299-1>} The
           syntax rules in this subclause are modified to remove the
           emphasis on basic characters vs.  others.  (In this day and
           age, there is no need to point out that you can write programs
@@ -3770,16 +3771,16 @@ implementation-defined version of ISO/IEC 10646 (2003 
edition or later).
           letters without diacritical marks.
 
 19.d/2
-          {AI95-00285-01AI95-00285-01} Character names now come from
+          {<AI95-00285-01AI95-00285-01>} Character names now come from
           ISO/IEC 10646:2003.
 
 19.e/2
-          This paragraph was deleted.{AI95-00285-01AI95-00285-01}
+          <This paragraph was deleted.>{<AI95-00285-01AI95-00285-01>}
 
                         _Extensions to Ada 95_
 
 19.f/2
-          {AI95-00285-01AI95-00285-01} {AI95-00395-01AI95-00395-01}
+          {<AI95-00285-01AI95-00285-01>} {<AI95-00395-01AI95-00395-01>}
           Program text can use most characters defined by
           ISO-10646:2003.  This subclause has been rewritten to use the
           categories defined in that Standard.  This should ease
@@ -3788,7 +3789,7 @@ implementation-defined version of ISO/IEC 10646 (2003 
edition or later).
                     _Inconsistencies With Ada 2005_
 
 19.g/3
-          {AI05-0299-1AI05-0299-1} {AI05-0266-1AI05-0266-1} An
+          {<AI05-0299-1AI05-0299-1>} {<AI05-0266-1AI05-0266-1>} An
           implementation is allowed (but not required) to use a newer
           character set standard to determine the categories, case
           mapping, and case folding.  Doing so will change the results
@@ -3806,13 +3807,13 @@ implementation-defined version of ISO/IEC 10646 (2003 
edition or later).
                     _Wording Changes from Ada 2005_
 
 19.h/3
-          {AI05-0079-1AI05-0079-1} Correction: Clarified that only
+          {<AI05-0079-1AI05-0079-1>} Correction: Clarified that only
           characters in the categories defined here are allowed in the
           source of an Ada program.  This was clear in Ada 95, but
           Amendment 1 dropped the wording instead of correcting it.
 
 19.i/3
-          {AI05-0286-1AI05-0286-1} A standard source representation is
+          {<AI05-0286-1AI05-0286-1>} A standard source representation is
           defined that all compilers are expected to process.  Since
           this is the same format as the ACATS, it seems unlikely that
           there are any implementations that don't meet this
@@ -3831,17 +3832,17 @@ File: aarm2012.info,  Node: 2.2,  Next: 2.3,  Prev: 
2.1,  Up: 2
 
 1
 The text of a program consists of the texts of one or more compilations.
-The text of each compilation is a sequence of separate lexical elements.
-Each lexical element is formed from a sequence of characters, and is
-either a delimiter, an identifier, a reserved word, a numeric_literal, a
-character_literal, a string_literal, or a comment.  The meaning of a
-program depends only on the particular sequences of lexical elements
-that form its compilations, excluding comments.
+The text of each compilation is a sequence of separate <lexical
+elements>.  Each lexical element is formed from a sequence of
+characters, and is either a delimiter, an identifier, a reserved word, a
+numeric_literal, a character_literal, a string_literal, or a comment.
+The meaning of a program depends only on the particular sequences of
+lexical elements that form its compilations, excluding comments.
 
 2/3
-{AI95-00285-01AI95-00285-01} {AI05-0262-1AI05-0262-1} The text of a
-compilation is divided into lines. In general, the representation for an
-end of line is implementation defined.  However, a sequence of one or
+{<AI95-00285-01AI95-00285-01>} {<AI05-0262-1AI05-0262-1>} The text of a
+compilation is divided into <lines>.  In general, the representation for
+an end of line is implementation defined.  However, a sequence of one or
 more format_effectors other than the character whose code point is
 16#09# (CHARACTER TABULATION) signifies at least one end of line.
 
@@ -3849,18 +3850,18 @@ more format_effectors other than the character whose 
code point is
           Implementation defined: The representation for an end of line.
 
 3/2
-{AI95-00285-01AI95-00285-01} [In some cases an explicit separator is
+{<AI95-00285-01AI95-00285-01>} [In some cases an explicit <separator> is
 required to separate adjacent lexical elements.]  A separator is any of
 a separator_space, a format_effector, or the end of a line, as follows:
 
 4/2
-   * {AI95-00285-01AI95-00285-01} A separator_space is a separator
+   * {<AI95-00285-01AI95-00285-01>} A separator_space is a separator
      except within a comment, a string_literal, or a character_literal.
 
 5/3
-   * {AI95-00285-01AI95-00285-01} {AI05-0262-1AI05-0262-1} The character
-     whose code point is 16#09# (CHARACTER TABULATION) is a separator
-     except within a comment.
+   * {<AI95-00285-01AI95-00285-01>} {<AI05-0262-1AI05-0262-1>} The
+     character whose code point is 16#09# (CHARACTER TABULATION) is a
+     separator except within a comment.
 
 6
    * The end of a line is always a separator.
@@ -3873,19 +3874,19 @@ or a numeric_literal and an adjacent identifier, 
reserved word, or
 numeric_literal.
 
 7.1/3
-{AI05-0079-1AI05-0079-1} One or more other_format characters are allowed
-anywhere that a separator is[; any such characters have no effect on the
-meaning of an Ada program].
+{<AI05-0079-1AI05-0079-1>} One or more other_format characters are
+allowed anywhere that a separator is[; any such characters have no
+effect on the meaning of an Ada program].
 
 8/2
-{AI95-00285-01AI95-00285-01} A delimiter is either one of the following
-characters:
+{<AI95-00285-01AI95-00285-01>} A <delimiter> is either one of the
+following characters:
 
 9
      &    '    (    )    *    +    ,    -    .    /    :    ;    <    =    >   
 |
 
 10
-or one of the following compound delimiters each composed of two
+or one of the following <compound delimiters> each composed of two
 adjacent special characters
 
 11
@@ -3900,16 +3901,18 @@ character_literal, or numeric_literal.
 13
 The following names are used when referring to compound delimiters:
 
-     delimiter  name=> arrow
-.. double dot
-** double star, exponentiate
-:= assignment (pronounced: "becomes")
-/= inequality (pronounced: "not equal")
->= greater than or equal
-<= less than or equal
-<< left label bracket
->> right label bracket
-<> box
+delimiter    name
+----------------------------------------------------
+=>           arrow
+..           double dot
+**           double star, exponentiate
+:=           assignment (pronounced: "becomes")
+/=           inequality (pronounced: "not equal")
+>=           greater than or equal
+<=           less than or equal
+<<           left label bracket
+>>           right label bracket
+<>           box
                      _Implementation Requirements_
 
 14
@@ -3929,14 +3932,14 @@ element length are implementation defined.
                      _Wording Changes from Ada 95_
 
 14.c/3
-          {AI95-00285-01AI95-00285-01} {AI05-0299-1AI05-0299-1} The
+          {<AI95-00285-01AI95-00285-01>} {<AI05-0299-1AI05-0299-1>} The
           wording was updated to use the new character categories
           defined in the preceding subclause.
 
                        _Extensions to Ada 2005_
 
 14.d/3
-          {AI05-0079-1AI05-0079-1} Correction: Clarified that
+          {<AI05-0079-1AI05-0079-1>} Correction: Clarified that
           other_format characters are allowed anywhere that separators
           are allowed.  This was intended in Ada 2005, but didn't
           actually make it into the wording.
@@ -3953,12 +3956,12 @@ Identifiers are used as names.
                                _Syntax_
 
 2/2
-     {AI95-00285-01AI95-00285-01} {AI95-00395-01AI95-00395-01}
+     {<AI95-00285-01AI95-00285-01>} {<AI95-00395-01AI95-00395-01>}
      identifier ::=
         identifier_start {identifier_start | identifier_extend}
 
 3/2
-     {AI95-00285-01AI95-00285-01} {AI95-00395-01AI95-00395-01}
+     {<AI95-00285-01AI95-00285-01>} {<AI95-00395-01AI95-00395-01>}
      identifier_start ::=
           letter_uppercase
         | letter_lowercase
@@ -3968,16 +3971,16 @@ Identifiers are used as names.
         | number_letter
 
 3.1/3
-     {AI95-00285-01AI95-00285-01} {AI95-00395-01AI95-00395-01}
-     {AI05-0091-1AI05-0091-1} identifier_extend ::=
+     {<AI95-00285-01AI95-00285-01>} {<AI95-00395-01AI95-00395-01>}
+     {<AI05-0091-1AI05-0091-1>} identifier_extend ::=
           mark_non_spacing
         | mark_spacing_combining
         | number_decimal
         | punctuation_connector
 
 4/3
-     {AI95-00395-01AI95-00395-01} {AI05-0091-1AI05-0091-1} An identifier
-     shall not contain two consecutive characters in category
+     {<AI95-00395-01AI95-00395-01>} {<AI05-0091-1AI05-0091-1>} An
+     identifier shall not contain two consecutive characters in category
      punctuation_connector, or end with a character in that category.
 
 4.a/3
@@ -3987,29 +3990,29 @@ Identifiers are used as names.
                           _Static Semantics_
 
 5/3
-{AI95-00285-01AI95-00285-01} {AI05-0091-1AI05-0091-1}
-{AI05-0227-1AI05-0227-1} {AI05-0266-1AI05-0266-1}
-{AI05-0299-1AI05-0299-1} Two identifiers are considered the same if they
-consist of the same sequence of characters after applying
+{<AI95-00285-01AI95-00285-01>} {<AI05-0091-1AI05-0091-1>}
+{<AI05-0227-1AI05-0227-1>} {<AI05-0266-1AI05-0266-1>}
+{<AI05-0299-1AI05-0299-1>} Two identifiers are considered the same if
+they consist of the same sequence of characters after applying
 locale-independent simple case folding, as defined by documents
 referenced in the note in Clause 1 of ISO/IEC 10646:2011.
 
 5.a/3
-          Discussion: {AI05-0227-1AI05-0227-1} Simple case folding is a
-          mapping to lower case, so this is matching the defining (lower
-          case) version of a reserved word.  We could have mentioned
-          case folding of the reserved words, but as that is an identity
-          function, it would have no effect.
+          Discussion: {<AI05-0227-1AI05-0227-1>} Simple case folding is
+          a mapping to lower case, so this is matching the defining
+          (lower case) version of a reserved word.  We could have
+          mentioned case folding of the reserved words, but as that is
+          an identity function, it would have no effect.
 
 5.a.1/3
-          {AI05-0227-1AI05-0227-1} The "documents referenced" means
+          {<AI05-0227-1AI05-0227-1>} The "documents referenced" means
           Unicode.  Note that simple case folding is supposed to be
           compatible between Unicode versions, so the Unicode version
           used doesn't matter.
 
 5.3/3
-{AI95-00395-01AI95-00395-01} {AI05-0091-1AI05-0091-1}
-{AI05-0227-1AI05-0227-1} After applying simple case folding, an
+{<AI95-00395-01AI95-00395-01>} {<AI05-0091-1AI05-0091-1>}
+{<AI05-0227-1AI05-0227-1>} After applying simple case folding, an
 identifier shall not be identical to a reserved word.
 
 5.b/3
@@ -4021,19 +4024,19 @@ identifier shall not be identical to a reserved word.
           headaches.
 
 5.c/3
-          Ramification: {AI05-0227-1AI05-0227-1} The rules for reserved
-          words differ in one way: they define case conversion on
-          letters rather than sequences.  This means that it is possible
-          that there exist some unusual sequences that are neither
-          identifiers nor reserved words.  We are not aware of any such
-          sequences so long as we use simple case folding (as opposed to
-          full case folding), but we have defined the rules in case any
-          are introduced in future character set standards.  This
-          originally was a problem when converting to upper case: "if"
-          and "acce�" have upper case conversions of "IF" and "ACCESS"
-          respectively.  We would not want these to be treated as
-          reserved words.  But neither of these cases exist when using
-          simple case folding.
+          Ramification: {<AI05-0227-1AI05-0227-1>} The rules for
+          reserved words differ in one way: they define case conversion
+          on letters rather than sequences.  This means that it is
+          possible that there exist some unusual sequences that are
+          neither identifiers nor reserved words.  We are not aware of
+          any such sequences so long as we use simple case folding (as
+          opposed to full case folding), but we have defined the rules
+          in case any are introduced in future character set standards.
+          This originally was a problem when converting to upper case:
+          "if" and "acce�" have upper case conversions of "IF" and
+          "ACCESS" respectively.  We would not want these to be treated
+          as reserved words.  But neither of these cases exist when
+          using simple case folding.
 
                      _Implementation Permissions_
 
@@ -4043,21 +4046,21 @@ case equivalence rules for identifiers[, to accommodate 
local
 conventions].
 
 6.a/3
-          Discussion: {AI95-00285-01AI95-00285-01}
-          {AI05-0227-1AI05-0227-1} For instance, in most languages, the
-          simple case folded equivalent of LATIN CAPITAL LETTER I (an
-          upper case letter without a dot above) is LATIN SMALL LETTER I
-          (a lower case letter with a dot above).  In Turkish, though,
-          LATIN CAPITAL LETTER I and LATIN CAPITAL LETTER I WITH DOT
-          ABOVE are two distinct letters, so the case folded equivalent
-          of LATIN CAPITAL LETTER I is LATIN SMALL LETTER DOTLESS I, and
-          the case folded equivalent of LATIN CAPITAL LETTER I WITH DOT
-          ABOVE is LATIN SMALL LETTER I. Take for instance the following
-          identifier (which is the name of a city on the Tigris river in
-          Eastern Anatolia):
+          Discussion: {<AI95-00285-01AI95-00285-01>}
+          {<AI05-0227-1AI05-0227-1>} For instance, in most languages,
+          the simple case folded equivalent of LATIN CAPITAL LETTER I
+          (an upper case letter without a dot above) is LATIN SMALL
+          LETTER I (a lower case letter with a dot above).  In Turkish,
+          though, LATIN CAPITAL LETTER I and LATIN CAPITAL LETTER I WITH
+          DOT ABOVE are two distinct letters, so the case folded
+          equivalent of LATIN CAPITAL LETTER I is LATIN SMALL LETTER
+          DOTLESS I, and the case folded equivalent of LATIN CAPITAL
+          LETTER I WITH DOT ABOVE is LATIN SMALL LETTER I. Take for
+          instance the following identifier (which is the name of a city
+          on the Tigris river in Eastern Anatolia):
 
 6.b/3
-               DIYARBAKIR -- The first i is dotted, the second isn't.
+               DIYARBAKIR -- <The first i is dotted, the second isn't.>
 
 6.c/3
           A Turkish reader would expect that the above identifier is
@@ -4099,21 +4102,21 @@ conventions].
      NOTES
 
 6.1/2
-     2  {AI95-00285-01AI95-00285-01} Identifiers differing only in the
+     2  {<AI95-00285-01AI95-00285-01>} Identifiers differing only in the
      use of corresponding upper and lower case letters are considered
      the same.
 
                               _Examples_
 
 7
-Examples of identifiers:
+<Examples of identifiers:>
 
 8/2
-     {AI95-00433-01AI95-00433-01} Count      X    Get_Symbol   Ethelyn   Marion
+     {<AI95-00433-01AI95-00433-01>} Count      X    Get_Symbol   Ethelyn   
Marion
      Snobol_4   X1   Page_Count   Store_Next_Item
-     [Unicode 928][Unicode 955][Unicode 940][Unicode 964][Unicode 969][Unicode 
957]      -- Plato
-     [Unicode 1063][Unicode 1072][Unicode 1081][Unicode 1082][Unicode 
1086][Unicode 1074][Unicode 1089][Unicode 1082][Unicode 1080][Unicode 1081]  -- 
Tchaikovsky
-     [Unicode 952]  [Unicode 966]        -- Angles
+     [Unicode 928][Unicode 955][Unicode 940][Unicode 964][Unicode 969][Unicode 
957]      --< Plato>
+     [Unicode 1063][Unicode 1072][Unicode 1081][Unicode 1082][Unicode 
1086][Unicode 1074][Unicode 1089][Unicode 1082][Unicode 1080][Unicode 1081]  
--< Tchaikovsky>
+     [Unicode 952]  [Unicode 966]        --< Angles>
 
                      _Wording Changes from Ada 83_
 
@@ -4135,22 +4138,22 @@ Examples of identifiers:
                         _Extensions to Ada 95_
 
 8.c/2
-          {AI95-00285-01AI95-00285-01} An identifier can use any letter
-          defined by ISO-10646:2003, along with several other
+          {<AI95-00285-01AI95-00285-01>} An identifier can use any
+          letter defined by ISO-10646:2003, along with several other
           categories.  This should ease programming in languages other
           than English.
 
                    _Incompatibilities With Ada 2005_
 
 8.d/3
-          {AI05-0091-1AI05-0091-1} Correction: other_format characters
+          {<AI05-0091-1AI05-0091-1>} Correction: other_format characters
           were removed from identifiers as the Unicode recommendations
           have changed.  This change can only affect programs written
           for the original Ada 2005, so there should be few such
           programs.
 
 8.e/3
-          {AI05-0227-1AI05-0227-1} Correction: We now specify simple
+          {<AI05-0227-1AI05-0227-1>} Correction: We now specify simple
           case folding rather than full case folding.  That potentially
           could change identifier equivalence, although it is more
           likely that identifiers that are considered the same in
@@ -4168,9 +4171,9 @@ File: aarm2012.info,  Node: 2.4,  Next: 2.5,  Prev: 2.3,  
Up: 2
 ====================
 
 1
-There are two kinds of numeric_literals, real literals and integer
-literals. A real literal is a numeric_literal that includes a point; an
-integer literal is a numeric_literal without a point.
+There are two kinds of numeric_literals, <real literals> and <integer
+literals>.  A real literal is a numeric_literal that includes a point;
+an integer literal is a numeric_literal without a point.
 
                                _Syntax_
 
@@ -4180,8 +4183,8 @@ integer literal is a numeric_literal without a point.
      NOTES
 
 3
-     3  The type of an integer literal is universal_integer.  The type
-     of a real literal is universal_real.
+     3  The type of an integer literal is <universal_integer>.  The type
+     of a real literal is <universal_real>.
 
 * Menu:
 
@@ -4210,7 +4213,7 @@ notation (that is, the base is ten).
      exponent ::= E [+] numeral | E - numeral
 
 4.1/2
-     {AI95-00285-01AI95-00285-01} digit ::=
+     {<AI95-00285-01AI95-00285-01>} digit ::=
      0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9
 
 5
@@ -4239,12 +4242,12 @@ value of the decimal_literal with the exponent.
                               _Examples_
 
 8
-Examples of decimal literals:
+<Examples of decimal literals:>
 
 9
-     12        0      1E6    123_456    --  integer literals
+     12        0      1E6    123_456    --<  integer literals>
 
-     12.0      0.0    0.456  3.14159_26 --  real literals
+     12.0      0.0    0.456  3.14159_26 --<  real literals>
 
                      _Wording Changes from Ada 83_
 
@@ -4284,7 +4287,7 @@ specifies the base explicitly.]
                            _Legality Rules_
 
 6
-The base (the numeric value of the decimal numeral preceding the first
+The <base> (the numeric value of the decimal numeral preceding the first
 #) shall be at least two and at most sixteen.  The extended_digits A
 through F represent the digits ten through fifteen, respectively.  The
 value of each extended_digit of a based_literal shall be less than the
@@ -4306,12 +4309,12 @@ in upper case, with the same meaning.
                               _Examples_
 
 9
-Examples of based literals:
+<Examples of based literals:>
 
 10
-     2#1111_1111#  16#FF#       016#0ff#   --  integer literals of value 255
-     16#E#E1       2#1110_0000#            --  integer literals of value 224
-     16#F.FF#E+2   2#1.1111_1111_1110#E11  --  real literals of value 4095.0
+     2#1111_1111#  16#FF#       016#0ff#   --<  integer literals of value 255>
+     16#E#E1       2#1110_0000#            --<  integer literals of value 224>
+     16#F.FF#E+2   2#1.1111_1111_1110#E11  --<  real literals of value 4095.0>
 
                      _Wording Changes from Ada 83_
 
@@ -4344,17 +4347,17 @@ two apostrophe characters.]
                               _Examples_
 
 4
-Examples of character literals:
+<Examples of character literals:>
 
 5/2
-     {AI95-00433-01AI95-00433-01} 'A'     '*'     '''     ' '
-     'L'     '[Unicode 1051]'     '[Unicode 923]'    -- Various els.
-     '[Unicode 8734]'     '[Unicode 1488]'            -- Big numbers - 
infinity and aleph.
+     {<AI95-00433-01AI95-00433-01>} 'A'     '*'     '''     ' '
+     'L'     '[Unicode 1051]'     '[Unicode 923]'    --< Various els.>
+     '[Unicode 8734]'     '[Unicode 1488]'            --< Big numbers - 
infinity and aleph.>
 
                      _Wording Changes from Ada 83_
 
 5.a/3
-          {AI05-0299-1AI05-0299-1} The definitions of the values of
+          {<AI05-0299-1AI05-0299-1>} The definitions of the values of
           literals are in Clauses 3 and 4, rather than here, since it
           requires knowledge of types.
 
@@ -4369,7 +4372,7 @@ File: aarm2012.info,  Node: 2.6,  Next: 2.7,  Prev: 2.5,  
Up: 2
 (possibly none) enclosed between two quotation marks used as string
 brackets.  They are used to represent operator_symbols (see *note
 6.1::), values of a string type (see *note 4.2::), and array
-subaggregates (see *note 4.3.3::). ]
+subaggregates (see *note 4.3.3::).  ]
 
                                _Syntax_
 
@@ -4377,7 +4380,7 @@ subaggregates (see *note 4.3.3::). ]
      string_literal ::= "{string_element}"
 
 3
-     string_element ::= "" | non_quotation_mark_graphic_character
+     string_element ::= "" | <non_quotation_mark_>graphic_character
 
 4
      A string_element is either a pair of quotation marks (""), or a
@@ -4386,14 +4389,14 @@ subaggregates (see *note 4.3.3::). ]
                           _Static Semantics_
 
 5
-The sequence of characters of a string_literal is formed from the
+The <sequence of characters> of a string_literal is formed from the
 sequence of string_elements between the bracketing quotation marks, in
 the given order, with a string_element that is "" becoming a single
 quotation mark in the sequence of characters, and any other
 string_element being reproduced in the sequence.
 
 6
-A null string literal is a string_literal with no string_elements
+A <null string literal> is a string_literal with no string_elements
 between the quotation marks.
 
      NOTES
@@ -4402,19 +4405,19 @@ between the quotation marks.
      5  An end of line cannot appear in a string_literal.
 
 7.1/2
-     6  {AI95-00285-01AI95-00285-01} No transformation is performed on
+     6  {<AI95-00285-01AI95-00285-01>} No transformation is performed on
      the sequence of characters of a string_literal.
 
                               _Examples_
 
 8
-Examples of string literals:
+<Examples of string literals:>
 
 9/2
-     {AI95-00433-01AI95-00433-01} "Message of the day:"
+     {<AI95-00433-01AI95-00433-01>} "Message of the day:"
 
-     ""                    --  a null string literal
-     " "   "A"   """"      --  three string literals of length 1
+     ""                    --<  a null string literal>
+     " "   "A"   """"      --<  three string literals of length 1>
 
      "Characters such as $, %, and } are allowed in string literals"
      "Archimedes said ""[Unicode 917][Unicode 973][Unicode 961][Unicode 
951][Unicode 954][Unicode 945]"""
@@ -4434,7 +4437,7 @@ Examples of string literals:
                      _Wording Changes from Ada 95_
 
 9.c/2
-          {AI95-00285-01AI95-00285-01} We explicitly say that the
+          {<AI95-00285-01AI95-00285-01>} We explicitly say that the
           characters of a string_literal should be used as is.  In
           particular, no normalization or folding should be performed on
           a string_literal.
@@ -4452,7 +4455,7 @@ the line.
                                _Syntax_
 
 2
-     comment ::= --{non_end_of_line_character}
+     comment ::= --{<non_end_of_line_>character}
 
 3
      A comment may appear on any line of a program.
@@ -4468,17 +4471,17 @@ human reader.
                               _Examples_
 
 5
-Examples of comments:
+<Examples of comments:>
 
 6
-     --  the last sentence above echoes the Algol 68 report 
+     --<  the last sentence above echoes the Algol 68 report >
 
-     end;  --  processing of Line is complete 
+     end;  --<  processing of Line is complete >
 
-     --  a long comment may be split onto
-     --  two or more consecutive lines   
+     --<  a long comment may be split onto>
+     --<  two or more consecutive lines   >
 
-     ----------------  the first two hyphens start the comment  
+     ----------------<  the first two hyphens start the comment  >
 
 
 File: aarm2012.info,  Node: 2.8,  Next: 2.9,  Prev: 2.7,  Up: 2
@@ -4494,9 +4497,9 @@ implementation may support additional 
(implementation-defined) pragmas.
                      _Language Design Principles_
 
 1.a/3
-          {AI05-0100-1AI05-0100-1} {AI05-0163-1AI05-0163-1} In general,
-          if all pragmas are treated as unrecognized pragmas, the
-          program should remain both syntactically and semantically
+          {<AI05-0100-1AI05-0100-1>} {<AI05-0163-1AI05-0163-1>} In
+          general, if all pragmas are treated as unrecognized pragmas,
+          the program should remain both syntactically and semantically
           legal.  There are a few exceptions to this general principle
           (for example, pragma Import can eliminate the need for a
           completion), but the principle remains, and is strictly true
@@ -4513,17 +4516,18 @@ implementation may support additional 
(implementation-defined) pragmas.
      pragma_argument_association})];
 
 3/3
-     {AI05-0290-1AI05-0290-1} pragma_argument_association ::=
-          [pragma_argument_identifier =>] name
-        | [pragma_argument_identifier =>] expression
-        | pragma_argument_aspect_mark =>  name
-        | pragma_argument_aspect_mark =>  expression
+     {<AI05-0290-1AI05-0290-1>} pragma_argument_association ::=
+          [<pragma_argument_>identifier =>] name
+        | [<pragma_argument_>identifier =>] expression
+        | <pragma_argument_>aspect_mark =>  name
+        | <pragma_argument_>aspect_mark =>  expression
 
 4/3
-     {AI05-0290-1AI05-0290-1} In a pragma, any
-     pragma_argument_associations without a pragma_argument_identifier
-     or pragma_argument_aspect_mark shall precede any associations with
-     a pragma_argument_identifier or pragma_argument_aspect_mark.
+     {<AI05-0290-1AI05-0290-1>} In a pragma, any
+     pragma_argument_associations without a <pragma_argument_>identifier
+     or <pragma_argument_>aspect_mark shall precede any associations
+     with a <pragma_argument_>identifier or
+     <pragma_argument_>aspect_mark.
 
 5
      Pragmas are only allowed at the following places in a program:
@@ -4533,8 +4537,8 @@ implementation may support additional 
(implementation-defined) pragmas.
           discriminant_part.
 
 7/3
-        * {AI05-0100-1AI05-0100-1} {AI05-0163-1AI05-0163-1} At any place
-          where the syntax rules allow a construct defined by a
+        * {<AI05-0100-1AI05-0100-1>} {<AI05-0163-1AI05-0163-1>} At any
+          place where the syntax rules allow a construct defined by a
           syntactic category whose name ends with "declaration", "item",
           "statement", "clause", or "alternative", or one of the
           syntactic categories variant or exception_handler; but not in
@@ -4543,12 +4547,12 @@ implementation may support additional 
(implementation-defined) pragmas.
           construct.
 
 7.1/3
-        * {AI05-0163-1AI05-0163-1} In place of a statement in a
+        * {<AI05-0163-1AI05-0163-1>} In place of a statement in a
           sequence_of_statements.
 
 7.2/3
-        * {AI05-0100-1AI05-0100-1} At any place where a compilation_unit
-          is allowed.
+        * {<AI05-0100-1AI05-0100-1>} At any place where a
+          compilation_unit is allowed.
 
 8
      Additional syntax rules and placement restrictions exist for
@@ -4564,18 +4568,18 @@ implementation may support additional 
(implementation-defined) pragmas.
           generic_formal_parameter_declaration is allowed.
 
 9
-The name of a pragma is the identifier following the reserved word
-pragma. The name or expression of a pragma_argument_association is a
-pragma argument.
+The <name> of a pragma is the identifier following the reserved word
+pragma.  The name or expression of a pragma_argument_association is a
+<pragma argument>.
 
 9.a/2
-          To be honest: {AI95-00284-02AI95-00284-02} For compatibility
+          To be honest: {<AI95-00284-02AI95-00284-02>} For compatibility
           with Ada 83, the name of a pragma may also be "interface",
           which is not an identifier (because it is a reserved word).
           See *note J.12::.
 
 10/3
-{AI05-0272-1AI05-0272-1} An identifier specific to a pragma is an
+{<AI05-0272-1AI05-0272-1>} An <identifier specific to a pragma> is an
 identifier or reserved word that is used in a pragma argument with
 special meaning for that pragma.
 
@@ -4585,7 +4589,7 @@ special meaning for that pragma.
           identifier is an identifier specific to that pragma.
 
 10.b/3
-          {AI05-0272-1AI05-0272-1} In a few cases, a reserved word is
+          {<AI05-0272-1AI05-0272-1>} In a few cases, a reserved word is
           allowed as "an identifier specific to a pragma".  Even in
           these cases, the syntax still is written as identifier (the
           reserved word(s) are not shown).  For example, the restriction
@@ -4649,7 +4653,7 @@ the only rules that apply are the Syntax Rules.
           be invoked, which is not what we want.
 
 11.i/3
-          {AI05-0229-1AI05-0229-1} This also implies that named
+          {<AI05-0229-1AI05-0229-1>} This also implies that named
           associations do not allow one to give the arguments in an
           arbitrary order -- the order given in the syntax rule for each
           individual pragma must be obeyed.  However, it is generally
@@ -4742,8 +4746,8 @@ some of the Syntax Rules, if detecting the syntax error 
is too complex.
                         _Implementation Advice_
 
 16/3
-{AI05-0163-1AI05-0163-1} Normally, implementation-defined pragmas should
-have no semantic effect for error-free programs; that is, if the
+{<AI05-0163-1AI05-0163-1>} Normally, implementation-defined pragmas
+should have no semantic effect for error-free programs; that is, if the
 implementation-defined pragmas in a working program are replaced with
 unrecognized pragmas, the program should still be legal, and should
 still have the same semantics.
@@ -4770,10 +4774,10 @@ Normally, an implementation should not define pragmas 
that can make an
 illegal program legal, except as follows:
 
 18/3
-   * {AI05-0229-1AI05-0229-1} A pragma used to complete a declaration;
+   * {<AI05-0229-1AI05-0229-1>} A pragma used to complete a declaration;
 
 18.a/3
-          Discussion: {AI05-0229-1AI05-0229-1} There are no
+          Discussion: {<AI05-0229-1AI05-0229-1>} There are no
           language-defined pragmas which can be completions; pragma
           Import was defined this way in Ada 95 and Ada 2005, but in Ada
           2012 pragma Import just sets aspect Import which disallows
@@ -4830,16 +4834,16 @@ illegal program legal, except as follows:
                        _Extensions to Ada 2005_
 
 19.f/3
-          {AI05-0163-1AI05-0163-1} Correction: Allow pragmas in place of
-          a statement, even if there are no other statements in a
+          {<AI05-0163-1AI05-0163-1>} Correction: Allow pragmas in place
+          of a statement, even if there are no other statements in a
           sequence_of_statements.
 
 19.g/3
-          {AI05-0272-1AI05-0272-1} Identifiers specific to a pragma can
-          be reserved words.
+          {<AI05-0272-1AI05-0272-1>} Identifiers specific to a pragma
+          can be reserved words.
 
 19.h/3
-          {AI05-0290-1AI05-0290-1} Pragma arguments can be identified
+          {<AI05-0290-1AI05-0290-1>} Pragma arguments can be identified
           with aspect_marks; this allows identifier'Class in this
           context.  As usual, this is only allowed if specifically
           allowed by a particular pragma.
@@ -4847,7 +4851,7 @@ illegal program legal, except as follows:
                     _Wording Changes from Ada 2005_
 
 19.i/3
-          {AI05-0100-1AI05-0100-1} Correction: Clarified where pragmas
+          {<AI05-0100-1AI05-0100-1>} Correction: Clarified where pragmas
           are (and are not) allowed.
 
                                _Syntax_
@@ -4921,14 +4925,14 @@ defined how this advice is followed.]
                               _Examples_
 
 28
-Examples of pragmas:
+<Examples of pragmas:>
 
 29/3
-     {AI95-00433-01AI95-00433-01} {AI05-0229-1AI05-0229-1} pragma List(Off); 
-- turn off listing generation
-     pragma Optimize(Off); -- turn off optional optimizations
-     pragma Pure(Rational_Numbers); -- set categorization for package
+     {<AI95-00433-01AI95-00433-01>} {<AI05-0229-1AI05-0229-1>} pragma 
List(Off); -- <turn off listing generation>
+     pragma Optimize(Off); -- <turn off optional optimizations>
+     pragma Pure(Rational_Numbers); -- <set categorization for package>
      pragma Assert(Exists(File_Name),
-                   Message => "Nonexistent file"); -- assert file exists
+                   Message => "Nonexistent file"); -- <assert file exists>
 
                         _Extensions to Ada 83_
 
@@ -4950,14 +4954,14 @@ Examples of pragmas:
                      _Wording Changes from Ada 95_
 
 29.d/2
-          {AI95-00433-01AI95-00433-01} Updated the example of named
+          {<AI95-00433-01AI95-00433-01>} Updated the example of named
           pragma parameters, because the second parameter of pragma
           Suppress is obsolescent.
 
                     _Wording Changes from Ada 2005_
 
 29.e/3
-          {AI05-0229-1AI05-0229-1} Updated the example of pragmas,
+          {<AI05-0229-1AI05-0229-1>} Updated the example of pragmas,
           because both pragmas Inline and Import are obsolescent.
 
 
@@ -4969,11 +4973,11 @@ File: aarm2012.info,  Node: 2.9,  Prev: 2.8,  Up: 2
                                _Syntax_
 
 1/1
-     This paragraph was deleted.
+     <This paragraph was deleted.>
 
 2/3
-     {AI95-00284-02AI95-00284-02} {AI95-00395-01AI95-00395-01}
-     {AI05-0091-1AI05-0091-1} The following are the reserved words.
+     {<AI95-00284-02AI95-00284-02>} {<AI95-00395-01AI95-00395-01>}
+     {<AI05-0091-1AI05-0091-1>} The following are the <reserved words>.
      Within a program, some or all of the letters of a reserved word may
      be in upper case.
 
@@ -5034,14 +5038,14 @@ do         mod         requeue
                      _Wording Changes from Ada 83_
 
 3.b/3
-          {AI05-0299-1AI05-0299-1} The subclause entitled "Allowed
+          {<AI05-0299-1AI05-0299-1>} The subclause entitled "Allowed
           Replacements of Characters" has been moved to *note Annex J::,
           "*note Annex J:: Obsolescent Features".
 
                     _Incompatibilities With Ada 95_
 
 3.c/2
-          {AI95-00284-02AI95-00284-02} The following words are not
+          {<AI95-00284-02AI95-00284-02>} The following words are not
           reserved in Ada 95, but are reserved in Ada 2005: interface,
           overriding, synchronized.  A special allowance is made for
           pragma Interface (see *note J.12::).  Uses of these words as
@@ -5051,7 +5055,7 @@ do         mod         requeue
                      _Wording Changes from Ada 95_
 
 3.d/2
-          {AI95-00395-01AI95-00395-01} The definition of upper case
+          {<AI95-00395-01AI95-00395-01>} The definition of upper case
           equivalence has been modified to allow identifiers using all
           of the characters of ISO 10646.  This change has no effect on
           the character sequences that are reserved words, but does make
@@ -5060,7 +5064,7 @@ do         mod         requeue
                    _Incompatibilities With Ada 2005_
 
 3.e/3
-          {AI05-0091-1AI05-0091-1} Correction: Removed other_format
+          {<AI05-0091-1AI05-0091-1>} Correction: Removed other_format
           characters from reserved words in order to be compatible with
           the latest Unicode recommendations.  This change can only
           affect programs written for original Ada 2005, and there is
@@ -5069,8 +5073,8 @@ do         mod         requeue
           programs.
 
 3.f/3
-          {AI05-0176-1AI05-0176-1} The following word is not reserved in
-          Ada 2005, but is reserved in Ada 2012: some.  Uses of this
+          {<AI05-0176-1AI05-0176-1>} The following word is not reserved
+          in Ada 2005, but is reserved in Ada 2012: some.  Uses of this
           word as an identifier will need to be changed, but we do not
           expect them to be common.
 
@@ -5081,8 +5085,9 @@ File: aarm2012.info,  Node: 3,  Next: 4,  Prev: 2,  Up: 
Top
 ************************
 
 1/3
-{AI05-0299-1AI05-0299-1} This clause describes the types in the language
-and the rules for declaring constants, variables, and named numbers.
+{<AI05-0299-1AI05-0299-1>} This clause describes the types in the
+language and the rules for declaring constants, variables, and named
+numbers.
 
 * Menu:
 
@@ -5105,8 +5110,8 @@ File: aarm2012.info,  Node: 3.1,  Next: 3.2,  Up: 3
 ================
 
 1
-The language defines several kinds of named entities that are declared
-by declarations. The entity's name is defined by the declaration,
+The language defines several kinds of named <entities> that are declared
+by declarations.  The entity's <name> is defined by the declaration,
 usually by a defining_identifier (*note 3.1: S0022.), but sometimes by a
 defining_character_literal (*note 3.5.1: S0040.) or
 defining_operator_symbol (*note 6.1: S0171.).
@@ -5118,7 +5123,7 @@ of declaration defined as follows.
                                _Syntax_
 
 3/3
-     {AI95-00348-01AI95-00348-01} {AI05-0177-1AI05-0177-1}
+     {<AI95-00348-01AI95-00348-01>} {<AI05-0177-1AI05-0177-1>}
      basic_declaration ::=
           type_declaration   | subtype_declaration
         | object_declaration   | number_declaration
@@ -5134,11 +5139,11 @@ of declaration defined as follows.
                           _Static Semantics_
 
 5
-A declaration is a language construct that associates a name with (a
-view of) an entity. A declaration may appear explicitly in the program
-text (an explicit declaration), or may be supposed to occur at a given
+A <declaration> is a language construct that associates a name with (a
+view of) an entity.  A declaration may appear explicitly in the program
+text (an <explicit> declaration), or may be supposed to occur at a given
 place in the text as a consequence of the semantics of another construct
-(an implicit declaration).
+(an <implicit> declaration).
 
 5.a
           Discussion: An implicit declaration generally declares a
@@ -5148,8 +5153,8 @@ place in the text as a consequence of the semantics of 
another construct
           declarations, as part of a type declaration.
 
 6/3
-{AI95-00318-02AI95-00318-02} {AI05-0255-1AI05-0255-1}
-{AI05-0277-1AI05-0277-1} Each of the following is defined to be a
+{<AI95-00318-02AI95-00318-02>} {<AI05-0255-1AI05-0255-1>}
+{<AI05-0277-1AI05-0277-1>} Each of the following is defined to be a
 declaration: any basic_declaration (*note 3.1: S0021.); an
 enumeration_literal_specification (*note 3.5.1: S0039.); a
 discriminant_specification (*note 3.7: S0062.); a component_declaration
@@ -5175,15 +5180,15 @@ S0267.); a generic_formal_parameter_declaration (*note 
12.1: S0275.).
           sometimes not.
 
 7
-All declarations contain a definition for a view of an entity.  A view
-consists of an identification of the entity (the entity of the view),
-plus view-specific characteristics that affect the use of the entity
-through that view (such as mode of access to an object, formal parameter
-names and defaults for a subprogram, or visibility to components of a
-type).  In most cases, a declaration also contains the definition for
-the entity itself (a renaming_declaration is an example of a declaration
-that does not define a new entity, but instead defines a view of an
-existing entity (see *note 8.5::)).
+All declarations contain a <definition> for a <view> of an entity.  A
+view consists of an identification of the entity (the entity <of> the
+view), plus view-specific characteristics that affect the use of the
+entity through that view (such as mode of access to an object, formal
+parameter names and defaults for a subprogram, or visibility to
+components of a type).  In most cases, a declaration also contains the
+definition for the entity itself (a renaming_declaration is an example
+of a declaration that does not define a new entity, but instead defines
+a view of an existing entity (see *note 8.5::)).
 
 7.a/2
           Glossary entry: A view of an entity reveals some or all of the
@@ -5195,16 +5200,16 @@ existing entity (see *note 8.5::)).
           whose view-specific characteristics are unchanging for the
           life of the view.  However, subtypes are somewhat unusual in
           that they inherit characteristics from whatever view of their
-          type is currently visible.  Hence, a subtype is not a view of
-          a type; it is more of an indirect reference.  By contrast, a
-          private type provides a single, unchanging (partial) view of
+          type is currently visible.  Hence, a subtype is not a <view>
+          of a type; it is more of an indirect reference.  By contrast,
+          a private type provides a single, unchanging (partial) view of
           its full type.
 
 7.1/3
-{AI05-0080-1AI05-0080-1} When it is clear from context, the term object
-is used in place of view of an object.  Similarly, the terms type and
-subtype are used in place of view of a type and view of a subtype,
-respectively.
+{<AI05-0080-1AI05-0080-1>} When it is clear from context, the term
+<object> is used in place of <view of an object>.  Similarly, the terms
+<type> and <subtype> are used in place of <view of a type> and <view of
+a subtype>, respectively.
 
 7.c/3
           Discussion: Rules interpreted at compile time generally refer
@@ -5221,16 +5226,16 @@ respectively.
 
 8
 For each declaration, the language rules define a certain region of text
-called the scope of the declaration (see *note 8.2::).  Most
+called the <scope> of the declaration (see *note 8.2::).  Most
 declarations associate an identifier with a declared entity.  Within its
 scope, and only there, there are places where it is possible to use the
 identifier to refer to the declaration, the view it defines, and the
 associated entity; these places are defined by the visibility rules (see
-*note 8.3::). At such places the identifier is said to be a name of the
-entity (the direct_name or selector_name); the name is said to denote
-the declaration, the view, and the associated entity (see *note 8.6::).
-The declaration is said to declare the name, the view, and in most
-cases, the entity itself.
+*note 8.3::).  At such places the identifier is said to be a <name> of
+the entity (the direct_name or selector_name); the name is said to
+<denote> the declaration, the view, and the associated entity (see *note
+8.6::).  The declaration is said to <declare> the name, the view, and in
+most cases, the entity itself.
 
 9
 As an alternative to an identifier, an enumeration literal can be
@@ -5242,10 +5247,10 @@ function can be declared with an operator_symbol as its 
name (see *note
 The syntax rules use the terms defining_identifier,
 defining_character_literal (*note 3.5.1: S0040.), and
 defining_operator_symbol (*note 6.1: S0171.) for the defining occurrence
-of a name; these are collectively called defining names. The terms
+of a name; these are collectively called <defining names>.  The terms
 direct_name and selector_name are used for usage occurrences of
 identifiers, character_literals, and operator_symbols.  These are
-collectively called usage names.
+collectively called <usage names>.
 
 10.a
           To be honest: The terms identifier, character_literal, and
@@ -5259,16 +5264,16 @@ collectively called usage names.
 
 11
 The process by which a construct achieves its run-time effect is called
-execution. This process is also called elaboration for declarations and
-evaluation for expressions.  One of the terms execution, elaboration, or
-evaluation is defined by this International Standard for each construct
-that has a run-time effect.
+<execution>.  This process is also called <elaboration> for declarations
+and <evaluation> for expressions.  One of the terms execution,
+elaboration, or evaluation is defined by this International Standard for
+each construct that has a run-time effect.
 
 11.a
           Glossary entry: The process by which a construct achieves its
-          run-time effect is called execution. Execution of a
-          declaration is also called elaboration.  Execution of an
-          expression is also called evaluation.
+          run-time effect is called <execution>.  Execution of a
+          declaration is also called <elaboration>.  Execution of an
+          expression is also called <evaluation>.
 
 11.b
           To be honest: The term elaboration is also used for the
@@ -5320,9 +5325,9 @@ that has a run-time effect.
           of the forms of execution.
 
 11.g
-          To be honest: A construct is elaborable if elaboration is
-          defined for it. A construct is evaluable if evaluation is
-          defined for it. A construct is executable if execution is
+          To be honest: A construct is <elaborable> if elaboration is
+          defined for it.  A construct is <evaluable> if evaluation is
+          defined for it.  A construct is <executable> if execution is
           defined for it.
 
 11.h
@@ -5330,7 +5335,7 @@ that has a run-time effect.
           (defined in *note 10.2.1::).
 
 11.i/2
-          {AI95-00114-01AI95-00114-01} Evaluation of an evaluable
+          {<AI95-00114-01AI95-00114-01>} Evaluation of an evaluable
           construct produces a result that is either a value, a
           denotation, or a range.  The following are evaluable:
           expression; name prefix; range; entry_index_specification; and
@@ -5342,26 +5347,26 @@ that has a run-time effect.
           subtype_indications are not evaluated; they are elaborated.
 
 11.j
-          Intuitively, an executable construct is one that has a defined
-          run-time effect (which may be null).  Since execution includes
-          elaboration and evaluation as special cases, all elaborable
-          and all evaluable constructs are also executable.  Hence, most
-          constructs in Ada are executable.  An important exception is
-          that the constructs inside a generic unit are not executable
-          directly, but rather are used as a template for (generally)
-          executable constructs in instances of the generic.
+          Intuitively, an <executable> construct is one that has a
+          defined run-time effect (which may be null).  Since execution
+          includes elaboration and evaluation as special cases, all
+          elaborable and all evaluable constructs are also executable.
+          Hence, most constructs in Ada are executable.  An important
+          exception is that the constructs inside a generic unit are not
+          executable directly, but rather are used as a template for
+          (generally) executable constructs in instances of the generic.
 
      NOTES
 
 12
-     1  At compile time, the declaration of an entity declares the
-     entity. At run time, the elaboration of the declaration creates the
-     entity.
+     1  At compile time, the declaration of an entity <declares> the
+     entity.  At run time, the elaboration of the declaration <creates>
+     the entity.
 
 12.a
           Ramification: Syntactic categories for declarations are named
-          either entity_declaration (if they include a trailing
-          semicolon) or entity_specification (if not).
+          either <entity_>declaration (if they include a trailing
+          semicolon) or <entity_>specification (if not).
 
 12.b
           The various kinds of named entities that can be declared are
@@ -5395,12 +5400,12 @@ that has a run-time effect.
                indicate a defining occurrence;
 
 12.f/3
-             * {AI05-0299-1AI05-0299-1} It becomes a direct_name, in
+             * {<AI05-0299-1AI05-0299-1>} It becomes a direct_name, in
                usage occurrences where the usage is required (in Clause
                *note 8::) to be directly visible;
 
 12.g/3
-             * {AI05-0299-1AI05-0299-1} It becomes a selector_name, in
+             * {<AI05-0299-1AI05-0299-1>} It becomes a selector_name, in
                usage occurrences where the usage is required (in Clause
                *note 8::) to be visible but not necessarily directly
                visible;
@@ -5431,7 +5436,7 @@ that has a run-time effect.
           for selector_names.
 
 12.l/3
-          {AI05-0299-1AI05-0299-1} (Note that in Ada 95, a declaration
+          {<AI05-0299-1AI05-0299-1>} (Note that in Ada 95, a declaration
           is visible at all places where one could have used a
           selector_name, not just at places where a selector_name was
           actually used.  Thus, the places where a declaration is
@@ -5446,7 +5451,7 @@ that has a run-time effect.
           "declarations."
 
 12.n/3
-          {AI05-0299-1AI05-0299-1} RM83 contains an incomplete
+          {<AI05-0299-1AI05-0299-1>} RM83 contains an incomplete
           definition of "elaborated" in this subclause: it defines
           "elaborated" for declarations, declarative_parts,
           declarative_items and compilation_units, but "elaboration" is
@@ -5479,18 +5484,18 @@ that has a run-time effect.
                      _Wording Changes from Ada 95_
 
 12.q/2
-          {AI95-00318-02AI95-00318-02} Added extended_return_statement
+          {<AI95-00318-02AI95-00318-02>} Added extended_return_statement
           to the list of declarations.
 
 12.r/2
-          {AI95-00348-01AI95-00348-01} Added null procedures (see *note
-          6.7::) to the syntax.
+          {<AI95-00348-01AI95-00348-01>} Added null procedures (see
+          *note 6.7::) to the syntax.
 
                     _Wording Changes from Ada 2005_
 
 12.s/3
-          {AI05-0177-1AI05-0177-1} Added expression functions (see *note
-          6.8::) to the syntax.
+          {<AI05-0177-1AI05-0177-1>} Added expression functions (see
+          *note 6.8::) to the syntax.
 
 
 File: aarm2012.info,  Node: 3.2,  Next: 3.3,  Prev: 3.1,  Up: 3
@@ -5501,17 +5506,17 @@ File: aarm2012.info,  Node: 3.2,  Next: 3.3,  Prev: 
3.1,  Up: 3
                           _Static Semantics_
 
 1
-A type is characterized by a set of values, and a set of primitive
-operations which implement the fundamental aspects of its semantics. An
-object of a given type is a run-time entity that contains (has) a value
-of the type.
+A <type> is characterized by a set of values, and a set of <primitive
+operations> which implement the fundamental aspects of its semantics.
+An <object> of a given type is a run-time entity that contains (has) a
+value of the type.
 
 1.a/2
-          Glossary entry: Each object has a type.  A type has an
-          associated set of values, and a set of primitive operations
+          Glossary entry: Each object has a type.  A <type> has an
+          associated set of values, and a set of <primitive operations>
           which implement the fundamental aspects of its semantics.
-          Types are grouped into categories.  Most language-defined
-          categories of types are also classes of types.
+          Types are grouped into <categories>.  Most language-defined
+          categories of types are also <classes> of types.
 
 1.b/3
           Glossary entry: A subtype is a type together with optional
@@ -5520,16 +5525,17 @@ of the type.
           values of a subtype are a subset of the values of its type.
 
 2/2
-{AI95-00442-01AI95-00442-01} Types are grouped into categories of types.
-There exist several language-defined categories of types (see NOTES
-below), reflecting the similarity of their values and primitive
-operations.  [Most categories of types form classes of types.]
-Elementary types are those whose values are logically indivisible; 
-composite types are those whose values are composed of component values.
+{<AI95-00442-01AI95-00442-01>} Types are grouped into <categories> of
+types.  There exist several <language-defined categories> of types (see
+NOTES below), reflecting the similarity of their values and primitive
+operations.  [Most categories of types form <classes> of types.]
+<Elementary> types are those whose values are logically indivisible; 
+<composite> types are those whose values are composed of <component>
+values.  
 
 2.a/2
-          Proof: {AI95-00442-01AI95-00442-01} The formal definition of
-          category and class is found in *note 3.4::.
+          Proof: {<AI95-00442-01AI95-00442-01>} The formal definition of
+          <category> and <class> is found in *note 3.4::.
 
 2.b/2
           Glossary entry: A class is a set of types that is closed under
@@ -5542,7 +5548,7 @@ composite types are those whose values are composed of 
component values.
           Glossary entry: A category of types is a set of types with one
           or more common properties, such as primitive operations.  A
           category of types that is closed under derivation is also
-          known as a class.
+          known as a <class>.
 
 2.c
           Glossary entry: An elementary type does not have components.
@@ -5632,48 +5638,48 @@ composite types are those whose values are composed of 
component values.
           types can be used for defining recursive data structures.
 
 3
-The elementary types are the scalar types (discrete and real) and the
-access types (whose values provide access to objects or subprograms). 
-Discrete types are either integer types or are defined by enumeration of
-their values (enumeration types). Real types are either floating point
-types or fixed point types.
+The elementary types are the <scalar> types (<discrete> and <real>) and
+the <access> types (whose values provide access to objects or
+subprograms).  Discrete types are either <integer> types or are defined
+by enumeration of their values (<enumeration> types).  Real types are
+either <floating point> types or <fixed point> types.
 
 4/2
-{AI95-00251-01AI95-00251-01} {AI95-00326-01AI95-00326-01} The composite
-types are the record types, record extensions, array types, interface
-types, task types, and protected types.
+{<AI95-00251-01AI95-00251-01>} {<AI95-00326-01AI95-00326-01>} The
+composite types are the <record> types, <record extensions>, <array>
+types, <interface> types, <task> types, and <protected> types.
 
 4.a/2
-          This paragraph was deleted.{AI95-00442-01AI95-00442-01}
+          <This paragraph was deleted.>{<AI95-00442-01AI95-00442-01>}
 
 4.1/2
-{AI95-00326-01AI95-00326-01} There can be multiple views of a type with
-varying sets of operations.  [An incomplete type represents an
+{<AI95-00326-01AI95-00326-01>} There can be multiple views of a type
+with varying sets of operations.  [An <incomplete> type represents an
 incomplete view (see *note 3.10.1::) of a type with a very restricted
-usage, providing support for recursive data structures.  A private type
-or private extension represents a partial view (see *note 7.3::) of a
-type, providing support for data abstraction.  The full view (see *note
-3.2.1::) of a type represents its complete definition.]  An incomplete
-or partial view is considered a composite type[, even if the full view
-is not].
+usage, providing support for recursive data structures.  A <private>
+type or <private extension> represents a partial view (see *note 7.3::)
+of a type, providing support for data abstraction.  The full view (see
+*note 3.2.1::) of a type represents its complete definition.]  An
+incomplete or partial view is considered a composite type[, even if the
+full view is not].
 
 4.b/3
-          Proof: {AI05-0299-1AI05-0299-1} The real definitions of the
+          Proof: {<AI05-0299-1AI05-0299-1>} The real definitions of the
           views are in the referenced subclauses.
 
 5/2
-{AI95-00326-01AI95-00326-01} Certain composite types (and views thereof)
-have special components called discriminants whose values affect the
-presence, constraints, or initialization of other components.
+{<AI95-00326-01AI95-00326-01>} Certain composite types (and views
+thereof) have special components called <discriminants> whose values
+affect the presence, constraints, or initialization of other components.
 Discriminants can be thought of as parameters of the type.
 
 6/2
-{AI95-00366-01AI95-00366-01} The term subcomponent is used in this
+{<AI95-00366-01AI95-00366-01>} The term <subcomponent> is used in this
 International Standard in place of the term component to indicate either
 a component, or a component of another subcomponent.  Where other
 subcomponents are excluded, the term component is used instead.
-Similarly, a part of an object or value is used to mean the whole object
-or value, or any set of its subcomponents.  The terms component,
+Similarly, a <part> of an object or value is used to mean the whole
+object or value, or any set of its subcomponents.  The terms component,
 subcomponent, and part are also applied to a type meaning the component,
 subcomponent, or part of objects and values of the type.
 
@@ -5695,28 +5701,29 @@ subcomponent, or part of objects and values of the type.
           whole is controlled, or any subcomponent is.
 
 7/2
-{AI95-00231-01AI95-00231-01} The set of possible values for an object of
-a given type can be subjected to a condition that is called a constraint
-(the case of a null constraint that specifies no restriction is also
-included)[; the rules for which values satisfy a given kind of
-constraint are given in *note 3.5:: for range_constraints, *note 3.6.1::
-for index_constraints, and *note 3.7.1:: for discriminant_constraints].
-The set of possible values for an object of an access type can also be
-subjected to a condition that excludes the null value (see *note
-3.10::).
+{<AI95-00231-01AI95-00231-01>} The set of possible values for an object
+of a given type can be subjected to a condition that is called a
+<constraint> (the case of a <null constraint> that specifies no
+restriction is also included)[; the rules for which values satisfy a
+given kind of constraint are given in *note 3.5:: for range_constraints,
+*note 3.6.1:: for index_constraints, and *note 3.7.1:: for
+discriminant_constraints].  The set of possible values for an object of
+an access type can also be subjected to a condition that excludes the
+null value (see *note 3.10::).
 
 8/2
-{AI95-00231-01AI95-00231-01} {AI95-00415-01AI95-00415-01} A subtype of a
-given type is a combination of the type, a constraint on values of the
-type, and certain attributes specific to the subtype.  The given type is
-called the type of the subtype. Similarly, the associated constraint is
-called the constraint of the subtype.   The set of values of a subtype
-consists of the values of its type that satisfy its constraint and any
-exclusion of the null value. Such values belong to the subtype. 
+{<AI95-00231-01AI95-00231-01>} {<AI95-00415-01AI95-00415-01>} A
+<subtype> of a given type is a combination of the type, a constraint on
+values of the type, and certain attributes specific to the subtype.  The
+given type is called the <type of the subtype>.  Similarly, the
+associated constraint is called the <constraint of the subtype>.   The
+set of values of a subtype consists of the values of its type that
+satisfy its constraint and any exclusion of the null value.  Such values
+<belong> to the subtype.  
 
 8.a
           Discussion: We make a strong distinction between a type and
-          its subtypes.  In particular, a type is not a subtype of
+          its subtypes.  In particular, a type is <not> a subtype of
           itself.  There is no constraint associated with a type (not
           even a null one), and type-related attributes are distinct
           from subtype-specific attributes.
@@ -5725,7 +5732,7 @@ exclusion of the null value. Such values belong to the 
subtype.
           Discussion: We no longer use the term "base type."  All types
           were "base types" anyway in Ada 83, so the term was redundant,
           and occasionally confusing.  In the RM95 we say simply "the
-          type of the subtype" instead of "the base type of the
+          type <of> the subtype" instead of "the base type of the
           subtype."
 
 8.c
@@ -5733,7 +5740,7 @@ exclusion of the null value. Such values belong to the 
subtype.
           and need not be a proper subset.
 
 8.d/2
-          To be honest: {AI95-00442-01AI95-00442-01} Any name of a
+          To be honest: {<AI95-00442-01AI95-00442-01>} Any name of a
           category of types (such as "discrete", "real", or "limited")
           is also used to qualify its subtypes, as well as its objects,
           values, declarations, and definitions, such as an "integer
@@ -5747,11 +5754,11 @@ exclusion of the null value. Such values belong to the 
subtype.
           explicitly defining them, when the meaning is obvious.
 
 9
-A subtype is called an unconstrained subtype if its type has unknown
+A subtype is called an <unconstrained> subtype if its type has unknown
 discriminants, or if its type allows range, index, or discriminant
 constraints, but the subtype does not impose such a constraint;
-otherwise, the subtype is called a constrained subtype (since it has no
-unconstrained characteristics).
+otherwise, the subtype is called a <constrained> subtype (since it has
+no unconstrained characteristics).
 
 9.a
           Discussion: In an earlier version of Ada 9X, "constrained"
@@ -5772,15 +5779,15 @@ unconstrained characteristics).
      NOTES
 
 10/2
-     2  {AI95-00442-01AI95-00442-01} Any set of types can be called a
+     2  {<AI95-00442-01AI95-00442-01>} Any set of types can be called a
      "category" of types, and any set of types that is closed under
      derivation (see *note 3.4::) can be called a "class" of types.
      However, only certain categories and classes are used in the
      description of the rules of the language -- generally those that
      have their own particular set of primitive operations (see *note
      3.2.3::), or that correspond to a set of types that are matched by
-     a given kind of generic formal type (see *note 12.5::). The
-     following are examples of "interesting" language-defined classes:
+     a given kind of generic formal type (see *note 12.5::).  The
+     following are examples of "interesting" <language-defined classes>:
      elementary, scalar, discrete, enumeration, character, boolean,
      integer, signed integer, modular, real, floating point, fixed
      point, ordinary fixed point, decimal fixed point, numeric, access,
@@ -5788,28 +5795,28 @@ unconstrained characteristics).
      (untagged) record, tagged, task, protected, nonlimited.  Special
      syntax is provided to define types in each of these classes.  In
      addition to these classes, the following are examples of
-     "interesting" language-defined categories: abstract, incomplete,
+     "interesting" <language-defined categories>: abstract, incomplete,
      interface, limited, private, record.
 
 10.a
-          Discussion: A value is a run-time entity with a given type
+          Discussion: A <value> is a run-time entity with a given type
           which can be assigned to an object of an appropriate subtype
-          of the type. An operation is a program entity that operates on
-          zero or more operands to produce an effect, or yield a result,
-          or both.
+          of the type.  An <operation> is a program entity that operates
+          on zero or more operands to produce an effect, or yield a
+          result, or both.
 
 10.b/2
-          Ramification: {AI95-00442-01AI95-00442-01} Note that a type's
-          category (and class) depends on the place of the reference --
-          a private type is composite outside and possibly elementary
-          inside.  It's really the view that is elementary or composite.
-          Note that although private types are composite, there are some
-          properties that depend on the corresponding full view -- for
-          example, parameter passing modes, and the constraint checks
-          that apply in various places.
+          Ramification: {<AI95-00442-01AI95-00442-01>} Note that a
+          type's category (and class) depends on the place of the
+          reference -- a private type is composite outside and possibly
+          elementary inside.  It's really the <view> that is elementary
+          or composite.  Note that although private types are composite,
+          there are some properties that depend on the corresponding
+          full view -- for example, parameter passing modes, and the
+          constraint checks that apply in various places.
 
 10.c/2
-          {AI95-00345-01AI95-00345-01} {AI95-00442-01AI95-00442-01}
+          {<AI95-00345-01AI95-00345-01>} {<AI95-00442-01AI95-00442-01>}
           Every property of types forms a category, but not every
           property of types represents a class.  For example, the set of
           all abstract types does not form a class, because this set is
@@ -5817,30 +5824,30 @@ unconstrained characteristics).
           interface types does not form a class.
 
 10.d/2
-          {AI95-00442-01AI95-00442-01} The set of limited types does not
-          form a class (since nonlimited types can inherit from limited
-          interfaces), but the set of nonlimited types does.  The set of
-          tagged record types and the set of tagged private types do not
-          form a class (because each of them can be extended to create a
-          type of the other category); that implies that the set of
-          record types and the set of private types also do not form a
-          class (even though untagged record types and untagged private
-          types do form a class).  In all of these cases, we can talk
-          about the category of the type; for instance, we can talk
-          about the "category of limited types"..
+          {<AI95-00442-01AI95-00442-01>} The set of limited types does
+          not form a class (since nonlimited types can inherit from
+          limited interfaces), but the set of nonlimited types does.
+          The set of tagged record types and the set of tagged private
+          types do not form a class (because each of them can be
+          extended to create a type of the other category); that implies
+          that the set of record types and the set of private types also
+          do not form a class (even though untagged record types and
+          untagged private types do form a class).  In all of these
+          cases, we can talk about the category of the type; for
+          instance, we can talk about the "category of limited types"..
 
 10.e/2
-          {AI95-00442-01AI95-00442-01} Normatively, the language-defined
-          classes are those that are defined to be inherited on
-          derivation by *note 3.4::; other properties either aren't
-          interesting or form categories, not classes.
+          {<AI95-00442-01AI95-00442-01>} Normatively, the
+          <language-defined classes> are those that are defined to be
+          inherited on derivation by *note 3.4::; other properties
+          either aren't interesting or form categories, not classes.
 
 11/2
-     {AI95-00442-01AI95-00442-01} These language-defined categories are
-     organized like this:
+     {<AI95-00442-01AI95-00442-01>} These language-defined categories
+     are organized like this:
 
 12/2
-          {AI95-00345-01AI95-00345-01} all types
+          {<AI95-00345-01AI95-00345-01>} all types
              elementary
                 scalar
                    discrete
@@ -5876,14 +5883,14 @@ unconstrained characteristics).
                          tagged protected
 
 13/2
-     {AI95-00345-01AI95-00345-01} {AI95-00442-01AI95-00442-01} There are
-     other categories, such as "numeric" and "discriminated", which
+     {<AI95-00345-01AI95-00345-01>} {<AI95-00442-01AI95-00442-01>} There
+     are other categories, such as "numeric" and "discriminated", which
      represent other categorization dimensions, but do not fit into the
      above strictly hierarchical picture.
 
 13.a.1/2
-          Discussion: {AI95-00345-01AI95-00345-01}
-          {AI95-00442-01AI95-00442-01} Note that this is also true for
+          Discussion: {<AI95-00345-01AI95-00345-01>}
+          {<AI95-00442-01AI95-00442-01>} Note that this is also true for
           some categories mentioned in the chart.  The category "task"
           includes both untagged tasks and tagged tasks.  Similarly for
           "protected", "limited", and "nonlimited" (note that limited
@@ -5892,7 +5899,7 @@ unconstrained characteristics).
                      _Wording Changes from Ada 83_
 
 13.a/3
-          {AI05-0299-1AI05-0299-1} This subclause now precedes the
+          {<AI05-0299-1AI05-0299-1>} This subclause now precedes the
           subclauses on objects and named numbers, to cut down on the
           number of forward references.
 
@@ -5905,29 +5912,29 @@ unconstrained characteristics).
                      _Wording Changes from Ada 95_
 
 13.c/2
-          {AI95-00231-01AI95-00231-01} Added a mention of null
+          {<AI95-00231-01AI95-00231-01>} Added a mention of null
           exclusions when we're talking about constraints (these are not
           constraints, but they are similar).
 
 13.d/2
-          {AI95-00251-01AI95-00251-01} Defined an interface type to be a
-          composite type.
+          {<AI95-00251-01AI95-00251-01>} Defined an interface type to be
+          a composite type.
 
 13.e/2
-          {AI95-00326-01AI95-00326-01} Revised the wording so that it is
-          clear that an incomplete view is similar to a partial view in
-          terms of the language.
+          {<AI95-00326-01AI95-00326-01>} Revised the wording so that it
+          is clear that an incomplete view is similar to a partial view
+          in terms of the language.
 
 13.f/2
-          {AI95-00366-01AI95-00366-01} Added a definition of component
+          {<AI95-00366-01AI95-00366-01>} Added a definition of component
           of a type, subcomponent of a type, and part of a type.  These
           are commonly used in the standard, but they were not
           previously defined.
 
 13.g/3
-          {AI95-00442-01AI95-00442-01} {AI05-0299-1AI05-0299-1} Reworded
-          most of this subclause to use category rather than class,
-          since so many interesting properties are not, strictly
+          {<AI95-00442-01AI95-00442-01>} {<AI05-0299-1AI05-0299-1>}
+          Reworded most of this subclause to use category rather than
+          class, since so many interesting properties are not, strictly
           speaking, classes.  Moreover, there was no normative
           description of exactly which properties formed classes, and
           which did not.  The real definition of class, along with a
@@ -5958,7 +5965,7 @@ A type_declaration declares a type and its first subtype.
         | private_extension_declaration
 
 3/3
-     {AI05-0183-1AI05-0183-1} full_type_declaration ::=
+     {<AI05-0183-1AI05-0183-1>} full_type_declaration ::=
           type defining_identifier [known_discriminant_part] is 
      type_definition
              [aspect_specification];
@@ -5966,7 +5973,7 @@ A type_declaration declares a type and its first subtype.
         | protected_type_declaration
 
 4/2
-     {AI95-00251-01AI95-00251-01} type_definition ::=
+     {<AI95-00251-01AI95-00251-01>} type_definition ::=
           enumeration_type_definition   | integer_type_definition
         | real_type_definition   | array_type_definition
         | record_type_definition   | access_type_definition
@@ -5982,26 +5989,26 @@ itself.
 
 6
 The defining_identifier (*note 3.1: S0022.) of a type_declaration (*note
-3.2.1: S0023.) denotes the first subtype of the type.  The
+3.2.1: S0023.) denotes the <first subtype> of the type.  The
 known_discriminant_part (*note 3.7: S0061.), if any, defines the
 discriminants of the type (see *note 3.7::, "*note 3.7::
 Discriminants").  The remainder of the type_declaration (*note 3.2.1:
 S0023.) defines the remaining characteristics of (the view of) the type.
 
 7/2
-{AI95-00230-01AI95-00230-01} A type defined by a type_declaration (*note
-3.2.1: S0023.) is a named type; such a type has one or more nameable
-subtypes. Certain other forms of declaration also include type
+{<AI95-00230-01AI95-00230-01>} A type defined by a type_declaration
+(*note 3.2.1: S0023.) is a <named> type; such a type has one or more
+nameable subtypes.  Certain other forms of declaration also include type
 definitions as part of the declaration for an object.  The type defined
-by such a declaration is anonymous -- it has no nameable subtypes. For
-explanatory purposes, this International Standard sometimes refers to an
-anonymous type by a pseudo-name, written in italics, and uses such
+by such a declaration is <anonymous> -- it has no nameable subtypes.
+For explanatory purposes, this International Standard sometimes refers
+to an anonymous type by a pseudo-name, written in italics, and uses such
 pseudo-names at places where the syntax normally requires an identifier.
 For a named type whose first subtype is T, this International Standard
 sometimes refers to the type of T as simply "the type T".
 
 7.a/2
-          Ramification: {AI95-00230-01AI95-00230-01} The only
+          Ramification: {<AI95-00230-01AI95-00230-01>} The only
           user-defined types that can be anonymous in the above sense
           are array, access, task, and protected types.  An anonymous
           array, task, or protected type can be defined as part of an
@@ -6009,15 +6016,15 @@ sometimes refers to the type of T as simply "the type 
T".
           as part of numerous other constructs.
 
 8/2
-{AI95-00230-01AI95-00230-01} {AI95-00326-01AI95-00326-01} A named type
-that is declared by a full_type_declaration (*note 3.2.1: S0024.), or an
-anonymous type that is defined by an access_definition or as part of
-declaring an object of the type, is called a full type.  The declaration
-of a full type also declares the full view of the type.  The
-type_definition (*note 3.2.1: S0025.), task_definition (*note 9.1:
+{<AI95-00230-01AI95-00230-01>} {<AI95-00326-01AI95-00326-01>} A named
+type that is declared by a full_type_declaration (*note 3.2.1: S0024.),
+or an anonymous type that is defined by an access_definition or as part
+of declaring an object of the type, is called a <full type>.  The
+declaration of a full type also declares the <full view> of the type.
+The type_definition (*note 3.2.1: S0025.), task_definition (*note 9.1:
 S0207.), protected_definition (*note 9.4: S0212.), or access_definition
-(*note 3.10: S0084.) that defines a full type is called a full type
-definition.  [Types declared by other forms of type_declaration (*note
+(*note 3.10: S0084.) that defines a full type is called a <full type
+definition>.  [Types declared by other forms of type_declaration (*note
 3.2.1: S0023.) are not separate types; they are partial or incomplete
 views of some full type.]
 
@@ -6026,13 +6033,13 @@ views of some full type.]
           are full types.
 
 8.b/2
-          Reason: {AI95-00230-01AI95-00230-01} We need to mention
+          Reason: {<AI95-00230-01AI95-00230-01>} We need to mention
           access_definition separately, as it may occur in renames,
           which do not declare objects.
 
 9
-The definition of a type implicitly declares certain predefined
-operators that operate on the type, according to what classes the type
+The definition of a type implicitly declares certain <predefined
+operators> that operate on the type, according to what classes the type
 belongs, as specified in *note 4.5::, "*note 4.5:: Operators and
 Expression Evaluation".
 
@@ -6043,10 +6050,10 @@ Expression Evaluation".
           only certain classes of types.
 
 10
-The predefined types [(for example the types Boolean, Wide_Character,
-Integer, root_integer, and universal_integer)] are the types that are
-defined in [a predefined library package called] Standard[; this package
-also includes the [(implicit)] declarations of their predefined
+The <predefined types> [(for example the types Boolean, Wide_Character,
+Integer, <root_integer>, and <universal_integer>)] are the types that
+are defined in [a predefined library package called] Standard[; this
+package also includes the [(implicit)] declarations of their predefined
 operators].  [The package Standard is described in *note A.1::.]
 
 10.a
@@ -6063,15 +6070,15 @@ operators].  [The package Standard is described in 
*note A.1::.]
 
 11
 The elaboration of a full_type_declaration consists of the elaboration
-of the full type definition. Each elaboration of a full type definition
+of the full type definition.  Each elaboration of a full type definition
 creates a distinct type and its first subtype.
 
 11.a
-          Reason: The creation is associated with the type definition,
-          rather than the type declaration, because there are types that
-          are created by full type definitions that are not immediately
-          contained within a type declaration (e.g.  an array object
-          declaration, a singleton task declaration, etc.).
+          Reason: The creation is associated with the type <definition>,
+          rather than the type <declaration>, because there are types
+          that are created by full type definitions that are not
+          immediately contained within a type declaration (e.g.  an
+          array object declaration, a singleton task declaration, etc.).
 
 11.b
           Ramification: Any implicit declarations that occur immediately
@@ -6081,7 +6088,7 @@ creates a distinct type and its first subtype.
                               _Examples_
 
 12
-Examples of type definitions:
+<Examples of type definitions:>
 
 13
      (White, Red, Yellow, Green, Blue, Brown, Black)
@@ -6089,7 +6096,7 @@ Examples of type definitions:
      array(1 .. 10) of Integer
 
 14
-Examples of type declarations:
+<Examples of type declarations:>
 
 15
      type Color  is (White, Red, Yellow, Green, Blue, Brown, Black);
@@ -6117,7 +6124,7 @@ Examples of type declarations:
           and protected type declarations.
 
 16.b/3
-          {AI05-0299-1AI05-0299-1} We have generalized the concept of
+          {<AI05-0299-1AI05-0299-1>} We have generalized the concept of
           first-named subtype (now called simply "first subtype") to
           cover all kinds of types, for uniformity of description
           elsewhere.  RM83 defined first-named subtype in Section 13.
@@ -6126,7 +6133,7 @@ Examples of type declarations:
           some first subtypes have no name.
 
 16.c/2
-          {AI95-00230-01AI95-00230-01} We no longer elaborate
+          {<AI95-00230-01AI95-00230-01>} We no longer elaborate
           discriminant_parts, because there is nothing to do, and it was
           complex to say that you only wanted to elaborate it once for a
           private or incomplete type.  This is also consistent with the
@@ -6140,23 +6147,23 @@ Examples of type declarations:
                      _Wording Changes from Ada 95_
 
 16.d/2
-          {AI95-00230-01AI95-00230-01} Added wording so that anonymous
+          {<AI95-00230-01AI95-00230-01>} Added wording so that anonymous
           access types are always full types, even if they appear in
           renames.
 
 16.e/2
-          {AI95-00251-01AI95-00251-01} Added interface types (see *note
-          3.9.4::) to the syntax.
+          {<AI95-00251-01AI95-00251-01>} Added interface types (see
+          *note 3.9.4::) to the syntax.
 
 16.f/2
-          {AI95-00326-01AI95-00326-01} Added a definition of full view,
-          so that all types have a well-defined full view.
+          {<AI95-00326-01AI95-00326-01>} Added a definition of full
+          view, so that all types have a well-defined full view.
 
                        _Extensions to Ada 2005_
 
 16.g/3
-          {AI05-0183-1AI05-0183-1} An optional aspect_specification can
-          be used in a full_type_declaration.  This is described in
+          {<AI05-0183-1AI05-0183-1>} An optional aspect_specification
+          can be used in a full_type_declaration.  This is described in
           *note 13.1.1::.
 
 
@@ -6172,16 +6179,16 @@ type, as defined by a subtype_indication.
                                _Syntax_
 
 2/3
-     {AI05-0183-1AI05-0183-1} subtype_declaration ::=
+     {<AI05-0183-1AI05-0183-1>} subtype_declaration ::=
         subtype defining_identifier is subtype_indication
              [aspect_specification];
 
 3/2
-     {AI95-00231-01AI95-00231-01} subtype_indication ::=  [
+     {<AI95-00231-01AI95-00231-01>} subtype_indication ::=  [
      null_exclusion] subtype_mark [constraint]
 
 4
-     subtype_mark ::= subtype_name
+     subtype_mark ::= <subtype_>name
 
 4.a
           Ramification: Note that name includes attribute_reference;
@@ -6206,21 +6213,22 @@ type, as defined by a subtype_indication.
                         _Name Resolution Rules_
 
 8
-A subtype_mark shall resolve to denote a subtype. The type determined by
-a subtype_mark is the type of the subtype denoted by the subtype_mark.
+A subtype_mark shall resolve to denote a subtype.  The type <determined
+by> a subtype_mark is the type of the subtype denoted by the
+subtype_mark.
 
 8.a/3
-          Ramification: {AI05-0005-1AI05-0005-1} Types are never
+          Ramification: {<AI05-0005-1AI05-0005-1>} Types are never
           directly named; all subtype_marks denote subtypes -- possibly
           an unconstrained (base) subtype, but never the type.  When we
-          use the term anonymous type we really mean a type with no
+          use the term <anonymous type> we really mean a type with no
           nameable subtypes.
 
                           _Dynamic Semantics_
 
 9
 The elaboration of a subtype_declaration consists of the elaboration of
-the subtype_indication. The elaboration of a subtype_indication creates
+the subtype_indication.  The elaboration of a subtype_indication creates
 a new subtype.  If the subtype_indication does not include a constraint,
 the new subtype has the same (possibly null) constraint as that denoted
 by the subtype_mark.  The elaboration of a subtype_indication that
@@ -6230,7 +6238,7 @@ includes a constraint proceeds as follows:
    * The constraint is first elaborated.
 
 11
-   * A check is then made that the constraint is compatible with the
+   * A check is then made that the constraint is <compatible> with the
      subtype denoted by the subtype_mark.
 
 11.a
@@ -6241,11 +6249,11 @@ includes a constraint proceeds as follows:
 
 12
 The condition imposed by a constraint is the condition obtained after
-elaboration of the constraint. The rules defining compatibility are
+elaboration of the constraint.  The rules defining compatibility are
 given for each form of constraint in the appropriate subclause.  These
-rules are such that if a constraint is compatible with a subtype, then
+rules are such that if a constraint is <compatible> with a subtype, then
 the condition imposed by the constraint cannot contradict any condition
-already imposed by the subtype on its values. The exception
+already imposed by the subtype on its values.  The exception
 Constraint_Error is raised if any check of compatibility fails.
 
 12.a
@@ -6270,17 +6278,17 @@ Constraint_Error is raised if any check of 
compatibility fails.
                               _Examples_
 
 14
-Examples of subtype declarations:
+<Examples of subtype declarations:>
 
 15/2
-     {AI95-00433-01AI95-00433-01} subtype Rainbow   is Color range Red .. 
Blue;        --  see *note 3.2.1::
+     {<AI95-00433-01AI95-00433-01>} subtype Rainbow   is Color range Red .. 
Blue;        --<  see *note 3.2.1::>
      subtype Red_Blue  is Rainbow;
      subtype Int       is Integer;
      subtype Small_Int is Integer range -10 .. 10;
-     subtype Up_To_K   is Column range 1 .. K;            --  see *note 3.2.1::
-     subtype Square    is Matrix(1 .. 10, 1 .. 10);       --  see *note 3.6::
-     subtype Male      is Person(Sex => M);               --  see *note 
3.10.1::
-     subtype Binop_Ref is not null Binop_Ptr;             --  see *note 3.10::
+     subtype Up_To_K   is Column range 1 .. K;            --<  see *note 
3.2.1::>
+     subtype Square    is Matrix(1 .. 10, 1 .. 10);       --<  see *note 3.6::>
+     subtype Male      is Person(Sex => M);               --<  see *note 
3.10.1::>
+     subtype Binop_Ref is not null Binop_Ptr;             --<  see *note 
3.10::>
 
                     _Incompatibilities With Ada 83_
 
@@ -6306,16 +6314,16 @@ Examples of subtype declarations:
                         _Extensions to Ada 95_
 
 15.d/2
-          {AI95-00231-01AI95-00231-01} An optional null_exclusion can be
-          used in a subtype_indication.  This is described in *note
+          {<AI95-00231-01AI95-00231-01>} An optional null_exclusion can
+          be used in a subtype_indication.  This is described in *note
           3.10::.
 
                        _Extensions to Ada 2005_
 
 15.e/3
-          {AI05-0183-1AI05-0183-1} An optional aspect_specification can
-          be used in a subtype_declaration.  This is described in *note
-          13.1.1::.
+          {<AI05-0183-1AI05-0183-1>} An optional aspect_specification
+          can be used in a subtype_declaration.  This is described in
+          *note 13.1.1::.
 
 
 File: aarm2012.info,  Node: 3.2.3,  Next: 3.2.4,  Prev: 3.2.2,  Up: 3.2
@@ -6326,14 +6334,14 @@ File: aarm2012.info,  Node: 3.2.3,  Next: 3.2.4,  Prev: 
3.2.2,  Up: 3.2
                           _Static Semantics_
 
 1/2
-{AI95-00416-01AI95-00416-01} An operation operates on a type T if it
-yields a value of type T, if it has an operand whose expected type (see
-*note 8.6::) is T, or if it has an access parameter or access result
-type (see *note 6.1::) designating T. A predefined operator, or other
-language-defined operation such as assignment or a membership test, that
-operates on a type, is called a predefined operation of the type. The
-primitive operations of a type are the predefined operations of the
-type, plus any user-defined primitive subprograms.
+{<AI95-00416-01AI95-00416-01>} An operation <operates on a type> <T> if
+it yields a value of type <T>, if it has an operand whose expected type
+(see *note 8.6::) is <T>, or if it has an access parameter or access
+result type (see *note 6.1::) designating <T>.  A predefined operator,
+or other language-defined operation such as assignment or a membership
+test, that operates on a type, is called a <predefined operation> of the
+type.  The <primitive operations> of a type are the predefined
+operations of the type, plus any user-defined primitive subprograms.
 
 1.a
           Glossary entry: The primitive operations of a type are the
@@ -6359,7 +6367,7 @@ type, plus any user-defined primitive subprograms.
           used mostly in conceptual discussions.
 
 2
-The primitive subprograms of a specific type are defined as follows:
+The <primitive subprograms> of a specific type are defined as follows:
 
 3
    * The predefined operators of the type (see *note 4.5::);
@@ -6379,16 +6387,16 @@ The primitive subprograms of a specific type are 
defined as follows:
      within the same package_specification and that operate on the type;
 
 6.1/3
-   * {AI05-0128-1AI05-0128-1} For a specific type with an explicitly
+   * {<AI05-0128-1AI05-0128-1>} For a specific type with an explicitly
      declared primitive "=" operator whose result type is Boolean, the
      corresponding "/=" operator (see *note 6.6::);
 
 7/2
-   * {AI95-00200-01AI95-00200-01} For a nonformal type, any subprograms
-     not covered above [that are explicitly declared immediately within
-     the same declarative region as the type] and that override (see
-     *note 8.3::) other implicitly declared primitive subprograms of the
-     type.
+   * {<AI95-00200-01AI95-00200-01>} For a nonformal type, any
+     subprograms not covered above [that are explicitly declared
+     immediately within the same declarative region as the type] and
+     that override (see *note 8.3::) other implicitly declared primitive
+     subprograms of the type.
 
 7.a
           Discussion: In Ada 83, only subprograms declared in the
@@ -6410,7 +6418,7 @@ The primitive subprograms of a specific type are defined 
as follows:
           Classes".
 
 7.d/2
-          Ramification: {AI95-00200-01AI95-00200-01} Subprograms
+          Ramification: {<AI95-00200-01AI95-00200-01>} Subprograms
           declared in a generic package specification are never
           primitive for a formal type, even if they happen to override
           an operation of the formal type.  This includes formal
@@ -6419,7 +6427,7 @@ The primitive subprograms of a specific type are defined 
as follows:
 
 8
 A primitive subprogram whose designator is an operator_symbol is called
-a primitive operator.
+a <primitive operator>.
 
                     _Incompatibilities With Ada 83_
 
@@ -6441,9 +6449,9 @@ a primitive operator.
                      _Wording Changes from Ada 83_
 
 8.c
-          We have dropped the confusing term operation of a type in
-          favor of the more useful primitive operation of a type and the
-          phrase operates on a type.
+          We have dropped the confusing term <operation of a type> in
+          favor of the more useful <primitive operation of a type> and
+          the phrase <operates on a type>.
 
 8.d
           The description of S'Base has been moved to *note 3.5::,
@@ -6453,20 +6461,20 @@ a primitive operator.
                      _Wording Changes from Ada 95_
 
 8.e/2
-          {AI95-00200-01AI95-00200-01} Clarified that a formal
+          {<AI95-00200-01AI95-00200-01>} Clarified that a formal
           subprogram that happens to override a primitive operation of a
           formal type is not a primitive operation (and thus not a
           dispatching operation) of the formal type.
 
 8.f/2
-          {AI95-00416-01AI95-00416-01} Added wording to include access
+          {<AI95-00416-01AI95-00416-01>} Added wording to include access
           result types in the kinds of operations that operate on a type
           T.
 
                     _Wording Changes from Ada 2005_
 
 8.g/3
-          {AI05-0128-1AI05-0128-1} Correction: The implicitly declared
+          {<AI05-0128-1AI05-0128-1>} Correction: The implicitly declared
           "/=" for a primitive "=" operator is also primitive; this
           makes it eligible to be made visible by a use type clause.
 
@@ -6477,10 +6485,10 @@ File: aarm2012.info,  Node: 3.2.4,  Prev: 3.2.3,  Up: 
3.2
 ------------------------
 
 1/3
-{AI05-0153-3AI05-0153-3} {AI05-0269-1AI05-0269-1}
-{AI05-0299-1AI05-0299-1} The language-defined predicate aspects
+{<AI05-0153-3AI05-0153-3>} {<AI05-0269-1AI05-0269-1>}
+{<AI05-0299-1AI05-0299-1>} The language-defined <predicate aspects>
 Static_Predicate and Dynamic_Predicate may be used to define properties
-of subtypes.  A predicate specification is an aspect_specification for
+of subtypes.  A <predicate specification> is an aspect_specification for
 one of the two predicate aspects.  General rules for aspects and
 aspect_specifications are found in Clause *note 13:: (*note 13.1:: and
 *note 13.1.1:: respectively).
@@ -6498,19 +6506,19 @@ aspect_specifications are found in Clause *note 13:: 
(*note 13.1:: and
                         _Name Resolution Rules_
 
 2/3
-{AI05-0153-3AI05-0153-3} The expected type for a predicate aspect
+{<AI05-0153-3AI05-0153-3>} The expected type for a predicate aspect
 expression is any boolean type.
 
                           _Static Semantics_
 
 3/3
-{AI05-0153-3AI05-0153-3} A predicate specification may be given on a
+{<AI05-0153-3AI05-0153-3>} A predicate specification may be given on a
 type_declaration or a subtype_declaration, and applies to the declared
 subtype.  In addition, predicate specifications apply to certain other
 subtypes:
 
 4/4
-   * {AI12-0071-1AI12-0071-1} {AI12-0099-1AI12-0099-1} For a (first)
+   * {<AI12-0071-1AI12-0071-1>} {<AI12-0099-1AI12-0099-1>} For a (first)
      subtype defined by a type declaration, any predicates of parent or
      progenitor subtypes apply.
 
@@ -6519,12 +6527,12 @@ subtypes:
      subtype denoted by the subtype_mark applies.
 
 6/4
-This paragraph was deleted.{AI05-0153-3AI05-0153-3}
-{AI12-0071-1AI12-0071-1}
+<This paragraph was deleted.>{<AI05-0153-3AI05-0153-3>}
+{<AI12-0071-1AI12-0071-1>}
 
 7/3
-{AI05-0290-1AI05-0290-1} Predicate checks are defined to be enabled or
-disabled for a given subtype as follows:
+{<AI05-0290-1AI05-0290-1>} Predicate checks are defined to be <enabled>
+or <disabled> for a given subtype as follows:
 
 8/3
    * If a subtype is declared by a type_declaration or
@@ -6548,7 +6556,7 @@ disabled for a given subtype as follows:
           other subtypes mentioned in the declaration];
 
 12/4
-   * {AI12-0099-1AI12-0099-1} If a subtype is defined by a type
+   * {<AI12-0099-1AI12-0099-1>} If a subtype is defined by a type
      declaration that does not include a predicate specification, then
      predicate checks are enabled for the subtype if and only if any
      predicate checks are enabled for parent or progenitor subtypes;
@@ -6572,13 +6580,13 @@ disabled for a given subtype as follows:
           above.
 
 14.b/4
-          {AI12-0071-1AI12-0071-1} Even when predicate checks are
+          {<AI12-0071-1AI12-0071-1>} Even when predicate checks are
           disabled, a predicate can affect various Legality Rules, the
           results of membership tests, the items in a for loop, and the
           result of the Valid attribute.
 
 14.1/4
-{AI12-0054-2AI12-0054-2} For a subtype with a directly-specified
+{<AI12-0054-2AI12-0054-2>} For a subtype with a directly-specified
 predicate aspect, the following additional language-defined aspect may
 be specified with an aspect_specification (see *note 13.1.1::):
 
@@ -6596,28 +6604,28 @@ Predicate_Failure
                         _Name Resolution Rules_
 
 14.3/4
-{AI12-0054-2AI12-0054-2} The expected type for the Predicate_Failure
+{<AI12-0054-2AI12-0054-2>} The expected type for the Predicate_Failure
 expression is String.
 
                            _Legality Rules_
 
 15/3
-{AI05-0153-3AI05-0153-3} {AI05-0269-1AI05-0269-1} The expression of a
-Static_Predicate specification shall be predicate-static; that is, one
-of the following:
+{<AI05-0153-3AI05-0153-3>} {<AI05-0269-1AI05-0269-1>} The expression of
+a Static_Predicate specification shall be <predicate-static>; that is,
+one of the following:
 
 16/3
    * a static expression;
 
 17/4
-   * {AI12-0039-1AI12-0039-1} a membership test whose
-     tested_simple_expression is the current instance, and whose
+   * {<AI12-0039-1AI12-0039-1>} a membership test whose
+     <tested_>simple_expression is the current instance, and whose
      membership_choice_list meets the requirements for a static
      membership test (see *note 4.9::);
 
 18/3
-   * a case_expression whose selecting_expression is the current
-     instance, and whose dependent_expressions are static expressions;
+   * a case_expression whose <selecting_>expression is the current
+     instance, and whose <dependent_>expressions are static expressions;
 
 19/3
    * a call to a predefined equality or ordering operator, where one
@@ -6625,19 +6633,19 @@ of the following:
      expression;
 
 20/4
-   * {AI05-0262-1AI05-0262-1} {AI12-0099-1AI12-0099-1} a call to a
+   * {<AI05-0262-1AI05-0262-1>} {<AI12-0099-1AI12-0099-1>} a call to a
      predefined boolean operator and, or, xor, or not, where each
      operand is predicate-static;
 
 21/3
-   * {AI05-0269-1AI05-0269-1} a short-circuit control form where both
+   * {<AI05-0269-1AI05-0269-1>} a short-circuit control form where both
      operands are predicate-static; or
 
 22/3
    * a parenthesized predicate-static expression.
 
 23/3
-{AI05-0262-1AI05-0262-1} A predicate shall not be specified for an
+{<AI05-0262-1AI05-0262-1>} A predicate shall not be specified for an
 incomplete subtype.
 
 23.a/3
@@ -6647,8 +6655,8 @@ incomplete subtype.
           complexity needed to support it.
 
 24/3
-{AI05-0287-1AI05-0287-1} If a predicate applies to a subtype, then that
-predicate shall not mention any other subtype to which the same
+{<AI05-0287-1AI05-0287-1>} If a predicate applies to a subtype, then
+that predicate shall not mention any other subtype to which the same
 predicate applies.
 
 24.a/3
@@ -6664,60 +6672,60 @@ predicate applies.
                private
                   subtype Ugly is Really_Ugly;
                   type Really_Ugly is new Integer
-                     with Static_Predicate => Really_Ugly not in Ugly; -- 
Illegal!
+                     with Static_Predicate => Really_Ugly not in Ugly; --< 
Illegal!>
 
 25/3
-{AI05-0153-3AI05-0153-3} An index subtype, discrete_range of an
+{<AI05-0153-3AI05-0153-3>} An index subtype, discrete_range of an
 index_constraint or slice, or a discrete_subtype_definition of a
 constrained_array_definition, entry_declaration, or
 entry_index_specification shall not denote a subtype to which predicate
 specifications apply.
 
 26/3
-{AI05-0153-3AI05-0153-3} The prefix of an attribute_reference whose
+{<AI05-0153-3AI05-0153-3>} The prefix of an attribute_reference whose
 attribute_designator is First, Last, or Range shall not denote a scalar
 subtype to which predicate specifications apply.
 
 26.a/3
-          Reason: {AI05-0297-1AI05-0297-1} This is to prevent confusion
-          about whether the First value is the lowest value of the
-          subtype (which does not depend on the predicate) or the lowest
-          value of the subtype which meets the predicate.  (For a
+          Reason: {<AI05-0297-1AI05-0297-1>} This is to prevent
+          confusion about whether the First value is the lowest value of
+          the subtype (which does not depend on the predicate) or the
+          lowest value of the subtype which meets the predicate.  (For a
           dynamic predicate, determining this latter value is expensive
           as it would usually require a loop.)  For a static subtype
           that has a static predicate, the First_Valid and Last_Valid
           attributes (see *note 3.5.5::) can be used instead.
 
 27/3
-{AI05-0153-3AI05-0153-3} {AI05-0262-1AI05-0262-1}
-{AI05-0287-1AI05-0287-1} The discrete_subtype_definition of a
+{<AI05-0153-3AI05-0153-3>} {<AI05-0262-1AI05-0262-1>}
+{<AI05-0287-1AI05-0287-1>} The discrete_subtype_definition of a
 loop_parameter_specification shall not denote a nonstatic subtype to
 which predicate specifications apply or any subtype to which
 Dynamic_Predicate specifications apply.
 
 28/3
-{AI05-0153-3AI05-0153-3} {AI05-0262-1AI05-0262-1} The discrete_choice of
-a named_array_aggregate shall not denote a nonstatic subtype to which
-predicate specifications apply.
+{<AI05-0153-3AI05-0153-3>} {<AI05-0262-1AI05-0262-1>} The
+discrete_choice of a named_array_aggregate shall not denote a nonstatic
+subtype to which predicate specifications apply.
 
 28.a/3
-          Reason: {AI05-0262-1AI05-0262-1} This rule prevents
+          Reason: {<AI05-0262-1AI05-0262-1>} This rule prevents
           noncontiguous dynamically bounded array aggregates, which
           could be expensive to check for.  (Array aggregates have rules
           to prevent problems with static subtypes.)  We define this
           rule here so that the runtime generic body check applies.
 
 29/3
-{AI05-0262-1AI05-0262-1} In addition to the places where Legality Rules
-normally apply (see *note 12.3::), these rules apply also in the private
-part of an instance of a generic unit.
+{<AI05-0262-1AI05-0262-1>} In addition to the places where Legality
+Rules normally apply (see *note 12.3::), these rules apply also in the
+private part of an instance of a generic unit.
 
                           _Dynamic Semantics_
 
 29.1/4
-{AI125-0071AI125-0071} If any of the above Legality Rules is violated in
-an instance of a generic unit, Program_Error is raised at the point of
-the violation.
+{<AI125-0071AI125-0071>} If any of the above Legality Rules is violated
+in an instance of a generic unit, Program_Error is raised at the point
+of the violation.
 
 29.a/4
           Discussion: This is the usual way around the contract model;
@@ -6727,23 +6735,23 @@ the violation.
           should raise Program_Error.
 
 29.2/4
-{AI12-0071-1AI12-0071-1} To determine whether a value satisfies the
-predicates of a subtype S, the following tests are performed in the
+{<AI12-0071-1AI12-0071-1>} To determine whether a value <satisfies the
+predicates> of a subtype <S>, the following tests are performed in the
 following order, until one of the tests fails, in which case the
 predicates are not satisfied and no further tests are performed, or all
 of the tests succeed, in which case the predicates are satisfied:
 
 29.3/4
    * the value is first tested to determine whether it satisfies any
-     constraints or any null exclusion of S;
+     constraints or any null exclusion of <S>;
 
 29.4/4
    * then:
 
 29.5/4
-        * if S is a first subtype, the value is tested to determine
+        * if <S> is a first subtype, the value is tested to determine
           whether it satisfies the predicates of the parent and
-          progenitor subtypes (if any) of S (in an arbitrary order);
+          progenitor subtypes (if any) of <S> (in an arbitrary order);
 
 29.b/4
           Ramification: This rule has an effect for derived types (which
@@ -6753,12 +6761,12 @@ of the tests succeed, in which case the predicates are 
satisfied:
           required for other first subtypes.
 
 29.6/4
-        * if S is defined by a subtype_indication, the value is tested
+        * if <S> is defined by a subtype_indication, the value is tested
           to determine whether it satisfies the predicates of the
           subtype denoted by the subtype_mark of the subtype_indication;
 
 29.7/4
-   * finally, if S is defined by a declaration to which one or more
+   * finally, if <S> is defined by a declaration to which one or more
      predicate specifications apply, the predicates are evaluated (in an
      arbitrary order) to test that all of them yield True for the given
      value.
@@ -6769,19 +6777,19 @@ of the tests succeed, in which case the predicates are 
satisfied:
           earlier steps had succeeded.
 
 30/3
-{AI05-0153-3AI05-0153-3} {AI05-0290-1AI05-0290-1} If predicate checks
-are enabled for a given subtype, then:
+{<AI05-0153-3AI05-0153-3>} {<AI05-0290-1AI05-0290-1>} If predicate
+checks are enabled for a given subtype, then:
 
 31/4
-          {AI12-0054-2AI12-0054-2} {AI12-0071-1AI12-0071-1} [On every
-          subtype conversion, a check is performed that the operand
-          satisfies the predicates of the target subtype.  This includes
-          all parameter passing, except for certain parameters passed by
-          reference, which are covered by the following rule: ] After
-          normal completion and leaving of a subprogram, for each in out
-          or out parameter that is passed by reference, a check is
-          performed that the value of the parameter satisfies the
-          predicates of the subtype of the actual.  For an object
+          {<AI12-0054-2AI12-0054-2>} {<AI12-0071-1AI12-0071-1>} [On
+          every subtype conversion, a check is performed that the
+          operand satisfies the predicates of the target subtype.  This
+          includes all parameter passing, except for certain parameters
+          passed by reference, which are covered by the following rule:
+          ] After normal completion and leaving of a subprogram, for
+          each in out or out parameter that is passed by reference, a
+          check is performed that the value of the parameter satisfies
+          the predicates of the subtype of the actual.  For an object
           created by an object_declaration with no explicit
           initialization expression, or by an uninitialized allocator,
           if any subcomponents have default_expressions, a check is
@@ -6789,8 +6797,8 @@ are enabled for a given subtype, then:
           predicates of the nominal subtype.
 
 31.1/4
-          {AI12-0054-2AI12-0054-2} If any of the predicate checks fail,
-          Assertion_Error is raised, unless the subtype whose
+          {<AI12-0054-2AI12-0054-2>} If any of the predicate checks
+          fail, Assertion_Error is raised, unless the subtype whose
           directly-specified predicate aspect evaluated to False also
           has a directly-specified Predicate_Failure aspect.  In that
           case, the specified Predicate_Failure expression is evaluated;
@@ -6818,59 +6826,59 @@ are enabled for a given subtype, then:
           check if there is no applicable Predicate_Failure aspect.
 
 32/4
-This paragraph was deleted.{AI05-0262-1AI05-0262-1}
-{AI125-0071AI125-0071}
+<This paragraph was deleted.>{<AI05-0262-1AI05-0262-1>}
+{<AI125-0071AI125-0071>}
 
 33/4
-This paragraph was deleted.{AI05-0153-3AI05-0153-3}
-{AI05-0276-1AI05-0276-1} {AI125-0071AI125-0071}
+<This paragraph was deleted.>{<AI05-0153-3AI05-0153-3>}
+{<AI05-0276-1AI05-0276-1>} {<AI125-0071AI125-0071>}
 
 33.a/4
-          This paragraph was deleted.
+          <This paragraph was deleted.>
 
      NOTES
 
 34/3
-     5  {AI05-0153-3AI05-0153-3} A predicate specification does not
+     5  {<AI05-0153-3AI05-0153-3>} A predicate specification does not
      cause a subtype to be considered constrained.
 
 35/3
-     6  {AI05-0153-3AI05-0153-3} A Static_Predicate, like a constraint,
-     always remains True for all objects of the subtype, except in the
-     case of uninitialized variables and other invalid values.  A
-     Dynamic_Predicate, on the other hand, is checked as specified
-     above, but can become False at other times.  For example, the
-     predicate of a record subtype is not checked when a subcomponent is
-     modified.
+     6  {<AI05-0153-3AI05-0153-3>} A Static_Predicate, like a
+     constraint, always remains True for all objects of the subtype,
+     except in the case of uninitialized variables and other invalid
+     values.  A Dynamic_Predicate, on the other hand, is checked as
+     specified above, but can become False at other times.  For example,
+     the predicate of a record subtype is not checked when a
+     subcomponent is modified.
 
 36/4
-     7  {AI12-0071-1AI12-0071-1} No predicates apply to the base subtype
-     of a scalar type; every value of a scalar type T is considered to
-     satisfy the predicates of T'Base.
+     7  {<AI12-0071-1AI12-0071-1>} No predicates apply to the base
+     subtype of a scalar type; every value of a scalar type <T> is
+     considered to satisfy the predicates of <T>'Base.
 
 37/4
-     8  {AI12-0054-2AI12-0054-2} Predicate_Failure expressions are never
-     evaluated during the evaluation of a membership test (see *note
-     4.5.2::) or Valid attribute (see *note 13.9.2::).
+     8  {<AI12-0054-2AI12-0054-2>} Predicate_Failure expressions are
+     never evaluated during the evaluation of a membership test (see
+     *note 4.5.2::) or Valid attribute (see *note 13.9.2::).
 
 38/4
-     9  {AI12-0054-2AI12-0054-2} A Predicate_Failure expression can be a
-     raise_expression (see *note 11.3::).
+     9  {<AI12-0054-2AI12-0054-2>} A Predicate_Failure expression can be
+     a raise_expression (see *note 11.3::).
 
                               _Examples_
 
 39/4
-     {AI12-0054-2AI12-0054-2} subtype Basic_Letter is Character -- See *note 
A.3.2:: for "basic letter".
+     {<AI12-0054-2AI12-0054-2>} subtype Basic_Letter is Character -- <See 
*note A.3.2:: for "basic letter".>
         with Static_Predicate => Basic_Letter in 'A'..'Z' | 'a'..'z' | '�' | 
'�' | '�' | '�' | '�' | '�' | '�';
 
 40/4
-     {AI12-0054-2AI12-0054-2} subtype Even_Integer is Integer
+     {<AI12-0054-2AI12-0054-2>} subtype Even_Integer is Integer
         with Dynamic_Predicate => Even_Integer mod 2 = 0,
             Predicate_Failure => "Even_Integer must be a multiple of 2";
 
 41/4
-{AI12-0054-2AI12-0054-2} Text_IO (see *note A.10.1::) could have used
-predicates to describe some common exceptional conditions as follows:
+{<AI12-0054-2AI12-0054-2>} <Text_IO (see *note A.10.1::) could have used
+predicates to describe some common exceptional conditions as follows:>
 
 42/4
      with Ada.IO_Exceptions;
@@ -6913,19 +6921,19 @@ predicates to describe some common exceptional 
conditions as follows:
         ...
 
 51/4
-        -- Similarly for all of the other input and output subprograms.
+        -- <Similarly for all of the other input and output subprograms.>
 
                        _Extensions to Ada 2005_
 
 51.a/3
-          {AI05-0153-3AI05-0153-3} {AI05-0262-1AI05-0262-1}
-          {AI05-0276-1AI05-0276-1} {AI05-0290-1AI05-0290-1} Predicate
-          aspects are new in Ada 2012.
+          {<AI05-0153-3AI05-0153-3>} {<AI05-0262-1AI05-0262-1>}
+          {<AI05-0276-1AI05-0276-1>} {<AI05-0290-1AI05-0290-1>}
+          Predicate aspects are new in Ada 2012.
 
                        _Extensions to Ada 2012_
 
 51.b/4
-          {AI12-0054-2AI12-0054-2} Corrigendum: The Predicate_Failure
+          {<AI12-0054-2AI12-0054-2>} Corrigendum: The Predicate_Failure
           aspect is new.  We can consider this a correction as it is
           always possible for implementers to add implementation-defined
           aspects, so the same is true for language-defined aspects.
@@ -6933,7 +6941,7 @@ predicates to describe some common exceptional conditions 
as follows:
                     _Wording Changes from Ada 2012_
 
 51.c/4
-          {AI12-0071-1AI12-0071-1} Corrigendum: Specified the order of
+          {<AI12-0071-1AI12-0071-1>} Corrigendum: Specified the order of
           evaluation of most predicates, by defining the new term
           "satisfies the predicates of the subtype".  This is not
           inconsistent, as the order previously was unspecified, so any
@@ -6943,14 +6951,14 @@ predicates to describe some common exceptional 
conditions as follows:
           see the Ada.Text_IO example above for such a case.
 
 51.d/4
-          {AI12-0099-1AI12-0099-1} Corrigendum: Revised wording to
+          {<AI12-0099-1AI12-0099-1>} Corrigendum: Revised wording to
           ensure all kinds of types are covered, including the anonymous
           task associated with a single_task_declaration, and
           generalized it.
 
 51.e/4
-          {AI12-0099-1AI12-0099-1} Corrigendum: Revised wording to list
-          the boolean operators that can be predicate-static, to
+          {<AI12-0099-1AI12-0099-1>} Corrigendum: Revised wording to
+          list the boolean operators that can be predicate-static, to
           eliminate confusion about whether not is included.
 
 
@@ -6960,8 +6968,8 @@ File: aarm2012.info,  Node: 3.3,  Next: 3.4,  Prev: 3.2,  
Up: 3
 =============================
 
 1
-[Objects are created at run time and contain a value of a given type. An
-object can be created and initialized as part of elaborating a
+[Objects are created at run time and contain a value of a given type.
+An object can be created and initialized as part of elaborating a
 declaration, evaluating an allocator, aggregate, or function_call, or
 passing a parameter by copy.  Prior to reclaiming the storage for an
 object, it is finalized if necessary (see *note 7.6.1::).]
@@ -7001,37 +7009,37 @@ All of the following are objects:
      4.1::);
 
 10/3
-   * {AI95-00416-01AI95-00416-01} {AI05-0015-1AI05-0015-1} the return
-     object of a function;
+   * {<AI95-00416-01AI95-00416-01>} {<AI05-0015-1AI05-0015-1>} the
+     return object of a function;
 
 11
    * the result of evaluating an aggregate;
 
 11.1/3
-   * {AI05-0003-1AI05-0003-1} a qualified_expression whose operand
+   * {<AI05-0003-1AI05-0003-1>} a qualified_expression whose operand
      denotes an object;
 
 12
    * a component, slice, or view conversion of another object.
 
 13/3
-{AI05-0054-2AI05-0054-2} An object is either a constant object or a
-variable object.  Similarly, a view of an object is either a constant or
-a variable.  All views of a constant elementary object are constant.
-All views of a constant composite object are constant, except for parts
-that are of controlled or immutably limited types; variable views of
-those parts and their subcomponents may exist.  In this sense, objects
-of controlled and immutably limited types are inherently mutable.  A
-constant view of an object cannot be used to modify its value.  The
-terms constant and variable by themselves refer to constant and variable
-views of objects.
+{<AI05-0054-2AI05-0054-2>} An object is either a <constant> object or a
+<variable> object.  Similarly, a view of an object is either a
+<constant> or a <variable>.  All views of a constant elementary object
+are constant.  All views of a constant composite object are constant,
+except for parts that are of controlled or immutably limited types;
+variable views of those parts and their subcomponents may exist.  In
+this sense, objects of controlled and immutably limited types are
+<inherently mutable>.  A constant view of an object cannot be used to
+modify its value.  The terms constant and variable by themselves refer
+to constant and variable views of objects.
 
 14
-The value of an object is read when the value of any part of the object
-is evaluated, or when the value of an enclosing object is evaluated. The
-value of a variable is updated when an assignment is performed to any
-part of the variable, or when an assignment is performed to an enclosing
-object.
+The value of an object is <read> when the value of any part of the
+object is evaluated, or when the value of an enclosing object is
+evaluated.  The value of a variable is <updated> when an assignment is
+performed to any part of the variable, or when an assignment is
+performed to an enclosing object.
 
 14.a
           Ramification: Reading and updating are intended to include
@@ -7057,7 +7065,7 @@ constants:
      constant;
 
 16.a/2
-          To be honest: {AI95-00385-01AI95-00385-01} We mean the word
+          To be honest: {<AI95-00385-01AI95-00385-01>} We mean the word
           constant as defined by the grammar for object_declaration, not
           some random word constant.  Thus,
 
@@ -7074,29 +7082,29 @@ constants:
    * a discriminant;
 
 18.1/3
-   * {AI05-0262-1AI05-0262-1} a loop parameter unless specified to be a
-     variable for a generalized loop (see *note 5.5.2::);
+   * {<AI05-0262-1AI05-0262-1>} a loop parameter unless specified to be
+     a variable for a generalized loop (see *note 5.5.2::);
 
 19/3
-   * {AI05-0262-1AI05-0262-1} a choice parameter or entry index;
+   * {<AI05-0262-1AI05-0262-1>} a choice parameter or entry index;
 
 20
    * the dereference of an access-to-constant value;
 
 20.1/3
-   * {AI05-0015-1AI05-0015-1} the return object declared by an
+   * {<AI05-0015-1AI05-0015-1>} the return object declared by an
      extended_return_statement with the reserved word constant;
 
 21/3
-   * {AI05-0015-1AI05-0015-1} the object denoted by a function_call or
+   * {<AI05-0015-1AI05-0015-1>} the object denoted by a function_call or
      an aggregate;
 
 21.1/3
-   * {AI05-0003-1AI05-0003-1} the result of evaluating a
+   * {<AI05-0003-1AI05-0003-1>} the result of evaluating a
      qualified_expression;
 
 21.2/3
-   * {AI05-0120-1AI05-0120-1} within the body of a protected function
+   * {<AI05-0120-1AI05-0120-1>} within the body of a protected function
      (or a function declared immediately within a protected_body), the
      current instance of the enclosing protected unit;
 
@@ -7105,14 +7113,14 @@ constants:
      of a constant.
 
 23/3
-{AI05-0264-1AI05-0264-1} At the place where a view of an object is
-defined, a nominal subtype is associated with the view. The object's
-actual subtype (that is, its subtype) can be more restrictive than the
+{<AI05-0264-1AI05-0264-1>} At the place where a view of an object is
+defined, a <nominal subtype> is associated with the view.  The object's
+<actual subtype> (that is, its subtype) can be more restrictive than the
 nominal subtype of the view; it always is if the nominal subtype is an
-indefinite subtype. A subtype is an indefinite subtype if it is an
+<indefinite subtype>.  A subtype is an indefinite subtype if it is an
 unconstrained array subtype, or if it has unknown discriminants or
 unconstrained discriminants without defaults (see *note 3.7::);
-otherwise, the subtype is a definite subtype [(all elementary subtypes
+otherwise, the subtype is a <definite> subtype [(all elementary subtypes
 are definite subtypes)].  [A class-wide subtype is defined to have
 unknown discriminants, and is therefore an indefinite subtype.  An
 indefinite subtype does not by itself provide enough information to
@@ -7121,8 +7129,8 @@ expression is necessary (see *note 3.3.1::).  A component 
cannot have an
 indefinite nominal subtype.]
 
 23.1/3
-{AI05-0008-1AI05-0008-1} A view of a composite object is known to be
-constrained if:
+{<AI05-0008-1AI05-0008-1>} A view of a composite object is <known to be
+constrained> if:
 
 23.2/3
    * its nominal subtype is constrained, and is not an untagged partial
@@ -7132,7 +7140,7 @@ constrained if:
    * its nominal subtype is indefinite; or
 
 23.4/3
-   * {AI05-0008-1AI05-0008-1} {AI05-0093-1AI05-0093-1} its type is
+   * {<AI05-0008-1AI05-0008-1>} {<AI05-0093-1AI05-0093-1>} its type is
      immutably limited (see *note 7.5::); or
 
 23.5/3
@@ -7151,7 +7159,7 @@ constrained if:
      extended_return_statement; or
 
 23.9/3
-   * {AI05-0008-1AI05-0008-1} {AI05-0041-1AI05-0041-1} it is a
+   * {<AI05-0008-1AI05-0008-1>} {<AI05-0041-1AI05-0041-1>} it is a
      dereference of a pool-specific access type, and there is no
      ancestor of its type that has a constrained partial view.
 
@@ -7163,18 +7171,18 @@ constrained if:
           be a constant).
 
 23.b/3
-          {AI05-0005-1AI05-0005-1} {AI05-0008-1AI05-0008-1} There are
-          other cases that could have been included in this definition
-          (view conversions, the current instance of a type, objects of
-          a formal discriminated private type), but these are not
-          relevant to the places this term is used, so they were not
+          {<AI05-0005-1AI05-0005-1>} {<AI05-0008-1AI05-0008-1>} There
+          are other cases that could have been included in this
+          definition (view conversions, the current instance of a type,
+          objects of a formal discriminated private type), but these are
+          not relevant to the places this term is used, so they were not
           included.  If this term is used in additional places, the
           definition should be checked to see if any of these additional
           cases are relevant and appropriate wording added if necessary.
 
 23.10/3
-{AI05-0008-1AI05-0008-1} {AI05-0041-1AI05-0041-1} For the purposes of
-determining within a generic body whether an object is known to be
+{<AI05-0008-1AI05-0008-1>} {<AI05-0041-1AI05-0041-1>} For the purposes
+of determining within a generic body whether an object is known to be
 constrained:
 
 23.11/3
@@ -7188,7 +7196,7 @@ constrained:
      considered pool-specific.
 
 24
-A named number provides a name for a numeric value known at compile
+A <named number> provides a name for a numeric value known at compile
 time.  It is declared by a number_declaration.
 
      NOTES
@@ -7199,14 +7207,14 @@ time.  It is declared by a number_declaration.
      and finalization, if any.
 
 25.1/3
-     11  {AI05-0054-2AI05-0054-2} The value of a constant object cannot
-     be changed after its initialization, except in some cases where the
-     object has a controlled or immutably limited part (see *note 7.5::,
-     *note 7.6::, and *note 13.9.1::).
+     11  {<AI05-0054-2AI05-0054-2>} The value of a constant object
+     cannot be changed after its initialization, except in some cases
+     where the object has a controlled or immutably limited part (see
+     *note 7.5::, *note 7.6::, and *note 13.9.1::).
 
 26/3
-     12  {AI05-0264-1AI05-0264-1} The nominal and actual subtypes of an
-     elementary object are always the same.  For a discriminated or
+     12  {<AI05-0264-1AI05-0264-1>} The nominal and actual subtypes of
+     an elementary object are always the same.  For a discriminated or
      array object, if the nominal subtype is constrained, then so is the
      actual subtype.
 
@@ -7227,7 +7235,7 @@ time.  It is declared by a number_declaration.
                      _Wording Changes from Ada 83_
 
 26.c/3
-          {AI05-0299-1AI05-0299-1} This subclause now follows the
+          {<AI05-0299-1AI05-0299-1>} This subclause now follows the
           subclauses on types and subtypes, to cut down on the number of
           forward references.
 
@@ -7264,42 +7272,43 @@ time.  It is declared by a number_declaration.
                      _Wording Changes from Ada 95_
 
 26.i/2
-          {AI95-00416-01AI95-00416-01} Clarified that the return object
-          is the object created by a function call.
+          {<AI95-00416-01AI95-00416-01>} Clarified that the return
+          object is the object created by a function call.
 
                        _Extensions to Ada 2005_
 
 26.j/3
-          {AI05-0015-1AI05-0015-1} Added wording to allow return objects
-          to be declared as constants, and corrected the definition of
-          return objects as objects.
+          {<AI05-0015-1AI05-0015-1>} Added wording to allow return
+          objects to be declared as constants, and corrected the
+          definition of return objects as objects.
 
                     _Wording Changes from Ada 2005_
 
 26.k/3
-          {AI05-0008-1AI05-0008-1} {AI05-0041-1AI05-0041-1}
-          {AI05-0093-1AI05-0093-1} Correction: Added a definition of
-          known to be constrained, for use in other rules.
+          {<AI05-0008-1AI05-0008-1>} {<AI05-0041-1AI05-0041-1>}
+          {<AI05-0093-1AI05-0093-1>} Correction: Added a definition of
+          <known to be constrained>, for use in other rules.
 
 26.l/3
-          {AI05-0054-2AI05-0054-2} Correction: We now recognize the fact
-          that not all declared constant objects are immutable; for
+          {<AI05-0054-2AI05-0054-2>} Correction: We now recognize the
+          fact that not all declared constant objects are immutable; for
           those that a variable view can be constructed, they can be
           changed via that view.
 
 26.m/3
-          {AI05-0120-1AI05-0120-1} Correction: Added the current
+          {<AI05-0120-1AI05-0120-1>} Correction: Added the current
           instance of a protected object to the list of constant views;
           since the list claims to include all possibilities, it had
           better include that one.
 
 26.n/3
-          {AI05-0003-1AI05-0003-1} The result of a qualified_expression
-          is defined to be a constant view and is defined to be an
-          object if the operand of the qualified_expression is an
-          object.  These definitions, combined with some grammar
-          changes, allow qualified_expressions to be used in more
-          places.  See *note 4.1:: for details.
+          {<AI05-0003-1AI05-0003-1>} The result of a
+          qualified_expression is defined to be a constant view and is
+          defined to be an object if the operand of the
+          qualified_expression is an object.  These definitions,
+          combined with some grammar changes, allow
+          qualified_expressions to be used in more places.  See *note
+          4.1:: for details.
 
 * Menu:
 
@@ -7313,17 +7322,17 @@ File: aarm2012.info,  Node: 3.3.1,  Next: 3.3.2,  Up: 
3.3
 -------------------------
 
 1/3
-{AI05-0262-1AI05-0262-1} An object_declaration declares a stand-alone
-object with a given nominal subtype and, optionally, an explicit initial
-value given by an initialization expression. For an array, access, task,
-or protected object, the object_declaration may include the definition
-of the (anonymous) type of the object.
+{<AI05-0262-1AI05-0262-1>} An object_declaration declares a
+<stand-alone> object with a given nominal subtype and, optionally, an
+explicit initial value given by an initialization expression.  For an
+array, access, task, or protected object, the object_declaration may
+include the definition of the (anonymous) type of the object.
 
                                _Syntax_
 
 2/3
-     {AI95-00385-01AI95-00385-01} {AI95-00406-01AI95-00406-01}
-     {AI05-0183-1AI05-0183-1} object_declaration ::=
+     {<AI95-00385-01AI95-00385-01>} {<AI95-00406-01AI95-00406-01>}
+     {<AI05-0183-1AI05-0183-1>} object_declaration ::=
          defining_identifier_list : [aliased] [constant] 
      subtype_indication [:= expression]
              [aspect_specification];
@@ -7345,26 +7354,26 @@ of the (anonymous) type of the object.
 4
 For an object_declaration with an expression following the compound
 delimiter :=, the type expected for the expression is that of the
-object. This expression is called the initialization expression. 
+object.  This expression is called the <initialization expression>.  
 
                            _Legality Rules_
 
 5/2
-{AI95-00287-01AI95-00287-01} An object_declaration without the reserved
-word constant declares a variable object.  If it has a
+{<AI95-00287-01AI95-00287-01>} An object_declaration without the
+reserved word constant declares a variable object.  If it has a
 subtype_indication or an array_type_definition that defines an
 indefinite subtype, then there shall be an initialization expression.
 
                           _Static Semantics_
 
 6/3
-{AI05-0264-1AI05-0264-1} {AI05-0299-1AI05-0299-1} An object_declaration
-with the reserved word constant declares a constant object. If it has an
-initialization expression, then it is called a full constant
-declaration. Otherwise, it is called a deferred constant declaration.
-The rules for deferred constant declarations are given in subclause
-*note 7.4::.  The rules for full constant declarations are given in this
-subclause.
+{<AI05-0264-1AI05-0264-1>} {<AI05-0299-1AI05-0299-1>} An
+object_declaration with the reserved word constant declares a constant
+object.  If it has an initialization expression, then it is called a
+<full constant declaration>.  Otherwise, it is called a <deferred
+constant declaration>.  The rules for deferred constant declarations are
+given in subclause *note 7.4::.  The rules for full constant
+declarations are given in this subclause.
 
 7
 Any declaration that includes a defining_identifier_list with more than
@@ -7376,22 +7385,22 @@ Standard relies on this equivalence; explanations are 
given for
 declarations with a single defining_identifier.
 
 8/2
-{AI95-00385-01AI95-00385-01} The subtype_indication, access_definition,
-or full type definition of an object_declaration defines the nominal
-subtype of the object.  The object_declaration declares an object of the
-type of the nominal subtype.
+{<AI95-00385-01AI95-00385-01>} The subtype_indication,
+access_definition, or full type definition of an object_declaration
+defines the nominal subtype of the object.  The object_declaration
+declares an object of the type of the nominal subtype.
 
 8.a/2
-          Discussion: {AI95-00385-01AI95-00385-01} The phrase "full type
-          definition" here includes the case of an anonymous array,
+          Discussion: {<AI95-00385-01AI95-00385-01>} The phrase "full
+          type definition" here includes the case of an anonymous array,
           access, task, or protected type.
 
 8.1/2
-{AI95-00373-01AI95-00373-01} A component of an object is said to require
-late initialization if it has an access discriminant value constrained
-by a per-object expression, or if it has an initialization expression
-that includes a name denoting the current instance of the type or
-denoting an access discriminant.
+{<AI95-00373-01AI95-00373-01>} A component of an object is said to
+<require late initialization> if it has an access discriminant value
+constrained by a per-object expression, or if it has an initialization
+expression that includes a name denoting the current instance of the
+type or denoting an access discriminant.
 
 8.b/2
           Reason: Such components can depend on the values of other
@@ -7401,27 +7410,27 @@ denoting an access discriminant.
                           _Dynamic Semantics_
 
 9/2
-{AI95-00363-01AI95-00363-01} If a composite object declared by an
+{<AI95-00363-01AI95-00363-01>} If a composite object declared by an
 object_declaration has an unconstrained nominal subtype, then if this
 subtype is indefinite or the object is constant the actual subtype of
 this object is constrained.  The constraint is determined by the bounds
 or discriminants (if any) of its initial value; the object is said to be
-constrained by its initial value. When not constrained by its initial
-value, the actual and nominal subtypes of the object are the same. If
-its actual subtype is constrained, the object is called a constrained
-object.
+<constrained by its initial value>.  When not constrained by its initial
+value, the actual and nominal subtypes of the object are the same.  If
+its actual subtype is constrained, the object is called a <constrained
+object>.
 
 10
 For an object_declaration without an initialization expression, any
 initial values for the object or its subcomponents are determined by the
-implicit initial values defined for its nominal subtype, as follows:
+<implicit initial values> defined for its nominal subtype, as follows:
 
 11
    * The implicit initial value for an access subtype is the null value
      of the access type.
 
 11.1/3
-   * {AI05-0228-1AI05-0228-1} The implicit initial value for a scalar
+   * {<AI05-0228-1AI05-0228-1>} The implicit initial value for a scalar
      subtype that has the Default_Value aspect specified is the value of
      that aspect converted to the nominal subtype (which might raise
      Constraint_Error -- see *note 4.6::, "*note 4.6:: Type
@@ -7439,13 +7448,13 @@ implicit initial values defined for its nominal 
subtype, as follows:
      constrained discriminated subtype is defined by the subtype.
 
 13/3
-   * {AI05-0228-1AI05-0228-1} For a (definite) composite subtype, the
+   * {<AI05-0228-1AI05-0228-1>} For a (definite) composite subtype, the
      implicit initial value of each component with a default_expression
      is obtained by evaluation of this expression and conversion to the
      component's nominal subtype (which might raise Constraint_Error),
      unless the component is a discriminant of a constrained subtype
      (the previous case), or is in an excluded variant (see *note
-     3.8.1::). For each component that does not have a
+     3.8.1::).  For each component that does not have a
      default_expression, if the composite subtype has the
      Default_Component_Value aspect specified, the implicit initial
      value is the value of that aspect converted to the component's
@@ -7470,7 +7479,7 @@ The elaboration of an object_declaration proceeds in the 
following
 sequence of steps:
 
 16/2
-     1.  {AI95-00385-01AI95-00385-01} The subtype_indication (*note
+     1.  {<AI95-00385-01AI95-00385-01>} The subtype_indication (*note
      3.2.2: S0027.), access_definition (*note 3.10: S0084.),
      array_type_definition (*note 3.6: S0051.), single_task_declaration
      (*note 9.1: S0206.), or single_protected_declaration (*note 9.4:
@@ -7481,19 +7490,19 @@ sequence of steps:
      2.  If the object_declaration includes an initialization
      expression, the (explicit) initial value is obtained by evaluating
      the expression and converting it to the nominal subtype (which
-     might raise Constraint_Error -- see *note 4.6::). 
+     might raise Constraint_Error -- see *note 4.6::).  
 
 18/2
-     3.  {8652/00028652/0002} {AI95-00171-01AI95-00171-01}
-     {AI95-00373-01AI95-00373-01} The object is created, and, if there
-     is not an initialization expression, the object is initialized by
-     default. When an object is initialized by default, any per-object
+     3.  {<8652/00028652/0002>} {<AI95-00171-01AI95-00171-01>}
+     {<AI95-00373-01AI95-00373-01>} The object is created, and, if there
+     is not an initialization expression, the object is <initialized by
+     default>.  When an object is initialized by default, any per-object
      constraints (see *note 3.8::) are elaborated and any implicit
      initial values for the object or for its subcomponents are obtained
-     as determined by the nominal subtype. Any initial values (whether
+     as determined by the nominal subtype.  Any initial values (whether
      explicit or implicit) are assigned to the object or to the
      corresponding subcomponents.  As described in *note 5.2:: and *note
-     7.6::, Initialize and Adjust procedures can be called. 
+     7.6::, Initialize and Adjust procedures can be called.  
 
 18.a
           Discussion: For a per-object constraint that contains some
@@ -7520,7 +7529,7 @@ sequence of steps:
           known early, since this optimization is semantically neutral.
 
 19/2
-       This paragraph was deleted.{AI95-00373-01AI95-00373-01}
+       <This paragraph was deleted.>{<AI95-00373-01AI95-00373-01>}
 
 19.a
           Ramification: Since the initial values have already been
@@ -7531,12 +7540,12 @@ sequence of steps:
           *note 3.5::.
 
 20/2
-{AI95-00373-01AI95-00373-01} For the third step above, evaluations and
+{<AI95-00373-01AI95-00373-01>} For the third step above, evaluations and
 assignments are performed in an arbitrary order subject to the following
 restrictions:
 
 20.1/2
-   * {AI95-00373-01AI95-00373-01} Assignment to any part of the object
+   * {<AI95-00373-01AI95-00373-01>} Assignment to any part of the object
      is preceded by the evaluation of the value that is to be assigned.
 
 20.a.1/2
@@ -7547,9 +7556,9 @@ restrictions:
           code it wants.
 
 20.2/2
-   * {AI95-00373-01AI95-00373-01} The evaluation of a default_expression
-     that includes the name of a discriminant is preceded by the
-     assignment to that discriminant.
+   * {<AI95-00373-01AI95-00373-01>} The evaluation of a
+     default_expression that includes the name of a discriminant is
+     preceded by the assignment to that discriminant.
 
 20.a.2/2
           Reason: Duh again.  But we have to say this, too.  It's odd
@@ -7558,7 +7567,7 @@ restrictions:
           about discriminant values that come from subtype_indications.
 
 20.3/2
-   * {AI95-00373-01AI95-00373-01} The evaluation of the
+   * {<AI95-00373-01AI95-00373-01>} The evaluation of the
      default_expression for any component that depends on a discriminant
      is preceded by the assignment to that discriminant.
 
@@ -7579,7 +7588,7 @@ restrictions:
           that F be evaluated before the aggregate.
 
 20.4/3
-   * {AI95-00373-01AI95-00373-01} {AI05-0092-1AI05-0092-1} The
+   * {<AI95-00373-01AI95-00373-01>} {<AI05-0092-1AI05-0092-1>} The
      assignments to any components, including implicit components, not
      requiring late initialization precede the initial value evaluations
      for any components requiring late initialization; if two components
@@ -7623,9 +7632,9 @@ restrictions:
           execution to be erroneous.
 
 21/3
-{AI05-0228-1AI05-0228-1} [There is no implicit initial value defined for
-a scalar subtype unless the Default_Value aspect has been specified for
-the type.] In the absence of an explicit initialization or the
+{<AI05-0228-1AI05-0228-1>} [There is no implicit initial value defined
+for a scalar subtype unless the Default_Value aspect has been specified
+for the type.]  In the absence of an explicit initialization or the
 specification of the Default_Value aspect, a newly created scalar object
 might have a value that does not belong to its subtype (see *note
 13.9.1:: and *note H.1::).
@@ -7658,8 +7667,8 @@ might have a value that does not belong to its subtype 
(see *note
      explicit initial value is required.
 
 23/3
-     14  {AI05-0092-1AI05-0092-1} {AI05-0255-1AI05-0255-1} As indicated
-     above, a stand-alone object is an object declared by an
+     14  {<AI05-0092-1AI05-0092-1>} {<AI05-0255-1AI05-0255-1>} As
+     indicated above, a stand-alone object is an object declared by an
      object_declaration.  Similar definitions apply to "stand-alone
      constant" and "stand-alone variable."  A subcomponent of an object
      is not a stand-alone object, nor is an object that is created by an
@@ -7676,26 +7685,26 @@ might have a value that does not belong to its subtype 
(see *note
                               _Examples_
 
 25
-Example of a multiple object declaration:
+<Example of a multiple object declaration:>
 
 26
-     --  the multiple object declaration 
+     --<  the multiple object declaration >
 
 27/2
-     {AI95-00433-01AI95-00433-01} John, Paul : not null Person_Name := new 
Person(Sex => M);  --  see *note 3.10.1::
+     {<AI95-00433-01AI95-00433-01>} John, Paul : not null Person_Name := new 
Person(Sex => M);  --<  see *note 3.10.1::>
 
 28
-     --  is equivalent to the two single object declarations in the order given
+     --<  is equivalent to the two single object declarations in the order 
given>
 
 29/2
-     {AI95-00433-01AI95-00433-01} John : not null Person_Name := new 
Person(Sex => M);
+     {<AI95-00433-01AI95-00433-01>} John : not null Person_Name := new 
Person(Sex => M);
      Paul : not null Person_Name := new Person(Sex => M);
 
 30
-Examples of variable declarations:
+<Examples of variable declarations:>
 
 31/2
-     {AI95-00433-01AI95-00433-01} Count, Sum  : Integer;
+     {<AI95-00433-01AI95-00433-01>} Count, Sum  : Integer;
      Size        : Integer range 0 .. 10_000 := 0;
      Sorted      : Boolean := False;
      Color_Table : array(1 .. Max) of Color;
@@ -7704,13 +7713,13 @@ Examples of variable declarations:
      [Unicode 952], [Unicode 966]        : Float range -PI .. +PI;
 
 32
-Examples of constant declarations:
+<Examples of constant declarations:>
 
 33/2
-     {AI95-00433-01AI95-00433-01} Limit     : constant Integer := 10_000;
+     {<AI95-00433-01AI95-00433-01>} Limit     : constant Integer := 10_000;
      Low_Limit : constant Integer := Limit/10;
      Tolerance : constant Real := Dispersion(1.15);
-     Hello_Msg : constant access String := Hello'Access; -- see *note 3.10.2::
+     Hello_Msg : constant access String := Hello'Access; --< see *note 
3.10.2::>
 
                         _Extensions to Ada 83_
 
@@ -7759,8 +7768,8 @@ Examples of constant declarations:
                      _Inconsistencies With Ada 95_
 
 33.f/2
-          {AI95-00363-01AI95-00363-01} Unconstrained aliased objects of
-          types with discriminants with defaults are no longer
+          {<AI95-00363-01AI95-00363-01>} Unconstrained aliased objects
+          of types with discriminants with defaults are no longer
           constrained by their initial values.  This means that a
           program that raised Constraint_Error from an attempt to change
           the discriminants will no longer do so.  The change only
@@ -7775,42 +7784,42 @@ Examples of constant declarations:
                         _Extensions to Ada 95_
 
 33.g/2
-          {AI95-00287-01AI95-00287-01} A constant may have a limited
+          {<AI95-00287-01AI95-00287-01>} A constant may have a limited
           type; the initialization expression has to be built-in-place
           (see *note 7.5::).
 
 33.h/2
-          {AI95-00385-01AI95-00385-01} {AI95-00406-01AI95-00406-01} A
-          stand-alone object may have an anonymous access type.
+          {<AI95-00385-01AI95-00385-01>} {<AI95-00406-01AI95-00406-01>}
+          A stand-alone object may have an anonymous access type.
 
                      _Wording Changes from Ada 95_
 
 33.i/2
-          {8652/00028652/0002} {AI95-00171-01AI95-00171-01} Corrigendum:
-          Corrected wording to say that per-object constraints are
-          elaborated (not evaluated).
+          {<8652/00028652/0002>} {<AI95-00171-01AI95-00171-01>}
+          Corrigendum: Corrected wording to say that per-object
+          constraints are elaborated (not evaluated).
 
 33.j/2
-          {AI95-00373-01AI95-00373-01} The rules for evaluating default
-          initialization have been tightened.  In particular, components
-          whose default initialization can refer to the rest of the
-          object are required to be initialized last.
+          {<AI95-00373-01AI95-00373-01>} The rules for evaluating
+          default initialization have been tightened.  In particular,
+          components whose default initialization can refer to the rest
+          of the object are required to be initialized last.
 
 33.k/2
-          {AI95-00433-01AI95-00433-01} Added examples of various new
+          {<AI95-00433-01AI95-00433-01>} Added examples of various new
           constructs.
 
                        _Extensions to Ada 2005_
 
 33.l/3
-          {AI05-0183-1AI05-0183-1} An optional aspect_specification can
-          be used in an object_declaration.  This is described in *note
-          13.1.1::.
+          {<AI05-0183-1AI05-0183-1>} An optional aspect_specification
+          can be used in an object_declaration.  This is described in
+          *note 13.1.1::.
 
                     _Wording Changes from Ada 2005_
 
 33.m/3
-          {AI05-0228-1AI05-0228-1} Implicit initial values can now be
+          {<AI05-0228-1AI05-0228-1>} Implicit initial values can now be
           given for scalar types and for scalar array components, using
           the Default_Value (see *note 3.5::) and
           Default_Component_Value (see *note 3.6::) aspects; the
@@ -7826,44 +7835,44 @@ File: aarm2012.info,  Node: 3.3.2,  Prev: 3.3.1,  Up: 
3.3
 A number_declaration declares a named number.
 
 1.a/3
-          Discussion: {AI05-0299-1AI05-0299-1} If a value or other
-          property of a construct is required to be static that means it
-          is required to be determined prior to execution.  A static
-          expression is an expression whose value is computed at compile
-          time and is usable in contexts where the actual value might
-          affect the legality of the construct.  This is fully defined
-          in subclause *note 4.9::.
+          Discussion: {<AI05-0299-1AI05-0299-1>} If a value or other
+          property of a construct is required to be <static> that means
+          it is required to be determined prior to execution.  A
+          <static> expression is an expression whose value is computed
+          at compile time and is usable in contexts where the actual
+          value might affect the legality of the construct.  This is
+          fully defined in subclause *note 4.9::.
 
                                _Syntax_
 
 2
      number_declaration ::=
-          defining_identifier_list : constant := static_expression;
+          defining_identifier_list : constant := <static_>expression;
 
                         _Name Resolution Rules_
 
 3
-The static_expression given for a number_declaration is expected to be
+The <static_>expression given for a number_declaration is expected to be
 of any numeric type.
 
                            _Legality Rules_
 
 4/3
-{AI05-0299-1AI05-0299-1} The static_expression given for a number
+{<AI05-0299-1AI05-0299-1>} The <static_>expression given for a number
 declaration shall be a static expression, as defined by subclause *note
 4.9::.
 
                           _Static Semantics_
 
 5
-The named number denotes a value of type universal_integer if the type
-of the static_expression is an integer type.  The named number denotes a
-value of type universal_real if the type of the static_expression is a
-real type.
+The named number denotes a value of type <universal_integer> if the type
+of the <static_>expression is an integer type.  The named number denotes
+a value of type <universal_real> if the type of the <static_>expression
+is a real type.
 
 6
 The value denoted by the named number is the value of the
-static_expression, converted to the corresponding universal type. 
+<static_>expression, converted to the corresponding universal type.  
 
                           _Dynamic Semantics_
 
@@ -7871,22 +7880,22 @@ static_expression, converted to the corresponding 
universal type.
 The elaboration of a number_declaration has no effect.
 
 7.a
-          Proof: Since the static_expression was evaluated at compile
+          Proof: Since the <static_>expression was evaluated at compile
           time.
 
                               _Examples_
 
 8
-Examples of number declarations:
+<Examples of number declarations:>
 
 9
-     Two_Pi        : constant := 2.0*Ada.Numerics.Pi;   -- a real number (see 
*note A.5::)
+     Two_Pi        : constant := 2.0*Ada.Numerics.Pi;   --< a real number (see 
*note A.5::)>
 
 10/2
-     {AI95-00433-01AI95-00433-01} Max           : constant := 500;             
      -- an integer number
-     Max_Line_Size : constant := Max/6;                 -- the integer 83
-     Power_16      : constant := 2**16;                 -- the integer 65_536
-     One, Un, Eins : constant := 1;                     -- three different 
names for 1
+     {<AI95-00433-01AI95-00433-01>} Max           : constant := 500;           
        --< an integer number>
+     Max_Line_Size : constant := Max/6;                 --< the integer 83>
+     Power_16      : constant := 2**16;                 --< the integer 65_536>
+     One, Un, Eins : constant := 1;                     --< three different 
names for 1>
 
                         _Extensions to Ada 83_
 
@@ -7918,10 +7927,10 @@ File: aarm2012.info,  Node: 3.4,  Next: 3.5,  Prev: 
3.3,  Up: 3
 =============================
 
 1/2
-{AI95-00401-01AI95-00401-01} {AI95-00419-01AI95-00419-01} A
-derived_type_definition defines a derived type (and its first subtype)
-whose characteristics are derived from those of a parent type, and
-possibly from progenitor types. 
+{<AI95-00401-01AI95-00401-01>} {<AI95-00419-01AI95-00419-01>} A
+derived_type_definition defines a <derived type> (and its first subtype)
+whose characteristics are <derived> from those of a parent type, and
+possibly from progenitor types.  
 
 1.a/2
           Glossary entry: A derived type is a type defined in terms of
@@ -7935,12 +7944,12 @@ possibly from progenitor types.
           (directly or indirectly) form a derivation class.
 
 1.1/2
-{AI95-00442-01AI95-00442-01} A class of types is a set of types that is
-closed under derivation; that is, if the parent or a progenitor type of
-a derived type belongs to a class, then so does the derived type.  By
+{<AI95-00442-01AI95-00442-01>} A <class of types> is a set of types that
+is closed under derivation; that is, if the parent or a progenitor type
+of a derived type belongs to a class, then so does the derived type.  By
 saying that a particular group of types forms a class, we are saying
 that all derivatives of a type in the set inherit the characteristics
-that define that set.  The more general term category of types is used
+that define that set.  The more general term <category of types> is used
 for a set of types whose defining characteristics are not necessarily
 inherited by derivatives; for example, limited, abstract, and interface
 are all categories of types, but not classes of types.
@@ -7951,19 +7960,19 @@ are all categories of types, but not classes of types.
                                _Syntax_
 
 2/2
-     {AI95-00251-01AI95-00251-01} {AI95-00419-01AI95-00419-01}
+     {<AI95-00251-01AI95-00251-01>} {<AI95-00419-01AI95-00419-01>}
      derived_type_definition ::=
-         [abstract] [limited] new parent_subtype_indication [[and 
+         [abstract] [limited] new <parent_>subtype_indication [[and 
      interface_list] record_extension_part]
 
                            _Legality Rules_
 
 3/2
-{AI95-00251-01AI95-00251-01} {AI95-00401-01AI95-00401-01}
-{AI95-00419-01AI95-00419-01} The parent_subtype_indication defines the
-parent subtype; its type is the parent type.  The interface_list defines
-the progenitor types (see *note 3.9.4::).  A derived type has one parent
-type and zero or more progenitor types.
+{<AI95-00251-01AI95-00251-01>} {<AI95-00401-01AI95-00401-01>}
+{<AI95-00419-01AI95-00419-01>} The <parent_>subtype_indication defines
+the <parent subtype>; its type is the <parent type>.  The interface_list
+defines the progenitor types (see *note 3.9.4::).  A derived type has
+one parent type and zero or more progenitor types.
 
 3.a/2
           Glossary entry: The parent of a derived type is the first type
@@ -7992,17 +8001,17 @@ have to precede the derived_type_definition.]
           subsequently became nonlimited.
 
 5/2
-{AI95-00401-01AI95-00401-01} If there is a record_extension_part, the
-derived type is called a record extension of the parent type.  A
+{<AI95-00401-01AI95-00401-01>} If there is a record_extension_part, the
+derived type is called a <record extension> of the parent type.  A
 record_extension_part shall be provided if and only if the parent type
 is a tagged type.  [An interface_list shall be provided only if the
 parent type is a tagged type.]
 
 5.a.1/2
-          Proof: {AI95-00401-01AI95-00401-01} The syntax only allows an
-          interface_list to appear with a record_extension_part, and a
-          record_extension_part can only be provided if the parent type
-          is a tagged type.  We give the last sentence anyway for
+          Proof: {<AI95-00401-01AI95-00401-01>} The syntax only allows
+          an interface_list to appear with a record_extension_part, and
+          a record_extension_part can only be provided if the parent
+          type is a tagged type.  We give the last sentence anyway for
           completeness.
 
 5.a
@@ -8016,9 +8025,10 @@ parent type is a tagged type.]
           association list.
 
 5.b/2
-          Ramification: {AI95-00114-01AI95-00114-01} This rule needs to
-          be rechecked in the visible part of an instance of a generic
-          unit because of the "only if" part of the rule.  For example:
+          Ramification: {<AI95-00114-01AI95-00114-01>} This rule needs
+          to be rechecked in the visible part of an instance of a
+          generic unit because of the "only if" part of the rule.  For
+          example:
 
 5.c/2
                generic
@@ -8028,10 +8038,10 @@ parent type is a tagged type.]
                end P;
 
 5.d/2
-               package I is new P (Some_Tagged_Type); -- illegal
+               package I is new P (Some_Tagged_Type); -- <illegal>
 
 5.e/2
-          {AI95-00114-01AI95-00114-01} The instantiation is illegal
+          {<AI95-00114-01AI95-00114-01>} The instantiation is illegal
           because a tagged type is being extended in the visible part
           without a record_extension_part.  Note that this is legal in
           the private part or body of an instance, both to avoid a
@@ -8046,18 +8056,18 @@ parent type is a tagged type.]
           is illegal).
 
 5.1/3
-{AI95-00419-01AI95-00419-01} {AI05-0096-1AI05-0096-1} If the reserved
-word limited appears in a derived_type_definition, the parent type shall
-be a limited type.  If the parent type is a tagged formal type, then in
-addition to the places where Legality Rules normally apply (see *note
-12.3::), this rule applies also in the private part of an instance of a
-generic unit.
+{<AI95-00419-01AI95-00419-01>} {<AI05-0096-1AI05-0096-1>} If the
+reserved word limited appears in a derived_type_definition, the parent
+type shall be a limited type.  If the parent type is a tagged formal
+type, then in addition to the places where Legality Rules normally apply
+(see *note 12.3::), this rule applies also in the private part of an
+instance of a generic unit.
 
 5.g/2
           Reason: We allow limited because we don't inherit limitedness
           from interfaces, so we must have a way to derive a limited
           type from interfaces.  The word limited has to be legal when
-          the parent could be an interface, and that includes generic
+          the parent <could be> an interface, and that includes generic
           formal abstract types.  Since we have to allow it in this
           case, we might as well allow it everywhere as documentation,
           to make it explicit that the type is limited.
@@ -8088,8 +8098,8 @@ generic unit.
 6
 The first subtype of the derived type is unconstrained if a
 known_discriminant_part is provided in the declaration of the derived
-type, or if the parent subtype is unconstrained. Otherwise, the
-constraint of the first subtype corresponds to that of the parent
+type, or if the parent subtype is unconstrained.  Otherwise, the
+constraint of the first subtype <corresponds> to that of the parent
 subtype in the following sense: it is the same as that of the parent
 subtype except that for a range constraint (implicit or explicit), the
 value of each bound of its range is replaced by the corresponding value
@@ -8102,25 +8112,25 @@ of the derived type.
           3.5.9::, "*note 3.5.9:: Fixed Point Types".
 
 6.1/2
-{AI95-00231-01AI95-00231-01} The first subtype of the derived type
+{<AI95-00231-01AI95-00231-01>} The first subtype of the derived type
 excludes null (see *note 3.10::) if and only if the parent subtype
 excludes null.
 
 7/3
-{AI05-0110-1AI05-0110-1} The characteristics and implicitly declared
+{<AI05-0110-1AI05-0110-1>} The <characteristics> and implicitly declared
 primitive subprograms of the derived type are defined as follows:
 
 7.a/3
-          Ramification: {AI05-0110-1AI05-0110-1} The characteristics of
-          a type do not include its primitive subprograms (primitive
+          Ramification: {<AI05-0110-1AI05-0110-1>} The characteristics
+          of a type do not include its primitive subprograms (primitive
           subprograms include predefined operators).  The rules
           governing availability/visibility and inheritance of
           characteristics are separate from those for primitive
           subprograms.
 
 8/2
-   * {AI95-00251-01AI95-00251-01} {AI95-00401-01AI95-00401-01}
-     {AI95-00442-01AI95-00442-01} [If the parent type or a progenitor
+   * {<AI95-00251-01AI95-00251-01>} {<AI95-00401-01AI95-00401-01>}
+     {<AI95-00442-01AI95-00442-01>} [If the parent type or a progenitor
      type belongs to a class of types, then the derived type also
      belongs to that class.]  The following sets of types, as well as
      any higher-level sets composed from them, are classes in this
@@ -8167,16 +8177,16 @@ primitive subprograms of the derived type are defined 
as follows:
                known_discriminant_part, if there is one; otherwise, each
                discriminant of the parent type (implicitly declared in
                the same order with the same specifications) -- in the
-               latter case, the discriminants are said to be inherited,
-               or if unknown in the parent, are also unknown in the
-               derived type;
+               latter case, the discriminants are said to be
+               <inherited>, or if unknown in the parent, are also
+               unknown in the derived type;
 
 12
              * Each nondiscriminant component, entry, and protected
                subprogram of the parent type, implicitly declared in the
                same order with the same declarations; these components,
                entries, and protected subprograms are said to be
-               inherited;
+               <inherited>;
 
 12.a
           Ramification: The profiles of entries and protected
@@ -8206,10 +8216,11 @@ primitive subprograms of the derived type are defined 
as follows:
 
 14.b
           Ramification: In most cases, these things are implicitly
-          declared immediately following the parent subtype_indication.
-          However, *note 7.3.1::, "*note 7.3.1:: Private Operations"
-          defines some cases in which they are implicitly declared
-          later, and some cases in which the are not declared at all.
+          declared <immediately> following the parent
+          subtype_indication.  However, *note 7.3.1::, "*note 7.3.1::
+          Private Operations" defines some cases in which they are
+          implicitly declared later, and some cases in which the are not
+          declared at all.
 
 14.c
           Discussion: The place of the implicit declarations of
@@ -8223,7 +8234,7 @@ primitive subprograms of the derived type are defined as 
follows:
           parent type.
 
 15/2
-   * This paragraph was deleted.{AI95-00419-01AI95-00419-01}
+   * <This paragraph was deleted.>{<AI95-00419-01AI95-00419-01>}
 
 16
    * [For each predefined operator of the parent type, there is a
@@ -8252,12 +8263,12 @@ primitive subprograms of the derived type are defined 
as follows:
           subprograms.
 
 17/2
-   * {AI95-00401-01AI95-00401-01} For each user-defined primitive
+   * {<AI95-00401-01AI95-00401-01>} For each user-defined primitive
      subprogram (other than a user-defined equality operator -- see
      below) of the parent type or of a progenitor type that already
      exists at the place of the derived_type_definition, there exists a
-     corresponding inherited primitive subprogram of the derived type
-     with the same defining name. Primitive user-defined equality
+     corresponding <inherited> primitive subprogram of the derived type
+     with the same defining name.  Primitive user-defined equality
      operators of the parent type and any progenitor types are also
      inherited by the derived type, except when the derived type is a
      nonlimited record extension, and the inherited operator would have
@@ -8265,7 +8276,7 @@ primitive subprograms of the derived type are defined as 
follows:
      corresponding predefined equality operator; in this case, the
      user-defined equality operator is not inherited, but is rather
      incorporated into the implementation of the predefined equality
-     operator of the record extension (see *note 4.5.2::). 
+     operator of the record extension (see *note 4.5.2::).  
 
 17.a
           Ramification: We say "...already exists..."  rather than "is
@@ -8293,7 +8304,7 @@ primitive subprograms of the derived type are defined as 
follows:
           predefined equality operator to take its place.
 
 17.d/2
-          Ramification: {AI95-00114-01AI95-00114-01} Because
+          Ramification: {<AI95-00114-01AI95-00114-01>} Because
           user-defined equality operators are not inherited by
           nonlimited record extensions, the formal parameter names of =
           and /= revert to Left and Right, even if different formal
@@ -8301,21 +8312,21 @@ primitive subprograms of the derived type are defined 
as follows:
           operators of the parent type.
 
 17.e/2
-          Discussion: {AI95-00401-01AI95-00401-01} This rule only
+          Discussion: {<AI95-00401-01AI95-00401-01>} This rule only
           describes what operations are inherited; the rules that
           describe what happens when there are conflicting inherited
           subprograms are found in *note 8.3::.
 
 18/3
-     {AI95-00401-01AI95-00401-01} {AI05-0164-1AI05-0164-1}
-     {AI05-0240-1AI05-0240-1} The profile of an inherited subprogram
+     {<AI95-00401-01AI95-00401-01>} {<AI05-0164-1AI05-0164-1>}
+     {<AI05-0240-1AI05-0240-1>} The profile of an inherited subprogram
      (including an inherited enumeration literal) is obtained from the
      profile of the corresponding (user-defined) primitive subprogram of
      the parent or progenitor type, after systematic replacement of each
      subtype of its profile (see *note 6.1::) that is of the parent or
      progenitor type, other than those subtypes found in the designated
-     profile of an access_definition, with a corresponding subtype of
-     the derived type. For a given subtype of the parent or progenitor
+     profile of an access_definition, with a <corresponding subtype> of
+     the derived type.  For a given subtype of the parent or progenitor
      type, the corresponding subtype of the derived type is defined as
      follows:
 
@@ -8336,7 +8347,7 @@ primitive subprograms of the derived type are defined as 
follows:
                is not a record extension, then the corresponding subtype
                is constrained to those values that when converted to the
                parent type belong to the given subtype (see *note
-               4.6::). 
+               4.6::).  
 
 21.a
           Reason: An inherited subprogram of an untagged type has an
@@ -8347,7 +8358,7 @@ primitive subprograms of the derived type are defined as 
follows:
           undesirable implementation burden.
 
 21.b/3
-          {AI05-0164-1AI05-0164-1} Note that the exception to
+          {<AI05-0164-1AI05-0164-1>} Note that the exception to
           substitution of the parent or progenitor type applies only in
           the profiles of anonymous access-to-subprogram types.  The
           exception is necessary to avoid calling an
@@ -8355,7 +8366,7 @@ primitive subprograms of the derived type are defined as 
follows:
           than expected by the actual routine.
 
 22/2
-     {AI95-00401-01AI95-00401-01} The same formal parameters have
+     {<AI95-00401-01AI95-00401-01>} The same formal parameters have
      default_expressions in the profile of the inherited subprogram.
      [Any type mismatch due to the systematic replacement of the parent
      or progenitor type by the derived type is handled as part of the
@@ -8363,7 +8374,7 @@ primitive subprograms of the derived type are defined as 
follows:
      *note 6.4.1::.]
 
 22.a/2
-          Reason: {AI95-00401-01AI95-00401-01} We don't introduce the
+          Reason: {<AI95-00401-01AI95-00401-01>} We don't introduce the
           type conversion explicitly here since conversions to record
           extensions or on access parameters are not generally legal.
           Furthermore, any type conversion would just be "undone" since
@@ -8373,12 +8384,12 @@ primitive subprograms of the derived type are defined 
as follows:
           subprograms of an interface.)
 
 23/2
-{AI95-00401-01AI95-00401-01} If a primitive subprogram of the parent or
-progenitor type is visible at the place of the derived_type_definition,
-then the corresponding inherited subprogram is implicitly declared
-immediately after the derived_type_definition.  Otherwise, the inherited
-subprogram is implicitly declared later or not at all, as explained in
-*note 7.3.1::.
+{<AI95-00401-01AI95-00401-01>} If a primitive subprogram of the parent
+or progenitor type is visible at the place of the
+derived_type_definition, then the corresponding inherited subprogram is
+implicitly declared immediately after the derived_type_definition.
+Otherwise, the inherited subprogram is implicitly declared later or not
+at all, as explained in *note 7.3.1::.
 
 24
 A derived type can also be defined by a private_extension_declaration
@@ -8403,13 +8414,13 @@ S0027.) depends on a discriminant, then only those 
expressions that do
 not depend on a discriminant are evaluated.
 
 26.a/2
-          Discussion: {AI95-00251-01AI95-00251-01} We don't mention the
-          interface_list, because it does not need elaboration (see
+          Discussion: {<AI95-00251-01AI95-00251-01>} We don't mention
+          the interface_list, because it does not need elaboration (see
           *note 3.9.4::).  This is consistent with the handling of
           discriminant_parts, which aren't elaborated either.
 
 27/2
-{AI95-00391-01AI95-00391-01} {AI95-00401-01AI95-00401-01} For the
+{<AI95-00391-01AI95-00391-01>} {<AI95-00401-01AI95-00401-01>} For the
 execution of a call on an inherited subprogram, a call on the
 corresponding primitive subprogram of the parent or progenitor type is
 performed; the normal conversion of each actual parameter to the subtype
@@ -8419,10 +8430,9 @@ subprogram is the derived type, the result of calling 
the subprogram of
 the parent or progenitor is converted to the derived type, or in the
 case of a null extension, extended to the derived type using the
 equivalent of an extension_aggregate with the original result as the
-ancestor_part and null record as the record_component_association_list. 
-
+ancestor_part and null record as the record_component_association_list.
 27.a/2
-          Discussion: {AI95-00391-01AI95-00391-01} If an inherited
+          Discussion: {<AI95-00391-01AI95-00391-01>} If an inherited
           function returns the derived type, and the type is a nonnull
           record extension, then the inherited function shall be
           overridden, unless the type is abstract (in which case the
@@ -8441,7 +8451,7 @@ ancestor_part and null record as the 
record_component_association_list.
      17  Evaluating an inherited enumeration literal is equivalent to
      evaluating the corresponding enumeration literal of the parent
      type, and then converting the result to the derived type.  This
-     follows from their equivalence to parameterless functions. 
+     follows from their equivalence to parameterless functions.  
 
 30
      18  A generic subprogram is not a subprogram, and hence cannot be a
@@ -8480,51 +8490,51 @@ ancestor_part and null record as the 
record_component_association_list.
 34.b
                type T1 is range 1..100;
                subtype S1 is T1 range 1..10;
-               procedure P(X : in S1);  -- P is a primitive subprogram
+               procedure P(X : in S1);  <-- P is a primitive subprogram>
                type T2 is new T1 range 11..20;
-               -- implicitly declared:
-               -- procedure P(X : in T2'Base range 1..10);
-               --      X cannot be in T2'First .. T2'Last
+               <-- implicitly declared:>
+               <-- procedure P(X : in T2'Base range 1..10);>
+               <--      X cannot be in T2'First .. T2'Last>
 
 35
      23  If the reserved word abstract is given in the declaration of a
      type, the type is abstract (see *note 3.9.3::).
 
 35.1/2
-     24  {AI95-00251-01AI95-00251-01} {AI95-00401-01AI95-00401-01} An
-     interface type that has a progenitor type "is derived from" that
+     24  {<AI95-00251-01AI95-00251-01>} {<AI95-00401-01AI95-00401-01>}
+     An interface type that has a progenitor type "is derived from" that
      type.  A derived_type_definition, however, never defines an
      interface type.
 
 35.2/2
-     25  {AI95-00345-01AI95-00345-01} It is illegal for the parent type
-     of a derived_type_definition to be a synchronized tagged type.
+     25  {<AI95-00345-01AI95-00345-01>} It is illegal for the parent
+     type of a derived_type_definition to be a synchronized tagged type.
 
 35.a/3
-          Proof: {AI05-0299-1AI05-0299-1} *note 3.9.1:: prohibits record
-          extensions whose parent type is a synchronized tagged type,
-          and this subclause requires tagged types to have a record
-          extension.  Thus there are no legal derivations.  Note that a
-          synchronized interface can be used as a progenitor in an
-          interface_type_definition as well as in task and protected
+          Proof: {<AI05-0299-1AI05-0299-1>} *note 3.9.1:: prohibits
+          record extensions whose parent type is a synchronized tagged
+          type, and this subclause requires tagged types to have a
+          record extension.  Thus there are no legal derivations.  Note
+          that a synchronized interface can be used as a progenitor in
+          an interface_type_definition as well as in task and protected
           types, but we do not allow concrete extensions of any
           synchronized tagged type.
 
                               _Examples_
 
 36
-Examples of derived type declarations:
+<Examples of derived type declarations:>
 
 37
-     type Local_Coordinate is new Coordinate;   --  two different types
-     type Midweek is new Day range Tue .. Thu;  --  see *note 3.5.1::
-     type Counter is new Positive;              --  same range as Positive 
+     type Local_Coordinate is new Coordinate;   --<  two different types>
+     type Midweek is new Day range Tue .. Thu;  --<  see *note 3.5.1::>
+     type Counter is new Positive;              --<  same range as Positive >
 
 38
-     type Special_Key is new Key_Manager.Key;   --  see *note 7.3.1::
-       -- the inherited subprograms have the following specifications: 
-       --         procedure Get_Key(K : out Special_Key);
-       --         function "<"(X,Y : Special_Key) return Boolean;
+     type Special_Key is new Key_Manager.Key;   --<  see *note 7.3.1::>
+       --< the inherited subprograms have the following specifications: >
+       --<         procedure Get_Key(K : out Special_Key);>
+       --<         function "<"(X,Y : Special_Key) return Boolean;>
 
                      _Inconsistencies With Ada 83_
 
@@ -8552,18 +8562,18 @@ Examples of derived type declarations:
                      type T is (A, B, C, D);
                      function F( X : T := A ) return Integer;
                      type NT is new T;
-                     -- inherits F as
-                     -- function F( X : NT := A ) return Integer;
-                     -- in Ada 95 only
+                     --< inherits F as>
+                     --< function F( X : NT := A ) return Integer;>
+                     --< in Ada 95 only>
                      ...
                   end P;
                   ...
-                  use P;  -- Only one declaration of F from P is use-visible in
-                          -- Ada 83;  two declarations of F are use-visible in
-                          -- Ada 95.
+                  use P;  --< Only one declaration of F from P is use-visible 
in>
+                          --< Ada 83;  two declarations of F are use-visible 
in>
+                          --< Ada 95.>
                begin
                   ...
-                  if F > 1 then ... -- legal in Ada 83, ambiguous in Ada 95
+                  if F > 1 then ... --< legal in Ada 83, ambiguous in Ada 95>
 
                         _Extensions to Ada 83_
 
@@ -8594,13 +8604,13 @@ Examples of derived type declarations:
                         _Extensions to Ada 95_
 
 38.i/2
-          {AI05-0190-1AI05-0190-1} {AI95-00251-01AI95-00251-01}
-          {AI95-00401-01AI95-00401-01} A derived type may inherit from
+          {<AI05-0190-1AI05-0190-1>} {<AI95-00251-01AI95-00251-01>}
+          {<AI95-00401-01AI95-00401-01>} A derived type may inherit from
           multiple (interface) progenitors, as well as the parent type
           -- see *note 3.9.4::, "*note 3.9.4:: Interface Types".
 
 38.j/2
-          {AI95-00419-01AI95-00419-01} A derived type may specify that
+          {<AI95-00419-01AI95-00419-01>} A derived type may specify that
           it is a limited type.  This is required for interface
           ancestors (from which limitedness is not inherited), but it is
           generally useful as documentation of limitedness.
@@ -8608,12 +8618,12 @@ Examples of derived type declarations:
                      _Wording Changes from Ada 95_
 
 38.k/2
-          {AI95-00391-01AI95-00391-01} Defined the result of functions
+          {<AI95-00391-01AI95-00391-01>} Defined the result of functions
           for null extensions (which we no longer require to be
           overridden - see *note 3.9.3::).
 
 38.l/2
-          {AI95-00442-01AI95-00442-01} Defined the term "category of
+          {<AI95-00442-01AI95-00442-01>} Defined the term "category of
           types" and used it in wording elsewhere; also specified the
           language-defined categories that form classes of types (this
           was never normatively specified in Ada 95).
@@ -8621,7 +8631,7 @@ Examples of derived type declarations:
                    _Incompatibilities With Ada 2005_
 
 38.m/3
-          {AI05-0096-1AI05-0096-1} Correction: Added a (re)check that
+          {<AI05-0096-1AI05-0096-1>} Correction: Added a (re)check that
           limited type extensions never are derived from nonlimited
           types in generic private parts.  This is disallowed as it
           would make it possible to pass a limited object to a
@@ -8632,14 +8642,14 @@ Examples of derived type declarations:
                     _Wording Changes from Ada 2005_
 
 38.n/3
-          {AI05-0110-1AI05-0110-1} Correction: Added wording to clarify
-          that the characteristics of derived types are formally defined
-          here.  (This is the only place in the Standard that actually
-          spells out what sorts of things are actually characteristics,
-          which is rather important.)
+          {<AI05-0110-1AI05-0110-1>} Correction: Added wording to
+          clarify that the characteristics of derived types are formally
+          defined here.  (This is the only place in the Standard that
+          actually spells out what sorts of things are actually
+          characteristics, which is rather important.)
 
 38.o/3
-          {AI05-0164-1AI05-0164-1} Correction: Added wording to ensure
+          {<AI05-0164-1AI05-0164-1>} Correction: Added wording to ensure
           that anonymous access-to-subprogram types don't get modified
           on derivation.
 
@@ -8655,20 +8665,21 @@ File: aarm2012.info,  Node: 3.4.1,  Up: 3.4
 
 1
 In addition to the various language-defined classes of types, types can
-be grouped into derivation classes.
+be grouped into <derivation classes>.
 
                           _Static Semantics_
 
 2/2
-{AI95-00251-01AI95-00251-01} {AI95-00401-01AI95-00401-01} A derived type
-is derived from its parent type directly; it is derived indirectly from
-any type from which its parent type is derived.  A derived type,
-interface type, type extension, task type, protected type, or formal
-derived type is also derived from every ancestor of each of its
-progenitor types, if any. The derivation class of types for a type T
-(also called the class rooted at T) is the set consisting of T (the root
-type of the class) and all types derived from T (directly or indirectly)
-plus any associated universal or class-wide types (defined below).
+{<AI95-00251-01AI95-00251-01>} {<AI95-00401-01AI95-00401-01>} A derived
+type is <derived from> its parent type <directly>; it is derived
+<indirectly> from any type from which its parent type is derived.  A
+derived type, interface type, type extension, task type, protected type,
+or formal derived type is also derived from every ancestor of each of
+its progenitor types, if any.  The derivation class of types for a type
+<T> (also called the class <rooted> at <T>) is the set consisting of <T>
+(the <root type> of the class) and all types derived from <T> (directly
+or indirectly) plus any associated universal or class-wide types
+(defined below).
 
 2.a
           Discussion: Note that the definition of "derived from" is a
@@ -8678,48 +8689,48 @@ plus any associated universal or class-wide types 
(defined below).
 
 2.b
           To be honest: By the class-wide type "associated" with a type
-          T, we mean the type T'Class.  Similarly, the universal type
-          associated with root_integer, root_real, and root_fixed are
-          universal_integer, universal_real, and universal_fixed,
-          respectively.
+          <T>, we mean the type <T>'Class.  Similarly, the universal
+          type associated with <root_integer>, <root_real>, and
+          <root_fixed> are <universal_integer>, <universal_real>, and
+          <universal_fixed>, respectively.
 
 3/2
-{AI95-00230-01AI95-00230-01} Every type is either a specific type, a
-class-wide type, or a universal type. A specific type is one defined by
-a type_declaration, a formal_type_declaration, or a full type definition
-embedded in another construct.  Class-wide and universal types are
-implicitly defined, to act as representatives for an entire class of
-types, as follows:
+{<AI95-00230-01AI95-00230-01>} Every type is either a <specific> type, a
+<class-wide> type, or a <universal> type.  A specific type is one
+defined by a type_declaration, a formal_type_declaration, or a full type
+definition embedded in another construct.  Class-wide and universal
+types are implicitly defined, to act as representatives for an entire
+class of types, as follows:
 
 3.a
-          To be honest: The root types root_integer, root_real, and
-          root_fixed are also specific types.  They are declared in the
-          specification of package Standard.
+          To be honest: The root types <root_integer>, <root_real>, and
+          <root_fixed> are also specific types.  They are declared in
+          the specification of package Standard.
 
 4
 Class-wide types
                Class-wide types are defined for [(and belong to)] each
                derivation class rooted at a tagged type (see *note
-               3.9::).  Given a subtype S of a tagged type T, S'Class is
-               the subtype_mark for a corresponding subtype of the
-               tagged class-wide type T'Class.  Such types are called
+               3.9::).  Given a subtype S of a tagged type <T>, S'Class
+               is the subtype_mark for a corresponding subtype of the
+               tagged class-wide type <T>'Class.  Such types are called
                "class-wide" because when a formal parameter is defined
-               to be of a class-wide type T'Class, an actual parameter
-               of any type in the derivation class rooted at T is
+               to be of a class-wide type <T>'Class, an actual parameter
+               of any type in the derivation class rooted at <T> is
                acceptable (see *note 8.6::).
 
 5
-               The set of values for a class-wide type T'Class is the
+               The set of values for a class-wide type <T>'Class is the
                discriminated union of the set of values of each specific
-               type in the derivation class rooted at T (the tag acts as
-               the implicit discriminant -- see *note 3.9::).
+               type in the derivation class rooted at <T> (the tag acts
+               as the implicit discriminant -- see *note 3.9::).
                Class-wide types have no primitive subprograms of their
                own.  However, as explained in *note 3.9.2::, operands of
-               a class-wide type T'Class can be used as part of a
-               dispatching call on a primitive subprogram of the type T.
-               The only components [(including discriminants)] of
-               T'Class that are visible are those of T. If S is a first
-               subtype, then S'Class is a first subtype.
+               a class-wide type <T>'Class can be used as part of a
+               dispatching call on a primitive subprogram of the type
+               <T>.  The only components [(including discriminants)] of
+               <T>'Class that are visible are those of <T>.  If S is a
+               first subtype, then S'Class is a first subtype.
 
 5.a
           Reason: We want S'Class to be a first subtype when S is, so
@@ -8727,20 +8738,21 @@ Class-wide types
           "for S'Class'Output use ...;" will be legal.
 
 6/2
-{AI95-00230-01AI95-00230-01} Universal types
+{<AI95-00230-01AI95-00230-01>} Universal types
                Universal types are defined for [(and belong to)] the
                integer, real, fixed point, and access classes, and are
                referred to in this standard as respectively,
-               universal_integer, universal_real, universal_fixed, and
-               universal_access.  These are analogous to class-wide
-               types for these language-defined elementary classes.  As
-               with class-wide types, if a formal parameter is of a
-               universal type, then an actual parameter of any type in
-               the corresponding class is acceptable.  In addition, a
-               value of a universal type (including an integer or real
-               numeric_literal, or the literal null) is "universal" in
-               that it is acceptable where some particular type in the
-               class is expected (see *note 8.6::).
+               <universal_integer>, <universal_real>, <universal_fixed>,
+               and <universal_access>.  These are analogous to
+               class-wide types for these language-defined elementary
+               classes.  As with class-wide types, if a formal parameter
+               is of a universal type, then an actual parameter of any
+               type in the corresponding class is acceptable.  In
+               addition, a value of a universal type (including an
+               integer or real numeric_literal, or the literal null) is
+               "universal" in that it is acceptable where some
+               particular type in the class is expected (see *note
+               8.6::).
 
 7
                The set of values of a universal type is the
@@ -8758,14 +8770,14 @@ Class-wide types
           specific to universal and back.
 
 7.b/2
-          {AI95-00230-01AI95-00230-01} We considered defining class-wide
-          or perhaps universal types for all derivation classes, not
-          just tagged classes and these four elementary classes.
-          However, this was felt to overly weaken the strong-typing
-          model in some situations.  Tagged types preserve strong type
-          distinctions thanks to the run-time tag.  Class-wide or
-          universal types for untagged types would weaken the
-          compile-time type distinctions without providing a
+          {<AI95-00230-01AI95-00230-01>} We considered defining
+          class-wide or perhaps universal types for all derivation
+          classes, not just tagged classes and these four elementary
+          classes.  However, this was felt to overly weaken the
+          strong-typing model in some situations.  Tagged types preserve
+          strong type distinctions thanks to the run-time tag.
+          Class-wide or universal types for untagged types would weaken
+          the compile-time type distinctions without providing a
           compensating run-time-checkable distinction.
 
 7.c
@@ -8776,36 +8788,37 @@ Class-wide types
 
 7.d
           To be honest: Formally, the set of values of a universal type
-          is actually a copy of the undiscriminated union of the values
-          of the types in its class.  This is because we want each value
-          to have exactly one type, with explicit or implicit conversion
-          needed to go between types.  An alternative, consistent model
-          would be to associate a class, rather than a particular type,
-          with a value, even though any given expression would have a
-          particular type.  In that case, implicit type conversions
-          would not generally need to change the value, although an
-          associated subtype conversion might need to.
+          is actually a <copy> of the undiscriminated union of the
+          values of the types in its class.  This is because we want
+          each value to have exactly one type, with explicit or implicit
+          conversion needed to go between types.  An alternative,
+          consistent model would be to associate a class, rather than a
+          particular type, with a value, even though any given
+          expression would have a particular type.  In that case,
+          implicit type conversions would not generally need to change
+          the value, although an associated subtype conversion might
+          need to.
 
 8
 The integer and real numeric classes each have a specific root type in
-addition to their universal type, named respectively root_integer and
-root_real.
+addition to their universal type, named respectively <root_integer> and
+<root_real>.
 
 9
-A class-wide or universal type is said to cover all of the types in its
-class.  A specific type covers only itself.
+A class-wide or universal type is said to <cover> all of the types in
+its class.  A specific type covers only itself.
 
 10/2
-{AI95-00230-01AI95-00230-01} {AI95-00251-01AI95-00251-01} A specific
-type T2 is defined to be a descendant of a type T1 if T2 is the same as
-T1, or if T2 is derived (directly or indirectly) from T1.  A class-wide
-type T2'Class is defined to be a descendant of type T1 if T2 is a
-descendant of T1.  Similarly, the numeric universal types are defined to
-be descendants of the root types of their classes. If a type T2 is a
-descendant of a type T1, then T1 is called an ancestor of T2. An
-ultimate ancestor of a type is an ancestor of that type that is not
-itself a descendant of any other type.  Every untagged type has a unique
-ultimate ancestor.
+{<AI95-00230-01AI95-00230-01>} {<AI95-00251-01AI95-00251-01>} A specific
+type <T2> is defined to be a <descendant> of a type <T1> if <T2> is the
+same as <T1>, or if <T2> is derived (directly or indirectly) from <T1>.
+A class-wide type <T2>'Class is defined to be a descendant of type <T1>
+if <T2> is a descendant of <T1>.  Similarly, the numeric universal types
+are defined to be descendants of the root types of their classes.  If a
+type <T2> is a descendant of a type <T1>, then <T1> is called an
+<ancestor> of <T2>.  An <ultimate ancestor> of a type is an ancestor of
+that type that is not itself a descendant of any other type.  Every
+untagged type has a unique ultimate ancestor.
 
 10.a
           Ramification: A specific type is a descendant of itself.
@@ -8823,7 +8836,7 @@ ultimate ancestor.
           ancestor are all related.  For example:
 
 10.d/2
-             * {AI95-00251-01AI95-00251-01} Each type has at most one
+             * {<AI95-00251-01AI95-00251-01>} Each type has at most one
                parent, and one or more ancestor types; each untagged
                type has exactly one ultimate ancestor.  In Ada 83, the
                term "parent type" was sometimes used more generally to
@@ -8839,9 +8852,9 @@ ultimate ancestor.
                the class (including itself).
 
 10.g
-             * The type root_integer is the root of the integer class,
+             * The type <root_integer> is the root of the integer class,
                and is the ultimate ancestor of all integer types.  A
-               similar statement applies to root_real.
+               similar statement applies to <root_real>.
 
 10.h/2
           Glossary entry: An ancestor of a type is the type itself or,
@@ -8856,7 +8869,7 @@ ultimate ancestor.
 
 11
 An inherited component [(including an inherited discriminant)] of a
-derived type is inherited from a given ancestor of the type if the
+derived type is inherited <from> a given ancestor of the type if the
 corresponding component was inherited by each derived type in the chain
 of derivations going back to the given ancestor.
 
@@ -8865,18 +8878,18 @@ of derivations going back to the given ancestor.
 12
      26  Because operands of a universal type are acceptable to the
      predefined operators of any type in their class, ambiguity can
-     result.  For universal_integer and universal_real, this potential
-     ambiguity is resolved by giving a preference (see *note 8.6::) to
-     the predefined operators of the corresponding root types
-     (root_integer and root_real, respectively).  Hence, in an
+     result.  For <universal_integer> and <universal_real>, this
+     potential ambiguity is resolved by giving a preference (see *note
+     8.6::) to the predefined operators of the corresponding root types
+     (<root_integer> and <root_real>, respectively).  Hence, in an
      apparently ambiguous expression like
 
 13
           1 + 4 < 7
 
 14
-     where each of the literals is of type universal_integer, the
-     predefined operators of root_integer will be preferred over those
+     where each of the literals is of type <universal_integer>, the
+     predefined operators of <root_integer> will be preferred over those
      of other specific integer types, thereby resolving the ambiguity.
 
 14.a
@@ -8889,14 +8902,14 @@ of derivations going back to the given ancestor.
                      _Wording Changes from Ada 95_
 
 14.b/2
-          {AI95-00230-01AI95-00230-01} Updated the wording to define the
-          universal_access type.  This was defined to make null for
-          anonymous access types sensible.
+          {<AI95-00230-01AI95-00230-01>} Updated the wording to define
+          the <universal_access> type.  This was defined to make null
+          for anonymous access types sensible.
 
 14.c/2
-          {AI95-00251-01AI95-00251-01} {AI95-00401-01AI95-00401-01} The
-          definitions of ancestors and descendants were updated to allow
-          multiple ancestors (necessary to support interfaces).
+          {<AI95-00251-01AI95-00251-01>} {<AI95-00401-01AI95-00401-01>}
+          The definitions of ancestors and descendants were updated to
+          allow multiple ancestors (necessary to support interfaces).
 
 
 File: aarm2012.info,  Node: 3.5,  Next: 3.6,  Prev: 3.4,  Up: 3
@@ -8905,11 +8918,11 @@ File: aarm2012.info,  Node: 3.5,  Next: 3.6,  Prev: 
3.4,  Up: 3
 ================
 
 1
-Scalar types comprise enumeration types, integer types, and real types.
-Enumeration types and integer types are called discrete types; each
-value of a discrete type has a position number which is an integer
-value. Integer types and real types are called numeric types.  [All
-scalar types are ordered, that is, all relational operators are
+<Scalar> types comprise enumeration types, integer types, and real
+types.  Enumeration types and integer types are called <discrete> types;
+each value of a discrete type has a <position number> which is an
+integer value.  Integer types and real types are called <numeric> types.
+[All scalar types are ordered, that is, all relational operators are
 predefined for their values.]
 
                                _Syntax_
@@ -8928,16 +8941,17 @@ predefined for their values.]
           be ambiguous.
 
 4
-A range has a lower bound and an upper bound and specifies a subset of
-the values of some scalar type (the type of the range).  A range with
-lower bound L and upper bound R is described by "L ..  R". If R is less
-than L, then the range is a null range, and specifies an empty set of
-values.  Otherwise, the range specifies the values of the type from the
-lower bound to the upper bound, inclusive. A value belongs to a range if
-it is of the type of the range, and is in the subset of values specified
-by the range. A value satisfies a range constraint if it belongs to the
-associated range. One range is included in another if all values that
-belong to the first range also belong to the second.
+A <range> has a <lower bound> and an <upper bound> and specifies a
+subset of the values of some scalar type (the <type of the range>).  A
+range with lower bound L and upper bound R is described by "L ..  R". If
+R is less than L, then the range is a <null range>, and specifies an
+empty set of values.  Otherwise, the range specifies the values of the
+type from the lower bound to the upper bound, inclusive.  A value
+<belongs> to a range if it is of the type of the range, and is in the
+subset of values specified by the range.  A value <satisfies> a range
+constraint if it belongs to the associated range.  One range is
+<included> in another if all values that belong to the first range also
+belong to the second.
 
                         _Name Resolution Rules_
 
@@ -8945,7 +8959,7 @@ belong to the first range also belong to the second.
 For a subtype_indication containing a range_constraint, either directly
 or as part of some other scalar_constraint, the type of the range shall
 resolve to that of the type determined by the subtype_mark of the
-subtype_indication. For a range of a given type, the simple_expressions
+subtype_indication.  For a range of a given type, the simple_expressions
 of the range (likewise, the simple_expressions of the equivalent range
 for a range_attribute_reference) are expected to be of the type of the
 range.
@@ -8957,8 +8971,8 @@ range.
           real_range_specifications.
 
 5.b/3
-          {AI05-0299-1AI05-0299-1} We say "the expected type is ..."  or
-          "the type is expected to be ..."  depending on which reads
+          {<AI05-0299-1AI05-0299-1>} We say "the expected type is ..."
+          or "the type is expected to be ..."  depending on which reads
           better.  They are fundamentally equivalent, and both feed into
           the type resolution rules of subclause *note 8.6::.
 
@@ -8981,7 +8995,7 @@ range.
                           _Static Semantics_
 
 6
-The base range of a scalar type is the range of finite values of the
+The <base range> of a scalar type is the range of finite values of the
 type that can be represented in every unconstrained object of the type;
 it is also the range supported at a minimum for intermediate values
 during the evaluation of expressions involving predefined operators of
@@ -9016,17 +9030,17 @@ the type.
 
 7
 [A constrained scalar subtype is one to which a range constraint
-applies.] The range of a constrained scalar subtype is the range
-associated with the range constraint of the subtype.  The range of an
+applies.]  The <range> of a constrained scalar subtype is the range
+associated with the range constraint of the subtype.  The <range> of an
 unconstrained scalar subtype is the base range of its type.
 
                           _Dynamic Semantics_
 
 8
-A range is compatible with a scalar subtype if and only if it is either
-a null range or each bound of the range belongs to the range of the
-subtype. A range_constraint is compatible with a scalar subtype if and
-only if its range is compatible with the subtype.
+A range is <compatible> with a scalar subtype if and only if it is
+either a null range or each bound of the range belongs to the range of
+the subtype.  A range_constraint is <compatible> with a scalar subtype
+if and only if its range is compatible with the subtype.
 
 8.a
           Ramification: Only range_constraints (explicit or implicit)
@@ -9035,7 +9049,7 @@ only if its range is compatible with the subtype.
           delta_constraints impose conditions on the subtype denoted by
           the subtype_mark in a subtype_indication, but don't impose a
           condition on the values of the subtype being defined.
-          Therefore, a scalar subtype is not called constrained if all
+          Therefore, a scalar subtype is not called <constrained> if all
           that applies to it is a digits_constraint.  Decimal subtypes
           are subtle, because a digits_constraint without a
           range_constraint nevertheless includes an implicit
@@ -9043,15 +9057,15 @@ only if its range is compatible with the subtype.
 
 9
 The elaboration of a range_constraint consists of the evaluation of the
-range. The evaluation of a range determines a lower bound and an upper
+range.  The evaluation of a range determines a lower bound and an upper
 bound.  If simple_expressions are given to specify bounds, the
 evaluation of the range evaluates these simple_expressions in an
-arbitrary order, and converts them to the type of the range. If a
+arbitrary order, and converts them to the type of the range.  If a
 range_attribute_reference is given, the evaluation of the range consists
 of the evaluation of the range_attribute_reference.
 
 10
-Attributes
+<Attributes>
 
 11
 For every scalar subtype S, the following attributes are defined:
@@ -9080,8 +9094,8 @@ S'Range
 15
 S'Base
                S'Base denotes an unconstrained subtype of the type of S.
-               This unconstrained subtype is called the base subtype of
-               the type. 
+               This unconstrained subtype is called the <base subtype>
+               of the type.  
 
 16
 S'Min
@@ -9089,7 +9103,7 @@ S'Min
                specification:
 
 17
-                    function S'Min(Left, Right : S'Base)
+                    function S'Min(<Left>, <Right> : S'Base)
                       return S'Base
 
 18
@@ -9110,7 +9124,7 @@ S'Max
                specification:
 
 20
-                    function S'Max(Left, Right : S'Base)
+                    function S'Max(<Left>, <Right> : S'Base)
                       return S'Base
 
 21
@@ -9123,27 +9137,27 @@ S'Succ
                specification:
 
 23
-                    function S'Succ(Arg : S'Base)
+                    function S'Succ(<Arg> : S'Base)
                       return S'Base
 
 24
                For an enumeration type, the function returns the value
                whose position number is one more than that of the value
-               of Arg; Constraint_Error is raised if there is no such
+               of <Arg>; Constraint_Error is raised if there is no such
                value of the type.  For an integer type, the function
-               returns the result of adding one to the value of Arg.
+               returns the result of adding one to the value of <Arg>.
                For a fixed point type, the function returns the result
-               of adding small to the value of Arg.  For a floating
+               of adding <small> to the value of <Arg>.  For a floating
                point type, the function returns the machine number (as
                defined in *note 3.5.7::) immediately above the value of
-               Arg; Constraint_Error is raised if there is no such
+               <Arg>; Constraint_Error is raised if there is no such
                machine number.
 
 24.a
           Ramification: S'Succ for a modular integer subtype wraps
-          around if the value of Arg is S'Base'Last.  S'Succ for a
+          around if the value of <Arg> is S'Base'Last.  S'Succ for a
           signed integer subtype might raise Constraint_Error if the
-          value of Arg is S'Base'Last, or it might return the
+          value of <Arg> is S'Base'Last, or it might return the
           out-of-base-range value S'Base'Last+1, as is permitted for all
           predefined numeric operations.
 
@@ -9153,43 +9167,43 @@ S'Pred
                specification:
 
 26
-                    function S'Pred(Arg : S'Base)
+                    function S'Pred(<Arg> : S'Base)
                       return S'Base
 
 27
                For an enumeration type, the function returns the value
                whose position number is one less than that of the value
-               of Arg; Constraint_Error is raised if there is no such
+               of <Arg>; Constraint_Error is raised if there is no such
                value of the type.  For an integer type, the function
                returns the result of subtracting one from the value of
-               Arg.  For a fixed point type, the function returns the
-               result of subtracting small from the value of Arg.  For a
-               floating point type, the function returns the machine
-               number (as defined in *note 3.5.7::) immediately below
-               the value of Arg; Constraint_Error is raised if there is
-               no such machine number.
+               <Arg>.  For a fixed point type, the function returns the
+               result of subtracting <small> from the value of <Arg>.
+               For a floating point type, the function returns the
+               machine number (as defined in *note 3.5.7::) immediately
+               below the value of <Arg>; Constraint_Error is raised if
+               there is no such machine number.
 
 27.a
           Ramification: S'Pred for a modular integer subtype wraps
-          around if the value of Arg is S'Base'First.  S'Pred for a
+          around if the value of <Arg> is S'Base'First.  S'Pred for a
           signed integer subtype might raise Constraint_Error if the
-          value of Arg is S'Base'First, or it might return the
+          value of <Arg> is S'Base'First, or it might return the
           out-of-base-range value S'Base'First-1, as is permitted for
           all predefined numeric operations.
 
 27.1/2
 S'Wide_Wide_Image
-               {AI95-00285-01AI95-00285-01} S'Wide_Wide_Image denotes a
-               function with the following specification:
+               {<AI95-00285-01AI95-00285-01>} S'Wide_Wide_Image denotes
+               a function with the following specification:
 
 27.2/2
-                    function S'Wide_Wide_Image(Arg : S'Base)
+                    function S'Wide_Wide_Image(<Arg> : S'Base)
                       return Wide_Wide_String
 
 27.3/2
-               The function returns an image of the value of Arg, that
-               is, a sequence of characters representing the value in
-               display form.  The lower bound of the result is one.
+               The function returns an <image> of the value of <Arg>,
+               that is, a sequence of characters representing the value
+               in display form.  The lower bound of the result is one.
 
 27.4/2
                The image of an integer value is the corresponding
@@ -9210,11 +9224,11 @@ S'Wide_Wide_Image
                corresponding identifier in upper case or the
                corresponding character literal (including the two
                apostrophes); neither leading nor trailing spaces are
-               included.  For a nongraphic character (a value of a
+               included.  For a <nongraphic character> (a value of a
                character type that has no enumeration literal associated
                with it), the result is a corresponding language-defined
                name in upper case (for example, the image of the
-               nongraphic character identified as nul is "NUL" -- the
+               nongraphic character identified as <nul> is "NUL" -- the
                quotes are not part of the image).
 
 27.c/2
@@ -9280,14 +9294,14 @@ S'Wide_Image
                specification:
 
 29
-                    function S'Wide_Image(Arg : S'Base)
+                    function S'Wide_Image(<Arg> : S'Base)
                       return Wide_String
 
 30/3
-               {AI95-00285-01AI95-00285-01} {AI05-0262-1AI05-0262-1}
-               {AI05-0264-1AI05-0264-1} The function returns an image of
-               the value of Arg as a Wide_String.  The lower bound of
-               the result is one.  The image has the same sequence of
+               {<AI95-00285-01AI95-00285-01>} {<AI05-0262-1AI05-0262-1>}
+               {<AI05-0264-1AI05-0264-1>} The function returns an image
+               of the value of <Arg> as a Wide_String.  The lower bound
+               of the result is one.  The image has the same sequence of
                graphic characters as defined for S'Wide_Wide_Image if
                all the graphic characters are defined in Wide_Character;
                otherwise, the sequence of characters is implementation
@@ -9300,7 +9314,7 @@ S'Wide_Image
           characters of S'Wide_Wide_Image are not defined in
           Wide_Character.
 
-               Paragraphs 31 through 34 were moved to Wide_Wide_Image.
+               <Paragraphs 31 through 34 were moved to Wide_Wide_Image.>
 
 35
 S'Image
@@ -9308,19 +9322,19 @@ S'Image
                specification:
 
 36
-                    function S'Image(Arg : S'Base)
+                    function S'Image(<Arg> : S'Base)
                       return String
 
 37/3
-               {AI95-00285-01AI95-00285-01} {AI05-0264-1AI05-0264-1} The
-               function returns an image of the value of Arg as a
+               {<AI95-00285-01AI95-00285-01>} {<AI05-0264-1AI05-0264-1>}
+               The function returns an image of the value of <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_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 Arg).
+               of <Arg>).
 
 37.a/2
           Implementation defined: The sequence of characters of the
@@ -9329,33 +9343,33 @@ S'Image
 
 37.1/2
 S'Wide_Wide_Width
-               {AI95-00285-01AI95-00285-01} S'Wide_Wide_Width denotes
+               {<AI95-00285-01AI95-00285-01>} S'Wide_Wide_Width denotes
                the maximum length of a Wide_Wide_String returned by
                S'Wide_Wide_Image over all values of the subtype S. It
                denotes zero for a subtype that has a null range.  Its
-               type is universal_integer.
+               type is <universal_integer>.
 
 38
 S'Wide_Width
                S'Wide_Width denotes the maximum length of a Wide_String
                returned by S'Wide_Image over all values of the subtype
                S. It denotes zero for a subtype that has a null range.
-               Its type is universal_integer.
+               Its type is <universal_integer>.
 
 39
 S'Width
                S'Width denotes the maximum length of a String returned
                by S'Image over all values of the subtype S. It denotes
                zero for a subtype that has a null range.  Its type is
-               universal_integer.
+               <universal_integer>.
 
 39.1/2
 S'Wide_Wide_Value
-               {AI95-00285-01AI95-00285-01} S'Wide_Wide_Value denotes a
-               function with the following specification:
+               {<AI95-00285-01AI95-00285-01>} S'Wide_Wide_Value denotes
+               a function with the following specification:
 
 39.2/2
-                    function S'Wide_Wide_Value(Arg : Wide_Wide_String)
+                    function S'Wide_Wide_Value(<Arg> : Wide_Wide_String)
                       return S'Base
 
 39.3/2
@@ -9364,8 +9378,8 @@ S'Wide_Wide_Value
                spaces.
 
 39.4/3
-               {AI05-0264-1AI05-0264-1} For the evaluation of a call on
-               S'Wide_Wide_Value for an enumeration subtype S, if the
+               {<AI05-0264-1AI05-0264-1>} 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
@@ -9381,8 +9395,8 @@ S'Wide_Wide_Value
           to lump it in with Range_Check.
 
 39.a.2/2
-          To be honest: {8652/00968652/0096}
-          {AI95-00053-01AI95-00053-01} A sequence of characters
+          To be honest: {<8652/00968652/0096>}
+          {<AI95-00053-01AI95-00053-01>} A sequence of characters
           corresponds to the result of S'Wide_Wide_Image if it is the
           same ignoring case.  Thus, the case of an image of a
           nongraphic character does not matter.  For example,
@@ -9391,8 +9405,8 @@ S'Wide_Wide_Value
           returns "NUL" for the nul character.
 
 39.5/3
-               {AI05-0264-1AI05-0264-1} For the evaluation of a call on
-               S'Wide_Wide_Value for an integer subtype S, if the
+               {<AI05-0264-1AI05-0264-1>} 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
@@ -9436,7 +9450,7 @@ S'Wide_Wide_Value
                   * base#.based_numeral#[exponent]
 
 39.12/3
-               {AI05-0264-1AI05-0264-1} with an optional leading sign
+               {<AI05-0264-1AI05-0264-1>} 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,
@@ -9450,7 +9464,7 @@ S'Wide_Value
                specification:
 
 41
-                    function S'Wide_Value(Arg : Wide_String)
+                    function S'Wide_Value(<Arg> : Wide_String)
                       return S'Base
 
 42
@@ -9459,8 +9473,8 @@ S'Wide_Value
                spaces.
 
 43/3
-               {AI95-00285-01AI95-00285-01} {AI05-0264-1AI05-0264-1} For
-               the evaluation of a call on S'Wide_Value for an
+               {<AI95-00285-01AI95-00285-01>} {<AI05-0264-1AI05-0264-1>}
+               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
@@ -9469,16 +9483,16 @@ S'Wide_Value
                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 Wide_String is equivalent to a call on
-               S'Wide_Wide_Value for a corresponding Arg of type
+               <Arg> of type Wide_String is equivalent to a call on
+               S'Wide_Wide_Value for a corresponding <Arg> of type
                Wide_Wide_String.
 
 43.a/2
-          This paragraph was deleted.
+          <This paragraph was deleted.>
 
 43.a.1/2
-          This paragraph was deleted.{8652/00968652/0096}
-          {AI95-00053-01AI95-00053-01}
+          <This paragraph was deleted.>{<8652/00968652/0096>}
+          {<AI95-00053-01AI95-00053-01>}
 
 43.b/2
           Reason: S'Wide_Value is subtly different from
@@ -9491,7 +9505,7 @@ S'Wide_Value
           for numeric subtypes yield the same result given the same
           sequence of characters.
 
-               Paragraphs 44 through 51 were moved to Wide_Wide_Value.
+               <Paragraphs 44 through 51 were moved to Wide_Wide_Value.>
 
 52
 S'Value
@@ -9499,7 +9513,7 @@ S'Value
                specification:
 
 53
-                    function S'Value(Arg : String)
+                    function S'Value(<Arg> : String)
                       return S'Base
 
 54
@@ -9507,57 +9521,57 @@ S'Value
                as a String, ignoring any leading or trailing spaces.
 
 55/3
-               {AI95-00285-01AI95-00285-01} {AI05-0264-1AI05-0264-1} 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 Arg of type String is equivalent to a call
-               on S'Wide_Wide_Value for a corresponding Arg of type
-               Wide_Wide_String.
+               {<AI95-00285-01AI95-00285-01>} {<AI05-0264-1AI05-0264-1>}
+               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 <Arg> of type String
+               is equivalent to a call on S'Wide_Wide_Value for a
+               corresponding <Arg> of type Wide_Wide_String.
 
 55.a/2
-          Reason: {AI95-00285-01AI95-00285-01} S'Value is subtly
+          Reason: {<AI95-00285-01AI95-00285-01>} S'Value is subtly
           different from S'Wide_Wide_Value for enumeration subtypes; see
           the discussion under S'Wide_Value.
 
 55.1/4
-{AI12-0124-1AI12-0124-1} For a prefix X that denotes an object of a
+{<AI12-0124-1AI12-0124-1>} For a prefix X that denotes an object of a
 scalar type[ (after any implicit dereference)], the following attributes
 are defined:
 
 55.2/4
 X'Wide_Wide_Image
-               {AI12-0124-1AI12-0124-1} X'Wide_Wide_Image denotes the
-               result of calling function S'Wide_Wide_Image with Arg
+               {<AI12-0124-1AI12-0124-1>} X'Wide_Wide_Image denotes the
+               result of calling function S'Wide_Wide_Image with <Arg>
                being X, where S is the nominal subtype of X.
 
 55.3/4
 X'Wide_Image
-               {AI12-0124-1AI12-0124-1} X'Wide_Image denotes the result
-               of calling function S'Wide_Image with Arg being X, where
-               S is the nominal subtype of X.
+               {<AI12-0124-1AI12-0124-1>} X'Wide_Image denotes the
+               result of calling function S'Wide_Image with <Arg> being
+               X, where S is the nominal subtype of X.
 
 55.4/4
 X'Image
-               {AI12-0124-1AI12-0124-1} X'Image denotes the result of
-               calling function S'Image with Arg being X, where S is the
-               nominal subtype of X.
+               {<AI12-0124-1AI12-0124-1>} X'Image denotes the result of
+               calling function S'Image with <Arg> being X, where S is
+               the nominal subtype of X.
 
                      _Implementation Permissions_
 
 56/2
-{AI95-00285-01AI95-00285-01} An implementation may extend the
+{<AI95-00285-01AI95-00285-01>} 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.
 
 56.a/2
-          Proof: {AI95-00285-01AI95-00285-01} The permission is really
+          Proof: {<AI95-00285-01AI95-00285-01>} The permission is really
           only necessary for Wide_Wide_Value, because Value and
           Wide_Value are defined in terms of Wide_Wide_Value, and
           because the behavior of Wide_Wide_Image, Wide_Image, and Image
@@ -9569,19 +9583,19 @@ such as infinities and NaNs.
           for Get in *note A.10.9::.
 
 56.1/3
-{AI05-0182-1AI05-0182-1} {AI05-0262-1AI05-0262-1}
-{AI05-0269-1AI05-0269-1} An implementation may extend the
+{<AI05-0182-1AI05-0182-1>} {<AI05-0262-1AI05-0262-1>}
+{<AI05-0269-1AI05-0269-1>} An implementation may extend the
 Wide_Wide_Value, Wide_Value, and Value attributes of a character type to
-accept strings of the form "Hex_hhhhhhhh" (ignoring case) for any
+accept strings of the form "Hex_<hhhhhhhh>" (ignoring case) for any
 character (not just the ones for which Wide_Wide_Image would produce
 that form -- see *note 3.5.2::), as well as three-character strings of
-the form "'X'", where X is any character, including nongraphic
+the form "'<X>'", where <X> is any character, including nongraphic
 characters.
 
                           _Static Semantics_
 
 56.2/3
-{AI05-0228-1AI05-0228-1} For a scalar type, the following
+{<AI05-0228-1AI05-0228-1>} For a scalar type, the following
 language-defined representation aspect may be specified with an
 aspect_specification (see *note 13.1.1::):
 
@@ -9609,9 +9623,9 @@ Default_Value
           scalar subtype.
 
 56.4/3
-{AI05-0228-1AI05-0228-1} If a derived type with no primitive subprograms
-inherits a boolean Default_Value aspect, the aspect may be specified to
-have any value for the derived type.
+{<AI05-0228-1AI05-0228-1>} If a derived type with no primitive
+subprograms inherits a boolean Default_Value aspect, the aspect may be
+specified to have any value for the derived type.
 
 56.f/3
           Reason: This overrides the *note 13.1.1:: rule that says that
@@ -9620,8 +9634,8 @@ have any value for the derived type.
                         _Name Resolution Rules_
 
 56.5/3
-{AI05-0228-1AI05-0228-1} The expected type for the expression specified
-for the Default_Value aspect is the type defined by the
+{<AI05-0228-1AI05-0228-1>} The expected type for the expression
+specified for the Default_Value aspect is the type defined by the
 full_type_declaration on which it appears.
 
      NOTES
@@ -9659,18 +9673,18 @@ full_type_declaration on which it appears.
                               _Examples_
 
 60
-Examples of ranges:
+<Examples of ranges:>
 
 61
      -10 .. 10
      X .. X + 1
      0.0 .. 2.0*Pi
-     Red .. Green     -- see *note 3.5.1::
-     1 .. 0           -- a null range
-     Table'Range      -- a range attribute reference (see *note 3.6::)
+     Red .. Green     --< see *note 3.5.1::>
+     1 .. 0           --< a null range>
+     Table'Range      --< a range attribute reference (see *note 3.6::)>
 
 62
-Examples of range constraints:
+<Examples of range constraints:>
 
 63
      range -999.0 .. +999.0
@@ -9740,7 +9754,7 @@ Examples of range constraints:
                         _Extensions to Ada 95_
 
 63.j/2
-          {AI95-00285-01AI95-00285-01} The attributes Wide_Wide_Image,
+          {<AI95-00285-01AI95-00285-01>} The attributes Wide_Wide_Image,
           Wide_Wide_Value, and Wide_Wide_Width are new.  Note that
           Wide_Image and Wide_Value are now defined in terms of
           Wide_Wide_Image and Wide_Wide_Value, but the image of types
@@ -9749,7 +9763,7 @@ Examples of range constraints:
                      _Wording Changes from Ada 95_
 
 63.k/2
-          {AI95-00285-01AI95-00285-01} The Wide_Image and Wide_Value
+          {<AI95-00285-01AI95-00285-01>} The Wide_Image and Wide_Value
           attributes are now defined in terms of Wide_Wide_Image and
           Wide_Wide_Value, but the images of numeric types have not
           changed.
@@ -9757,11 +9771,11 @@ Examples of range constraints:
                     _Inconsistencies With Ada 2005_
 
 63.l/3
-          {AI05-0181-1AI05-0181-1} Correction: Soft hyphen (code point
+          {<AI05-0181-1AI05-0181-1>} Correction: Soft hyphen (code point
           173) is nongraphic in ISO/IEC 10646:2011 (and also in the 2003
           version of that standard).  Thus, we have given it the
-          language-defined name soft_hyphen.  This changes the result of
-          Character'Image (and all of the related types and Image
+          language-defined name <soft_hyphen>.  This changes the result
+          of Character'Image (and all of the related types and Image
           attributes) for this character, and changes the behavior of
           Character'Value (and all of the related types and Value
           attributes) for this character, and (in unusual
@@ -9771,7 +9785,7 @@ Examples of range constraints:
           already prepared to handle nongraphic characters.
 
 63.m/3
-          {AI05-0182-1AI05-0182-1} Correction: Added an Implementation
+          {<AI05-0182-1AI05-0182-1>} Correction: Added an Implementation
           Permissions to let Wide_Wide_Value, Wide_Value, and Value
           accept strings in the form of literals containing nongraphic
           characters and "Hex_hhhhhhhh" for Latin-1 and graphic
@@ -9785,14 +9799,14 @@ Examples of range constraints:
                        _Extensions to Ada 2005_
 
 63.n/3
-          {AI05-0228-1AI05-0228-1} The new aspect Default_Value allows
+          {<AI05-0228-1AI05-0228-1>} The new aspect Default_Value allows
           defining implicit initial values (see *note 3.3.1::) for
           scalar types.
 
                        _Extensions to Ada 2012_
 
 63.o/4
-          {AI12-0124-1AI12-0124-1} Corrigendum: An object can be now
+          {<AI12-0124-1AI12-0124-1>} Corrigendum: An object can be now
           used as the prefix of the Image attribute (as well as
           Wide_Image and Wide_Wide_Image), a convenience feature already
           present in some implementations.
@@ -9836,26 +9850,26 @@ File: aarm2012.info,  Node: 3.5.1,  Next: 3.5.2,  Up: 
3.5
                            _Legality Rules_
 
 5/3
-{AI05-0227-1AI05-0227-1} {AI05-0299-1AI05-0299-1} The
+{<AI05-0227-1AI05-0227-1>} {<AI05-0299-1AI05-0299-1>} The
 defining_identifiers in upper case [and the defining_character_literals]
 listed in an enumeration_type_definition shall be distinct.
 
 5.a/3
-          Proof: {AI05-0227-1AI05-0227-1} For character literals, this
+          Proof: {<AI05-0227-1AI05-0227-1>} For character literals, this
           is a ramification of the normal disallowance of homographs
           explicitly declared immediately in the same declarative
           region.
 
 5.b/3
-          Reason: {AI05-0227-1AI05-0227-1} To ease implementation of the
-          attribute Wide_Wide_Value, we require that all enumeration
+          Reason: {<AI05-0227-1AI05-0227-1>} To ease implementation of
+          the attribute Wide_Wide_Value, we require that all enumeration
           literals have distinct images.
 
                           _Static Semantics_
 
 6/3
-{AI05-0006-1AI05-0006-1} Each enumeration_literal_specification is the
-explicit declaration of the corresponding enumeration literal: it
+{<AI05-0006-1AI05-0006-1>} Each enumeration_literal_specification is the
+explicit declaration of the corresponding <enumeration literal>: it
 declares a parameterless function, whose defining name is the
 defining_identifier (*note 3.1: S0022.) or defining_character_literal
 (*note 3.5.1: S0040.), and whose result subtype is the base subtype of
@@ -9872,15 +9886,15 @@ the enumeration type.
           and it never fails the Elaboration_Check when called.
 
 6.c/3
-          Discussion: {AI05-0006-1AI05-0006-1} The result subtype is
+          Discussion: {<AI05-0006-1AI05-0006-1>} The result subtype is
           primarily a concern when an enumeration literal is used as the
           expression of a case statement, due to the full coverage
           requirement based on the nominal subtype.
 
 7
 Each enumeration literal corresponds to a distinct value of the
-enumeration type, and to a distinct position number. The position number
-of the value of the first listed enumeration literal is zero; the
+enumeration type, and to a distinct position number.  The position
+number of the value of the first listed enumeration literal is zero; the
 position number of the value of each subsequent enumeration literal is
 one more than that of its predecessor in the list.
 
@@ -9892,9 +9906,9 @@ follow the order of corresponding position numbers.]
 [ If the same defining_identifier or defining_character_literal is
 specified in more than one enumeration_type_definition (*note 3.5.1:
 S0038.), the corresponding enumeration literals are said to be
-overloaded.  At any place where an overloaded enumeration literal occurs
-in the text of a program, the type of the enumeration literal has to be
-determinable from the context (see *note 8.6::).]
+<overloaded>.  At any place where an overloaded enumeration literal
+occurs in the text of a program, the type of the enumeration literal has
+to be determinable from the context (see *note 8.6::).]
 
                           _Dynamic Semantics_
 
@@ -9923,7 +9937,7 @@ literal returns the corresponding value of the 
enumeration type.
                               _Examples_
 
 13
-Examples of enumeration types and subtypes:
+<Examples of enumeration types and subtypes: >
 
 14
      type Day    is (Mon, Tue, Wed, Thu, Fri, Sat, Sun);
@@ -9931,7 +9945,7 @@ Examples of enumeration types and subtypes:
      type Gender is (M, F);
      type Level  is (Low, Medium, Urgent);
      type Color  is (White, Red, Yellow, Green, Blue, Brown, Black);
-     type Light  is (Red, Amber, Green); -- Red and Green are overloaded
+     type Light  is (Red, Amber, Green); --< Red and Green are overloaded>
 
 15
      type Hexa   is ('A', 'B', 'C', 'D', 'E', 'F');
@@ -9940,7 +9954,7 @@ Examples of enumeration types and subtypes:
 16
      subtype Weekday is Day   range Mon .. Fri;
      subtype Major   is Suit  range Hearts .. Spades;
-     subtype Rainbow is Color range Red .. Blue;  --  the Color Red, not the 
Light
+     subtype Rainbow is Color range Red .. Blue;  --<  the Color Red, not the 
Light>
 
                      _Wording Changes from Ada 83_
 
@@ -9957,7 +9971,7 @@ Examples of enumeration types and subtypes:
                    _Incompatibilities With Ada 2005_
 
 16.c/3
-          {AI05-0227-1AI05-0227-1} Correction: Required that all
+          {<AI05-0227-1AI05-0227-1>} Correction: Required that all
           enumeration literals in a type have distinct images; this
           might not be the case since upper case conversion can map
           distinct characters to the same upper case character.  This
@@ -9972,7 +9986,7 @@ Examples of enumeration types and subtypes:
                     _Wording Changes from Ada 2005_
 
 16.d/3
-          {AI05-0006-1AI05-0006-1} Correction: Defined the result
+          {<AI05-0006-1AI05-0006-1>} Correction: Defined the result
           subtype of an enumeration literal to close a minor language
           hole.
 
@@ -9985,29 +9999,29 @@ File: aarm2012.info,  Node: 3.5.2,  Next: 3.5.3,  Prev: 
3.5.1,  Up: 3.5
                           _Static Semantics_
 
 1
-An enumeration type is said to be a character type if at least one of
+An enumeration type is said to be a <character type> if at least one of
 its enumeration literals is a character_literal.
 
 2/3
-{AI95-00285-01AI95-00285-01} {AI05-0181-1AI05-0181-1}
-{AI05-0262-1AI05-0262-1} {AI05-0266-1AI05-0266-1} The predefined type
-Character is a character type whose values correspond to the 256 code
-points of Row 00 (also known as Latin-1) of the ISO/IEC 10646:2011 Basic
-Multilingual Plane (BMP). Each of the graphic characters of Row 00 of
-the BMP has a corresponding character_literal in Character.  Each of the
-nongraphic characters of Row 00 has a corresponding language-defined
+{<AI95-00285-01AI95-00285-01>} {<AI05-0181-1AI05-0181-1>}
+{<AI05-0262-1AI05-0262-1>} {<AI05-0266-1AI05-0266-1>} The predefined
+type Character is a character type whose values correspond to the 256
+code points of Row 00 (also known as Latin-1) of the ISO/IEC 10646:2011
+Basic Multilingual Plane (BMP). Each of the graphic characters of Row 00
+of the BMP has a corresponding character_literal in Character.  Each of
+the nongraphic characters of Row 00 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 *note A.1::, "*note A.1:: The Package Standard",
-but are set in italics. 
+but are set in <italics>.  
 
 2.a/3
-          Discussion: {AI05-0262-1AI05-0262-1} Code point is defined in
-          ISO/IEC 10646:2011.
+          Discussion: {<AI05-0262-1AI05-0262-1>} <Code point> is defined
+          in ISO/IEC 10646:2011.
 
 3/3
-{AI95-00285-01AI95-00285-01} {AI05-0262-1AI05-0262-1} The predefined
+{<AI95-00285-01AI95-00285-01>} {<AI05-0262-1AI05-0262-1>} The predefined
 type Wide_Character is a character type whose values correspond to the
 65536 code points of the ISO/IEC 10646:2011 Basic Multilingual Plane
 (BMP). Each of the graphic characters of the BMP has a corresponding
@@ -10017,7 +10031,7 @@ as defined for Character.  Each of the 
graphic_characters has a
 corresponding character_literal.
 
 4/3
-{AI95-00285-01AI95-00285-01} {AI05-0262-1AI05-0262-1} The predefined
+{<AI95-00285-01AI95-00285-01>} {<AI05-0262-1AI05-0262-1>} The predefined
 type Wide_Wide_Character is a character type whose values correspond to
 the 2147483648 code points of the ISO/IEC 10646:2011 character set.
 Each of the graphic_characters has a corresponding character_literal in
@@ -10026,7 +10040,7 @@ the same character_literal or language-defined name as 
defined for
 Wide_Character.
 
 5/3
-{AI95-00285-01AI95-00285-01} {AI05-0262-1AI05-0262-1} The characters
+{<AI95-00285-01AI95-00285-01>} {<AI05-0262-1AI05-0262-1>} The characters
 whose code point is larger than 16#FF# and which are not
 graphic_characters have language-defined names which are formed by
 appending to the string "Hex_" the representation of their code point in
@@ -10035,7 +10049,7 @@ names, these names are usable only with the attributes 
(Wide_)Wide_Image
 and (Wide_)Wide_Value; they are not usable as enumeration literals.
 
 5.a/2
-          Reason: {AI95-00285-01AI95-00285-01} The language-defined
+          Reason: {<AI95-00285-01AI95-00285-01>} The language-defined
           names are not usable as enumeration literals to avoid
           "polluting" the name space.  Since Wide_Character and
           Wide_Wide_Character are defined in Standard, if the
@@ -10043,7 +10057,7 @@ and (Wide_)Wide_Value; they are not usable as 
enumeration literals.
           they would hide other nonoverloadable declarations with the
           same names in use-d packages.]}
 
-Paragraphs 6 and 7 were deleted.
+<Paragraphs 6 and 7 were deleted.>
 
      NOTES
 
@@ -10059,8 +10073,8 @@ Paragraphs 6 and 7 were deleted.
           obsolescent package, and we no longer mention it here.
 
 9/3
-     32  {AI05-0299-1AI05-0299-1} A conventional character set such as
-     EBCDIC can be declared as a character type; the internal codes of
+     32  {<AI05-0299-1AI05-0299-1>} A conventional character set such as
+     <EBCDIC> can be declared as a character type; the internal codes of
      the characters can be specified by an
      enumeration_representation_clause as explained in subclause *note
      13.4::.
@@ -10068,7 +10082,7 @@ Paragraphs 6 and 7 were deleted.
                               _Examples_
 
 10
-Example of a character type:
+<Example of a character type: >
 
 11
      type Roman_Digit is ('I', 'V', 'X', 'L', 'C', 'D', 'M');
@@ -10120,19 +10134,20 @@ Example of a character type:
                      _Inconsistencies With Ada 95_
 
 11.h/2
-          {AI95-00285-01AI95-00285-01} Ada 95 defined most characters in
-          Wide_Character to be graphic characters, while Ada 2005 uses
-          the categorizations from ISO-10646:2003.  It also provides
-          language-defined names for all nongraphic characters.  That
-          means that in Ada 2005, Wide_Character'Wide_Value will raise
-          Constraint_Error for a string representing a character_literal
-          of a nongraphic character, while Ada 95 would have accepted
-          it.  Similarly, the result of Wide_Character'Wide_Image will
-          change for such nongraphic characters.
+          {<AI95-00285-01AI95-00285-01>} Ada 95 defined most characters
+          in Wide_Character to be graphic characters, while Ada 2005
+          uses the categorizations from ISO-10646:2003.  It also
+          provides language-defined names for all nongraphic characters.
+          That means that in Ada 2005, Wide_Character'Wide_Value will
+          raise Constraint_Error for a string representing a
+          character_literal of a nongraphic character, while Ada 95
+          would have accepted it.  Similarly, the result of
+          Wide_Character'Wide_Image will change for such nongraphic
+          characters.
 
 11.i/3
-          {AI95-00395-01AI95-00395-01} {AI05-0005-1AI05-0005-1}
-          {AI05-0262-1AI05-0262-1} The language-defined names FFFE and
+          {<AI95-00395-01AI95-00395-01>} {<AI05-0005-1AI05-0005-1>}
+          {<AI05-0262-1AI05-0262-1>} The language-defined names FFFE and
           FFFF were replaced by a consistent set of language-defined
           names for all nongraphic characters with code points greater
           than 16#FF#.  That means that in Ada 2005,
@@ -10144,7 +10159,7 @@ Example of a character type:
           characters.
 
 11.j/2
-          {AI95-00285-01AI95-00285-01} {AI95-00395-01AI95-00395-01}
+          {<AI95-00285-01AI95-00285-01>} {<AI95-00395-01AI95-00395-01>}
           Because of the previously mentioned changes to the
           Wide_Character'Wide_Image of various character values, the
           value of attribute Wide_Width will change for some subtypes of
@@ -10153,7 +10168,7 @@ Example of a character type:
           does not change.
 
 11.k/2
-          {AI95-00285-01AI95-00285-01} The declaration of
+          {<AI95-00285-01AI95-00285-01>} The declaration of
           Wide_Wide_Character in package Standard hides use-visible
           declarations with the same defining identifier.  In the (very)
           unlikely event that an Ada 95 program had depended on such a
@@ -10164,17 +10179,17 @@ Example of a character type:
                         _Extensions to Ada 95_
 
 11.l/2
-          {AI95-00285-01AI95-00285-01} The type Wide_Wide_Character is
+          {<AI95-00285-01AI95-00285-01>} The type Wide_Wide_Character is
           new.
 
                      _Wording Changes from Ada 95_
 
 11.m/2
-          {AI95-00285-01AI95-00285-01} Characters are now defined in
+          {<AI95-00285-01AI95-00285-01>} Characters are now defined in
           terms of the entire ISO/IEC 10646:2003 character set.
 
 11.n/3
-          {AI95-00285-01AI95-00285-01} {AI05-0248-1AI05-0248-1} We
+          {<AI95-00285-01AI95-00285-01>} {<AI05-0248-1AI05-0248-1>} We
           dropped the Implementation Advice for nonstandard
           interpretation of character sets; an implementation can do
           what it wants in a nonstandard mode, so there isn't much point
@@ -10183,12 +10198,12 @@ Example of a character type:
                     _Wording Changes from Ada 2005_
 
 11.o/3
-          {AI05-0181-1AI05-0181-1} Correction: Removed the position
+          {<AI05-0181-1AI05-0181-1>} Correction: Removed the position
           numbers of nongraphic characters from the text, as it is wrong
           and thus misleading.
 
 11.p/3
-          {AI05-0262-1AI05-0262-1} Changed "code position" to "code
+          {<AI05-0262-1AI05-0262-1>} Changed "code position" to "code
           point" consistently throughout the standard, as ISO/IEC
           10646:2011 prefers "code point" and we are referring to the
           definition in that Standard.  This change also reduces
@@ -10206,9 +10221,9 @@ File: aarm2012.info,  Node: 3.5.3,  Next: 3.5.4,  Prev: 
3.5.2,  Up: 3.5
 
 1
 There is a predefined enumeration type named Boolean, [declared in the
-visible part of package Standard]. It has the two enumeration literals
-False and True ordered with the relation False < True. Any descendant of
-the predefined type Boolean is called a boolean type.
+visible part of package Standard].  It has the two enumeration literals
+False and True ordered with the relation False < True.  Any descendant
+of the predefined type Boolean is called a <boolean> type.
 
 1.a
           Implementation Note: An implementation is not required to
@@ -10227,11 +10242,11 @@ File: aarm2012.info,  Node: 3.5.4,  Next: 3.5.5,  
Prev: 3.5.3,  Up: 3.5
 
 1
 An integer_type_definition defines an integer type; it defines either a
-signed integer type, or a modular integer type.  The base range of a
+<signed> integer type, or a <modular> integer type.  The base range of a
 signed integer type includes at least the values of the specified range.
 A modular type is an integer type with all arithmetic modulo a specified
-positive modulus; such a type corresponds to an unsigned type with
-wrap-around semantics. 
+positive <modulus>; such a type corresponds to an unsigned type with
+wrap-around semantics.  
 
                                _Syntax_
 
@@ -10240,8 +10255,8 @@ wrap-around semantics.
      modular_type_definition
 
 3
-     signed_integer_type_definition ::= range static_
-     simple_expression .. static_simple_expression
+     signed_integer_type_definition ::= range <static_>
+     simple_expression .. <static_>simple_expression
 
 3.a
           Discussion: We don't call this a range_constraint, because it
@@ -10258,13 +10273,13 @@ wrap-around semantics.
           the generic type matching rules.
 
 4
-     modular_type_definition ::= mod static_expression
+     modular_type_definition ::= mod <static_>expression
 
                         _Name Resolution Rules_
 
 5
 Each simple_expression in a signed_integer_type_definition is expected
-to be of any integer type; they need not be of the same type. The
+to be of any integer type; they need not be of the same type.  The
 expression in a modular_type_definition is likewise expected to be of
 any integer type.
 
@@ -10277,7 +10292,7 @@ System.Max_Int.
 
 7
 The expression of a modular_type_definition shall be static, and its
-value (the modulus) shall be positive, and shall be no greater than
+value (the <modulus>) shall be positive, and shall be no greater than
 System.Max_Binary_Modulus if a power of 2, or no greater than
 System.Max_Nonbinary_Modulus if not.
 
@@ -10300,27 +10315,27 @@ inclusive.
 9
 A signed_integer_type_definition defines an integer type whose base
 range includes at least the values of the simple_expressions and is
-symmetric about zero, excepting possibly an extra negative value. A
+symmetric about zero, excepting possibly an extra negative value.  A
 signed_integer_type_definition also defines a constrained first subtype
 of the type, with a range whose bounds are given by the values of the
 simple_expressions, converted to the type being defined.
 
 9.a/2
-          Implementation Note: {AI95-00114-01AI95-00114-01} The base
+          Implementation Note: {<AI95-00114-01AI95-00114-01>} The base
           range of a signed integer type might be much larger than is
           necessary to satisfy the above requirements.
 
 9.a.1/1
           To be honest: The conversion mentioned above is not an
-          implicit subtype conversion (which is something that happens
+          <implicit subtype conversion> (which is something that happens
           at overload resolution, see *note 4.6::), although it happens
           implicitly.  Therefore, the freezing rules are not invoked on
           the type (which is important so that representation items can
-          be given for the type). 
+          be given for the type).  
 
 10
 A modular_type_definition defines a modular type whose base range is
-from zero to one less than the given modulus. A modular_type_definition
+from zero to one less than the given modulus.  A modular_type_definition
 also defines a constrained first subtype of the type with a range that
 is the same as the base range of the type.
 
@@ -10360,14 +10375,14 @@ package Standard:]
 
 14
 A type defined by an integer_type_definition is implicitly derived from
-root_integer, an anonymous predefined (specific) integer type, whose
+<root_integer>, an anonymous predefined (specific) integer type, whose
 base range is System.Min_Int ..  System.Max_Int.  However, the base
-range of the new type is not inherited from root_integer, but is instead
-determined by the range or modulus specified by the
-integer_type_definition. [Integer literals are all of the type
-universal_integer, the universal type (see *note 3.4.1::) for the class
-rooted at root_integer, allowing their use with the operations of any
-integer type.]
+range of the new type is not inherited from <root_integer>, but is
+instead determined by the range or modulus specified by the
+integer_type_definition.  [Integer literals are all of the type
+<universal_integer>, the universal type (see *note 3.4.1::) for the
+class rooted at <root_integer>, allowing their use with the operations
+of any integer type.]
 
 14.a
           Discussion: This implicit derivation is not considered exactly
@@ -10376,54 +10391,54 @@ integer type.]
           via a derived_type_definition inherit their base range from
           their parent type.  A type defined by an
           integer_type_definition does not necessarily inherit its base
-          range from root_integer.  It is not specified whether the
-          implicit derivation from root_integer is direct or indirect,
+          range from <root_integer>.  It is not specified whether the
+          implicit derivation from <root_integer> is direct or indirect,
           not that it really matters.  All we want is for all integer
-          types to be descendants of root_integer.
+          types to be descendants of <root_integer>.
 
 14.a.1/1
-          {8652/00998652/0099} {AI95-00152-01AI95-00152-01} Note that
-          this derivation does not imply any inheritance of subprograms.
-          Subprograms are inherited only for types derived by a
-          derived_type_definition (*note 3.4: S0035.) (see *note 3.4::),
-          or a private_extension_declaration (*note 7.3: S0194.) (see
-          *note 7.3::, *note 7.3.1::, and *note 12.5.1::).
+          {<8652/00998652/0099>} {<AI95-00152-01AI95-00152-01>} Note
+          that this derivation does not imply any inheritance of
+          subprograms.  Subprograms are inherited only for types derived
+          by a derived_type_definition (*note 3.4: S0035.) (see *note
+          3.4::), or a private_extension_declaration (*note 7.3: S0194.)
+          (see *note 7.3::, *note 7.3.1::, and *note 12.5.1::).
 
 14.b
           Implementation Note: It is the intent that even nonstandard
-          integer types (see below) will be descendants of root_integer,
-          even though they might have a base range that exceeds that of
-          root_integer.  This causes no problem for static calculations,
-          which are performed without range restrictions (see *note
-          4.9::).  However for run-time calculations, it is possible
-          that Constraint_Error might be raised when using an operator
-          of root_integer on the result of 'Val applied to a value of a
-          nonstandard integer type.
+          integer types (see below) will be descendants of
+          <root_integer>, even though they might have a base range that
+          exceeds that of <root_integer>.  This causes no problem for
+          static calculations, which are performed without range
+          restrictions (see *note 4.9::).  However for run-time
+          calculations, it is possible that Constraint_Error might be
+          raised when using an operator of <root_integer> on the result
+          of 'Val applied to a value of a nonstandard integer type.
 
 15
-The position number of an integer value is equal to the value.
+The <position number> of an integer value is equal to the value.
 
 16/2
-{AI95-00340-01AI95-00340-01} For every modular subtype S, the following
-attributes are defined:
+{<AI95-00340-01AI95-00340-01>} For every modular subtype S, the
+following attributes are defined:
 
 16.1/2
 S'Mod
-               {AI95-00340-01AI95-00340-01} S'Mod denotes a function
+               {<AI95-00340-01AI95-00340-01>} S'Mod denotes a function
                with the following specification:
 
 16.2/2
-                    function S'Mod (Arg : universal_integer)
+                    function S'Mod (<Arg> : <universal_integer>)
                       return S'Base
 
 16.3/2
-               This function returns Arg mod S'Modulus, as a value of
+               This function returns <Arg> mod S'Modulus, as a value of
                the type of S.
 
 17
 S'Modulus
                S'Modulus yields the modulus of the type of S, as a value
-               of the type universal_integer.
+               of the type <universal_integer>.
 
                           _Dynamic Semantics_
 
@@ -10488,13 +10503,13 @@ be the base range of its type.
           in Standard.
 
 26
-An implementation may provide nonstandard integer types, descendants of
-root_integer that are declared outside of the specification of package
-Standard, which need not have all the standard characteristics of a type
-defined by an integer_type_definition.  For example, a nonstandard
-integer type might have an asymmetric base range or it might not be
-allowed as an array or loop index (a very long integer).  Any type
-descended from a nonstandard integer type is also nonstandard.  An
+An implementation may provide <nonstandard integer types>, descendants
+of <root_integer> that are declared outside of the specification of
+package Standard, which need not have all the standard characteristics
+of a type defined by an integer_type_definition.  For example, a
+nonstandard integer type might have an asymmetric base range or it might
+not be allowed as an array or loop index (a very long integer).  Any
+type descended from a nonstandard integer type is also nonstandard.  An
 implementation may place arbitrary restrictions on the use of such
 types; it is implementation defined whether operators that are
 predefined for "any integer type" are defined for a particular
@@ -10514,11 +10529,11 @@ implementation defined for which powers of 2, if any, 
this permission is
 exercised.
 
 27.1/1
-{8652/00038652/0003} {AI95-00095-01AI95-00095-01} For a one's complement
-machine, implementations may support nonbinary modulus values greater
-than System.Max_Nonbinary_Modulus.  It is implementation defined which
-specific values greater than System.Max_Nonbinary_Modulus, if any, are
-supported.
+{<8652/00038652/0003>} {<AI95-00095-01AI95-00095-01>} For a one's
+complement machine, implementations may support nonbinary modulus values
+greater than System.Max_Nonbinary_Modulus.  It is implementation defined
+which specific values greater than System.Max_Nonbinary_Modulus, if any,
+are supported.
 
 27.a.1/1
           Reason: On a one's complement machine, the natural full word
@@ -10590,10 +10605,10 @@ should support a nonbinary modulus up to Integer'Last.
 
 30
      33  Integer literals are of the anonymous predefined integer type
-     universal_integer.  Other integer types have no literals.  However,
-     the overload resolution rules (see *note 8.6::, "*note 8.6:: The
-     Context of Overload Resolution") allow expressions of the type
-     universal_integer whenever an integer type is expected.
+     <universal_integer>.  Other integer types have no literals.
+     However, the overload resolution rules (see *note 8.6::, "*note
+     8.6:: The Context of Overload Resolution") allow expressions of the
+     type <universal_integer> whenever an integer type is expected.
 
 31
      34  The same arithmetic operators are predefined for all signed
@@ -10613,7 +10628,7 @@ should support a nonbinary modulus up to Integer'Last.
                               _Examples_
 
 33
-Examples of integer types and subtypes:
+<Examples of integer types and subtypes: >
 
 34
      type Page_Num  is range 1 .. 2_000;
@@ -10625,8 +10640,8 @@ Examples of integer types and subtypes:
      subtype Buffer_Size is Integer   range 0 .. Max;
 
 36
-     type Byte        is mod 256; -- an unsigned byte
-     type Hash_Index  is mod 97;  -- modulus is prime
+     type Byte        is mod 256; --< an unsigned byte>
+     type Hash_Index  is mod 97;  --< modulus is prime>
 
                         _Extensions to Ada 83_
 
@@ -10657,7 +10672,7 @@ Examples of integer types and subtypes:
           We no longer explain integer type definition in terms of an
           equivalence to a normal type derivation, except to say that
           all integer types are by definition implicitly derived from
-          root_integer.  This is for various reasons.
+          <root_integer>.  This is for various reasons.
 
 36.g
           First of all, the equivalence with a type derivation and a
@@ -10678,7 +10693,7 @@ Examples of integer types and subtypes:
           implement a given user-defined integer type.  Hence, we would
           have needed anonymous integer types as parent types for the
           implicit derivation anyway.  We have simply chosen to identify
-          only one anonymous integer type -- root_integer, and stated
+          only one anonymous integer type -- <root_integer>, and stated
           that every integer type is derived from it.
 
 36.j
@@ -10692,7 +10707,7 @@ Examples of integer types and subtypes:
                         _Extensions to Ada 95_
 
 36.k/2
-          {AI95-00340-01AI95-00340-01} The Mod attribute is new.  It
+          {<AI95-00340-01AI95-00340-01>} The Mod attribute is new.  It
           eases mixing of signed and unsigned values in an expression,
           which can be difficult as there may be no type which can
           contain all of the values of both of the types involved.
@@ -10700,9 +10715,9 @@ Examples of integer types and subtypes:
                      _Wording Changes from Ada 95_
 
 36.l/2
-          {8652/00038652/0003} {AI95-00095-01AI95-00095-01} Corrigendum:
-          Added additional permissions for modular types on one's
-          complement machines.
+          {<8652/00038652/0003>} {<AI95-00095-01AI95-00095-01>}
+          Corrigendum: Added additional permissions for modular types on
+          one's complement machines.
 
 
 File: aarm2012.info,  Node: 3.5.5,  Next: 3.5.6,  Prev: 3.5.4,  Up: 3.5
@@ -10721,12 +10736,12 @@ S'Pos
                specification:
 
 3
-                    function S'Pos(Arg : S'Base)
-                      return universal_integer
+                    function S'Pos(<Arg> : S'Base)
+                      return <universal_integer>
 
 4
                This function returns the position number of the value of
-               Arg, as a value of type universal_integer.
+               <Arg>, as a value of type <universal_integer>.
 
 5
 S'Val
@@ -10734,20 +10749,20 @@ S'Val
                specification:
 
 6
-                    function S'Val(Arg : universal_integer)
+                    function S'Val(<Arg> : <universal_integer>)
                       return S'Base
 
 7
                This function returns a value of the type of S whose
-               position number equals the value of Arg. For the
+               position number equals the value of <Arg>.  For the
                evaluation of a call on S'Val, if there is no value in
                the base range of its type with the given position
                number, Constraint_Error is raised.
 
 7.a
           Ramification: By the overload resolution rules, a formal
-          parameter of type universal_integer allows an actual parameter
-          of any integer type.
+          parameter of type <universal_integer> allows an actual
+          parameter of any integer type.
 
 7.b
           Reason: We considered allowing S'Val for a signed integer
@@ -10756,27 +10771,27 @@ S'Val
           allowance didn't seem worth the complexity of the rule.
 
 7.1/4
-{AI05-0297-1AI05-0297-1} {AI12-0071-1AI12-0071-1} For every static
+{<AI05-0297-1AI05-0297-1>} {<AI12-0071-1AI12-0071-1>} For every static
 discrete subtype S for which there exists at least one value belonging
 to S that satisfies the predicates of S, the following attributes are
 defined:
 
 7.2/4
 S'First_Valid
-               {AI05-0297-1AI05-0297-1} {AI12-0071-1AI12-0071-1}
+               {<AI05-0297-1AI05-0297-1>} {<AI12-0071-1AI12-0071-1>}
                S'First_Valid denotes the smallest value that belongs to
                S and satisfies the predicates of S. The value of this
                attribute is of the type of S.
 
 7.3/4
 S'Last_Valid
-               {AI05-0297-1AI05-0297-1} {AI12-0071-1AI12-0071-1}
+               {<AI05-0297-1AI05-0297-1>} {<AI12-0071-1AI12-0071-1>}
                S'Last_Valid denotes the largest value that belongs to S
                and satisfies the predicates of S. The value of this
                attribute is of the type of S.
 
 7.4/3
-{AI05-0297-1AI05-0297-1} [First_Valid and Last_Valid
+{<AI05-0297-1AI05-0297-1>} [First_Valid and Last_Valid
 attribute_references are always static expressions.  Any explicit
 predicate of S can only have been specified by a Static_Predicate
 aspect.]
@@ -10804,7 +10819,7 @@ aspect.]
 For the evaluation of a call on S'Pos for an enumeration subtype, if the
 value of the operand does not correspond to the internal code for any
 enumeration literal of its type [(perhaps due to an uninitialized
-variable)], then the implementation should raise Program_Error. This is
+variable)], then the implementation should raise Program_Error.  This is
 particularly important for enumeration types with noncontiguous internal
 codes specified by an enumeration_representation_clause (*note 13.4:
 S0311.).
@@ -10829,7 +10844,7 @@ S0311.).
      36  Indexing and loop iteration use values of discrete types.
 
 10/3
-     37  {AI05-0299-1AI05-0299-1} The predefined operations of a
+     37  {<AI05-0299-1AI05-0299-1>} The predefined operations of a
      discrete type include the assignment operation, qualification, the
      membership tests, and the relational operators; for a boolean type
      they include the short-circuit control forms and the logical
@@ -10858,10 +10873,10 @@ S0311.).
                               _Examples_
 
 14
-Examples of attributes of discrete subtypes:
+<Examples of attributes of discrete subtypes: >
 
 15
-     --  For the types and subtypes declared in subclause *note 3.5.1:: the 
following hold: 
+     --<  For the types and subtypes declared in subclause *note 3.5.1:: the 
following hold: >
 
 16
      --  Color'First   = White,   Color'Last   = Black
@@ -10882,13 +10897,13 @@ Examples of attributes of discrete subtypes:
                        _Extensions to Ada 2005_
 
 17.b/3
-          {AI05-0297-1AI05-0297-1} The attributes S'First_Valid and
+          {<AI05-0297-1AI05-0297-1>} The attributes S'First_Valid and
           S'Last_Valid are new.
 
                     _Wording Changes from Ada 2012_
 
 17.c/4
-          {AI12-0071-1AI12-0071-1} Corrigendum: Updated wording of the
+          {<AI12-0071-1AI12-0071-1>} Corrigendum: Updated wording of the
           attributes S'First_Valid and S'Last_Valid to use the new term
           "satisfies the predicates" (see *note 3.2.4::).
 
@@ -10913,32 +10928,32 @@ fixed point types.
 
 3
 A type defined by a real_type_definition is implicitly derived from
-root_real, an anonymous predefined (specific) real type.  [Hence, all
+<root_real>, an anonymous predefined (specific) real type.  [Hence, all
 real types, whether floating point or fixed point, are in the derivation
-class rooted at root_real.]
+class rooted at <root_real>.]
 
 3.a
           Ramification: It is not specified whether the derivation from
-          root_real is direct or indirect, not that it really matters.
+          <root_real> is direct or indirect, not that it really matters.
           All we want is for all real types to be descendants of
-          root_real.
+          <root_real>.
 
 3.a.1/1
-          {8652/00998652/0099} {AI95-00152-01AI95-00152-01} Note that
-          this derivation does not imply any inheritance of subprograms.
-          Subprograms are inherited only for types derived by a
-          derived_type_definition (*note 3.4: S0035.) (see *note 3.4::),
-          or a private_extension_declaration (*note 7.3: S0194.) (see
-          *note 7.3::, *note 7.3.1::, and *note 12.5.1::).
+          {<8652/00998652/0099>} {<AI95-00152-01AI95-00152-01>} Note
+          that this derivation does not imply any inheritance of
+          subprograms.  Subprograms are inherited only for types derived
+          by a derived_type_definition (*note 3.4: S0035.) (see *note
+          3.4::), or a private_extension_declaration (*note 7.3: S0194.)
+          (see *note 7.3::, *note 7.3.1::, and *note 12.5.1::).
 
 4
-[ Real literals are all of the type universal_real, the universal type
-(see *note 3.4.1::) for the class rooted at root_real, allowing their
-use with the operations of any real type. Certain multiplying operators
-have a result type of universal_fixed (see *note 4.5.5::), the universal
-type for the class of fixed point types, allowing the result of the
-multiplication or division to be used where any specific fixed point
-type is expected.]
+[ Real literals are all of the type <universal_real>, the universal type
+(see *note 3.4.1::) for the class rooted at <root_real>, allowing their
+use with the operations of any real type.  Certain multiplying operators
+have a result type of <universal_fixed> (see *note 4.5.5::), the
+universal type for the class of fixed point types, allowing the result
+of the multiplication or division to be used where any specific fixed
+point type is expected.]
 
                           _Dynamic Semantics_
 
@@ -10950,39 +10965,39 @@ the floating_point_definition or the 
fixed_point_definition.
 
 6
 An implementation shall perform the run-time evaluation of a use of a
-predefined operator of root_real with an accuracy at least as great as
+predefined operator of <root_real> with an accuracy at least as great as
 that of any floating point type definable by a
 floating_point_definition.
 
 6.a
           Ramification: Static calculations using the operators of
-          root_real are exact, as for all static calculations.  See
+          <root_real> are exact, as for all static calculations.  See
           *note 4.9::.
 
 6.b
           Implementation Note: The Digits attribute of the type used to
-          represent root_real at run time is at least as great as that
+          represent <root_real> at run time is at least as great as that
           of any other floating point type defined by a
           floating_point_definition, and its safe range includes that of
           any such floating point type with the same Digits attribute.
           On some machines, there might be real types with less accuracy
           but a wider range, and hence run-time calculations with
-          root_real might not be able to accommodate all values that can
-          be represented at run time in such floating point or fixed
+          <root_real> might not be able to accommodate all values that
+          can be represented at run time in such floating point or fixed
           point types.
 
                      _Implementation Permissions_
 
 7/2
-{AI95-00114-01AI95-00114-01} [For the execution of a predefined
+{<AI95-00114-01AI95-00114-01>} [For the execution of a predefined
 operation of a real type, the implementation need not raise
 Constraint_Error if the result is outside the base range of the type, so
 long as the correct result is produced, or the Machine_Overflows
 attribute of the type is False (see *note G.2::).]
 
 8
-An implementation may provide nonstandard real types, descendants of
-root_real that are declared outside of the specification of package
+An implementation may provide <nonstandard real types>, descendants of
+<root_real> that are declared outside of the specification of package
 Standard, which need not have all the standard characteristics of a type
 defined by a real_type_definition.  For example, a nonstandard real type
 might have an asymmetric or unsigned base range, or its predefined
@@ -11004,9 +11019,10 @@ explicit_generic_actual_parameters for formal scalar 
types -- see *note
 
 9
      40  As stated, real literals are of the anonymous predefined real
-     type universal_real.  Other real types have no literals.  However,
-     the overload resolution rules (see *note 8.6::) allow expressions
-     of the type universal_real whenever a real type is expected.
+     type <universal_real>.  Other real types have no literals.
+     However, the overload resolution rules (see *note 8.6::) allow
+     expressions of the type <universal_real> whenever a real type is
+     expected.
 
                      _Wording Changes from Ada 83_
 
@@ -11022,7 +11038,7 @@ explicit_generic_actual_parameters for formal scalar 
types -- see *note
           All discussion of model numbers, safe ranges, and machine
           numbers is moved to *note 3.5.7::, *note 3.5.8::, and *note
           G.2::.  Values of a fixed point type are now described as
-          being multiples of the small of the fixed point type, and we
+          being multiples of the <small> of the fixed point type, and we
           have no need for model numbers, safe ranges, etc.  for fixed
           point types.
 
@@ -11041,19 +11057,19 @@ digits.
 
 2
      floating_point_definition ::=
-       digits static_expression [real_range_specification]
+       digits <static_>expression [real_range_specification]
 
 3
      real_range_specification ::=
-       range static_simple_expression .. static_simple_expression
+       range <static_>simple_expression .. <static_>simple_expression
 
                         _Name Resolution Rules_
 
 4
-The requested decimal precision, which is the minimum number of
+The <requested decimal precision>, which is the minimum number of
 significant decimal digits required for the floating point type, is
 specified by the value of the expression given after the reserved word
-digits. This expression is expected to be of any integer type.
+digits.  This expression is expected to be of any integer type.
 
 5
 Each simple_expression of a real_range_specification is expected to be
@@ -11065,18 +11081,18 @@ of any real type[; the types need not be the same].
 The requested decimal precision shall be specified by a static
 expression whose value is positive and no greater than
 System.Max_Base_Digits.  Each simple_expression of a
-real_range_specification shall also be static. If the
+real_range_specification shall also be static.  If the
 real_range_specification is omitted, the requested decimal precision
 shall be no greater than System.Max_Digits.
 
 6.a
           Reason: We have added Max_Base_Digits to package System.  It
-          corresponds to the requested decimal precision of root_real.
+          corresponds to the requested decimal precision of <root_real>.
           System.Max_Digits corresponds to the maximum value for Digits
           that may be specified in the absence of a
           real_range_specification, for upward compatibility.  These
-          might not be the same if root_real has a base range that does
-          not include � 10.0**(4*Max_Base_Digits).
+          might not be the same if <root_real> has a base range that
+          does not include � 10.0**(4*Max_Base_Digits).
 
 7
 A floating_point_definition is illegal if the implementation does not
@@ -11091,9 +11107,9 @@ precision and range.
 
 8
 The set of values for a floating point type is the (infinite) set of
-rational numbers. The machine numbers of a floating point type are the
-values of the type that can be represented exactly in every
-unconstrained variable of the type. The base range (see *note 3.5::) of
+rational numbers.  The <machine numbers> of a floating point type are
+the values of the type that can be represented exactly in every
+unconstrained variable of the type.  The base range (see *note 3.5::) of
 a floating point type is symmetric around zero, except that it can
 include some extra negative values in some implementations.
 
@@ -11110,9 +11126,9 @@ include some extra negative values in some 
implementations.
           plus zero.
 
 9
-The base decimal precision of a floating point type is the number of
-decimal digits of precision representable in objects of the type. The
-safe range of a floating point type is that part of its base range for
+The <base decimal precision> of a floating point type is the number of
+decimal digits of precision representable in objects of the type.  The
+<safe range> of a floating point type is that part of its base range for
 which the accuracy corresponding to the base decimal precision is
 preserved by all predefined operations.
 
@@ -11126,7 +11142,7 @@ preserved by all predefined operations.
 
 10
 A floating_point_definition defines a floating point type whose base
-decimal precision is no less than the requested decimal precision. If a
+decimal precision is no less than the requested decimal precision.  If a
 real_range_specification is given, the safe range of the floating point
 type (and hence, also its base range) includes at least the values of
 the simple expressions given in the real_range_specification.  If a
@@ -11137,19 +11153,19 @@ range might include other values as well.  The 
attributes Safe_First and
 Safe_Last give the actual bounds of the safe range.]
 
 11
-A floating_point_definition also defines a first subtype of the type. If
-a real_range_specification is given, then the subtype is constrained to
-a range whose bounds are given by a conversion of the values of the
+A floating_point_definition also defines a first subtype of the type.  
+If a real_range_specification is given, then the subtype is constrained
+to a range whose bounds are given by a conversion of the values of the
 simple_expressions of the real_range_specification to the type being
 defined.  Otherwise, the subtype is unconstrained.
 
 11.a.1/1
           To be honest: The conversion mentioned above is not an
-          implicit subtype conversion (which is something that happens
+          <implicit subtype conversion> (which is something that happens
           at overload resolution, see *note 4.6::), although it happens
           implicitly.  Therefore, the freezing rules are not invoked on
           the type (which is important so that representation items can
-          be given for the type). 
+          be given for the type).  
 
 12
 There is a predefined, unconstrained, floating point subtype named
@@ -11228,7 +11244,7 @@ library package Interfaces (see *note B.2::).
                               _Examples_
 
 19
-Examples of floating point types and subtypes:
+<Examples of floating point types and subtypes:>
 
 20
      type Coefficient is digits 10 range -1.0 .. 1.0;
@@ -11238,7 +11254,7 @@ Examples of floating point types and subtypes:
      type Mass is digits 7 range 0.0 .. 1.0E35;
 
 22
-     subtype Probability is Real range 0.0 .. 1.0;   --   a subtype with a 
smaller range
+     subtype Probability is Real range 0.0 .. 1.0;   --<   a subtype with a 
smaller range>
 
                      _Inconsistencies With Ada 83_
 
@@ -11298,13 +11314,13 @@ The following attribute is defined for every floating 
point subtype S:
 
 2/1
 S'Digits
-               {8652/00048652/0004} {AI95-00203-01AI95-00203-01}
+               {<8652/00048652/0004>} {<AI95-00203-01AI95-00203-01>}
                S'Digits denotes the requested decimal precision for the
                subtype S. The value of this attribute is of the type
-               universal_integer.  The requested decimal precision of
-               the base subtype of a floating point type T is defined to
-               be the largest value of d for which
-               ceiling(d * log(10) / log(T'Machine_Radix)) + g <=
+               <universal_integer>.  The requested decimal precision of
+               the base subtype of a floating point type <T> is defined
+               to be the largest value of <d> for which
+               ceiling(<d> * log(10) / log(T'Machine_Radix)) + <g> <=
                T'Model_Mantissa
                where g is 0 if Machine_Radix is a positive power of 10
                and 1 otherwise.
@@ -11328,8 +11344,9 @@ S'Digits
                      _Wording Changes from Ada 95_
 
 4.a/2
-          {8652/00048652/0004} {AI95-00203-01AI95-00203-01} Corrigendum:
-          Corrected the formula for Digits when the Machine_Radix is 10.
+          {<8652/00048652/0004>} {<AI95-00203-01AI95-00203-01>}
+          Corrigendum: Corrected the formula for Digits when the
+          Machine_Radix is 10.
 
 
 File: aarm2012.info,  Node: 3.5.9,  Next: 3.5.10,  Prev: 3.5.8,  Up: 3.5
@@ -11339,8 +11356,8 @@ File: aarm2012.info,  Node: 3.5.9,  Next: 3.5.10,  
Prev: 3.5.8,  Up: 3.5
 
 1
 A fixed point type is either an ordinary fixed point type, or a decimal
-fixed point type. The error bound of a fixed point type is specified as
-an absolute value, called the delta of the fixed point type.
+fixed point type.  The error bound of a fixed point type is specified as
+an absolute value, called the <delta> of the fixed point type.
 
                                _Syntax_
 
@@ -11350,32 +11367,32 @@ an absolute value, called the delta of the fixed 
point type.
 
 3
      ordinary_fixed_point_definition ::=
-        delta static_expression  real_range_specification
+        delta <static_>expression  real_range_specification
 
 4
      decimal_fixed_point_definition ::=
-        delta static_expression digits static_expression [
+        delta <static_>expression digits <static_>expression [
      real_range_specification]
 
 5/4
-     {AI12-0152-1AI12-0152-1} digits_constraint ::=
-        digits static_simple_expression [range_constraint]
+     {<AI12-0152-1AI12-0152-1>} digits_constraint ::=
+        digits <static_>simple_expression [range_constraint]
 
                         _Name Resolution Rules_
 
 6
-For a type defined by a fixed_point_definition, the delta of the type is
-specified by the value of the expression given after the reserved word
-delta; this expression is expected to be of any real type. For a type
-defined by a decimal_fixed_point_definition (a decimal fixed point
-type), the number of significant decimal digits for its first subtype
-(the digits of the first subtype) is specified by the expression given
-after the reserved word digits; this expression is expected to be of any
-integer type.
+For a type defined by a fixed_point_definition, the <delta> of the type
+is specified by the value of the expression given after the reserved
+word delta; this expression is expected to be of any real type.  For a
+type defined by a decimal_fixed_point_definition (a <decimal> fixed
+point type), the number of significant decimal digits for its first
+subtype (the <digits> of the first subtype) is specified by the
+expression given after the reserved word digits; this expression is
+expected to be of any integer type.
 
 6.1/4
-{AI12-0159-1AI12-0159-1} The simple_expression of a digits_constraint is
-expected to be of any integer type.
+{<AI12-0159-1AI12-0159-1>} The simple_expression of a digits_constraint
+is expected to be of any integer type.
 
                            _Legality Rules_
 
@@ -11385,35 +11402,35 @@ after the reserved words delta and digits shall be 
static; their values
 shall be positive.
 
 8/2
-{AI95-00100-01AI95-00100-01} The set of values of a fixed point type
-comprise the integral multiples of a number called the small of the
-type.  The machine numbers of a fixed point type are the values of the
+{<AI95-00100-01AI95-00100-01>} The set of values of a fixed point type
+comprise the integral multiples of a number called the <small> of the
+type.  The <machine numbers> of a fixed point type are the values of the
 type that can be represented exactly in every unconstrained variable of
-the type. For a type defined by an ordinary_fixed_point_definition (an
-ordinary fixed point type), the small may be specified by an
+the type.  For a type defined by an ordinary_fixed_point_definition (an
+<ordinary> fixed point type), the <small> may be specified by an
 attribute_definition_clause (*note 13.3: S0310.) (see *note 13.3::); if
-so specified, it shall be no greater than the delta of the type.  If not
-specified, the small of an ordinary fixed point type is an
-implementation-defined power of two less than or equal to the delta.
+so specified, it shall be no greater than the <delta> of the type.  If
+not specified, the <small> of an ordinary fixed point type is an
+implementation-defined power of two less than or equal to the <delta>.
 
 8.a
-          Implementation defined: The small of an ordinary fixed point
+          Implementation defined: The <small> of an ordinary fixed point
           type.
 
 9
-For a decimal fixed point type, the small equals the delta; the delta
-shall be a power of 10.  If a real_range_specification is given, both
-bounds of the range shall be in the range -(10**digits-1)*delta ..
-+(10**digits-1)*delta.
+For a decimal fixed point type, the <small> equals the <delta>; the
+<delta> shall be a power of 10.  If a real_range_specification is given,
+both bounds of the range shall be in the range -(10**<digits>-1)*<delta>
+..  +(10**<digits>-1)*<delta>.
 
 10
 A fixed_point_definition is illegal if the implementation does not
-support a fixed point type with the given small and specified range or
-digits.
+support a fixed point type with the given <small> and specified range or
+<digits>.
 
 10.a
-          Implementation defined: What combinations of small, range, and
-          digits are supported for fixed point types.
+          Implementation defined: What combinations of <small>, range,
+          and <digits> are supported for fixed point types.
 
 11
 For a subtype_indication with a digits_constraint, the subtype_mark
@@ -11432,10 +11449,10 @@ implementations.
 
 13
 An ordinary_fixed_point_definition defines an ordinary fixed point type
-whose base range includes at least all multiples of small that are
+whose base range includes at least all multiples of <small> that are
 between the bounds specified in the real_range_specification.  The base
 range of the type does not necessarily include the specified bounds
-themselves. An ordinary_fixed_point_definition (*note 3.5.9: S0048.)
+themselves.  An ordinary_fixed_point_definition (*note 3.5.9: S0048.)
 also defines a constrained first subtype of the type, with each bound of
 its range given by the closer to zero of:
 
@@ -11445,32 +11462,32 @@ its range given by the closer to zero of:
 
 14.a.1/1
           To be honest: The conversion mentioned above is not an
-          implicit subtype conversion (which is something that happens
+          <implicit subtype conversion> (which is something that happens
           at overload resolution, see *note 4.6::), although it happens
           implicitly.  Therefore, the freezing rules are not invoked on
           the type (which is important so that representation items can
-          be given for the type). 
+          be given for the type).  
 
 15
    * the corresponding bound of the base range.
 
 16
 A decimal_fixed_point_definition defines a decimal fixed point type
-whose base range includes at least the range -(10**digits-1)*delta ..
-+(10**digits-1)*delta. A decimal_fixed_point_definition also defines a
-constrained first subtype of the type.  If a real_range_specification is
-given, the bounds of the first subtype are given by a conversion of the
-values of the expressions of the real_range_specification. Otherwise,
-the range of the first subtype is -(10**digits-1)*delta ..
-+(10**digits-1)*delta.
+whose base range includes at least the range -(10**<digits>-1)*<delta>
+..  +(10**<digits>-1)*<delta>.  A decimal_fixed_point_definition also
+defines a constrained first subtype of the type.  If a
+real_range_specification is given, the bounds of the first subtype are
+given by a conversion of the values of the expressions of the
+real_range_specification.  Otherwise, the range of the first subtype is
+-(10**<digits>-1)*<delta> ..  +(10**<digits>-1)*<delta>.
 
 16.a.1/1
           To be honest: The conversion mentioned above is not an
-          implicit subtype conversion (which is something that happens
+          <implicit subtype conversion> (which is something that happens
           at overload resolution, see *note 4.6::), although it happens
           implicitly.  Therefore, the freezing rules are not invoked on
           the type (which is important so that representation items can
-          be given for the type). 
+          be given for the type).  
 
                           _Dynamic Semantics_
 
@@ -11479,18 +11496,18 @@ The elaboration of a fixed_point_definition creates 
the fixed point type
 and its first subtype.
 
 18/4
-{AI12-0152-1AI12-0152-1} For a digits_constraint on a decimal fixed
-point subtype with a given delta, if it does not have a
-range_constraint, then it specifies an implicit range -(10**D-1)*delta
-..  +(10**D-1)*delta, where D is the value of the simple_expression. A
-digits_constraint is compatible with a decimal fixed point subtype if
-the value of the simple_expression is no greater than the digits of the
-subtype, and if it specifies (explicitly or implicitly) a range that is
-compatible with the subtype.
+{<AI12-0152-1AI12-0152-1>} For a digits_constraint on a decimal fixed
+point subtype with a given <delta>, if it does not have a
+range_constraint, then it specifies an implicit range
+-(10**<D>-1)*<delta> ..  +(10**<D>-1)*<delta>, where <D> is the value of
+the simple_expression.  A digits_constraint is <compatible> with a
+decimal fixed point subtype if the value of the simple_expression is no
+greater than the <digits> of the subtype, and if it specifies
+(explicitly or implicitly) a range that is compatible with the subtype.
 
 18.a
-          Discussion: Except for the requirement that the digits
-          specified be no greater than the digits of the subtype being
+          Discussion: Except for the requirement that the <digits>
+          specified be no greater than the <digits> of the subtype being
           constrained, a digits_constraint is essentially equivalent to
           a range_constraint.
 
@@ -11508,12 +11525,12 @@ compatible with the subtype.
           compatible.
 
 18.e/2
-          {AI95-00114-01AI95-00114-01} A value of a scalar type belongs
-          to a constrained subtype of the type if it belongs to the
-          range of the subtype.  Attributes like Digits and Delta have
-          no effect on this fundamental rule.  So the obsolescent forms
-          of digits_constraints and delta_constraints that are called
-          "accuracy constraints" in RM83 don't really represent
+          {<AI95-00114-01AI95-00114-01>} A value of a scalar type
+          belongs to a constrained subtype of the type if it belongs to
+          the range of the subtype.  Attributes like Digits and Delta
+          have no effect on this fundamental rule.  So the obsolescent
+          forms of digits_constraints and delta_constraints that are
+          called "accuracy constraints" in RM83 don't really represent
           constraints on the values of the subtype, but rather primarily
           affect compatibility of the "constraint" with the subtype
           being "constrained."  In this sense, they might better be
@@ -11521,18 +11538,18 @@ compatible with the subtype.
 
 18.f
           Note that the digits_constraint on a decimal fixed point
-          subtype is a combination of an assertion about the digits of
+          subtype is a combination of an assertion about the <digits> of
           the subtype being further constrained, and a constraint on the
           range of the subtype being defined, either explicit or
           implicit.
 
 19/4
-{AI12-0152-1AI12-0152-1} The elaboration of a digits_constraint consists
-of the elaboration of the range_constraint, if any. If a
+{<AI12-0152-1AI12-0152-1>} The elaboration of a digits_constraint
+consists of the elaboration of the range_constraint, if any.  If a
 range_constraint is given, a check is made that the bounds of the range
-are both in the range -(10**D-1)*delta ..  +(10**D-1)*delta, where D is
-the value of the (static) simple_expression given after the reserved
-word digits. If this check fails, Constraint_Error is raised.
+are both in the range -(10**<D>-1)*<delta> ..  +(10**<D>-1)*<delta>,
+where <D> is the value of the (static) simple_expression given after the
+reserved word digits.  If this check fails, Constraint_Error is raised.
 
                      _Implementation Requirements_
 
@@ -11542,28 +11559,29 @@ The implementation shall support at least 24 bits of 
precision
 
 20.a
           Reason: This is sufficient to represent Standard.Duration with
-          a small no more than 50 milliseconds.
+          a <small> no more than 50 milliseconds.
 
                      _Implementation Permissions_
 
 21
-Implementations are permitted to support only smalls that are a power of
-two.  In particular, all decimal fixed point type declarations can be
+Implementations are permitted to support only <small>s that are a power
+of two.  In particular, all decimal fixed point type declarations can be
 disallowed.  Note however that conformance with the Information Systems
-Annex requires support for decimal smalls, and decimal fixed point type
-declarations with digits up to at least 18.
+Annex requires support for decimal <small>s, and decimal fixed point
+type declarations with <digits> up to at least 18.
 
 21.a
           Implementation Note: The accuracy requirements for
           multiplication, division, and conversion (see *note G.2.1::,
           "*note G.2.1:: Model of Floating Point Arithmetic") are such
-          that support for arbitrary smalls should be practical without
-          undue implementation effort.  Therefore, implementations
-          should support fixed point types with arbitrary values for
-          small (within reason).  One reasonable limitation would be to
-          limit support to fixed point types that can be converted to
-          the most precise floating point type without loss of precision
-          (so that Fixed_IO is implementable in terms of Float_IO).
+          that support for arbitrary <small>s should be practical
+          without undue implementation effort.  Therefore,
+          implementations should support fixed point types with
+          arbitrary values for <small> (within reason).  One reasonable
+          limitation would be to limit support to fixed point types that
+          can be converted to the most precise floating point type
+          without loss of precision (so that Fixed_IO is implementable
+          in terms of Float_IO).
 
      NOTES
 
@@ -11574,7 +11592,7 @@ declarations with digits up to at least 18.
 
 23
              type Fraction is delta 2.0**(-15) range -1.0 .. 1.0;
-            
+  
 
 24
      With 2's complement hardware, such a type could have a signed
@@ -11584,40 +11602,40 @@ declarations with digits up to at least 18.
                               _Examples_
 
 25
-Examples of fixed point types and subtypes:
+<Examples of fixed point types and subtypes:>
 
 26
      type Volt is delta 0.125 range 0.0 .. 255.0;
 
 27
-       -- A pure fraction which requires all the available
-       -- space in a word can be declared as the type Fraction:
+       -- <A pure fraction which requires all the available>
+       -- <space in a word can be declared as the type Fraction:>
      type Fraction is delta System.Fine_Delta range -1.0 .. 1.0;
-       -- Fraction'Last = 1.0 - System.Fine_Delta
+       -- <Fraction'Last = 1.0 - System.Fine_Delta>
 
 28
-     type Money is delta 0.01 digits 15;  -- decimal fixed point
+     type Money is delta 0.01 digits 15;  -- <decimal fixed point>
      subtype Salary is Money digits 10;
-       -- Money'Last = 10.0**13 - 0.01, Salary'Last = 10.0**8 - 0.01
+       -- <Money'Last = 10.0**13 - 0.01, Salary'Last = 10.0**8 - 0.01>
 
                      _Inconsistencies With Ada 83_
 
 28.a
           In Ada 95, S'Small always equals S'Base'Small, so if an
-          implementation chooses a small for a fixed point type smaller
-          than required by the delta, the value of S'Small in Ada 95
-          might not be the same as it was in Ada 83.
+          implementation chooses a <small> for a fixed point type
+          smaller than required by the <delta>, the value of S'Small in
+          Ada 95 might not be the same as it was in Ada 83.
 
                         _Extensions to Ada 83_
 
 28.b/3
-          {AI05-0005-1AI05-0005-1} Decimal fixed point types are new,
+          {<AI05-0005-1AI05-0005-1>} Decimal fixed point types are new,
           though their capabilities are essentially similar to that
-          available in Ada 83 with a fixed point type whose small equals
-          its delta and both are a power of 10.  However, in the
-          Information Systems Annex, additional requirements are placed
-          on the support of decimal fixed point types (e.g.  a minimum
-          of 18 digits of precision).
+          available in Ada 83 with a fixed point type whose <small>
+          equals its <delta> and both are a power of 10.  However, in
+          the Information Systems Annex, additional requirements are
+          placed on the support of decimal fixed point types (e.g.  a
+          minimum of 18 digits of precision).
 
                      _Wording Changes from Ada 83_
 
@@ -11631,14 +11649,14 @@ Examples of fixed point types and subtypes:
                      _Wording Changes from Ada 95_
 
 28.d/2
-          {AI95-00100-01AI95-00100-01} Added wording to define the
+          {<AI95-00100-01AI95-00100-01>} Added wording to define the
           machine numbers of fixed point types; this is needed by the
           static evaluation rules.
 
                    _Incompatibilities With Ada 2012_
 
 28.e/4
-          {AI12-0152-1AI12-0152-1} Corrigendum: Changed the syntax so
+          {<AI12-0152-1AI12-0152-1>} Corrigendum: Changed the syntax so
           that the value following digits in a digits_constraint is a
           simple_expression.  This is compatible with one very unlikely
           exception: if the digits expression is a static expression of
@@ -11650,7 +11668,7 @@ Examples of fixed point types and subtypes:
                     _Wording Changes from Ada 2012_
 
 28.f/4
-          {AI12-0159-1AI12-0159-1} Corrigendum:Added wording to define
+          {<AI12-0159-1AI12-0159-1>} Corrigendum:Added wording to define
           the expected type for a digits_constraint.  This was missing
           since Ada 95, but as it is obvious and unchanged from Ada 83,
           we don't consider it an incompatibility.
@@ -11668,13 +11686,13 @@ The following attributes are defined for every fixed 
point subtype S:
 
 2/1
 S'Small
-               {8652/00058652/0005} {AI95-00054-01AI95-00054-01} S'Small
-               denotes the small of the type of S. The value of this
-               attribute is of the type universal_real. Small may be
-               specified for nonderived ordinary fixed point types via
-               an attribute_definition_clause (*note 13.3: S0310.) (see
-               *note 13.3::); the expression of such a clause shall be
-               static.
+               {<8652/00058652/0005>} {<AI95-00054-01AI95-00054-01>}
+               S'Small denotes the <small> of the type of S. The value
+               of this attribute is of the type <universal_real>.  Small
+               may be specified for nonderived ordinary fixed point
+               types via an attribute_definition_clause (*note 13.3:
+               S0310.) (see *note 13.3::); the expression of such a
+               clause shall be static.
 
 2.a/3
           Aspect Description for Small: Scale factor for a fixed point
@@ -11682,14 +11700,14 @@ S'Small
 
 3
 S'Delta
-               S'Delta denotes the delta of the fixed point subtype S.
+               S'Delta denotes the <delta> of the fixed point subtype S.
                The value of this attribute is of the type
-               universal_real.
+               <universal_real>.
 
 3.a
-          Reason: The delta is associated with the subtype as opposed to
-          the type, because of the possibility of an (obsolescent)
-          delta_constraint.
+          Reason: The <delta> is associated with the <sub>type as
+          opposed to the type, because of the possibility of an
+          (obsolescent) delta_constraint.
 
 4
 S'Fore
@@ -11700,17 +11718,18 @@ S'Fore
                a one-character prefix that is either a minus sign or a
                space.  (This minimum number does not include superfluous
                zeros or underlines, and is at least 2.)  The value of
-               this attribute is of the type universal_integer.
+               this attribute is of the type <universal_integer>.
 
 5
 S'Aft
                S'Aft yields the number of decimal digits needed after
-               the decimal point to accommodate the delta of the subtype
-               S, unless the delta of the subtype S is greater than 0.1,
-               in which case the attribute yields the value one.
-               [(S'Aft is the smallest positive integer N for which
-               (10**N)*S'Delta is greater than or equal to one.)]  The
-               value of this attribute is of the type universal_integer.
+               the decimal point to accommodate the <delta> of the
+               subtype S, unless the <delta> of the subtype S is greater
+               than 0.1, in which case the attribute yields the value
+               one.  [(S'Aft is the smallest positive integer N for
+               which (10**N)*S'Delta is greater than or equal to one.)]
+               The value of this attribute is of the type
+               <universal_integer>.
 
 6
 The following additional attributes are defined for every decimal fixed
@@ -11718,11 +11737,12 @@ point subtype S:
 
 7
 S'Digits
-               S'Digits denotes the digits of the decimal fixed point
+               S'Digits denotes the <digits> of the decimal fixed point
                subtype S, which corresponds to the number of decimal
                digits that are representable in objects of the subtype.
                The value of this attribute is of the type
-               universal_integer.  Its value is determined as follows: 
+               <universal_integer>.  Its value is determined as follows:
+               
 
 8
                   * For a first subtype or a subtype defined by a
@@ -11745,17 +11765,18 @@ S'Digits
 
 10
                   * The digits of a base subtype is the largest integer
-                    D such that the range -(10**D-1)*delta ..
-                    +(10**D-1)*delta is included in the base range of
-                    the type.
+                    <D> such that the range -(10**<D>-1)*<delta> ..
+                    +(10**<D>-1)*<delta> is included in the base range
+                    of the type.
 
 11
 S'Scale
-               S'Scale denotes the scale of the subtype S, defined as
+               S'Scale denotes the <scale> of the subtype S, defined as
                the value N such that S'Delta = 10.0**(-N). [The scale
                indicates the position of the point relative to the
                rightmost significant digits of values of subtype S.] The
-               value of this attribute is of the type universal_integer.
+               value of this attribute is of the type
+               <universal_integer>.
 
 11.a
           Ramification: S'Scale is negative if S'Delta is greater than
@@ -11767,7 +11788,7 @@ S'Round
                specification:
 
 13
-                    function S'Round(X : universal_real)
+                    function S'Round(<X> : <universal_real>)
                       return S'Base
 
 14
@@ -11802,9 +11823,9 @@ S'Round
                      _Wording Changes from Ada 95_
 
 18.a/2
-          {8652/00058652/0005} {AI95-00054-01AI95-00054-01} Corrigendum:
-          Clarified that small may be specified only for ordinary fixed
-          point types.
+          {<8652/00058652/0005>} {<AI95-00054-01AI95-00054-01>}
+          Corrigendum: Clarified that <small> may be specified only for
+          ordinary fixed point types.
 
 
 File: aarm2012.info,  Node: 3.6,  Next: 3.7,  Prev: 3.5,  Up: 3
@@ -11813,11 +11834,11 @@ File: aarm2012.info,  Node: 3.6,  Next: 3.7,  Prev: 
3.5,  Up: 3
 ===============
 
 1
-An array object is a composite object consisting of components which all
-have the same subtype.  The name for a component of an array uses one or
-more index values belonging to specified discrete types.  The value of
-an array object is a composite value consisting of the values of the
-components.
+An <array> object is a composite object consisting of components which
+all have the same subtype.  The name for a component of an array uses
+one or more index values belonging to specified discrete types.  The
+value of an array object is a composite value consisting of the values
+of the components.
 
                                _Syntax_
 
@@ -11839,10 +11860,11 @@ components.
      discrete_subtype_definition}) of component_definition
 
 6
-     discrete_subtype_definition ::= discrete_subtype_indication | range
+     discrete_subtype_definition ::= <discrete_>subtype_indication | 
+     range
 
 7/2
-     {AI95-00230-01AI95-00230-01} {AI95-00406-01AI95-00406-01}
+     {<AI95-00230-01AI95-00230-01>} {<AI95-00406-01AI95-00406-01>}
      component_definition ::=
         [aliased] subtype_indication
       | [aliased] access_definition
@@ -11853,23 +11875,24 @@ components.
 For a discrete_subtype_definition that is a range, the range shall
 resolve to be of some specific discrete type[; which discrete type shall
 be determined without using any context other than the bounds of the
-range itself (plus the preference for root_integer -- see *note 8.6::).]
+range itself (plus the preference for <root_integer> -- see *note
+8.6::).]
 
                            _Legality Rules_
 
 9
 Each index_subtype_definition or discrete_subtype_definition in an
-array_type_definition defines an index subtype; its type (the index
-type) shall be discrete.
+array_type_definition defines an <index subtype>; its type (the <index
+type>) shall be discrete.
 
 9.a
-          Discussion: An index is a discrete quantity used to select
+          Discussion: An <index> is a discrete quantity used to select
           along a given dimension of an array.  A component is selected
           by specifying corresponding values for each of the indices.
 
 10
 The subtype defined by the subtype_indication of a component_definition
-(the component subtype) shall be a definite subtype.
+(the <component subtype>) shall be a definite subtype.
 
 10.a
           Ramification: This applies to all uses of
@@ -11877,12 +11900,12 @@ The subtype defined by the subtype_indication of a 
component_definition
           protected_definitions.
 
 11/2
-This paragraph was deleted.{AI95-00363-01AI95-00363-01}
+<This paragraph was deleted.>{<AI95-00363-01AI95-00363-01>}
 
                           _Static Semantics_
 
 12
-An array is characterized by the number of indices (the dimensionality
+An array is characterized by the number of indices (the <dimensionality>
 of the array), the type and position of each index, the lower and upper
 bounds for each index, and the subtype of the components.  The order of
 the indices is significant.
@@ -11893,11 +11916,11 @@ value.  A multidimensional array has a distinct 
component for each
 possible sequence of index values that can be formed by selecting one
 value for each index position (in the given order).  The possible values
 for a given index are all the values between the lower and upper bounds,
-inclusive; this range of values is called the index range. The bounds of
-an array are the bounds of its index ranges. The length of a dimension
-of an array is the number of values of the index range of the dimension
-(zero for a null range). The length of a one-dimensional array is the
-length of its only dimension.
+inclusive; this range of values is called the <index range>.  The
+<bounds> of an array are the bounds of its index ranges.  The <length>
+of a dimension of an array is the number of values of the index range of
+the dimension (zero for a null range).  The <length> of a
+one-dimensional array is the length of its only dimension.
 
 14
 An array_type_definition defines an array type and its first subtype.
@@ -11912,19 +11935,19 @@ An unconstrained_array_definition defines an array 
type with an
 unconstrained first subtype.  Each index_subtype_definition (*note 3.6:
 S0053.) defines the corresponding index subtype to be the subtype
 denoted by the subtype_mark (*note 3.2.2: S0028.).  [ The compound
-delimiter <> (called a box) of an index_subtype_definition stands for an
-undefined range (different objects of the type need not have the same
+delimiter <> (called a <box>) of an index_subtype_definition stands for
+an undefined range (different objects of the type need not have the same
 bounds).]
 
 16
 A constrained_array_definition defines an array type with a constrained
 first subtype.  Each discrete_subtype_definition (*note 3.6: S0055.)
 defines the corresponding index subtype, as well as the corresponding
-index range for the constrained first subtype. The constraint of the
+index range for the constrained first subtype.  The <constraint> of the
 first subtype consists of the bounds of the index ranges.
 
 16.a/3
-          Discussion: {AI05-0005-1AI05-0005-1} Although there is no
+          Discussion: {<AI05-0005-1AI05-0005-1>} Although there is no
           nameable unconstrained array subtype in this case, the
           predefined slicing and concatenation operations can operate on
           and yield values that do not necessarily belong to the first
@@ -11936,7 +11959,7 @@ The discrete subtype defined by a 
discrete_subtype_definition (*note
 3.2.2: S0027.), or a subtype determined by the range as follows:
 
 18
-   * If the type of the range resolves to root_integer, then the
+   * If the type of the range resolves to <root_integer>, then the
      discrete_subtype_definition defines a subtype of the predefined
      type Integer with bounds given by a conversion to Integer of the
      bounds of the range; 
@@ -11944,12 +11967,12 @@ The discrete subtype defined by a 
discrete_subtype_definition (*note
 18.a
           Reason: This ensures that indexing over the discrete subtype
           can be performed with regular Integers, rather than only
-          universal_integers.
+          <universal_integer>s.
 
 18.b
           Discussion: We considered doing this by simply creating a
-          "preference" for Integer when resolving the range. However,
-          this can introduce Beaujolais effects when the
+          "preference" for Integer when resolving the range.  However,
+          this can introduce <Beaujolais> effects when the
           simple_expressions involve calls on functions visible due to
           use clauses.
 
@@ -11972,14 +11995,14 @@ discrete_subtype_definition (*note 3.6: S0055.)s and 
the
 component_definition (*note 3.6: S0056.).
 
 22/2
-{8652/00028652/0002} {AI95-00171-01AI95-00171-01}
-{AI95-00230-01AI95-00230-01} The elaboration of a
+{<8652/00028652/0002>} {<AI95-00171-01AI95-00171-01>}
+{<AI95-00230-01AI95-00230-01>} The elaboration of a
 discrete_subtype_definition that does not contain any per-object
 expressions creates the discrete subtype, and consists of the
 elaboration of the subtype_indication (*note 3.2.2: S0027.) or the
 evaluation of the range.  The elaboration of a
 discrete_subtype_definition that contains one or more per-object
-expressions is defined in *note 3.8::. The elaboration of a
+expressions is defined in *note 3.8::.  The elaboration of a
 component_definition (*note 3.6: S0056.) in an array_type_definition
 (*note 3.6: S0051.) consists of the elaboration of the
 subtype_indication (*note 3.2.2: S0027.) or access_definition.  The
@@ -11990,9 +12013,9 @@ performed in an arbitrary order.
                           _Static Semantics_
 
 22.1/3
-{AI05-0228-1AI05-0228-1} For an array type with a scalar component type,
-the following language-defined representation aspect may be specified
-with an aspect_specification (see *note 13.1.1::):
+{<AI05-0228-1AI05-0228-1>} For an array type with a scalar component
+type, the following language-defined representation aspect may be
+specified with an aspect_specification (see *note 13.1.1::):
 
 22.2/3
 Default_Component_Value
@@ -12018,9 +12041,9 @@ Default_Component_Value
           for the components of an array-of-scalar subtype.
 
 22.3/3
-{AI05-0228-1AI05-0228-1} If a derived type with no primitive subprograms
-inherits a boolean Default_Component_Value aspect, the aspect may be
-specified to have any value for the derived type.
+{<AI05-0228-1AI05-0228-1>} If a derived type with no primitive
+subprograms inherits a boolean Default_Component_Value aspect, the
+aspect may be specified to have any value for the derived type.
 
 22.d/3
           Reason: This overrides the *note 13.1.1:: rule that says that
@@ -12029,9 +12052,10 @@ specified to have any value for the derived type.
                         _Name Resolution Rules_
 
 22.4/3
-{AI05-0228-1AI05-0228-1} The expected type for the expression specified
-for the Default_Component_Value aspect is the component type of the
-array type defined by the full_type_declaration on which it appears.
+{<AI05-0228-1AI05-0228-1>} The expected type for the expression
+specified for the Default_Component_Value aspect is the component type
+of the array type defined by the full_type_declaration on which it
+appears.
 
      NOTES
 
@@ -12050,16 +12074,16 @@ array type defined by the full_type_declaration on 
which it appears.
                               _Examples_
 
 25
-Examples of type declarations with unconstrained array definitions:
+<Examples of type declarations with unconstrained array definitions: >
 
 26
      type Vector     is array(Integer  range <>) of Real;
      type Matrix     is array(Integer  range <>, Integer range <>) of Real;
      type Bit_Vector is array(Integer  range <>) of Boolean;
-     type Roman      is array(Positive range <>) of Roman_Digit; -- see *note 
3.5.2::
+     type Roman      is array(Positive range <>) of Roman_Digit; --< see *note 
3.5.2::>
 
 27
-Examples of type declarations with constrained array definitions:
+<Examples of type declarations with constrained array definitions: >
 
 28
      type Table    is array(1 .. 10) of Integer;
@@ -12067,17 +12091,17 @@ Examples of type declarations with constrained array 
definitions:
      type Line     is array(1 .. Max_Line_Size) of Character;
 
 29
-Examples of object declarations with array type definitions:
+<Examples of object declarations with array type definitions: >
 
 30/2
-     {AI95-00433-01AI95-00433-01} Grid      : array(1 .. 80, 1 .. 100) of 
Boolean;
+     {<AI95-00433-01AI95-00433-01>} Grid      : array(1 .. 80, 1 .. 100) of 
Boolean;
      Mix       : array(Color range Red .. Green) of Boolean;
      Msg_Table : constant array(Error_Code) of access constant String :=
            (Too_Big => new String'("Result too big"), Too_Small => ...);
-     Page      : array(Positive range <>) of Line :=  --  an array of arrays
-       (1 | 50  => Line'(1 | Line'Last => '+', others => '-'),  -- see *note 
4.3.3::
+     Page      : array(Positive range <>) of Line :=  --<  an array of arrays>
+       (1 | 50  => Line'(1 | Line'Last => '+', others => '-'),  --< see *note 
4.3.3::>
         2 .. 49 => Line'(1 | Line'Last => '|', others => ' '));
-         -- Page is constrained by its initial value to (1..50)
+         --< Page is constrained by its initial value to (1..50)>
 
                         _Extensions to Ada 83_
 
@@ -12089,7 +12113,7 @@ Examples of object declarations with array type 
definitions:
           The syntax rules for unconstrained_array_definition and
           constrained_array_definition are modified to use
           component_definition (instead of
-          component_subtype_indication).  The effect of this change is
+          <component_>subtype_indication).  The effect of this change is
           to allow the reserved word aliased before the component
           subtype_indication.
 
@@ -12122,11 +12146,11 @@ Examples of object declarations with array type 
definitions:
                         _Extensions to Ada 95_
 
 30.g/2
-          {AI95-00230-01AI95-00230-01} {AI95-00406-01AI95-00406-01}
+          {<AI95-00230-01AI95-00230-01>} {<AI95-00406-01AI95-00406-01>}
           Array components can have an anonymous access type.
 
 30.h/2
-          {AI95-00363-01AI95-00363-01} The prohibition against
+          {<AI95-00363-01AI95-00363-01>} The prohibition against
           unconstrained discriminated aliased components has been
           lifted.  It has been replaced by a prohibition against the
           actual troublemakers: general access discriminant constraints
@@ -12135,14 +12159,14 @@ Examples of object declarations with array type 
definitions:
                      _Wording Changes from Ada 95_
 
 30.i/2
-          {8652/00028652/0002} {AI95-00171-01AI95-00171-01} Corrigendum:
-          Added wording to allow the elaboration of per-object
-          constraints for constrained arrays.
+          {<8652/00028652/0002>} {<AI95-00171-01AI95-00171-01>}
+          Corrigendum: Added wording to allow the elaboration of
+          per-object constraints for constrained arrays.
 
                        _Extensions to Ada 2005_
 
 30.j/3
-          {AI05-0228-1AI05-0228-1} The new aspect
+          {<AI05-0228-1AI05-0228-1>} The new aspect
           Default_Component_Value allows defining implicit initial
           values (see *note 3.3.1::) for arrays of scalar types.
 
@@ -12168,13 +12192,13 @@ index of an array subtype, and thereby the 
corresponding array bounds.
      index_constraint ::=  (discrete_range {, discrete_range})
 
 3
-     discrete_range ::= discrete_subtype_indication | range
+     discrete_range ::= <discrete_>subtype_indication | range
 
                         _Name Resolution Rules_
 
 4
 The type of a discrete_range is the type of the subtype defined by the
-subtype_indication, or the type of the range. For an index_constraint,
+subtype_indication, or the type of the range.  For an index_constraint,
 each discrete_range shall resolve to be of the type of the corresponding
 index.
 
@@ -12201,13 +12225,13 @@ by the range of the subtype defined by the 
subtype_indication.
                           _Dynamic Semantics_
 
 7
-An index_constraint is compatible with an unconstrained array subtype if
-and only if the index range defined by each discrete_range is compatible
-(see *note 3.5::) with the corresponding index subtype. If any of the
-discrete_ranges defines a null range, any array thus constrained is a
-null array, having no components. An array value satisfies an
-index_constraint if at each index position the array value and the
-index_constraint have the same index bounds.
+An index_constraint is <compatible> with an unconstrained array subtype
+if and only if the index range defined by each discrete_range is
+compatible (see *note 3.5::) with the corresponding index subtype.  If
+any of the discrete_ranges defines a null range, any array thus
+constrained is a <null array>, having no components.  An array value
+<satisfies> an index_constraint if at each index position the array
+value and the index_constraint have the same index bounds.
 
 7.a
           Ramification: There is no need to define compatibility with a
@@ -12216,7 +12240,7 @@ index_constraint have the same index bounds.
 
 8
 The elaboration of an index_constraint consists of the evaluation of the
-discrete_range(s), in an arbitrary order. The evaluation of a
+discrete_range(s), in an arbitrary order.  The evaluation of a
 discrete_range consists of the elaboration of the subtype_indication or
 the evaluation of the range.
 
@@ -12237,24 +12261,24 @@ the evaluation of the range.
                               _Examples_
 
 11
-Examples of array declarations including an index constraint:
+<Examples of array declarations including an index constraint: >
 
 12
-     Board     : Matrix(1 .. 8,  1 .. 8);  --  see *note 3.6::
+     Board     : Matrix(1 .. 8,  1 .. 8);  --<  see *note 3.6::>
      Rectangle : Matrix(1 .. 20, 1 .. 30);
-     Inverse   : Matrix(1 .. N,  1 .. N);  --  N need not be static 
+     Inverse   : Matrix(1 .. N,  1 .. N);  --<  N need not be static >
 
 13
      Filter    : Bit_Vector(0 .. 31);
 
 14
-Example of array declaration with a constrained array subtype:
+<Example of array declaration with a constrained array subtype: >
 
 15
-     My_Schedule : Schedule;  --  all arrays of type Schedule have the same 
bounds
+     My_Schedule : Schedule;  --<  all arrays of type Schedule have the same 
bounds>
 
 16
-Example of record type with a component that is an array:
+<Example of record type with a component that is an array: >
 
 17
      type Var_Line(Length : Natural) is
@@ -12263,7 +12287,7 @@ Example of record type with a component that is an 
array:
         end record;
 
 18
-     Null_Line : Var_Line(0);  --  Null_Line.Image is a null array
+     Null_Line : Var_Line(0);  --<  Null_Line.Image is a null array>
 
                         _Extensions to Ada 83_
 
@@ -12307,7 +12331,7 @@ dimensionality of the array.
                           _Static Semantics_
 
 2/1
-{8652/00068652/0006} {AI95-00030-01AI95-00030-01} The following
+{<8652/00068652/0006>} {<AI95-00030-01AI95-00030-01>} The following
 attributes are defined for a prefix A that is of an array type [(after
 any implicit dereference)], or denotes a constrained array subtype:
 
@@ -12351,18 +12375,18 @@ A'Range(N)
 A'Length
                A'Length denotes the number of values of the first index
                range (zero for a null range); its type is
-               universal_integer.
+               <universal_integer>.
 
 10
 A'Length(N)
                A'Length(N) denotes the number of values of the N-th
                index range (zero for a null range); its type is
-               universal_integer.
+               <universal_integer>.
 
                         _Implementation Advice_
 
 11/3
-{AI05-0229-1AI05-0229-1} An implementation should normally represent
+{<AI05-0229-1AI05-0229-1>} An implementation should normally represent
 multidimensional arrays in row-major order, consistent with the notation
 used for multidimensional array aggregates (see *note 4.3.3::).
 However, if convention Fortran is specified for a multidimensional array
@@ -12401,7 +12425,7 @@ type, then column-major order should be used instead 
(see *note B.5::,
      operators are also included.
 
 16/2
-     56  {AI95-00287-01AI95-00287-01} A component of an array can be
+     56  {<AI95-00287-01AI95-00287-01>} A component of an array can be
      named with an indexed_component.  A value of an array type can be
      specified with an array_aggregate.  For a one-dimensional array
      type, a slice of the array can be named; also, string literals are
@@ -12410,8 +12434,8 @@ type, then column-major order should be used instead 
(see *note B.5::,
                               _Examples_
 
 17
-Examples (using arrays declared in the examples of subclause *note
-3.6.1::):
+<Examples (using arrays declared in the examples of subclause *note
+3.6.1::):>
 
 18
      --  Filter'First      =   0   Filter'Last       =  31   Filter'Length =  
32
@@ -12427,10 +12451,10 @@ File: aarm2012.info,  Node: 3.6.3,  Prev: 3.6.2,  Up: 
3.6
 
 1
 A one-dimensional array type whose component type is a character type is
-called a string type.
+called a <string> type.
 
 2/2
-{AI95-00285-01AI95-00285-01} [There are three predefined string types,
+{<AI95-00285-01AI95-00285-01>} [There are three predefined string types,
 String, Wide_String, and Wide_Wide_String, each indexed by values of the
 predefined subtype Positive; these are declared in the visible part of
 package Standard:]
@@ -12439,7 +12463,7 @@ package Standard:]
      [subtype Positive is Integer range 1 .. Integer'Last;
 
 4/2
-     {AI95-00285-01AI95-00285-01} type String is array(Positive range <>) of 
Character;
+     {<AI95-00285-01AI95-00285-01>} type String is array(Positive range <>) of 
Character;
      type Wide_String is array(Positive range <>) of Wide_Character;
      type Wide_Wide_String is array(Positive range <>) of Wide_Wide_Character;
      ]
@@ -12458,17 +12482,17 @@ package Standard:]
                               _Examples_
 
 6
-Examples of string objects:
+<Examples of string objects:>
 
 7
      Stars      : String(1 .. 120) := (1 .. 120 => '*' );
      Question   : constant String  := "How many characters?";
-        -- Question'First = 1, Question'Last = 20
-        -- Question'Length = 20 (the number of characters)
+        --< Question'First = 1, Question'Last = 20>
+        --< Question'Length = 20 (the number of characters)>
 
 8
-     Ask_Twice  : String  := Question & Question;   -- constrained to (1..40)
-     Ninety_Six : constant Roman   := "XCVI";   -- see *note 3.5.2:: and *note 
3.6::
+     Ask_Twice  : String  := Question & Question;   --< constrained to (1..40)>
+     Ninety_Six : constant Roman   := "XCVI";   --< see *note 3.5.2:: and 
*note 3.6::>
 
                      _Inconsistencies With Ada 83_
 
@@ -12500,13 +12524,13 @@ Examples of string objects:
                      _Wording Changes from Ada 83_
 
 8.f
-          We define the term string type as a natural analogy to the
-          term character type.
+          We define the term <string type> as a natural analogy to the
+          term <character type>.
 
                      _Inconsistencies With Ada 95_
 
 8.g/2
-          {AI95-00285-01AI95-00285-01} The declaration of
+          {<AI95-00285-01AI95-00285-01>} The declaration of
           Wide_Wide_String in Standard hides a use-visible declaration
           with the same defining_identifier.  In the (very) unlikely
           event that an Ada 95 program had depended on such a
@@ -12517,7 +12541,8 @@ Examples of string objects:
                         _Extensions to Ada 95_
 
 8.h/2
-          {AI95-00285-01AI95-00285-01} The type Wide_Wide_String is new.
+          {<AI95-00285-01AI95-00285-01>} The type Wide_Wide_String is
+          new.
 
 
 File: aarm2012.info,  Node: 3.7,  Next: 3.8,  Prev: 3.6,  Up: 3
@@ -12526,14 +12551,15 @@ File: aarm2012.info,  Node: 3.7,  Next: 3.8,  Prev: 
3.6,  Up: 3
 =================
 
 1/2
-{AI95-00251-01AI95-00251-01} {AI95-00326-01AI95-00326-01} [ A composite
-type (other than an array or interface type) can have discriminants,
-which parameterize the type.  A known_discriminant_part specifies the
-discriminants of a composite type.  A discriminant of an object is a
-component of the object, and is either of a discrete type or an access
-type.  An unknown_discriminant_part in the declaration of a view of a
-type specifies that the discriminants of the type are unknown for the
-given view; all subtypes of such a view are indefinite subtypes.]
+{<AI95-00251-01AI95-00251-01>} {<AI95-00326-01AI95-00326-01>} [ A
+composite type (other than an array or interface type) can have
+discriminants, which parameterize the type.  A known_discriminant_part
+specifies the discriminants of a composite type.  A discriminant of an
+object is a component of the object, and is either of a discrete type or
+an access type.  An unknown_discriminant_part in the declaration of a
+view of a type specifies that the discriminants of the type are unknown
+for the given view; all subtypes of such a view are indefinite
+subtypes.]
 
 1.a/2
           Glossary entry: A discriminant is a parameter for a composite
@@ -12543,17 +12569,17 @@ given view; all subtypes of such a view are 
indefinite subtypes.]
           upon creation.
 
 1.b/2
-          Discussion: {AI95-00114-01AI95-00114-01} A view of a type, and
-          all subtypes of the view, have unknown discriminants when the
-          number or names of the discriminants, if any, are unknown at
-          the point of the type declaration for the view.  A
+          Discussion: {<AI95-00114-01AI95-00114-01>} A view of a type,
+          and all subtypes of the view, have <unknown discriminants>
+          when the number or names of the discriminants, if any, are
+          unknown at the point of the type declaration for the view.  A
           discriminant_part of (<>) is used to indicate unknown
           discriminants.
 
                      _Language Design Principles_
 
 1.c/2
-          {AI95-00402-01AI95-00402-01} When an access discriminant is
+          {<AI95-00402-01AI95-00402-01>} When an access discriminant is
           initialized at the time of object creation with an allocator
           of an anonymous type, the allocated object and the object with
           the discriminant are tied together for their lifetime.  They
@@ -12600,7 +12626,7 @@ given view; all subtypes of such a view are indefinite 
subtypes.]
         (discriminant_specification {; discriminant_specification})
 
 5/2
-     {AI95-00231-01AI95-00231-01} discriminant_specification ::=
+     {<AI95-00231-01AI95-00231-01>} discriminant_specification ::=
         defining_identifier_list : [null_exclusion] subtype_mark [:= 
      default_expression]
       | defining_identifier_list : access_definition [:= 
@@ -12618,11 +12644,11 @@ discriminant_specification is that of the 
corresponding discriminant.
                            _Legality Rules_
 
 8/2
-{8652/00078652/0007} {AI95-00098-01AI95-00098-01}
-{AI95-00251-01AI95-00251-01} A discriminant_part is only permitted in a
-declaration for a composite type that is not an array or interface type
-[(this includes generic formal types)].  A type declared with a
-known_discriminant_part is called a discriminated type, as is a type
+{<8652/00078652/0007>} {<AI95-00098-01AI95-00098-01>}
+{<AI95-00251-01AI95-00251-01>} A discriminant_part is only permitted in
+a declaration for a composite type that is not an array or interface
+type [(this includes generic formal types)].  A type declared with a
+known_discriminant_part is called a <discriminated> type, as is a type
 that inherits (known) discriminants.
 
 8.a
@@ -12640,23 +12666,24 @@ that inherits (known) discriminants.
           composite, much less have any discriminants.
 
 8.b.1/1
-          {8652/00078652/0007} {AI95-00098-01AI95-00098-01} On the other
-          hand, unknown_discriminant_parts cannot be applied to type
-          declarations that cannot have a known_discriminant_part.
+          {<8652/00078652/0007>} {<AI95-00098-01AI95-00098-01>} On the
+          other hand, unknown_discriminant_parts cannot be applied to
+          type declarations that cannot have a known_discriminant_part.
           There is no point in having unknown discriminants on a type
           that can never have discriminants (for instance, a formal
           modular type), even when these are allowed syntactically.
 
 9/2
-{AI95-00231-01AI95-00231-01} {AI95-00254-01AI95-00254-01} The subtype of
-a discriminant may be defined by an optional null_exclusion and a
-subtype_mark, in which case the subtype_mark shall denote a discrete or
-access subtype, or it may be defined by an access_definition. A
-discriminant that is defined by an access_definition is called an access
-discriminant and is of an anonymous access type.
+{<AI95-00231-01AI95-00231-01>} {<AI95-00254-01AI95-00254-01>} The
+subtype of a discriminant may be defined by an optional null_exclusion
+and a subtype_mark, in which case the subtype_mark shall denote a
+discrete or access subtype, or it may be defined by an
+access_definition.  A discriminant that is defined by an
+access_definition is called an <access discriminant> and is of an
+anonymous access type.
 
 9.a/2
-          This paragraph was deleted.{AI95-00230-01AI95-00230-01}
+          <This paragraph was deleted.>{<AI95-00230-01AI95-00230-01>}
 
 9.b
           Reason: Note that discriminants of a named access type are not
@@ -12665,7 +12692,7 @@ discriminant and is of an anonymous access type.
           access_definition.
 
 9.1/3
-{AI95-00402-01AI95-00402-01} {AI05-0214-1AI05-0214-1}
+{<AI95-00402-01AI95-00402-01>} {<AI05-0214-1AI05-0214-1>}
 Default_expressions shall be provided either for all or for none of the
 discriminants of a known_discriminant_part (*note 3.7: S0061.).  No
 default_expression (*note 3.7: S0063.)s are permitted in a
@@ -12683,23 +12710,24 @@ nonlimited tagged type [or a generic formal type].
           discriminants alterable as part of assigning to the object.
 
 9.d/3
-          {AI05-0214-1AI05-0214-1} Defaults for discriminants of tagged
-          types are disallowed so that every object of a nonlimited
-          tagged type is constrained, either by an explicit constraint,
-          or by its initial discriminant values.  This substantially
-          simplifies the semantic rules and the implementation of
-          inherited dispatching operations.  We don't need this rule for
-          limited tagged types, as the discriminants of such objects
-          cannot be changed after the object is created in any case --
-          no full-object assignment is supported, and that is required
-          to change discriminant values.  For generic formal types, the
-          restriction simplifies the type matching rules.  If one simply
-          wants a "default" value for the discriminants, a constrained
-          subtype can be declared for future use.
+          {<AI05-0214-1AI05-0214-1>} Defaults for discriminants of
+          tagged types are disallowed so that every object of a
+          nonlimited tagged type is constrained, either by an explicit
+          constraint, or by its initial discriminant values.  This
+          substantially simplifies the semantic rules and the
+          implementation of inherited dispatching operations.  We don't
+          need this rule for limited tagged types, as the discriminants
+          of such objects cannot be changed after the object is created
+          in any case -- no full-object assignment is supported, and
+          that is required to change discriminant values.  For generic
+          formal types, the restriction simplifies the type matching
+          rules.  If one simply wants a "default" value for the
+          discriminants, a constrained subtype can be declared for
+          future use.
 
 10/3
-{AI95-00230-01AI95-00230-01} {AI95-00402-01AI95-00402-01}
-{AI95-00419-01AI95-00419-01} {AI05-0063-1AI05-0063-1} A
+{<AI95-00230-01AI95-00230-01>} {<AI95-00402-01AI95-00402-01>}
+{<AI95-00419-01AI95-00419-01>} {<AI05-0063-1AI05-0063-1>} A
 discriminant_specification for an access discriminant may have a
 default_expression only in the declaration for an immutably limited type
 (see *note 7.5::).  In addition to the places where Legality Rules
@@ -12722,7 +12750,7 @@ part of an instance of a generic unit.
           will always be immutably limited (if legal).
 
 10.c/2
-          Reason: {AI95-00230-01AI95-00230-01} We considered the
+          Reason: {<AI95-00230-01AI95-00230-01>} We considered the
           following rules for access discriminants:
 
 10.d
@@ -12746,7 +12774,7 @@ part of an instance of a generic unit.
                that "become nonlimited".
 
 10.e.1/3
-             * {AI05-0063-1AI05-0063-1} A type may have an access
+             * {<AI05-0063-1AI05-0063-1>} A type may have an access
                discriminant if it is an immutably limited type.  This
                was the rule chosen for Ada 95.
 
@@ -12761,7 +12789,7 @@ part of an instance of a generic unit.
                accessibility.
 
 10.f.1/3
-             * {AI05-0063-1AI05-0063-1} Any type may have an access
+             * {<AI05-0063-1AI05-0063-1>} Any type may have an access
                discriminant, as above.  However, special accessibility
                rules only apply to types that are immutably limited
                (task, protected, and explicitly limited records).
@@ -12769,7 +12797,7 @@ part of an instance of a generic unit.
                depend on the definition of accessibility.
 
 10.f.2/3
-             * {AI05-0063-1AI05-0063-1} Any type may have an access
+             * {<AI05-0063-1AI05-0063-1>} Any type may have an access
                discriminant, as above.  Limited types have special
                accessibility, while nonlimited types have normal
                accessibility.  However, a limited partial view with an
@@ -12800,14 +12828,14 @@ part of an instance of a generic unit.
                it would be horribly incompatible with Ada 95.
 
 10.h.1/3
-             * {AI05-0063-1AI05-0063-1} Any type may have an access
+             * {<AI05-0063-1AI05-0063-1>} Any type may have an access
                discriminant, but access discriminants may have defaults
                only if they are of an immutably limited type.  This is
                the rule chosen for Ada 2005, as it is not incompatible,
                and it doesn't require weird accessibility checks.
 
 11/2
-This paragraph was deleted.{AI95-00402-01AI95-00402-01}
+<This paragraph was deleted.>{<AI95-00402-01AI95-00402-01>}
 
 12
 For a type defined by a derived_type_definition, if a
@@ -12843,10 +12871,10 @@ known_discriminant_part is provided in its 
declaration, then:
           parent's discriminant.
 
 16/3
-This paragraph was deleted.{AI05-0102-1AI05-0102-1}
+<This paragraph was deleted.>{<AI05-0102-1AI05-0102-1>}
 
 16.a/3
-          This paragraph was deleted.
+          <This paragraph was deleted.>
 
                           _Static Semantics_
 
@@ -12860,14 +12888,14 @@ defined by the access_definition.
 [For a type defined by a derived_type_definition, each discriminant of
 the parent type is either inherited, constrained to equal some new
 discriminant of the derived type, or constrained to the value of an
-expression.] When inherited or constrained to equal some new
+expression.]  When inherited or constrained to equal some new
 discriminant, the parent discriminant and the discriminant of the
-derived type are said to correspond.  Two discriminants also correspond
-if there is some common discriminant to which they both correspond.  A
-discriminant corresponds to itself as well. If a discriminant of a
-parent type is constrained to a specific value by a
-derived_type_definition, then that discriminant is said to be specified
-by that derived_type_definition.
+derived type are said to <correspond>.  Two discriminants also
+correspond if there is some common discriminant to which they both
+correspond.  A discriminant corresponds to itself as well.  If a
+discriminant of a parent type is constrained to a specific value by a
+derived_type_definition, then that discriminant is said to be
+<specified> by that derived_type_definition.
 
 18.a
           Ramification: The correspondence relationship is transitive,
@@ -12877,26 +12905,26 @@ by that derived_type_definition.
 
 19
 A constraint that appears within the definition of a discriminated type
-depends on a discriminant of the type if it names the discriminant as a
-bound or discriminant value.  A component_definition depends on a
+<depends on a discriminant> of the type if it names the discriminant as
+a bound or discriminant value.  A component_definition depends on a
 discriminant if its constraint depends on the discriminant, or on a
 discriminant that corresponds to it.
 
 19.a
           Ramification: A constraint in a task_body is not considered to
-          depend on a discriminant of the task type, even if it names
+          <depend> on a discriminant of the task type, even if it names
           it.  It is only the constraints in the type definition itself
           that are considered dependents.  Similarly for protected
           types.
 
 20
-A component depends on a discriminant if:
+A component <depends on a discriminant> if:
 
 21
    * Its component_definition depends on the discriminant; or
 
 21.a
-          Ramification: A component does not depend on a discriminant
+          Ramification: A component does <not> depend on a discriminant
           just because its default_expression refers to the
           discriminant.
 
@@ -12906,8 +12934,8 @@ A component depends on a discriminant if:
 
 23
    * It is a component inherited as part of a derived_type_definition,
-     and the constraint of the parent_subtype_indication depends on the
-     discriminant; or
+     and the constraint of the <parent_>subtype_indication depends on
+     the discriminant; or
 
 23.a
           Reason: When the parent subtype depends on a discriminant, the
@@ -12952,22 +12980,22 @@ type.
           To be honest: Which values are present might depend on
           discriminants of some ancestor type that are constrained in an
           intervening derived_type_definition.  That's why we say
-          "values of discriminants" instead of "values of the
+          "values of discriminants" instead of "values of <the>
           discriminants" -- a subtle point.
 
 26
-A type declared with a known_discriminant_part is said to have known
-discriminants; its first subtype is unconstrained. A type declared with
-an unknown_discriminant_part is said to have unknown discriminants.  A
-type declared without a discriminant_part has no discriminants, unless
-it is a derived type; if derived, such a type has the same sort of
-discriminants (known, unknown, or none) as its parent (or ancestor)
-type.  A tagged class-wide type also has unknown discriminants. [Any
-subtype of a type with unknown discriminants is an unconstrained and
-indefinite subtype (see *note 3.2:: and *note 3.3::).]
+A type declared with a known_discriminant_part is said to have <known
+discriminants>; its first subtype is unconstrained.  A type declared
+with an unknown_discriminant_part is said to have <unknown
+discriminants>.  A type declared without a discriminant_part has no
+discriminants, unless it is a derived type; if derived, such a type has
+the same sort of discriminants (known, unknown, or none) as its parent
+(or ancestor) type.  A tagged class-wide type also has unknown
+discriminants.  [Any subtype of a type with unknown discriminants is an
+unconstrained and indefinite subtype (see *note 3.2:: and *note 3.3::).]
 
 26.a/2
-          Discussion: {AI95-00114-01AI95-00114-01} An
+          Discussion: {<AI95-00114-01AI95-00114-01>} An
           unknown_discriminant_part "(<>)" is only permitted in the
           declaration of a (generic or nongeneric) private type, private
           extension, incomplete type, or formal derived type.  Hence,
@@ -12982,7 +13010,7 @@ indefinite subtype (see *note 3.2:: and *note 3.3::).]
           is not known at compile time.
 
 26.b/2
-          {AI95-00287-01AI95-00287-01} A subtype with unknown
+          {<AI95-00287-01AI95-00287-01>} A subtype with unknown
           discriminants is indefinite, and hence an object of such a
           subtype needs explicit initialization.  A limited private type
           with unknown discriminants is "extremely" limited; objects of
@@ -13003,20 +13031,20 @@ indefinite subtype (see *note 3.2:: and *note 3.3::).]
                           _Dynamic Semantics_
 
 27/2
-{AI95-00230-01AI95-00230-01} {AI95-00416-01AI95-00416-01} For an access
-discriminant, its access_definition is elaborated when the value of the
-access discriminant is defined: by evaluation of its default_expression,
-by elaboration of a discriminant_constraint, or by an assignment that
-initializes the enclosing object. 
+{<AI95-00230-01AI95-00230-01>} {<AI95-00416-01AI95-00416-01>} For an
+access discriminant, its access_definition is elaborated when the value
+of the access discriminant is defined: by evaluation of its
+default_expression, by elaboration of a discriminant_constraint, or by
+an assignment that initializes the enclosing object.  
 
 27.a/2
-          Ramification: {AI95-00231-01AI95-00231-01}
-          {AI95-00416-01AI95-00416-01} The conversion of the expression
-          defining the access discriminant to the anonymous access type
-          raises Program_Error for an object created by an allocator of
-          an access type T, if the initial value is an access parameter
-          that designates a view whose accessibility level is deeper
-          than that of T.
+          Ramification: {<AI95-00231-01AI95-00231-01>}
+          {<AI95-00416-01AI95-00416-01>} The conversion of the
+          expression defining the access discriminant to the anonymous
+          access type raises Program_Error for an object created by an
+          allocator of an access type T, if the initial value is an
+          access parameter that designates a view whose accessibility
+          level is deeper than that of T.
 
      NOTES
 
@@ -13039,8 +13067,8 @@ initializes the enclosing object.
 
 28.b
           An unconstrained discriminated subtype with defaults is called
-          a mutable subtype, and a variable of such a subtype is called
-          a mutable variable, because the discriminants of such a
+          a <mutable> subtype, and a variable of such a subtype is
+          called a mutable variable, because the discriminants of such a
           variable can change.  There are no mutable arrays (that is,
           the bounds of an array object can never change), because there
           is no way in the language to define default values for the
@@ -13068,7 +13096,7 @@ initializes the enclosing object.
      enclosing object, presuming it is an unconstrained variable.
 
 30.a/2
-          Discussion: {AI95-00114-01AI95-00114-01} An
+          Discussion: {<AI95-00114-01AI95-00114-01>} An
           unknown_discriminant_part is permitted only in the declaration
           of a private type (including generic formal private), private
           extension, incomplete type, or generic formal derived type.
@@ -13102,10 +13130,10 @@ initializes the enclosing object.
                               _Examples_
 
 32
-Examples of discriminated types:
+<Examples of discriminated types:>
 
 33
-     type Buffer(Size : Buffer_Size := 100)  is        -- see *note 3.5.4::
+     type Buffer(Size : Buffer_Size := 100)  is        --< see *note 3.5.4::>
         record
            Pos   : Buffer_Size := 0;
            Value : String(1 .. Size);
@@ -13114,7 +13142,7 @@ Examples of discriminated types:
 34
      type Matrix_Rec(Rows, Columns : Integer) is
         record
-           Mat : Matrix(1 .. Rows, 1 .. Columns);       -- see *note 3.6::
+           Mat : Matrix(1 .. Rows, 1 .. Columns);       --< see *note 3.6::>
         end record;
 
 35
@@ -13129,9 +13157,9 @@ Examples of discriminated types:
         end record;
 
 37/3
-     {AI95-00433-01AI95-00433-01} {AI05-0229-1AI05-0229-1} task type 
Worker(Prio : System.Priority; Buf : access Buffer)
-        with Priority => Prio is -- see *note D.1::
-        -- discriminants used to parameterize the task type (see *note 9.1::)
+     {<AI95-00433-01AI95-00433-01>} {<AI05-0229-1AI05-0229-1>} task type 
Worker(Prio : System.Priority; Buf : access Buffer)
+        with Priority => Prio is --< see *note D.1::>
+        --< discriminants used to parameterize the task type (see *note 9.1::)>
         entry Fill;
         entry Drain;
      end Worker;
@@ -13140,12 +13168,12 @@ Examples of discriminated types:
 
 37.a
           The syntax for a discriminant_specification is modified to
-          allow an access discriminant, with a type specified by an
+          allow an <access discriminant>, with a type specified by an
           access_definition (see *note 3.10::).
 
 37.b/2
-          {AI95-00251-01AI95-00251-01} Discriminants are allowed on all
-          composite types other than array and interface types.
+          {<AI95-00251-01AI95-00251-01>} Discriminants are allowed on
+          all composite types other than array and interface types.
 
 37.c
           Discriminants may be of an access type.
@@ -13160,44 +13188,45 @@ Examples of discriminated types:
                         _Extensions to Ada 95_
 
 37.e/2
-          {AI95-00230-01AI95-00230-01} {AI95-00402-01AI95-00402-01}
-          {AI95-00416-01AI95-00416-01} Access discriminants (anonymous
+          {<AI95-00230-01AI95-00230-01>} {<AI95-00402-01AI95-00402-01>}
+          {<AI95-00416-01AI95-00416-01>} Access discriminants (anonymous
           access types used as a discriminant) can be used on any type
           allowing discriminants.  Defaults aren't allowed on
           discriminants of nonlimited types, however, so that
           accessibility problems don't happen on assignment.
 
 37.f/2
-          {AI95-00231-01AI95-00231-01} null_exclusion can be used in the
-          declaration of a discriminant.
+          {<AI95-00231-01AI95-00231-01>} null_exclusion can be used in
+          the declaration of a discriminant.
 
                      _Wording Changes from Ada 95_
 
 37.g/2
-          {8652/00078652/0007} {AI95-00098-01AI95-00098-01} Corrigendum:
-          The wording was clarified so that types that cannot have
-          discriminants cannot have an unknown_discriminant_part.
+          {<8652/00078652/0007>} {<AI95-00098-01AI95-00098-01>}
+          Corrigendum: The wording was clarified so that types that
+          cannot have discriminants cannot have an
+          unknown_discriminant_part.
 
 37.h/2
-          {AI95-00251-01AI95-00251-01} Added wording to prevent
+          {<AI95-00251-01AI95-00251-01>} Added wording to prevent
           interfaces from having discriminants.  We don't want
           interfaces to have any components.
 
 37.i/2
-          {AI95-00254-01AI95-00254-01} Removed wording which implied or
-          required an access discriminant to have an access-to-object
+          {<AI95-00254-01AI95-00254-01>} Removed wording which implied
+          or required an access discriminant to have an access-to-object
           type (anonymous access types can now be access-to-subprogram
           types as well).
 
 37.j/3
-          {AI95-00326-01AI95-00326-01} {AI05-0299-1AI05-0299-1} Fixed
-          the wording of the introduction to this subclause to reflect
-          that both incomplete and partial views can have unknown
-          discriminants.  That was always true, but for some reason this
-          wording specified partial views.
+          {<AI95-00326-01AI95-00326-01>} {<AI05-0299-1AI05-0299-1>}
+          Fixed the wording of the introduction to this subclause to
+          reflect that both incomplete and partial views can have
+          unknown discriminants.  That was always true, but for some
+          reason this wording specified partial views.
 
 37.k/2
-          {AI95-00419-01AI95-00419-01} Changed the wording to use the
+          {<AI95-00419-01AI95-00419-01>} Changed the wording to use the
           new term "explicitly limited record", which makes the intent
           much clearer (and eliminates confusion with derived types that
           happen to contain the reserved word limited).
@@ -13205,7 +13234,7 @@ Examples of discriminated types:
                    _Incompatibilities With Ada 2005_
 
 37.l/3
-          {AI05-0063-1AI05-0063-1} Correction: Changed the rules for
+          {<AI05-0063-1AI05-0063-1>} Correction: Changed the rules for
           when access discriminants can have defaults to depend on the
           new definition for immutably limited types; this will help
           ensure that unusual corner cases are properly handled.  Note
@@ -13217,14 +13246,14 @@ Examples of discriminated types:
                        _Extensions to Ada 2005_
 
 37.m/3
-          {AI05-0214-1AI05-0214-1} A limited tagged type may now have
+          {<AI05-0214-1AI05-0214-1>} A limited tagged type may now have
           defaults for its discriminants.
 
                     _Wording Changes from Ada 2005_
 
 37.n/3
-          {AI05-0102-1AI05-0102-1} Correction: Moved implicit conversion
-          Legality Rule to *note 8.6::.
+          {<AI05-0102-1AI05-0102-1>} Correction: Moved implicit
+          conversion Legality Rule to *note 8.6::.
 
 * Menu:
 
@@ -13244,7 +13273,7 @@ a given discriminated type.
                      _Language Design Principles_
 
 1.a/3
-          {AI05-0299-1AI05-0299-1} The rules in this subclause are
+          {<AI05-0299-1AI05-0299-1>} The rules in this subclause are
           intentionally parallel to those given in *note 4.3.1::, "*note
           4.3.1:: Record Aggregates".
 
@@ -13256,13 +13285,13 @@ a given discriminated type.
 
 3
      discriminant_association ::=
-        [discriminant_selector_name {| discriminant_selector_name} =>] 
-     expression
+        [<discriminant_>selector_name {| <discriminant_>
+     selector_name} =>] expression
 
 4
-     A discriminant_association is said to be named if it has one or
-     more discriminant_selector_names; it is otherwise said to be
-     positional.  In a discriminant_constraint, any positional
+     A discriminant_association is said to be <named> if it has one or
+     more <discriminant_>selector_names; it is otherwise said to be
+     <positional>.  In a discriminant_constraint, any positional
      associations shall precede any named associations.
 
                         _Name Resolution Rules_
@@ -13270,12 +13299,12 @@ a given discriminated type.
 5
 Each selector_name of a named discriminant_association (*note 3.7.1:
 S0065.) shall resolve to denote a discriminant of the subtype being
-constrained; the discriminants so named are the associated discriminants
-of the named association. For a positional association, the associated
-discriminant is the one whose discriminant_specification (*note 3.7:
-S0062.) occurred in the corresponding position in the
-known_discriminant_part (*note 3.7: S0061.) that defined the
-discriminants of the subtype being constrained.
+constrained; the discriminants so named are the <associated
+discriminants> of the named association.  For a positional association,
+the <associated discriminant> is the one whose
+discriminant_specification (*note 3.7: S0062.) occurred in the
+corresponding position in the known_discriminant_part (*note 3.7:
+S0061.) that defined the discriminants of the subtype being constrained.
 
 6
 The expected type for the expression in a discriminant_association is
@@ -13284,8 +13313,8 @@ that of the associated discriminant(s).
                            _Legality Rules_
 
 7/3
-{8652/00088652/0008} {AI95-00168-01AI95-00168-01}
-{AI95-00363-01AI95-00363-01} {AI05-0041-1AI05-0041-1} A
+{<8652/00088652/0008>} {<AI95-00168-01AI95-00168-01>}
+{<AI95-00363-01AI95-00363-01>} {<AI05-0041-1AI05-0041-1>} A
 discriminant_constraint is only allowed in a subtype_indication whose
 subtype_mark denotes either an unconstrained discriminated subtype, or
 an unconstrained access subtype whose designated subtype is an
@@ -13297,11 +13326,11 @@ Rules normally apply (see *note 12.3::), these rules 
apply also in the
 private part of an instance of a generic unit.
 
 7.a.1/2
-          This paragraph was deleted.{8652/00088652/0008}
-          {AI95-00168-01AI95-00168-01} {AI95-00363-01AI95-00363-01}
+          <This paragraph was deleted.>{<8652/00088652/0008>}
+          {<AI95-00168-01AI95-00168-01>} {<AI95-00363-01AI95-00363-01>}
 
 7.a/2
-          Reason: {AI95-00363-01AI95-00363-01} The second rule is
+          Reason: {<AI95-00363-01AI95-00363-01>} The second rule is
           necessary to prevent objects from changing so that they no
           longer match their constraint.  In Ada 95, we attempted to
           prevent this by banning every case where an aliased object
@@ -13315,12 +13344,12 @@ private part of an instance of a generic unit.
           to an item whose discriminants can be changed by assignment".
 
 7.b/3
-          Discussion: {AI05-0041-1AI05-0041-1} The second rule will only
-          use the indefinite or dereference bullets in the definition of
-          "known to be constrained".  The rule is worded in terms of
-          "known to be constrained" in order to capture the special
-          rules that apply in generic bodies (rather than repeating them
-          and getting them subtly wrong).
+          Discussion: {<AI05-0041-1AI05-0041-1>} The second rule will
+          only use the indefinite or dereference bullets in the
+          definition of "known to be constrained".  The rule is worded
+          in terms of "known to be constrained" in order to capture the
+          special rules that apply in generic bodies (rather than
+          repeating them and getting them subtly wrong).
 
 8
 A named discriminant_association with more than one selector_name is
@@ -13329,7 +13358,7 @@ discriminant_constraint shall provide exactly one value 
for each
 discriminant of the subtype being constrained.
 
 9/3
-This paragraph was deleted.{AI05-0102-1AI05-0102-1}
+<This paragraph was deleted.>{<AI05-0102-1AI05-0102-1>}
 
 9.a/3
           Ramification: In addition, *note 8.6:: requires that the
@@ -13346,7 +13375,7 @@ This paragraph was deleted.{AI05-0102-1AI05-0102-1}
                           _Dynamic Semantics_
 
 10
-A discriminant_constraint is compatible with an unconstrained
+A discriminant_constraint is <compatible> with an unconstrained
 discriminated subtype if each discriminant value belongs to the subtype
 of the corresponding discriminant.
 
@@ -13361,7 +13390,7 @@ of the corresponding discriminant.
           to constrain it again.
 
 11
-A composite value satisfies a discriminant constraint if and only if
+A composite value <satisfies> a discriminant constraint if and only if
 each discriminant of the composite value has the value imposed by the
 discriminant constraint.
 
@@ -13371,7 +13400,7 @@ discriminant_associations are evaluated in an arbitrary 
order and
 converted to the type of the associated discriminant (which might raise
 Constraint_Error -- see *note 4.6::); the expression of a named
 association is evaluated (and converted) once for each associated
-discriminant. The result of each evaluation and conversion is the value
+discriminant.  The result of each evaluation and conversion is the value
 imposed by the constraint for the associated discriminant.
 
 12.a
@@ -13399,16 +13428,16 @@ imposed by the constraint for the associated 
discriminant.
                               _Examples_
 
 14/3
-{AI05-0299-1AI05-0299-1} Examples (using types declared above in
-subclause *note 3.7::):
+{<AI05-0299-1AI05-0299-1>} <Examples (using types declared above in
+subclause *note 3.7::):>
 
 15
-     Large   : Buffer(200);  --  constrained, always 200 characters
-                             --   (explicit discriminant value)
-     Message : Buffer;       --  unconstrained, initially 100 characters
-                             --   (default discriminant value)
-     Basis   : Square(5);    --  constrained, always 5 by 5
-     Illegal : Square;       --  illegal, a Square has to be constrained
+     Large   : Buffer(200);  --<  constrained, always 200 characters>
+                             --<   (explicit discriminant value)>
+     Message : Buffer;       --<  unconstrained, initially 100 characters>
+                             --<   (default discriminant value)>
+     Basis   : Square(5);    --<  constrained, always 5 by 5>
+     Illegal : Square;       --<  illegal, a Square has to be constrained>
 
                      _Inconsistencies With Ada 83_
 
@@ -13431,8 +13460,8 @@ subclause *note 3.7::):
                     _Incompatibilities With Ada 95_
 
 15.c/2
-          {8652/00088652/0008} {AI95-00168-01AI95-00168-01}
-          {AI95-00363-01AI95-00363-01} The Corrigendum added a
+          {<8652/00088652/0008>} {<AI95-00168-01AI95-00168-01>}
+          {<AI95-00363-01AI95-00363-01>} The Corrigendum added a
           restriction on discriminant_constraints for general access
           subtypes.  Such constraints are prohibited if the designated
           type can be treated as constrained somewhere in the program.
@@ -13452,15 +13481,15 @@ subclause *note 3.7::):
                     _Wording Changes from Ada 2005_
 
 15.d/3
-          {AI05-0041-1AI05-0041-1} Correction: Revised the rules on
+          {<AI05-0041-1AI05-0041-1>} Correction: Revised the rules on
           access subtypes having discriminant constraints to depend on
           the "known to be constrained" rules.  This centralizes the
           rules so that future fixes need to be made in only one place,
           as well as fixing bugs in obscure cases.
 
 15.e/3
-          {AI05-0102-1AI05-0102-1} Correction: Moved implicit conversion
-          Legality Rule to *note 8.6::.
+          {<AI05-0102-1AI05-0102-1>} Correction: Moved implicit
+          conversion Legality Rule to *note 8.6::.
 
 
 File: aarm2012.info,  Node: 3.7.2,  Prev: 3.7.1,  Up: 3.7
@@ -13484,12 +13513,12 @@ dereference)], the following attribute is defined:
 
 3/3
 A'Constrained
-               {AI05-0214-1AI05-0214-1} Yields the value True if A
+               {<AI05-0214-1AI05-0214-1>} Yields the value True if A
                denotes a constant, a value, a tagged object, or a
                constrained variable, and False otherwise.
 
 3.a/3
-          Implementation Note: {AI05-0214-1AI05-0214-1} This attribute
+          Implementation Note: {<AI05-0214-1AI05-0214-1>} This attribute
           is primarily used on parameters, to determine whether the
           discriminants can be changed as part of an assignment.  The
           Constrained attribute is statically True for in parameters.
@@ -13506,8 +13535,8 @@ A'Constrained
           change its discriminants.
 
 3.b/4
-          Reason: {AI05-0214-1AI05-0214-1} {AI12-0005-1AI12-0005-1} All
-          tagged objects are known to be constrained (as nonlimited
+          Reason: {<AI05-0214-1AI05-0214-1>} {<AI12-0005-1AI12-0005-1>}
+          All tagged objects are known to be constrained (as nonlimited
           tagged types cannot have discriminant defaults, and limited
           tagged objects are immutably limited), and are always
           considered constrained by this attribute to avoid distributed
@@ -13520,12 +13549,12 @@ A'Constrained
           parameters.
 
 3.c/3
-          Discussion: {AI05-0005-1AI05-0005-1} {AI05-0214-1AI05-0214-1}
-          If the type of A is a type derived from an untagged partial
-          view of a tagged type such that it is not a tagged type, then
-          A is not considered a tagged object, and A'Constrained can
-          return either True or False depending on the nature of the
-          object.
+          Discussion: {<AI05-0005-1AI05-0005-1>}
+          {<AI05-0214-1AI05-0214-1>} If the type of A is a type derived
+          from an untagged partial view of a tagged type such that it is
+          not a tagged type, then A is not considered a tagged object,
+          and A'Constrained can return either True or False depending on
+          the nature of the object.
 
                          _Erroneous Execution_
 
@@ -13575,7 +13604,7 @@ execution) of the subcomponent denoted by the name.
                     _Wording Changes from Ada 2005_
 
 4.e/3
-          {AI05-0214-1AI05-0214-1} A'Constrained is now defined to
+          {<AI05-0214-1AI05-0214-1>} A'Constrained is now defined to
           return True for any A that is a tagged object.  This doesn't
           change the result for any A allowed by previous versions of
           Ada; the change is necessary to avoid unnecessary overhead for
@@ -13590,7 +13619,7 @@ File: aarm2012.info,  Node: 3.8,  Next: 3.9,  Prev: 
3.7,  Up: 3
 1
 A record object is a composite object consisting of named components.
 The value of a record object is a composite value consisting of the
-values of the components. 
+values of the components.  
 
                                _Syntax_
 
@@ -13612,11 +13641,11 @@ values of the components.
         |  null;
 
 5/1
-     {8652/00098652/0009} {AI95-00137-01AI95-00137-01} component_item
-     ::= component_declaration | aspect_clause
+     {<8652/00098652/0009>} {<AI95-00137-01AI95-00137-01>}
+     component_item ::= component_declaration | aspect_clause
 
 6/3
-     {AI05-0183-1AI05-0183-1} component_declaration ::=
+     {<AI05-0183-1AI05-0183-1>} component_declaration ::=
         defining_identifier_list : component_definition [:= 
      default_expression]
              [aspect_specification];
@@ -13630,10 +13659,10 @@ component_declaration is the type of the component.
                            _Legality Rules_
 
 8/2
-This paragraph was deleted.{AI95-00287-01AI95-00287-01}
+<This paragraph was deleted.>{<AI95-00287-01AI95-00287-01>}
 
 9/2
-{AI95-00366-01AI95-00366-01} Each component_declaration declares a
+{<AI95-00366-01AI95-00366-01>} Each component_declaration declares a
 component of the record type.  Besides components declared by
 component_declarations, the components of a record type include any
 components declared by discriminant_specifications of the record type
@@ -13641,7 +13670,7 @@ declaration.  [The identifiers of all components of a 
record type shall
 be distinct.]
 
 9.a/3
-          Proof: {AI05-0299-1AI05-0299-1} The identifiers of all
+          Proof: {<AI05-0299-1AI05-0299-1>} The identifiers of all
           components of a record type have to be distinct because they
           are all declared immediately within the same declarative
           region.  See Clause *note 8::.
@@ -13651,14 +13680,14 @@ Within a type_declaration, a name that denotes a 
component, protected
 subprogram, or entry of the type is allowed only in the following cases:
 
 11/3
-   * {AI05-0004-1AI05-0004-1} {AI05-0295-1AI05-0295-1} A name that
+   * {<AI05-0004-1AI05-0004-1>} {<AI05-0295-1AI05-0295-1>} A name that
      denotes any component, protected subprogram, or entry is allowed
      within an aspect_specification, an operational item, or a
      representation item that occurs within the declaration of the
      composite type.
 
 12/3
-   * {AI05-0264-1AI05-0264-1} A name that denotes a noninherited
+   * {<AI05-0264-1AI05-0264-1>} A name that denotes a noninherited
      discriminant is allowed within the declaration of the type, but not
      within the discriminant_part.  If the discriminant is used to
      define the constraint of a component, the bounds of an entry
@@ -13689,7 +13718,7 @@ subprogram, or entry of the type is allowed only in the 
following cases:
           type.
 
 12.e/2
-          Reason: {AI95-00373-01AI95-00373-01} The above rules, and a
+          Reason: {<AI95-00373-01AI95-00373-01>} The above rules, and a
           similar one in *note 6.1:: for formal parameters, are intended
           to allow initializations of components or parameters to occur
           in a (nearly) arbitrary order -- whatever order is most
@@ -13698,11 +13727,11 @@ subprogram, or entry of the type is allowed only in 
the following cases:
           another one.  They also prevent circularities.
 
 12.f/3
-          Ramification: {AI05-0295-1AI05-0295-1} Inherited discriminants
-          are not allowed to be denoted, except within
+          Ramification: {<AI05-0295-1AI05-0295-1>} Inherited
+          discriminants are not allowed to be denoted, except within
           aspect_specifications and representation items.  However, the
-          discriminant_selector_name of the parent subtype_indication is
-          allowed to denote a discriminant of the parent.
+          <discriminant_>selector_name of the parent subtype_indication
+          is allowed to denote a discriminant of the parent.
 
 13
 If the name of the current instance of a type (see *note 8.6::) is used
@@ -13720,9 +13749,9 @@ of an access type, and the attribute_reference shall 
appear alone.
                           _Static Semantics_
 
 13.1/3
-{AI95-00318-02AI95-00318-02} {AI05-0004-1AI05-0004-1} If a
+{<AI95-00318-02AI95-00318-02>} {<AI05-0004-1AI05-0004-1>} If a
 record_type_definition includes the reserved word limited, the type is
-called an explicitly limited record type.
+called an <explicitly limited record> type.
 
 14
 The component_definition of a component_declaration defines the
@@ -13733,7 +13762,7 @@ appears in the component_definition, then the component 
is aliased (see
 15
 If the component_list of a record type is defined by the reserved word
 null and there are no discriminants, then the record type has no
-components and all records of the type are null records.  A
+components and all records of the type are <null records>.  A
 record_definition of null record is equivalent to record null; end
 record.
 
@@ -13746,13 +13775,13 @@ record.
 16
 The elaboration of a record_type_definition creates the record type and
 its first subtype, and consists of the elaboration of the
-record_definition. The elaboration of a record_definition consists of
+record_definition.  The elaboration of a record_definition consists of
 the elaboration of its component_list, if any.
 
 17
 The elaboration of a component_list consists of the elaboration of the
 component_items and variant_part, if any, in the order in which they
-appear. The elaboration of a component_declaration consists of the
+appear.  The elaboration of a component_declaration consists of the
 elaboration of the component_definition.
 
 17.a
@@ -13763,30 +13792,31 @@ elaboration of the component_definition.
           elaborated once for each defining_identifier in the list.
 
 18/2
-{8652/00028652/0002} {AI95-00171-01AI95-00171-01}
-{AI95-00230-01AI95-00230-01} Within the definition of a composite type,
-if a component_definition or discrete_subtype_definition (see *note
-9.5.2::) includes a name that denotes a discriminant of the type, or
-that is an attribute_reference whose prefix denotes the current instance
-of the type, the expression containing the name is called a per-object
-expression, and the constraint or range being defined is called a
-per-object constraint. For the elaboration of a component_definition of
-a component_declaration or the discrete_subtype_definition (*note 3.6:
-S0055.) of an entry_declaration (*note 9.5.2: S0218.) for an entry
-family (see *note 9.5.2::), if the component subtype is defined by an
-access_definition or if the constraint or range of the
-subtype_indication or discrete_subtype_definition (*note 3.6: S0055.) is
-not a per-object constraint, then the access_definition,
-subtype_indication, or discrete_subtype_definition (*note 3.6: S0055.)
-is elaborated.  On the other hand, if the constraint or range is a
-per-object constraint, then the elaboration consists of the evaluation
-of any included expression that is not part of a per-object expression.
-Each such expression is evaluated once unless it is part of a named
-association in a discriminant constraint, in which case it is evaluated
-once for each associated discriminant.
+{<8652/00028652/0002>} {<AI95-00171-01AI95-00171-01>}
+{<AI95-00230-01AI95-00230-01>} Within the definition of a composite
+type, if a component_definition or discrete_subtype_definition (see
+*note 9.5.2::) includes a name that denotes a discriminant of the type,
+or that is an attribute_reference whose prefix denotes the current
+instance of the type, the expression containing the name is called a
+<per-object expression>, and the constraint or range being defined is
+called a <per-object constraint>.  For the elaboration of a
+component_definition of a component_declaration or the
+discrete_subtype_definition (*note 3.6: S0055.) of an entry_declaration
+(*note 9.5.2: S0218.) for an entry family (see *note 9.5.2::), if the
+component subtype is defined by an access_definition or if the
+constraint or range of the subtype_indication or
+discrete_subtype_definition (*note 3.6: S0055.) is not a per-object
+constraint, then the access_definition, subtype_indication, or
+discrete_subtype_definition (*note 3.6: S0055.) is elaborated.  On the
+other hand, if the constraint or range is a per-object constraint, then
+the elaboration consists of the evaluation of any included expression
+that is not part of a per-object expression.  Each such expression is
+evaluated once unless it is part of a named association in a
+discriminant constraint, in which case it is evaluated once for each
+associated discriminant.
 
 18.1/1
-{8652/00028652/0002} {AI95-00171-01AI95-00171-01} When a per-object
+{<8652/00028652/0002>} {<AI95-00171-01AI95-00171-01>} When a per-object
 constraint is elaborated [(as part of creating an object)], each
 per-object expression of the constraint is evaluated.  For other
 expressions, the values determined during the elaboration of the
@@ -13839,14 +13869,14 @@ associated subtype is created.
      equality operators.
 
 25/2
-     69  {AI95-00287-01AI95-00287-01} A component of a record can be
+     69  {<AI95-00287-01AI95-00287-01>} A component of a record can be
      named with a selected_component.  A value of a record can be
      specified with a record_aggregate.
 
                               _Examples_
 
 26
-Examples of record type declarations:
+<Examples of record type declarations: >
 
 27
      type Date is
@@ -13864,14 +13894,14 @@ Examples of record type declarations:
         end record;
 
 29
-Examples of record variables:
+<Examples of record variables: >
 
 30
      Tomorrow, Yesterday : Date;
      A, B, C : Complex;
 
 31
-     -- both components of A, B, and C are implicitly initialized to zero 
+     --< both components of A, B, and C are implicitly initialized to zero >
 
                         _Extensions to Ada 83_
 
@@ -13901,8 +13931,8 @@ Examples of record variables:
                      _Wording Changes from Ada 83_
 
 31.d/1
-          {8652/00098652/0009} {AI95-00137-01AI95-00137-01} The syntax
-          rules now allow aspect_clauses to appear in a
+          {<8652/00098652/0009>} {<AI95-00137-01AI95-00137-01>} The
+          syntax rules now allow aspect_clauses to appear in a
           record_definition.  This is not a language extension, because
           Legality Rules prevent all language-defined representation
           clauses from appearing there.  However, an
@@ -13914,11 +13944,11 @@ Examples of record variables:
                         _Extensions to Ada 95_
 
 31.e/2
-          {AI95-00287-01AI95-00287-01} Record components can have an
+          {<AI95-00287-01AI95-00287-01>} Record components can have an
           anonymous access type.
 
 31.f/2
-          {AI95-00287-01AI95-00287-01} Limited components can be
+          {<AI95-00287-01AI95-00287-01>} Limited components can be
           initialized, so long as the expression is one that allows
           building the object in place (such as an aggregate or
           function_call).
@@ -13926,24 +13956,25 @@ Examples of record variables:
                      _Wording Changes from Ada 95_
 
 31.g/2
-          {8652/00028652/0002} {AI95-00171-01AI95-00171-01} Corrigendum:
-          Improved the description of the elaboration of per-object
-          constraints.
+          {<8652/00028652/0002>} {<AI95-00171-01AI95-00171-01>}
+          Corrigendum: Improved the description of the elaboration of
+          per-object constraints.
 
 31.h/2
-          {8652/00098652/0009} {AI95-00137-01AI95-00137-01} Corrigendum:
-          Changed representation clauses to aspect clauses to reflect
-          that they are used for more than just representation.
+          {<8652/00098652/0009>} {<AI95-00137-01AI95-00137-01>}
+          Corrigendum: Changed representation clauses to aspect clauses
+          to reflect that they are used for more than just
+          representation.
 
 31.i/2
-          {AI95-00318-02AI95-00318-02} Defined explicitly limited record
-          type to use in other rules.
+          {<AI95-00318-02AI95-00318-02>} Defined <explicitly limited
+          record> type to use in other rules.
 
                        _Extensions to Ada 2005_
 
 31.j/3
-          {AI05-0183-1AI05-0183-1} An optional aspect_specification can
-          be used in a component_declaration.  This is described in
+          {<AI05-0183-1AI05-0183-1>} An optional aspect_specification
+          can be used in a component_declaration.  This is described in
           *note 13.1.1::.
 
 * Menu:
@@ -13963,7 +13994,7 @@ of the discriminant covered by its discrete_choice_list.
 
 1.a
           Discussion: Discrete_choice_lists and discrete_choices are
-          said to cover values as defined below; which
+          said to <cover> values as defined below; which
           discrete_choice_list covers a value determines which of
           various alternatives is chosen.  These are used in
           variant_parts, array_aggregates, and case_statements.
@@ -13983,7 +14014,7 @@ of the discriminant covered by its discrete_choice_list.
 
 2
      variant_part ::=
-        case discriminant_direct_name is
+        case <discriminant_>direct_name is
             variant
            {variant}
         end case;
@@ -13997,18 +14028,18 @@ of the discriminant covered by its 
discrete_choice_list.
      discrete_choice_list ::= discrete_choice {| discrete_choice}
 
 5/3
-     {AI05-0153-3AI05-0153-3} {AI05-0158-1AI05-0158-1} discrete_choice
-     ::= choice_expression | discrete_subtype_indication | 
-     range | others
+     {<AI05-0153-3AI05-0153-3>} {<AI05-0158-1AI05-0158-1>}
+     discrete_choice ::= choice_expression | <discrete_>
+     subtype_indication | range | others
 
                         _Name Resolution Rules_
 
 6
-The discriminant_direct_name shall resolve to denote a discriminant
-(called the discriminant of the variant_part) specified in the
+The <discriminant_>direct_name shall resolve to denote a discriminant
+(called the <discriminant of the variant_part>) specified in the
 known_discriminant_part of the full_type_declaration that contains the
-variant_part. The expected type for each discrete_choice in a variant is
-the type of the discriminant of the variant_part.
+variant_part.  The expected type for each discrete_choice in a variant
+is the type of the discriminant of the variant_part.
 
 6.a
           Ramification: A full_type_declaration with a variant_part has
@@ -14025,37 +14056,37 @@ The discriminant of the variant_part shall be of a 
discrete type.
           anonymous.
 
 8/3
-{AI05-0153-3AI05-0153-3} The choice_expressions, subtype_indications,
+{<AI05-0153-3AI05-0153-3>} The choice_expressions, subtype_indications,
 and ranges given as discrete_choices in a variant_part shall be static.
 The discrete_choice others shall appear alone in a discrete_choice_list,
 and such a discrete_choice_list, if it appears, shall be the last one in
 the enclosing construct.
 
 9
-A discrete_choice is defined to cover a value in the following cases:
+A discrete_choice is defined to <cover a value> in the following cases:
 
 10/3
-   * {AI05-0262-1AI05-0262-1} A discrete_choice that is a
+   * {<AI05-0262-1AI05-0262-1>} A discrete_choice that is a
      choice_expression covers a value if the value equals the value of
      the choice_expression converted to the expected type.
 
 10.1/4
-   * {AI05-0153-3AI05-0153-3} {AI05-0262-1AI05-0262-1}
-     {AI12-0071-1AI12-0071-1} A discrete_choice that is a
+   * {<AI05-0153-3AI05-0153-3>} {<AI05-0262-1AI05-0262-1>}
+     {<AI12-0071-1AI12-0071-1>} A discrete_choice that is a
      subtype_indication covers all values (possibly none) that belong to
      the subtype and that satisfy the static predicates of the subtype
      (see *note 3.2.4::).
 
 10.a/3
-          Ramification: {AI05-0262-1AI05-0262-1} A dynamic predicate is
-          never allowed in this case (for variants, case_statements, and
-          case_expressions, a subtype with a dynamic predicate isn't
+          Ramification: {<AI05-0262-1AI05-0262-1>} A dynamic predicate
+          is never allowed in this case (for variants, case_statements,
+          and case_expressions, a subtype with a dynamic predicate isn't
           static and thus isn't allowed in a discrete_choice, and for a
           choice in an array_aggregate, a dynamic predicate is
           explicitly disallowed -- see *note 3.2.4::).
 
 11/3
-   * {AI05-0153-3AI05-0153-3} A discrete_choice that is a range covers
+   * {<AI05-0153-3AI05-0153-3>} A discrete_choice that is a range covers
      all values (possibly none) that belong to the range.
 
 12
@@ -14080,8 +14111,8 @@ The possible values of the discriminant of a 
variant_part shall be
 covered as follows:
 
 15/4
-   * {AI05-0153-3AI05-0153-3} {AI05-0188-1AI05-0188-1}
-     {AI05-0262-1AI05-0262-1} {AI12-0071-1AI12-0071-1} If the
+   * {<AI05-0153-3AI05-0153-3>} {<AI05-0188-1AI05-0188-1>}
+     {<AI05-0262-1AI05-0262-1>} {<AI12-0071-1AI12-0071-1>} If the
      discriminant is of a static constrained scalar subtype then, except
      within an instance of a generic unit, each non-others
      discrete_choice (*note 3.8.1: S0074.) shall cover only values in
@@ -14091,7 +14122,7 @@ covered as follows:
      others)];
 
 15.a/3
-          Reason: {AI05-0188-1AI05-0188-1} The exemption for a
+          Reason: {<AI05-0188-1AI05-0188-1>} The exemption for a
           discriminated type declared in an instance allows the
           following example:
 
@@ -14110,10 +14141,10 @@ covered as follows:
                end G;
 
 15.c/3
-               package I is new G (Natural); -- Legal
+               package I is new G (Natural); -- <Legal>
 
 16/3
-   * {AI05-0264-1AI05-0264-1} If the type of the discriminant is a
+   * {<AI05-0264-1AI05-0264-1>} If the type of the discriminant is a
      descendant of a generic formal scalar type, then the variant_part
      shall have an others discrete_choice;
 
@@ -14135,7 +14166,7 @@ If the component_list of a variant is specified by 
null, the variant has
 no components.
 
 20
-The discriminant of a variant_part is said to govern the variant_part
+The discriminant of a variant_part is said to <govern> the variant_part
 and its variants.  In addition, the discriminant of a derived type
 governs a variant_part and its variants if it corresponds (see *note
 3.7::) to the discriminant of the variant_part.
@@ -14150,13 +14181,13 @@ in turn to any further variant that is, itself, 
included in the
 component_list of the given variant.
 
 21.1/3
-{AI05-0290-1AI05-0290-1} When an object of a discriminated type T is
+{<AI05-0290-1AI05-0290-1>} When an object of a discriminated type <T> is
 initialized by default, Constraint_Error is raised if no
-discrete_choice_list of any variant of a variant_part of T covers the
+discrete_choice_list of any variant of a variant_part of <T> covers the
 value of the discriminant that governs the variant_part.  When a
-variant_part appears in the component_list of another variant V, this
-test is only applied if the value of the discriminant governing V is
-covered by the discrete_choice_list of V.
+variant_part appears in the component_list of another variant <V>, this
+test is only applied if the value of the discriminant governing <V> is
+covered by the discrete_choice_list of <V>.
 
 21.a/3
           Implementation Note: This is not a "check"; it cannot be
@@ -14189,7 +14220,7 @@ component_list of each variant in the order in which 
they appear.
                               _Examples_
 
 23
-Example of record type with a variant part:
+<Example of record type with a variant part: >
 
 24
      type Device is (Printer, Disk, Drum);
@@ -14209,14 +14240,14 @@ Example of record type with a variant part:
            end record;
 
 26
-Examples of record subtypes:
+<Examples of record subtypes:>
 
 27
      subtype Drum_Unit is Peripheral(Drum);
      subtype Disk_Unit is Peripheral(Disk);
 
 28
-Examples of constrained record variables:
+<Examples of constrained record variables:>
 
 29
      Writer   : Peripheral(Unit  => Printer);
@@ -14239,7 +14270,7 @@ Examples of constrained record variables:
           associations.
 
 29.c/3
-          {AI05-0299-1AI05-0299-1} We have added the term Discrete
+          {<AI05-0299-1AI05-0299-1>} We have added the term Discrete
           Choice to the title since this is where they are talked about.
           This is analogous to the name of the subclause "Index
           Constraints and Discrete Ranges" in the subclause on Array
@@ -14253,7 +14284,7 @@ Examples of constrained record variables:
                    _Incompatibilities With Ada 2005_
 
 29.e/3
-          {AI05-0158-1AI05-0158-1} Membership tests are no longer
+          {<AI05-0158-1AI05-0158-1>} Membership tests are no longer
           allowed as a discrete_choice, in order that those tests can be
           expanded to allow multiple tests in a single expression
           without ambiguity.  Since a membership test has a boolean
@@ -14262,12 +14293,12 @@ Examples of constrained record variables:
                        _Extensions to Ada 2005_
 
 29.f/3
-          {AI05-0153-3AI05-0153-3} Subtypes with static predicates can
+          {<AI05-0153-3AI05-0153-3>} Subtypes with static predicates can
           be used in discrete_choices, and the coverage rules are
           modified to respect the predicates.
 
 29.g/3
-          {AI05-0188-1AI05-0188-1} Variants in generic specifications
+          {<AI05-0188-1AI05-0188-1>} Variants in generic specifications
           are no longer rejected if the subtype of the actual type does
           not include all of the case choices.  This probably isn't
           useful, but it is consistent with the treatment of
@@ -14276,17 +14307,17 @@ Examples of constrained record variables:
                     _Wording Changes from Ada 2005_
 
 29.h/3
-          {AI05-0290-1AI05-0290-1} Added a test that some variant covers
-          the value of a discriminant that governs a variant_part.  This
-          is similar to the test that some case limb covers the value of
-          the Selecting_expression of a case_statement.  This test
-          cannot change the behavior of any nonerroneous Ada 2005
-          program, so it is not an inconsistency.
+          {<AI05-0290-1AI05-0290-1>} Added a test that some variant
+          covers the value of a discriminant that governs a
+          variant_part.  This is similar to the test that some case limb
+          covers the value of the <Selecting_>expression of a
+          case_statement.  This test cannot change the behavior of any
+          nonerroneous Ada 2005 program, so it is not an inconsistency.
 
                     _Wording Changes from Ada 2012_
 
 29.i/4
-          {AI12-0071-1AI12-0071-1} Corrigendum: Updated wording of the
+          {<AI12-0071-1AI12-0071-1>} Corrigendum: Updated wording of the
           coverage rules to use the new term "satisfies the predicates"
           (see *note 3.2.4::).
 
@@ -14299,14 +14330,14 @@ File: aarm2012.info,  Node: 3.9,  Next: 3.10,  Prev: 
3.8,  Up: 3
 1
 [ Tagged types and type extensions support object-oriented programming,
 based on inheritance with extension and run-time polymorphism via
-dispatching operations. ]
+<dispatching operations>.  ]
 
                      _Language Design Principles_
 
 1.a/2
-          {AI95-00251-01AI95-00251-01} The intended implementation model
-          is for the static portion of a tag to be represented as a
-          pointer to a statically allocated and link-time initialized
+          {<AI95-00251-01AI95-00251-01>} The intended implementation
+          model is for the static portion of a tag to be represented as
+          a pointer to a statically allocated and link-time initialized
           type descriptor.  The type descriptor contains the address of
           the code for each primitive operation of the type.  It
           probably also contains other information, such as might make
@@ -14321,7 +14352,7 @@ dispatching operations. ]
           operation; the linker fills in the actual addresses.
 
 1.b.1/2
-          {AI95-00251-01AI95-00251-01} Primitive operations of type
+          {<AI95-00251-01AI95-00251-01>} Primitive operations of type
           extensions that are declared at a level deeper than the level
           of the ultimate ancestor from which they are derived can be
           represented by wrappers that use the dynamic part of the tag
@@ -14335,7 +14366,7 @@ dispatching operations. ]
           indirect access.)
 
 1.b.2/2
-          {AI95-00251-01AI95-00251-01} If the tagged type is descended
+          {<AI95-00251-01AI95-00251-01>} If the tagged type is descended
           from any interface types, it also will need to include
           "subtags" (one for each interface) that describe the mapping
           of the primitive operations of the interface to the primitives
@@ -14357,7 +14388,7 @@ dispatching operations. ]
           possible to get a run-time error from a missing method.
 
 1.e/2
-          {AI95-00251-01AI95-00251-01} Dispatching calls should be
+          {<AI95-00251-01AI95-00251-01>} Dispatching calls should be
           efficient, and should have a bounded worst-case execution
           time.  This is important in a language intended for real-time
           applications.  In the intended implementation model, a
@@ -14401,7 +14432,7 @@ dispatching operations. ]
           the type profiles of the operations.
 
 1.k/2
-          {AI95-00401-01AI95-00401-01} When a type extension is
+          {<AI95-00401-01AI95-00401-01>} When a type extension is
           declared, if there is any place within its immediate scope
           where a certain subprogram of the parent or progenitor is
           visible, then a matching subprogram should override.  If there
@@ -14422,21 +14453,21 @@ dispatching operations. ]
                           _Static Semantics_
 
 2/2
-{AI95-00345-01AI95-00345-01} A record type or private type that has the
-reserved word tagged in its declaration is called a tagged type.  In
-addition, an interface type is a tagged type, as is a task or protected
-type derived from an interface (see *note 3.9.4::).  [When deriving from
-a tagged type, as for any derived type, additional primitive subprograms
-may be defined, and inherited primitive subprograms may be overridden.] 
-The derived type is called an extension of its ancestor types, or simply
-a type extension.
+{<AI95-00345-01AI95-00345-01>} A record type or private type that has
+the reserved word tagged in its declaration is called a <tagged> type.
+In addition, an interface type is a tagged type, as is a task or
+protected type derived from an interface (see *note 3.9.4::).  [When
+deriving from a tagged type, as for any derived type, additional
+primitive subprograms may be defined, and inherited primitive
+subprograms may be overridden.]  The derived type is called an
+<extension> of its ancestor types, or simply a <type extension>.
 
 2.1/2
-{AI95-00345-01AI95-00345-01} Every type extension is also a tagged type,
-and is a record extension or a private extension of some other tagged
-type, or a noninterface synchronized tagged type (see *note 3.9.4::).  A
-record extension is defined by a derived_type_definition with a
-record_extension_part (see *note 3.9.1::)[, which may include the
+{<AI95-00345-01AI95-00345-01>} Every type extension is also a tagged
+type, and is a <record extension> or a <private extension> of some other
+tagged type, or a noninterface synchronized tagged type (see *note
+3.9.4::).  A record extension is defined by a derived_type_definition
+with a record_extension_part (see *note 3.9.1::)[, which may include the
 definition of additional components].  A private extension, which is a
 partial view of a record extension or of a synchronized tagged type, can
 be declared in the visible part of a package (see *note 7.3::) or in a
@@ -14453,8 +14484,8 @@ generic formal part (see *note 12.5.1::).
           with additional components.
 
 2.b/2
-          Ramification: {AI95-00218-03AI95-00218-03} If a tagged type is
-          declared other than in a package_specification, it is
+          Ramification: {<AI95-00218-03AI95-00218-03>} If a tagged type
+          is declared other than in a package_specification, it is
           impossible to add new primitive subprograms for that type,
           although it can inherit primitive subprograms, and those can
           be overridden.  If the user incorrectly thinks a certain
@@ -14468,15 +14499,16 @@ generic formal part (see *note 12.5.1::).
           with Ada 95.
 
 3
-An object of a tagged type has an associated (run-time) tag that
+An object of a tagged type has an associated (run-time) <tag> that
 identifies the specific tagged type used to create the object
-originally.  [ The tag of an operand of a class-wide tagged type T'Class
-controls which subprogram body is to be executed when a primitive
-subprogram of type T is applied to the operand (see *note 3.9.2::);
-using a tag to control which body to execute is called dispatching.] 
+originally.  [ The tag of an operand of a class-wide tagged type
+<T>'Class controls which subprogram body is to be executed when a
+primitive subprogram of type <T> is applied to the operand (see *note
+3.9.2::); using a tag to control which body to execute is called
+<dispatching>.]  
 
 4/2
-{AI95-00344-01AI95-00344-01} The tag of a specific tagged type
+{<AI95-00344-01AI95-00344-01>} The tag of a specific tagged type
 identifies the full_type_declaration of the type, and for a type
 extension, is sufficient to uniquely identify the type among all
 descendants of the same ancestor.  If a declaration for a tagged type
@@ -14488,10 +14520,10 @@ generic body, the language does not specify whether 
repeated
 instantiations of the generic body result in distinct tags.
 
 4.a/2
-          This paragraph was deleted.{AI95-00344-01AI95-00344-01}
+          <This paragraph was deleted.>{<AI95-00344-01AI95-00344-01>}
 
 4.a.1/2
-          Implementation Note: {AI95-00344-01AI95-00344-01} In most
+          Implementation Note: {<AI95-00344-01AI95-00344-01>} In most
           cases, a tag need only identify a particular tagged type
           declaration, and can therefore be a simple link-time-known
           address.  However, for tag checks (see *note 3.9.2::) it is
@@ -14514,7 +14546,7 @@ instantiations of the generic body result in distinct 
tags.
           level of indirection, the type Tag could remain a single-word.
 
 4.b/2
-          {AI95-00344-01AI95-00344-01} For types that are not type
+          {<AI95-00344-01AI95-00344-01>} For types that are not type
           extensions (even for ones declared in nested scopes), we do
           not require that repeated elaborations of the same
           full_type_declaration correspond to distinct tags.  This was
@@ -14524,7 +14556,7 @@ instantiations of the generic body result in distinct 
tags.
           in Ada 95 require additional information with the tag.
 
 4.c/2
-          To be honest: {AI95-00344-01AI95-00344-01} The wording "is
+          To be honest: {<AI95-00344-01AI95-00344-01>} The wording "is
           sufficient to uniquely identify the type among all descendants
           of the same ancestor" only applies to types that currently
           exist.  It is not necessary to distinguish between descendants
@@ -14540,44 +14572,44 @@ instantiations of the generic body result in distinct 
tags.
 The following language-defined library package exists:
 
 6/2
-     {AI95-00362-01AI95-00362-01} package Ada.Tags is
+     {<AI95-00362-01AI95-00362-01>} package Ada.Tags is
          pragma Preelaborate(Tags);
          type Tag is private;
          pragma Preelaborable_Initialization(Tag);
 
 6.1/2
-     {AI95-00260-02AI95-00260-02}     No_Tag : constant Tag;
+     {<AI95-00260-02AI95-00260-02>}     No_Tag : constant Tag;
 
 7/2
-     {AI95-00400-01AI95-00400-01}     function Expanded_Name(T : Tag) return 
String;
+     {<AI95-00400-01AI95-00400-01>}     function Expanded_Name(T : Tag) return 
String;
          function Wide_Expanded_Name(T : Tag) return Wide_String;
          function Wide_Wide_Expanded_Name(T : Tag) return Wide_Wide_String;
          function External_Tag(T : Tag) return String;
          function Internal_Tag(External : String) return Tag;
 
 7.1/2
-     {AI95-00344-01AI95-00344-01}     function Descendant_Tag(External : 
String; Ancestor : Tag) return Tag;
+     {<AI95-00344-01AI95-00344-01>}     function Descendant_Tag(External : 
String; Ancestor : Tag) return Tag;
          function Is_Descendant_At_Same_Level(Descendant, Ancestor : Tag)
              return Boolean;
 
 7.2/2
-     {AI95-00260-02AI95-00260-02}     function Parent_Tag (T : Tag) return Tag;
+     {<AI95-00260-02AI95-00260-02>}     function Parent_Tag (T : Tag) return 
Tag;
 
 7.3/2
-     {AI95-00405-01AI95-00405-01}     type Tag_Array is array (Positive range 
<>) of Tag;
+     {<AI95-00405-01AI95-00405-01>}     type Tag_Array is array (Positive 
range <>) of Tag;
 
 7.4/2
-     {AI95-00405-01AI95-00405-01}     function Interface_Ancestor_Tags (T : 
Tag) return Tag_Array;
+     {<AI95-00405-01AI95-00405-01>}     function Interface_Ancestor_Tags (T : 
Tag) return Tag_Array;
 
 7.5/3
-     {AI05-0173-1AI05-0173-1}     function Is_Abstract (T : Tag) return 
Boolean;
+     {<AI05-0173-1AI05-0173-1>}     function Is_Abstract (T : Tag) return 
Boolean;
 
 8
          Tag_Error : exception;
 
 9
      private
-        ... -- not specified by the language
+        ... -- <not specified by the language>
      end Ada.Tags;
 
 9.a
@@ -14593,15 +14625,15 @@ The following language-defined library package exists:
           one reason to allow equality for type Tag.
 
 9.1/2
-{AI95-00260-02AI95-00260-02} No_Tag is the default initial value of type
-Tag.
+{<AI95-00260-02AI95-00260-02>} No_Tag is the default initial value of
+type Tag.
 
 9.c/2
-          Reason: {AI95-00260-02AI95-00260-02} This is similar to the
+          Reason: {<AI95-00260-02AI95-00260-02>} This is similar to the
           requirement that all access values be initialized to null.
 
 10/2
-{AI95-00400-01AI95-00400-01} The function Wide_Wide_Expanded_Name
+{<AI95-00400-01AI95-00400-01>} The function Wide_Wide_Expanded_Name
 returns the full expanded name of the first subtype of the specific type
 identified by the tag, in upper case, starting with a root library unit.
 The result is implementation defined if the type is declared within an
@@ -14617,7 +14649,7 @@ unnamed block_statement.
           unnamed block_statement.
 
 10.1/2
-{AI95-00400-01AI95-00400-01} The function Expanded_Name (respectively,
+{<AI95-00400-01AI95-00400-01>} The function Expanded_Name (respectively,
 Wide_Expanded_Name) returns the same sequence of graphic characters as
 that defined for Wide_Wide_Expanded_Name, if all the graphic characters
 are defined in Character (respectively, Wide_Character); otherwise, the
@@ -14645,12 +14677,12 @@ equivalent to the attribute_reference S'External_Tag 
(see *note 13.3::).
           via an attribute_definition_clause.
 
 11.1/2
-{AI95-00417-01AI95-00417-01} The string returned by the functions
+{<AI95-00417-01AI95-00417-01>} The string returned by the functions
 Expanded_Name, Wide_Expanded_Name, Wide_Wide_Expanded_Name, and
 External_Tag has lower bound 1.
 
 12/2
-{AI95-00279-01AI95-00279-01} The function Internal_Tag returns a tag
+{<AI95-00279-01AI95-00279-01>} The function Internal_Tag returns a tag
 that corresponds to the given external tag, or raises Tag_Error if the
 given string is not the external tag for any specific type of the
 partition.  Tag_Error is also raised if the specific type identified is
@@ -14658,19 +14690,20 @@ a library-level type whose tag has not yet been 
created (see *note
 13.14::).
 
 12.a/3
-          Reason: {AI95-00279-01AI95-00279-01} {AI05-0005-1AI05-0005-1}
-          The check for uncreated library-level types prevents a
-          reference to the type before execution reaches the freezing
-          point of the type.  This is important so that T'Class'Input or
-          an instance of Tags.Generic_Dispatching_Constructor do not try
-          to create an object of a type that hasn't been frozen (which
-          might not have yet elaborated its constraints).  We don't
-          require this behavior for non-library-level types as the tag
-          can be created multiple times and possibly multiple copies can
-          exist at the same time, making the check complex.
+          Reason: {<AI95-00279-01AI95-00279-01>}
+          {<AI05-0005-1AI05-0005-1>} The check for uncreated
+          library-level types prevents a reference to the type before
+          execution reaches the freezing point of the type.  This is
+          important so that T'Class'Input or an instance of
+          Tags.Generic_Dispatching_Constructor do not try to create an
+          object of a type that hasn't been frozen (which might not have
+          yet elaborated its constraints).  We don't require this
+          behavior for non-library-level types as the tag can be created
+          multiple times and possibly multiple copies can exist at the
+          same time, making the check complex.
 
 12.1/3
-{AI95-00344-01AI95-00344-01} {AI05-0113-1AI05-0113-1} The function
+{<AI95-00344-01AI95-00344-01>} {<AI05-0113-1AI05-0113-1>} The function
 Descendant_Tag returns the (internal) tag for the type that corresponds
 to the given external tag and is both a descendant of the type
 identified by the Ancestor tag and has the same accessibility level as
@@ -14692,7 +14725,7 @@ has the appropriate Ancestor and accessibility level.
           constructing a user-defined replacement for T'Class'Input.
 
 12.b.1/3
-          {AI05-0113-1AI05-0113-1} Rules for specifying external tags
+          {<AI05-0113-1AI05-0113-1>} Rules for specifying external tags
           will usually prevent an external tag from identifying more
           than one type.  However, an external tag can identify multiple
           types if a generic body contains a derivation of a tagged type
@@ -14702,7 +14735,7 @@ has the appropriate Ancestor and accessibility level.
           case.)
 
 12.2/2
-{AI95-00344-01AI95-00344-01} The function Is_Descendant_At_Same_Level
+{<AI95-00344-01AI95-00344-01>} The function Is_Descendant_At_Same_Level
 returns True if the Descendant tag identifies a type that is both a
 descendant of the type identified by Ancestor and at the same
 accessibility level.  If not, it returns False.
@@ -14716,9 +14749,9 @@ accessibility level.  If not, it returns False.
           a user-defined replacement for T'Class'Output.
 
 12.3/3
-{AI05-0115-1AI05-0115-1} For the purposes of the dynamic semantics of
+{<AI05-0115-1AI05-0115-1>} For the purposes of the dynamic semantics of
 functions Descendant_Tag and Is_Descendant_At_Same_Level, a tagged type
-T2 is a descendant of a type T1 if it is the same as T1, or if its
+T2 is a <descendant> of a type T1 if it is the same as T1, or if its
 parent type or one of its progenitor types is a descendant of type T1 by
 this rule[, even if at the point of the declaration of T2, one of the
 derivations in the chain is not visible].
@@ -14729,20 +14762,20 @@ derivations in the chain is not visible].
           parent type.  See *note 7.3.1::.
 
 12.4/4
-{AI95-00260-02AI95-00260-02} {AI12-0056-1AI12-0056-1} The function
+{<AI95-00260-02AI95-00260-02>} {<AI12-0056-1AI12-0056-1>} The function
 Parent_Tag returns the tag of the parent type of the type whose tag is
 T. If the type does not have a parent type (that is, it was not defined
 by a derived_type_definition), then No_Tag is returned.
 
 12.d/4
-          Ramification: {AI12-0005-1AI12-0005-1} The parent type is
+          Ramification: {<AI12-0005-1AI12-0005-1>} The parent type is
           always the parent of the full type; a private extension
           appears to define a parent type, but it does not (only the
           various forms of derivation do that).  As this is a run-time
           operation, ignoring privacy is OK.
 
 12.5/3
-{AI95-00405-01AI95-00405-01} The function Interface_Ancestor_Tags
+{<AI95-00405-01AI95-00405-01>} The function Interface_Ancestor_Tags
 returns an array containing the tag of each interface ancestor type of
 the type whose tag is T, other than T itself.  The lower bound of the
 returned array is 1, and the order of the returned tags is unspecified.
@@ -14761,24 +14794,24 @@ has no interface ancestors, a null array is returned.]
           has an interface as an ancestor.
 
 12.6/3
-{AI05-0173-1AI05-0173-1} The function Is_Abstract returns True if the
+{<AI05-0173-1AI05-0173-1>} The function Is_Abstract returns True if the
 type whose tag is T is abstract, and False otherwise.
 
 13
-For every subtype S of a tagged type T (specific or class-wide), the
+For every subtype S of a tagged type <T> (specific or class-wide), the
 following attributes are defined:
 
 14
 S'Class
                S'Class denotes a subtype of the class-wide type (called
-               T'Class in this International Standard) for the class
-               rooted at T (or if S already denotes a class-wide
+               <T>'Class in this International Standard) for the class
+               rooted at <T> (or if S already denotes a class-wide
                subtype, then S'Class is the same as S).
 
 15
                S'Class is unconstrained.  However, if S is constrained,
                then the values of S'Class are only those that when
-               converted to the type T belong to S.
+               converted to the type <T> belong to S.
 
 15.a
           Ramification: This attribute is defined for both specific and
@@ -14788,10 +14821,10 @@ S'Class
 15.b
           Note that if S is constrained, S'Class is only partially
           constrained, since there might be additional discriminants
-          added in descendants of T which are not constrained.
+          added in descendants of <T> which are not constrained.
 
 15.c/2
-          Reason: {AI95-00326-01AI95-00326-01} The Class attribute is
+          Reason: {<AI95-00326-01AI95-00326-01>} The Class attribute is
           not defined for untagged subtypes (except for incomplete types
           and private types whose full view is tagged -- see *note
           J.11:: and *note 7.3.1::) so as to preclude implicit
@@ -14802,7 +14835,7 @@ S'Class
 
 16
 S'Tag
-               S'Tag denotes the tag of the type T (or if T is
+               S'Tag denotes the tag of the type <T> (or if <T> is
                class-wide, the tag of the root type of the corresponding
                class).  The value of this attribute is of type Tag.
 
@@ -14828,11 +14861,11 @@ X'Tag
           of a class-wide type.
 
 18.1/2
-{AI95-00260-02AI95-00260-02} {AI95-00441-01AI95-00441-01} The following
-language-defined generic function exists:
+{<AI95-00260-02AI95-00260-02>} {<AI95-00441-01AI95-00441-01>} The
+following language-defined generic function exists:
 
 18.2/3
-     {AI05-0229-1AI05-0229-1} generic
+     {<AI05-0229-1AI05-0229-1>} generic
          type T (<>) is abstract tagged limited private;
          type Parameters (<>) is limited private;
          with function Constructor (Params : not null access Parameters)
@@ -14844,7 +14877,7 @@ language-defined generic function exists:
      pragma Preelaborate(Generic_Dispatching_Constructor);
 
 18.3/2
-{AI95-00260-02AI95-00260-02} Tags.Generic_Dispatching_Constructor
+{<AI95-00260-02AI95-00260-02>} Tags.Generic_Dispatching_Constructor
 provides a mechanism to create an object of an appropriate type from
 just a tag value.  The function Constructor is expected to create the
 object given a reference to an object of type Parameters.
@@ -14865,20 +14898,20 @@ follows:
 
 20
    * The tag of a stand-alone object, a component, or an aggregate of a
-     specific tagged type T identifies T.
+     specific tagged type <T> identifies <T>.
 
 20.a
-          Discussion: The tag of a formal parameter of type T is not
-          necessarily the tag of T, if, for example, the actual was a
+          Discussion: The tag of a formal parameter of type <T> is not
+          necessarily the tag of <T>, if, for example, the actual was a
           type conversion.
 
 21
    * The tag of an object created by an allocator for an access type
-     with a specific designated tagged type T, identifies T.
+     with a specific designated tagged type <T>, identifies <T>.
 
 21.a
           Discussion: The tag of an object designated by a value of such
-          an access type might not be T, if, for example, the access
+          an access type might not be <T>, if, for example, the access
           value is the result of a type conversion.
 
 22
@@ -14894,10 +14927,10 @@ follows:
 
 23
    * The tag of the result returned by a function whose result type is a
-     specific tagged type T identifies T.
+     specific tagged type <T> identifies <T>.
 
 23.a/2
-          Implementation Note: {AI95-00318-02AI95-00318-02} For a
+          Implementation Note: {<AI95-00318-02AI95-00318-02>} For a
           limited tagged type, the return object is "built in place" in
           the ultimate result object with the appropriate tag.  For a
           nonlimited type, a new anonymous object with the appropriate
@@ -14905,7 +14938,7 @@ follows:
           6.5::, "*note 6.5:: Return Statements".
 
 24/2
-   * {AI95-00318-02AI95-00318-02} The tag of the result returned by a
+   * {<AI95-00318-02AI95-00318-02>} The tag of the result returned by a
      function with a class-wide result type is that of the return
      object.
 
@@ -14914,16 +14947,16 @@ The tag is preserved by type conversion and by 
parameter passing.  The
 tag of a value is the tag of the associated object (see *note 6.2::).
 
 25.1/3
-{AI95-00260-02AI95-00260-02} {AI95-00344-01AI95-00344-01}
-{AI95-00405-01AI95-00405-01} {AI05-0092-1AI05-0092-1}
-{AI05-0262-1AI05-0262-1} Tag_Error is raised by a call of
+{<AI95-00260-02AI95-00260-02>} {<AI95-00344-01AI95-00344-01>}
+{<AI95-00405-01AI95-00405-01>} {<AI05-0092-1AI05-0092-1>}
+{<AI05-0262-1AI05-0262-1>} Tag_Error is raised by a call of
 Descendant_Tag, Expanded_Name, External_Tag, Interface_Ancestor_Tags,
 Is_Abstract, Is_Descendant_At_Same_Level, Parent_Tag,
 Wide_Expanded_Name, or Wide_Wide_Expanded_Name if any tag passed is
 No_Tag.
 
 25.2/2
-{AI95-00260-02AI95-00260-02} An instance of
+{<AI95-00260-02AI95-00260-02>} An instance of
 Tags.Generic_Dispatching_Constructor raises Tag_Error if The_Tag does
 not represent a concrete descendant of T or if the innermost master (see
 *note 7.6.1::) of this descendant is not also a master of the instance.
@@ -14945,12 +14978,12 @@ returns the result.  Any exception raised by the 
function is propagated.
                          _Erroneous Execution_
 
 25.3/2
-{AI95-00260-02AI95-00260-02} If an internal tag provided to an instance
-of Tags.Generic_Dispatching_Constructor or to any subprogram declared in
-package Tags identifies either a type that is not library-level and
-whose tag has not been created (see *note 13.14::), or a type that does
-not exist in the partition at the time of the call, then execution is
-erroneous.
+{<AI95-00260-02AI95-00260-02>} If an internal tag provided to an
+instance of Tags.Generic_Dispatching_Constructor or to any subprogram
+declared in package Tags identifies either a type that is not
+library-level and whose tag has not been created (see *note 13.14::), or
+a type that does not exist in the partition at the time of the call,
+then execution is erroneous.
 
 25.b/2
           Ramification: One reason that a type might not exist in the
@@ -14976,7 +15009,7 @@ erroneous.
           13.13.2::).
 
 25.d/2
-          Discussion: {AI95-00344-01AI95-00344-01} Ada 95 allowed
+          Discussion: {<AI95-00344-01AI95-00344-01>} Ada 95 allowed
           Tag_Error in this case, or expected the functions to work.
           This worked because most implementations used tags constructed
           at link-time, and each elaboration of the same
@@ -15006,7 +15039,7 @@ erroneous.
                      _Implementation Permissions_
 
 26/2
-{AI95-00260-02AI95-00260-02} {AI95-00279-01AI95-00279-01} The
+{<AI95-00260-02AI95-00260-02>} {<AI95-00279-01AI95-00279-01>} The
 implementation of Internal_Tag and Descendant_Tag may raise Tag_Error if
 no specific type corresponding to the string External passed as a
 parameter exists in the partition at the time the function is called, or
@@ -15014,8 +15047,8 @@ if there is no such type whose innermost master is a 
master of the point
 of the function call.
 
 26.a/2
-          Reason: {AI95-00260-02AI95-00260-02}
-          {AI95-00279-01AI95-00279-01} {AI95-00344-01AI95-00344-01}
+          Reason: {<AI95-00260-02AI95-00260-02>}
+          {<AI95-00279-01AI95-00279-01>} {<AI95-00344-01AI95-00344-01>}
           Locking would be required to ensure that the mapping of
           strings to tags never returned tags of types which no longer
           exist, because types can cease to exist (because they belong
@@ -15029,7 +15062,7 @@ of the function call.
                         _Implementation Advice_
 
 26.1/3
-{AI95-00260-02AI95-00260-02} {AI05-0113-1AI05-0113-1} Internal_Tag
+{<AI95-00260-02AI95-00260-02>} {<AI05-0113-1AI05-0113-1>} Internal_Tag
 should return the tag of a type, if one exists, whose innermost master
 is a master of the point of the function call.
 
@@ -15039,16 +15072,16 @@ is a master of the point of the function call.
           of the point of the function call..
 
 26.c/2
-          Reason: {AI95-00260-02AI95-00260-02}
-          {AI95-00344-01AI95-00344-01} It's not helpful if Internal_Tag
-          returns the tag of some type in another task when one is
-          available in the task that made the call.  We don't require
-          this behavior (because it requires the same implementation
-          techniques we decided not to insist on previously), but
-          encourage it.
+          Reason: {<AI95-00260-02AI95-00260-02>}
+          {<AI95-00344-01AI95-00344-01>} It's not helpful if
+          Internal_Tag returns the tag of some type in another task when
+          one is available in the task that made the call.  We don't
+          require this behavior (because it requires the same
+          implementation techniques we decided not to insist on
+          previously), but encourage it.
 
 26.d/3
-          Discussion: {AI05-0113-1AI05-0113-1} There is no Advice for
+          Discussion: {<AI05-0113-1AI05-0113-1>} There is no Advice for
           the result of Internal_Tag if no such type exists.  In most
           cases, the Implementation Permission can be used to raise
           Tag_Error, but some other tag can be returned as well.
@@ -15072,14 +15105,14 @@ is a master of the point of the function call.
      class-wide.
 
 30/2
-     73  {AI95-00260-02AI95-00260-02} {AI95-00326-01AI95-00326-01} The
-     capability provided by Tags.Generic_Dispatching_Constructor is
-     sometimes known as a factory.
+     73  {<AI95-00260-02AI95-00260-02>} {<AI95-00326-01AI95-00326-01>}
+     The capability provided by Tags.Generic_Dispatching_Constructor is
+     sometimes known as a <factory>.
 
                               _Examples_
 
 31
-Examples of tagged record types:
+<Examples of tagged record types:>
 
 32
      type Point is tagged
@@ -15089,7 +15122,7 @@ Examples of tagged record types:
 
 33
      type Expression is tagged null record;
-       -- Components will be added by each extension
+       --< Components will be added by each extension>
 
                         _Extensions to Ada 83_
 
@@ -15099,7 +15132,7 @@ Examples of tagged record types:
                      _Inconsistencies With Ada 95_
 
 33.b/2
-          {AI95-00279-01AI95-00279-01} Amendment Correction: Added
+          {<AI95-00279-01AI95-00279-01>} Amendment Correction: Added
           wording specifying that Internal_Tag must raise Tag_Error if
           the tag of a library-level type has not yet been created.  Ada
           95 gave an Implementation Permission to do this; we require it
@@ -15115,8 +15148,8 @@ Examples of tagged record types:
           Permission, this is not a significant inconsistency.
 
 33.c/2
-          {AI95-00417-01AI95-00417-01} We now define the lower bound of
-          the string returned from [[Wide_]Wide_]Expanded_Name and
+          {<AI95-00417-01AI95-00417-01>} We now define the lower bound
+          of the string returned from [[Wide_]Wide_]Expanded_Name and
           External_Name.  This makes working with the returned string
           easier, and is consistent with many other string-returning
           functions in Ada.  This is technically an inconsistency; if a
@@ -15128,71 +15161,72 @@ Examples of tagged record types:
                     _Incompatibilities With Ada 95_
 
 33.d/3
-          {AI95-00260-02AI95-00260-02} {AI95-00344-01AI95-00344-01}
-          {AI95-00400-01AI95-00400-01} {AI95-00405-01AI95-00405-01}
-          {AI05-0005-1AI05-0005-1} Constant No_Tag, and functions
+          {<AI95-00260-02AI95-00260-02>} {<AI95-00344-01AI95-00344-01>}
+          {<AI95-00400-01AI95-00400-01>} {<AI95-00405-01AI95-00405-01>}
+          {<AI05-0005-1AI05-0005-1>} Constant No_Tag, and functions
           Parent_Tag, Interface_Ancestor_Tags, Descendant_Tag,
           Is_Descendant_At_Same_Level, Wide_Expanded_Name, and
           Wide_Wide_Expanded_Name are added to Ada.Tags.  If Ada.Tags is
-          referenced in a use_clause, and an entity E with the same
+          referenced in a use_clause, and an entity <E> with the same
           defining_identifier as a new entity in Ada.Tags is defined in
           a package that is also referenced in a use_clause, the entity
-          E may no longer be use-visible, resulting in errors.  This
+          <E> may no longer be use-visible, resulting in errors.  This
           should be rare and is easily fixed if it does occur.
 
                         _Extensions to Ada 95_
 
 33.e/2
-          {AI95-00362-01AI95-00362-01} Ada.Tags is now defined to be
+          {<AI95-00362-01AI95-00362-01>} Ada.Tags is now defined to be
           preelaborated.
 
 33.f/2
-          {AI95-00260-02AI95-00260-02} Generic function
+          {<AI95-00260-02AI95-00260-02>} Generic function
           Tags.Generic_Dispatching_Constructor is new.
 
                      _Wording Changes from Ada 95_
 
 33.g/2
-          {AI95-00318-02AI95-00318-02} We talk about return objects
+          {<AI95-00318-02AI95-00318-02>} We talk about return objects
           rather than return expressions, as functions can return using
           an extended_return_statement.
 
 33.h/2
-          {AI95-00344-01AI95-00344-01} Added wording to define that tags
-          for all descendants of a tagged type must be distinct.  This
-          is needed to ensure that more nested type extensions will work
-          properly.  The wording does not require implementation changes
-          for types that were allowed in Ada 95.
+          {<AI95-00344-01AI95-00344-01>} Added wording to define that
+          tags for all descendants of a tagged type must be distinct.
+          This is needed to ensure that more nested type extensions will
+          work properly.  The wording does not require implementation
+          changes for types that were allowed in Ada 95.
 
                     _Inconsistencies With Ada 2005_
 
 33.i/3
-          {AI05-0113-1AI05-0113-1} Correction: Added wording specifying
-          that Dependent_Tag must raise Tag_Error if there is more than
-          one type which matches the requirements.  If an implementation
-          had returned a random tag of the matching types, a program may
-          have worked properly.  However, such a program would not be
-          portable (another implementation may return a different tag)
-          and the conditions that would cause the problem are unlikely
-          (most likely, a tagged type extension declared in a generic
-          body with multiple instances in the same scope).
+          {<AI05-0113-1AI05-0113-1>} Correction: Added wording
+          specifying that Dependent_Tag must raise Tag_Error if there is
+          more than one type which matches the requirements.  If an
+          implementation had returned a random tag of the matching
+          types, a program may have worked properly.  However, such a
+          program would not be portable (another implementation may
+          return a different tag) and the conditions that would cause
+          the problem are unlikely (most likely, a tagged type extension
+          declared in a generic body with multiple instances in the same
+          scope).
 
                    _Incompatibilities With Ada 2005_
 
 33.j/3
-          {AI05-0173-1AI05-0173-1} Function Is_Abstract is added to
+          {<AI05-0173-1AI05-0173-1>} Function Is_Abstract is added to
           Ada.Tags.  If Ada.Tags is referenced in a use_clause, and an
-          entity E with the defining_identifier Is_Abstract is defined
+          entity <E> with the defining_identifier Is_Abstract is defined
           in a package that is also referenced in a use_clause, the
-          entity E may no longer be use-visible, resulting in errors.
+          entity <E> may no longer be use-visible, resulting in errors.
           This should be rare and is easily fixed if it does occur.
 
                     _Wording Changes from Ada 2005_
 
 33.k/3
-          {AI05-0115-1AI05-0115-1} Correction: We explicitly define the
-          meaning of "descendant" at runtime, so that it does not depend
-          on visibility as does the usual meaning.
+          {<AI05-0115-1AI05-0115-1>} Correction: We explicitly define
+          the meaning of "descendant" at runtime, so that it does not
+          depend on visibility as does the usual meaning.
 
 * Menu:
 
@@ -15208,9 +15242,9 @@ File: aarm2012.info,  Node: 3.9.1,  Next: 3.9.2,  Up: 
3.9
 ---------------------
 
 1/2
-{AI95-00345-01AI95-00345-01} [ Every type extension is a tagged type,
-and is a record extension or a private extension of some other tagged
-type, or a noninterface synchronized tagged type.]
+{<AI95-00345-01AI95-00345-01>} [ Every type extension is a tagged type,
+and is a <record extension> or a <private extension> of some other
+tagged type, or a noninterface synchronized tagged type.]
 
                      _Language Design Principles_
 
@@ -15232,37 +15266,37 @@ type, or a noninterface synchronized tagged type.]
                            _Legality Rules_
 
 3/2
-{AI95-00344-01AI95-00344-01} {AI95-00345-01AI95-00345-01}
-{AI95-00419-01AI95-00419-01} The parent type of a record extension shall
-not be a class-wide type nor shall it be a synchronized tagged type (see
-*note 3.9.4::).  If the parent type or any progenitor is nonlimited,
-then each of the components of the record_extension_part shall be
-nonlimited. In addition to the places where Legality Rules normally
-apply (see *note 12.3::), these rules apply also in the private part of
-an instance of a generic unit.
+{<AI95-00344-01AI95-00344-01>} {<AI95-00345-01AI95-00345-01>}
+{<AI95-00419-01AI95-00419-01>} The parent type of a record extension
+shall not be a class-wide type nor shall it be a synchronized tagged
+type (see *note 3.9.4::).  If the parent type or any progenitor is
+nonlimited, then each of the components of the record_extension_part
+shall be nonlimited.  In addition to the places where Legality Rules
+normally apply (see *note 12.3::), these rules apply also in the private
+part of an instance of a generic unit.
 
 3.a
           Reason: If the parent is a limited formal type, then the
           actual might be nonlimited.
 
 3.b/2
-          {AI95-00344-01AI95-00344-01} Ada 95 required the record
+          {<AI95-00344-01AI95-00344-01>} Ada 95 required the record
           extensions to be the same level as the parent type.  Now we
           use accessibility checks on class-wide allocators and return
           statements to prevent objects from living longer than their
           type.
 
 3.c/2
-          {AI95-00345-01AI95-00345-01} Synchronized tagged types cannot
-          be extended.  We have this limitation so that all of the data
-          of a task or protected type is defined within the type.  Data
-          defined outside of the type wouldn't be subject to the mutual
-          exclusion properties of a protected type, and couldn't be used
-          by a task, and thus doesn't seem to be worth the potential
-          impact on implementations.
+          {<AI95-00345-01AI95-00345-01>} Synchronized tagged types
+          cannot be extended.  We have this limitation so that all of
+          the data of a task or protected type is defined within the
+          type.  Data defined outside of the type wouldn't be subject to
+          the mutual exclusion properties of a protected type, and
+          couldn't be used by a task, and thus doesn't seem to be worth
+          the potential impact on implementations.
 
 4/2
-{AI95-00344-01AI95-00344-01} Within the body of a generic unit, or the
+{<AI95-00344-01AI95-00344-01>} Within the body of a generic unit, or the
 body of any of its descendant library units, a tagged type shall not be
 declared as a descendant of a formal type declared within the formal
 part of the generic unit.
@@ -15272,26 +15306,26 @@ part of the generic unit.
           never attempt to execute an inaccessible subprogram body.
 
 4.a.1/2
-          {AI95-00344-01AI95-00344-01} The convoluted wording ("formal
+          {<AI95-00344-01AI95-00344-01>} The convoluted wording ("formal
           type declared within the formal part") is necessary to include
           tagged types that are formal parameters of formal packages of
           the generic unit, as well as formal tagged and tagged formal
           derived types of the generic unit.
 
 4.b/2
-          {AI95-00344-01AI95-00344-01} This rule is necessary in order
+          {<AI95-00344-01AI95-00344-01>} This rule is necessary in order
           to preserve the contract model.
 
 4.c/2
-          {AI05-0005-1AI05-0005-1} {AI95-00344-01AI95-00344-01} If an
-          ancestor is a formal of the generic unit , we have a problem
-          because it might have an unknown number of subprograms that
-          require overriding, as in the following example:
+          {<AI05-0005-1AI05-0005-1>} {<AI95-00344-01AI95-00344-01>} If
+          an ancestor is a formal of the generic unit , we have a
+          problem because it might have an unknown number of subprograms
+          that require overriding, as in the following example:
 
 4.d/2
                package P is
                    type T is tagged null record;
-                   function F return T; -- Inherited versions will require 
overriding.
+                   function F return T; --< Inherited versions will require 
overriding.>
                end P;
 
 4.e
@@ -15304,11 +15338,11 @@ part of the generic unit.
 
 4.f/2
                package body Gp is
-                   type NT2 is new NT with null record; -- Illegal!
+                   type NT2 is new NT with null record; --< Illegal!>
                    procedure Q(X : in NT2) is begin null; end Q;
-                   -- Is this legal or not? Can't decide because
-                   -- we don't know whether TT had any functions that require
-                   -- overriding on extension.
+                   --< Is this legal or not? Can't decide because>
+                   --< we don't know whether TT had any functions that require>
+                   --< overriding on extension.>
                end Gp;
 
 4.g
@@ -15351,10 +15385,10 @@ part of the generic unit.
           having to do with abstract types.
 
 4.l/2
-          This paragraph was deleted.
+          <This paragraph was deleted.>
 
 4.m/2
-          Ramification: {AI95-00344AI95-00344} This rule applies to
+          Ramification: {<AI95-00344AI95-00344>} This rule applies to
           types with ancestors (directly or indirectly) of formal
           interface types (see *note 12.5.5::), formal tagged private
           types (see *note 12.5.1::), and formal derived private types
@@ -15363,8 +15397,8 @@ part of the generic unit.
                           _Static Semantics_
 
 4.1/2
-{AI95-00391-01AI95-00391-01} A record extension is a null extension if
-its declaration has no known_discriminant_part and its
+{<AI95-00391-01AI95-00391-01>} A record extension is a <null extension>
+if its declaration has no known_discriminant_part and its
 record_extension_part includes no component_declarations.
 
                           _Dynamic Semantics_
@@ -15397,7 +15431,7 @@ of the record_definition.
           extension").
 
 7/2
-     75  {AI95-00344-01AI95-00344-01} When an extension is declared
+     75  {<AI95-00344-01AI95-00344-01>} When an extension is declared
      immediately within a body, primitive subprograms are inherited and
      are overridable, but new primitive subprograms cannot be added.
 
@@ -15427,41 +15461,41 @@ of the record_definition.
                               _Examples_
 
 10
-Examples of record extensions (of types defined above in *note 3.9::):
+<Examples of record extensions (of types defined above in *note 3.9::):>
 
 11
      type Painted_Point is new Point with
        record
          Paint : Color := White;
        end record;
-         -- Components X and Y are inherited
+         --< Components X and Y are inherited>
 
 12
      Origin : constant Painted_Point := (X | Y => 0.0, Paint => Black);
 
 13
      type Literal is new Expression with
-       record                 -- a leaf in an Expression tree
+       record                 --< a leaf in an Expression tree>
          Value : Real;
        end record;
 
 14
      type Expr_Ptr is access all Expression'Class;
-                                    -- see *note 3.10::
+                                    --< see *note 3.10::>
 
 15
      type Binary_Operation is new Expression with
-       record                 -- an internal node in an Expression tree
+       record                 --< an internal node in an Expression tree>
          Left, Right : Expr_Ptr;
        end record;
 
 16
      type Addition is new Binary_Operation with null record;
      type Subtraction is new Binary_Operation with null record;
-       -- No additional components needed for these extensions
+       --< No additional components needed for these extensions>
 
 17
-     Tree : Expr_Ptr :=         -- A tree representation of "5.0 + (13.0-7.0)"
+     Tree : Expr_Ptr :=         --< A tree representation of "5.0 + 
(13.0-7.0)">
         new Addition'(
            Left  => new Literal'(Value => 5.0),
            Right => new Subtraction'(
@@ -15476,7 +15510,7 @@ Examples of record extensions (of types defined above 
in *note 3.9::):
                         _Extensions to Ada 95_
 
 17.b/2
-          {AI95-00344-01AI95-00344-01} Type extensions now can be
+          {<AI95-00344-01AI95-00344-01>} Type extensions now can be
           declared in more nested scopes than their parent types.
           Additional accessibility checks on allocators and return
           statements prevent objects from outliving their type.
@@ -15484,11 +15518,11 @@ Examples of record extensions (of types defined above 
in *note 3.9::):
                      _Wording Changes from Ada 95_
 
 17.c/2
-          {AI95-00345-01AI95-00345-01} Added wording to prevent
+          {<AI95-00345-01AI95-00345-01>} Added wording to prevent
           extending synchronized tagged types.
 
 17.d/2
-          {AI95-00391-01AI95-00391-01} Defined null extension for use
+          {<AI95-00391-01AI95-00391-01>} Defined null extension for use
           elsewhere.
 
 
@@ -15498,34 +15532,35 @@ File: aarm2012.info,  Node: 3.9.2,  Next: 3.9.3,  
Prev: 3.9.1,  Up: 3.9
 --------------------------------------------
 
 1/2
-{AI95-00260-02AI95-00260-02} {AI95-00335-01AI95-00335-01} The primitive
-subprograms of a tagged type, the subprograms declared by
+{<AI95-00260-02AI95-00260-02>} {<AI95-00335-01AI95-00335-01>} The
+primitive subprograms of a tagged type, the subprograms declared by
 formal_abstract_subprogram_declaration (*note 12.6: S0298.)s, and the
 stream attributes of a specific tagged type that are available (see
 *note 13.13.2::) at the end of the declaration list where the type is
-declared are called dispatching operations.  [A dispatching operation
-can be called using a statically determined controlling tag, in which
+declared are called <dispatching operations>.  [A dispatching operation
+can be called using a statically determined <controlling> tag, in which
 case the body to be executed is determined at compile time.
 Alternatively, the controlling tag can be dynamically determined, in
-which case the call dispatches to a body that is determined at run
-time;] such a call is termed a dispatching call.  [As explained below,
+which case the call <dispatches> to a body that is determined at run
+time;] such a call is termed a <dispatching call>.  [As explained below,
 the properties of the operands and the context of a particular call on a
 dispatching operation determine how the controlling tag is determined,
 and hence whether or not the call is a dispatching call.  Run-time
 polymorphism is achieved when a dispatching operation is called by a
-dispatching call.] 
+dispatching call.]  
 
 1.a.1/2
-          Reason: {AI95-00335-01AI95-00335-01} For the stream attributes
-          of a type declared immediately within a package_specification
-          that has a partial view, the declaration list to consider is
-          the visible part of the package.  Stream attributes that are
-          not available in the same declaration list are not dispatching
-          as there is no guarantee that descendants of the type have
-          available attributes (there is such a guarantee for visibly
-          available attributes).  If we allowed dispatching for any
-          available attribute, then for attributes defined in the
-          private part we could end up executing a nonexistent body.
+          Reason: {<AI95-00335-01AI95-00335-01>} For the stream
+          attributes of a type declared immediately within a
+          package_specification that has a partial view, the declaration
+          list to consider is the visible part of the package.  Stream
+          attributes that are not available in the same declaration list
+          are not dispatching as there is no guarantee that descendants
+          of the type have available attributes (there is such a
+          guarantee for visibly available attributes).  If we allowed
+          dispatching for any available attribute, then for attributes
+          defined in the private part we could end up executing a
+          nonexistent body.
 
                      _Language Design Principles_
 
@@ -15539,22 +15574,22 @@ dispatching call.]
                           _Static Semantics_
 
 2/3
-{AI95-00260-02AI95-00260-02} {AI95-00416-01AI95-00416-01}
-{AI05-0076-1AI05-0076-1} A call on a dispatching operation is a call
+{<AI95-00260-02AI95-00260-02>} {<AI95-00416-01AI95-00416-01>}
+{<AI05-0076-1AI05-0076-1>} A <call on a dispatching operation> is a call
 whose name or prefix denotes the declaration of a dispatching operation.
-A controlling operand in a call on a dispatching operation of a tagged
-type T is one whose corresponding formal parameter is of type T or is of
-an anonymous access type with designated type T; the corresponding
-formal parameter is called a controlling formal parameter.  If the
-controlling formal parameter is an access parameter, the controlling
-operand is the object designated by the actual parameter, rather than
-the actual parameter itself. If the call is to a (primitive) function
-with result type T (a function with a controlling result), then the call
-has a controlling result -- the context of the call can control the
-dispatching.  Similarly, if the call is to a function with an access
-result type designating T (a function with a controlling access result),
-then the call has a controlling access result, and the context can
-similarly control dispatching.
+A <controlling operand> in a call on a dispatching operation of a tagged
+type <T> is one whose corresponding formal parameter is of type <T> or
+is of an anonymous access type with designated type <T>; the
+corresponding formal parameter is called a <controlling formal
+parameter>.  If the controlling formal parameter is an access parameter,
+the controlling operand is the object designated by the actual
+parameter, rather than the actual parameter itself.  If the call is to a
+(primitive) function with result type <T> (a <function with a
+controlling result>), then the call has a <controlling result> -- the
+context of the call can control the dispatching.  Similarly, if the call
+is to a function with an access result type designating <T> (a <function
+with a controlling access result>), then the call has a <controlling
+access result>, and the context can similarly control dispatching.
 
 2.a
           Ramification: This definition implies that a call through the
@@ -15565,8 +15600,8 @@ similarly control dispatching.
           thing being renamed is irrelevant.
 
 3
-A name or expression of a tagged type is either statically tagged,
-dynamically tagged, or tag indeterminate, according to whether, when
+A name or expression of a tagged type is either <statically> tagged,
+<dynamically> tagged, or <tag indeterminate>, according to whether, when
 used as a controlling operand, the tag that controls dispatching is
 determined statically by the operand's (specific) type, dynamically by
 its tag at run time, or from context.  A qualified_expression or
@@ -15575,10 +15610,10 @@ tagged according to its operand.  For other kinds of 
names and
 expressions, this is determined as follows:
 
 4/2
-   * {AI95-00416-01AI95-00416-01} The name or expression is statically
-     tagged if it is of a specific tagged type and, if it is a call with
-     a controlling result or controlling access result, it has at least
-     one statically tagged controlling operand;
+   * {<AI95-00416-01AI95-00416-01>} The name or expression is
+     <statically tagged> if it is of a specific tagged type and, if it
+     is a call with a controlling result or controlling access result,
+     it has at least one statically tagged controlling operand;
 
 4.a
           Discussion: It is illegal to have both statically tagged and
@@ -15586,20 +15621,20 @@ expressions, this is determined as follows:
           see below.
 
 5/2
-   * {AI95-00416-01AI95-00416-01} The name or expression is dynamically
-     tagged if it is of a class-wide type, or it is a call with a
-     controlling result or controlling access result and at least one
-     dynamically tagged controlling operand;
+   * {<AI95-00416-01AI95-00416-01>} The name or expression is
+     <dynamically tagged> if it is of a class-wide type, or it is a call
+     with a controlling result or controlling access result and at least
+     one dynamically tagged controlling operand;
 
 6/2
-   * {AI95-00416-01AI95-00416-01} The name or expression is tag
-     indeterminate if it is a call with a controlling result or
+   * {<AI95-00416-01AI95-00416-01>} The name or expression is <tag
+     indeterminate> if it is a call with a controlling result or
      controlling access result, all of whose controlling operands (if
      any) are tag indeterminate.
 
 7/1
-{8652/00108652/0010} {AI95-00127-01AI95-00127-01} [A type_conversion is
-statically or dynamically tagged according to whether the type
+{<8652/00108652/0010>} {<AI95-00127-01AI95-00127-01>} [A type_conversion
+is statically or dynamically tagged according to whether the type
 determined by the subtype_mark is specific or class-wide, respectively.]
 For an object that is designated by an expression whose expected type is
 an anonymous access-to-specific tagged type, the object is dynamically
@@ -15616,9 +15651,9 @@ respectively.
           indeterminate.
 
 7.a.1/1
-          {8652/00108652/0010} {AI95-00127-01AI95-00127-01} Allocators
-          and access attributes of class-wide types can be used as the
-          controlling parameters of dispatching calls.
+          {<8652/00108652/0010>} {<AI95-00127-01AI95-00127-01>}
+          Allocators and access attributes of class-wide types can be
+          used as the controlling parameters of dispatching calls.
 
                            _Legality Rules_
 
@@ -15633,8 +15668,8 @@ and statically tagged controlling operands.
           statically tagged operand(s).
 
 9/1
-{8652/00108652/0010} {AI95-00127-01AI95-00127-01} If the expected type
-for an expression or name is some specific tagged type, then the
+{<8652/00108652/0010>} {<AI95-00127-01AI95-00127-01>} If the expected
+type for an expression or name is some specific tagged type, then the
 expression or name shall not be dynamically tagged unless it is a
 controlling operand in a call on a dispatching operation.  Similarly, if
 the expected type for an expression is an anonymous access-to-specific
@@ -15649,25 +15684,26 @@ dispatching operation.
           this truncation.
 
 9.b/4
-          Ramification: {AI95-00252-01AI95-00252-01}
-          {AI12-0039-1AI12-0039-1} This rule applies to all expressions
-          or names with a specific expected type, not just those that
-          are actual parameters to a dispatching call.  This rule does
-          not apply to a membership test whose tested_simple_expression
-          is class-wide, since any type that covers the tested type is
-          explicitly allowed.  See *note 4.5.2::.  This rule also
-          doesn't apply to a selected_component whose selector_name is a
-          subprogram, since the rules explicitly say that the prefix may
-          be class-wide (see *note 4.1.3::).
+          Ramification: {<AI95-00252-01AI95-00252-01>}
+          {<AI12-0039-1AI12-0039-1>} This rule applies to all
+          expressions or names with a specific expected type, not just
+          those that are actual parameters to a dispatching call.  This
+          rule does not apply to a membership test whose
+          <tested_>simple_expression is class-wide, since any type that
+          covers the tested type is explicitly allowed.  See *note
+          4.5.2::.  This rule also doesn't apply to a selected_component
+          whose selector_name is a subprogram, since the rules
+          explicitly say that the prefix may be class-wide (see *note
+          4.1.3::).
 
 10/2
-{8652/00118652/0011} {AI95-00117-01AI95-00117-01}
-{AI95-00430-01AI95-00430-01} In the declaration of a dispatching
+{<8652/00118652/0011>} {<AI95-00117-01AI95-00117-01>}
+{<AI95-00430-01AI95-00430-01>} In the declaration of a dispatching
 operation of a tagged type, everywhere a subtype of the tagged type
 appears as a subtype of the profile (see *note 6.1::), it shall
-statically match the first subtype of the tagged type. If the
+statically match the first subtype of the tagged type.  If the
 dispatching operation overrides an inherited subprogram, it shall be
-subtype conformant with the inherited subprogram. The convention of an
+subtype conformant with the inherited subprogram.  The convention of an
 inherited dispatching operation is the convention of the corresponding
 primitive operation of the parent or progenitor type.  The default
 convention of a dispatching operation that overrides an inherited
@@ -15684,11 +15720,11 @@ shall not be of convention Intrinsic.
           that are outside of its first subtype.
 
 11/2
-{AI95-00416-01AI95-00416-01} The default_expression for a controlling
+{<AI95-00416-01AI95-00416-01>} The default_expression for a controlling
 formal parameter of a dispatching operation shall be tag indeterminate.
 
 11.a/2
-          Reason: {AI95-00416-01AI95-00416-01} This rule ensures that
+          Reason: {<AI95-00416-01AI95-00416-01>} This rule ensures that
           the default_expression always produces the "correct" tag when
           called with or without dispatching, or when inherited by a
           descendant.  If it were statically tagged, the default would
@@ -15697,8 +15733,8 @@ formal parameter of a dispatching operation shall be 
tag indeterminate.
           call.
 
 11.1/2
-{AI95-00404-01AI95-00404-01} If a dispatching operation is defined by a
-subprogram_renaming_declaration or the instantiation of a generic
+{<AI95-00404-01AI95-00404-01>} If a dispatching operation is defined by
+a subprogram_renaming_declaration or the instantiation of a generic
 subprogram, any access parameter of the renamed subprogram or the
 generic subprogram that corresponds to a controlling access parameter of
 the dispatching operation, shall have a subtype that excludes null.
@@ -15714,12 +15750,13 @@ distinct tagged types.
           types.
 
 12.a.1/1
-          Ramification: {8652/00988652/0098}
-          {AI95-00183-01AI95-00183-01} This restriction applies even if
-          the partial view (see *note 7.3::) of one or both of the types
-          is untagged.  This follows from the definition of dispatching
-          operation: the operation is a dispatching operation anywhere
-          the full views of the (tagged) types are visible.
+          Ramification: {<8652/00988652/0098>}
+          {<AI95-00183-01AI95-00183-01>} This restriction applies even
+          if the partial view (see *note 7.3::) of one or both of the
+          types is untagged.  This follows from the definition of
+          dispatching operation: the operation is a dispatching
+          operation anywhere the full views of the (tagged) types are
+          visible.
 
 13
 The explicit declaration of a primitive subprogram of a tagged type
@@ -15729,13 +15766,13 @@ values of the type exist, nor after deriving a record 
extension from it,
 nor after a body.]
 
 13.a/2
-          Reason: {AI95-00344-01AI95-00344-01} This rule is needed
+          Reason: {<AI95-00344-01AI95-00344-01>} This rule is needed
           because (1) we don't want people dispatching to things that
           haven't been declared yet, and (2) we want to allow the static
           part of tagged type descriptors to be static (allocated
           statically, and initialized to link-time-known symbols).
           Suppose T2 inherits primitive P from T1, and then overrides P.
-          Suppose P is called before the declaration of the overriding
+          Suppose P is called <before> the declaration of the overriding
           P. What should it dispatch to?  If the answer is the new P,
           we've violated the first principle above.  If the answer is
           the old P, we've violated the second principle.  (A call to
@@ -15743,8 +15780,8 @@ nor after a body.]
           beside the point.)
 
 13.b
-          Note that a call upon a dispatching operation of type T will
-          freeze T.
+          Note that a call upon a dispatching operation of type <T> will
+          freeze <T>.
 
 13.c
           We considered applying this rule to all derived types, for
@@ -15754,7 +15791,7 @@ nor after a body.]
           confusing).
 
 13.d/2
-          Implementation Note: {AI95-00326-01AI95-00326-01} Because of
+          Implementation Note: {<AI95-00326-01AI95-00326-01>} Because of
           this rule, the type descriptor can be created (presumably
           containing linker symbols pointing at the not-yet-compiled
           bodies) at the first freezing point of the type.  It also
@@ -15763,15 +15800,15 @@ nor after a body.]
           subprogram.
 
 13.e/2
-          Ramification: {AI95-00251-01AI95-00251-01} A consequence is
+          Ramification: {<AI95-00251-01AI95-00251-01>} A consequence is
           that for a tagged type declaration in a declarative_part, only
           the last (overriding) primitive subprogram can be declared by
           a subprogram_body.  (Other overridings must be provided by
           subprogram_declarations.)
 
 13.f/3
-          To be honest: {AI05-0222-1AI05-0222-1} This rule applies only
-          to "original" declarations and not to the completion of a
+          To be honest: {<AI05-0222-1AI05-0222-1>} This rule applies
+          only to "original" declarations and not to the completion of a
           primitive subprogram, even though a completion is technically
           an explicit declaration, and it may declare a primitive
           subprogram.
@@ -15779,26 +15816,28 @@ nor after a body.]
                           _Dynamic Semantics_
 
 14
-For the execution of a call on a dispatching operation of a type T, the
-controlling tag value determines which subprogram body is executed.  The
-controlling tag value is defined as follows:
+For the execution of a call on a dispatching operation of a type <T>,
+the <controlling tag value> determines which subprogram body is
+executed.  The controlling tag value is defined as follows:
 
 15
    * If one or more controlling operands are statically tagged, then the
-     controlling tag value is statically determined to be the tag of T.
+     controlling tag value is <statically determined> to be the tag of
+     <T>.
 
 16
    * If one or more controlling operands are dynamically tagged, then
      the controlling tag value is not statically determined, but is
-     rather determined by the tags of the controlling operands. If there
-     is more than one dynamically tagged controlling operand, a check is
-     made that they all have the same tag. If this check fails,
-     Constraint_Error is raised unless the call is a function_call whose
-     name denotes the declaration of an equality operator (predefined or
-     user defined) that returns Boolean, in which case the result of the
-     call is defined to indicate inequality, and no subprogram_body is
-     executed.  This check is performed prior to evaluating any
-     tag-indeterminate controlling operands.
+     rather determined by the tags of the controlling operands.  If
+     there is more than one dynamically tagged controlling operand, a
+     check is made that they all have the same tag.  If this check
+     fails, Constraint_Error is raised unless the call is a
+     function_call whose name denotes the declaration of an equality
+     operator (predefined or user defined) that returns Boolean, in
+     which case the result of the call is defined to indicate
+     inequality, and no subprogram_body is executed.  This check is
+     performed prior to evaluating any tag-indeterminate controlling
+     operands.
 
 16.a
           Reason: Tag mismatch is considered an error (except for "="
@@ -15814,21 +15853,22 @@ controlling tag value is defined as follows:
           Constraint_Error.
 
 17/2
-   * {AI95-00196-01AI95-00196-01} If all of the controlling operands (if
-     any) are tag-indeterminate, then:
+   * {<AI95-00196-01AI95-00196-01>} If all of the controlling operands
+     (if any) are tag-indeterminate, then:
 
 18/2
-             * {AI95-00239-01AI95-00239-01} {AI95-00416-01AI95-00416-01}
-               If the call has a controlling result or controlling
-               access result and is itself, or designates, a (possibly
-               parenthesized or qualified) controlling operand of an
-               enclosing call on a dispatching operation of a descendant
-               of type T, then its controlling tag value is determined
-               by the controlling tag value of this enclosing call;
+             * {<AI95-00239-01AI95-00239-01>}
+               {<AI95-00416-01AI95-00416-01>} If the call has a
+               controlling result or controlling access result and is
+               itself, or designates, a (possibly parenthesized or
+               qualified) controlling operand of an enclosing call on a
+               dispatching operation of a descendant of type <T>, then
+               its controlling tag value is determined by the
+               controlling tag value of this enclosing call;
 
 18.a/2
-          Discussion: {AI95-00239-01AI95-00239-01} For code that a user
-          can write explicitly, the only contexts that can control
+          Discussion: {<AI95-00239-01AI95-00239-01>} For code that a
+          user can write explicitly, the only contexts that can control
           dispatching of a function with a controlling result of type T
           are those that involve controlling operands of the same type
           T: if the two types differ there is an illegality and the
@@ -15847,17 +15887,17 @@ controlling tag value is defined as follows:
           call, so it is guaranteed to always land on a concrete body.
 
 18.1/2
-             * {AI95-00196-01AI95-00196-01} {AI95-00416-01AI95-00416-01}
-               If the call has a controlling result or controlling
-               access result and (possibly parenthesized, qualified, or
-               dereferenced) is the expression of an
-               assignment_statement whose target is of a class-wide
-               type, then its controlling tag value is determined by the
-               target;
+             * {<AI95-00196-01AI95-00196-01>}
+               {<AI95-00416-01AI95-00416-01>} If the call has a
+               controlling result or controlling access result and
+               (possibly parenthesized, qualified, or dereferenced) is
+               the expression of an assignment_statement whose target is
+               of a class-wide type, then its controlling tag value is
+               determined by the target;
 
 19
              * Otherwise, the controlling tag value is statically
-               determined to be the tag of type T.
+               determined to be the tag of type <T>.
 
 19.a
           Ramification: This includes the cases of a tag-indeterminate
@@ -15866,19 +15906,19 @@ controlling tag value is defined as follows:
           object.
 
 20/3
-{AI95-00345-01AI95-00345-01} {AI05-0126-1AI05-0126-1} For the execution
-of a call on a dispatching operation, the action performed is determined
-by the properties of the corresponding dispatching operation of the
-specific type identified by the controlling tag value:
+{<AI95-00345-01AI95-00345-01>} {<AI05-0126-1AI05-0126-1>} For the
+execution of a call on a dispatching operation, the action performed is
+determined by the properties of the corresponding dispatching operation
+of the specific type identified by the controlling tag value:
 
 20.1/3
-   * {AI05-0126-1AI05-0126-1} if the corresponding operation is
+   * {<AI05-0126-1AI05-0126-1>} if the corresponding operation is
      explicitly declared for this type, [even if the declaration occurs
      in a private part], then the action comprises an invocation of the
      explicit body for the operation;
 
 20.2/3
-   * {AI95-00345-01AI95-00345-01} {AI05-0126-1AI05-0126-1} if the
+   * {<AI95-00345-01AI95-00345-01>} {<AI05-0126-1AI05-0126-1>} if the
      corresponding operation is implicitly declared for this type and is
      implemented by an entry or protected subprogram (see *note 9.1::
      and *note 9.4::), then the action comprises a call on this entry or
@@ -15888,14 +15928,14 @@ specific type identified by the controlling tag value:
      actual parameters of the call, if any;
 
 20.3/3
-   * {AI05-0197-1AI05-0197-1} if the corresponding operation is a
+   * {<AI05-0197-1AI05-0197-1>} if the corresponding operation is a
      predefined operator then the action comprises an invocation of that
      operator;
 
 20.4/3
-   * {AI95-00345-01AI95-00345-01} {AI05-0126-1AI05-0126-1}
-     {AI05-0197-1AI05-0197-1} {AI05-0250-1AI05-0250-1}
-     {AI05-0254-1AI05-0254-1} otherwise, the action is the same as the
+   * {<AI95-00345-01AI95-00345-01>} {<AI05-0126-1AI05-0126-1>}
+     {<AI05-0197-1AI05-0197-1>} {<AI05-0250-1AI05-0250-1>}
+     {<AI05-0254-1AI05-0254-1>} otherwise, the action is the same as the
      action for the corresponding operation of the parent type or
      progenitor type from which the operation was inherited except that
      additional invariant checks (see *note 7.3.2::) and class-wide
@@ -15905,29 +15945,29 @@ specific type identified by the controlling tag value:
      action is that of an arbitrary one of the operations.
 
 20.a/3
-          This paragraph was deleted.{AI05-0126-1AI05-0126-1}
+          <This paragraph was deleted.>{<AI05-0126-1AI05-0126-1>}
 
 20.a.1/3
-          Ramification: {AI05-0005-1AI05-0005-1}
-          {AI05-0126-1AI05-0126-1} "Corresponding dispatching operation"
-          refers to the inheritance relationship between subprograms.
-          Primitive operations are always inherited for a type T, but
-          they might not be declared if the primitive operation is never
-          visible within the immediate scope of the type T. If no
-          corresponding operation is declared, the last bullet is used
-          and the corresponding operation of the parent type is executed
-          (an explicit body that happens to have the same name and
-          profile is not called in that case).
+          Ramification: {<AI05-0005-1AI05-0005-1>}
+          {<AI05-0126-1AI05-0126-1>} "Corresponding dispatching
+          operation" refers to the inheritance relationship between
+          subprograms.  Primitive operations are always inherited for a
+          type T, but they might not be declared if the primitive
+          operation is never visible within the immediate scope of the
+          type T. If no corresponding operation is declared, the last
+          bullet is used and the corresponding operation of the parent
+          type is executed (an explicit body that happens to have the
+          same name and profile is not called in that case).
 
 20.a.2/3
-          {AI05-0005-1AI05-0005-1} {AI05-0126-1AI05-0126-1} We have to
-          talk about progenitors in the last bullet in case the
+          {<AI05-0005-1AI05-0005-1>} {<AI05-0126-1AI05-0126-1>} We have
+          to talk about progenitors in the last bullet in case the
           corresponding operation is a null procedure inherited from an
           interface.  In that case, the parent type might not even have
           the operation in question.
 
 20.a.3/3
-          {AI05-0197-1AI05-0197-1} For the last bullet, if there are
+          {<AI05-0197-1AI05-0197-1>} For the last bullet, if there are
           multiple corresponding operations for the parent and
           progenitors, all but one of them have to be a null procedure.
           (If the progenitors declared abstract routines, there would
@@ -15936,13 +15976,13 @@ specific type identified by the controlling tag value:
           one exists.
 
 20.a.4/3
-          {AI05-0126-1AI05-0126-1} Any explicit declaration for an
+          {<AI05-0126-1AI05-0126-1>} Any explicit declaration for an
           inherited corresponding operation has to be an overriding
           routine.  These rules mean that a dispatching call executes
           the overriding routine (if any) for the specific type.
 
 20.b/3
-          Reason: {AI05-0005-1AI05-0005-1} The wording of the above
+          Reason: {<AI05-0005-1AI05-0005-1>} The wording of the above
           rules is intended to ensure that the same body is executed for
           a given tag, whether that tag is determined statically or
           dynamically.  For a type declared in a package, it doesn't
@@ -15972,10 +16012,10 @@ specific type identified by the controlling tag value:
                    X : P2.T2;
                    Y : P1.T1'Class := X;
                begin
-                   P2.Op_A(Param => X); -- Nondispatching call to a 
dispatching operation.
-                   P1.Op_A(Arg => Y); -- Dispatching call.
-                   P2.Op_B(Arg => X); -- Nondispatching call to a dispatching 
operation.
-                   P1.Op_B(Arg => Y); -- Dispatching call.
+                   P2.Op_A(Param => X); --< Nondispatching call to a 
dispatching operation.>
+                   P1.Op_A(Arg => Y); --< Dispatching call.>
+                   P2.Op_B(Arg => X); --< Nondispatching call to a dispatching 
operation.>
+                   P1.Op_B(Arg => Y); --< Dispatching call.>
                end Main;
 
 20.f
@@ -15996,8 +16036,8 @@ specific type identified by the controlling tag value:
           call.
 
 20.h
-          Implementation Note: Even when a tag is not statically
-          determined, a compiler might still be able to figure it out
+          Implementation Note: Even when a tag is not <statically
+          determined>, a compiler might still be able to figure it out
           and thereby avoid the overhead of run-time dispatching.
 
      NOTES
@@ -16010,7 +16050,7 @@ specific type identified by the controlling tag value:
      call.
 
 22/2
-     79  {AI95-00260-02AI95-00260-02} This subclause covers calls on
+     79  {<AI95-00260-02AI95-00260-02>} This subclause covers calls on
      dispatching subprograms of a tagged type.  Rules for tagged type
      membership tests are described in *note 4.5.2::.  Controlling tag
      determination for an assignment_statement is described in *note
@@ -16035,7 +16075,7 @@ specific type identified by the controlling tag value:
                     _Incompatibilities With Ada 95_
 
 24.b/2
-          {AI95-00404-01AI95-00404-01} If a dispatching operation is
+          {<AI95-00404-01AI95-00404-01>} If a dispatching operation is
           defined by a subprogram_renaming_declaration, and it has a
           controlling access parameter, Ada 2005 requires the subtype of
           the parameter to exclude null.  The same applies to
@@ -16052,53 +16092,53 @@ specific type identified by the controlling tag value:
                         _Extensions to Ada 95_
 
 24.c/2
-          {AI95-00416-01AI95-00416-01} Functions that have an access
+          {<AI95-00416-01AI95-00416-01>} Functions that have an access
           result type can be dispatching in the same way as a function
           that returns a tagged object directly.
 
                      _Wording Changes from Ada 95_
 
 24.d/3
-          {8652/00108652/0010} {AI95-00127-01AI95-00127-01}
-          {AI05-0299-1AI05-0299-1} Corrigendum: Allocators and access
+          {<8652/00108652/0010>} {<AI95-00127-01AI95-00127-01>}
+          {<AI05-0299-1AI05-0299-1>} Corrigendum: Allocators and access
           attributes of objects of class-wide types can be used as the
           controlling parameter in a dispatching calls.  This was an
           oversight in the definition of Ada 95.  (See *note 3.10.2::
           and *note 4.8::).
 
 24.e/2
-          {8652/00118652/0011} {AI95-00117-01AI95-00117-01}
-          {AI95-00430-01AI95-00430-01} Corrigendum: Corrected the
+          {<8652/00118652/0011>} {<AI95-00117-01AI95-00117-01>}
+          {<AI95-00430-01AI95-00430-01>} Corrigendum: Corrected the
           conventions of dispatching operations.  This is extended in
           Ada 2005 to cover operations inherited from progenitors, and
           to ensure that the conventions of all inherited operations are
           the same.
 
 24.f/2
-          {AI95-00196-01AI95-00196-01} Clarified the wording to ensure
+          {<AI95-00196-01AI95-00196-01>} Clarified the wording to ensure
           that functions with no controlling operands are
           tag-indeterminate, and to describe that the controlling tag
           can come from the target of an assignment_statement.
 
 24.g/2
-          {AI95-00239-01AI95-00239-01} Fixed the wording to cover
+          {<AI95-00239-01AI95-00239-01>} Fixed the wording to cover
           default expressions inherited by derived subprograms.  A
           literal reading of the old wording would have implied that
           operations would be called with objects of the wrong type.
 
 24.h/2
-          {AI95-00260-02AI95-00260-02} An abstract formal subprogram is
-          a dispatching operation, even though it is not a primitive
+          {<AI95-00260-02AI95-00260-02>} An abstract formal subprogram
+          is a dispatching operation, even though it is not a primitive
           operation.  See *note 12.6::, "*note 12.6:: Formal
           Subprograms".
 
 24.i/2
-          {AI95-00345-01AI95-00345-01} Dispatching calls include
+          {<AI95-00345-01AI95-00345-01>} Dispatching calls include
           operations implemented by entries and protected operations, so
           we have to update the wording to reflect that.
 
 24.j/2
-          {AI95-00335-01AI95-00335-01} A stream attribute of a tagged
+          {<AI95-00335-01AI95-00335-01>} A stream attribute of a tagged
           type is usually a dispatching operation, even though it is not
           a primitive operation.  If they weren't dispatching,
           T'Class'Input and T'Class'Output wouldn't work.
@@ -16106,14 +16146,15 @@ specific type identified by the controlling tag value:
                     _Wording Changes from Ada 2005_
 
 24.k/3
-          {AI05-0076-1AI05-0076-1} Correction: Defined "function with a
-          controlling result", as it is used in *note 3.9.3::.
+          {<AI05-0076-1AI05-0076-1>} Correction: Defined "function with
+          a controlling result", as it is used in *note 3.9.3::.
 
 24.l/3
-          {AI05-0126-1AI05-0126-1} {AI05-0197-1AI05-0197-1} Correction:
-          Corrected holes in the definition of dynamic dispatching: the
-          behavior for operations that are never declared and/or
-          inherited from a progenitor were not specified.
+          {<AI05-0126-1AI05-0126-1>} {<AI05-0197-1AI05-0197-1>}
+          Correction: Corrected holes in the definition of dynamic
+          dispatching: the behavior for operations that are never
+          declared and/or inherited from a progenitor were not
+          specified.
 
 
 File: aarm2012.info,  Node: 3.9.3,  Next: 3.9.4,  Prev: 3.9.2,  Up: 3.9
@@ -16122,10 +16163,10 @@ File: aarm2012.info,  Node: 3.9.3,  Next: 3.9.4,  
Prev: 3.9.2,  Up: 3.9
 ------------------------------------
 
 1/2
-{AI95-00345-01AI95-00345-01} [ An abstract type is a tagged type
+{<AI95-00345-01AI95-00345-01>} [ An <abstract type> is a tagged type
 intended for use as an ancestor of other types, but which is not allowed
-to have objects of its own. An abstract subprogram is a subprogram that
-has no body, but is intended to be overridden at some point when
+to have objects of its own.  An <abstract subprogram> is a subprogram
+that has no body, but is intended to be overridden at some point when
 inherited.  Because objects of an abstract type cannot be created, a
 dispatching call to an abstract subprogram always dispatches to some
 overriding body.]
@@ -16138,7 +16179,7 @@ overriding body.]
                      _Language Design Principles_
 
 1.a/3
-          {AI05-0299-1AI05-0299-1} An abstract subprogram has no body,
+          {<AI05-0299-1AI05-0299-1>} An abstract subprogram has no body,
           so the rules in this subclause are designed to ensure (at
           compile time) that the body will never be invoked.  We do so
           primarily by disallowing the creation of values of the
@@ -16152,8 +16193,8 @@ overriding body.]
                                _Syntax_
 
 1.1/3
-     {AI95-00218-03AI95-00218-03} {AI95-00348-01AI95-00348-01}
-     {AI05-0183-1AI05-0183-1} abstract_subprogram_declaration ::=
+     {<AI95-00218-03AI95-00218-03>} {<AI95-00348-01AI95-00348-01>}
+     {<AI05-0183-1AI05-0183-1>} abstract_subprogram_declaration ::=
          [overriding_indicator]
          subprogram_specification is abstract
              [aspect_specification];
@@ -16161,7 +16202,7 @@ overriding body.]
                           _Static Semantics_
 
 1.2/2
-{AI95-00345-01AI95-00345-01} Interface types (see *note 3.9.4::) are
+{<AI95-00345-01AI95-00345-01>} Interface types (see *note 3.9.4::) are
 abstract types.  In addition, a tagged type that has the reserved word
 abstract in its declaration is an abstract type.  The class-wide type
 (see *note 3.4.1::) rooted at an abstract type is not itself an abstract
@@ -16170,8 +16211,8 @@ type.
                            _Legality Rules_
 
 2/2
-{AI95-00345-01AI95-00345-01} Only a tagged type shall have the reserved
-word abstract in its declaration.
+{<AI95-00345-01AI95-00345-01>} Only a tagged type shall have the
+reserved word abstract in its declaration.
 
 2.a
           Ramification: Untagged types are never abstract, even though
@@ -16188,11 +16229,11 @@ word abstract in its declaration.
           will necessarily be different from T'Tag.
 
 3/2
-{AI95-00260-02AI95-00260-02} {AI95-00348-01AI95-00348-01} A subprogram
-declared by an abstract_subprogram_declaration (*note 3.9.3: S0076.) or
-a formal_abstract_subprogram_declaration (*note 12.6: S0298.) (see *note
-12.6::) is an abstract subprogram.  If it is a primitive subprogram of a
-tagged type, then the tagged type shall be abstract.
+{<AI95-00260-02AI95-00260-02>} {<AI95-00348-01AI95-00348-01>} A
+subprogram declared by an abstract_subprogram_declaration (*note 3.9.3:
+S0076.) or a formal_abstract_subprogram_declaration (*note 12.6: S0298.)
+(see *note 12.6::) is an <abstract subprogram>.  If it is a primitive
+subprogram of a tagged type, then the tagged type shall be abstract.
 
 3.a
           Ramification: Note that for a private type, this applies to
@@ -16201,24 +16242,24 @@ tagged type, then the tagged type shall be abstract.
 3.b
                package P is
                    type T is abstract tagged private;
-                   function Foo (X : T) return Boolean is abstract; -- Illegal!
+                   function Foo (X : T) return Boolean is abstract; --< 
Illegal!>
                private
-                   type T is tagged null record; -- Illegal!
+                   type T is tagged null record; --< Illegal!>
                    X : T;
                    Y : Boolean := Foo (T'Class (X));
                end P;
 
 3.c
           The full view of T is not abstract, but has an abstract
-          operation Foo, which is illegal.  The two lines marked "--
-          Illegal!"  are illegal when taken together.
+          operation Foo, which is illegal.  The two lines marked "--<
+          Illegal!>" are illegal when taken together.
 
 3.d/2
-          Reason: {AI95-00310-01AI95-00310-01} We considered disallowing
-          untagged types from having abstract primitive subprograms.
-          However, we rejected that plan, because it introduced some
-          silly anomalies, and because such subprograms are harmless.
-          For example:
+          Reason: {<AI95-00310-01AI95-00310-01>} We considered
+          disallowing untagged types from having abstract primitive
+          subprograms.  However, we rejected that plan, because it
+          introduced some silly anomalies, and because such subprograms
+          are harmless.  For example:
 
 3.e/1
                package P is
@@ -16228,7 +16269,7 @@ tagged type, then the tagged type shall be abstract.
                  . . .
                package Q is
                   type My_Field_Size is new Field_Size;
-                  -- implicit declaration of Print(X : T; F : My_Field_Size := 
0) is abstract;
+                  --< implicit declaration of Print(X : T; F : My_Field_Size 
:= 0) is abstract;>
                end Q;
 
 3.f
@@ -16239,27 +16280,27 @@ tagged type, then the tagged type shall be abstract.
           but the current ones seem like the simplest.
 
 3.g/2
-          {AI95-00310-01AI95-00310-01} In Ada 2005, abstract primitive
+          {<AI95-00310-01AI95-00310-01>} In Ada 2005, abstract primitive
           subprograms of an untagged type may be used to "undefine" an
           operation.
 
 3.h/2
-          Ramification: {AI95-00260-02AI95-00260-02} Note that the
+          Ramification: {<AI95-00260-02AI95-00260-02>} Note that the
           second sentence does not apply to abstract formal subprograms,
           as they are never primitive operations of a type.
 
 4/3
-{AI95-00251-01AI95-00251-01} {AI95-00334-01AI95-00334-01}
-{AI95-00391-01AI95-00391-01} {AI05-0097-1AI05-0097-1}
-{AI05-0198-1AI05-0198-1} If a type has an implicitly declared primitive
-subprogram that is inherited or is a predefined operator, and the
-corresponding primitive subprogram of the parent or ancestor type is
+{<AI95-00251-01AI95-00251-01>} {<AI95-00334-01AI95-00334-01>}
+{<AI95-00391-01AI95-00391-01>} {<AI05-0097-1AI05-0097-1>}
+{<AI05-0198-1AI05-0198-1>} If a type has an implicitly declared
+primitive subprogram that is inherited or is a predefined operator, and
+the corresponding primitive subprogram of the parent or ancestor type is
 abstract or is a function with a controlling access result, or if a type
 other than a nonabstract null extension inherits a function with a
 controlling result, then:
 
 4.a/3
-          Ramification: {AI05-0068-1AI05-0068-1} These rules apply to
+          Ramification: {<AI05-0068-1AI05-0068-1>} These rules apply to
           each view of the type individually.  That is necessary to
           preserve privacy.  For instance, in the following example:
 
@@ -16273,7 +16314,7 @@ controlling result, then:
                with P;
                package Q is
                   type T is abstract new P.I with private;
-                  -- Op inherited here.
+                  -- <Op inherited here.>
                private
                   type T is abstract new P.I with null record;
                   procedure Op (X : T) is null;
@@ -16283,7 +16324,7 @@ controlling result, then:
                with Q;
                package R is
                   type T2 is new Q.T with null record;
-                  -- Illegal. Op inherited here, but requires overriding.
+                  -- <Illegal. Op inherited here, but requires overriding.>
                end R;
 
 4.e/3
@@ -16302,29 +16343,29 @@ controlling result, then:
           been legal.
 
 5/2
-   * {AI95-00251-01AI95-00251-01} {AI95-00334-01AI95-00334-01} If the
-     type is abstract or untagged, the implicitly declared subprogram is
-     abstract.
+   * {<AI95-00251-01AI95-00251-01>} {<AI95-00334-01AI95-00334-01>} If
+     the type is abstract or untagged, the implicitly declared
+     subprogram is <abstract>.
 
 5.a
           Ramification: Note that it is possible to override a concrete
           subprogram with an abstract one.
 
 6/4
-   * {AI95-00391-01AI95-00391-01} {AI12-0080-1AI12-0080-1} Otherwise,
-     the subprogram shall be overridden with a nonabstract subprogram
-     or, in the case of a private extension inheriting a nonabstract
-     function with a controlling result, have a full type that is a null
-     extension[; for a type declared in the visible part of a package,
-     the overriding may be either in the visible or the private part].
-     Such a subprogram is said to require overriding.  However, if the
-     type is a generic formal type, the subprogram need not be
-     overridden for the formal type itself; [a nonabstract version will
-     necessarily be provided by the actual type.]
+   * {<AI95-00391-01AI95-00391-01>} {<AI12-0080-1AI12-0080-1>}
+     Otherwise, the subprogram shall be overridden with a nonabstract
+     subprogram or, in the case of a private extension inheriting a
+     nonabstract function with a controlling result, have a full type
+     that is a null extension[; for a type declared in the visible part
+     of a package, the overriding may be either in the visible or the
+     private part].  Such a subprogram is said to <require overriding>.
+     However, if the type is a generic formal type, the subprogram need
+     not be overridden for the formal type itself; [a nonabstract
+     version will necessarily be provided by the actual type.]
 
 6.a/2
-          Reason: {AI95-00228-01AI95-00228-01}
-          {AI95-00391-01AI95-00391-01} A function that returns the
+          Reason: {<AI95-00228-01AI95-00228-01>}
+          {<AI95-00391-01AI95-00391-01>} A function that returns the
           parent type requires overriding for a type extension (or
           becomes abstract for an abstract type) because conversion from
           a parent type to a type extension is not defined, and function
@@ -16347,8 +16388,8 @@ controlling result, then:
                with Pack1; use Pack1;
                package Pack2 is
                    type T1 is new Ancestor with record ...;
-                       -- A concrete type.
-                   procedure Do_Something(X : in T1); -- Have to override.
+                       --< A concrete type.>
+                   procedure Do_Something(X : in T1); --< Have to override.>
                end Pack2;
 
 6.e
@@ -16356,16 +16397,16 @@ controlling result, then:
                with Pack2; use Pack2;
                package Pack3 is
                    type T2 is new Ancestor with private;
-                       -- A concrete type.
+                       --< A concrete type.>
                private
-                   type T2 is new T1 with -- Parent different from ancestor.
+                   type T2 is new T1 with --< Parent different from ancestor.>
                      record ... end record;
-                   -- Here, we inherit Pack2.Do_Something.
+                   --< Here, we inherit Pack2.Do_Something.>
                end Pack3;
-                   
+    
 
 6.f/2
-          {AI95-00228-01AI95-00228-01} T2 inherits an abstract
+          {<AI95-00228-01AI95-00228-01>} T2 inherits an abstract
           Do_Something, but T2 is not abstract, so Do_Something has to
           be overridden.  However, it is OK to override it in the
           private part.  In this case, we override it by inheriting a
@@ -16375,15 +16416,15 @@ controlling result, then:
           necessarily overridden somewhere.
 
 6.g/2
-          {AI95-00391-01AI95-00391-01} For a null extension, the result
-          of a function with a controlling result is defined in terms of
-          an extension_aggregate with a null record extension part (see
-          *note 3.4::).  This means that these restrictions on functions
-          with a controlling result do not have to apply to null
-          extensions.
+          {<AI95-00391-01AI95-00391-01>} For a null extension, the
+          result of a function with a controlling result is defined in
+          terms of an extension_aggregate with a null record extension
+          part (see *note 3.4::).  This means that these restrictions on
+          functions with a controlling result do not have to apply to
+          null extensions.
 
 6.h/2
-          {AI95-00391-01AI95-00391-01} However, functions with
+          {<AI95-00391-01AI95-00391-01>} However, functions with
           controlling access results still require overriding.  Changing
           the tag in place might clobber a preexisting object, and
           allocating new memory would possibly change the pool of the
@@ -16398,14 +16439,14 @@ A call on an abstract subprogram shall be a 
dispatching call;
 [nondispatching calls to an abstract subprogram are not allowed.]
 
 7.a/2
-          Ramification: {AI95-00310-01AI95-00310-01} If an abstract
+          Ramification: {<AI95-00310-01AI95-00310-01>} If an abstract
           subprogram is not a dispatching operation of some tagged type,
           then it cannot be called at all.  In Ada 2005, such
           subprograms are not even considered by name resolution (see
           *note 6.4::).
 
 8/3
-{AI05-0073-1AI05-0073-1} {AI05-0203-1AI05-0203-1} The type of an
+{<AI05-0073-1AI05-0073-1>} {<AI05-0203-1AI05-0203-1>} The type of an
 aggregate, or of an object created by an object_declaration or an
 allocator, or a generic formal object of mode in, shall not be abstract.
 The type of the target of an assignment operation (see *note 5.2::)
@@ -16430,10 +16471,10 @@ result type designating an abstract type.
           terribly useful.
 
 8.c/3
-          {AI05-0073-1AI05-0073-1} Generic functions returning a formal
-          abstract type are illegal because any instance would have to
-          be instantiated with a nonabstract type in order to avoid
-          violating the function rule (generic functions cannot be
+          {<AI05-0073-1AI05-0073-1>} Generic functions returning a
+          formal abstract type are illegal because any instance would
+          have to be instantiated with a nonabstract type in order to
+          avoid violating the function rule (generic functions cannot be
           declared abstract).  But that would be an implied contract; it
           would be better for the contract to be explicit by the formal
           type not being declared abstract.  Moreover, the implied
@@ -16458,7 +16499,7 @@ corresponding primitive subprogram of the actual shall 
not be abstract.
           dispatching operations.
 
 9.c/2
-          To be honest: {AI95-00294-01AI95-00294-01} In the sentence
+          To be honest: {<AI95-00294-01AI95-00294-01>} In the sentence
           about primitive subprograms above, there is some ambiguity as
           to what is meant by "corresponding" in the case where an
           inherited operation is overridden.  This is best explained by
@@ -16468,24 +16509,24 @@ corresponding primitive subprogram of the actual 
shall not be abstract.
 9.d/2
                package P1 is
                   type T1 is abstract tagged null record;
-                  procedure P (X : T1); -- (1)
+                  procedure P (X : T1); -- <(1)>
                end P1;
 
 9.e/2
                package P2 is
                   type T2 is abstract new P1.T1 with null record;
-                  -- procedure P (X : T2); -- (2)
+                  -- <procedure P (X : T2); -- (2)>
                   procedure P (X : T2) is abstract; -- (3)
                end P2;
 
 9.f/2
                generic
                   type D is abstract new P1.T1 with private;
-                  -- procedure P (X : D); -- (4)
+                  -- <procedure P (X : D); -- (4)>
                procedure G (X : D);
 
 9.g/2
-               procedure I is new G (P2.T2); -- Illegal.
+               procedure I is new G (P2.T2); -- <Illegal.>
 
 9.h/2
           Type T2 inherits a nonabstract procedure P (2) from the
@@ -16497,7 +16538,7 @@ corresponding primitive subprogram of the actual shall 
not be abstract.
           does not "reemerge".  Therefore, the instantiation is illegal.
 
 10/3
-{AI05-0073-1AI05-0073-1} For an abstract type declared in a visible
+{<AI05-0073-1AI05-0073-1>} For an abstract type declared in a visible
 part, an abstract primitive subprogram shall not be declared in the
 private part, unless it is overriding an abstract subprogram implicitly
 declared in the visible part.  For a tagged type declared in a visible
@@ -16534,9 +16575,9 @@ overriding a function implicitly declared in the 
visible part.
           T1 and T2, the example would be legal as is.
 
 11/2
-{AI95-00260-02AI95-00260-02} A generic actual subprogram shall not be an
-abstract subprogram unless the generic formal subprogram is declared by
-a formal_abstract_subprogram_declaration.  The prefix of an
+{<AI95-00260-02AI95-00260-02>} A generic actual subprogram shall not be
+an abstract subprogram unless the generic formal subprogram is declared
+by a formal_abstract_subprogram_declaration.  The prefix of an
 attribute_reference for the Access, Unchecked_Access, or Address
 attributes shall not denote an abstract subprogram.
 
@@ -16548,7 +16589,7 @@ attributes shall not denote an abstract subprogram.
           subprogram.
 
 11.b/2
-          {AI95-00260-02AI95-00260-02} The part about generic actual
+          {<AI95-00260-02AI95-00260-02>} The part about generic actual
           subprograms includes those given by default.  Of course, an
           abstract formal subprogram's actual subprogram can be
           abstract.
@@ -16556,7 +16597,7 @@ attributes shall not denote an abstract subprogram.
                           _Dynamic Semantics_
 
 11.1/2
-{AI95-00348-01AI95-00348-01} The elaboration of an
+{<AI95-00348-01AI95-00348-01>} The elaboration of an
 abstract_subprogram_declaration has no effect.
 
      NOTES
@@ -16581,7 +16622,7 @@ abstract_subprogram_declaration has no effect.
                               _Examples_
 
 14
-Example of an abstract type representing a set of natural numbers:
+<Example of an abstract type representing a set of natural numbers:>
 
 15
      package Sets is
@@ -16598,8 +16639,8 @@ Example of an abstract type representing a set of 
natural numbers:
      NOTES
 
 16
-     84  Notes on the example: Given the above abstract type, one could
-     then derive various (nonabstract) extensions of the type,
+     84  <Notes on the example:> Given the above abstract type, one
+     could then derive various (nonabstract) extensions of the type,
      representing alternative implementations of a set.  One might use a
      bit vector, but impose an upper bound on the largest element
      representable, while another might use a hash table, trading off
@@ -16636,7 +16677,7 @@ Example of an abstract type representing a set of 
natural numbers:
                         _Extensions to Ada 95_
 
 16.d/2
-          {AI95-00391-01AI95-00391-01} It is not necessary to override
+          {<AI95-00391-01AI95-00391-01>} It is not necessary to override
           functions with a controlling result for a null extension.
           This makes it easier to derive a tagged type to complete a
           private type.
@@ -16644,58 +16685,58 @@ Example of an abstract type representing a set of 
natural numbers:
                      _Wording Changes from Ada 95_
 
 16.e/2
-          {AI95-00251-01AI95-00251-01} {AI95-00345-01AI95-00345-01}
+          {<AI95-00251-01AI95-00251-01>} {<AI95-00345-01AI95-00345-01>}
           Updated the wording to reflect the addition of interface types
           (see *note 3.9.4::).
 
 16.f/2
-          {AI95-00260-02AI95-00260-02} Updated the wording to reflect
+          {<AI95-00260-02AI95-00260-02>} Updated the wording to reflect
           the addition of abstract formal subprograms (see *note
           12.6::).
 
 16.g/2
-          {AI95-00334-01AI95-00334-01} The wording of
+          {<AI95-00334-01AI95-00334-01>} The wording of
           shall-be-overridden was clarified so that it clearly applies
           to abstract predefined equality.
 
 16.h/2
-          {AI95-00348-01AI95-00348-01} Moved the syntax and elaboration
-          rule for abstract_subprogram_declaration here, so the syntax
-          and most of the semantics are together (which is consistent
-          with null procedures).
+          {<AI95-00348-01AI95-00348-01>} Moved the syntax and
+          elaboration rule for abstract_subprogram_declaration here, so
+          the syntax and most of the semantics are together (which is
+          consistent with null procedures).
 
 16.i/2
-          {AI95-00391-01AI95-00391-01} We define the term require
-          overriding to make other wording easier to understand.
+          {<AI95-00391-01AI95-00391-01>} We define the term <require
+          overriding> to make other wording easier to understand.
 
                    _Incompatibilities With Ada 2005_
 
 16.j/3
-          {AI05-0073-1AI05-0073-1} Correction: Added rules to eliminate
-          holes with controlling access results and generic functions
-          that return abstract types.  While these changes are
+          {<AI05-0073-1AI05-0073-1>} Correction: Added rules to
+          eliminate holes with controlling access results and generic
+          functions that return abstract types.  While these changes are
           technically incompatible, it is unlikely that they could be
           used in a program without violating some other rule of the use
           of abstract types.
 
 16.k/3
-          {AI05-0097-1AI05-0097-1} Correction: Corrected a minor glitch
-          having to do with abstract null extensions.  The Ada 2005 rule
-          allowed such extensions to inherit concrete operations in some
-          rare cases.  It is unlikely that these cases exist in user
-          code.
+          {<AI05-0097-1AI05-0097-1>} Correction: Corrected a minor
+          glitch having to do with abstract null extensions.  The Ada
+          2005 rule allowed such extensions to inherit concrete
+          operations in some rare cases.  It is unlikely that these
+          cases exist in user code.
 
                        _Extensions to Ada 2005_
 
 16.l/3
-          {AI05-0183-1AI05-0183-1} An optional aspect_specification can
-          be used in an abstract_subprogram_declaration.  This is
+          {<AI05-0183-1AI05-0183-1>} An optional aspect_specification
+          can be used in an abstract_subprogram_declaration.  This is
           described in *note 13.1.1::.
 
                     _Wording Changes from Ada 2005_
 
 16.m/3
-          {AI05-0198-1AI05-0198-1} Correction: Clarified that the
+          {<AI05-0198-1AI05-0198-1>} Correction: Clarified that the
           predefined operator corresponding to an inherited abstract
           operator is also abstract.  The Ada 2005 rules caused the
           predefined operator and the inherited operator to override
@@ -16703,10 +16744,10 @@ Example of an abstract type representing a set of 
natural numbers:
           way (the operator is not considered for resolution).
 
 16.n/3
-          {AI05-0203-1AI05-0203-1} Correction: Added wording to disallow
-          abstract return objects.  These were illegal in Ada 2005 by
-          other rules; the extension to support class-wide type better
-          opened a hole which has now been plugged.
+          {<AI05-0203-1AI05-0203-1>} Correction: Added wording to
+          disallow abstract return objects.  These were illegal in Ada
+          2005 by other rules; the extension to support class-wide type
+          better opened a hole which has now been plugged.
 
 
 File: aarm2012.info,  Node: 3.9.4,  Prev: 3.9.3,  Up: 3.9
@@ -16715,10 +16756,10 @@ File: aarm2012.info,  Node: 3.9.4,  Prev: 3.9.3,  Up: 
3.9
 ---------------------
 
 1/2
-{AI95-00251-01AI95-00251-01} {AI95-00345-01AI95-00345-01} [An interface
-type is an abstract tagged type that provides a restricted form of
-multiple inheritance.  A tagged type, task type, or protected type may
-have one or more interface types as ancestors.]
+{<AI95-00251-01AI95-00251-01>} {<AI95-00345-01AI95-00345-01>} [An
+interface type is an abstract tagged type that provides a restricted
+form of multiple inheritance.  A tagged type, task type, or protected
+type may have one or more interface types as ancestors.]
 
 1.a/2
           Glossary entry: An interface type is a form of abstract tagged
@@ -16731,9 +16772,9 @@ have one or more interface types as ancestors.]
                      _Language Design Principles_
 
 1.b/2
-          {AI95-00251-01AI95-00251-01} {AI95-00345-01AI95-00345-01} The
-          rules are designed so that an interface can be used as either
-          a parent type or a progenitor type without changing the
+          {<AI95-00251-01AI95-00251-01>} {<AI95-00345-01AI95-00345-01>}
+          The rules are designed so that an interface can be used as
+          either a parent type or a progenitor type without changing the
           meaning.  That's important so that the order that interfaces
           are specified in a derived_type_definition is not significant.
           In particular, we want:
@@ -16748,28 +16789,28 @@ have one or more interface types as ancestors.]
                                _Syntax_
 
 2/2
-     {AI95-00251-01AI95-00251-01} {AI95-00345-01AI95-00345-01}
+     {<AI95-00251-01AI95-00251-01>} {<AI95-00345-01AI95-00345-01>}
      interface_type_definition ::=
          [limited | task | protected | synchronized] interface [and 
      interface_list]
 
 3/2
-     {AI95-00251-01AI95-00251-01} {AI95-00419-01AI95-00419-01}
-     interface_list ::= interface_subtype_mark {and interface_
+     {<AI95-00251-01AI95-00251-01>} {<AI95-00419-01AI95-00419-01>}
+     interface_list ::= <interface_>subtype_mark {and <interface_>
      subtype_mark}
 
                           _Static Semantics_
 
 4/2
-{AI95-00251-01AI95-00251-01} An interface type (also called an
-interface) is a specific abstract tagged type that is defined by an
+{<AI95-00251-01AI95-00251-01>} An interface type (also called an
+<interface>) is a specific abstract tagged type that is defined by an
 interface_type_definition.
 
 5/2
-{AI95-00345-01AI95-00345-01} An interface with the reserved word
+{<AI95-00345-01AI95-00345-01>} An interface with the reserved word
 limited, task, protected, or synchronized in its definition is termed,
-respectively, a limited interface, a task interface, a protected
-interface, or a synchronized interface.  In addition, all task and
+respectively, a <limited interface>, a <task interface>, a <protected
+interface>, or a <synchronized interface>.  In addition, all task and
 protected interfaces are synchronized interfaces, and all synchronized
 interfaces are limited interfaces.
 
@@ -16781,9 +16822,9 @@ interfaces are limited interfaces.
           type.
 
 6/2
-{AI95-00345-01AI95-00345-01} {AI95-00443-01AI95-00443-01} [A task or
+{<AI95-00345-01AI95-00345-01>} {<AI95-00443-01AI95-00443-01>} [A task or
 protected type derived from an interface is a tagged type.]  Such a
-tagged type is called a synchronized tagged type, as are synchronized
+tagged type is called a <synchronized> tagged type, as are synchronized
 interfaces and private extensions whose declaration includes the
 reserved word synchronized.
 
@@ -16797,18 +16838,19 @@ reserved word synchronized.
           task type (including a task interface type) is a task type,
           because "task" is one of the language-defined classes of types
           (see *note 3.2::).  However, the class-wide type associated
-          with an interface is not an interface type, as "interface" is
-          not one of the language-defined classes (as it is not closed
-          under derivation).  In this sense, "interface" is similar to
-          "abstract".  The class-wide type associated with an interface
-          is a concrete (nonabstract) indefinite tagged composite type.
+          with an interface is <not> an interface type, as "interface"
+          is <not> one of the language-defined classes (as it is not
+          closed under derivation).  In this sense, "interface" is
+          similar to "abstract".  The class-wide type associated with an
+          interface is a concrete (nonabstract) indefinite tagged
+          composite type.
 
 6.c/2
           "Private extension" includes generic formal private
           extensions, as explained in *note 12.5.1::.
 
 7/2
-{AI95-00345-01AI95-00345-01} A task interface is an [abstract] task
+{<AI95-00345-01AI95-00345-01>} A task interface is an [abstract] task
 type.  A protected interface is an [abstract] protected type.
 
 7.a/2
@@ -16823,16 +16865,16 @@ type.  A protected interface is an [abstract] 
protected type.
           interfaces for consistency.
 
 8/2
-{AI95-00251-01AI95-00251-01} [An interface type has no components.]
+{<AI95-00251-01AI95-00251-01>} [An interface type has no components.]
 
 8.a/2
           Proof: This follows from the syntax and the fact that
           discriminants are not allowed for interface types.
 
 9/2
-{AI95-00419-01AI95-00419-01} An interface_subtype_mark in an
-interface_list names a progenitor subtype; its type is the progenitor
-type.  An interface type inherits user-defined primitive subprograms
+{<AI95-00419-01AI95-00419-01>} An <interface_>subtype_mark in an
+interface_list names a <progenitor subtype>; its type is the <progenitor
+type>.  An interface type inherits user-defined primitive subprograms
 from each progenitor type in the same way that a derived type inherits
 user-defined primitive subprograms from its progenitor types (see *note
 3.4::).
@@ -16847,32 +16889,32 @@ user-defined primitive subprograms from its 
progenitor types (see *note
                            _Legality Rules_
 
 10/2
-{AI95-00251-01AI95-00251-01} All user-defined primitive subprograms of
+{<AI95-00251-01AI95-00251-01>} All user-defined primitive subprograms of
 an interface type shall be abstract subprograms or null procedures.
 
 11/2
-{AI95-00251-01AI95-00251-01} The type of a subtype named in an
+{<AI95-00251-01AI95-00251-01>} The type of a subtype named in an
 interface_list shall be an interface type.
 
 12/2
-{AI95-00251-01AI95-00251-01} {AI95-00345-01AI95-00345-01} A type derived
-from a nonlimited interface shall be nonlimited.
+{<AI95-00251-01AI95-00251-01>} {<AI95-00345-01AI95-00345-01>} A type
+derived from a nonlimited interface shall be nonlimited.
 
 13/2
-{AI95-00345-01AI95-00345-01} An interface derived from a task interface
-shall include the reserved word task in its definition; any other type
-derived from a task interface shall be a private extension or a task
-type declared by a task declaration (see *note 9.1::).
+{<AI95-00345-01AI95-00345-01>} An interface derived from a task
+interface shall include the reserved word task in its definition; any
+other type derived from a task interface shall be a private extension or
+a task type declared by a task declaration (see *note 9.1::).
 
 14/2
-{AI95-00345-01AI95-00345-01} An interface derived from a protected
+{<AI95-00345-01AI95-00345-01>} An interface derived from a protected
 interface shall include the reserved word protected in its definition;
 any other type derived from a protected interface shall be a private
 extension or a protected type declared by a protected declaration (see
 *note 9.4::).
 
 15/2
-{AI95-00345-01AI95-00345-01} An interface derived from a synchronized
+{<AI95-00345-01AI95-00345-01>} An interface derived from a synchronized
 interface shall include one of the reserved words task, protected, or
 synchronized in its definition; any other type derived from a
 synchronized interface shall be a private extension, a task type
@@ -16895,7 +16937,7 @@ protected declaration.
           the kind of the formal interface (see *note 12.5.5::).
 
 16/2
-{AI95-00345-01AI95-00345-01} No type shall be derived from both a task
+{<AI95-00345-01AI95-00345-01>} No type shall be derived from both a task
 interface and a protected interface.
 
 16.a
@@ -16907,12 +16949,12 @@ interface and a protected interface.
           early detection of the errors.
 
 17/2
-{AI95-00251-01AI95-00251-01} In addition to the places where Legality
+{<AI95-00251-01AI95-00251-01>} In addition to the places where Legality
 Rules normally apply (see *note 12.3::), these rules apply also in the
 private part of an instance of a generic unit.
 
 17.a/3
-          Ramification: {AI05-0299-1AI05-0299-1} This paragraph is
+          Ramification: {<AI05-0299-1AI05-0299-1>} This paragraph is
           intended to apply to all of the Legality Rules in this
           subclause.  We cannot allow interface types which do not obey
           these rules, anywhere.  Luckily, deriving from a formal type
@@ -16923,9 +16965,9 @@ private part of an instance of a generic unit.
                           _Dynamic Semantics_
 
 18/3
-{AI95-00251-01AI95-00251-01} {AI05-0070-1AI05-0070-1} The elaboration of
-an interface_type_definition creates the interface type and its first
-subtype.
+{<AI95-00251-01AI95-00251-01>} {<AI05-0070-1AI05-0070-1>} The
+elaboration of an interface_type_definition creates the interface type
+and its first subtype.
 
 18.a/3
           Discussion: There is no other effect.  An interface_list is
@@ -16936,7 +16978,7 @@ subtype.
      NOTES
 
 19/2
-     85  {AI95-00411-01AI95-00411-01} Nonlimited interface types have
+     85  {<AI95-00411-01AI95-00411-01>} Nonlimited interface types have
      predefined nonabstract equality operators.  These may be overridden
      with user-defined abstract equality operators.  Such operators will
      then require an explicit overriding for any nonabstract descendant
@@ -16945,8 +16987,8 @@ subtype.
                               _Examples_
 
 20/2
-{AI95-00433-01AI95-00433-01} Example of a limited interface and a
-synchronized interface extending it:
+{<AI95-00433-01AI95-00433-01>} <Example of a limited interface and a
+synchronized interface extending it:>
 
 21/2
      type Queue is limited interface;
@@ -16955,15 +16997,15 @@ synchronized interface extending it:
                             Person : out Person_Name) is abstract;
      function Cur_Count(Q : in Queue) return Natural is abstract;
      function Max_Count(Q : in Queue) return Natural is abstract;
-     -- See *note 3.10.1:: for Person_Name.
+     -- <See *note 3.10.1:: for Person_Name.>
 
 22/3
-     {AI05-0004-1AI05-0004-1} Queue_Error : exception;
-     -- Append raises Queue_Error if Cur_Count(Q) = Max_Count(Q)
-     -- Remove_First raises Queue_Error if Cur_Count(Q) = 0
+     {<AI05-0004-1AI05-0004-1>} Queue_Error : exception;
+     --< Append raises Queue_Error if Cur_Count(Q) = Max_Count(Q)>
+     --< Remove_First raises Queue_Error if Cur_Count(Q) = 0>
 
 23/2
-     type Synchronized_Queue is synchronized interface and Queue; -- see *note 
9.11::
+     type Synchronized_Queue is synchronized interface and Queue; --< see 
*note 9.11::>
      procedure Append_Wait(Q      : in out Synchronized_Queue;
                            Person : in Person_Name) is abstract;
      procedure Remove_First_Wait(Q      : in out Synchronized_Queue;
@@ -17004,10 +17046,10 @@ This synchronized interface may only be implemented 
by a task or
 protected type, and as such ensures safe concurrent access.
 
 28/2
-{AI95-00433-01AI95-00433-01} Example use of the interface:
+{<AI95-00433-01AI95-00433-01>} <Example use of the interface:>
 
 29/3
-     {AI05-0004-1AI05-0004-1} type Fast_Food_Queue is new Queue with record 
...;
+     {<AI05-0004-1AI05-0004-1>} type Fast_Food_Queue is new Queue with record 
...;
      procedure Append(Q : in out Fast_Food_Queue; Person : in Person_Name);
      procedure Remove_First(Q : in out Fast_Food_Queue; Person : out 
Person_Name);
      function Cur_Count(Q : in Fast_Food_Queue) return Natural;
@@ -17021,9 +17063,9 @@ protected type, and as such ensures safe concurrent 
access.
 
 32/2
      ...
-     -- Add George (see *note 3.10.1::) to the cashier's queue:
+     -- <Add George (see *note 3.10.1::) to the cashier's queue:>
      Append (Cashier, George);
-     -- After payment, move George to the sandwich counter queue:
+     -- <After payment, move George to the sandwich counter queue:>
      Transfer (Cashier, Counter);
      ...
 
@@ -17036,10 +17078,10 @@ must be provided.  Inside the call of Transfer, calls 
will dispatch to
 the implementations of Append and Remove_First for type Fast_Food_Queue.
 
 34/2
-{AI95-00433-01AI95-00433-01} Example of a task interface:
+{<AI95-00433-01AI95-00433-01>} <Example of a task interface:>
 
 35/2
-     type Serial_Device is task interface;  -- see *note 9.1::
+     type Serial_Device is task interface;  --< see *note 9.1::>
      procedure Read (Dev : in Serial_Device; C : out Character) is abstract;
      procedure Write(Dev : in Serial_Device; C : in  Character) is abstract;
 
@@ -17050,7 +17092,7 @@ intended to be implemented by task entries (see 9.1).
                         _Extensions to Ada 95_
 
 36.a/2
-          {AI95-00251-01AI95-00251-01} {AI95-00345-01AI95-00345-01}
+          {<AI95-00251-01AI95-00251-01>} {<AI95-00345-01AI95-00345-01>}
           Interface types are new.  They provide multiple inheritance of
           interfaces, similar to the facility provided in Java and other
           recent language designs.
@@ -17058,9 +17100,9 @@ intended to be implemented by task entries (see 9.1).
                     _Wording Changes from Ada 2005_
 
 36.b/3
-          {AI05-0070-1AI05-0070-1} Correction: Corrected the definition
-          of elaboration for an interface_type_definition to match that
-          of other type definitions.
+          {<AI05-0070-1AI05-0070-1>} Correction: Corrected the
+          definition of elaboration for an interface_type_definition to
+          match that of other type definitions.
 
 
 File: aarm2012.info,  Node: 3.10,  Next: 3.11,  Prev: 3.9,  Up: 3
@@ -17069,22 +17111,22 @@ File: aarm2012.info,  Node: 3.10,  Next: 3.11,  Prev: 
3.9,  Up: 3
 =================
 
 1
-A value of an access type (an access value) provides indirect access to
-the object or subprogram it designates.  Depending on its type, an
+A value of an access type (an <access value>) provides indirect access
+to the object or subprogram it <designates>.  Depending on its type, an
 access value can designate either subprograms, objects created by
-allocators (see *note 4.8::), or more generally aliased objects of an
-appropriate type. 
+allocators (see *note 4.8::), or more generally <aliased> objects of an
+appropriate type.  
 
 1.a
-          Discussion: A name denotes an entity; an access value
-          designates an entity.  The "dereference" of an access value X,
-          written "X.all", is a name that denotes the entity designated
-          by X.
+          Discussion: A name <denotes> an entity; an access value
+          <designates> an entity.  The "dereference" of an access value
+          X, written "X.all", is a name that denotes the entity
+          designated by X.
 
                      _Language Design Principles_
 
 1.b/3
-          {AI05-0299-1AI05-0299-1} Access values should always be well
+          {<AI05-0299-1AI05-0299-1>} Access values should always be well
           defined (barring uses of certain unchecked features of Clause
           *note 13::).  In particular, uninitialized access variables
           should be prevented by compile-time rules.
@@ -17092,7 +17134,7 @@ appropriate type.
                                _Syntax_
 
 2/2
-     {AI95-00231-01AI95-00231-01} access_type_definition ::=
+     {<AI95-00231-01AI95-00231-01>} access_type_definition ::=
          [null_exclusion] access_to_object_definition
        | [null_exclusion] access_to_subprogram_definition
 
@@ -17109,11 +17151,11 @@ appropriate type.
        | access [protected] function  parameter_and_result_profile
 
 5.1/2
-     {AI95-00231-01AI95-00231-01} null_exclusion ::= not null
+     {<AI95-00231-01AI95-00231-01>} null_exclusion ::= not null
 
 6/2
-     {AI95-00231-01AI95-00231-01} {AI95-00254-01AI95-00254-01}
-     {AI95-00404-01AI95-00404-01} access_definition ::=
+     {<AI95-00231-01AI95-00231-01>} {<AI95-00254-01AI95-00254-01>}
+     {<AI95-00404-01AI95-00404-01>} access_definition ::=
          [null_exclusion] access [constant] subtype_mark
        | [null_exclusion] access [protected] procedure parameter_profile
        | [null_exclusion] access [protected] function 
@@ -17122,23 +17164,23 @@ appropriate type.
                           _Static Semantics_
 
 7/1
-{8652/00128652/0012} {AI95-00062-01AI95-00062-01} There are two kinds of
-access types, access-to-object types, whose values designate objects,
-and access-to-subprogram types, whose values designate subprograms.
-Associated with an access-to-object type is a storage pool; several
-access types may share the same storage pool.  All descendants of an
-access type share the same storage pool. A storage pool is an area of
-storage used to hold dynamically allocated objects (called pool
-elements) created by allocators[; storage pools are described further in
-*note 13.11::, "*note 13.11:: Storage Management"].
+{<8652/00128652/0012>} {<AI95-00062-01AI95-00062-01>} There are two
+kinds of access types, <access-to-object> types, whose values designate
+objects, and <access-to-subprogram> types, whose values designate
+subprograms.  Associated with an access-to-object type is a <storage
+pool>; several access types may share the same storage pool.  All
+descendants of an access type share the same storage pool.  A storage
+pool is an area of storage used to hold dynamically allocated objects
+(called <pool elements>) created by allocators[; storage pools are
+described further in *note 13.11::, "*note 13.11:: Storage Management"].
 
 8
-Access-to-object types are further subdivided into pool-specific access
-types, whose values can designate only the elements of their associated
-storage pool, and general access types, whose values can designate the
-elements of any storage pool, as well as aliased objects created by
-declarations rather than allocators, and aliased subcomponents of other
-objects.
+Access-to-object types are further subdivided into <pool-specific>
+access types, whose values can designate only the elements of their
+associated storage pool, and <general> access types, whose values can
+designate the elements of any storage pool, as well as aliased objects
+created by declarations rather than allocators, and aliased
+subcomponents of other objects.
 
 8.a
           Implementation Note: The value of an access type will
@@ -17148,19 +17190,20 @@ objects.
           to the elements of that pool.
 
 9/3
-{AI95-00225-01AI95-00225-01} {AI95-00363-01AI95-00363-01}
-{AI05-0053-1AI05-0053-1} {AI05-0142-4AI05-0142-4}
-{AI05-0277-1AI05-0277-1} A view of an object is defined to be aliased if
-it is defined by an object_declaration (*note 3.3.1: S0032.),
-component_definition (*note 3.6: S0056.), parameter_specification (*note
-6.1: S0175.), or extended_return_object_declaration with the reserved
-word aliased, or by a renaming of an aliased view.  In addition, the
-dereference of an access-to-object value denotes an aliased view, as
-does a view conversion (see *note 4.6::) of an aliased view.  The
-current instance of an immutably limited type (see *note 7.5::) is
-defined to be aliased.  Finally, a formal parameter or generic formal
-object of a tagged type is defined to be aliased.  [Aliased views are
-the ones that can be designated by an access value.]
+{<AI95-00225-01AI95-00225-01>} {<AI95-00363-01AI95-00363-01>}
+{<AI05-0053-1AI05-0053-1>} {<AI05-0142-4AI05-0142-4>}
+{<AI05-0277-1AI05-0277-1>} A view of an object is defined to be
+<aliased> if it is defined by an object_declaration (*note 3.3.1:
+S0032.), component_definition (*note 3.6: S0056.),
+parameter_specification (*note 6.1: S0175.), or
+extended_return_object_declaration with the reserved word aliased, or by
+a renaming of an aliased view.  In addition, the dereference of an
+access-to-object value denotes an aliased view, as does a view
+conversion (see *note 4.6::) of an aliased view.  The current instance
+of an immutably limited type (see *note 7.5::) is defined to be aliased.
+Finally, a formal parameter or generic formal object of a tagged type is
+defined to be aliased.  [Aliased views are the ones that can be
+designated by an access value.]
 
 9.a
           Glossary entry: An aliased view of an object is one that can
@@ -17187,8 +17230,8 @@ the ones that can be designated by an access value.]
           discussion.
 
 9.f/2
-          Reason: {AI95-00225-01AI95-00225-01} The current instance of a
-          limited type is defined to be aliased so that an access
+          Reason: {<AI95-00225-01AI95-00225-01>} The current instance of
+          a limited type is defined to be aliased so that an access
           discriminant of a component can be initialized with T'Access
           inside the definition of T. Note that we don't want this to
           apply to a type that could become nonlimited later within its
@@ -17218,12 +17261,12 @@ the ones that can be designated by an access value.]
                type T2 is new T1 with ...;
                procedure P(X : access T2) is
                begin
-                   P(T1(X.all)'Access);  -- hand off to T1's P
-                   . . .     -- now do extra T2-specific processing
+                   P(T1(X.all)'Access);  --< hand off to T1's P>
+                   . . .     --< now do extra T2-specific processing>
                end P;
 
 9.k/2
-          This paragraph was deleted.{AI95-00363-01AI95-00363-01}
+          <This paragraph was deleted.>{<AI95-00363-01AI95-00363-01>}
 
 9.l/2
           We considered making more kinds of objects aliased by default.
@@ -17250,20 +17293,20 @@ the ones that can be designated by an access value.]
 10
 An access_to_object_definition defines an access-to-object type and its
 first subtype; the subtype_indication (*note 3.2.2: S0027.) defines the
-designated subtype of the access type.  If a general_access_modifier
+<designated subtype> of the access type.  If a general_access_modifier
 (*note 3.10: S0081.) appears, then the access type is a general access
-type. If the modifier is the reserved word constant, then the type is an
-access-to-constant type[; a designated object cannot be updated through
-a value of such a type]. If the modifier is the reserved word all, then
-the type is an access-to-variable type[; a designated object can be both
-read and updated through a value of such a type].  If no
+type.  If the modifier is the reserved word constant, then the type is
+an <access-to-constant type>[; a designated object cannot be updated
+through a value of such a type].  If the modifier is the reserved word
+all, then the type is an <access-to-variable type>[; a designated object
+can be both read and updated through a value of such a type].  If no
 general_access_modifier (*note 3.10: S0081.) appears in the
 access_to_object_definition (*note 3.10: S0080.), the access type is a
 pool-specific access-to-variable type.
 
 10.a
           To be honest: The type of the designated subtype is called the
-          designated type.
+          <designated type>.
 
 10.b
           Reason: The modifier all was picked to suggest that values of
@@ -17300,27 +17343,27 @@ pool-specific access-to-variable type.
 11
 An access_to_subprogram_definition defines an access-to-subprogram type
 and its first subtype; the parameter_profile or
-parameter_and_result_profile defines the designated profile of the
-access type. There is a calling convention associated with the
+parameter_and_result_profile defines the <designated profile> of the
+access type.  There is a <calling convention> associated with the
 designated profile[; only subprograms with this calling convention can
 be designated by values of the access type.]  By default, the calling
-convention is "protected" if the reserved word protected appears, and
+convention is "<protected>" if the reserved word protected appears, and
 "Ada" otherwise.  [See *note Annex B:: for how to override this
 default.]
 
 11.a
-          Ramification: The calling convention protected is in italics
+          Ramification: The calling convention <protected> is in italics
           to emphasize that it cannot be specified explicitly by the
           user.  This is a consequence of it being a reserved word.
 
 11.b/2
-          Implementation Note: {AI95-00254-01AI95-00254-01} For a named
-          access-to-subprogram type, the representation of an access
-          value might include implementation-defined information needed
-          to support up-level references -- for example, a static link.
-          The accessibility rules (see *note 3.10.2::) ensure that in a
-          "global-display-based" implementation model (as opposed to a
-          static-link-based model), a named
+          Implementation Note: {<AI95-00254-01AI95-00254-01>} For a
+          named access-to-subprogram type, the representation of an
+          access value might include implementation-defined information
+          needed to support up-level references -- for example, a static
+          link.  The accessibility rules (see *note 3.10.2::) ensure
+          that in a "global-display-based" implementation model (as
+          opposed to a static-link-based model), a named
           access-to-(unprotected)-subprogram value need consist only of
           the address of the subprogram.  The global display is
           guaranteed to be properly set up any time the designated
@@ -17374,30 +17417,30 @@ default.]
           descriptor, by indexing off the "known" register.
 
 11.f/2
-          This paragraph was deleted.{AI95-00344-01AI95-00344-01}
+          <This paragraph was deleted.>{<AI95-00344-01AI95-00344-01>}
 
 11.g/2
-          {AI95-00254-01AI95-00254-01} Note that access parameters of an
-          anonymous access-to-subprogram type are permitted.  Such
+          {<AI95-00254-01AI95-00254-01>} Note that access parameters of
+          an anonymous access-to-subprogram type are permitted.  Such
           parameters represent full "downward" closures, meaning that in
           an implementation that uses a per-task (global) display, the
           display will have to be passed as a hidden parameter, and
           reconstructed at the point of call.
 
 12/3
-{AI95-00230-01AI95-00230-01} {AI95-00231-01AI95-00231-01}
-{AI95-00254-01AI95-00254-01} {AI05-0264-1AI05-0264-1} An
+{<AI95-00230-01AI95-00230-01>} {<AI95-00231-01AI95-00231-01>}
+{<AI95-00254-01AI95-00254-01>} {<AI05-0264-1AI05-0264-1>} An
 access_definition defines an anonymous general access type or an
 anonymous access-to-subprogram type.  For a general access type, the
-subtype_mark denotes its designated subtype; if the
+subtype_mark denotes its <designated subtype>; if the
 general_access_modifier (*note 3.10: S0081.) constant appears, the type
 is an access-to-constant type; otherwise, it is an access-to-variable
 type.  For an access-to-subprogram type, the parameter_profile (*note
 6.1: S0172.) or parameter_and_result_profile (*note 6.1: S0173.) denotes
-its designated profile.
+its <designated profile>.
 
 13/2
-{AI95-00230-01AI95-00230-01} {AI95-00231-01AI95-00231-01} For each
+{<AI95-00230-01AI95-00230-01>} {<AI95-00231-01AI95-00231-01>} For each
 access type, there is a null access value designating no entity at all,
 which can be obtained by (implicitly) converting the literal null to the
 access type.  [The null value of an access type is the default initial
@@ -17411,16 +17454,16 @@ evaluating an attribute_reference for the Access 
attribute of a
 nonintrinsic subprogram.
 
 13.a/2
-          This paragraph was deleted.{AI95-00231-01AI95-00231-01}
+          <This paragraph was deleted.>{<AI95-00231-01AI95-00231-01>}
 
 13.b/2
-          This paragraph was deleted.{AI95-00231-01AI95-00231-01}
+          <This paragraph was deleted.>{<AI95-00231-01AI95-00231-01>}
 
 13.1/2
-{AI95-00231-01AI95-00231-01} A null_exclusion in a construct specifies
+{<AI95-00231-01AI95-00231-01>} A null_exclusion in a construct specifies
 that the null value does not belong to the access subtype defined by the
-construct, that is, the access subtype excludes null.  In addition, the
-anonymous access subtype defined by the access_definition for a
+construct, that is, the access subtype <excludes null>.  In addition,
+the anonymous access subtype defined by the access_definition for a
 controlling access parameter (see *note 3.9.2::) excludes null.
 Finally, for a subtype_indication without a null_exclusion, the subtype
 denoted by the subtype_indication excludes null if and only if the
@@ -17428,28 +17471,29 @@ subtype denoted by the subtype_mark in the 
subtype_indication excludes
 null.
 
 13.c/2
-          Reason: {AI95-00231-01AI95-00231-01} An access_definition used
-          in a controlling parameter excludes null because it is
+          Reason: {<AI95-00231-01AI95-00231-01>} An access_definition
+          used in a controlling parameter excludes null because it is
           necessary to read the tag to dispatch, and null has no tag.
           We would have preferred to require not null to be specified
           for such parameters, but that would have been too incompatible
           with Ada 95 code to require.
 
 13.d/2
-          {AI95-00416-01AI95-00416-01} Note that we considered imposing
-          a similar implicit null exclusion for controlling access
-          results, but chose not to do that, because there is no Ada 95
-          compatibility issue, and there is no automatic null check
-          inherent in the use of a controlling access result.  If a null
-          check is necessary, it is because there is a dereference of
-          the result, or because the value is passed to a parameter
-          whose subtype excludes null.  If there is no dereference of
-          the result, a null return value is perfectly acceptable, and
-          can be a useful indication of a particular status of the call.
+          {<AI95-00416-01AI95-00416-01>} Note that we considered
+          imposing a similar implicit null exclusion for controlling
+          access results, but chose not to do that, because there is no
+          Ada 95 compatibility issue, and there is no automatic null
+          check inherent in the use of a controlling access result.  If
+          a null check is necessary, it is because there is a
+          dereference of the result, or because the value is passed to a
+          parameter whose subtype excludes null.  If there is no
+          dereference of the result, a null return value is perfectly
+          acceptable, and can be a useful indication of a particular
+          status of the call.
 
 14/3
-{8652/00138652/0013} {AI95-00012-01AI95-00012-01}
-{AI05-0264-1AI05-0264-1} [All subtypes of an access-to-subprogram type
+{<8652/00138652/0013>} {<AI95-00012-01AI95-00012-01>}
+{<AI05-0264-1AI05-0264-1>} [All subtypes of an access-to-subprogram type
 are constrained.]  The first subtype of a type defined by an
 access_definition or an access_to_object_definition is unconstrained if
 the designated subtype is an unconstrained array or discriminated
@@ -17467,7 +17511,7 @@ subtype; otherwise, it is constrained.
           subtype_indication with a constraint.
 
 14.b/2
-          Reason: {AI95-00363-01AI95-00363-01} Only
+          Reason: {<AI95-00363-01AI95-00363-01>} Only
           composite_constraints are permitted for an access type, and
           only on access-to-composite types.  A constraint on an
           access-to-scalar or access-to-access type might be violated
@@ -17487,7 +17531,7 @@ subtype; otherwise, it is constrained.
                            _Legality Rules_
 
 14.1/2
-{AI95-00231-01AI95-00231-01} If a subtype_indication (*note 3.2.2:
+{<AI95-00231-01AI95-00231-01>} If a subtype_indication (*note 3.2.2:
 S0027.), discriminant_specification (*note 3.7: S0062.),
 parameter_specification (*note 6.1: S0175.),
 parameter_and_result_profile (*note 6.1: S0173.),
@@ -17497,27 +17541,28 @@ formal_object_declaration (*note 12.4: S0280.) has a 
null_exclusion
 construct shall denote an access subtype that does not exclude null.
 
 14.c/2
-          To be honest: {AI95-00231-01AI95-00231-01} This means
+          To be honest: {<AI95-00231-01AI95-00231-01>} This means
           "directly allowed in"; we are not talking about a
           null_exclusion that occurs in an access_definition in one of
           these constructs (for an access_definition, the subtype_mark
           in such an access_definition is not restricted).
 
 14.d/2
-          Reason: {AI95-00231-01AI95-00231-01} This is similar to doubly
-          constraining a composite subtype, which we also don't allow.
+          Reason: {<AI95-00231-01AI95-00231-01>} This is similar to
+          doubly constraining a composite subtype, which we also don't
+          allow.
 
                           _Dynamic Semantics_
 
 15/2
-{AI95-00231-01AI95-00231-01} A composite_constraint is compatible with
-an unconstrained access subtype if it is compatible with the designated
-subtype.  A null_exclusion is compatible with any access subtype that
-does not exclude null. An access value satisfies a composite_constraint
-of an access subtype if it equals the null value of its type or if it
-designates an object whose value satisfies the constraint.  An access
-value satisfies an exclusion of the null value if it does not equal the
-null value of its type.
+{<AI95-00231-01AI95-00231-01>} A composite_constraint is <compatible>
+with an unconstrained access subtype if it is compatible with the
+designated subtype.  A null_exclusion is compatible with any access
+subtype that does not exclude null.  An access value <satisfies> a
+composite_constraint of an access subtype if it equals the null value of
+its type or if it designates an object whose value satisfies the
+constraint.  An access value satisfies an exclusion of the null value if
+it does not equal the null value of its type.
 
 16
 The elaboration of an access_type_definition creates the access type and
@@ -17526,7 +17571,7 @@ includes the elaboration of the subtype_indication, 
which creates the
 designated subtype.
 
 17/2
-{AI95-00230-01AI95-00230-01} {AI95-00254-01AI95-00254-01} The
+{<AI95-00230-01AI95-00230-01>} {<AI95-00254-01AI95-00254-01>} The
 elaboration of an access_definition creates an anonymous access type.
 
      NOTES
@@ -17550,22 +17595,22 @@ elaboration of an access_definition creates an 
anonymous access type.
                               _Examples_
 
 21
-Examples of access-to-object types:
+<Examples of access-to-object types:>
 
 22/4
-     {AI95-00433-01AI95-00433-01} {AI12-0056-1AI12-0056-1} type Frame is 
access Matrix;    --  see *note 3.6::
-     type Peripheral_Ref is not null access Peripheral;  --  see *note 3.8.1::
+     {<AI95-00433-01AI95-00433-01>} {<AI12-0056-1AI12-0056-1>} type Frame is 
access Matrix;    --<  see *note 3.6::>
+     type Peripheral_Ref is not null access Peripheral;  --<  see *note 
3.8.1::>
      type Binop_Ptr is access all Binary_Operation'Class;
-                                                -- general 
access-to-class-wide, see *note 3.9.1::
+                                                --< general 
access-to-class-wide, see *note 3.9.1::>
 
 23
-Example of an access subtype:
+<Example of an access subtype:>
 
 24
-     subtype Drum_Ref is Peripheral_Ref(Drum);  --  see *note 3.8.1::
+     subtype Drum_Ref is Peripheral_Ref(Drum);  --<  see *note 3.8.1::>
 
 25
-Example of an access-to-subprogram type:
+<Example of an access-to-subprogram type:>
 
 26
      type Message_Procedure is access procedure (M : in String := "Error!");
@@ -17576,8 +17621,8 @@ Example of an access-to-subprogram type:
      ...
      Give_Message := Other_Procedure'Access;
      ...
-     Give_Message("File not found.");  -- call with parameter (.all is 
optional)
-     Give_Message.all;                 -- call with no parameters
+     Give_Message("File not found.");  --< call with parameter (.all is 
optional)>
+     Give_Message.all;                 --< call with no parameters>
 
                         _Extensions to Ada 83_
 
@@ -17590,7 +17635,7 @@ Example of an access-to-subprogram type:
                      _Wording Changes from Ada 83_
 
 26.b/3
-          {AI05-0190-1AI05-0190-1} We use the term "storage pool" to
+          {<AI05-0190-1AI05-0190-1>} We use the term "storage pool" to
           talk about the data area from which allocation takes place.
           The term "collection" is only used for finalization.
           ("Collection" and "storage pool" are not the same thing
@@ -17600,7 +17645,7 @@ Example of an access-to-subprogram type:
                      _Inconsistencies With Ada 95_
 
 26.c/2
-          {AI95-00231-01AI95-00231-01} Access discriminants and
+          {<AI95-00231-01AI95-00231-01>} Access discriminants and
           noncontrolling access parameters no longer exclude null.  A
           program which passed null to such an access discriminant or
           access parameter and expected it to raise Constraint_Error may
@@ -17610,7 +17655,7 @@ Example of an access-to-subprogram type:
           likely.)
 
 26.d/2
-          {AI95-00363-01AI95-00363-01} Most unconstrained aliased
+          {<AI95-00363-01AI95-00363-01>} Most unconstrained aliased
           objects with defaulted discriminants are no longer constrained
           by their initial values.  This means that a program that
           raised Constraint_Error from an attempt to change the
@@ -17625,7 +17670,7 @@ Example of an access-to-subprogram type:
                     _Incompatibilities With Ada 95_
 
 26.e/2
-          {AI95-00225-01AI95-00225-01} Amendment Correction: The rule
+          {<AI95-00225-01AI95-00225-01>} Amendment Correction: The rule
           defining when a current instance of a limited type is
           considered to be aliased has been tightened to apply only to
           types that cannot become nonlimited.  A program that attempts
@@ -17639,14 +17684,14 @@ Example of an access-to-subprogram type:
                         _Extensions to Ada 95_
 
 26.f/2
-          {AI95-00231-01AI95-00231-01} The null_exclusion is new.  It
+          {<AI95-00231-01AI95-00231-01>} The null_exclusion is new.  It
           can be used in both anonymous and named access type
           definitions.  It is most useful to declare that parameters
           cannot be null, thus eliminating the need for checks on use.
 
 26.g/2
-          {AI95-00231-01AI95-00231-01} {AI95-00254-01AI95-00254-01}
-          {AI95-00404-01AI95-00404-01} The kinds of anonymous access
+          {<AI95-00231-01AI95-00231-01>} {<AI95-00254-01AI95-00254-01>}
+          {<AI95-00404-01AI95-00404-01>} The kinds of anonymous access
           types allowed were increased by adding anonymous
           access-to-constant and anonymous access-to-subprogram types.
           Anonymous access-to-subprogram types used as parameters allow
@@ -17655,26 +17700,26 @@ Example of an access-to-subprogram type:
                      _Wording Changes from Ada 95_
 
 26.h/2
-          {8652/00128652/0012} {AI95-00062-01AI95-00062-01} Corrigendum:
-          Added accidentally-omitted wording that says that a derived
-          access type shares its storage pool with its parent type.
-          This was clearly intended, both because of a note in *note
-          3.4::, and because anything else would have been incompatible
-          with Ada 83.
+          {<8652/00128652/0012>} {<AI95-00062-01AI95-00062-01>}
+          Corrigendum: Added accidentally-omitted wording that says that
+          a derived access type shares its storage pool with its parent
+          type.  This was clearly intended, both because of a note in
+          *note 3.4::, and because anything else would have been
+          incompatible with Ada 83.
 
 26.i/2
-          {8652/00138652/0013} {AI95-00012-01AI95-00012-01} Corrigendum:
-          Fixed typographical errors in the description of when access
-          types are constrained.
+          {<8652/00138652/0013>} {<AI95-00012-01AI95-00012-01>}
+          Corrigendum: Fixed typographical errors in the description of
+          when access types are constrained.
 
 26.j/2
-          {AI95-00230-01AI95-00230-01} The wording was fixed to allow
+          {<AI95-00230-01AI95-00230-01>} The wording was fixed to allow
           allocators and the literal null for anonymous access types.
           The former was clearly intended by Ada 95; see the
           Implementation Advice in *note 13.11::.
 
 26.k/2
-          {AI95-00363-01AI95-00363-01} The rules about aliased objects
+          {<AI95-00363-01AI95-00363-01>} The rules about aliased objects
           being constrained by their initial values now apply only to
           allocated objects, and thus have been moved to *note 4.8::,
           "*note 4.8:: Allocators".
@@ -17682,17 +17727,18 @@ Example of an access-to-subprogram type:
                     _Wording Changes from Ada 2005_
 
 26.l/3
-          {AI05-0053-1AI05-0053-1} {AI05-0277-1AI05-0277-1} Correction:
-          The rule about a current instance being aliased now is worded
-          in terms of immutably limited types.  Wording was also added
-          to make extended return object declarations that have the
-          keyword aliased be considered aliased.  This latter was a
-          significant oversight in Ada 2005 -- technically, the keyword
-          aliased had no effect.  But of course implementations followed
-          the intent, not the letter of the Standard.
+          {<AI05-0053-1AI05-0053-1>} {<AI05-0277-1AI05-0277-1>}
+          Correction: The rule about a current instance being aliased
+          now is worded in terms of immutably limited types.  Wording
+          was also added to make extended return object declarations
+          that have the keyword aliased be considered aliased.  This
+          latter was a significant oversight in Ada 2005 -- technically,
+          the keyword aliased had no effect.  But of course
+          implementations followed the intent, not the letter of the
+          Standard.
 
 26.m/3
-          {AI05-0142-4AI05-0142-4} Explicitly aliased parameters (see
+          {<AI05-0142-4AI05-0142-4>} Explicitly aliased parameters (see
           *note 6.1::) are defined to be aliased.
 
 * Menu:
@@ -17718,49 +17764,49 @@ subsequent full_type_declaration.
                                _Syntax_
 
 2/2
-     {AI95-00326-01AI95-00326-01} incomplete_type_declaration ::= type 
-     defining_identifier [discriminant_part] [is tagged];
+     {<AI95-00326-01AI95-00326-01>} incomplete_type_declaration ::=
+     type defining_identifier [discriminant_part] [is tagged];
 
                           _Static Semantics_
 
 2.1/4
-{AI95-00326-01AI95-00326-01} {AI12-0137-1AI12-0137-1} An
-incomplete_type_declaration declares an incomplete view of a type and
+{<AI95-00326-01AI95-00326-01>} {<AI12-0137-1AI12-0137-1>} An
+incomplete_type_declaration declares an <incomplete view> of a type and
 its first subtype; the first subtype is unconstrained if a
 discriminant_part appears.  If the incomplete_type_declaration (*note
-3.10.1: S0085.) includes the reserved word tagged, it declares a tagged
-incomplete view.  If T denotes a tagged incomplete view, then T'Class
-denotes a tagged incomplete view.  [An incomplete view of a type is a
-limited view of the type (see *note 7.5::).]
+3.10.1: S0085.) includes the reserved word tagged, it declares a <tagged
+incomplete view>.  If <T> denotes a tagged incomplete view, then
+<T>'Class denotes a tagged incomplete view.  [An incomplete view of a
+type is a limited view of the type (see *note 7.5::).]
 
 2.2/2
-{AI95-00326-01AI95-00326-01} Given an access type A whose designated
-type T is an incomplete view, a dereference of a value of type A also
-has this incomplete view except when:
+{<AI95-00326-01AI95-00326-01>} Given an access type <A> whose designated
+type <T> is an incomplete view, a dereference of a value of type <A>
+also has this incomplete view except when:
 
 2.a/3
-          Discussion: {AI05-0208-1AI05-0208-1} Whether the designated
+          Discussion: {<AI05-0208-1AI05-0208-1>} Whether the designated
           type is an incomplete view (and thus whether this set of rules
           applies) is determined by the view of the type at the
           declaration of the access type; it does not change during the
           life of the type.
 
 2.3/2
-   * it occurs within the immediate scope of the completion of T, or
+   * it occurs within the immediate scope of the completion of <T>, or
 
 2.4/3
-   * {AI05-0208-1AI05-0208-1} it occurs within the scope of a
+   * {<AI05-0208-1AI05-0208-1>} it occurs within the scope of a
      nonlimited_with_clause that mentions a library package in whose
-     visible part the completion of T is declared, or
+     visible part the completion of <T> is declared, or
 
 2.5/3
-   * {AI05-0208-1AI05-0208-1} it occurs within the scope of the
-     completion of T and T is an incomplete view declared by an
+   * {<AI05-0208-1AI05-0208-1>} it occurs within the scope of the
+     completion of <T> and <T> is an incomplete view declared by an
      incomplete_type_declaration.
 
 2.6/3
-{AI05-0162-1AI05-0162-1} In these cases, the dereference has the view of
-T visible at the point of the dereference.
+{<AI05-0162-1AI05-0162-1>} In these cases, the dereference has the view
+of <T> visible at the point of the dereference.
 
 2.b/2
           Discussion: We need the "in whose visible part" rule so that
@@ -17780,26 +17826,26 @@ T visible at the point of the dereference.
                end P.C;
 
 2.e/3
-               {AI05-0005-1AI05-0005-1} with P.C;
+               {<AI05-0005-1AI05-0005-1>} with P.C;
                package body P is
-                   -- Ptr.all'Size is not legal here, but we are within the 
scope
-                   -- of a nonlimited_with_clause for P.
+                   -- <Ptr.all'Size is not legal here, but we are within the 
scope>
+                   -- <of a nonlimited_with_clause for P.>
                type T is ...
-                   --  Ptr.all'Size is legal here.
+                   --  <Ptr.all'Size is legal here.>
                end P;
 
 2.7/3
-{AI95-00412-01AI95-00412-01} {AI05-0162-1AI05-0162-1}
-{AI05-0208-1AI05-0208-1} Similarly, if a subtype_mark denotes a
-subtype_declaration defining a subtype of an incomplete view T, the
+{<AI95-00412-01AI95-00412-01>} {<AI05-0162-1AI05-0162-1>}
+{<AI05-0208-1AI05-0208-1>} Similarly, if a subtype_mark denotes a
+subtype_declaration defining a subtype of an incomplete view <T>, the
 subtype_mark denotes an incomplete view except under the same three
-circumstances given above, in which case it denotes the view of T
+circumstances given above, in which case it denotes the view of <T>
 visible at the point of the subtype_mark.
 
                            _Legality Rules_
 
 3/3
-{AI05-0162-1AI05-0162-1} An incomplete_type_declaration (*note 3.10.1:
+{<AI05-0162-1AI05-0162-1>} An incomplete_type_declaration (*note 3.10.1:
 S0085.) requires a completion, which shall be a type_declaration (*note
 3.2.1: S0023.) other than an incomplete_type_declaration (*note 3.10.1:
 S0085.).  [If the incomplete_type_declaration (*note 3.10.1: S0085.)
@@ -17834,7 +17880,7 @@ the corresponding package_body (*note 7.2: S0192.).]
           is allowed.
 
 4/3
-{AI95-00326-01AI95-00326-01} {AI05-0162-1AI05-0162-1} If an
+{<AI95-00326-01AI95-00326-01>} {<AI05-0162-1AI05-0162-1>} If an
 incomplete_type_declaration (*note 3.10.1: S0085.) includes the reserved
 word tagged, then a type_declaration (*note 3.2.1: S0023.) that
 completes it shall declare a tagged type.  If an
@@ -17842,18 +17888,18 @@ incomplete_type_declaration (*note 3.10.1: S0085.) 
has a
 known_discriminant_part (*note 3.7: S0061.), then a type_declaration
 (*note 3.2.1: S0023.) that completes it shall have a fully conforming
 (explicit) known_discriminant_part (*note 3.7: S0061.) (see *note
-6.3.1::). [If an incomplete_type_declaration (*note 3.10.1: S0085.) has
+6.3.1::).  [If an incomplete_type_declaration (*note 3.10.1: S0085.) has
 no discriminant_part (or an unknown_discriminant_part (*note 3.7:
 S0060.)), then a corresponding type_declaration (*note 3.2.1: S0023.) is
 nevertheless allowed to have discriminants, either explicitly, or
 inherited via derivation.]
 
 5/2
-{AI95-00326-01AI95-00326-01} A name that denotes an incomplete view of a
-type may be used as follows:
+{<AI95-00326-01AI95-00326-01>} A name that denotes an incomplete view of
+a type may be used as follows:
 
 6/3
-   * {AI05-0098-1AI05-0098-1} as the subtype_mark in the
+   * {<AI05-0098-1AI05-0098-1>} as the subtype_mark in the
      subtype_indication of an access_to_object_definition (*note 3.10:
      S0080.); [the only form of constraint allowed in this
      subtype_indication is a discriminant_constraint [(a null_exclusion
@@ -17868,13 +17914,14 @@ type may be used as follows:
           AI83-00007.
 
 7/2
-   * {AI95-00326-01AI95-00326-01} {AI95-00412-01AI95-00412-01} as the
-     subtype_mark in the subtype_indication of a subtype_declaration;
-     the subtype_indication (*note 3.2.2: S0027.) shall not have a
-     null_exclusion (*note 3.10: S0083.) or a constraint;
+   * {<AI95-00326-01AI95-00326-01>} {<AI95-00412-01AI95-00412-01>} as
+     the subtype_mark in the subtype_indication of a
+     subtype_declaration; the subtype_indication (*note 3.2.2: S0027.)
+     shall not have a null_exclusion (*note 3.10: S0083.) or a
+     constraint;
 
 8/3
-   * {AI95-00326-01AI95-00326-01} {AI05-0151-1AI05-0151-1} as the
+   * {<AI95-00326-01AI95-00326-01>} {<AI05-0151-1AI05-0151-1>} as the
      subtype_mark in an access_definition for an access-to-object type;
 
 8.a/2
@@ -17884,7 +17931,7 @@ type may be used as follows:
           access_definition.
 
 8.1/3
-   * {AI05-0151-1AI05-0151-1} as the subtype_mark defining the subtype
+   * {<AI05-0151-1AI05-0151-1>} as the subtype_mark defining the subtype
      of a parameter or result in a profile occurring within a
      basic_declaration;
 
@@ -17892,43 +17939,43 @@ type may be used as follows:
           Ramification: But not in the profile for a body or entry.
 
 8.2/3
-   * {AI05-0213-1AI05-0213-1} as a generic actual parameter whose
+   * {<AI05-0213-1AI05-0213-1>} as a generic actual parameter whose
      corresponding generic formal parameter is a formal incomplete type
      (see *note 12.5.1::).
 
 8.3/2
-{AI95-00326-01AI95-00326-01} If such a name denotes a tagged incomplete
-view, it may also be used:
+{<AI95-00326-01AI95-00326-01>} If such a name denotes a tagged
+incomplete view, it may also be used:
 
 8.4/3
-   * {AI95-00326-01AI95-00326-01} {AI05-0151-1AI05-0151-1} as the
+   * {<AI95-00326-01AI95-00326-01>} {<AI05-0151-1AI05-0151-1>} as the
      subtype_mark defining the subtype of a parameter in the profile for
      a subprogram_body, entry_body, or accept_statement;
 
 9/2
-   * {AI95-00326-01AI95-00326-01} as the prefix of an
+   * {<AI95-00326-01AI95-00326-01>} as the prefix of an
      attribute_reference whose attribute_designator (*note 4.1.4:
      S0101.) is Class; such an attribute_reference (*note 4.1.4: S0100.)
      is restricted to the uses allowed here; it denotes a tagged
      incomplete view.
 
 9.a/2
-          This paragraph was deleted.{AI95-00326-01AI95-00326-01}
+          <This paragraph was deleted.>{<AI95-00326-01AI95-00326-01>}
 
 9.1/3
-This paragraph was deleted.{AI95-00326-01AI95-00326-01}
-{AI05-0151-1AI05-0151-1}
+<This paragraph was deleted.>{<AI95-00326-01AI95-00326-01>}
+{<AI05-0151-1AI05-0151-1>}
 
 9.2/3
-   * This paragraph was deleted.{AI95-00326-01AI95-00326-01}
-     {AI05-0098-1AI05-0098-1} {AI05-0151-1AI05-0151-1}
+   * <This paragraph was deleted.>{<AI95-00326-01AI95-00326-01>}
+     {<AI05-0098-1AI05-0098-1>} {<AI05-0151-1AI05-0151-1>}
 
 9.b/3
-          This paragraph was deleted.
+          <This paragraph was deleted.>
 
 9.3/2
-{AI95-00326-01AI95-00326-01} If any of the above uses occurs as part of
-the declaration of a primitive subprogram of the incomplete view, and
+{<AI95-00326-01AI95-00326-01>} If any of the above uses occurs as part
+of the declaration of a primitive subprogram of the incomplete view, and
 the declaration occurs immediately within the private part of a package,
 then the completion of the incomplete view shall also occur immediately
 within the private part; it shall not be deferred to the package body.
@@ -17942,11 +17989,11 @@ within the private part; it shall not be deferred to 
the package body.
           representation of the type.
 
 9.4/2
-{AI95-00326-01AI95-00326-01} No other uses of a name that denotes an
+{<AI95-00326-01AI95-00326-01>} No other uses of a name that denotes an
 incomplete view of a type are allowed.
 
 10/3
-{AI95-00326-01AI95-00326-01} {AI05-0151-1AI05-0151-1} A prefix that
+{<AI95-00326-01AI95-00326-01>} {<AI05-0151-1AI05-0151-1>} A prefix that
 denotes an object shall not be of an incomplete view.  An actual
 parameter in a call shall not be of an untagged incomplete view.  The
 result object of a function call shall not be of an incomplete view.  A
@@ -17963,10 +18010,10 @@ untagged incomplete view, nor a return type that is 
an incomplete view.
 
 10.b/2
           This also disallows prefixes that are directly of an
-          incomplete view.  For instance, a parameter P can be declared
-          of a tagged incomplete type, but we don't want to allow
-          P'Size, P'Alignment, or the like, as representation values
-          aren't known for an incomplete view.
+          incomplete view.  For instance, a parameter <P> can be
+          declared of a tagged incomplete type, but we don't want to
+          allow <P>'Size, <P>'Alignment, or the like, as representation
+          values aren't known for an incomplete view.
 
 10.c/2
           We say "denotes an object" so that prefixes that directly name
@@ -17974,14 +18021,14 @@ untagged incomplete view, nor a return type that is 
an incomplete view.
           such cases, and we certainly don't want to ban Incomp'Class.
 
 10.d/3
-          {AI05-0151-1AI05-0151-1} As subprogram profiles now may
+          {<AI05-0151-1AI05-0151-1>} As subprogram profiles now may
           include any kind of incomplete type, we also disallow passing
           objects of untagged incomplete types in subprogram calls (as
           the parameter passing method is not known as it is for tagged
           types) and disallow returning any sort of incomplete objects
           (since we don't know how big they are).
 
-Paragraph 11 was deleted.
+<Paragraph 11 was deleted.>
 
                           _Dynamic Semantics_
 
@@ -18006,18 +18053,18 @@ The elaboration of an incomplete_type_declaration has 
no effect.
      prior to it in the same declarative_part (see *note 13.14::).
 
 13.1/3
-     90  {AI05-0151-1AI05-0151-1} {AI05-0269-1AI05-0269-1} A name that
-     denotes an object of an incomplete view is defined to be of a
+     90  {<AI05-0151-1AI05-0151-1>} {<AI05-0269-1AI05-0269-1>} A name
+     that denotes an object of an incomplete view is defined to be of a
      limited type.  Hence, the target of an assignment statement cannot
      be of an incomplete view.
 
                               _Examples_
 
 14
-Example of a recursive type:
+<Example of a recursive type:>
 
 15
-     type Cell;  --  incomplete type declaration
+     type Cell;  --<  incomplete type declaration>
      type Link is access Cell;
 
 16
@@ -18033,18 +18080,18 @@ Example of a recursive type:
      Next   : Link  := Head.Succ;
 
 18
-Examples of mutually dependent access types:
+<Examples of mutually dependent access types:>
 
 19/2
-     {AI95-00433-01AI95-00433-01} type Person(<>);    -- incomplete type 
declaration
-     type Car is tagged; -- incomplete type declaration
+     {<AI95-00433-01AI95-00433-01>} type Person(<>);    --< incomplete type 
declaration>
+     type Car is tagged; --< incomplete type declaration>
 
 20/2
-     {AI95-00433-01AI95-00433-01} type Person_Name is access Person;
+     {<AI95-00433-01AI95-00433-01>} type Person_Name is access Person;
      type Car_Name    is access all Car'Class;
 
 21/2
-     {AI95-00433-01AI95-00433-01} type Car is tagged
+     {<AI95-00433-01AI95-00433-01>} type Car is tagged
         record
            Number  : Integer;
            Owner   : Person_Name;
@@ -18064,7 +18111,7 @@ Examples of mutually dependent access types:
         end record;
 
 23
-     My_Car, Your_Car, Next_Car : Car_Name := new Car;  -- see *note 4.8::
+     My_Car, Your_Car, Next_Car : Car_Name := new Car;  --< see *note 4.8::>
      George : Person_Name := new Person(M);
         ...
      George.Vehicle := Your_Car;
@@ -18107,7 +18154,7 @@ Examples of mutually dependent access types:
                end Pack;
 
 23.e
-               package body Pack is -- Could be separately compiled!
+               package body Pack is --< Could be separately compiled!>
                    type Sep is ...;
                    X := new Sep;
                end Pack;
@@ -18115,7 +18162,7 @@ Examples of mutually dependent access types:
 23.f
                pragma Elaborate(Pack);
                private package Pack.Child is
-                   I : Integer := X.all'Size; -- Legal, by AI-00039.
+                   I : Integer := X.all'Size; --< Legal, by AI-00039.>
                end Pack.Child;
 
 23.g
@@ -18130,7 +18177,7 @@ Examples of mutually dependent access types:
                     _Incompatibilities With Ada 95_
 
 23.h/2
-          {AI95-00326-01AI95-00326-01} It is now illegal to use an
+          {<AI95-00326-01AI95-00326-01>} It is now illegal to use an
           incomplete view (type) as the parameter or result of an
           access-to-subprogram type unless the incomplete view is
           completed in the same declaration list as the use.  This was
@@ -18141,7 +18188,7 @@ Examples of mutually dependent access types:
           views.
 
 23.i/2
-          {AI95-00326-01AI95-00326-01} It is now illegal to use an
+          {<AI95-00326-01AI95-00326-01>} It is now illegal to use an
           incomplete view (type) in a primitive subprogram of the type
           unless the incomplete view is completed in the package
           specification.  This was allowed in Ada 95 for incomplete
@@ -18153,22 +18200,22 @@ Examples of mutually dependent access types:
                         _Extensions to Ada 95_
 
 23.j/2
-          {AI95-00326-01AI95-00326-01} Tagged incomplete types are new.
-          They are allowed in parameter declarations as well as the
-          usual places, as tagged types are always by-reference types
-          (and thus there can be no code generation issue).
+          {<AI95-00326-01AI95-00326-01>} Tagged incomplete types are
+          new.  They are allowed in parameter declarations as well as
+          the usual places, as tagged types are always by-reference
+          types (and thus there can be no code generation issue).
 
 23.k/2
-          {AI95-00412-01AI95-00412-01} A subtype_declaration can be used
-          to give a new name to an incomplete view of a type.  This is
-          valuable to give shorter names to entities imported with a
+          {<AI95-00412-01AI95-00412-01>} A subtype_declaration can be
+          used to give a new name to an incomplete view of a type.  This
+          is valuable to give shorter names to entities imported with a
           limited_with_clause.
 
                      _Wording Changes from Ada 95_
 
 23.l/2
-          {AI95-00326-01AI95-00326-01} The description of incomplete
-          types as incomplete views is new.  Ada 95 defined these as
+          {<AI95-00326-01AI95-00326-01>} The description of incomplete
+          types as <incomplete views> is new.  Ada 95 defined these as
           separate types, but neglected to give any rules for matching
           them with other types.  Luckily, implementers did the right
           thing anyway.  This change also makes it easier to describe
@@ -18177,40 +18224,41 @@ Examples of mutually dependent access types:
                        _Extensions to Ada 2005_
 
 23.m/3
-          {AI05-0098-1AI05-0098-1} Correction: Fixed the definition so
+          {<AI05-0098-1AI05-0098-1>} Correction: Fixed the definition so
           that an anonymous access-to-subprogram type can use an
           incomplete view in the same way that a named
           access-to-subprogram type can.
 
 23.n/3
-          {AI05-0151-1AI05-0151-1} Incomplete types now can be used in
+          {<AI05-0151-1AI05-0151-1>} Incomplete types now can be used in
           subprogram declarations.  The type has to be complete before
           any calls or the body is declared.  This reduces the places
           where access types are required for types imported from
           limited views of packages.
 
 23.o/3
-          {AI05-0162-1AI05-0162-1} Incomplete types now can be completed
-          by private types and private extensions.  Since this can
-          already happen for limited views, there is no remaining reason
-          to disallow it for explicitly declared incomplete types.
+          {<AI05-0162-1AI05-0162-1>} Incomplete types now can be
+          completed by private types and private extensions.  Since this
+          can already happen for limited views, there is no remaining
+          reason to disallow it for explicitly declared incomplete
+          types.
 
                     _Wording Changes from Ada 2005_
 
 23.p/3
-          {AI05-0208-1AI05-0208-1} Correction: Changed the rules of uses
-          of dereferences of incomplete views such that it does not
+          {<AI05-0208-1AI05-0208-1>} Correction: Changed the rules of
+          uses of dereferences of incomplete views such that it does not
           introduce an unintentional incompatibility with Ada 83 and Ada
           95.
 
 23.q/3
-          {AI05-0213-1AI05-0213-1} Incomplete types now can be used as
+          {<AI05-0213-1AI05-0213-1>} Incomplete types now can be used as
           actuals to formal incomplete types (see *note 12.5.1::).
 
                     _Wording Changes from Ada 2012_
 
 23.r/4
-          {AI12-0137-1AI12-0137-1} Corrigndum: Changed the wording to
+          {<AI12-0137-1AI12-0137-1>} Corrigndum: Changed the wording to
           clarify that the class-wide type associated with a specific
           tagged type that has an incomplete view is also an incomplete
           view.  While this was previously undefined, an interpretation
@@ -18226,9 +18274,9 @@ File: aarm2012.info,  Node: 3.10.2,  Prev: 3.10.1,  Up: 
3.10
 ---------------------------------
 
 1/3
-{AI05-0299-1AI05-0299-1} [The attribute Access is used to create access
-values designating aliased objects and nonintrinsic subprograms.  The
-"accessibility" rules prevent dangling references (in the absence of
+{<AI05-0299-1AI05-0299-1>} [The attribute Access is used to create
+access values designating aliased objects and nonintrinsic subprograms.
+The "accessibility" rules prevent dangling references (in the absence of
 uses of certain unchecked features -- see Clause *note 13::).]
 
                      _Language Design Principles_
@@ -18250,26 +18298,26 @@ uses of certain unchecked features -- see Clause 
*note 13::).]
                         _Name Resolution Rules_
 
 2/2
-{AI95-00235-01AI95-00235-01} For an attribute_reference with
+{<AI95-00235-01AI95-00235-01>} For an attribute_reference with
 attribute_designator Access (or Unchecked_Access -- see *note 13.10::),
-the expected type shall be a single access type A such that:
+the expected type shall be a single access type <A> such that:
 
 2.1/2
-   * {AI95-00235-01AI95-00235-01} A is an access-to-object type with
-     designated type D and the type of the prefix is D'Class or is
-     covered by D, or
+   * {<AI95-00235-01AI95-00235-01>} <A> is an access-to-object type with
+     designated type <D> and the type of the prefix is <D>'Class or is
+     covered by <D>, or
 
 2.2/2
-   * {AI95-00235-01AI95-00235-01} A is an access-to-subprogram type
+   * {<AI95-00235-01AI95-00235-01>} <A> is an access-to-subprogram type
      whose designated profile is type conformant with that of the
      prefix.
 
 2.3/2
-{AI95-00235-01AI95-00235-01} [The prefix of such an attribute_reference
-is never interpreted as an implicit_dereference or a parameterless
-function_call (see *note 4.1.4::).] The designated type or profile of
-the expected type of the attribute_reference is the expected type or
-profile for the prefix.
+{<AI95-00235-01AI95-00235-01>} [The prefix of such an
+attribute_reference is never interpreted as an implicit_dereference or a
+parameterless function_call (see *note 4.1.4::).]  The designated type
+or profile of the expected type of the attribute_reference is the
+expected type or profile for the prefix.
 
 2.a
           Discussion: Saying that the expected type shall be a "single
@@ -18284,8 +18332,8 @@ profile for the prefix.
           4.1.4::.
 
 2.b/2
-          {AI95-00235-01AI95-00235-01} Saying "single access type" is a
-          bit of a fudge.  Both the context and the prefix may provide
+          {<AI95-00235-01AI95-00235-01>} Saying "single access type" is
+          a bit of a fudge.  Both the context and the prefix may provide
           both multiple types; "single" only means that a single,
           specific interpretation must remain after resolution.  We say
           "single" here to trigger the Legality Rules of *note 8.6::.
@@ -18298,26 +18346,26 @@ profile for the prefix.
                type Float_Ptr is access all Float;
 
 2.d/2
-               function Zap (Val : Int_Ptr) return Float;   -- (1)
-               function Zap (Val : Float_Ptr) return Float; -- (2)
-               function Zop return Int_Ptr;  -- (3)
-               function Zop return Char_Ptr; -- (4)
+               function Zap (Val : Int_Ptr) return Float;   -- <(1)>
+               function Zap (Val : Float_Ptr) return Float; -- <(2)>
+               function Zop return Int_Ptr;  -- <(3)>
+               function Zop return Char_Ptr; -- <(4)>
 
 2.e/2
-               Result : Float := Zap (Zop.all'Access); -- Resolves to Zap (1) 
and Zop (3).
+               Result : Float := Zap (Zop.all'Access); -- <Resolves to Zap (1) 
and Zop (3).>
 
                           _Static Semantics_
 
 3/2
-{AI95-00162-01AI95-00162-01} [The accessibility rules, which prevent
-dangling references, are written in terms of accessibility levels, which
-reflect the run-time nesting of masters.  As explained in *note 7.6.1::,
-a master is the execution of a certain construct, such as a
-subprogram_body.  An accessibility level is deeper than another if it is
-more deeply nested at run time.  For example, an object declared local
-to a called subprogram has a deeper accessibility level than an object
-declared local to the calling subprogram.  The accessibility rules for
-access types require that the accessibility level of an object
+{<AI95-00162-01AI95-00162-01>} [The accessibility rules, which prevent
+dangling references, are written in terms of <accessibility levels>,
+which reflect the run-time nesting of <masters>.  As explained in *note
+7.6.1::, a master is the execution of a certain construct, such as a
+subprogram_body.  An accessibility level is <deeper than> another if it
+is more deeply nested at run time.  For example, an object declared
+local to a called subprogram has a deeper accessibility level than an
+object declared local to the calling subprogram.  The accessibility
+rules for access types require that the accessibility level of an object
 designated by an access value be no deeper than that of the access type.
 This ensures that the object will live at least as long as the access
 type, which in turn ensures that the access value cannot later designate
@@ -18325,7 +18373,7 @@ an object that no longer exists.  The Unchecked_Access 
attribute may be
 used to circumvent the accessibility rules.]
 
 3.a/3
-          Discussion: {AI05-0005-1AI05-0005-1} The Unchecked_Access
+          Discussion: {<AI05-0005-1AI05-0005-1>} The Unchecked_Access
           attribute acts as if the object was declared at library-level;
           this applies even when it is used as the value of anonymous
           access type.  See *note 13.10::.
@@ -18335,10 +18383,10 @@ used to circumvent the accessibility rules.]
           informally known as the "Heart of Darkness" amongst the
           maintainers of Ada.  Woe unto all who enter here (well, at
           least unto anyone that needs to understand any of these
-          rules). 
+          rules).  
 
 4
-[A given accessibility level is said to be statically deeper than
+[A given accessibility level is said to be <statically deeper> than
 another if the given level is known at compile time (as defined below)
 to be deeper than the other for all possible executions.  In most cases,
 accessibility is enforced at compile time by Legality Rules.  Run-time
@@ -18356,25 +18404,25 @@ accessibility level:
      depends (see *note 9.3::).
 
 7/4
-   * {AI95-00162-01AI95-00162-01} {AI95-00416-01AI95-00416-01}
-     {AI05-0235-1AI05-0235-1} {AI12-0067-1AI12-0067-1}
-     {AI12-0089-1AI12-0089-1} An entity or view defined by a declaration
-     and created as part of its elaboration has the same accessibility
-     level as the innermost master of the declaration except in the
-     cases of renaming and derived access types described below.  Other
-     than for an explicitly aliased parameter of a function or generic
-     function, a formal parameter of a callable entity has the same
-     accessibility level as the master representing the invocation of
-     the entity.
+   * {<AI95-00162-01AI95-00162-01>} {<AI95-00416-01AI95-00416-01>}
+     {<AI05-0235-1AI05-0235-1>} {<AI12-0067-1AI12-0067-1>}
+     {<AI12-0089-1AI12-0089-1>} An entity or view defined by a
+     declaration and created as part of its elaboration has the same
+     accessibility level as the innermost master of the declaration
+     except in the cases of renaming and derived access types described
+     below.  Other than for an explicitly aliased parameter of a
+     function or generic function, a formal parameter of a callable
+     entity has the same accessibility level as the master representing
+     the invocation of the entity.
 
 7.a/2
-          Reason: {AI95-00416-01AI95-00416-01} This rule defines the
+          Reason: {<AI95-00416-01AI95-00416-01>} This rule defines the
           "normal" accessibility of entities.  In the absence of special
           rules below, we intend for this rule to apply.
 
 7.b/4
-          Discussion: {AI95-00416-01AI95-00416-01}
-          {AI12-0005-1AI12-0005-1} This rule defines the accessibility
+          Discussion: {<AI95-00416-01AI95-00416-01>}
+          {<AI12-0005-1AI12-0005-1>} This rule defines the accessibility
           of all named access types, as well as the accessibility level
           of anonymous access types in a component_definition Special
           rules exist for the accessibility level of other anonymous
@@ -18383,7 +18431,7 @@ accessibility level:
           named access types defined at the same point.
 
 7.c/2
-          Ramification: {AI95-00230-01AI95-00230-01} Because
+          Ramification: {<AI95-00230-01AI95-00230-01>} Because
           accessibility level is determined by where the
           access_definition is elaborated, for a type extension, the
           anonymous access types of components (other than access
@@ -18395,22 +18443,22 @@ accessibility level:
           type have the same accessibility as they did in the parent.
 
 7.d/3
-          To be honest: {AI05-0235-1AI05-0235-1} We use "invocation of"
-          in the parameter case as a master is formally an execution of
-          something.  But we mean this to be interpreted statically (for
-          instance, as the body of the subprogram) for the purposes of
-          computing "statically deeper than" (see below).
+          To be honest: {<AI05-0235-1AI05-0235-1>} We use "invocation
+          of" in the parameter case as a master is formally an execution
+          of something.  But we mean this to be interpreted statically
+          (for instance, as the body of the subprogram) for the purposes
+          of computing "statically deeper than" (see below).
 
 7.e/3
-          Ramification: {AI05-0235-1AI05-0235-1} Note that accessibility
-          can differ depending on the view of an object (for both static
-          and dynamic accessibility).  For instance, the accessibility
-          level of a formal parameter may be different than the
-          accessibility level of the corresponding actual parameter.
-          This occurs in other cases as well.
+          Ramification: {<AI05-0235-1AI05-0235-1>} Note that
+          accessibility can differ depending on the view of an object
+          (for both static and dynamic accessibility).  For instance,
+          the accessibility level of a formal parameter may be different
+          than the accessibility level of the corresponding actual
+          parameter.  This occurs in other cases as well.
 
 7.f/3
-          Reason: {AI05-0235-1AI05-0235-1} We define the (dynamic)
+          Reason: {<AI05-0235-1AI05-0235-1>} We define the (dynamic)
           accessibility of formal parameters in order that it does not
           depend on the parameter passing model (by-reference or
           by-copy) as that is implementation defined.  Otherwise, there
@@ -18422,29 +18470,29 @@ accessibility level:
      renamed view.
 
 9/2
-   * {AI95-00416-01AI95-00416-01} The accessibility level of a view
+   * {<AI95-00416-01AI95-00416-01>} The accessibility level of a view
      conversion, qualified_expression, or parenthesized expression, is
      the same as that of the operand.
 
 9.1/3
-   * {AI05-0188-1AI05-0188-1} The accessibility level of a
+   * {<AI05-0188-1AI05-0188-1>} The accessibility level of a
      conditional_expression is the accessibility level of the evaluated
-     dependent_expression.
+     <dependent_>expression.
 
 10/4
-   * {AI95-00318-02AI95-00318-02} {AI95-00416-01AI95-00416-01}
-     {AI05-0234-1AI05-0234-1} {AI12-0027-1AI12-0027-1} The accessibility
-     level of an aggregate that is used (in its entirety) to directly
-     initialize part of an object is that of the object being
-     initialized.  In other contexts, the accessibility level of an
-     aggregate is that of the innermost master that evaluates the
+   * {<AI95-00318-02AI95-00318-02>} {<AI95-00416-01AI95-00416-01>}
+     {<AI05-0234-1AI05-0234-1>} {<AI12-0027-1AI12-0027-1>} The
+     accessibility level of an aggregate that is used (in its entirety)
+     to directly initialize part of an object is that of the object
+     being initialized.  In other contexts, the accessibility level of
+     an aggregate is that of the innermost master that evaluates the
      aggregate.  Corresponding rules apply to a value conversion (see
      *note 4.6::).
 
 10.1/3
-   * {AI05-0234-1AI05-0234-1} The accessibility level of the result of a
-     function call is that of the master of the function call, which is
-     determined by the point of call as follows:
+   * {<AI05-0234-1AI05-0234-1>} The accessibility level of the result of
+     a function call is that of the <master of the function call>, which
+     is determined by the point of call as follows:
 
 10.2/3
              * If the result is used (in its entirety) to directly
@@ -18456,16 +18504,16 @@ accessibility level:
                be transferred.
 
 10.a/2
-          To be honest: {AI95-00416-01AI95-00416-01} The first sentence
-          is talking about a static use of the entire return object -- a
-          slice that happens to be the entire return object doesn't
-          count.  On the other hand, this is intended to allow
+          To be honest: {<AI95-00416-01AI95-00416-01>} The first
+          sentence is talking about a static use of the entire return
+          object -- a slice that happens to be the entire return object
+          doesn't count.  On the other hand, this is intended to allow
           parentheses and qualified_expressions.
 
 10.b/3
-          Ramification: {AI95-00416-01AI95-00416-01}
-          {AI05-0234-1AI05-0234-1} If the function is used as a prefix,
-          this bullet does not apply.  Similarly, an
+          Ramification: {<AI95-00416-01AI95-00416-01>}
+          {<AI05-0234-1AI05-0234-1>} If the function is used as a
+          prefix, this bullet does not apply.  Similarly, an
           assignment_statement is not an initialization of an object, so
           this bullet does not apply.
 
@@ -18491,27 +18539,28 @@ accessibility level:
                innermost master that evaluates the function call.
 
 10.c/2
-          Ramification: {AI95-00318-02AI95-00318-02}
-          {AI95-00416-01AI95-00416-01} The "innermost master which
+          Ramification: {<AI95-00318-02AI95-00318-02>}
+          {<AI95-00416-01AI95-00416-01>} The "innermost master which
           evaluated the function call" does not include the function
           call itself (which might be a master).
 
 10.d/2
-          {AI95-00318-02AI95-00318-02} {AI95-00416-01AI95-00416-01} We
-          really mean the innermost master here, which could be a very
-          short lifetime.  Consider a function call used as a parameter
-          of a procedure call.  In this case the innermost master which
-          evaluated the function call is the procedure call.
+          {<AI95-00318-02AI95-00318-02>} {<AI95-00416-01AI95-00416-01>}
+          We really mean the innermost master here, which could be a
+          very short lifetime.  Consider a function call used as a
+          parameter of a procedure call.  In this case the innermost
+          master which evaluated the function call is the procedure
+          call.
 
 10.d.1/3
-          Ramification: {AI05-0234-1AI05-0234-1} These rules do not
+          Ramification: {<AI05-0234-1AI05-0234-1>} These rules do not
           mention whether the result object is built-in-place (see *note
           7.6::).  In particular, in the case where building in place is
           optional, the choice whether or not to build-in-place has no
           effect on masters, lifetimes, or accessibility.
 
 10.d.2/3
-          Implementation Note: {AI05-0234-1AI05-0234-1} There are
+          Implementation Note: {<AI05-0234-1AI05-0234-1>} There are
           several cases where the implementation may have to pass in the
           accessibility level of the result object on a call, to support
           later rules where the accessibility level comes from the
@@ -18539,13 +18588,13 @@ accessibility level:
           parameter.
 
 10.7/3
-     {AI05-0284-1AI05-0284-1} In the case of a call to a function whose
-     result type is an anonymous access type, the accessibility level of
-     the type of the result of the function call is also determined by
-     the point of call as described above.
+     {<AI05-0284-1AI05-0284-1>} In the case of a call to a function
+     whose result type is an anonymous access type, the accessibility
+     level of the type of the result of the function call is also
+     determined by the point of call as described above.
 
 10.8/3
-   * {AI95-00416-01AI95-00416-01} Within a return statement, the
+   * {<AI95-00416-01AI95-00416-01>} Within a return statement, the
      accessibility level of the return object is that of the execution
      of the return statement.  If the return statement completes
      normally by returning from the function, then prior to leaving the
@@ -18569,13 +18618,13 @@ accessibility level:
      that of its ultimate ancestor.
 
 11.1/2
-   * {AI95-00230-01AI95-00230-01} The accessibility level of the
+   * {<AI95-00230-01AI95-00230-01>} The accessibility level of the
      anonymous access type defined by an access_definition of an
      object_renaming_declaration is the same as that of the renamed
      view.
 
 12/2
-   * {AI95-00230-01AI95-00230-01} {AI95-00416-01AI95-00416-01} The
+   * {<AI95-00230-01AI95-00230-01>} {<AI95-00416-01AI95-00416-01>} The
      accessibility level of the anonymous access type of an access
      discriminant in the subtype_indication or qualified_expression of
      an allocator, or in the expression or return_subtype_indication
@@ -18608,20 +18657,21 @@ accessibility level:
                     access-to-constrained subtype, etc.
 
 12.e/3
-          Ramification: {AI05-0281-1AI05-0281-1} The subtype_indication
-          mentioned in this bullet is not necessarily the one given in
-          the allocator or return statement that is determining the
-          accessibility level; the constrained subtype might have been
-          defined in an earlier declaration (as a named subtype).
+          Ramification: {<AI05-0281-1AI05-0281-1>} The
+          subtype_indication mentioned in this bullet is not necessarily
+          the one given in the allocator or return statement that is
+          determining the accessibility level; the constrained subtype
+          might have been defined in an earlier declaration (as a named
+          subtype).
 
 12.f/3
-          {AI05-0005-1AI05-0005-1} If the value for this rule and the
+          {<AI05-0005-1AI05-0005-1>} If the value for this rule and the
           next one is derived from an Unchecked_Access attribute, the
           accessibility is library-level no matter what the
           accessibility level of the object is (see *note 13.10::).
 
 12.2/3
-             * {AI05-0234-1AI05-0234-1} If the value of the access
+             * {<AI05-0234-1AI05-0234-1>} If the value of the access
                discriminant is determined by a default_expression in the
                declaration of the discriminant, the level of the object
                or subprogram designated by the associated value (or
@@ -18633,7 +18683,7 @@ accessibility level:
           discriminants.
 
 12.3/3
-             * {AI05-0004-1AI05-0004-1} If the value of the access
+             * {<AI05-0004-1AI05-0004-1>} If the value of the access
                discriminant is determined by a
                record_component_association in an aggregate, the
                accessibility level of the object or subprogram
@@ -18654,7 +18704,7 @@ accessibility level:
                the object.
 
 12.h/2
-          Discussion: {AI95-00416-01AI95-00416-01} In other words, if
+          Discussion: {<AI95-00416-01AI95-00416-01>} In other words, if
           you know the value of the discriminant for an allocator or
           return statement from a discriminant constraint or an
           aggregate component association, then that determines the
@@ -18662,24 +18712,24 @@ accessibility level:
           the object itself.
 
 12.5/3
-   * {AI95-00416-01AI95-00416-01} The accessibility level of the
+   * {<AI95-00416-01AI95-00416-01>} The accessibility level of the
      anonymous access type of an access discriminant in any other
      context is that of the enclosing object.
 
 13/3
-   * {AI95-00162-01AI95-00162-01} {AI95-00254-01AI95-00254-01}
-     {AI05-0270-1AI05-0270-1} The accessibility level of the anonymous
+   * {<AI95-00162-01AI95-00162-01>} {<AI95-00254-01AI95-00254-01>}
+     {<AI05-0270-1AI05-0270-1>} The accessibility level of the anonymous
      access type of an access parameter specifying an access-to-object
      type is the same as that of the view designated by the actual (or
      library-level if the actual is null).
 
 13.a/3
-          Ramification: {AI05-0005-1AI05-0005-1} If the value of the
+          Ramification: {<AI05-0005-1AI05-0005-1>} If the value of the
           actual is derived from an Unchecked_Access attribute, the
           accessibility is always library-level (see *note 13.10::).
 
 13.1/2
-   * {AI95-00254-01AI95-00254-01} The accessibility level of the
+   * {<AI95-00254-01AI95-00254-01>} The accessibility level of the
      anonymous access type of an access parameter specifying an
      access-to-subprogram type is deeper than that of any master; all
      such anonymous access types have this same level.
@@ -18694,14 +18744,14 @@ accessibility level:
           information needed to make a call.
 
 13.2/4
-   * {AI12-0070-1AI12-0070-1} The accessibility level of the anonymous
+   * {<AI12-0070-1AI12-0070-1>} The accessibility level of the anonymous
      access subtype defined by a return_subtype_indication that is an
      access_definition (see *note 6.5::) is that of the result subtype
      of the enclosing function.
 
 13.3/4
-   * {AI05-0148-1AI05-0148-1} {AI05-0240-1AI05-0240-1}
-     {AI12-0070-1AI12-0070-1} The accessibility level of the type of a
+   * {<AI05-0148-1AI05-0148-1>} {<AI05-0240-1AI05-0240-1>}
+     {<AI12-0070-1AI12-0070-1>} The accessibility level of the type of a
      stand-alone object of an anonymous access-to-object type is the
      same as the accessibility level of the type of the access value
      most recently assigned to the object[; accessibility checks ensure
@@ -18709,18 +18759,18 @@ accessibility level:
      stand-alone object].
 
 13.4/4
-   * {AI05-0142-4AI05-0142-4} {AI05-0240-1AI05-0240-1}
-     {AI12-0070-1AI12-0070-1} The accessibility level of an explicitly
+   * {<AI05-0142-4AI05-0142-4>} {<AI05-0240-1AI05-0240-1>}
+     {<AI12-0070-1AI12-0070-1>} The accessibility level of an explicitly
      aliased (see *note 6.1::) formal parameter in a function body is
      determined by the point of call; it is the same level that the
      return object ultimately will have.
 
 14/3
-   * {AI95-00416-01AI95-00416-01} {AI05-0051-1AI05-0051-1}
-     {AI05-0253-1AI05-0253-1} The accessibility level of an object
+   * {<AI95-00416-01AI95-00416-01>} {<AI05-0051-1AI05-0051-1>}
+     {<AI05-0253-1AI05-0253-1>} The accessibility level of an object
      created by an allocator is the same as that of the access type,
-     except for an allocator of an anonymous access type (an anonymous
-     allocator) in certain contexts, as follows: For an anonymous
+     except for an allocator of an anonymous access type (an <anonymous
+     allocator>) in certain contexts, as follows: For an anonymous
      allocator that defines the result of a function with an access
      result, the accessibility level is determined as though the
      allocator were in place of the call of the function; in the special
@@ -18735,24 +18785,25 @@ accessibility level:
      determined as follows:
 
 14.1/3
-             * {AI95-00416-01AI95-00416-01} {AI05-0024-1AI05-0024-1} for
-               an allocator used to define the discriminant of an
+             * {<AI95-00416-01AI95-00416-01>} {<AI05-0024-1AI05-0024-1>}
+               for an allocator used to define the discriminant of an
                object, the level of the object;
 
 14.2/3
-             * {AI95-00416-01AI95-00416-01} {AI05-0024-1AI05-0024-1} for
-               an allocator used to define the constraint in a
+             * {<AI95-00416-01AI95-00416-01>} {<AI05-0024-1AI05-0024-1>}
+               for an allocator used to define the constraint in a
                subtype_indication in any other context, the level of the
                master that elaborates the subtype_indication.
 
 14.3/3
-             * This paragraph was deleted.{AI95-00416-01AI95-00416-01}
-               {AI05-0024-1AI05-0024-1}
+             * <This paragraph was
+               deleted.>{<AI95-00416-01AI95-00416-01>}
+               {<AI05-0024-1AI05-0024-1>}
 
 14.4/3
-     {AI95-00416-01AI95-00416-01} {AI05-0024-1AI05-0024-1}
-     {AI05-0066-1AI05-0066-1} In the first case, the allocated object is
-     said to be a coextension of the object whose discriminant
+     {<AI95-00416-01AI95-00416-01>} {<AI05-0024-1AI05-0024-1>}
+     {<AI05-0066-1AI05-0066-1>} In the first case, the allocated object
+     is said to be a <coextension> of the object whose discriminant
      designates it, as well as of any object of which the discriminated
      object is itself a coextension or subcomponent.  If the allocated
      object is a coextension of an anonymous object representing the
@@ -18773,21 +18824,22 @@ accessibility level:
           stack frame, in the case of a declared object).
 
 14.5/3
-   * {AI05-0051-1AI05-0051-1} Within a return statement, the
+   * {<AI05-0051-1AI05-0051-1>} Within a return statement, the
      accessibility level of the anonymous access type of an access
      result is that of the master of the call.
 
 15/3
-   * {AI05-0014-1AI05-0014-1} The accessibility level of a view of an
+   * {<AI05-0014-1AI05-0014-1>} The accessibility level of a view of an
      object or subprogram designated by an access value is the same as
      that of the access type.
 
 15.a/3
-          Discussion: {AI05-0005-1AI05-0005-1} {AI05-0014-1AI05-0014-1}
-          This rule applies even when no dereference exists, for example
-          when an access value is passed as an access parameter.  This
-          rule ensures that implementations are not required to include
-          dynamic accessibility values with all access values.
+          Discussion: {<AI05-0005-1AI05-0005-1>}
+          {<AI05-0014-1AI05-0014-1>} This rule applies even when no
+          dereference exists, for example when an access value is passed
+          as an access parameter.  This rule ensures that
+          implementations are not required to include dynamic
+          accessibility values with all access values.
 
 16
    * The accessibility level of a component, protected subprogram, or
@@ -18795,17 +18847,17 @@ accessibility level:
      view of) the composite object.
 
 16.1/3
-{AI95-00416-01AI95-00416-01} {AI05-0262-1AI05-0262-1} In the above
+{<AI95-00416-01AI95-00416-01>} {<AI05-0262-1AI05-0262-1>} In the above
 rules, the operand of a view conversion, parenthesized expression or
 qualified_expression is considered to be used in a context if the view
 conversion, parenthesized expression or qualified_expression itself is
-used in that context.  Similarly, a dependent_expression of a
+used in that context.  Similarly, a <dependent_>expression of a
 conditional_expression is considered to be used in a context if the
 conditional_expression itself is used in that context.
 
 17
-One accessibility level is defined to be statically deeper than another
-in the following cases:
+One accessibility level is defined to be <statically deeper> than
+another in the following cases:
 
 18
    * For a master that is statically nested within another master, the
@@ -18814,9 +18866,9 @@ in the following cases:
 
 18.a
           To be honest: Strictly speaking, this should talk about the
-          constructs (such as subprogram_bodies) being statically nested
-          within one another; the masters are really the executions of
-          those constructs.
+          <constructs> (such as subprogram_bodies) being statically
+          nested within one another; the masters are really the
+          <executions> of those constructs.
 
 18.b
           To be honest: If a given accessibility level is statically
@@ -18825,7 +18877,7 @@ in the following cases:
           to be the same as the other level.
 
 18.1/2
-   * {AI95-00254-01AI95-00254-01} The accessibility level of the
+   * {<AI95-00254-01AI95-00254-01>} The accessibility level of the
      anonymous access type of an access parameter specifying an
      access-to-subprogram type is statically deeper than that of any
      master; all such anonymous access types have this same level.
@@ -18838,7 +18890,7 @@ in the following cases:
           conversion's accessibility will succeed).
 
 19/3
-   * {AI95-00254-01AI95-00254-01} {AI05-0082-1AI05-0082-1} The
+   * {<AI95-00254-01AI95-00254-01>} {<AI05-0082-1AI05-0082-1>} The
      statically deeper relationship does not apply to the accessibility
      level of the anonymous type of an access parameter specifying an
      access-to-object type nor does it apply to a descendant of a
@@ -18847,7 +18899,7 @@ in the following cases:
      any other.
 
 19.1/3
-   * {AI05-0148-1AI05-0148-1} The statically deeper relationship does
+   * {<AI05-0148-1AI05-0148-1>} The statically deeper relationship does
      not apply to the accessibility level of the type of a stand-alone
      object of an anonymous access-to-object type; that is, such an
      accessibility level is not considered to be statically deeper, nor
@@ -18858,36 +18910,36 @@ in the following cases:
           checks.
 
 19.2/4
-   * {AI05-0142-4AI05-0142-4} {AI05-0235-1AI05-0235-1}
-     {AI12-0089-1AI12-0089-1} {AI12-0157-1AI12-0157-1} Inside a return
-     statement that applies to a function or generic function F, or the
-     return expression of an expression function F, when determining
-     whether the accessibility level of an explicitly aliased parameter
-     of F is statically deeper than the level of the return object of F,
-     the level of the return object is considered to be the same as that
-     of the level of the explicitly aliased parameter; for statically
-     comparing with the level of other entities, an explicitly aliased
-     parameter of F is considered to have the accessibility level of the
-     body of F.
+   * {<AI05-0142-4AI05-0142-4>} {<AI05-0235-1AI05-0235-1>}
+     {<AI12-0089-1AI12-0089-1>} {<AI12-0157-1AI12-0157-1>} Inside a
+     return statement that applies to a function or generic function
+     <F>, or the return expression of an expression function <F>, when
+     determining whether the accessibility level of an explicitly
+     aliased parameter of <F> is statically deeper than the level of the
+     return object of <F>, the level of the return object is considered
+     to be the same as that of the level of the explicitly aliased
+     parameter; for statically comparing with the level of other
+     entities, an explicitly aliased parameter of <F> is considered to
+     have the accessibility level of the body of <F>.
 
 19.3/4
-   * {AI05-0051-1AI05-0051-1} {AI05-0234-1AI05-0234-1}
-     {AI05-0235-1AI05-0235-1} {AI12-0089-1AI12-0089-1}
-     {AI12-0157-1AI12-0157-1} For determining whether a level is
+   * {<AI05-0051-1AI05-0051-1>} {<AI05-0234-1AI05-0234-1>}
+     {<AI05-0235-1AI05-0235-1>} {<AI12-0089-1AI12-0089-1>}
+     {<AI12-0157-1AI12-0157-1>} For determining whether a level is
      statically deeper than the level of the anonymous access type of an
-     access result of a function or generic function F, when within a
-     return statement that applies to F or the return expression of
-     expression function F, the level of the master of the call is
+     access result of a function or generic function <F>, when within a
+     return statement that applies to <F> or the return expression of
+     expression function <F>, the level of the master of the call is
      presumed to be the same as that of the level of the master that
-     elaborated the body of F.
+     elaborated the body of <F>.
 
 20
-   * or generic function F
+   * or generic function <F>
 
 20.a/3
-          To be honest: {AI05-0235-1AI05-0235-1} This rule has no effect
-          if the previous bullet also applies (that is, the "a level" is
-          of an explicitly aliased parameter).
+          To be honest: {<AI05-0235-1AI05-0235-1>} This rule has no
+          effect if the previous bullet also applies (that is, the "a
+          level" is of an explicitly aliased parameter).
 
 21
    * [For determining whether one level is statically deeper than
@@ -18897,7 +18949,7 @@ in the following cases:
      nested instantiations.]
 
 21.a/3
-          Proof: {AI05-0082-1AI05-0082-1} A generic package does not
+          Proof: {<AI05-0082-1AI05-0082-1>} A generic package does not
           introduce a new master, so it has the static level of its
           declaration; the rest follows from the other "statically
           deeper" rules.
@@ -18913,8 +18965,8 @@ in the following cases:
           time of the type_declaration, in an assume-the-worst manner.
 
 23
-The accessibility level of all library units is called the library
-level; a library-level declaration or entity is one whose accessibility
+The accessibility level of all library units is called the <library
+level>; a library-level declaration or entity is one whose accessibility
 level is the library level.
 
 23.a
@@ -18984,9 +19036,9 @@ level is the library level.
           the package.
 
 23.k
-          Note that the level of the view denoted by X.all can be
-          different from the level of the object denoted by X.all.  The
-          former is determined by the type of X; the latter is
+          Note that the level of the <view> denoted by X.all can be
+          different from the level of the <object> denoted by X.all.
+          The former is determined by the type of X; the latter is
           determined either by the type of the allocator, or by the
           master in which the object was declared.  The former is used
           in several Legality Rules and run-time checks; the latter is
@@ -19019,11 +19071,11 @@ level is the library level.
                a type.
 
 23.o.1/3
-             * {AI05-0082-1AI05-0082-1} Checks involving generic formal
-               types and their descendants.  This is because the actual
-               type can be more or less deeply nested than the generic
-               unit.  Note that this only applies to the generic unit
-               itself, and not to the instance.  Any static checks
+             * {<AI05-0082-1AI05-0082-1>} Checks involving generic
+               formal types and their descendants.  This is because the
+               actual type can be more or less deeply nested than the
+               generic unit.  Note that this only applies to the generic
+               unit itself, and not to the instance.  Any static checks
                needed in the instance will be performed.  Any other
                checks (such as those in the generic body) will require a
                run-time check of some sort (although implementations
@@ -19031,23 +19083,24 @@ level is the library level.
                the check when the generic is expanded).
 
 23.p/3
-             * {AI05-0082-1AI05-0082-1} Checks involving other entities
-               and views within generic packages.  This is because an
-               instantiation can be at a level that is more deeply
-               nested than the generic package itself.  In
+             * {<AI05-0082-1AI05-0082-1>} Checks involving other
+               entities and views within generic packages.  This is
+               because an instantiation can be at a level that is more
+               deeply nested than the generic package itself.  In
                implementations that use a macro-expansion model of
                generics, these violations can be detected at
                macro-expansion time.  For implementations that share
                generics, run-time code is needed to detect the error.
 
 23.q/2
-             * {AI95-00318-02AI95-00318-02} {AI95-00344-01AI95-00344-01}
-               {AI95-00416-01AI95-00416-01} Checks during function
+             * {<AI95-00318-02AI95-00318-02>}
+               {<AI95-00344-01AI95-00344-01>}
+               {<AI95-00416-01AI95-00416-01>} Checks during function
                return and allocators, for nested type extensions and
                access discriminants.
 
 23.r/3
-          {AI05-0005-1AI05-0005-1} Note that run-time checks are not
+          {<AI05-0005-1AI05-0005-1>} Note that run-time checks are not
           required for access discriminants (except during function
           returns and allocators), because their accessibility is
           determined statically by the accessibility level of the
@@ -19064,9 +19117,9 @@ level is the library level.
           deeper, or deeper, respectively, than something else.
 
 23.u/2
-          Implementation Note: {AI95-00318-02AI95-00318-02}
-          {AI95-00344-01AI95-00344-01} {AI95-00416-01AI95-00416-01} If
-          an accessibility Legality Rule is satisfied, then the
+          Implementation Note: {<AI95-00318-02AI95-00318-02>}
+          {<AI95-00344-01AI95-00344-01>} {<AI95-00416-01AI95-00416-01>}
+          If an accessibility Legality Rule is satisfied, then the
           corresponding run-time check (if any) cannot fail (and a
           reasonable implementation will not generate any checking code)
           unless one of the cases requiring run-time checks mentioned
@@ -19094,7 +19147,7 @@ level is the library level.
           is not deeper than Y would involve checking that X <= Y.
 
 23.x
-          A more efficient method is based on passing static nesting
+          A more efficient method is based on passing <static> nesting
           levels (within constructs that correspond at run time to
           masters -- packages don't count).  Whenever an access
           parameter is passed, an implicit extra parameter is passed
@@ -19158,7 +19211,7 @@ level is the library level.
           overhead.
 
 23.ff.1/3
-          {AI05-0148-1AI05-0148-1} The implementation of accessibility
+          {<AI05-0148-1AI05-0148-1>} The implementation of accessibility
           checks for stand-alone objects of anonymous access-to-object
           types can be similar to that for anonymous access-to-object
           parameters.  A static level suffices; it can be calculated
@@ -19166,15 +19219,15 @@ level is the library level.
           parameters.
 
 23.ff.2/3
-          {AI05-0148-1AI05-0148-1} One important difference between the
-          stand-alone access variables and access parameters is that one
-          can assign a local access parameter to a more global
+          {<AI05-0148-1AI05-0148-1>} One important difference between
+          the stand-alone access variables and access parameters is that
+          one can assign a local access parameter to a more global
           stand-alone access variable.  Similarly, one can assign a more
           global access parameter to a more local stand-alone access
           variable.
 
 23.ff.3/3
-          {AI05-0148-1AI05-0148-1} For these cases, it is important to
+          {<AI05-0148-1AI05-0148-1>} For these cases, it is important to
           note that the "correct" static accessibility level for an
           access parameter assigned to a stand-alone access object is
           the minimum of the passed in level and the static
@@ -19192,26 +19245,26 @@ level is the library level.
           Discussion: Examples of accessibility:
 
 23.hh/3
-               {AI05-0005-1AI05-0005-1} package body Lib_Unit is
+               {<AI05-0005-1AI05-0005-1>} package body Lib_Unit is
                    type T is tagged ...;
                    type A0 is access all T;
                    Global: A0 := ...;
                    procedure P(X: in out T) is
                        Y: aliased T;
                        type A1 is access all T;
-                       Ptr0: A0 := Global; -- OK.
-                       Ptr1: A1 := X'Access; -- OK.
+                       Ptr0: A0 := Global; --< OK.>
+                       Ptr1: A1 := X'Access; --< OK.>
                    begin
-                       Ptr1 := Y'Access; -- OK;
-                       Ptr0 := A0(Ptr1); -- Illegal type conversion!
-                       Ptr0 := X'Access; -- Illegal reference to Access 
attribute!
-                       Ptr0 := Y'Access; -- Illegal reference to Access 
attribute!
-                       Global := Ptr0; -- OK.
+                       Ptr1 := Y'Access; --< OK;>
+                       Ptr0 := A0(Ptr1); --< Illegal type conversion!>
+                       Ptr0 := X'Access; --< Illegal reference to Access 
attribute!>
+                       Ptr0 := Y'Access; --< Illegal reference to Access 
attribute!>
+                       Global := Ptr0; --< OK.>
                    end P;
                end Lib_Unit;
 
 23.ii/3
-          {AI05-0005-1AI05-0005-1} The above illegal statements are
+          {<AI05-0005-1AI05-0005-1>} The above illegal statements are
           illegal because the accessibility levels of X and Y are
           statically deeper than the accessibility level of A0.  In
           every possible execution of any program including this library
@@ -19231,8 +19284,8 @@ level is the library level.
                    procedure P(X: access Integer) is
                        type Nested_Type is access all Integer;
                    begin
-                       ... Nested_Type(X) ... -- (1)
-                       ... Level_1_Type(X) ... -- (2)
+                       ... Nested_Type(X) ... --< (1)>
+                       ... Level_1_Type(X) ... --< (2)>
                    end P;
 
 23.mm
@@ -19249,13 +19302,13 @@ level is the library level.
                    procedure R is
                        Level_2: aliased Integer;
                    begin
-                       Q(Level_2'Access); -- (3)
+                       Q(Level_2'Access); --< (3)>
                    end R;
 
 23.oo
                    Level_1: aliased Integer;
                begin
-                   Q(Level_1'Access); -- (4)
+                   Q(Level_1'Access); --< (4)>
                    R;
                end Main;
 
@@ -19269,7 +19322,7 @@ level is the library level.
           assume-the-worst manner.  For example:
 
 23.rr/3
-               {AI05-0298-1AI05-0298-1} package P is
+               {<AI05-0298-1AI05-0298-1>} package P is
                    type Int_Ptr is access all Integer;
                    type Rec(D: access Integer) is limited private;
                private
@@ -19278,9 +19331,9 @@ level is the library level.
                    function G(X: access Rec) return Boolean;
                    type Rec(D: access Integer) is
                        limited record
-                           C1: Int_Ptr := Int_Ptr(D); -- Illegal!
-                           C2: Rec_Ptr := Rec'Access; -- Illegal!
-                           C3: Boolean := F(Rec'Access); -- Illegal!
+                           C1: Int_Ptr := Int_Ptr(D); --< Illegal!>
+                           C2: Rec_Ptr := Rec'Access; --< Illegal!>
+                           C3: Boolean := F(Rec'Access); --< Illegal!>
                            C4: Boolean := G(Rec'Access);
                        end record;
                end P;
@@ -19306,24 +19359,23 @@ aliased view of an object:
 
 25/1
 X'Access
-               {8652/00108652/0010} {AI95-00127-01AI95-00127-01}
+               {<8652/00108652/0010>} {<AI95-00127-01AI95-00127-01>}
                X'Access yields an access value that designates the
                object denoted by X. The type of X'Access is an
                access-to-object type, as determined by the expected
-               type.  The expected type shall be a general access type.
-               X shall denote an aliased view of an object[, including
+               type.  The expected type shall be a general access type.        
       X shall denote an aliased view of an object[, including
                possibly the current instance (see *note 8.6::) of a
                limited type within its definition, or a formal parameter
                or generic formal object of a tagged type].  The view
                denoted by the prefix X shall satisfy the following
                additional requirements, presuming the expected type for
-               X'Access is the general access type A with designated
-               type D:
+               X'Access is the general access type <A> with designated
+               type <D>:
 
 26
-                  * If A is an access-to-variable type, then the view
-                    shall be a variable; [on the other hand, if A is an
-                    access-to-constant type, the view may be either a
+                  * If <A> is an access-to-variable type, then the view
+                    shall be a variable; [on the other hand, if <A> is
+                    an access-to-constant type, the view may be either a
                     constant or a variable.]
 
 26.a
@@ -19331,11 +19383,11 @@ X'Access
           considered a variable.
 
 27/3
-                  * {AI95-00363-01AI95-00363-01}
-                    {AI05-0008-1AI05-0008-1} {AI05-0041-1AI05-0041-1}
-                    The view shall not be a subcomponent that depends on
-                    discriminants of an object unless the object is
-                    known to be constrained.
+                  * {<AI95-00363-01AI95-00363-01>}
+                    {<AI05-0008-1AI05-0008-1>}
+                    {<AI05-0041-1AI05-0041-1>} The view shall not be a
+                    subcomponent that depends on discriminants of an
+                    object unless the object is known to be constrained.
 
 27.a
           Discussion: This restriction is intended to be similar to the
@@ -19387,26 +19439,28 @@ X'Access
           the derived type (see *note 3.7::).
 
 28/2
-                  * {8652/00108652/0010} {AI95-00127-01AI95-00127-01}
-                    {AI95-00363-01AI95-00363-01} If A is a named access
-                    type and D is a tagged type, then the type of the
-                    view shall be covered by D; if A is anonymous and D
-                    is tagged, then the type of the view shall be either
-                    D'Class or a type covered by D; if D is untagged,
-                    then the type of the view shall be D, and either:
+                  * {<8652/00108652/0010>}
+                    {<AI95-00127-01AI95-00127-01>}
+                    {<AI95-00363-01AI95-00363-01>} If <A> is a named
+                    access type and <D> is a tagged type, then the type
+                    of the view shall be covered by <D>; if <A> is
+                    anonymous and <D> is tagged, then the type of the
+                    view shall be either <D>'Class or a type covered by
+                    <D>; if <D> is untagged, then the type of the view
+                    shall be <D>, and either:
 
 28.1/2
-                            * {AI95-00363-01AI95-00363-01} the
-                              designated subtype of A shall statically
+                            * {<AI95-00363-01AI95-00363-01>} the
+                              designated subtype of <A> shall statically
                               match the nominal subtype of the view; or
 
 28.2/4
-                            * {AI95-00363-01AI95-00363-01}
-                              {AI05-0041-1AI05-0041-1}
-                              {AI12-0095-1AI12-0095-1} D shall be
+                            * {<AI95-00363-01AI95-00363-01>}
+                              {<AI05-0041-1AI05-0041-1>}
+                              {<AI12-0095-1AI12-0095-1>} <D> shall be
                               discriminated in its full view and
                               unconstrained in any partial view, and the
-                              designated subtype of A shall be
+                              designated subtype of <A> shall be
                               unconstrained.
 
 28.a
@@ -19415,56 +19469,57 @@ X'Access
           not be if its nominal subtype is constrained.
 
 28.a.1/1
-          Ramification: {8652/00108652/0010}
-          {AI95-00127-01AI95-00127-01} An access attribute can be used
+          Ramification: {<8652/00108652/0010>}
+          {<AI95-00127-01AI95-00127-01>} An access attribute can be used
           as the controlling operand in a dispatching call; see *note
           3.9.2::.
 
 28.a.2/2
-          {AI95-00363-01AI95-00363-01} This does not require that types
-          have a partial view in order to allow an access attribute of
-          an unconstrained discriminated object, only that any partial
-          view that does exist is unconstrained.
+          {<AI95-00363-01AI95-00363-01>} This does not require that
+          types have a partial view in order to allow an access
+          attribute of an unconstrained discriminated object, only that
+          any partial view that does exist is unconstrained.
 
 28.a.3/4
-          Discussion: {AI12-0095-1AI12-0095-1} We assume the worst in a
-          generic body whether or not a formal subtype has a constrained
-          partial view; specifically, in a generic body a discriminated
-          subtype is considered to have a constrained partial view if it
-          is a descendant of an untagged generic formal private or
-          derived type (see *note 12.5.1:: for the formal definition of
-          this rule).
+          Discussion: {<AI12-0095-1AI12-0095-1>} We assume the worst in
+          a generic body whether or not a formal subtype has a
+          constrained partial view; specifically, in a generic body a
+          discriminated subtype is considered to have a constrained
+          partial view if it is a descendant of an untagged generic
+          formal private or derived type (see *note 12.5.1:: for the
+          formal definition of this rule).
 
 29/3
-                  * {AI05-0041-1AI05-0041-1} The accessibility level of
-                    the view shall not be statically deeper than that of
-                    the access type A. 
+                  * {<AI05-0041-1AI05-0041-1>} The accessibility level
+                    of the view shall not be statically deeper than that
+                    of the access type <A>.  
 
 29.a
           Ramification: In an instance body, a run-time check applies.
 
 29.b/2
-          {AI95-00230-01AI95-00230-01} If A is an anonymous
+          {<AI95-00230-01AI95-00230-01>} If <A> is an anonymous
           access-to-object type of an access parameter, then the view
-          can never have a deeper accessibility level than A. The same
-          is true for an anonymous access-to-object type of an access
-          discriminant, except when X'Access is used to initialize an
-          access discriminant of an object created by an allocator.  The
-          latter case is illegal if the accessibility level of X is
-          statically deeper than that of the access type of the
-          allocator; a run-time check is needed in the case where the
-          initial value comes from an access parameter.  Other anonymous
-          access-to-object types have "normal" accessibility checks.
+          can never have a deeper accessibility level than <A>.  The
+          same is true for an anonymous access-to-object type of an
+          access discriminant, except when X'Access is used to
+          initialize an access discriminant of an object created by an
+          allocator.  The latter case is illegal if the accessibility
+          level of X is statically deeper than that of the access type
+          of the allocator; a run-time check is needed in the case where
+          the initial value comes from an access parameter.  Other
+          anonymous access-to-object types have "normal" accessibility
+          checks.
 
 29.1/3
-               {AI05-0041-1AI05-0041-1} In addition to the places where
-               Legality Rules normally apply (see *note 12.3::), these
-               requirements apply also in the private part of an
+               {<AI05-0041-1AI05-0041-1>} In addition to the places
+               where Legality Rules normally apply (see *note 12.3::),
+               these requirements apply also in the private part of an
                instance of a generic unit.
 
 30
                A check is made that the accessibility level of X is not
-               deeper than that of the access type A. If this check
+               deeper than that of the access type <A>.  If this check
                fails, Program_Error is raised.
 
 30.a/2
@@ -19472,7 +19527,7 @@ X'Access
           access-to-object type and in instance bodies.
 
 30.a.1/3
-          {AI05-0024-1AI05-0024-1} Because there are no access
+          {<AI05-0024-1AI05-0024-1>} Because there are no access
           parameters permitted for task entries, the accessibility
           levels are always comparable.  We would have to switch to the
           terminology used in *note 4.8:: and *note 6.5:: based on
@@ -19480,7 +19535,7 @@ X'Access
           might introduce unacceptable distributed overhead.
 
 30.b/3
-          Implementation Note: {AI05-0148-1AI05-0148-1} This check
+          Implementation Note: {<AI05-0148-1AI05-0148-1>} This check
           requires that some indication of lifetime is passed as an
           implicit parameter along with access parameters of an
           access-to-object type.  A similar indication is required for
@@ -19491,7 +19546,7 @@ X'Access
 
 31
                If the nominal subtype of X does not statically match the
-               designated subtype of A, a view conversion of X to the
+               designated subtype of <A>, a view conversion of X to the
                designated subtype is evaluated (which might raise
                Constraint_Error -- see *note 4.6::) and the value of
                X'Access designates that view.
@@ -19502,27 +19557,28 @@ subprogram:
 
 33/3
 P'Access
-               {AI95-00229-01AI95-00229-01} {AI95-00254-01AI95-00254-01}
-               {AI05-0239-1AI05-0239-1} P'Access yields an access value
-               that designates the subprogram denoted by P. The type of
-               P'Access is an access-to-subprogram type (S), as
-               determined by the expected type. The accessibility level
-               of P shall not be statically deeper than that of S. In
-               addition to the places where Legality Rules normally
-               apply (see *note 12.3::), this rule applies also in the
-               private part of an instance of a generic unit.  The
-               profile of P shall be subtype conformant with the
-               designated profile of S, and shall not be Intrinsic. If
-               the subprogram denoted by P is declared within a generic
-               unit, and the expression P'Access occurs within the body
-               of that generic unit or within the body of a generic unit
-               declared within the declarative region of the generic
-               unit, then the ultimate ancestor of S shall be either a
-               nonformal type declared within the generic unit or an
-               anonymous access type of an access parameter.
+               {<AI95-00229-01AI95-00229-01>}
+               {<AI95-00254-01AI95-00254-01>} {<AI05-0239-1AI05-0239-1>}
+               P'Access yields an access value that designates the
+               subprogram denoted by P. The type of P'Access is an
+               access-to-subprogram type (<S>), as determined by the
+               expected type.  The accessibility level of P shall not be
+               statically deeper than that of <S>.  In addition to the
+               places where Legality Rules normally apply (see *note
+               12.3::), this rule applies also in the private part of an
+               instance of a generic unit.  The profile of P shall be
+               subtype conformant with the designated profile of <S>,
+               and shall not be Intrinsic.  If the subprogram denoted by
+               P is declared within a generic unit, and the expression
+               P'Access occurs within the body of that generic unit or
+               within the body of a generic unit declared within the
+               declarative region of the generic unit, then the ultimate
+               ancestor of <S> shall be either a nonformal type declared
+               within the generic unit or an anonymous access type of an
+               access parameter.
 
 33.a/2
-          Discussion: {AI95-00229-01AI95-00229-01} The part about
+          Discussion: {<AI95-00229-01AI95-00229-01>} The part about
           generic bodies is worded in terms of the denoted subprogram,
           not the denoted view; this implies that renaming is invisible
           to this part of the rule.  "Declared within the declarative
@@ -19539,15 +19595,15 @@ P'Access
           conformant.  This rule specifies that subtype conformance is
           required (which also requires matching calling conventions).
           P cannot denote an entry because access-to-subprogram types
-          never have the entry calling convention.  P cannot denote an
+          never have the <entry> calling convention.  P cannot denote an
           enumeration literal or an attribute function because these
           have intrinsic calling conventions.
 
                            _Legality Rules_
 
 33.1/3
-{AI05-0188-1AI05-0188-1} An expression is said to have distributed
-accessibility if it is
+{<AI05-0188-1AI05-0188-1>} An expression is said to have <distributed
+accessibility> if it is
 
 33.2/3
    * a conditional_expression (see *note 4.5.7::); or
@@ -19557,17 +19613,17 @@ accessibility if it is
      expression whose operand has distributed accessibility.
 
 33.4/3
-{AI05-0188-1AI05-0188-1} The statically deeper relationship does not
+{<AI05-0188-1AI05-0188-1>} The statically deeper relationship does not
 apply to the accessibility level of an expression having distributed
 accessibility; that is, such an accessibility level is not considered to
 be statically deeper, nor statically shallower, than any other.
 
 33.5/3
-{AI05-0188-1AI05-0188-1} Any static accessibility requirement that is
+{<AI05-0188-1AI05-0188-1>} Any static accessibility requirement that is
 imposed on an expression that has distributed accessibility (or on its
-type) is instead imposed on the dependent_expressions of the underlying
-conditional_expression.  This rule is applied recursively if a
-dependent_expression also has distributed accessibility.
+type) is instead imposed on the <dependent_>expressions of the
+underlying conditional_expression.  This rule is applied recursively if
+a <dependent_>expression also has distributed accessibility.
 
 33.c/3
           Discussion: This means that any Legality Rule requiring that
@@ -19575,7 +19631,8 @@ dependent_expression also has distributed accessibility.
           of an expression) shall or shall not be statically deeper than
           some other level also applies, in the case where the
           expression has distributed accessibility, to each
-          dependent_expression of the underlying conditional_expression.
+          <dependent_>expression of the underlying
+          conditional_expression.
 
      NOTES
 
@@ -19589,18 +19646,18 @@ dependent_expression also has distributed 
accessibility.
      at all (see *note 4.2::).
 
 35/2
-     92  {AI95-00230-01AI95-00230-01} The predefined operations of an
+     92  {<AI95-00230-01AI95-00230-01>} The predefined operations of an
      access type also include the assignment operation, qualification,
      and membership tests.  Explicit conversion is allowed between
      general access types with matching designated subtypes; explicit
      conversion is allowed between access-to-subprogram types with
-     subtype conformant profiles (see *note 4.6::). Named access types
+     subtype conformant profiles (see *note 4.6::).  Named access types
      have predefined equality operators; anonymous access types do not,
      but they can use the predefined equality operators for
-     universal_access (see *note 4.5.2::).
+     <universal_access> (see *note 4.5.2::).
 
 35.a/2
-          Reason: {AI95-00230-01AI95-00230-01} Anonymous access types
+          Reason: {<AI95-00230-01AI95-00230-01>} Anonymous access types
           can use the universal access equality operators declared in
           Standard, while named access types cannot for compatibility
           reasons.  By not having equality operators for anonymous
@@ -19624,7 +19681,7 @@ dependent_expression also has distributed accessibility.
           Proof: See *note 3.9.2::.
 
 38/2
-     95  {AI95-00254-01AI95-00254-01} The Access attribute for
+     95  {<AI95-00254-01AI95-00254-01>} The Access attribute for
      subprograms and parameters of an anonymous access-to-subprogram
      type may together be used to implement "downward closures" -- that
      is, to pass a more-nested subprogram as a parameter to a
@@ -19656,10 +19713,10 @@ dependent_expression also has distributed 
accessibility.
                               _Examples_
 
 41
-Example of use of the Access attribute:
+<Example of use of the Access attribute:>
 
 42
-     Martha : Person_Name := new Person(F);       -- see *note 3.10.1::
+     Martha : Person_Name := new Person(F);       --< see *note 3.10.1::>
      Cars   : array (1..2) of aliased Car;
         ...
      Martha.Vehicle := Cars(1)'Access;
@@ -19678,7 +19735,7 @@ Example of use of the Access attribute:
                     _Incompatibilities With Ada 95_
 
 42.b/2
-          {AI95-00363-01AI95-00363-01}  Aliased variables are not
+          {<AI95-00363-01AI95-00363-01>}  Aliased variables are not
           necessarily constrained in Ada 2005 (see *note 3.6::).
           Therefore, a subcomponent of an aliased variable may disappear
           or change shape, and taking 'Access of such a subcomponent
@@ -19701,23 +19758,23 @@ Example of use of the Access attribute:
 
 42.d/2
                A_T : aliased T1;
-               Ptr : Acc_Int := A_T.C1'Access; -- Illegal in Ada 2005, legal 
in Ada 95
-               A_T := (D1 => True);            -- Raised Constraint_Error in 
Ada 95, but does not
-                                               -- in Ada 2005, so Ptr would 
become invalid when this
-                                               -- is assigned (thus Ptr is 
illegal).
+               Ptr : Acc_Int := A_T.C1'Access; -- <Illegal in Ada 2005, legal 
in Ada 95>
+               A_T := (D1 => True);            -- <Raised Constraint_Error in 
Ada 95, but does not>
+                                               -- <in Ada 2005, so Ptr would 
become invalid when this>
+                                               -- <is assigned (thus Ptr is 
illegal).>
 
 42.e/2
-          {AI95-00363-01AI95-00363-01} If a discriminated full type has
-          a partial view (private type) that is constrained, we do not
-          allow 'Access on objects to create a value of an object of an
-          access-to-unconstrained type.  Ada 95 allowed this attribute
-          and various access subtypes, requiring that the heap object be
-          constrained and thus making details of the implementation of
-          the private type visible to the client of the private type.
-          See *note 4.8:: for more on this topic.
+          {<AI95-00363-01AI95-00363-01>} If a discriminated full type
+          has a partial view (private type) that is constrained, we do
+          not allow 'Access on objects to create a value of an object of
+          an access-to-unconstrained type.  Ada 95 allowed this
+          attribute and various access subtypes, requiring that the heap
+          object be constrained and thus making details of the
+          implementation of the private type visible to the client of
+          the private type.  See *note 4.8:: for more on this topic.
 
 42.f/2
-          {AI95-00229-01AI95-00229-01} {AI95-00254-01AI95-00254-01}
+          {<AI95-00229-01AI95-00229-01>} {<AI95-00254-01AI95-00254-01>}
           Amendment Correction: Taking 'Access of a subprogram declared
           in a generic unit in the body of that generic is no longer
           allowed.  Such references can easily be used to create
@@ -19733,14 +19790,14 @@ Example of use of the Access attribute:
                         _Extensions to Ada 95_
 
 42.g/2
-          {8652/00108652/0010} {AI95-00127-01AI95-00127-01} Corrigendum:
-          Access attributes of objects of class-wide types can be used
-          as the controlling parameter in a dispatching calls (see *note
-          3.9.2::).  This was an oversight in Ada 95.
+          {<8652/00108652/0010>} {<AI95-00127-01AI95-00127-01>}
+          Corrigendum: Access attributes of objects of class-wide types
+          can be used as the controlling parameter in a dispatching
+          calls (see *note 3.9.2::).  This was an oversight in Ada 95.
 
 42.h/2
-          {AI95-00235-01AI95-00235-01} Amendment Correction: The type of
-          the prefix can now be used in resolving Access attributes.
+          {<AI95-00235-01AI95-00235-01>} Amendment Correction: The type
+          of the prefix can now be used in resolving Access attributes.
           This allows more uses of the Access attribute to resolve.  For
           example:
 
@@ -19756,8 +19813,8 @@ Example of use of the Access attribute:
                Value : aliased Integer := 10;
 
 42.l/2
-               Result1 : Float := Zap (Value'access); -- Ambiguous in Ada 95; 
resolves in Ada 2005.
-               Result2 : Float := Zap (Int_Ptr'(Value'access)); -- Resolves in 
Ada 95 and Ada 2005.
+               Result1 : Float := Zap (Value'access); -- <Ambiguous in Ada 95; 
resolves in Ada 2005.>
+               Result2 : Float := Zap (Int_Ptr'(Value'access)); -- <Resolves 
in Ada 95 and Ada 2005.>
 
 42.m/2
           This change is upward compatible; any expression that does not
@@ -19766,19 +19823,19 @@ Example of use of the Access attribute:
                      _Wording Changes from Ada 95_
 
 42.n/2
-          {AI95-00162-01AI95-00162-01} Adjusted the wording to reflect
+          {<AI95-00162-01AI95-00162-01>} Adjusted the wording to reflect
           the fact that expressions and function calls are masters.
 
 42.o/2
-          {AI95-00230-01AI95-00230-01} {AI95-00254-01AI95-00254-01}
-          {AI95-00318-02AI95-00318-02} {AI95-00385-01AI95-00385-01}
-          {AI95-00416-01AI95-00416-01} Defined the accessibility of the
-          various new kinds and uses of anonymous access types.
+          {<AI95-00230-01AI95-00230-01>} {<AI95-00254-01AI95-00254-01>}
+          {<AI95-00318-02AI95-00318-02>} {<AI95-00385-01AI95-00385-01>}
+          {<AI95-00416-01AI95-00416-01>} Defined the accessibility of
+          the various new kinds and uses of anonymous access types.
 
                    _Incompatibilities With Ada 2005_
 
 42.p/3
-          {AI05-0008-1AI05-0008-1} Correction: Simplified the
+          {<AI05-0008-1AI05-0008-1>} Correction: Simplified the
           description of when a discriminant-dependent component is
           allowed as the prefix of 'Access to when the object is known
           to be constrained.  This fixes a confusion as to whether a
@@ -19791,9 +19848,9 @@ Example of use of the Access attribute:
           constrained.
 
 42.q/3
-          {AI05-0041-1AI05-0041-1} Correction: Corrected the checks for
-          the constrainedness of the prefix of the Access attribute so
-          that assume-the-worst is used in generic bodies.  This may
+          {<AI05-0041-1AI05-0041-1>} Correction: Corrected the checks
+          for the constrainedness of the prefix of the Access attribute
+          so that assume-the-worst is used in generic bodies.  This may
           make some programs illegal, but those programs were at risk
           having objects disappear while valid access values still
           pointed at them.
@@ -19801,63 +19858,64 @@ Example of use of the Access attribute:
                        _Extensions to Ada 2005_
 
 42.r/3
-          {AI05-0082-1AI05-0082-1} Correction: Eliminated the static
+          {<AI05-0082-1AI05-0082-1>} Correction: Eliminated the static
           accessibility definition for generic formal types, as the
           actual can be more or less nested than the generic itself.
           This allows programs that were illegal for Ada 95 and for Ada
           2005.
 
 42.s/3
-          {AI05-0148-1AI05-0148-1} {AI05-0253-1AI05-0253-1} Eliminate
-          the static accessibility definition for stand-alone objects of
-          anonymous access-to-object types.  This allows such objects to
-          be used as temporaries without causing accessibility problems.
+          {<AI05-0148-1AI05-0148-1>} {<AI05-0253-1AI05-0253-1>}
+          Eliminate the static accessibility definition for stand-alone
+          objects of anonymous access-to-object types.  This allows such
+          objects to be used as temporaries without causing
+          accessibility problems.
 
                     _Wording Changes from Ada 2005_
 
 42.t/3
-          {AI05-0014-1AI05-0014-1} Correction: Corrected the rules so
+          {<AI05-0014-1AI05-0014-1>} Correction: Corrected the rules so
           that the accessibility of the object designated by an access
           object is that of the access type, even when no dereference is
           given.  The accessibility was not specified in the past.  This
           correction applies to both Ada 95 and Ada 2005.
 
 42.u/3
-          {AI05-0024-1AI05-0024-1} Correction: Corrected accessibility
+          {<AI05-0024-1AI05-0024-1>} Correction: Corrected accessibility
           rules for access discriminants so that no cases are omitted.
 
 42.v/3
-          {AI05-0051-1AI05-0051-1} {AI05-0234-1AI05-0234-1}
-          {AI05-0235-1AI05-0235-1} {AI05-0284-1AI05-0284-1} Correction:
-          Corrected accessibility rules for anonymous access return
-          types and access discriminants in return statements.
+          {<AI05-0051-1AI05-0051-1>} {<AI05-0234-1AI05-0234-1>}
+          {<AI05-0235-1AI05-0235-1>} {<AI05-0284-1AI05-0284-1>}
+          Correction: Corrected accessibility rules for anonymous access
+          return types and access discriminants in return statements.
 
 42.w/3
-          {AI05-0066-1AI05-0066-1} Correction: Changed coextension rules
-          so that coextensions that belong to an anonymous object are
-          transfered to the ultimate object.
+          {<AI05-0066-1AI05-0066-1>} Correction: Changed coextension
+          rules so that coextensions that belong to an anonymous object
+          are transfered to the ultimate object.
 
 42.x/3
-          {AI05-0142-4AI05-0142-4} {AI05-0188-1AI05-0188-1}
-          {AI05-0235-1AI05-0235-1} Defined the accessibility of
+          {<AI05-0142-4AI05-0142-4>} {<AI05-0188-1AI05-0188-1>}
+          {<AI05-0235-1AI05-0235-1>} Defined the accessibility of
           explicitly aliased parameters (see *note 6.1::) and
           conditional_expressions (see *note 4.5.7::).
 
 42.y/3
-          {AI05-0234-1AI05-0234-1} Correction: Defined the term "master
-          of the call" to simplify other wording, especially that for
-          the accessibility checks associated with return statements and
-          explicitly aliased parameters.
+          {<AI05-0234-1AI05-0234-1>} Correction: Defined the term
+          "master of the call" to simplify other wording, especially
+          that for the accessibility checks associated with return
+          statements and explicitly aliased parameters.
 
 42.z/3
-          {AI05-0270-1AI05-0270-1} Correction: Defined the (omitted)
+          {<AI05-0270-1AI05-0270-1>} Correction: Defined the (omitted)
           accessibility level of null values when those are passed as
           the actual of an access-to-object parameter.
 
                    _Incompatibilities With Ada 2012_
 
 42.aa/4
-          {AI12-0027-1AI12-0027-1} Corrigendum: Defined the
+          {<AI12-0027-1AI12-0027-1>} Corrigendum: Defined the
           accessibility of a value conversion, so that it is treated
           like an aggregate built at the point of the conversion.  This
           was previously unspecified, so this change might be
@@ -19875,31 +19933,31 @@ Example of use of the Access attribute:
                     _Wording Changes from Ada 2012_
 
 42.bb/4
-          {AI12-0067-1AI12-0067-1} Corrigendum: Corrected so that it is
-          clear that explicitly aliased parameters in procedures have
+          {<AI12-0067-1AI12-0067-1>} Corrigendum: Corrected so that it
+          is clear that explicitly aliased parameters in procedures have
           the same accessibility as other parameters.  Only explicitly
           aliased parameters in functions are special.
 
 42.cc/4
-          {AI12-0070-1AI12-0070-1} Corrigendum: The accessibility of an
-          anonymous access type of an extended_return_statement is
+          {<AI12-0070-1AI12-0070-1>} Corrigendum: The accessibility of
+          an anonymous access type of an extended_return_statement is
           defined here rather than in *note 6.5:: so that all
           accessibility rules are here.
 
 42.dd/4
-          {AI12-0089-1AI12-0089-1} Corrigendum: Corrected a number of
+          {<AI12-0089-1AI12-0089-1>} Corrigendum: Corrected a number of
           rules so that they clearly apply to generic functions as well
           as functions.  (Remember, a generic function is not a
           function.)
 
 42.ee/4
-          {AI12-0095-1AI12-0095-1} Corrigendum: Moved the assume the
+          {<AI12-0095-1AI12-0095-1>} Corrigendum: Moved the assume the
           worst rule about constrainedness of the prefix of attribute
           Access to *note 12.5.1::, as a number of places in the
           Standard need this rule.
 
 42.ff/4
-          {AI12-0157-1AI12-0157-1} Corrigendum: Ensured that the
+          {<AI12-0157-1AI12-0157-1>} Corrigendum: Ensured that the
           statically deeper relationship applies within the return
           expression of an expression function.  (Dynamic properties
           apply by equivalence, but static properties are handled
@@ -19924,7 +19982,7 @@ File: aarm2012.info,  Node: 3.11,  Prev: 3.10,  Up: 3
          basic_declarative_item | body
 
 4/1
-     {8652/00098652/0009} {AI95-00137-01AI95-00137-01}
+     {<8652/00098652/0009>} {<AI95-00137-01AI95-00137-01>}
      basic_declarative_item ::=
          basic_declaration | aspect_clause | use_clause
 
@@ -19938,8 +19996,9 @@ File: aarm2012.info,  Node: 3.11,  Prev: 3.10,  Up: 3
                           _Static Semantics_
 
 6.1/2
-{AI95-00420-01AI95-00420-01} The list of declarative_items of a
-declarative_part is called the declaration list of the declarative_part.
+{<AI95-00420-01AI95-00420-01>} The list of declarative_items of a
+declarative_part is called the <declaration list> of the
+declarative_part.
 
                           _Dynamic Semantics_
 
@@ -19949,8 +20008,9 @@ declarative_items, if any, in the order in which they 
are given in the
 declarative_part.
 
 8
-An elaborable construct is in the elaborated state after the normal
-completion of its elaboration.  Prior to that, it is not yet elaborated.
+An elaborable construct is in the <elaborated> state after the normal
+completion of its elaboration.  Prior to that, it is <not yet
+elaborated>.
 
 8.a
           Ramification: The elaborated state is only important for
@@ -19971,8 +20031,8 @@ For a construct that attempts to use a body, a check 
(Elaboration_Check)
 is performed, as follows:
 
 10/1
-   * {8652/00148652/0014} {AI95-00064-01AI95-00064-01} For a call to a
-     (non-protected) subprogram that has an explicit body, a check is
+   * {<8652/00148652/0014>} {<AI95-00064-01AI95-00064-01>} For a call to
+     a (non-protected) subprogram that has an explicit body, a check is
      made that the body is already elaborated.  This check and the
      evaluations of any actual parameters of the call are done in an
      arbitrary order.
@@ -19987,15 +20047,15 @@ is performed, as follows:
           applies to generic instantiation as well (see below).
 
 10.a.1/3
-          {8652/00148652/0014} {AI95-00064-01AI95-00064-01}
-          {AI05-0177-1AI05-0177-1} A subprogram can be completed by a
+          {<8652/00148652/0014>} {<AI95-00064-01AI95-00064-01>}
+          {<AI05-0177-1AI05-0177-1>} A subprogram can be completed by a
           renaming-as-body, a null_procedure_declaration, or an
           expression_function_declaration, and we need to make an
           elaboration check on such a body, so we use "body" rather than
           subprogram_body above.
 
 11/3
-   * {AI05-0229-1AI05-0229-1} For a call to a protected operation of a
+   * {<AI05-0229-1AI05-0229-1>} For a call to a protected operation of a
      protected type (that has a body -- no check is performed if the
      protected type is imported -- see *note B.1::), a check is made
      that the protected_body is already elaborated.  This check and the
@@ -20048,7 +20108,7 @@ The exception Program_Error is raised if any of these 
checks fails.
                         _Extensions to Ada 83_
 
 14.a/2
-          {AI95-00114-01AI95-00114-01} The syntax for declarative_part
+          {<AI95-00114-01AI95-00114-01>} The syntax for declarative_part
           is modified to remove the ordering restrictions of Ada 83;
           that is, the distinction between basic_declarative_items and
           later_declarative_items within declarative_parts is removed.
@@ -20087,17 +20147,18 @@ The exception Program_Error is raised if any of these 
checks fails.
                      _Wording Changes from Ada 95_
 
 14.f/2
-          {8652/00098652/0009} {AI95-00137-01AI95-00137-01} Corrigendum:
-          Changed representation clauses to aspect clauses to reflect
-          that they are used for more than just representation.
+          {<8652/00098652/0009>} {<AI95-00137-01AI95-00137-01>}
+          Corrigendum: Changed representation clauses to aspect clauses
+          to reflect that they are used for more than just
+          representation.
 
 14.g/2
-          {8652/00148652/0014} {AI95-00064-01AI95-00064-01} Corrigendum:
-          Clarified that the elaboration check applies to all kinds of
-          subprogram bodies.
+          {<8652/00148652/0014>} {<AI95-00064-01AI95-00064-01>}
+          Corrigendum: Clarified that the elaboration check applies to
+          all kinds of subprogram bodies.
 
 14.h/2
-          {AI95-00420-01AI95-00420-01} Defined "declaration list" to
+          {<AI95-00420-01AI95-00420-01>} Defined "declaration list" to
           avoid confusion for various rules.  Other kinds of declaration
           list are defined elsewhere.
 
@@ -20112,12 +20173,12 @@ File: aarm2012.info,  Node: 3.11.1,  Up: 3.11
 ----------------------------------
 
 1/3
-{8652/00148652/0014} {AI95-00064-01AI95-00064-01}
-{AI05-0177-1AI05-0177-1} Declarations sometimes come in two parts. A
-declaration that requires a second part is said to require completion.
-The second part is called the completion of the declaration (and of the
-entity declared), and is either another declaration, a body, or a
-pragma.  A body is a body, an entry_body, a null_procedure_declaration
+{<8652/00148652/0014>} {<AI95-00064-01AI95-00064-01>}
+{<AI05-0177-1AI05-0177-1>} Declarations sometimes come in two parts.  A
+declaration that requires a second part is said to <require completion>.
+The second part is called the <completion> of the declaration (and of
+the entity declared), and is either another declaration, a body, or a
+pragma.  A <body> is a body, an entry_body, a null_procedure_declaration
 or an expression_function_declaration that completes another
 declaration, or a renaming-as-body (see *note 8.5.4::).
 
@@ -20147,16 +20208,16 @@ declaration, or a renaming-as-body (see *note 
8.5.4::).
           Note that the declaration of a private type (if limited) can
           be completed with the declaration of a task type, which is
           then completed with a body.  Thus, a declaration can actually
-          come in three parts.
+          come in <three> parts.
 
 1.h/3
-          {AI95-00217-06AI95-00217-06} {AI05-0162-1AI05-0162-1} An
+          {<AI95-00217-06AI95-00217-06>} {<AI05-0162-1AI05-0162-1>} An
           incomplete type (whether declared in the limited view of a
           package or not) may be completed by a private type
-          declaration, so we can in fact have four parts.
+          declaration, so we can in fact have <four> parts.
 
 1.i/3
-          {AI05-0229-1AI05-0229-1} In Ada 2012, there are no
+          {<AI05-0229-1AI05-0229-1>} In Ada 2012, there are no
           language-defined pragmas that act as completions.  Pragma
           Import (which is obsolescent) has the effect of setting aspect
           Import to True; such an aspect makes giving a completion
@@ -20181,34 +20242,34 @@ a prior declaration only if:
 
 5
    * If the declaration is overloadable, then the completion either has
-     a type-conformant profile, or is a pragma. 
+     a type-conformant profile, or is a pragma.  
 
                            _Legality Rules_
 
 6/3
-{AI05-0229-1AI05-0229-1} An implicit declaration shall not have a
-completion. For any explicit declaration that is specified to require
-completion, there shall be a corresponding explicit completion, unless
+{<AI05-0229-1AI05-0229-1>} An implicit declaration shall not have a
+completion.  For any explicit declaration that is specified to <require
+completion>, there shall be a corresponding explicit completion, unless
 the declared entity is imported (see *note B.1::).
 
 6.a.1/2
-          To be honest: {AI95-00217-06AI95-00217-06} The implicit
+          To be honest: {<AI95-00217-06AI95-00217-06>} The implicit
           declarations occurring in a limited view do have a completion
           (the explicit declaration occurring in the full view) but
           that's a special case, since the implicit declarations are
-          actually built from the explicit ones.  So they do not require
-          a completion, they have one by fiat.
+          actually built from the explicit ones.  So they do not
+          <require> a completion, they have one by <fiat>.
 
 6.a/3
-          Discussion: {AI05-0299-1AI05-0299-1} The implicit declarations
-          of predefined operators are not allowed to have a completion.
-          Enumeration literals, although they are subprograms, are not
-          allowed to have a corresponding subprogram_body.  That's
-          because the completion rules are described in terms of
-          constructs (subprogram_declarations) and not entities
-          (subprograms).  When a completion is required, it has to be
-          explicit; the implicit null package_body that Clause *note 7::
-          talks about cannot serve as the completion of a
+          Discussion: {<AI05-0299-1AI05-0299-1>} The implicit
+          declarations of predefined operators are not allowed to have a
+          completion.  Enumeration literals, although they are
+          subprograms, are not allowed to have a corresponding
+          subprogram_body.  That's because the completion rules are
+          described in terms of constructs (subprogram_declarations) and
+          not entities (subprograms).  When a completion is required, it
+          has to be explicit; the implicit null package_body that Clause
+          *note 7:: talks about cannot serve as the completion of a
           package_declaration if a completion is required.
 
 7
@@ -20221,13 +20282,13 @@ defined.
 
 7.b
           If the completion of a declaration is also a declaration, then
-          that declaration might have a completion, too.  For example, a
-          limited private type can be completed with a task type, which
-          can then be completed with a task body.  This is not a
+          <that> declaration might have a completion, too.  For example,
+          a limited private type can be completed with a task type,
+          which can then be completed with a task body.  This is not a
           violation of the "at most one completion" rule.
 
 8
-A type is completely defined at a place that is after its full type
+A type is <completely defined> at a place that is after its full type
 definition (if it has one) and after all of its subcomponent types are
 completely defined.  A type shall be completely defined before it is
 frozen (see *note 13.14:: and *note 7.3::).
@@ -20240,14 +20301,14 @@ frozen (see *note 13.14:: and *note 7.3::).
      NOTES
 
 9/3
-     98  {AI05-0229-1AI05-0229-1} Completions are in principle allowed
+     98  {<AI05-0229-1AI05-0229-1>} Completions are in principle allowed
      for any kind of explicit declaration.  However, for some kinds of
      declaration, the only allowed completion is an
      implementation-defined pragma, and implementations are not required
      to have any such pragmas.
 
 9.a/3
-          This paragraph was deleted.{AI05-0229-1AI05-0229-1}
+          <This paragraph was deleted.>{<AI05-0229-1AI05-0229-1>}
 
 10
      99  There are rules that prevent premature uses of declarations
@@ -20270,15 +20331,16 @@ frozen (see *note 13.14:: and *note 7.3::).
                      _Wording Changes from Ada 95_
 
 10.b/2
-          {8652/00148652/0014} {AI95-00064-01AI95-00064-01} Corrigendum:
-          Added a definition of body, which is different than body or
-          body.
+          {<8652/00148652/0014>} {<AI95-00064-01AI95-00064-01>}
+          Corrigendum: Added a definition of <body>, which is different
+          than body or body.
 
                     _Wording Changes from Ada 2005_
 
 10.c/3
-          {AI95-0177-1AI95-0177-1} Added null procedures and expression
-          functions that are completions to the definition of body.
+          {<AI95-0177-1AI95-0177-1>} Added null procedures and
+          expression functions that are completions to the definition of
+          <body>.
 
 
 File: aarm2012.info,  Node: 4,  Next: 5,  Prev: 3,  Up: Top
@@ -20287,8 +20349,9 @@ File: aarm2012.info,  Node: 4,  Next: 5,  Prev: 3,  Up: 
Top
 ***********************
 
 1/3
-{AI05-0299-1AI05-0299-1} [The rules applicable to the different forms of
-name and expression, and to their evaluation, are given in this clause.]
+{<AI05-0299-1AI05-0299-1>} [The rules applicable to the different forms
+of name and expression, and to their evaluation, are given in this
+clause.]
 
 * Menu:
 
@@ -20320,7 +20383,7 @@ foregoing.]
                                _Syntax_
 
 2/3
-     {AI05-0003-1AI05-0003-1} {AI05-0139-2AI05-0139-2} name ::=
+     {<AI05-0003-1AI05-0003-1>} {<AI05-0139-2AI05-0139-2>} name ::=
           direct_name   | explicit_dereference
         | indexed_component   | slice
         | selected_component   | attribute_reference
@@ -20332,10 +20395,10 @@ foregoing.]
      direct_name ::= identifier | operator_symbol
 
 3.a/2
-          Discussion: {AI95-00114-01AI95-00114-01} character_literal is
-          no longer a direct_name.  character_literals are usable even
-          when the corresponding enumeration type declaration is not
-          visible.  See *note 4.2::.
+          Discussion: {<AI95-00114-01AI95-00114-01>} character_literal
+          is no longer a direct_name.  character_literals are usable
+          even when the corresponding enumeration type declaration is
+          not visible.  See *note 4.2::.
 
 4
      prefix ::= name | implicit_dereference
@@ -20347,7 +20410,7 @@ foregoing.]
      implicit_dereference ::= name
 
 7/3
-{AI05-0004-1AI05-0004-1} [Certain forms of name (indexed_components,
+{<AI05-0004-1AI05-0004-1>} [Certain forms of name (indexed_components,
 selected_components, slices, and attribute_references) include a prefix
 that is either itself a name that denotes some related entity, or an
 implicit_dereference of an access value that designates some related
@@ -20356,21 +20419,21 @@ entity.]
                         _Name Resolution Rules_
 
 8
-The name in a dereference (either an implicit_dereference or an
+The name in a <dereference> (either an implicit_dereference or an
 explicit_dereference) is expected to be of any access type.
 
                           _Static Semantics_
 
 9/3
-{AI05-0008-1AI05-0008-1} If the type of the name in a dereference is
-some access-to-object type T, then the dereference denotes a view of an
-object, the nominal subtype of the view being the designated subtype of
-T. If the designated subtype has unconstrained discriminants, the
-(actual) subtype of the view is constrained by the values of the
-discriminants of the designated object, except when there is a partial
-view of the type of the designated subtype that does not have
-discriminants, in which case the dereference is not constrained by its
-discriminant values.
+{<AI05-0008-1AI05-0008-1>} If the type of the name in a dereference is
+some access-to-object type <T>, then the dereference denotes a view of
+an object, the <nominal subtype> of the view being the designated
+subtype of <T>.  If the designated subtype has unconstrained
+discriminants, the (actual) subtype of the view is constrained by the
+values of the discriminants of the designated object, except when there
+is a partial view of the type of the designated subtype that does not
+have discriminants, in which case the dereference is not constrained by
+its discriminant values.
 
 9.a
           Ramification: If the value of the name is the result of an
@@ -20387,7 +20450,7 @@ discriminant values.
           mean the same thing.
 
 9.c/3
-          Reason: {AI05-0008-1AI05-0008-1} The last sentence was not
+          Reason: {<AI05-0008-1AI05-0008-1>} The last sentence was not
           present in Ada 95; it is necessary in Ada 2005 because general
           access types can designate unconstrained objects, which was
           not possible in Ada 95.  Thus, the rules that had this effect
@@ -20395,22 +20458,22 @@ discriminant values.
           don't work in Ada 2005 and we have to say this explicitly.
 
 9.d/3
-          {AI05-0008-1AI05-0008-1} The "except" part of the last
+          {<AI05-0008-1AI05-0008-1>} The "except" part of the last
           sentence prevents privacy "breaking", so that if a private
           type has discriminants only in the full view, they don't
           interfere with freely interassigning values between objects of
           the type, even when the objects live in the heap.
 
 9.e/3
-          Implementation Note: {AI05-0008-1AI05-0008-1} Since we don't
+          Implementation Note: {<AI05-0008-1AI05-0008-1>} Since we don't
           depend on whether the designated object is constrained, it is
           not necessary to include a constrained bit in every object
           that could be designated by a general access type.
 
 10
 If the type of the name in a dereference is some access-to-subprogram
-type S, then the dereference denotes a view of a subprogram, the profile
-of the view being the designated profile of S.
+type <S>, then the dereference denotes a view of a subprogram, the
+<profile> of the view being the designated profile of <S>.
 
 10.a
           Ramification: This means that the formal parameter names and
@@ -20423,46 +20486,46 @@ of the view being the designated profile of S.
                           _Dynamic Semantics_
 
 11/2
-{AI95-00415-01AI95-00415-01} The evaluation of a name determines the
+{<AI95-00415-01AI95-00415-01>} The evaluation of a name determines the
 entity denoted by the name.  This evaluation has no other effect for a
 name that is a direct_name or a character_literal.
 
 12
 [The evaluation of a name that has a prefix includes the evaluation of
-the prefix.] The evaluation of a prefix consists of the evaluation of
+the prefix.]  The evaluation of a prefix consists of the evaluation of
 the name or the implicit_dereference.  The prefix denotes the entity
 denoted by the name or the implicit_dereference.
 
 13
 The evaluation of a dereference consists of the evaluation of the name
 and the determination of the object or subprogram that is designated by
-the value of the name. A check is made that the value of the name is not
-the null access value. Constraint_Error is raised if this check fails.
-The dereference denotes the object or subprogram designated by the value
-of the name.
+the value of the name.  A check is made that the value of the name is
+not the null access value.  Constraint_Error is raised if this check
+fails.  The dereference denotes the object or subprogram designated by
+the value of the name.
 
                               _Examples_
 
 14
-Examples of direct names:
+<Examples of direct names:>
 
 15
-     Pi    -- the direct name of a number    (see *note 3.3.2::)
-     Limit    -- the direct name of a constant    (see *note 3.3.1::)
-     Count    -- the direct name of a scalar variable    (see *note 3.3.1::)
-     Board    -- the direct name of an array variable    (see *note 3.6.1::)
-     Matrix    -- the direct name of a type    (see *note 3.6::)
-     Random    -- the direct name of a function    (see *note 6.1::)
-     Error    -- the direct name of an exception    (see *note 11.1::)
+     Pi    <-- the direct name of a number>    (see *note 3.3.2::)
+     Limit    <-- the direct name of a constant>    (see *note 3.3.1::)
+     Count    <-- the direct name of a scalar variable>    (see *note 3.3.1::)
+     Board    <-- the direct name of an array variable>    (see *note 3.6.1::)
+     Matrix    <-- the direct name of a type>    (see *note 3.6::)
+     Random    <-- the direct name of a function>    (see *note 6.1::)
+     Error    <-- the direct name of an exception>    (see *note 11.1::)
 
 16
-Examples of dereferences:
+<Examples of dereferences:>
 
 17
-     Next_Car.all   --  explicit dereference denoting the object designated by
-                       --  the access variable Next_Car (see *note 3.10.1::)
-     Next_Car.Owner    --  selected component with implicit dereference;
-                       --  same as Next_Car.all.Owner
+     Next_Car.all   --<  explicit dereference denoting the object designated 
by>
+                       --<  the access variable Next_Car (see *note 3.10.1::)>
+     Next_Car.Owner    --<  selected component with implicit dereference;>
+                       --<  same as Next_Car.all.Owner>
 
                         _Extensions to Ada 83_
 
@@ -20493,7 +20556,7 @@ Examples of dereferences:
                      _Wording Changes from Ada 83_
 
 17.c/2
-          {AI95-00114-01AI95-00114-01} Everything of the general
+          {<AI95-00114-01AI95-00114-01>} Everything of the general
           syntactic form name(...)  is now syntactically a name.  In any
           realistic parser, this would be a necessity since
           distinguishing among the various name(...)  constructs
@@ -20540,17 +20603,17 @@ Examples of dereferences:
           that would be a bit radical.
 
 17.g
-          We no longer use the term appropriate for a type since we now
-          describe the semantics of a prefix in terms of implicit
+          We no longer use the term <appropriate for a type> since we
+          now describe the semantics of a prefix in terms of implicit
           dereference.
 
                        _Extensions to Ada 2005_
 
 17.h/3
-          {AI05-0003-1AI05-0003-1} A qualified_expression is now a name
-          denoting a constant view; this allows them to be used as a
-          prefix and to be renamed as an object.  They are often used to
-          remove ambiguity from function calls, and there may be no
+          {<AI05-0003-1AI05-0003-1>} A qualified_expression is now a
+          name denoting a constant view; this allows them to be used as
+          a prefix and to be renamed as an object.  They are often used
+          to remove ambiguity from function calls, and there may be no
           other way to do that.  Interestingly, a type_conversion of a
           qualified_expression is already legal in these contexts, so
           this change mainly reduces clutter by eliminating an otherwise
@@ -20559,14 +20622,14 @@ Examples of dereferences:
                     _Wording Changes from Ada 2005_
 
 17.i/3
-          {AI05-0008-1AI05-0008-1} Correction: Added a missing rule so
+          {<AI05-0008-1AI05-0008-1>} Correction: Added a missing rule so
           that most dereferences are assumed constrained (without
           determining whether the designated object is).  This is just
           confirming the Ada 95 rules; Ada 2005 failed to ensure that
           this property was unchanged.
 
 17.j/3
-          {AI05-0139-2AI05-0139-2} {AI05-0299-1AI05-0299-1} Added
+          {<AI05-0139-2AI05-0139-2>} {<AI05-0299-1AI05-0299-1>} Added
           generalized_reference and generalized_indexing as types of
           name; these are documented as extensions in the appropriate
           subclauses.
@@ -20588,7 +20651,7 @@ File: aarm2012.info,  Node: 4.1.1,  Next: 4.1.2,  Up: 
4.1
 
 1
 [An indexed_component denotes either a component of an array or an entry
-in a family of entries. ]
+in a family of entries.  ]
 
                                _Syntax_
 
@@ -20611,7 +20674,7 @@ The expected type for each expression is the 
corresponding index type.
 
 5
 When the prefix denotes an array, the indexed_component denotes the
-component of the array with the specified index value(s). The nominal
+component of the array with the specified index value(s).  The nominal
 subtype of the indexed_component is the component subtype of the array
 type.
 
@@ -20624,28 +20687,28 @@ the individual entry of the entry family with the 
specified index value.
 7
 For the evaluation of an indexed_component, the prefix and the
 expressions are evaluated in an arbitrary order.  The value of each
-expression is converted to the corresponding index type. A check is made
-that each index value belongs to the corresponding index range of the
-array or entry family denoted by the prefix. Constraint_Error is raised
-if this check fails.
+expression is converted to the corresponding index type.  A check is
+made that each index value belongs to the corresponding index range of
+the array or entry family denoted by the prefix.  Constraint_Error is
+raised if this check fails.
 
                               _Examples_
 
 8
-Examples of indexed components:
+<Examples of indexed components:>
 
 9
-      My_Schedule(Sat)     --  a component of a one-dimensional array    (see 
*note 3.6.1::)
-      Page(10)             --  a component of a one-dimensional array    (see 
*note 3.6::)
-      Board(M, J + 1)      --  a component of a two-dimensional array    (see 
*note 3.6.1::)
-      Page(10)(20)         --  a component of a component    (see *note 3.6::)
-      Request(Medium)      --  an entry in a family of entries    (see *note 
9.1::)
-      Next_Frame(L)(M, N)  --  a component of a function call    (see *note 
6.1::)
+      My_Schedule(Sat)     --<  a component of a one-dimensional array    (see 
*note 3.6.1::)>
+      Page(10)             --<  a component of a one-dimensional array    (see 
*note 3.6::)>
+      Board(M, J + 1)      --<  a component of a two-dimensional array    (see 
*note 3.6.1::)>
+      Page(10)(20)         --<  a component of a component    (see *note 
3.6::)>
+      Request(Medium)      --<  an entry in a family of entries    (see *note 
9.1::)>
+      Next_Frame(L)(M, N)  --<  a component of a function call    (see *note 
6.1::)>
 
      NOTES
 
 10
-     1  Notes on the examples: Distinct notations are used for
+     1  <Notes on the examples:> Distinct notations are used for
      components of multidimensional arrays (such as Board) and arrays of
      arrays (such as Page).  The components of an array of arrays are
      arrays and can therefore be indexed.  Thus Page(10)(20) denotes the
@@ -20695,10 +20758,10 @@ defined by the discrete_range.
 
 7
 For the evaluation of a slice, the prefix and the discrete_range are
-evaluated in an arbitrary order. If the slice is not a null slice (a
+evaluated in an arbitrary order.  If the slice is not a <null slice> (a
 slice where the discrete_range is a null range), then a check is made
 that the bounds of the discrete_range belong to the index range of the
-array denoted by the prefix. Constraint_Error is raised if this check
+array denoted by the prefix.  Constraint_Error is raised if this check
 fails.
 
      NOTES
@@ -20728,16 +20791,16 @@ fails.
                               _Examples_
 
 10
-Examples of slices:
+<Examples of slices:>
 
 11
-       Stars(1 .. 15)        --  a slice of 15 characters    (see *note 
3.6.3::)
-       Page(10 .. 10 + Size) --  a slice of 1 + Size components    (see *note 
3.6::)
-       Page(L)(A .. B)       --  a slice of the array Page(L)    (see *note 
3.6::)
-       Stars(1 .. 0)         --  a null slice    (see *note 3.6.3::)
-       My_Schedule(Weekday)  --  bounds given by subtype    (see *note 3.6.1:: 
and *note 3.5.1::)
-       Stars(5 .. 15)(K)     --  same as Stars(K)    (see *note 3.6.3::)
-                             --  provided that K is in 5 .. 15
+       Stars(1 .. 15)        --<  a slice of 15 characters    (see *note 
3.6.3::)>
+       Page(10 .. 10 + Size) --<  a slice of 1 + Size components    (see *note 
3.6::)>
+       Page(L)(A .. B)       --<  a slice of the array Page(L)    (see *note 
3.6::)>
+       Stars(1 .. 0)         --<  a null slice    (see *note 3.6.3::)>
+       My_Schedule(Weekday)  --<  bounds given by subtype    (see *note 
3.6.1:: and *note 3.5.1::)>
+       Stars(5 .. 15)(K)     --<  same as Stars(K)    (see *note 3.6.3::)>
+                             --<  provided that K is in 5 .. 15>
 
 
 File: aarm2012.info,  Node: 4.1.3,  Next: 4.1.4,  Prev: 4.1.2,  Up: 4.1
@@ -20748,7 +20811,7 @@ File: aarm2012.info,  Node: 4.1.3,  Next: 4.1.4,  Prev: 
4.1.2,  Up: 4.1
 1
 [Selected_components are used to denote components (including
 discriminants), entries, entry families, and protected subprograms; they
-are also used as expanded names as described below. ]
+are also used as expanded names as described below.  ]
 
                                _Syntax_
 
@@ -20761,7 +20824,7 @@ are also used as expanded names as described below. ]
                         _Name Resolution Rules_
 
 4
-A selected_component is called an expanded name if, according to the
+A selected_component is called an <expanded name> if, according to the
 visibility rules, at least one possible interpretation of its prefix
 denotes a package or an enclosing named construct (directly, not through
 a subprogram_renaming_declaration or generic_renaming_declaration).
@@ -20792,13 +20855,13 @@ denote one of the following:
      the corresponding component of the object or value.
 
 7.a/3
-          Reason: {AI05-0005-1AI05-0005-1} The components of a protected
-          object cannot be named except by an expanded name, even from
-          within the corresponding protected body.  The protected body
-          cannot reference the private components of some arbitrary
-          object of the protected type; the protected body may reference
-          components of the current instance only (by an expanded name
-          or a direct_name).
+          Reason: {<AI05-0005-1AI05-0005-1>} The components of a
+          protected object cannot be named except by an expanded name,
+          even from within the corresponding protected body.  The
+          protected body cannot reference the private components of some
+          arbitrary object of the protected type; the protected body may
+          reference components of the current instance only (by an
+          expanded name or a direct_name).
 
 7.b
           Ramification: Only the discriminants and components visible at
@@ -20825,34 +20888,34 @@ denote one of the following:
           (and expanded name notation has to be used for that).
 
 9.1/2
-   * {AI95-00252-01AI95-00252-01} {AI95-00407-01AI95-00407-01} A view of
-     a subprogram whose first formal parameter is of a tagged type or is
-     an access parameter whose designated type is tagged:
+   * {<AI95-00252-01AI95-00252-01>} {<AI95-00407-01AI95-00407-01>} A
+     view of a subprogram whose first formal parameter is of a tagged
+     type or is an access parameter whose designated type is tagged:
 
 9.2/3
-     {AI95-00252-01AI95-00252-01} {AI95-00407-01AI95-00407-01}
-     {AI05-0090-1AI05-0090-1} The prefix (after any implicit
+     {<AI95-00252-01AI95-00252-01>} {<AI95-00407-01AI95-00407-01>}
+     {<AI05-0090-1AI05-0090-1>} The prefix (after any implicit
      dereference) shall resolve to denote an object or value of a
-     specific tagged type T or class-wide type T'Class.  The
+     specific tagged type <T> or class-wide type <T>'Class.  The
      selector_name shall resolve to denote a view of a subprogram
      declared immediately within the declarative region in which an
-     ancestor of the type T is declared.  The first formal parameter of
-     the subprogram shall be of type T, or a class-wide type that covers
-     T, or an access parameter designating one of these types.  The
-     designator of the subprogram shall not be the same as that of a
+     ancestor of the type <T> is declared.  The first formal parameter
+     of the subprogram shall be of type <T>, or a class-wide type that
+     covers <T>, or an access parameter designating one of these types.
+     The designator of the subprogram shall not be the same as that of a
      component of the tagged type visible at the point of the
      selected_component.  The subprogram shall not be an implicitly
-     declared primitive operation of type T that overrides an inherited
-     subprogram implemented by an entry or protected subprogram visible
-     at the point of the selected_component.  The selected_component
-     denotes a view of this subprogram that omits the first formal
-     parameter.  This view is called a prefixed view of the subprogram,
-     and the prefix of the selected_component (after any implicit
-     dereference) is called the prefix of the prefixed view. 
+     declared primitive operation of type <T> that overrides an
+     inherited subprogram implemented by an entry or protected
+     subprogram visible at the point of the selected_component.  The
+     selected_component denotes a view of this subprogram that omits the
+     first formal parameter.  This view is called a <prefixed view> of
+     the subprogram, and the prefix of the selected_component (after any
+     implicit dereference) is called the <prefix> of the prefixed view.     
 
 9.b/3
-          Discussion: {AI05-0090-1AI05-0090-1} The part of the rule that
-          excludes a primitive overriding subprogram as a selector
+          Discussion: {<AI05-0090-1AI05-0090-1>} The part of the rule
+          that excludes a primitive overriding subprogram as a selector
           applies only to the wrapper subprogram that is implicitly
           declared to override a subprogram inherited from a
           synchronized interface that is implemented by an operation of
@@ -20905,12 +20968,12 @@ immediately within a named declarative region, as 
follows:
                            _Legality Rules_
 
 13.1/2
-{AI95-00252-01AI95-00252-01} {AI95-00407-01AI95-00407-01} For a
+{<AI95-00252-01AI95-00252-01>} {<AI95-00407-01AI95-00407-01>} For a
 subprogram whose first parameter is an access parameter, the prefix of
 any prefixed view shall denote an aliased view of an object.
 
 13.2/2
-{AI95-00407-01AI95-00407-01} For a subprogram whose first parameter is
+{<AI95-00407-01AI95-00407-01>} For a subprogram whose first parameter is
 of mode in out or out, or of an anonymous access-to-variable type, the
 prefix of any prefixed view shall denote a variable.
 
@@ -20932,36 +20995,36 @@ prefix.
 15
 For a selected_component that denotes a component of a variant, a check
 is made that the values of the discriminants are such that the value or
-object denoted by the prefix has this component. The exception
+object denoted by the prefix has this component.  The exception
 Constraint_Error is raised if this check fails.
 
                               _Examples_
 
 16
-Examples of selected components:
+<Examples of selected components:>
 
 17/2
-     {AI95-00252-01AI95-00252-01} {AI95-00407-01AI95-00407-01}   
Tomorrow.Month     --  a record component    (see *note 3.8::)
-       Next_Car.Owner     --  a record component    (see *note 3.10.1::)
-       Next_Car.Owner.Age --  a record component    (see *note 3.10.1::)
-                          --  the previous two lines involve implicit 
dereferences
-       Writer.Unit        --  a record component (a discriminant)    (see 
*note 3.8.1::)
-       Min_Cell(H).Value  --  a record component of the result    (see *note 
6.1::)
-                          --  of the function call Min_Cell(H)
-       Cashier.Append     --  a prefixed view of a procedure    (see *note 
3.9.4::)
-       Control.Seize      --  an entry of a protected object    (see *note 
9.4::)
-       Pool(K).Write      --  an entry of the task Pool(K)    (see *note 9.4::)
+     {<AI95-00252-01AI95-00252-01>} {<AI95-00407-01AI95-00407-01>}   
Tomorrow.Month     --<  a record component    (see *note 3.8::)>
+       Next_Car.Owner     --<  a record component    (see *note 3.10.1::)>
+       Next_Car.Owner.Age --<  a record component    (see *note 3.10.1::)>
+                          --<  the previous two lines involve implicit 
dereferences>
+       Writer.Unit        --<  a record component (a discriminant)    (see 
*note 3.8.1::)>
+       Min_Cell(H).Value  --<  a record component of the result    (see *note 
6.1::)>
+                          --<  of the function call Min_Cell(H)>
+       Cashier.Append     --<  a prefixed view of a procedure    (see *note 
3.9.4::)>
+       Control.Seize      --<  an entry of a protected object    (see *note 
9.4::)>
+       Pool(K).Write      --<  an entry of the task Pool(K)    (see *note 
9.4::)>
 
 18
-Examples of expanded names:
+<Examples of expanded names:>
 
 19
-       Key_Manager."<"      --  an operator of the visible part of a package   
 (see *note 7.3.1::)
-       Dot_Product.Sum      --  a variable declared in a function body    (see 
*note 6.1::)
-       Buffer.Pool          --  a variable declared in a protected unit    
(see *note 9.11::)
-       Buffer.Read          --  an entry of a protected unit    (see *note 
9.11::)
-       Swap.Temp            --  a variable declared in a block statement    
(see *note 5.6::)
-       Standard.Boolean     --  the name of a predefined type    (see *note 
A.1::)
+       Key_Manager."<"      --<  an operator of the visible part of a package  
  (see *note 7.3.1::)>
+       Dot_Product.Sum      --<  a variable declared in a function body    
(see *note 6.1::)>
+       Buffer.Pool          --<  a variable declared in a protected unit    
(see *note 9.11::)>
+       Buffer.Read          --<  an entry of a protected unit    (see *note 
9.11::)>
+       Swap.Temp            --<  a variable declared in a block statement    
(see *note 5.6::)>
+       Standard.Boolean     --<  the name of a predefined type    (see *note 
A.1::)>
 
                         _Extensions to Ada 83_
 
@@ -20995,11 +21058,11 @@ Examples of expanded names:
                         _Extensions to Ada 95_
 
 19.e/2
-          {AI95-00252-01AI95-00252-01} The prefixed view notation for
+          {<AI95-00252-01AI95-00252-01>} The prefixed view notation for
           tagged objects is new.  This provides a similar notation to
           that used in other popular languages, and also reduces the
           need for use_clauses.  This is sometimes known as
-          "distinguished receiver notation". 
+          "distinguished receiver notation".  
 
 19.f/2
           Given the following definitions for a tagged type T:
@@ -21026,9 +21089,10 @@ Examples of expanded names:
                     _Wording Changes from Ada 2005_
 
 19.l/3
-          {AI05-0090-1AI05-0090-1} Correction: Corrected the definition
-          of a prefixed view to ignore the implicit subprograms declared
-          for "implemented by" entries and protected subprograms.
+          {<AI05-0090-1AI05-0090-1>} Correction: Corrected the
+          definition of a prefixed view to ignore the implicit
+          subprograms declared for "implemented by" entries and
+          protected subprograms.
 
 
 File: aarm2012.info,  Node: 4.1.4,  Next: 4.1.5,  Prev: 4.1.3,  Up: 4.1
@@ -21037,7 +21101,7 @@ File: aarm2012.info,  Node: 4.1.4,  Next: 4.1.5,  Prev: 
4.1.3,  Up: 4.1
 ----------------
 
 1
-[An attribute is a characteristic of an entity that can be queried via
+[An <attribute> is a characteristic of an entity that can be queried via
 an attribute_reference (*note 4.1.4: S0100.) or a
 range_attribute_reference (*note 4.1.4: S0102.).]
 
@@ -21047,15 +21111,15 @@ range_attribute_reference (*note 4.1.4: S0102.).]
      attribute_reference ::= prefix'attribute_designator
 
 3/2
-     {AI05-0004-1AI05-0004-1} attribute_designator ::=
-         identifier[(static_expression)]
+     {<AI05-0004-1AI05-0004-1>} attribute_designator ::=
+         identifier[(<static_>expression)]
        | Access | Delta | Digits | Mod
 
 4
      range_attribute_reference ::= prefix'range_attribute_designator
 
 5
-     range_attribute_designator ::= Range[(static_expression)]
+     range_attribute_designator ::= Range[(<static_>expression)]
 
                         _Name Resolution Rules_
 
@@ -21092,19 +21156,19 @@ denotes a function, it is interpreted as a 
parameterless function_call.
           profile of the prefix.
 
 6.d/2
-          {AI95-00114-01AI95-00114-01} Other than the rules given above,
-          the Name Resolution Rules for the prefix of each attribute are
-          defined as Name Resolution Rules for that attribute.  If no
-          such rules are defined, then no context at all should be used
-          when resolving the prefix.  In particular, any knowledge about
-          the kind of entities required must not be used for resolution
-          unless that is required by Name Resolution Rules.  This
-          matters in obscure cases; for instance, given the following
-          declarations:
+          {<AI95-00114-01AI95-00114-01>} Other than the rules given
+          above, the Name Resolution Rules for the prefix of each
+          attribute are defined as Name Resolution Rules for that
+          attribute.  If no such rules are defined, then no context at
+          all should be used when resolving the prefix.  In particular,
+          any knowledge about the kind of entities required must not be
+          used for resolution unless that is required by Name Resolution
+          Rules.  This matters in obscure cases; for instance, given the
+          following declarations:
 
 6.e/2
-                 function Get_It return Integer is ... -- (1)
-                 function Get_It return Some_Record_Type is ... -- (2)
+                 function Get_It return Integer is ... -- <(1)>
+                 function Get_It return Some_Record_Type is ... -- <(2)>
 
 6.f/2
           the following attribute_reference cannot be resolved and is
@@ -21114,7 +21178,7 @@ denotes a function, it is interpreted as a 
parameterless function_call.
                  if Get_It'Valid then
 
 6.h/3
-          {AI05-0005-1AI05-0005-1} even though the Valid attribute is
+          {<AI05-0005-1AI05-0005-1>} even though the Valid attribute is
           only defined for objects of scalar types, and thus cannot be
           applied to the result of function (2).  That information
           cannot be used to resolve the prefix.  The same would be true
@@ -21135,8 +21199,8 @@ range_attribute_designator shall be static.
                           _Static Semantics_
 
 9/4
-{AI05-0006-1AI05-0006-1} {AI12-0032-1AI12-0032-1}
-{AI12-0159-1AI12-0159-1} An attribute_reference denotes a value, an
+{<AI05-0006-1AI05-0006-1>} {<AI12-0032-1AI12-0032-1>}
+{<AI12-0159-1AI12-0159-1>} An attribute_reference denotes a value, an
 object, a subprogram, or some other kind of program entity.  Unless
 explicitly specified otherwise, for an attribute_reference that denotes
 a value or an object, if its type is scalar, then its nominal subtype is
@@ -21157,7 +21221,7 @@ predicate.
           additional attributes.
 
 9.b/3
-          Discussion: {AI05-0006-1AI05-0006-1} The nominal subtype is
+          Discussion: {<AI05-0006-1AI05-0006-1>} The nominal subtype is
           primarily a concern when an attribute_reference, or a call on
           an attribute_reference, is used as the expression of a case
           statement, due to the full coverage requirement based on the
@@ -21166,12 +21230,12 @@ predicate.
           otherwise for implementation-defined attribute functions.
 
 9.c/3
-          The rule is written to match the meaning of the italicized T
+          The rule is written to match the meaning of the italicized <T>
           in the definition of attributes such as Input; see *note
           4.5.1::.
 
 9.d/3
-          To be honest: {AI05-0006-1AI05-0006-1} We don't worry about
+          To be honest: {<AI05-0006-1AI05-0006-1>} We don't worry about
           the fact that "base subtype" is not explicitly defined for the
           universal types.  Since it is not possible to constrain a
           universal numeric type, all subtypes are unconstrained, and
@@ -21197,8 +21261,8 @@ consists of the evaluation of the prefix.
                      _Implementation Permissions_
 
 12/1
-{8652/00158652/0015} {AI95-00093-01AI95-00093-01} An implementation may
-provide implementation-defined attributes; the identifier for an
+{<8652/00158652/0015>} {<AI95-00093-01AI95-00093-01>} An implementation
+may provide implementation-defined attributes; the identifier for an
 implementation-defined attribute shall differ from those of the
 language-defined attributes unless supplied for compatibility with a
 previous edition of this International Standard.
@@ -21218,7 +21282,7 @@ previous edition of this International Standard.
           expression.
 
 12.c.1/1
-          {8652/00158652/0015} {AI95-00093-01AI95-00093-01}
+          {<8652/00158652/0015>} {<AI95-00093-01AI95-00093-01>}
           Implementations are allowed to support the Small attribute for
           floating types, as this was defined in Ada 83, even though the
           name would conflict with a language-defined attribute.
@@ -21230,19 +21294,19 @@ previous edition of this International Standard.
      and are summarized in *note K.2::.
 
 14/2
-     5  {AI95-00235AI95-00235} In general, the name in a prefix of an
+     5  {<AI95-00235AI95-00235>} In general, the name in a prefix of an
      attribute_reference (or a range_attribute_reference) has to be
      resolved without using any context.  However, in the case of the
      Access attribute, the expected type for the attribute_reference has
      to be a single access type, and the resolution of the name can use
      the fact that the type of the object or the profile of the callable
      entity denoted by the prefix has to match the designated type or be
-     type conformant with the designated profile of the access type. 
+     type conformant with the designated profile of the access type.  
 
 14.a/2
-          Proof: {AI95-00235AI95-00235} In the general case, there is no
-          "expected type" for the prefix of an attribute_reference.  In
-          the special case of 'Access, there is an "expected type" or
+          Proof: {<AI95-00235AI95-00235>} In the general case, there is
+          no "expected type" for the prefix of an attribute_reference.
+          In the special case of 'Access, there is an "expected type" or
           "expected profile" for the prefix.
 
 14.b
@@ -21253,17 +21317,17 @@ previous edition of this International Standard.
                               _Examples_
 
 15
-Examples of attributes:
+<Examples of attributes:>
 
 16
-     Color'First        -- minimum value of the enumeration type Color    (see 
*note 3.5.1::)
-     Rainbow'Base'First -- same as Color'First    (see *note 3.5.1::)
-     Real'Digits        -- precision of the type Real    (see *note 3.5.7::)
-     Board'Last(2)      -- upper bound of the second dimension of Board    
(see *note 3.6.1::)
-     Board'Range(1)     -- index range of the first dimension of Board    (see 
*note 3.6.1::)
-     Pool(K)'Terminated -- True if task Pool(K) is terminated    (see *note 
9.1::)
-     Date'Size          -- number of bits for records of type Date    (see 
*note 3.8::)
-     Message'Address    -- address of the record variable Message    (see 
*note 3.7.1::)
+     Color'First        --< minimum value of the enumeration type Color    
(see *note 3.5.1::)>
+     Rainbow'Base'First --< same as Color'First    (see *note 3.5.1::)>
+     Real'Digits        --< precision of the type Real    (see *note 3.5.7::)>
+     Board'Last(2)      --< upper bound of the second dimension of Board    
(see *note 3.6.1::)>
+     Board'Range(1)     --< index range of the first dimension of Board    
(see *note 3.6.1::)>
+     Pool(K)'Terminated --< True if task Pool(K) is terminated    (see *note 
9.1::)>
+     Date'Size          --< number of bits for records of type Date    (see 
*note 3.8::)>
+     Message'Address    --< address of the record variable Message    (see 
*note 3.7.1::)>
 
                         _Extensions to Ada 83_
 
@@ -21272,8 +21336,8 @@ Examples of attributes:
           its use with scalar subtypes.
 
 16.b
-          We allow any integer type in the static_expression of an
-          attribute designator, not just a value of universal_integer.
+          We allow any integer type in the <static_>expression of an
+          attribute designator, not just a value of <universal_integer>.
           The preference rules ensure upward compatibility.
 
                      _Wording Changes from Ada 83_
@@ -21314,33 +21378,33 @@ Examples of attributes:
                      _Wording Changes from Ada 95_
 
 16.h/2
-          {8652/00158652/0015} {AI95-00093-01AI95-00093-01} Corrigendum:
-          The wording was changed to allow implementations to continue
-          to implement the Ada 83 Small attribute.  This was always
-          intended to be allowed.
+          {<8652/00158652/0015>} {<AI95-00093-01AI95-00093-01>}
+          Corrigendum: The wording was changed to allow implementations
+          to continue to implement the Ada 83 Small attribute.  This was
+          always intended to be allowed.
 
 16.i/2
-          {AI95-00235-01AI95-00235-01} The note about resolving prefixes
-          of attributes was updated to reflect that the prefix of an
-          Access attribute now has an expected type (see *note
+          {<AI95-00235-01AI95-00235-01>} The note about resolving
+          prefixes of attributes was updated to reflect that the prefix
+          of an Access attribute now has an expected type (see *note
           3.10.2::).
 
                     _Wording Changes from Ada 2005_
 
 16.j/3
-          {AI05-0006-1AI05-0006-1} Correction: Defined the nominal
+          {<AI05-0006-1AI05-0006-1>} Correction: Defined the nominal
           subtype of an attribute_reference to close a minor language
           hole.
 
                     _Wording Changes from Ada 2012_
 
 16.k/4
-          {AI12-0032-1AI12-0032-1} Corrigendum: Allowed overriding the
+          {<AI12-0032-1AI12-0032-1>} Corrigendum: Allowed overriding the
           nominal subtype of an attribute_reference for an object; that
           is used elsewhere in this standard.
 
 16.l/4
-          {AI12-0159-1AI12-0159-1} Corrigendum: Added wording so it is
+          {<AI12-0159-1AI12-0159-1>} Corrigendum: Added wording so it is
           clear that predicates don't apply to the result of an
           attribute.
 
@@ -21353,23 +21417,23 @@ File: aarm2012.info,  Node: 4.1.5,  Next: 4.1.6,  
Prev: 4.1.4,  Up: 4.1
                           _Static Semantics_
 
 1/3
-{AI05-0139-2AI05-0139-2} Given a discriminated type T, the following
+{<AI05-0139-2AI05-0139-2>} Given a discriminated type <T>, the following
 type-related operational aspect may be specified:
 
 2/3
 Implicit_Dereference
                This aspect is specified by a name that denotes an access
-               discriminant declared for the type T.
+               discriminant declared for the type <T>.
 
 2.a/3
           Aspect Description for Implicit_Dereference: Mechanism for
           user-defined implicit .all.
 
 3/3
-{AI05-0139-2AI05-0139-2} A (view of a) type with a specified
-Implicit_Dereference aspect is a reference type.  A reference object is
-an object of a reference type.  The discriminant named by the
-Implicit_Dereference aspect is the reference discriminant of the
+{<AI05-0139-2AI05-0139-2>} A (view of a) type with a specified
+Implicit_Dereference aspect is a <reference type>.  A <reference object>
+is an object of a reference type.  The discriminant named by the
+Implicit_Dereference aspect is the <reference discriminant> of the
 reference type or reference object.  [A generalized_reference is a name
 that identifies a reference object, and denotes the object or subprogram
 designated by the reference discriminant of the reference object.]
@@ -21382,20 +21446,20 @@ designated by the reference discriminant of the 
reference object.]
                                _Syntax_
 
 4/3
-     {AI05-0139-2AI05-0139-2} generalized_reference ::=
-     reference_object_name
+     {<AI05-0139-2AI05-0139-2>} generalized_reference ::=
+     <reference_object_>name
 
                         _Name Resolution Rules_
 
 5/3
-{AI05-0139-2AI05-0139-2} {AI05-0269-1AI05-0269-1} The expected type for
-the reference_object_name in a generalized_reference is any reference
-type.
+{<AI05-0139-2AI05-0139-2>} {<AI05-0269-1AI05-0269-1>} The expected type
+for the <reference_object_>name in a generalized_reference is any
+reference type.
 
                           _Static Semantics_
 
 5.1/4
-{AI12-0138-1AI12-0138-1} The Implicit_Dereference aspect is
+{<AI12-0138-1AI12-0138-1>} The Implicit_Dereference aspect is
 nonoverridable (see *note 13.1.1::).
 
 5.a/4
@@ -21404,28 +21468,29 @@ nonoverridable (see *note 13.1.1::).
           contract problems with formal derived types.
 
 6/3
-{AI05-0139-2AI05-0139-2} A generalized_reference denotes a view
+{<AI05-0139-2AI05-0139-2>} A generalized_reference denotes a view
 equivalent to that of a dereference of the reference discriminant of the
 reference object.
 
 7/3
-{AI05-0139-2AI05-0139-2} Given a reference type T, the
-Implicit_Dereference aspect is inherited by descendants of type T if not
-overridden.  If a descendant type constrains the value of the reference
-discriminant of T by a new discriminant, that new discriminant is the
-reference discriminant of the descendant.  [If the descendant type
-constrains the value of the reference discriminant of T by an expression
-other than the name of a new discriminant, a generalized_reference that
-identifies an object of the descendant type denotes the object or
-subprogram designated by the value of this constraining expression.]
+{<AI05-0139-2AI05-0139-2>} Given a reference type <T>, the
+Implicit_Dereference aspect is inherited by descendants of type <T> if
+not overridden.  If a descendant type constrains the value of the
+reference discriminant of <T> by a new discriminant, that new
+discriminant is the reference discriminant of the descendant.  [If the
+descendant type constrains the value of the reference discriminant of
+<T> by an expression other than the name of a new discriminant, a
+generalized_reference that identifies an object of the descendant type
+denotes the object or subprogram designated by the value of this
+constraining expression.]
 
                           _Dynamic Semantics_
 
 8/3
-{AI05-0139-2AI05-0139-2} The evaluation of a generalized_reference
-consists of the evaluation of the reference_object_name and a
+{<AI05-0139-2AI05-0139-2>} The evaluation of a generalized_reference
+consists of the evaluation of the <reference_object_>name and a
 determination of the object or subprogram designated by the reference
-discriminant of the named reference object. A check is made that the
+discriminant of the named reference object.  A check is made that the
 value of the reference discriminant is not the null access value.
 Constraint_Error is raised if this check fails.  The
 generalized_reference denotes the object or subprogram designated by the
@@ -21434,41 +21499,41 @@ value of the reference discriminant of the named 
reference object.
                               _Examples_
 
 9/3
-     {AI05-0268-1AI05-0268-1} type Barrel is tagged ...  -- holds objects of 
type Element
+     {<AI05-0268-1AI05-0268-1>} type Barrel is tagged ...  -- <holds objects 
of type Element>
 
 10/3
-     {AI05-0139-2AI05-0139-2} {AI05-0299-1AI05-0299-1} type Ref_Element(Data : 
access Element) is limited private
+     {<AI05-0139-2AI05-0139-2>} {<AI05-0299-1AI05-0299-1>} type 
Ref_Element(Data : access Element) is limited private
         with Implicit_Dereference => Data;
-           -- This Ref_Element type is a "reference" type.
-           -- "Data" is its reference discriminant.
+           -- <This Ref_Element type is a "reference" type.>
+           -- <"Data" is its reference discriminant.>
 
 11/3
-     {AI05-0139-2AI05-0139-2} {AI05-0268-1AI05-0268-1} function Find (B : 
aliased in out Barrel; Key : String) return Ref_Element;
-        -- Return a reference to an element of a barrel.
+     {<AI05-0139-2AI05-0139-2>} {<AI05-0268-1AI05-0268-1>} function Find (B : 
aliased in out Barrel; Key : String) return Ref_Element;
+        -- <Return a reference to an element of a barrel.>
 
 12/3
-     {AI05-0268-1AI05-0268-1} {AI05-0299-1AI05-0299-1} B: aliased Barrel;
+     {<AI05-0268-1AI05-0268-1>} {<AI05-0299-1AI05-0299-1>} B: aliased Barrel;
 
 13/3
-     {AI05-0139-2AI05-0139-2} ...
+     {<AI05-0139-2AI05-0139-2>} ...
 
 14/3
-     {AI05-0139-2AI05-0139-2} {AI05-0268-1AI05-0268-1} Find (B, "grape") := 
Element'(...);  -- Assign through a reference.
+     {<AI05-0139-2AI05-0139-2>} {<AI05-0268-1AI05-0268-1>} Find (B, "grape") 
:= Element'(...);  -- <Assign through a reference.>
 
 15/3
-     {AI05-0139-2AI05-0139-2} {AI05-0268-1AI05-0268-1} -- This is equivalent 
to:
+     {<AI05-0139-2AI05-0139-2>} {<AI05-0268-1AI05-0268-1>} -- <This is 
equivalent to:>
      Find (B, "grape").Data.all := Element'(...);
 
                        _Extensions to Ada 2005_
 
 15.a/3
-          {AI05-0139-2AI05-0139-2} The aspect Implicit_Dereference and
+          {<AI05-0139-2AI05-0139-2>} The aspect Implicit_Dereference and
           the generalized_reference are new.
 
                    _Incompatibilities With Ada 2012_
 
 15.b/4
-          {AI12-0138-1AI12-0138-1} Corrigendum: Defined
+          {<AI12-0138-1AI12-0138-1>} Corrigendum: Defined
           Implicit_Dereference to be nonoveridable, which makes
           redefinitions and hiding of the aspect illegal.  It's possible
           that some program could violate one of these new restrictions,
@@ -21484,18 +21549,18 @@ File: aarm2012.info,  Node: 4.1.6,  Prev: 4.1.5,  Up: 
4.1
                           _Static Semantics_
 
 1/3
-{AI05-0139-2AI05-0139-2} Given a tagged type T, the following
+{<AI05-0139-2AI05-0139-2>} Given a tagged type <T>, the following
 type-related, operational aspects may be specified:
 
 2/3
 Constant_Indexing
                This aspect shall be specified by a name that denotes one
                or more functions declared immediately within the same
-               declaration list in which T is declared.  All such
+               declaration list in which <T> is declared.  All such
                functions shall have at least two parameters, the first
-               of which is of type T or T'Class, or is an
-               access-to-constant parameter with designated type T or
-               T'Class.
+               of which is of type <T> or <T>'Class, or is an
+               access-to-constant parameter with designated type <T> or
+               <T>'Class.
 
 2.a/3
           Aspect Description for Constant_Indexing: Defines function(s)
@@ -21505,13 +21570,13 @@ Constant_Indexing
 Variable_Indexing
                This aspect shall be specified by a name that denotes one
                or more functions declared immediately within the same
-               declaration list in which T is declared.  All such
+               declaration list in which <T> is declared.  All such
                functions shall have at least two parameters, the first
-               of which is of type T or T'Class, or is an access
-               parameter with designated type T or T'Class.  All such
-               functions shall have a return type that is a reference
-               type (see *note 4.1.5::), whose reference discriminant is
-               of an access-to-variable type.
+               of which is of type <T> or <T>'Class, or is an access
+               parameter with designated type <T> or <T>'Class.  All
+               such functions shall have a return type that is a
+               reference type (see *note 4.1.5::), whose reference
+               discriminant is of an access-to-variable type.
 
 3.a/3
           Reason: We require these functions to return a reference type
@@ -21524,8 +21589,8 @@ Variable_Indexing
           to implement user-defined indexed_components.
 
 4/4
-{AI12-0104-1AI12-0104-1} These aspects are inherited by descendants of T
-(including the class-wide type T'Class).
+{<AI12-0104-1AI12-0104-1>} These aspects are inherited by descendants of
+<T> (including the class-wide type <T>'Class).
 
 4.a/3
           Ramification: Indexing can be provided for multiple index
@@ -21536,10 +21601,10 @@ Variable_Indexing
           aspects.
 
 5/3
-{AI05-0139-2AI05-0139-2} {AI05-0292-1AI05-0292-1} An indexable container
-type is (a view of) a tagged type with at least one of the aspects
-Constant_Indexing or Variable_Indexing specified.  An indexable
-container object is an object of an indexable container type.  [A
+{<AI05-0139-2AI05-0139-2>} {<AI05-0292-1AI05-0292-1>} An <indexable
+container type> is (a view of) a tagged type with at least one of the
+aspects Constant_Indexing or Variable_Indexing specified.  An <indexable
+container object> is an object of an indexable container type.  [A
 generalized_indexing is a name that denotes the result of calling a
 function named by a Constant_Indexing or Variable_Indexing aspect.]
 
@@ -21549,7 +21614,7 @@ function named by a Constant_Indexing or 
Variable_Indexing aspect.]
           or Variable_Indexing aspects.
 
 5.1/4
-{AI12-0138-1AI12-0138-1} The Constant_Indexing and Variable_Indexing
+{<AI12-0138-1AI12-0138-1>} The Constant_Indexing and Variable_Indexing
 aspects are nonoverridable (see *note 13.1.1::).
 
 5.a/4
@@ -21558,7 +21623,7 @@ aspects are nonoverridable (see *note 13.1.1::).
           prevents generic contract problems with formal derived types.
 
 5.b/4
-          {AI12-0104-1AI12-0104-1} {AI12-0138-1AI12-0138-1} A
+          {<AI12-0104-1AI12-0104-1>} {<AI12-0138-1AI12-0138-1>} A
           nonoverridable aspect allows the replacement of the
           implementation of an indexing function and the addition of a
           new indexing function for a derived type, but not the removal
@@ -21572,35 +21637,35 @@ aspects are nonoverridable (see *note 13.1.1::).
           be changed from the original body (that's just normal
           dispatching).
 
-Paragraphs 6 through 9 were deleted.
+<Paragraphs 6 through 9 were deleted.>
 
                                _Syntax_
 
 10/3
-     {AI05-0139-2AI05-0139-2} {AI05-0292-1AI05-0292-1}
-     generalized_indexing ::= indexable_container_object_prefix 
+     {<AI05-0139-2AI05-0139-2>} {<AI05-0292-1AI05-0292-1>}
+     generalized_indexing ::= <indexable_container_object_>prefix 
      actual_parameter_part
 
                         _Name Resolution Rules_
 
 11/3
-{AI05-0139-2AI05-0139-2} {AI05-0292-1AI05-0292-1} The expected type for
-the indexable_container_object_prefix of a generalized_indexing is any
-indexable container type.
+{<AI05-0139-2AI05-0139-2>} {<AI05-0292-1AI05-0292-1>} The expected type
+for the <indexable_container_object_>prefix of a generalized_indexing is
+any indexable container type.
 
 12/3
-{AI05-0139-2AI05-0139-2} {AI05-0292-1AI05-0292-1} If the
+{<AI05-0139-2AI05-0139-2>} {<AI05-0292-1AI05-0292-1>} If the
 Constant_Indexing aspect is specified for the type of the
-indexable_container_object_prefix of a generalized_indexing, then the
-generalized_indexing is interpreted as a constant indexing under the
+<indexable_container_object_>prefix of a generalized_indexing, then the
+generalized_indexing is interpreted as a <constant indexing> under the
 following circumstances:
 
 13/3
    * when the Variable_Indexing aspect is not specified for the type of
-     the indexable_container_object_prefix;
+     the <indexable_container_object_>prefix;
 
 14/3
-   * when the indexable_container_object_prefix denotes a constant;
+   * when the <indexable_container_object_>prefix denotes a constant;
 
 15/3
    * when the generalized_indexing is used within a primary where a name
@@ -21608,41 +21673,41 @@ following circumstances:
 
 15.a/3
           Ramification: This means it is not interpreted as a constant
-          indexing for the variable_name in the LHS of an assignment
+          indexing for the <variable_>name in the LHS of an assignment
           (not inside a primary), nor for the name used for an out or in
           out parameter (not allowed to be a constant), nor for the name
           in an object renaming (not inside a primary), unless there is
           no Variable_Indexing aspect defined.
 
 16/3
-Otherwise, the generalized_indexing is interpreted as a variable
-indexing.
+Otherwise, the generalized_indexing is interpreted as a <variable
+indexing>.
 
 17/3
 When a generalized_indexing is interpreted as a constant (or variable)
 indexing, it is equivalent to a call on a prefixed view of one of the
 functions named by the Constant_Indexing (or Variable_Indexing) aspect
-of the type of the indexable_container_object_prefix with the given
-actual_parameter_part, and with the indexable_container_object_prefix as
-the prefix of the prefixed view.
+of the type of the <indexable_container_object_>prefix with the given
+actual_parameter_part, and with the <indexable_container_object_>prefix
+as the prefix of the prefixed view.
 
 17.a/3
           Ramification: In other words, the generalized_indexing is
           equivalent to:
 
 17.b/3
-               indexable_container_object_prefix.Indexing actual_parameter_part
+               <indexable_container_object_>prefix.Indexing 
actual_parameter_part
 
 17.c/4
-          {AI12-0005-1AI12-0005-1} where Indexing is the name specified
-          for the Constant_Indexing or Variable_Indexing aspect.  This
-          equivalence is then resolved in the normal way; the aspect
-          specifies a name, it does not denote declarations.
+          {<AI12-0005-1AI12-0005-1>} where Indexing is the name
+          specified for the Constant_Indexing or Variable_Indexing
+          aspect.  This equivalence is then resolved in the normal way;
+          the aspect specifies a name, it does not denote declarations.
 
      NOTES
 
 18/4
-     6  {AI12-0104-1AI12-0104-1} The Constant_Indexing and
+     6  {<AI12-0104-1AI12-0104-1>} The Constant_Indexing and
      Variable_Indexing aspects cannot be redefined when inherited for a
      derived type, but the functions that they denote can be modified by
      overriding or overloading.
@@ -21650,42 +21715,42 @@ the prefix of the prefixed view.
                               _Examples_
 
 19/3
-     {AI05-0268-1AI05-0268-1} {AI05-0292-1AI05-0292-1} type Indexed_Barrel is 
tagged ...
+     {<AI05-0268-1AI05-0268-1>} {<AI05-0292-1AI05-0292-1>} type Indexed_Barrel 
is tagged ...
        with Variable_Indexing => Find;
-       -- Indexed_Barrel is an indexable container type,
-       -- Find is the generalized indexing operation.
+       -- <Indexed_Barrel is an indexable container type,>
+       -- <Find is the generalized indexing operation.>
 
 20/3
-     {AI05-0268-1AI05-0268-1} function Find (B : aliased in out 
Indexed_Barrel; Key : String) return Ref_Element;
-        -- Return a reference to an element of a barrel (see *note 4.1.5::).
+     {<AI05-0268-1AI05-0268-1>} function Find (B : aliased in out 
Indexed_Barrel; Key : String) return Ref_Element;
+        -- <Return a reference to an element of a barrel (see *note 4.1.5::).>
 
 21/3
-     {AI05-0268-1AI05-0268-1} IB: aliased Indexed_Barrel;
+     {<AI05-0268-1AI05-0268-1>} IB: aliased Indexed_Barrel;
 
 22/3
-     {AI05-0268-1AI05-0268-1} -- All of the following calls are then 
equivalent:
-     Find (IB,"pear").Data.all := Element'(...); -- Traditional call
-     IB.Find ("pear").Data.all := Element'(...); -- Call of prefixed view
-     IB.Find ("pear")          := Element'(...); -- Implicit dereference (see 
*note 4.1.5::)
-     IB      ("pear")          := Element'(...); -- Implicit indexing and 
dereference
-     IB      ("pear").Data.all := Element'(...); -- Implicit indexing only
+     {<AI05-0268-1AI05-0268-1>} -- <All of the following calls are then 
equivalent:>
+     Find (IB,"pear").Data.all := Element'(...); -- <Traditional call>
+     IB.Find ("pear").Data.all := Element'(...); -- <Call of prefixed view>
+     IB.Find ("pear")          := Element'(...); -- <Implicit dereference (see 
*note 4.1.5::)>
+     IB      ("pear")          := Element'(...); -- <Implicit indexing and 
dereference>
+     IB      ("pear").Data.all := Element'(...); -- <Implicit indexing only>
 
                        _Extensions to Ada 2005_
 
 22.a/3
-          {AI05-0139-2AI05-0139-2} Aspects Constant_Indexing and
+          {<AI05-0139-2AI05-0139-2>} Aspects Constant_Indexing and
           Variable_Indexing, and the generalized_indexing syntax are
           new.
 
                     _Wording Changes from Ada 2012_
 
 22.b/4
-          {AI12-0104-1AI12-0104-1} Corrigendum: Converted confusing and
-          unnecessary normative wording about "overriding an aspect"
+          {<AI12-0104-1AI12-0104-1>} Corrigendum: Converted confusing
+          and unnecessary normative wording about "overriding an aspect"
           into a note.
 
 22.c/4
-          {AI12-0138-1AI12-0138-1} Corrigendum: Defined
+          {<AI12-0138-1AI12-0138-1>} Corrigendum: Defined
           Constant_Indexing and Variable_Indexing to be nonoveridable.
           This is merely a new description for Legality Rules which
           already applied to these aspects.
@@ -21697,21 +21762,21 @@ File: aarm2012.info,  Node: 4.2,  Next: 4.3,  Prev: 
4.1,  Up: 4
 ============
 
 1
-[ A literal represents a value literally, that is, by means of notation
-suited to its kind.]  A literal is either a numeric_literal, a
-character_literal, the literal null, or a string_literal. 
+[ A <literal> represents a value literally, that is, by means of
+notation suited to its kind.]  A literal is either a numeric_literal, a
+character_literal, the literal null, or a string_literal.  
 
 1.a
           Discussion: An enumeration literal that is an identifier
-          rather than a character_literal is not considered a literal in
-          the above sense, because it involves no special notation
+          rather than a character_literal is not considered a <literal>
+          in the above sense, because it involves no special notation
           "suited to its kind."  It might more properly be called an
           enumeration_identifier, except for historical reasons.
 
                         _Name Resolution Rules_
 
 2/2
-This paragraph was deleted.{AI95-00230-01AI95-00230-01}
+<This paragraph was deleted.>{<AI95-00230-01AI95-00230-01>}
 
 3
 For a name that consists of a character_literal, either its expected
@@ -21745,15 +21810,15 @@ type, there shall be a corresponding 
defining_character_literal of the
 component type of the expected string type.
 
 7/2
-This paragraph was deleted.{AI95-00230-01AI95-00230-01}
-{AI95-00231-01AI95-00231-01}
+<This paragraph was deleted.>{<AI95-00230-01AI95-00230-01>}
+{<AI95-00231-01AI95-00231-01>}
 
                           _Static Semantics_
 
 8/2
-{AI95-00230-01AI95-00230-01} An integer literal is of type
-universal_integer.  A real literal is of type universal_real.  The
-literal null is of type universal_access.
+{<AI95-00230-01AI95-00230-01>} An integer literal is of type
+<universal_integer>.  A real literal is of type <universal_real>.  The
+literal null is of type <universal_access>.
 
                           _Dynamic Semantics_
 
@@ -21770,11 +21835,11 @@ positional_array_aggregates (see *note 4.3.3::), 
except that for a null
 string literal, the upper bound is the predecessor of the lower bound.
 
 11
-For the evaluation of a string_literal of type T, a check is made that
+For the evaluation of a string_literal of type <T>, a check is made that
 the value of each character of the string_literal belongs to the
-component subtype of T. For the evaluation of a null string literal, a
-check is made that its lower bound is greater than the lower bound of
-the base range of the index type. The exception Constraint_Error is
+component subtype of <T>.  For the evaluation of a null string literal,
+a check is made that its lower bound is greater than the lower bound of
+the base range of the index type.  The exception Constraint_Error is
 raised if either of these checks fails.
 
 11.a
@@ -21795,13 +21860,13 @@ raised if either of these checks fails.
                               _Examples_
 
 13
-Examples of literals:
+<Examples of literals:>
 
 14
-     3.14159_26536    --  a real literal
-     1_345    --  an integer literal
-     'A'    --  a character literal
-     "Some Text"    --  a string literal 
+     3.14159_26536    --<  a real literal>
+     1_345    --<  an integer literal>
+     'A'    --<  a character literal>
+     "Some Text"    --<  a string literal >
 
                     _Incompatibilities With Ada 83_
 
@@ -21832,9 +21897,9 @@ Examples of literals:
                         _Extensions to Ada 95_
 
 14.d/2
-          {AI95-00230-01AI95-00230-01} {AI95-00231-01AI95-00231-01} Null
-          now has type universal_access, which is similar to other
-          literals.  Null can be used with anonymous access types.
+          {<AI95-00230-01AI95-00230-01>} {<AI95-00231-01AI95-00231-01>}
+          Null now has type <universal_access>, which is similar to
+          other literals.  Null can be used with anonymous access types.
 
 
 File: aarm2012.info,  Node: 4.3,  Next: 4.4,  Prev: 4.2,  Up: 4
@@ -21843,8 +21908,8 @@ File: aarm2012.info,  Node: 4.3,  Next: 4.4,  Prev: 
4.2,  Up: 4
 ==============
 
 1
-[ An aggregate combines component values into a composite value of an
-array type, record type, or record extension.] 
+[ An <aggregate> combines component values into a composite value of an
+array type, record type, or record extension.]  
 
                                _Syntax_
 
@@ -21855,8 +21920,8 @@ array type, record type, or record extension.]
                         _Name Resolution Rules_
 
 3/2
-{AI95-00287-01AI95-00287-01} The expected type for an aggregate shall be
-a single array type, record type, or record extension.
+{<AI95-00287-01AI95-00287-01>} The expected type for an aggregate shall
+be a single array type, record type, or record extension.
 
 3.a
           Discussion: See *note 8.6::, "*note 8.6:: The Context of
@@ -21864,7 +21929,7 @@ a single array type, record type, or record extension.
           type."
 
 3.b/3
-          Ramification: {AI05-0005-1AI05-0005-1} There are additional
+          Ramification: {<AI05-0005-1AI05-0005-1>} There are additional
           rules for each kind of aggregate.  These aggregate rules are
           additive; a legal expression needs to satisfy all of the
           applicable rules.  That means the rule given here must be
@@ -21899,7 +21964,7 @@ For the evaluation of an aggregate, an anonymous object 
is created and
 values for the components or ancestor part are obtained (as described in
 the subsequent subclause for each kind of the aggregate) and assigned
 into the corresponding components or ancestor part of the anonymous
-object. Obtaining the values and the assignments occur in an arbitrary
+object.  Obtaining the values and the assignments occur in an arbitrary
 order.  The value of the aggregate is the value of this object.
 
 5.a
@@ -21926,7 +21991,7 @@ order.  The value of the aggregate is the value of this 
object.
 
 6
 If an aggregate is of a tagged type, a check is made that its value
-belongs to the first subtype of the type. Constraint_Error is raised if
+belongs to the first subtype of the type.  Constraint_Error is raised if
 this check fails.
 
 6.a
@@ -21958,10 +22023,10 @@ this check fails.
                     _Incompatibilities With Ada 95_
 
 6.e/2
-          {AI95-00287-01AI95-00287-01} In Ada 95, a limited type is not
-          considered when resolving an aggregate.  Since Ada 2005 now
-          allows limited aggregates, we can have incompatibilities.  For
-          example:
+          {<AI95-00287-01AI95-00287-01>} In Ada 95, a limited type is
+          not considered when resolving an aggregate.  Since Ada 2005
+          now allows limited aggregates, we can have incompatibilities.
+          For example:
 
 6.f/2
                type Lim is limited
@@ -21980,7 +22045,7 @@ this check fails.
                procedure P(X: Not_Lim);
 
 6.i/2
-               P((Comp => 123)); -- Illegal in Ada 2005, legal in Ada 95
+               P((Comp => 123)); -- <Illegal in Ada 2005, legal in Ada 95>
 
 6.j/2
           The call to P is ambiguous in Ada 2005, while it would not be
@@ -21993,7 +22058,7 @@ this check fails.
                         _Extensions to Ada 95_
 
 6.k/2
-          {AI95-00287-01AI95-00287-01} Aggregates can be of a limited
+          {<AI95-00287-01AI95-00287-01>} Aggregates can be of a limited
           type.
 
 * Menu:
@@ -22024,22 +22089,22 @@ association.]
        | null record
 
 4/2
-     {AI95-00287-01AI95-00287-01} record_component_association ::=
+     {<AI95-00287-01AI95-00287-01>} record_component_association ::=
          [component_choice_list =>] expression
         | component_choice_list => <>
 
 5
      component_choice_list ::=
-          component_selector_name {| component_selector_name}
+          <component_>selector_name {| <component_>selector_name}
         | others
 
 6
-     A record_component_association (*note 4.3.1: S0109.) is a named
-     component association if it has a component_choice_list; otherwise,
-     it is a positional component association.  Any positional component
-     associations shall precede any named component associations.  If
-     there is a named association with a component_choice_list of
-     others, it shall come last.
+     A record_component_association (*note 4.3.1: S0109.) is a <named
+     component association> if it has a component_choice_list;
+     otherwise, it is a <positional component association>.  Any
+     positional component associations shall precede any named component
+     associations.  If there is a named association with a
+     component_choice_list of others, it shall come last.
 
 6.a
           Discussion: These rules were implied by the BNF in an early
@@ -22057,7 +22122,7 @@ association.]
      association, it shall be a named association.
 
 7.a/3
-          Reason: {AI05-0264-1AI05-0264-1} Otherwise, the construct
+          Reason: {<AI05-0264-1AI05-0264-1>} Otherwise, the construct
           would be interpreted as a parenthesized expression.  This is
           considered a syntax rule, since it is relevant to overload
           resolution.  We choose not to express it with BNF so we can
@@ -22071,7 +22136,7 @@ association.]
                         _Name Resolution Rules_
 
 8/2
-{AI95-00287-01AI95-00287-01} The expected type for a record_aggregate
+{<AI95-00287-01AI95-00287-01>} The expected type for a record_aggregate
 shall be a single record type or record extension.
 
 8.a
@@ -22083,8 +22148,8 @@ shall be a single record type or record extension.
 9
 For the record_component_association_list (*note 4.3.1: S0108.) of a
 record_aggregate (*note 4.3.1: S0107.), all components of the composite
-value defined by the aggregate are needed[; for the association list of
-an extension_aggregate, only those components not determined by the
+value defined by the aggregate are <needed>[; for the association list
+of an extension_aggregate, only those components not determined by the
 ancestor expression or subtype are needed (see *note 4.3.2::).]  Each
 selector_name (*note 4.1.3: S0099.) in a record_component_association
 (*note 4.3.1: S0109.) shall denote a needed component [(including
@@ -22111,7 +22176,7 @@ possibly a discriminant)].
 
 10
 The expected type for the expression of a record_component_association
-(*note 4.3.1: S0109.) is the type of the associated component(s); the
+(*note 4.3.1: S0109.) is the type of the <associated> component(s); the
 associated component(s) are as follows:
 
 11
@@ -22126,7 +22191,7 @@ associated component(s) are as follows:
           to determine the position.
 
 11.b/3
-          {AI05-0005-1AI05-0005-1} For a derived type (including type
+          {<AI05-0005-1AI05-0005-1>} For a derived type (including type
           extensions), the order of declaration is defined in *note
           3.4::, "*note 3.4:: Derived Types and Classes".  In
           particular, all discriminants come first, regardless of
@@ -22134,8 +22199,8 @@ associated component(s) are as follows:
           added to the derived type.
 
 12
-   * For a named association with one or more component_selector_names,
-     the named component(s);
+   * For a named association with one or more
+     <component_>selector_names, the named component(s);
 
 13
    * For a named association with the reserved word others, all needed
@@ -22149,8 +22214,8 @@ be a descendant of a record type, through one or more 
record extensions
 (and no private extensions).
 
 15/3
-{AI05-0016-1AI05-0016-1} The reserved words null record may appear only
-if there are no components needed in a given
+{<AI05-0016-1AI05-0016-1>} The reserved words null record may appear
+only if there are no components needed in a given
 record_component_association_list (*note 4.3.1: S0108.).
 
 15.a
@@ -22160,16 +22225,16 @@ record_component_association_list (*note 4.3.1: 
S0108.).
           defined as a null record extension of T.
 
 15.b/3
-          {AI05-0016-1AI05-0016-1} If no components are needed and null
-          record is not used, the record_component_association (*note
-          4.3.1: S0109.) must necessarily be others => <>, as that is
-          the only record_component_association (*note 4.3.1: S0109.)
-          that does not require an associated component.
+          {<AI05-0016-1AI05-0016-1>} If no components are needed and
+          null record is not used, the record_component_association
+          (*note 4.3.1: S0109.) must necessarily be others => <>, as
+          that is the only record_component_association (*note 4.3.1:
+          S0109.) that does not require an associated component.
 
 16/4
-{AI95-00287-01AI95-00287-01} {AI05-0199-1AI05-0199-1}
-{AI12-0046-1AI12-0046-1} Each record_component_association other than an
-others choice with a <> shall have at least one associated component,
+{<AI95-00287-01AI95-00287-01>} {<AI05-0199-1AI05-0199-1>}
+{<AI12-0046-1AI12-0046-1>} Each record_component_association other than
+an others choice with a <> shall have at least one associated component,
 and each needed component shall be associated with exactly one
 record_component_association (*note 4.3.1: S0109.).  If a
 record_component_association (*note 4.3.1: S0109.) with an expression
@@ -22179,13 +22244,13 @@ statically match.  In addition, Legality Rules are 
enforced separately
 for each associated component.
 
 16.a/2
-          Ramification: {AI95-00287-01AI95-00287-01} These rules apply
+          Ramification: {<AI95-00287-01AI95-00287-01>} These rules apply
           to an association with an others choice with an expression.
           An others choice with a <> can match zero components or
           several components with different types.
 
 16.b/2
-          Reason: {AI95-00287-01AI95-00287-01} Without these rules,
+          Reason: {<AI95-00287-01AI95-00287-01>} Without these rules,
           there would be no way to know what was the expected type for
           the expression of the association.  Note that some of the
           rules do not apply to <> associations, as we do not need to
@@ -22195,12 +22260,12 @@ for each associated component.
           record or array value.
 
 16.c/4
-          Discussion: {AI12-0046-1AI12-0046-1} AI83-00244 also requires
-          that the expression shall be legal for each associated
-          component.  Ada 95 omitted this wording, as it was thought
-          that all cases of difference had been eliminated.  That
-          probably was true, but Ada 2005 reintroduced cases where the
-          types match but the legality differs.  For example:
+          Discussion: {<AI12-0046-1AI12-0046-1>} AI83-00244 also
+          requires that the expression shall be legal for each
+          associated component.  Ada 95 omitted this wording, as it was
+          thought that all cases of difference had been eliminated.
+          That probably was true, but Ada 2005 reintroduced cases where
+          the types match but the legality differs.  For example:
 
 16.c.1/4
                type Rec (D : access Integer) is record
@@ -22210,7 +22275,7 @@ for each associated component.
 16.c.2/4
                ...
                X : aliased Integer;
-               R : Rec := (D | F => X'Access); -- Legal for D, illegal for F
+               R : Rec := (D | F => X'Access); -- <Legal for D, illegal for F>
 
 16.c.3/4
           There are additional ways for this to happen; because of cases
@@ -22230,10 +22295,10 @@ for each associated component.
           components are left out, nor specified twice.
 
 17/3
-{AI05-0220-1AI05-0220-1} The value of a discriminant that governs a
-variant_part P shall be given by a static expression, unless P is nested
-within a variant V that is not selected by the discriminant value
-governing the variant_part enclosing V.
+{<AI05-0220-1AI05-0220-1>} The value of a discriminant that governs a
+variant_part <P> shall be given by a static expression, unless <P> is
+nested within a variant <V> that is not selected by the discriminant
+value governing the variant_part enclosing <V>.
 
 17.a
           Ramification: This expression might either be given within the
@@ -22242,7 +22307,7 @@ governing the variant_part enclosing V.
           aggregate.
 
 17.1/2
-{AI95-00287-01AI95-00287-01} A record_component_association for a
+{<AI95-00287-01AI95-00287-01>} A record_component_association for a
 discriminant without a default_expression shall have an expression
 rather than <>.
 
@@ -22261,7 +22326,7 @@ record_component_association_list (*note 4.3.1: S0108.).
 For the evaluation of a record_component_association_list (*note 4.3.1:
 S0108.), any per-object constraints (see *note 3.8::) for components
 specified in the association list are elaborated and any expressions are
-evaluated and converted to the subtype of the associated component. Any
+evaluated and converted to the subtype of the associated component.  Any
 constraint elaborations and expression evaluations (and conversions)
 occur in an arbitrary order, except that the expression for a
 discriminant is evaluated (and converted) prior to the elaboration of
@@ -22278,8 +22343,8 @@ with the per-object constraint.
           as part of the dependent compatibility check in Ada 83.
 
 19.1/2
-{AI95-00287-01AI95-00287-01} For a record_component_association with an
-expression, the expression defines the value for the associated
+{<AI95-00287-01AI95-00287-01>} For a record_component_association with
+an expression, the expression defines the value for the associated
 component(s).  For a record_component_association with <>, if the
 component_declaration has a default_expression, that default_expression
 defines the value for the associated component(s); otherwise, the
@@ -22291,7 +22356,7 @@ The expression of a record_component_association is 
evaluated (and
 converted) once for each associated component.
 
 20.a/3
-          Ramification: {AI05-0005-1AI05-0005-1} We don't need similar
+          Ramification: {<AI05-0005-1AI05-0005-1>} We don't need similar
           language for <>, as we're considering the value of <> for each
           individual component.  Each component has its own default
           expression or its own default initialization (they can be
@@ -22311,41 +22376,41 @@ converted) once for each associated component.
                               _Examples_
 
 22
-Example of a record aggregate with positional associations:
+<Example of a record aggregate with positional associations:>
 
 23
-     (4, July, 1776)                                       --  see *note 3.8:: 
+     (4, July, 1776)                                       --<  see *note 
3.8:: >
 
 24
-Examples of record aggregates with named associations:
+<Examples of record aggregates with named associations:>
 
 25
      (Day => 4, Month => July, Year => 1776)
      (Month => July, Day => 4, Year => 1776)
 
 26
-     (Disk, Closed, Track => 5, Cylinder => 12)            --  see *note 
3.8.1::
+     (Disk, Closed, Track => 5, Cylinder => 12)            --<  see *note 
3.8.1::>
      (Unit => Disk, Status => Closed, Cylinder => 9, Track => 1)
 
 27/2
-{AI95-00287-01AI95-00287-01} Examples of component associations with
-several choices:
+{<AI95-00287-01AI95-00287-01>} <Examples of component associations with
+several choices:>
 
 28
-     (Value => 0, Succ|Pred => new Cell'(0, null, null))    --  see *note 
3.10.1::
+     (Value => 0, Succ|Pred => new Cell'(0, null, null))    --<  see *note 
3.10.1::>
 
 29
-      --  The allocator is evaluated twice: Succ and Pred designate different 
cells
+      --<  The allocator is evaluated twice: Succ and Pred designate different 
cells>
 
 29.1/2
-     (Value => 0, Succ|Pred => <>)    --  see *note 3.10.1::
+     (Value => 0, Succ|Pred => <>)    --<  see *note 3.10.1::>
 
 29.2/2
-      --  Succ and Pred will be set to null
+      --<  Succ and Pred will be set to null>
 
 30
-Examples of record aggregates for tagged types (see *note 3.9:: and
-*note 3.9.1::):
+<Examples of record aggregates for tagged types (see *note 3.9:: and
+*note 3.9.1::):>
 
 31
      Expression'(null record)
@@ -22369,24 +22434,24 @@ Examples of record aggregates for tagged types (see 
*note 3.9:: and
                         _Extensions to Ada 95_
 
 31.c/2
-          {AI95-00287-01AI95-00287-01} <> can be used in place of an
+          {<AI95-00287-01AI95-00287-01>} <> can be used in place of an
           expression in a record_aggregate, default initializing the
           component.
 
                      _Wording Changes from Ada 95_
 
 31.d/2
-          {AI95-00287-01AI95-00287-01} Limited record_aggregates are
+          {<AI95-00287-01AI95-00287-01>} Limited record_aggregates are
           allowed (since all kinds of aggregates can now be limited, see
           *note 4.3::).
 
                    _Incompatibilities With Ada 2005_
 
 31.e/3
-          {AI05-0220-1AI05-0220-1} Correction: Corrected wording so that
-          the rule for discriminants governing variant_parts was not
-          effectively circular.  The change makes a few aggregates where
-          a nonstatic discriminant governs an empty variant_part
+          {<AI05-0220-1AI05-0220-1>} Correction: Corrected wording so
+          that the rule for discriminants governing variant_parts was
+          not effectively circular.  The change makes a few aggregates
+          where a nonstatic discriminant governs an empty variant_part
           illegal.  However, most Ada implementations already enforce
           some version of the new rule and already reject these
           aggregates.  So it is unlikely that any incompatibility will
@@ -22395,14 +22460,14 @@ Examples of record aggregates for tagged types (see 
*note 3.9:: and
                        _Extensions to Ada 2005_
 
 31.f/3
-          {AI05-0016-1AI05-0016-1} Correction: Fixed the wording so that
-          others => <> can be used in place of null record.  This is
-          needed to avoid a generic contract issue for generic bodies:
-          we do not want to have to assume the worst to disallow others
-          => <> if the record type might be a null record.
+          {<AI05-0016-1AI05-0016-1>} Correction: Fixed the wording so
+          that others => <> can be used in place of null record.  This
+          is needed to avoid a generic contract issue for generic
+          bodies: we do not want to have to assume the worst to disallow
+          others => <> if the record type <might> be a null record.
 
 31.g/3
-          {AI05-0199-1AI05-0199-1} Correction: We now allow multiple
+          {<AI05-0199-1AI05-0199-1>} Correction: We now allow multiple
           components with anonymous access types to be specified with a
           single component association.  This is to be consistent with
           the capabilities of a named access type.
@@ -22410,12 +22475,12 @@ Examples of record aggregates for tagged types (see 
*note 3.9:: and
                     _Wording Changes from Ada 2012_
 
 31.h/4
-          {AI12-0046-1AI12-0046-1} Corrigendum: We explicitly say that
+          {<AI12-0046-1AI12-0046-1>} Corrigendum: We explicitly say that
           the Legality Rules have to be rechecked for each component
-          individually.  This seems obvious, but as the AARM note *note
-          4.3.1:: (16.c) appeared to say that this was not necessary,
-          and since we explicitly state this sort of thing for generic
-          instances, it seemed better to be explicit.
+          individually.  This <seems> obvious, but as the AARM note
+          *note 4.3.1:: (16.c) appeared to say that this was not
+          necessary, and since we explicitly state this sort of thing
+          for generic instances, it seemed better to be explicit.
 
 
 File: aarm2012.info,  Node: 4.3.2,  Next: 4.3.3,  Prev: 4.3.1,  Up: 4.3
@@ -22451,21 +22516,21 @@ ancestor_part.]
                         _Name Resolution Rules_
 
 4/2
-{AI95-00287-01AI95-00287-01} The expected type for an
+{<AI95-00287-01AI95-00287-01>} The expected type for an
 extension_aggregate shall be a single type that is a record extension.
 If the ancestor_part is an expression, it is expected to be of any
 tagged type.
 
 4.a
-          Reason: We could have made the expected type T'Class where T
-          is the ultimate ancestor of the type of the aggregate, or we
-          could have made it even more specific than that.  However, if
-          the overload resolution rules get too complicated, the
+          Reason: We could have made the expected type <T'>Class where
+          <T> is the ultimate ancestor of the type of the aggregate, or
+          we could have made it even more specific than that.  However,
+          if the overload resolution rules get too complicated, the
           implementation gets more difficult and it becomes harder to
           produce good error messages.
 
 4.b/3
-          Ramification: {AI05-0005-1AI05-0005-1} This rule is additive
+          Ramification: {<AI05-0005-1AI05-0005-1>} This rule is additive
           with the rule given in *note 4.3::.  That means the *note
           4.3:: rule must be satisfied even though it is always
           syntactically possible to tell that something is an extension
@@ -22479,24 +22544,24 @@ tagged type.
                            _Legality Rules_
 
 5/3
-{AI95-00306-01AI95-00306-01} {AI05-0115-1AI05-0115-1} If the
+{<AI95-00306-01AI95-00306-01>} {<AI05-0115-1AI05-0115-1>} If the
 ancestor_part is a subtype_mark, it shall denote a specific tagged
 subtype.  If the ancestor_part is an expression, it shall not be
 dynamically tagged.  The type of the extension_aggregate shall be a
-descendant of the type of the ancestor_part (the ancestor type), through
-one or more record extensions (and no private extensions).  If the
-ancestor_part is a subtype_mark, the view of the ancestor type from
+descendant of the type of the ancestor_part (the <ancestor> type),
+through one or more record extensions (and no private extensions).  If
+the ancestor_part is a subtype_mark, the view of the ancestor type from
 which the type is descended (see *note 7.3.1::) shall not have unknown
 discriminants.
 
 5.a/2
-          Reason: {AI95-00306-01AI95-00306-01} The expression cannot be
-          dynamically tagged to prevent implicit "truncation" of a
+          Reason: {<AI95-00306-01AI95-00306-01>} The expression cannot
+          be dynamically tagged to prevent implicit "truncation" of a
           dynamically-tagged value to the specific ancestor type.  This
           is similar to the rules in *note 3.9.2::.
 
 5.1/3
-{AI05-0067-1AI05-0067-1} {AI05-0244-1AI05-0244-1} If the type of the
+{<AI05-0067-1AI05-0067-1>} {<AI05-0244-1AI05-0244-1>} If the type of the
 ancestor_part is limited and at least one component is needed in the
 record_component_association_list, then the ancestor_part shall not be:
 
@@ -22508,19 +22573,19 @@ record_component_association_list, then the 
ancestor_part shall not be:
      this rule; nor
 
 5.4/3
-   * a conditional_expression having at least one dependent_expression
+   * a conditional_expression having at least one <dependent_>expression
      that would violate this rule.
 
 5.b/3
-          Reason: {AI05-0067-1AI05-0067-1} {AI05-0244-1AI05-0244-1} This
-          restriction simplifies implementation, because it ensures that
-          either the caller or the callee knows the size to allocate for
-          the aggregate.  Without this restriction, information from
-          both caller and callee would have to be combined to determine
-          the appropriate size.
+          Reason: {<AI05-0067-1AI05-0067-1>} {<AI05-0244-1AI05-0244-1>}
+          This restriction simplifies implementation, because it ensures
+          that either the caller or the callee knows the size to
+          allocate for the aggregate.  Without this restriction,
+          information from both caller and callee would have to be
+          combined to determine the appropriate size.
 
 5.c/3
-          {AI05-0067-1AI05-0067-1} The (F(...)  with null record) case
+          {<AI05-0067-1AI05-0067-1>} The (F(...)  with null record) case
           is exempt from this rule, because such extension aggregates
           are created internally for inherited functions returning
           null-extension types -- we can't very well make those illegal.
@@ -22531,7 +22596,7 @@ record_component_association_list, then the 
ancestor_part shall not be:
 
 6
 For the record_component_association_list (*note 4.3.1: S0108.) of an
-extension_aggregate (*note 4.3.2: S0111.), the only components needed
+extension_aggregate (*note 4.3.2: S0111.), the only components <needed>
 are those of the composite value defined by the aggregate that are not
 inherited from the type of the ancestor_part (*note 4.3.2: S0112.), plus
 any inherited discriminants if the ancestor_part (*note 4.3.2: S0112.)
@@ -22553,14 +22618,14 @@ discriminant is evaluated prior to any other 
evaluation or
 initialization that depends on it.
 
 8/3
-{AI05-0282-1AI05-0282-1} If the type of the ancestor_part has
+{<AI05-0282-1AI05-0282-1>} If the type of the ancestor_part has
 discriminants and the ancestor_part is not a subtype_mark that denotes
 an unconstrained subtype, then a check is made that each discriminant
 determined by the ancestor_part has the value specified for a
 corresponding discriminant, if any, either in the
 record_component_association_list (*note 4.3.1: S0108.), or in the
 derived_type_definition for some ancestor of the type of the
-extension_aggregate. Constraint_Error is raised if this check fails.
+extension_aggregate.  Constraint_Error is raised if this check fails.
 
 8.a
           Ramification: Corresponding and specified discriminants are
@@ -22571,7 +22636,7 @@ extension_aggregate. Constraint_Error is raised if this 
check fails.
           expression.
 
 8.b/3
-          {AI05-0282-1AI05-0282-1} The check needs to be made any time
+          {<AI05-0282-1AI05-0282-1>} The check needs to be made any time
           that the ancestor is constrained; the source of the
           discriminants or the constraints is irrelevant.
 
@@ -22593,7 +22658,7 @@ extension_aggregate. Constraint_Error is raised if this 
check fails.
                               _Examples_
 
 11
-Examples of extension aggregates (for types defined in *note 3.9.1::):
+<Examples of extension aggregates (for types defined in *note 3.9.1::):>
 
 12
      Painted_Point'(Point with Red)
@@ -22602,7 +22667,7 @@ Examples of extension aggregates (for types defined in 
*note 3.9.1::):
 13
      (Expression with Left => 1.2, Right => 3.4)
      Addition'(Binop with null record)
-                  -- presuming Binop is of type Binary_Operation
+                  --< presuming Binop is of type Binary_Operation>
 
                         _Extensions to Ada 83_
 
@@ -22612,24 +22677,25 @@ Examples of extension aggregates (for types defined 
in *note 3.9.1::):
                     _Incompatibilities With Ada 95_
 
 13.b/2
-          {AI95-00306-01AI95-00306-01} Amendment Correction: Eliminated
-          implicit "truncation" of a dynamically tagged value when it is
-          used as an ancestor expression.  If an aggregate includes such
-          an expression, it is illegal in Ada 2005.  Such aggregates are
-          thought to be rare; the problem can be fixed with a type
-          conversion to the appropriate specific type if it occurs.
+          {<AI95-00306-01AI95-00306-01>} Amendment Correction:
+          Eliminated implicit "truncation" of a dynamically tagged value
+          when it is used as an ancestor expression.  If an aggregate
+          includes such an expression, it is illegal in Ada 2005.  Such
+          aggregates are thought to be rare; the problem can be fixed
+          with a type conversion to the appropriate specific type if it
+          occurs.
 
                      _Wording Changes from Ada 95_
 
 13.c/2
-          {AI95-00287-01AI95-00287-01} Limited extension_aggregates are
-          allowed (since all kinds of aggregates can now be limited, see
-          *note 4.3::).
+          {<AI95-00287-01AI95-00287-01>} Limited extension_aggregates
+          are allowed (since all kinds of aggregates can now be limited,
+          see *note 4.3::).
 
                     _Inconsistencies With Ada 2005_
 
 13.d/3
-          {AI05-0282-1AI05-0282-1} Correction: An extension_aggregate
+          {<AI05-0282-1AI05-0282-1>} Correction: An extension_aggregate
           with an ancestor_part whose discriminants are constrained and
           inherited might now raise Constraint_Error if the aggregate's
           type is constrained, while it was OK in Ada 2005.  In almost
@@ -22646,7 +22712,7 @@ Examples of extension aggregates (for types defined in 
*note 3.9.1::):
                    _Incompatibilities With Ada 2005_
 
 13.e/3
-          {AI05-0067-1AI05-0067-1} Correction: A limited unconstrained
+          {<AI05-0067-1AI05-0067-1>} Correction: A limited unconstrained
           ancestor expression that is a function call is now illegal
           unless the extension part is null.  Such aggregates were first
           introduced in Ada 2005 and are very complex to implement as
@@ -22655,8 +22721,8 @@ Examples of extension aggregates (for types defined in 
*note 3.9.1::):
           compilers and thus not often used in existing code.
 
 13.f/3
-          {AI05-0115-1AI05-0115-1} Correction: An ancestor_part that is
-          a subtype with unknown discriminants is now explicitly
+          {<AI05-0115-1AI05-0115-1>} Correction: An ancestor_part that
+          is a subtype with unknown discriminants is now explicitly
           illegal.  Such a subtype should not be used to declare an
           object, and the ancestor_part acts like an object.  The Ada 95
           rules did not disallow such cases, so it is possible that code
@@ -22692,7 +22758,7 @@ by the values covered by the discrete_choices.
        positional_array_aggregate | named_array_aggregate
 
 3/2
-     {AI95-00287-01AI95-00287-01} positional_array_aggregate ::=
+     {<AI95-00287-01AI95-00287-01>} positional_array_aggregate ::=
          (expression, expression {, expression})
        | (expression {, expression}, others => expression)
        | (expression {, expression}, others => <>)
@@ -22702,19 +22768,19 @@ by the values covered by the discrete_choices.
          (array_component_association {, array_component_association})
 
 5/2
-     {AI95-00287-01AI95-00287-01} array_component_association ::=
+     {<AI95-00287-01AI95-00287-01>} array_component_association ::=
          discrete_choice_list => expression
        | discrete_choice_list => <>
 
 6
-An n-dimensional array_aggregate is one that is written as n levels of
+An <n-dimensional> array_aggregate is one that is written as n levels of
 nested array_aggregates (or at the bottom level, equivalent
-string_literals). For the multidimensional case (n >= 2) the
+string_literals).  For the multidimensional case (n >= 2) the
 array_aggregates (or equivalent string_literals) at the n-1 lower levels
-are called subaggregates of the enclosing n-dimensional array_aggregate.
-The expressions of the bottom level subaggregates (or of the
-array_aggregate itself if one-dimensional) are called the array
-component expressions of the enclosing n-dimensional array_aggregate.
+are called <subaggregate>s of the enclosing n-dimensional
+array_aggregate.  The expressions of the bottom level subaggregates (or
+of the array_aggregate itself if one-dimensional) are called the <array
+component expressions> of the enclosing n-dimensional array_aggregate.
 
 6.a
           Ramification: Subaggregates do not have a type.  They
@@ -22724,29 +22790,29 @@ component expressions of the enclosing n-dimensional 
array_aggregate.
           subaggregates as well as aggregates that have a type.
 
 6.b
-          To be honest: An others choice is the reserved word others as
-          it appears in a positional_array_aggregate or as the
+          To be honest: An <others choice> is the reserved word others
+          as it appears in a positional_array_aggregate or as the
           discrete_choice of the discrete_choice_list in an
           array_component_association.
 
                         _Name Resolution Rules_
 
 7/2
-{AI95-00287-01AI95-00287-01} The expected type for an array_aggregate
-(that is not a subaggregate) shall be a single array type. The component
-type of this array type is the expected type for each array component
-expression of the array_aggregate.
+{<AI95-00287-01AI95-00287-01>} The expected type for an array_aggregate
+(that is not a subaggregate) shall be a single array type.  The
+component type of this array type is the expected type for each array
+component expression of the array_aggregate.
 
 7.a/2
-          Ramification: {AI95-00287-01AI95-00287-01} We already require
-          a single array or record type or record extension for an
-          aggregate.  The above rule requiring a single array type (and
-          similar ones for record and extension aggregates) resolves
-          which kind of aggregate you have.
+          Ramification: {<AI95-00287-01AI95-00287-01>} We already
+          require a single array or record type or record extension for
+          an aggregate.  The above rule requiring a single array type
+          (and similar ones for record and extension aggregates)
+          resolves which kind of aggregate you have.
 
 8
 The expected type for each discrete_choice in any discrete_choice_list
-of a named_array_aggregate is the type of the corresponding index; the
+of a named_array_aggregate is the type of the <corresponding index>; the
 corresponding index for an array_aggregate that is not a subaggregate is
 the first index of its type; for an (n-m)-dimensional subaggregate
 within an array_aggregate of an n-dimensional type, the corresponding
@@ -22764,15 +22830,16 @@ n-dimensional array_aggregate.
           be an (m-1)-dimensional subaggregate.
 
 10
-An others choice is allowed for an array_aggregate only if an applicable
-index constraint applies to the array_aggregate. [An applicable index
-constraint is a constraint provided by certain contexts where an
-array_aggregate is permitted that can be used to determine the bounds of
-the array value specified by the aggregate.]  Each of the following
-contexts (and none other) defines an applicable index constraint:
+An others choice is allowed for an array_aggregate only if an
+<applicable index constraint> applies to the array_aggregate.  [An
+applicable index constraint is a constraint provided by certain contexts
+where an array_aggregate is permitted that can be used to determine the
+bounds of the array value specified by the aggregate.]  Each of the
+following contexts (and none other) defines an applicable index
+constraint:
 
 11/4
-   * {AI95-00318-02AI95-00318-02} {AI12-0157-1AI12-0157-1} For an
+   * {<AI95-00318-02AI95-00318-02>} {<AI12-0157-1AI12-0157-1>} For an
      explicit_actual_parameter, an explicit_generic_actual_parameter,
      the expression of a return statement, the return expression of an
      expression function, the initialization expression in an
@@ -22809,7 +22876,7 @@ contexts (and none other) defines an applicable index 
constraint:
           used within a larger aggregate.
 
 15/3
-   * {AI05-0147-1AI05-0147-1} For a parenthesized expression, the
+   * {<AI05-0147-1AI05-0147-1>} For a parenthesized expression, the
      applicable index constraint is that, if any, defined for the
      expression;
 
@@ -22819,12 +22886,12 @@ contexts (and none other) defines an applicable index 
constraint:
           becomes illegal if parenthesized.
 
 15.1/3
-   * {AI05-0147-1AI05-0147-1} For a conditional_expression, the
-     applicable index constraint for each dependent_expression is that,
-     if any, defined for the conditional_expression.
+   * {<AI05-0147-1AI05-0147-1>} For a conditional_expression, the
+     applicable index constraint for each <dependent_>expression is
+     that, if any, defined for the conditional_expression.
 
 16
-The applicable index constraint applies to an array_aggregate that
+The applicable index constraint <applies> to an array_aggregate that
 appears in such a context, as well as to any subaggregates thereof.  In
 the case of an explicit_actual_parameter (or default_expression) for a
 call on a generic formal subprogram, no applicable index constraint is
@@ -22836,7 +22903,7 @@ defined.
           subprograms with generic formal subprograms.
 
 17/3
-{AI05-0153-3AI05-0153-3} The discrete_choice_list of an
+{<AI05-0153-3AI05-0153-3>} The discrete_choice_list of an
 array_component_association is allowed to have a discrete_choice that is
 a nonstatic choice_expression or that is a subtype_indication or range
 that defines a nonstatic or null range, only if it is the single
@@ -22848,7 +22915,7 @@ array_component_association in the array_aggregate.
           there are other array component expressions as well.
 
 18/3
-{AI05-0262-1AI05-0262-1} In a named_array_aggregate where all
+{<AI05-0262-1AI05-0262-1>} In a named_array_aggregate where all
 discrete_choices are static, no two discrete_choices are allowed to
 cover the same value (see *note 3.8.1::); if there is no others choice,
 the discrete_choices taken together shall exactly cover a contiguous
@@ -22859,7 +22926,7 @@ sequence of values of the corresponding index type.
           specified exactly once.  See AI83-309.
 
 18.b/3
-          Reason: {AI05-0262-1AI05-0262-1} This has to apply even if
+          Reason: {<AI05-0262-1AI05-0262-1>} This has to apply even if
           there is only one static discrete_choice; a single choice has
           to represent a contiguous range (a subtype_mark with a static
           predicate might represent a discontiguous set of values).  If
@@ -22897,7 +22964,7 @@ two steps:
      2.  The array component expressions of the aggregate are evaluated
      in an arbitrary order and their values are converted to the
      component subtype of the array type; an array component expression
-     is evaluated once for each associated component. 
+     is evaluated once for each associated component.  
 
 23.a
           Ramification: Subaggregates are not separately evaluated.  The
@@ -22905,9 +22972,9 @@ two steps:
           component subtype might raise Constraint_Error.
 
 23.b/3
-          {AI05-0005-1AI05-0005-1} We don't need to say that <> is
+          {<AI05-0005-1AI05-0005-1>} We don't need to say that <> is
           evaluated once for each component, as <> means that each
-          component is initialized by default.  That means that the
+          component is <initialized by default>.  That means that the
           actions defined for default initialization are applied to each
           component individually.  Initializing one component by default
           and copying that to the others would be an incorrect
@@ -22915,13 +22982,14 @@ two steps:
           default initialization is known to be constant).
 
 23.1/4
-{AI95-00287-01AI95-00287-01} {AI12-0084-1AI12-0084-1} Each expression in
-an array_component_association defines the value for the associated
-component(s).  For an array_component_association with <>, the
-associated component(s) are initialized to the Default_Component_Value
-of the array type if this aspect has been specified for the array type;
-otherwise, they are initialized by default as for a stand-alone object
-of the component subtype (see *note 3.3.1::).
+{<AI95-00287-01AI95-00287-01>} {<AI12-0084-1AI12-0084-1>} Each
+expression in an array_component_association defines the value for the
+associated component(s).  For an array_component_association with <>,
+the associated component(s) are initialized to the
+Default_Component_Value of the array type if this aspect has been
+specified for the array type; otherwise, they are initialized by default
+as for a stand-alone object of the component subtype (see *note
+3.3.1::).
 
 24
 The bounds of the index range of an array_aggregate [(including a
@@ -22966,8 +23034,8 @@ its bounds is compatible with the corresponding index 
subtype.
           a subtype.  See AI83-00313.
 
 29/3
-{AI05-0037-1AI05-0037-1} For an array_aggregate with an others choice, a
-check is made that no expression or <> is specified for an index value
+{<AI05-0037-1AI05-0037-1>} For an array_aggregate with an others choice,
+a check is made that no expression or <> is specified for an index value
 outside the bounds determined by the applicable index constraint.
 
 29.a
@@ -22999,7 +23067,7 @@ fail.
      NOTES
 
 32/3
-     11  {AI05-0004-1AI05-0004-1} In an array_aggregate, positional
+     11  {<AI05-0004-1AI05-0004-1>} In an array_aggregate, positional
      notation may only be used with two or more expressions; a single
      expression in parentheses is interpreted as a parenthesized
      expression.  A named_array_aggregate, such as (1 => X), may be used
@@ -23008,30 +23076,30 @@ fail.
                               _Examples_
 
 33
-Examples of array aggregates with positional associations:
+<Examples of array aggregates with positional associations:>
 
 34
      (7, 9, 5, 1, 3, 2, 4, 8, 6, 0)
-     Table'(5, 8, 4, 1, others => 0)  --  see *note 3.6:: 
+     Table'(5, 8, 4, 1, others => 0)  --<  see *note 3.6:: >
 
 35
-Examples of array aggregates with named associations:
+<Examples of array aggregates with named associations:>
 
 36
-     (1 .. 5 => (1 .. 8 => 0.0))      --  two-dimensional
-     (1 .. N => new Cell)             --  N new cells, in particular for N = 0
+     (1 .. 5 => (1 .. 8 => 0.0))      --<  two-dimensional>
+     (1 .. N => new Cell)             --<  N new cells, in particular for N = 
0>
 
 37
      Table'(2 | 4 | 10 => 1, others => 0)
-     Schedule'(Mon .. Fri => True,  others => False)  --  see *note 3.6::
+     Schedule'(Mon .. Fri => True,  others => False)  --<  see *note 3.6::>
      Schedule'(Wed | Sun  => False, others => True)
-     Vector'(1 => 2.5)                                --  single-component 
vector
+     Vector'(1 => 2.5)                                --<  single-component 
vector>
 
 38
-Examples of two-dimensional array aggregates:
+<Examples of two-dimensional array aggregates:>
 
 39
-     -- Three aggregates for the same value of subtype Matrix(1..2,1..3) (see 
*note 3.6::):
+     --< Three aggregates for the same value of subtype Matrix(1..2,1..3) (see 
*note 3.6::):>
 
 40
      ((1.1, 1.2, 1.3), (2.1, 2.2, 2.3))
@@ -23039,25 +23107,25 @@ Examples of two-dimensional array aggregates:
      (1 => (1 => 1.1, 2 => 1.2, 3 => 1.3), 2 => (1 => 2.1, 2 => 2.2, 3 => 2.3))
 
 41
-Examples of aggregates as initial values:
+<Examples of aggregates as initial values:>
 
 42
-     A : Table := (7, 9, 5, 1, 3, 2, 4, 8, 6, 0);        -- A(1)=7, A(10)=0
-     B : Table := (2 | 4 | 10 => 1, others => 0);        -- B(1)=0, B(10)=1
-     C : constant Matrix := (1 .. 5 => (1 .. 8 => 0.0)); -- C'Last(1)=5, 
C'Last(2)=8
+     A : Table := (7, 9, 5, 1, 3, 2, 4, 8, 6, 0);        --< A(1)=7, A(10)=0>
+     B : Table := (2 | 4 | 10 => 1, others => 0);        --< B(1)=0, B(10)=1>
+     C : constant Matrix := (1 .. 5 => (1 .. 8 => 0.0)); --< C'Last(1)=5, 
C'Last(2)=8>
 
 43
-     D : Bit_Vector(M .. N) := (M .. N => True);         -- see *note 3.6::
+     D : Bit_Vector(M .. N) := (M .. N => True);         --< see *note 3.6::>
      E : Bit_Vector(M .. N) := (others => True);
-     F : String(1 .. 1) := (1 => 'F');  -- a one component aggregate: same as 
"F"
+     F : String(1 .. 1) := (1 => 'F');  --< a one component aggregate: same as 
"F">
 
 44/2
-{AI95-00433-01AI95-00433-01} Example of an array aggregate with
+{<AI95-00433-01AI95-00433-01>} <Example of an array aggregate with
 defaulted others choice and with an applicable index constraint provided
-by an enclosing record aggregate:
+by an enclosing record aggregate:>
 
 45/2
-     Buffer'(Size => 50, Pos => 1, Value => String'('x', others => <>))  -- 
see *note 3.7::
+     Buffer'(Size => 50, Pos => 1, Value => String'('x', others => <>))  --< 
see *note 3.7::>
 
                     _Incompatibilities With Ada 83_
 
@@ -23074,7 +23142,7 @@ by an enclosing record aggregate:
                   with function F (The_S3 : in S3) return Integer;
                package Gp is
                   I : constant Integer := F ((1 => '!', others => '?'));
-                      -- The aggregate is legal in Ada 83, illegal in Ada 95.
+                      -- <The aggregate is legal in Ada 83, illegal in Ada 95.>
                end Gp;
 
 45.a.3/1
@@ -23121,19 +23189,19 @@ by an enclosing record aggregate:
                         _Extensions to Ada 95_
 
 45.f/2
-          {AI95-00287-01AI95-00287-01} <> can be used in place of an
+          {<AI95-00287-01AI95-00287-01>} <> can be used in place of an
           expression in an array_aggregate, default-initializing the
           component.
 
                      _Wording Changes from Ada 95_
 
 45.g/2
-          {AI95-00287-01AI95-00287-01} Limited array_aggregates are
+          {<AI95-00287-01AI95-00287-01>} Limited array_aggregates are
           allowed (since all kinds of aggregates can now be limited, see
           *note 4.3::).
 
 45.h/2
-          {AI95-00318-02AI95-00318-02} Fixed aggregates to use the
+          {<AI95-00318-02AI95-00318-02>} Fixed aggregates to use the
           subtype of the return object of a function, rather than the
           result subtype, because they can be different for an
           extended_return_statement, and we want to use the subtype
@@ -23142,7 +23210,7 @@ by an enclosing record aggregate:
                     _Inconsistencies With Ada 2005_
 
 45.i/3
-          {AI05-0037-1AI05-0037-1} Correction: Fixed so the check for
+          {<AI05-0037-1AI05-0037-1>} Correction: Fixed so the check for
           components outside of the array applies to both expressions
           and <>s.  As <> was a new feature in Ada 2005, there should be
           little existing code that depends on a <> component that is
@@ -23153,13 +23221,14 @@ by an enclosing record aggregate:
                     _Wording Changes from Ada 2005_
 
 45.j/3
-          {AI05-0147-1AI05-0147-1} Added a definition of the applicable
-          index constraint for conditional_expressions (which are new).
+          {<AI05-0147-1AI05-0147-1>} Added a definition of the
+          applicable index constraint for conditional_expressions (which
+          are new).
 
                     _Inconsistencies With Ada 2012_
 
 45.k/4
-          {AI05-0084-1AI05-0084-1} Corrigendum: Fixed so that the
+          {<AI05-0084-1AI05-0084-1>} Corrigendum: Fixed so that the
           Default_Component_Value (if any) is used to initialize
           components specified with <>.  This is what users would
           expect, and all Ada 2012 implementation known at the time of
@@ -23170,7 +23239,7 @@ by an enclosing record aggregate:
                     _Wording Changes from Ada 2012_
 
 45.l/4
-          {AI05-0157-1AI05-0157-1} Corrigendum: Added expression
+          {<AI05-0157-1AI05-0157-1>} Corrigendum: Added expression
           functions to the contexts that provide an applicable index
           constraint, because expression functions are handled
           separately in static semantics and legality rules.
@@ -23182,13 +23251,13 @@ File: aarm2012.info,  Node: 4.4,  Next: 4.5,  Prev: 
4.3,  Up: 4
 ===============
 
 1/3
-{AI05-0147-1AI05-0147-1} {AI05-0158-1AI05-0158-1}
-{AI05-0176-1AI05-0176-1} An expression is a formula that defines the
+{<AI05-0147-1AI05-0147-1>} {<AI05-0158-1AI05-0158-1>}
+{<AI05-0176-1AI05-0176-1>} An <expression> is a formula that defines the
 computation or retrieval of a value.  In this International Standard,
 the term "expression" refers to a construct of the syntactic category
 expression or of any of the following categories: choice_expression,
 choice_relation, relation, simple_expression, term, factor, primary,
-conditional_expression, quantified_expression. 
+conditional_expression, quantified_expression.  
 
                                _Syntax_
 
@@ -23199,7 +23268,7 @@ conditional_expression, quantified_expression.
         | relation {xor relation}
 
 2.1/3
-     {AI05-0158-1AI05-0158-1} choice_expression ::=
+     {<AI05-0158-1AI05-0158-1>} choice_expression ::=
           choice_relation {and choice_relation}
         | choice_relation {or choice_relation}
         | choice_relation {xor choice_relation}
@@ -23207,23 +23276,24 @@ conditional_expression, quantified_expression.
         | choice_relation {or else choice_relation}
 
 2.2/3
-     {AI05-0158-1AI05-0158-1} choice_relation ::=
+     {<AI05-0158-1AI05-0158-1>} choice_relation ::=
           simple_expression [relational_operator simple_expression]
 
 3/4
-     {AI05-0158-1AI05-0158-1} {AI12-0022-1AI12-0022-1}
-     {AI12-0039-1AI12-0039-1} relation ::=
+     {<AI05-0158-1AI05-0158-1>} {<AI12-0022-1AI12-0022-1>}
+     {<AI12-0039-1AI12-0039-1>} relation ::=
           simple_expression [relational_operator simple_expression]
-        | tested_simple_expression [not] in membership_choice_list
+        | <tested_>simple_expression [not] in membership_choice_list
         | raise_expression
 
 3.1/3
-     {AI05-0158-1AI05-0158-1} membership_choice_list ::=
+     {<AI05-0158-1AI05-0158-1>} membership_choice_list ::=
      membership_choice {| membership_choice}
 
 3.2/4
-     {AI05-0158-1AI05-0158-1} {AI12-0039-1AI12-0039-1} membership_choice
-     ::= choice_simple_expression | range | subtype_mark
+     {<AI05-0158-1AI05-0158-1>} {<AI12-0039-1AI12-0039-1>}
+     membership_choice ::= <choice_>simple_expression | range | 
+     subtype_mark
 
 4
      simple_expression ::= [unary_adding_operator] term {
@@ -23236,8 +23306,8 @@ conditional_expression, quantified_expression.
      factor ::= primary [** primary] | abs primary | not primary
 
 7/3
-     {AI05-0003-1AI05-0003-1} {AI05-0147-1AI05-0147-1}
-     {AI05-0176-1AI05-0176-1} primary ::=
+     {<AI05-0003-1AI05-0003-1>} {<AI05-0147-1AI05-0147-1>}
+     {<AI05-0176-1AI05-0176-1>} primary ::=
         numeric_literal | null | string_literal | aggregate
       | name | allocator | (expression)
       | (conditional_expression) | (quantified_expression)
@@ -23284,7 +23354,7 @@ base range of its type, the implementation may either 
raise
 Constraint_Error or return the value of the object.
 
 11.a/3
-          Ramification: {AI05-0299-1AI05-0299-1} This means that if
+          Ramification: {<AI05-0299-1AI05-0299-1>} This means that if
           extra-range intermediates are used to hold the value of an
           object of an unconstrained numeric subtype, a Constraint_Error
           can be raised on a read of the object, rather than only on an
@@ -23311,36 +23381,36 @@ Constraint_Error or return the value of the object.
                               _Examples_
 
 12
-Examples of primaries:
+<Examples of primaries:>
 
 13
-     4.0                --  real literal
-     Pi                 --  named number
-     (1 .. 10 => 0)     --  array aggregate
-     Sum                --  variable
-     Integer'Last       --  attribute
-     Sine(X)            --  function call
-     Color'(Blue)       --  qualified expression
-     Real(M*N)          --  conversion
-     (Line_Count + 10)  --  parenthesized expression 
+     4.0                --<  real literal>
+     Pi                 --<  named number>
+     (1 .. 10 => 0)     --<  array aggregate>
+     Sum                --<  variable>
+     Integer'Last       --<  attribute>
+     Sine(X)            --<  function call>
+     Color'(Blue)       --<  qualified expression>
+     Real(M*N)          --<  conversion>
+     (Line_Count + 10)  --<  parenthesized expression >
 
 14
-Examples of expressions:
+<Examples of expressions:>
 
 15/2
-     {AI95-00433-01AI95-00433-01} Volume                      -- primary
-     not Destroyed               -- factor
-     2*Line_Count                -- term
-     -4.0                        -- simple expression
-     -4.0 + A                    -- simple expression
-     B**2 - 4.0*A*C              -- simple expression
-     R*Sin([Unicode 952])*Cos([Unicode 966])             -- simple expression
-     Password(1 .. 3) = "Bwv"    -- relation
-     Count in Small_Int          -- relation
-     Count not in Small_Int      -- relation
-     Index = 0 or Item_Hit       -- expression
-     (Cold and Sunny) or Warm    -- expression (parentheses are required)
-     A**(B**C)                   -- expression (parentheses are required)
+     {<AI95-00433-01AI95-00433-01>} Volume                      --< primary>
+     not Destroyed               --< factor>
+     2*Line_Count                --< term>
+     -4.0                        --< simple expression>
+     -4.0 + A                    --< simple expression>
+     B**2 - 4.0*A*C              --< simple expression>
+     R*Sin([Unicode 952])*Cos([Unicode 966])             --< simple expression>
+     Password(1 .. 3) = "Bwv"    --< relation>
+     Count in Small_Int          --< relation>
+     Count not in Small_Int      --< relation>
+     Index = 0 or Item_Hit       --< expression>
+     (Cold and Sunny) or Warm    --< expression (parentheses are required)>
+     A**(B**C)                   --< expression (parentheses are required)>
 
                         _Extensions to Ada 83_
 
@@ -23367,22 +23437,22 @@ Examples of expressions:
                     _Wording Changes from Ada 2005_
 
 15.c/3
-          {AI05-0003-1AI05-0003-1} Moved qualified_expression from
+          {<AI05-0003-1AI05-0003-1>} Moved qualified_expression from
           primary to name (see *note 4.1::).  This allows the use of
           qualified_expressions in more places.
 
 15.d/3
-          {AI05-0147-1AI05-0147-1} {AI05-0176-1AI05-0176-1} Added
+          {<AI05-0147-1AI05-0147-1>} {<AI05-0176-1AI05-0176-1>} Added
           conditional_expression and quantified_expression to primary.
 
 15.e/3
-          {AI05-0158-1AI05-0158-1} Expanded membership test syntax (see
-          *note 4.5.2::).
+          {<AI05-0158-1AI05-0158-1>} Expanded membership test syntax
+          (see *note 4.5.2::).
 
                     _Inconsistencies With Ada 2012_
 
 15.f/4
-          {AI12-0039-1AI12-0039-1} Corrigendum: Revised membership
+          {<AI12-0039-1AI12-0039-1>} Corrigendum: Revised membership
           syntax to eliminate ambiguities.  In some cases, previously
           ambiguous membership expressions will now have an unambiguous
           meaning.  If an Ada 2012 implementation chose the "wrong"
@@ -23402,7 +23472,7 @@ Examples of expressions:
                    _Incompatibilities With Ada 2012_
 
 15.g/4
-          {AI12-0039-1AI12-0039-1} Corrigendum: The revised membership
+          {<AI12-0039-1AI12-0039-1>} Corrigendum: The revised membership
           syntax will require parentheses in membership_choice_lists in
           some cases where the Ada 2012 grammar did not require them.
           For instance, A in B in C | D is now illegal.  However, such
@@ -23472,10 +23542,10 @@ Parentheses can be used to impose specific 
associations.
 
 9
 For each form of type definition, certain of the above operators are
-predefined; that is, they are implicitly declared immediately after the
-type definition. For each such implicit operator declaration, the
-parameters are called Left and Right for binary operators; the single
-parameter is called Right for unary operators.  [An expression of the
+<predefined>; that is, they are implicitly declared immediately after
+the type definition.  For each such implicit operator declaration, the
+parameters are called Left and Right for <binary> operators; the single
+parameter is called Right for <unary> operators.  [An expression of the
 form X op Y, where op is a binary operator, is equivalent to a
 function_call of the form "op"(X, Y). An expression of the form op Y,
 where op is a unary operator, is equivalent to a function_call of the
@@ -23547,18 +23617,18 @@ association.
                               _Examples_
 
 15
-Examples of precedence:
+<Examples of precedence:>
 
 16
-     not Sunny or Warm    --  same as (not Sunny) or Warm
-     X > 4.0 and Y > 0.0  --  same as (X > 4.0) and (Y > 0.0)
+     not Sunny or Warm    --<  same as (not Sunny) or Warm>
+     X > 4.0 and Y > 0.0  --<  same as (X > 4.0) and (Y > 0.0)>
 
 17
-     -4.0*A**2            --  same as -(4.0 * (A**2))
-     abs(1 + A) + B       --  same as (abs (1 + A)) + B
-     Y**(-3)              --  parentheses are necessary
-     A / B * C            --  same as (A/B)*C
-     A + (B + C)          --  evaluate B + C before adding it to A 
+     -4.0*A**2            --<  same as -(4.0 * (A**2))>
+     abs(1 + A) + B       --<  same as (abs (1 + A)) + B>
+     Y**(-3)              --<  parentheses are necessary>
+     A / B * C            --<  same as (A/B)*C>
+     A + (B + C)          --<  evaluate B + C before adding it to A >
 
                      _Wording Changes from Ada 83_
 
@@ -23591,8 +23661,9 @@ File: aarm2012.info,  Node: 4.5.1,  Next: 4.5.2,  Up: 
4.5
 
 1
 An expression consisting of two relations connected by and then or or
-else (a short-circuit control form) shall resolve to be of some boolean
-type; the expected type for both relations is that same boolean type.
+else (a <short-circuit control form>) shall resolve to be of some
+boolean type; the expected type for both relations is that same boolean
+type.
 
 1.a
           Reason: This rule is written this way so that overload
@@ -23604,40 +23675,40 @@ type; the expected type for both relations is that 
same boolean type.
                           _Static Semantics_
 
 2
-The following logical operators are predefined for every boolean type T,
-for every modular type T, and for every one-dimensional array type T
-whose component type is a boolean type: 
+The following logical operators are predefined for every boolean type
+<T>, for every modular type <T>, and for every one-dimensional array
+type <T> whose component type is a boolean type: 
 
 3
-     function "and"(Left, Right : T) return T
-     function "or" (Left, Right : T) return T
-     function "xor"(Left, Right : T) return T
+     function "and"(Left, Right : <T>) return <T>
+     function "or" (Left, Right : <T>) return <T>
+     function "xor"(Left, Right : <T>) return <T>
 
 3.a/2
-          This paragraph was deleted.{AI95-00145-01AI95-00145-01}
+          <This paragraph was deleted.>{<AI95-00145-01AI95-00145-01>}
 
 3.b/2
-          Ramification: {AI95-00145-01AI95-00145-01} For these
+          Ramification: {<AI95-00145-01AI95-00145-01>} For these
           operators, we are talking about the type without any
           (interesting) subtype, and not some subtype with a constraint
           or exclusion.  Since it's possible that there is no name for
           the "uninteresting" subtype, we denote the type with an
-          italicized T. This applies to the italicized T in many other
-          predefined operators and attributes as well.
+          italicized <T>.  This applies to the italicized <T> in many
+          other predefined operators and attributes as well.
 
 3.c/2
-          {AI95-00145-01AI95-00145-01} In many cases, there is a subtype
-          with the correct properties available.  The italicized T
-          means:
+          {<AI95-00145-01AI95-00145-01>} In many cases, there is a
+          subtype with the correct properties available.  The italicized
+          <T> means:
 
 3.d/2
-             * T'Base, for scalars;
+             * <T>'Base, for scalars;
 
 3.e/2
-             * the first subtype of T, for tagged types;
+             * the first subtype of <T>, for tagged types;
 
 3.f/2
-             * a subtype of the type T without any constraint or null
+             * a subtype of the type <T> without any constraint or null
                exclusion, in other cases.
 
 3.g/2
@@ -23648,13 +23719,13 @@ whose component type is a boolean type:
 
 3.h/2
           Thus, the last case often is the same as the first subtype of
-          T, but that isn't the case for constrained array types (where
-          the correct subtype is unconstrained) and for access types
-          with a null_exclusion (where the correct subtype does not
-          exclude null).
+          <T>, but that isn't the case for constrained array types
+          (where the correct subtype is unconstrained) and for access
+          types with a null_exclusion (where the correct subtype does
+          not exclude null).
 
 3.i/2
-          This italicized T is used for defining operators and
+          This italicized <T> is used for defining operators and
           attributes of the language.  The meaning is intended to be as
           described here.
 
@@ -23690,8 +23761,8 @@ determines the result.
 8
 For the logical operators on arrays, a check is made that for each
 component of the left operand there is a matching component of the right
-operand, and vice versa. Also, a check is made that each component of
-the result belongs to the component subtype. The exception
+operand, and vice versa.  Also, a check is made that each component of
+the result belongs to the component subtype.  The exception
 Constraint_Error is raised if either of the above checks fails.
 
 8.a
@@ -23715,17 +23786,17 @@ Constraint_Error is raised if either of the above 
checks fails.
                               _Examples_
 
 11
-Examples of logical operators:
+<Examples of logical operators:>
 
 12
      Sunny or Warm
-     Filter(1 .. 10) and Filter(15 .. 24)   --   see *note 3.6.1:: 
+     Filter(1 .. 10) and Filter(15 .. 24)   --<   see *note 3.6.1:: >
 
 13
-Examples of short-circuit control forms:
+<Examples of short-circuit control forms:>
 
 14
-     Next_Car.Owner /= null and then Next_Car.Owner.Age > 25   --   see *note 
3.10.1::
+     Next_Car.Owner /= null and then Next_Car.Owner.Age > 25   --<   see *note 
3.10.1::>
      N = 0 or else A(N) = Hit_Value
 
 
@@ -23735,21 +23806,21 @@ File: aarm2012.info,  Node: 4.5.2,  Next: 4.5.3,  
Prev: 4.5.1,  Up: 4.5
 -----------------------------------------------
 
 1
-[ The equality operators = (equals) and /= (not equals) are predefined
-for nonlimited types. The other relational_operators are the ordering
-operators < (less than), <= (less than or equal), > (greater than), and
->= (greater than or equal). The ordering operators are predefined for
-scalar types, and for discrete array types, that is, one-dimensional
+[ The <equality operators> = (equals) and /= (not equals) are predefined
+for nonlimited types.  The other relational_operators are the <ordering
+operators> < (less than), <= (less than or equal), > (greater than), and
+>= (greater than or equal).  The ordering operators are predefined for
+scalar types, and for <discrete array types>, that is, one-dimensional
 array types whose components are of a discrete type.
 
 1.a
-          Ramification: The equality operators are not defined for every
-          nonlimited type -- see below for the exact rule.
+          Ramification: The equality operators are not defined for
+          <every> nonlimited type -- see below for the exact rule.
 
 2/3
-{AI05-0262-1AI05-0262-1} {AI05-0269-1AI05-0269-1} A membership test,
-using in or not in, determines whether or not a value belongs to any
-given subtype or range, is equal to any given value, has a tag that
+{<AI05-0262-1AI05-0262-1>} {<AI05-0269-1AI05-0269-1>} A <membership
+test>, using in or not in, determines whether or not a value belongs to
+any given subtype or range, is equal to any given value, has a tag that
 identifies a type that is covered by a given type, or is convertible to
 and has an accessibility level appropriate for a given access type.
 Membership tests are allowed for all types.]
@@ -23757,50 +23828,50 @@ Membership tests are allowed for all types.]
                         _Name Resolution Rules_
 
 3/3
-{AI95-00251-01AI95-00251-01} {AI05-0158-1AI05-0158-1} The tested type of
-a membership test is determined by the membership_choices of the
-membership_choice_list.  Either all membership_choices of the
+{<AI95-00251-01AI95-00251-01>} {<AI05-0158-1AI05-0158-1>} The <tested
+type> of a membership test is determined by the membership_choices of
+the membership_choice_list.  Either all membership_choices of the
 membership_choice_list shall resolve to the same type, which is the
 tested type; or each membership_choice shall be of an elementary type,
 and the tested type shall be covered by each of these elementary types.
 
 3.1/4
-{AI05-0158-1AI05-0158-1} {AI12-0039-1AI12-0039-1} If the tested type is
-tagged, then the tested_simple_expression shall resolve to be of a type
-that is convertible (see *note 4.6::) to the tested type; if untagged,
-the expected type for the tested_simple_expression is the tested type.
-The expected type of a choice_simple_expression in a membership_choice,
-and of a simple_expression of a range in a membership_choice, is the
-tested type of the membership operation.
+{<AI05-0158-1AI05-0158-1>} {<AI12-0039-1AI12-0039-1>} If the tested type
+is tagged, then the <tested_>simple_expression shall resolve to be of a
+type that is convertible (see *note 4.6::) to the tested type; if
+untagged, the expected type for the <tested_>simple_expression is the
+tested type.  The expected type of a <choice_>simple_expression in a
+membership_choice, and of a simple_expression of a range in a
+membership_choice, is the tested type of the membership operation.
 
 3.a/2
-          Reason: {AI95-00230-01AI95-00230-01} The part of the rule for
-          untagged types is stated in a way that ensures that operands
-          like a string literal are still legal as operands of a
-          membership test.
+          Reason: {<AI95-00230-01AI95-00230-01>} The part of the rule
+          for untagged types is stated in a way that ensures that
+          operands like a string literal are still legal as operands of
+          a membership test.
 
 3.b/4
-          {AI95-00251-01AI95-00251-01} {AI12-0039-1AI12-0039-1} The
+          {<AI95-00251-01AI95-00251-01>} {<AI12-0039-1AI12-0039-1>} The
           significance of "is convertible to" is that we allow the
-          tested_simple_expression to be of any class-wide type that
+          <tested_>simple_expression to be of any class-wide type that
           could be converted to the tested type, not just the one rooted
           at the tested type.  This includes any class-wide type that
           covers the tested type, along with class-wide interfaces in
           some cases.
 
 3.c/3
-          {AI05-0158-1AI05-0158-1} The special rule for determining the
-          tested type for elementary types is to allow numeric literals
-          in membership_choice_lists.  Without the rule, A in B | 1
-          would be illegal as B and 1 would have different types (the
-          literal having type universal integer).
+          {<AI05-0158-1AI05-0158-1>} The special rule for determining
+          the tested type for elementary types is to allow numeric
+          literals in membership_choice_lists.  Without the rule, A in B
+          | 1 would be illegal as B and 1 would have different types
+          (the literal having type <universal integer>).
 
                            _Legality Rules_
 
 4/4
-{AI12-0039-1AI12-0039-1} For a membership test, if the
-tested_simple_expression is of a tagged class-wide type, then the tested
-type shall be (visibly) tagged.
+{<AI12-0039-1AI12-0039-1>} For a membership test, if the
+<tested_>simple_expression is of a tagged class-wide type, then the
+tested type shall be (visibly) tagged.
 
 4.a
           Ramification: Untagged types covered by the tagged class-wide
@@ -23812,13 +23883,13 @@ type shall be (visibly) tagged.
           class-wide type.
 
 4.1/4
-{AI05-0158-1AI05-0158-1} {AI12-0039-1AI12-0039-1} If a membership test
-includes one or more choice_simple_expressions and the tested type of
-the membership test is limited, then the tested type of the membership
-test shall have a visible primitive equality operator.
+{<AI05-0158-1AI05-0158-1>} {<AI12-0039-1AI12-0039-1>} If a membership
+test includes one or more <choice_>simple_expressions and the tested
+type of the membership test is limited, then the tested type of the
+membership test shall have a visible primitive equality operator.
 
 4.b/3
-          Reason: {AI05-0158-1AI05-0158-1} A visible equality operator
+          Reason: {<AI05-0158-1AI05-0158-1>} A visible equality operator
           is required in order to avoid breaking privacy; that is, we
           don't want to depend on a hidden equality operator.
 
@@ -23828,54 +23899,56 @@ test shall have a visible primitive equality operator.
 The result type of a membership test is the predefined type Boolean.
 
 6
-The equality operators are predefined for every specific type T that is
-not limited, and not an anonymous access type, with the following
+The equality operators are predefined for every specific type <T> that
+is not limited, and not an anonymous access type, with the following
 specifications:
 
 7
-     function "=" (Left, Right : T) return Boolean
-     function "/="(Left, Right : T) return Boolean
+     function "=" (Left, Right : <T>) return Boolean
+     function "/="(Left, Right : <T>) return Boolean
 
 7.1/2
-{AI95-00230-01AI95-00230-01} The following additional equality operators
-for the universal_access type are declared in package Standard for use
-with anonymous access types:
+{<AI95-00230-01AI95-00230-01>} The following additional equality
+operators for the <universal_access> type are declared in package
+Standard for use with anonymous access types:
 
 7.2/2
-     function "=" (Left, Right : universal_access) return Boolean
-     function "/="(Left, Right : universal_access) return Boolean
+     function "=" (Left, Right : <universal_access>) return Boolean
+     function "/="(Left, Right : <universal_access>) return Boolean
 
 8
-The ordering operators are predefined for every specific scalar type T,
-and for every discrete array type T, with the following specifications:
+The ordering operators are predefined for every specific scalar type
+<T>, and for every discrete array type <T>, with the following
+specifications:
 
 9
-     function "<" (Left, Right : T) return Boolean
-     function "<="(Left, Right : T) return Boolean
-     function ">" (Left, Right : T) return Boolean
-     function ">="(Left, Right : T) return Boolean
+     function "<" (Left, Right : <T>) return Boolean
+     function "<="(Left, Right : <T>) return Boolean
+     function ">" (Left, Right : <T>) return Boolean
+     function ">="(Left, Right : <T>) return Boolean
 
                         _Name Resolution Rules_
 
 9.1/2
-{AI95-00230-01AI95-00230-01} {AI95-00420-01AI95-00420-01} At least one
-of the operands of an equality operator for universal_access shall be of
-a specific anonymous access type.  Unless the predefined equality
+{<AI95-00230-01AI95-00230-01>} {<AI95-00420-01AI95-00420-01>} At least
+one of the operands of an equality operator for <universal_access> shall
+be of a specific anonymous access type.  Unless the predefined equality
 operator is identified using an expanded name with prefix denoting the
 package Standard, neither operand shall be of an access-to-object type
-whose designated type is D or D'Class, where D has a user-defined
+whose designated type is <D> or <D>'Class, where <D> has a user-defined
 primitive equality operator such that:
 
 9.2/2
    * its result type is Boolean;
 
 9.3/3
-   * {AI05-0020-1AI05-0020-1} it is declared immediately within the same
-     declaration list as D or any partial or incomplete view of D; and
+   * {<AI05-0020-1AI05-0020-1>} it is declared immediately within the
+     same declaration list as <D> or any partial or incomplete view of
+     <D>; and
 
 9.4/2
    * at least one of its operands is an access parameter with designated
-     type D.
+     type <D>.
 
 9.a/2
           Reason: The first sentence prevents compatibility problems by
@@ -23903,9 +23976,9 @@ primitive equality operator such that:
                            _Legality Rules_
 
 9.5/2
-{AI95-00230-01AI95-00230-01} At least one of the operands of the
-equality operators for universal_access shall be of type
-universal_access, or both shall be of access-to-object types, or both
+{<AI95-00230-01AI95-00230-01>} At least one of the operands of the
+equality operators for <universal_access> shall be of type
+<universal_access>, or both shall be of access-to-object types, or both
 shall be of access-to-subprogram types.  Further:
 
 9.6/2
@@ -23931,11 +24004,11 @@ shall be of access-to-subprogram types.  Further:
           restrictions on Ada implementations.
 
 9.8/4
-{AI05-0123-1AI05-0123-1} {AI12-0101-1AI12-0101-1} If the profile of an
-explicitly declared primitive equality operator of an untagged record
+{<AI05-0123-1AI05-0123-1>} {<AI12-0101-1AI12-0101-1>} If the profile of
+an explicitly declared primitive equality operator of an untagged record
 type is type conformant with that of the corresponding predefined
 equality operator, the declaration shall occur before the type is
-frozen. In addition to the places where Legality Rules normally apply
+frozen.  In addition to the places where Legality Rules normally apply
 (see *note 12.3::), this rule applies also in the private part of an
 instance of a generic unit.
 
@@ -23953,7 +24026,7 @@ operands, subject to the accuracy of the type.
 
 11.a
           Ramification: For floating point types, the results of
-          comparing nearly equal values depends on the accuracy of the
+          comparing <nearly> equal values depends on the accuracy of the
           implementation (see *note G.2.1::, "*note G.2.1:: Model of
           Floating Point Arithmetic" for implementations that support
           the Numerics Annex).
@@ -23972,7 +24045,7 @@ or if both are equal to the null value of the access 
type.
 Two access-to-subprogram values are equal if they are the result of the
 same evaluation of an Access attribute_reference, or if both are equal
 to the null value of the access type.  Two access-to-subprogram values
-are unequal if they designate different subprograms. [It is unspecified
+are unequal if they designate different subprograms.  [It is unspecified
 whether two access values that designate the same subprogram but are the
 result of distinct evaluations of Access attribute_references are equal
 or unequal.]
@@ -23983,7 +24056,7 @@ or unequal.]
           necessary to support an indirect call.
 
 14/3
-{AI05-0123-1AI05-0123-1} For a type extension, predefined equality is
+{<AI05-0123-1AI05-0123-1>} For a type extension, predefined equality is
 defined in terms of the primitive [(possibly user-defined)] equals
 operator for the parent type and for any components that have a record
 type in the extension part, and predefined equality for any other
@@ -24001,7 +24074,7 @@ components not inherited from the parent type.
           them equal.
 
 14.b/2
-          {AI95-00349-01AI95-00349-01} The full type extension's
+          {<AI95-00349-01AI95-00349-01>} The full type extension's
           operation is used for a private extension.  This follows as
           only full types have parent types; the type specified in a
           private extension is an ancestor, but not necessarily the
@@ -24014,7 +24087,7 @@ components not inherited from the parent type.
                private
                   type Typ3 is new Pak1.Typ2 with null record;
                end Pak2;
-                 
+  
 
 14.d/2
           the parent type is Pak1.Typ2, not Pak1.Typ1, and the equality
@@ -24022,9 +24095,9 @@ components not inherited from the parent type.
           for Typ3.
 
 14.1/3
-{AI05-0123-1AI05-0123-1} For a derived type whose parent is an untagged
-record type, predefined equality is defined in terms of the primitive
-(possibly user-defined) equals operator of the parent type.
+{<AI05-0123-1AI05-0123-1>} For a derived type whose parent is an
+untagged record type, predefined equality is defined in terms of the
+primitive (possibly user-defined) equals operator of the parent type.
 
 14.e/3
           Reason: This prevents predefined equality from reemerging in
@@ -24033,7 +24106,7 @@ record type, predefined equality is defined in terms of 
the primitive
           primitive.
 
 15/3
-{AI05-0123-1AI05-0123-1} For a private type, if its full type is a
+{<AI05-0123-1AI05-0123-1>} For a private type, if its full type is a
 record type, predefined equality is defined in terms of the primitive
 equals operator of the full type; otherwise, predefined equality for the
 private type is that of its full type.
@@ -24042,7 +24115,7 @@ private type is that of its full type.
 For other composite types, the predefined equality operators [(and
 certain other predefined operations on composite types -- see *note
 4.5.1:: and *note 4.6::)] are defined in terms of the corresponding
-operation on matching components, defined as follows:
+operation on <matching components>, defined as follows:
 
 17
    * For two composite objects or values of the same non-array type,
@@ -24082,13 +24155,13 @@ composite types covered earlier) is defined as 
follows:
      False;
 
 24/3
-   * {AI05-0123-1AI05-0123-1} Otherwise, the result is defined in terms
-     of the primitive equals operator for any matching components that
-     are records, and the predefined equals for any other matching
+   * {<AI05-0123-1AI05-0123-1>} Otherwise, the result is defined in
+     terms of the primitive equals operator for any matching components
+     that are records, and the predefined equals for any other matching
      components.
 
 24.a/3
-          Reason: {AI05-0123-1AI05-0123-1} This asymmetry between
+          Reason: {<AI05-0123-1AI05-0123-1>} This asymmetry between
           components with and without a record type is necessary to
           preserve most upward compatibility and corresponds with the
           corresponding situation with generics, where the predefined
@@ -24108,8 +24181,8 @@ composite types covered earlier) is defined as follows:
           equal; two null records of the same type are always equal.
 
 24.c/3
-          {AI05-0123-1AI05-0123-1} Note that if a composite object has a
-          component of a floating point type, and the floating point
+          {<AI05-0123-1AI05-0123-1>} Note that if a composite object has
+          a component of a floating point type, and the floating point
           type has both a plus and minus zero, which are considered
           equal by the predefined equality, then a block compare cannot
           be used for the predefined composite equality.  Of course,
@@ -24122,19 +24195,19 @@ composite types covered earlier) is defined as 
follows:
           (integer) zero.
 
 24.d/2
-          To be honest: {AI95-00230-01AI95-00230-01} For a component
+          To be honest: {<AI95-00230-01AI95-00230-01>} For a component
           with an anonymous access type, "predefined equality" is that
-          defined for the universal_access type (anonymous access types
-          have no equality operators of their own).
+          defined for the <universal_access> type (anonymous access
+          types have no equality operators of their own).
 
 24.e/3
-          {AI05-0123-1AI05-0123-1} For a component with a record type T,
-          "the primitive equals operator" is the one with two parameters
-          of T which returns Boolean.  We're not talking about some
-          random other primitive function named "=".
+          {<AI05-0123-1AI05-0123-1>} For a component with a record type
+          <T>, "the primitive equals operator" is the one with two
+          parameters of <T> which returns Boolean.  We're not talking
+          about some random other primitive function named "=".
 
 24.1/3
-{AI05-0123-1AI05-0123-1} If the primitive equals operator for an
+{<AI05-0123-1AI05-0123-1>} If the primitive equals operator for an
 untagged record type is abstract, then Program_Error is raised at the
 point of any (implicit) call to that abstract subprogram.
 
@@ -24150,7 +24223,7 @@ point of any (implicit) call to that abstract 
subprogram.
           does not occur.
 
 24.2/1
-{8652/00168652/0016} {AI95-00123-01AI95-00123-01} For any composite
+{<8652/00168652/0016>} {<AI95-00123-01AI95-00123-01>} For any composite
 type, the order in which "=" is called for components is unspecified.
 Furthermore, if the result can be determined before calling "=" on some
 components, it is unspecified whether "=" is called on those components.
@@ -24166,8 +24239,8 @@ predefined "=" operator.
           give the complementary result.  See *note 6.6::.
 
 26/3
-{AI05-0264-1AI05-0264-1} For a discrete array type, the predefined
-ordering operators correspond to lexicographic order using the
+{<AI05-0264-1AI05-0264-1>} For a discrete array type, the predefined
+ordering operators correspond to <lexicographic order> using the
 predefined order relation of the component type: A null array is
 lexicographically less than any array having at least one component.  In
 the case of nonnull arrays, the left operand is lexicographically less
@@ -24175,60 +24248,61 @@ than the right operand if the first component of the 
left operand is
 less than that of the right; otherwise, the left operand is
 lexicographically less than the right operand only if their first
 components are equal and the tail of the left operand is
-lexicographically less than that of the right (the tail consists of the
-remaining components beyond the first and can be null).
+lexicographically less than that of the right (the <tail> consists of
+the remaining components beyond the first and can be null).
 
 26.1/3
-{AI05-0269-1AI05-0269-1} An individual membership test is the membership
-test of a single membership_choice.
+{<AI05-0269-1AI05-0269-1>} An <individual membership test> is the
+membership test of a single membership_choice.
 
 27/4
-{AI05-0158-1AI05-0158-1} {AI12-0039-1AI12-0039-1} For the evaluation of
-a membership test using in whose membership_choice_list has a single
-membership_choice, the tested_simple_expression and the
+{<AI05-0158-1AI05-0158-1>} {<AI12-0039-1AI12-0039-1>} For the evaluation
+of a membership test using in whose membership_choice_list has a single
+membership_choice, the <tested_>simple_expression and the
 membership_choice are evaluated in an arbitrary order; the result is the
 result of the individual membership test for the membership_choice.
 
 27.1/4
-{AI05-0158-1AI05-0158-1} {AI12-0039-1AI12-0039-1} For the evaluation of
-a membership test using in whose membership_choice_list has more than
-one membership_choice, the tested_simple_expression of the membership
+{<AI05-0158-1AI05-0158-1>} {<AI12-0039-1AI12-0039-1>} For the evaluation
+of a membership test using in whose membership_choice_list has more than
+one membership_choice, the <tested_>simple_expression of the membership
 test is evaluated first and the result of the operation is equivalent to
 that of a sequence consisting of an individual membership test on each
 membership_choice combined with the short-circuit control form or else.
 
 27.a.1/3
-          Ramification: {AI05-0158-1AI05-0158-1} This equivalence
+          Ramification: {<AI05-0158-1AI05-0158-1>} This equivalence
           includes the evaluation of the membership_choices; evaluation
           stops as soon as an individual choice evaluates to True.
 
 28/3
-{AI05-0158-1AI05-0158-1} {AI05-0269-1AI05-0269-1} An individual
+{<AI05-0158-1AI05-0158-1>} {<AI05-0269-1AI05-0269-1>} An individual
 membership test yields the result True if:
 
 28.1/4
-   * {AI05-0158-1AI05-0158-1} {AI05-0264-1AI05-0264-1}
-     {AI12-0039-1AI12-0039-1} The membership_choice is a
-     choice_simple_expression, and the tested_simple_expression is equal
-     to the value of the membership_choice.  If the tested type is a
-     record type or a limited type, the test uses the primitive equality
-     for the type; otherwise, the test uses predefined equality.
+   * {<AI05-0158-1AI05-0158-1>} {<AI05-0264-1AI05-0264-1>}
+     {<AI12-0039-1AI12-0039-1>} The membership_choice is a
+     <choice_>simple_expression, and the <tested_>simple_expression is
+     equal to the value of the membership_choice.  If the tested type is
+     a record type or a limited type, the test uses the primitive
+     equality for the type; otherwise, the test uses predefined
+     equality.
 
 28.2/4
-   * {AI05-0153-3AI05-0153-3} {AI05-0158-1AI05-0158-1}
-     {AI12-0039-1AI12-0039-1} The membership_choice is a range and the
-     value of the tested_simple_expression belongs to the given range.
+   * {<AI05-0153-3AI05-0153-3>} {<AI05-0158-1AI05-0158-1>}
+     {<AI12-0039-1AI12-0039-1>} The membership_choice is a range and the
+     value of the <tested_>simple_expression belongs to the given range.
 
 29/4
-   * {AI05-0153-3AI05-0153-3} {AI05-0158-1AI05-0158-1}
-     {AI12-0039-1AI12-0039-1} {AI12-0071-1AI12-0071-1} The
+   * {<AI05-0153-3AI05-0153-3>} {<AI05-0158-1AI05-0158-1>}
+     {<AI12-0039-1AI12-0039-1>} {<AI12-0071-1AI12-0071-1>} The
      membership_choice is a subtype_mark, the tested type is scalar, the
-     value of the tested_simple_expression belongs to the range of the
+     value of the <tested_>simple_expression belongs to the range of the
      named subtype, and the value satisfies the predicates of the named
      subtype.
 
 29.a/3
-          Ramification: {AI05-0153-3AI05-0153-3} The scalar membership
+          Ramification: {<AI05-0153-3AI05-0153-3>} The scalar membership
           test only does a range check and a predicate check.  It does
           not perform any other check, such as whether a value falls in
           a "hole" of a "holey" enumeration type.  The Pos attribute
@@ -24241,79 +24315,79 @@ membership test yields the result True if:
           outside Float'Range.
 
 30/4
-   * {AI95-00231-01AI95-00231-01} {AI05-0153-3AI05-0153-3}
-     {AI05-0158-1AI05-0158-1} {AI12-0039-1AI12-0039-1}
-     {AI12-0071-1AI12-0071-1} The membership_choice is a subtype_mark,
+   * {<AI95-00231-01AI95-00231-01>} {<AI05-0153-3AI05-0153-3>}
+     {<AI05-0158-1AI05-0158-1>} {<AI12-0039-1AI12-0039-1>}
+     {<AI12-0071-1AI12-0071-1>} The membership_choice is a subtype_mark,
      the tested type is not scalar, the value of the
-     tested_simple_expression satisfies any constraints of the named
+     <tested_>simple_expression satisfies any constraints of the named
      subtype, the value satisfies the predicates of the named subtype,
      and:
 
 30.1/4
-             * {AI95-00231-01AI95-00231-01} {AI12-0039-1AI12-0039-1} if
-               the type of the tested_simple_expression is class-wide,
-               the value has a tag that identifies a type covered by the
-               tested type;
+             * {<AI95-00231-01AI95-00231-01>} {<AI12-0039-1AI12-0039-1>}
+               if the type of the <tested_>simple_expression is
+               class-wide, the value has a tag that identifies a type
+               covered by the tested type;
 
 30.a/4
-          Ramification: {AI12-0039-1AI12-0039-1} Note that the tag is
-          not checked if the tested_simple_expression is of a specific
+          Ramification: {<AI12-0039-1AI12-0039-1>} Note that the tag is
+          not checked if the <tested_>simple_expression is of a specific
           type.
 
 30.2/4
-             * {AI95-00231-01AI95-00231-01} {AI05-0149-1AI05-0149-1}
-               {AI12-0039-1AI12-0039-1} if the tested type is an access
-               type and the named subtype excludes null, the value of
-               the tested_simple_expression is not null;
+             * {<AI95-00231-01AI95-00231-01>} {<AI05-0149-1AI05-0149-1>}
+               {<AI12-0039-1AI12-0039-1>} if the tested type is an
+               access type and the named subtype excludes null, the
+               value of the <tested_>simple_expression is not null;
 
 30.3/4
-             * {AI05-0149-1AI05-0149-1} {AI12-0039-1AI12-0039-1} if the
-               tested type is a general access-to-object type, the type
-               of the tested_simple_expression is convertible to the
-               tested type and its accessibility level is no deeper than
-               that of the tested type; further, if the designated type
-               of the tested type is tagged and the
-               tested_simple_expression is nonnull, the tag of the
+             * {<AI05-0149-1AI05-0149-1>} {<AI12-0039-1AI12-0039-1>} if
+               the tested type is a general access-to-object type, the
+               type of the <tested_>simple_expression is convertible to
+               the tested type and its accessibility level is no deeper
+               than that of the tested type; further, if the designated
+               type of the tested type is tagged and the
+               <tested_>simple_expression is nonnull, the tag of the
                object designated by the value of the
-               tested_simple_expression is covered by the designated
+               <tested_>simple_expression is covered by the designated
                type of the tested type.
 
 31/3
-{AI05-0264-1AI05-0264-1} Otherwise, the test yields the result False.
+{<AI05-0264-1AI05-0264-1>} Otherwise, the test yields the result False.
 
 32
 A membership test using not in gives the complementary result to the
 corresponding membership test using in.
 
 32.a/4
-          To be honest: {AI05-0158-1AI05-0158-1}
-          {AI12-0039-1AI12-0039-1} X not in A | B | C is intended to be
-          exactly equivalent to not (X in A | B | C), including the
-          order of evaluation of the tested_simple_expression and
-          membership_choices.
+          To be honest: {<AI05-0158-1AI05-0158-1>}
+          {<AI12-0039-1AI12-0039-1>} <X> not in <A> | <B> | <C> is
+          intended to be exactly equivalent to not (<X> in <A> | <B> |
+          <C>), including the order of evaluation of the
+          <tested_>simple_expression and membership_choices.
 
                      _Implementation Requirements_
 
 32.1/1
-{8652/00168652/0016} {AI95-00123-01AI95-00123-01} For all nonlimited
+{<8652/00168652/0016>} {<AI95-00123-01AI95-00123-01>} For all nonlimited
 types declared in language-defined packages, the "=" and "/=" operators
 of the type shall behave as if they were the predefined equality
 operators for the purposes of the equality of composite types and
 generic formal types.
 
 32.a.1/3
-          Ramification: {AI95-00123-01AI95-00123-01}
-          {AI05-0123-1AI05-0123-1} If any language-defined types are
+          Ramification: {<AI95-00123-01AI95-00123-01>}
+          {<AI05-0123-1AI05-0123-1>} If any language-defined types are
           implemented with a user-defined "=" operator, then either the
           full type must be a record type, or the compiler must use
           "magic" to implement equality for this type.  A normal
-          user-defined "=" operator for a non-record type does not meet
-          this requirement.
+          user-defined "=" operator for a non-record type does <not>
+          meet this requirement.
 
      NOTES
 
 33/2
-     This paragraph was deleted.{AI95-00230-01AI95-00230-01}
+     <This paragraph was deleted.>{<AI95-00230-01AI95-00230-01>}
 
 34
      14  If a composite type has components that depend on
@@ -24325,28 +24399,28 @@ generic formal types.
                               _Examples_
 
 35
-Examples of expressions involving relational operators and membership
-tests:
+<Examples of expressions involving relational operators and membership
+tests:>
 
 36
      X /= Y
 
 37
-     "" < "A" and "A" < "Aa"     --  True
-     "Aa" < "B" and "A" < "A  "  --  True
+     "" < "A" and "A" < "Aa"     --<  True>
+     "Aa" < "B" and "A" < "A  "  --<  True>
 
 38/3
-     {AI05-0264-1AI05-0264-1} My_Car = null               -- True if My_Car 
has been set to null (see *note 3.10.1::)
-     My_Car = Your_Car           -- True if we both share the same car
-     My_Car.all = Your_Car.all   -- True if the two cars are identical
+     {<AI05-0264-1AI05-0264-1>} My_Car = null               --< True if My_Car 
has been set to null (see *note 3.10.1::)>
+     My_Car = Your_Car           --< True if we both share the same car>
+     My_Car.all = Your_Car.all   --< True if the two cars are identical>
 
 39/3
-     {AI05-0158-1AI05-0158-1} N not in 1 .. 10            -- range membership 
test
-     Today in Mon .. Fri         -- range membership test
-     Today in Weekday            -- subtype membership test (see *note 3.5.1::)
-     Card in Clubs | Spades      -- list membership test (see *note 3.5.1::)
-     Archive in Disk_Unit        -- subtype membership test (see *note 3.8.1::)
-     Tree.all in Addition'Class  -- class membership test (see *note 3.9.1::)
+     {<AI05-0158-1AI05-0158-1>} N not in 1 .. 10            --< range 
membership test>
+     Today in Mon .. Fri         --< range membership test>
+     Today in Weekday            --< subtype membership test (see *note 
3.5.1::)>
+     Card in Clubs | Spades      --< list membership test (see *note 3.5.1::)>
+     Archive in Disk_Unit        --< subtype membership test (see *note 
3.8.1::)>
+     Tree.all in Addition'Class  --< class membership test (see *note 3.9.1::)>
 
                         _Extensions to Ada 83_
 
@@ -24368,7 +24442,7 @@ tests:
 39.d
           We use the term "equality operator" to refer to both the =
           (equals) and /= (not equals) operators.  Ada 83 referred to =
-          as the equality operator, and /= as the inequality operator.
+          as <the> equality operator, and /= as the inequality operator.
           The new wording is more consistent with the ISO 10646 name for
           "=" (equals sign) and provides a category similar to "ordering
           operator" to refer to both = and /=.
@@ -24379,38 +24453,38 @@ tests:
                         _Extensions to Ada 95_
 
 39.f/2
-          {AI95-00230-01AI95-00230-01} {AI95-00420-01AI95-00420-01} The
-          universal_access equality operators are new.  They provide
-          equality operations (most importantly, testing against null)
-          for anonymous access types.
+          {<AI95-00230-01AI95-00230-01>} {<AI95-00420-01AI95-00420-01>}
+          The <universal_access> equality operators are new.  They
+          provide equality operations (most importantly, testing against
+          null) for anonymous access types.
 
                      _Wording Changes from Ada 95_
 
 39.g/2
-          {8652/00168652/0016} {AI95-00123-01AI95-00123-01} Corrigendum:
-          Wording was added to clarify that the order of calls (and
-          whether the calls are made at all) on "=" for components is
-          unspecified.  Also clarified that "=" must compose properly
-          for language-defined types.
+          {<8652/00168652/0016>} {<AI95-00123-01AI95-00123-01>}
+          Corrigendum: Wording was added to clarify that the order of
+          calls (and whether the calls are made at all) on "=" for
+          components is unspecified.  Also clarified that "=" must
+          compose properly for language-defined types.
 
 39.h/2
-          {AI95-00251-01AI95-00251-01} Memberships were adjusted to
+          {<AI95-00251-01AI95-00251-01>} Memberships were adjusted to
           allow interfaces which don't cover the tested type, in order
           to be consistent with type conversions.
 
                     _Inconsistencies With Ada 2005_
 
 39.i/3
-          {AI05-0123-1AI05-0123-1} User-defined untagged record equality
-          is now defined to compose and be used in generics.  Any code
-          which assumes that the predefined equality reemerges in
-          generics and in predefined equals for composite types could
+          {<AI05-0123-1AI05-0123-1>} User-defined untagged record
+          equality is now defined to compose and be used in generics.
+          Any code which assumes that the predefined equality reemerges
+          in generics and in predefined equals for composite types could
           fail.  However, it is much more likely that this change will
           fix bugs, as the behavior that would be expected (the
           user-defined "=" is used) will be true in more cases.
 
 39.j/3
-          {AI05-0123-1AI05-0123-1} If a composite type contains a
+          {<AI05-0123-1AI05-0123-1>} If a composite type contains a
           component of an untagged record type with an abstract equality
           operation, calling "=" on the composite type will raise
           Program_Error, while in the past a result will be returned
@@ -24421,7 +24495,7 @@ tests:
                    _Incompatibilities With Ada 2005_
 
 39.k/3
-          {AI05-0123-1AI05-0123-1} Late and hidden overriding of
+          {<AI05-0123-1AI05-0123-1>} Late and hidden overriding of
           equality for untagged record types is now prohibited.  This is
           necessary to make composition of equality predictable.  It
           should always be possible to move the overriding to an earlier
@@ -24430,23 +24504,23 @@ tests:
                        _Extensions to Ada 2005_
 
 39.l/3
-          {AI05-0149-1AI05-0149-1} Membership tests for valid
+          {<AI05-0149-1AI05-0149-1>} Membership tests for valid
           accessibility levels and tag coverage by the designated type
           for general access types are new.
 
 39.m/3
-          {AI05-0153-3AI05-0153-3} Membership tests now include a
+          {<AI05-0153-3AI05-0153-3>} Membership tests now include a
           predicate check.
 
 39.n/3
-          {AI05-0158-1AI05-0158-1} Membership tests now allow multiple
+          {<AI05-0158-1AI05-0158-1>} Membership tests now allow multiple
           choices.
 
                     _Wording Changes from Ada 2005_
 
 39.o/3
-          {AI05-0020-1AI05-0020-1} Correction: Wording was added to
-          clarify that universal_access "=" does not apply if an
+          {<AI05-0020-1AI05-0020-1>} Correction: Wording was added to
+          clarify that <universal_access> "=" does not apply if an
           appropriate operator is declared for a partial or incomplete
           view of the designated type.  Otherwise, adding a partial or
           incomplete view could make some "=" operators ambiguous.
@@ -24454,32 +24528,32 @@ tests:
                     _Inconsistencies With Ada 2012_
 
 39.p/4
-          {AI12-0101-1AI12-0101-1} Corrigendum: Removed the incompatible
-          rule preventing the declaration of "=" in the private part of
-          a package specification for an untagged record type that
-          completes a private type.  Any code that calls the predefined
-          "=" on the private type will now execute the body for the
-          redefined "=" instead for the predefined "=".  Eliminating the
-          rule eliminates an unnecessary incompatibility (especially for
-          programs that never call the predefined "=").  Moreover, (like
-          the composition of untagged record "=" in Ada 2012) this is
-          more likely to fix bugs than cause them (who defines an "="
-          with a presumably different result and does not want clients
-          to us it?).
+          {<AI12-0101-1AI12-0101-1>} Corrigendum: Removed the
+          incompatible rule preventing the declaration of "=" in the
+          private part of a package specification for an untagged record
+          type that completes a private type.  Any code that calls the
+          predefined "=" on the private type will now execute the body
+          for the redefined "=" instead for the predefined "=".
+          Eliminating the rule eliminates an unnecessary incompatibility
+          (especially for programs that never call the predefined "=").
+          Moreover, (like the composition of untagged record "=" in Ada
+          2012) this is more likely to fix bugs than cause them (who
+          defines an "=" with a presumably different result and does not
+          want clients to us it?).
 
                     _Wording Changes from Ada 2012_
 
 39.q/4
-          {AI12-0039-1AI12-0039-1} Corrigendum: Reworded membership
-          tests to use the syntax items tested_simple_expression and
-          choice_simple_expression.  This was necessary to eliminate
+          {<AI12-0039-1AI12-0039-1>} Corrigendum: Reworded membership
+          tests to use the syntax items <tested_>simple_expression and
+          <choice_>simple_expression.  This was necessary to eliminate
           wording ambiguities introduced when the grammar was corrected
           to eliminate syntax ambiguities.  (Both of the above are now
           simple_expressions, so merely talking about a
           simple_expression is insufficient.)
 
 39.r/4
-          {AI12-0071-1AI12-0071-1} Corrigendum: Updated wording of the
+          {<AI12-0071-1AI12-0071-1>} Corrigendum: Updated wording of the
           membership tests to use the new term "satisfies the
           predicates" (see *note 3.2.4::).
 
@@ -24493,29 +24567,29 @@ File: aarm2012.info,  Node: 4.5.3,  Next: 4.5.4,  
Prev: 4.5.2,  Up: 4.5
 
 1
 The binary adding operators + (addition) and - (subtraction) are
-predefined for every specific numeric type T with their conventional
+predefined for every specific numeric type <T> with their conventional
 meaning.  They have the following specifications:
 
 2
-     function "+"(Left, Right : T) return T
-     function "-"(Left, Right : T) return T
+     function "+"(Left, Right : <T>) return <T>
+     function "-"(Left, Right : <T>) return <T>
 
 3
 The concatenation operators & are predefined for every nonlimited,
-one-dimensional array type T with component type C. They have the
+one-dimensional array type <T> with component type <C>.  They have the
 following specifications:
 
 4
-     function "&"(Left : T; Right : T) return T
-     function "&"(Left : T; Right : C) return T
-     function "&"(Left : C; Right : T) return T
-     function "&"(Left : C; Right : C) return T
+     function "&"(Left : <T>; Right : <T>) return <T>
+     function "&"(Left : <T>; Right : <C>) return <T>
+     function "&"(Left : <C>; Right : <T>) return <T>
+     function "&"(Left : <C>; Right : <C>) return <T>
 
                           _Dynamic Semantics_
 
 5
-For the evaluation of a concatenation with result type T, if both
-operands are of type T, the result of the concatenation is a
+For the evaluation of a concatenation with result type <T>, if both
+operands are of type <T>, the result of the concatenation is a
 one-dimensional array whose length is the sum of the lengths of its
 operands, and whose components comprise the components of the left
 operand followed by the components of the right operand.  If the left
@@ -24539,17 +24613,17 @@ follows:
      is that of the left operand.
 
 8
-[The upper bound is determined by the lower bound and the length.] A
+[The upper bound is determined by the lower bound and the length.]  A
 check is made that the upper bound of the result of the concatenation
 belongs to the range of the index subtype, unless the result is a null
-array. Constraint_Error is raised if this check fails.
+array.  Constraint_Error is raised if this check fails.
 
 9
-If either operand is of the component type C, the result of the
+If either operand is of the component type <C>, the result of the
 concatenation is given by the above rules, using in place of such an
 operand an array having this operand as its only component (converted to
 the component subtype) and having the lower bound of the index subtype
-of the array type as its lower bound. 
+of the array type as its lower bound.  
 
 9.a
           Ramification: The conversion might raise Constraint_Error.
@@ -24590,15 +24664,15 @@ anonymous object, as for any function call (see *note 
6.5::).
                               _Examples_
 
 12
-Examples of expressions involving binary adding operators:
+<Examples of expressions involving binary adding operators:>
 
 13
-     Z + 0.1      --  Z has to be of a real type 
+     Z + 0.1      --<  Z has to be of a real type >
 
 14
-     "A" & "BCD"  --  concatenation of two string literals
-     'A' & "BCD"  --  concatenation of a character literal and a string literal
-     'A' & 'A'    --  concatenation of two character literals 
+     "A" & "BCD"  --<  concatenation of two string literals>
+     'A' & "BCD"  --<  concatenation of a character literal and a string 
literal>
+     'A' & 'A'    --<  concatenation of two character literals >
 
                      _Inconsistencies With Ada 83_
 
@@ -24639,12 +24713,12 @@ File: aarm2012.info,  Node: 4.5.4,  Next: 4.5.5,  
Prev: 4.5.3,  Up: 4.5
 
 1
 The unary adding operators + (identity) and - (negation) are predefined
-for every specific numeric type T with their conventional meaning.  They
-have the following specifications:
+for every specific numeric type <T> with their conventional meaning.
+They have the following specifications:
 
 2
-     function "+"(Right : T) return T
-     function "-"(Right : T) return T
+     function "+"(Right : <T>) return <T>
+     function "-"(Right : <T>) return <T>
 
      NOTES
 
@@ -24665,13 +24739,13 @@ File: aarm2012.info,  Node: 4.5.5,  Next: 4.5.6,  
Prev: 4.5.4,  Up: 4.5
 1
 The multiplying operators * (multiplication), / (division), mod
 (modulus), and rem (remainder) are predefined for every specific integer
-type T:
+type <T>:
 
 2
-     function "*"  (Left, Right : T) return T
-     function "/"  (Left, Right : T) return T
-     function "mod"(Left, Right : T) return T
-     function "rem"(Left, Right : T) return T
+     function "*"  (Left, Right : <T>) return <T>
+     function "/"  (Left, Right : <T>) return <T>
+     function "mod"(Left, Right : <T>) return <T>
+     function "rem"(Left, Right : <T>) return <T>
 
 3
 Signed integer multiplication has its conventional meaning.
@@ -24690,10 +24764,11 @@ absolute value of B. Signed integer division 
satisfies the identity:
      (-A)/B = -(A/B) = A/(-B)
 
 8/3
-{AI05-0260-1AI05-0260-1} The signed integer modulus operator is defined
-such that the result of A mod B is either zero, or has the sign of B and
-an absolute value less than the absolute value of B; in addition, for
-some signed integer value N, this result satisfies the relation:
+{<AI05-0260-1AI05-0260-1>} The signed integer modulus operator is
+defined such that the result of A mod B is either zero, or has the sign
+of B and an absolute value less than the absolute value of B; in
+addition, for some signed integer value N, this result satisfies the
+relation:
 
 9
      A = B*N + (A mod B)
@@ -24711,72 +24786,72 @@ is only possible for the "*" operator)].
 
 11
 Multiplication and division operators are predefined for every specific
-floating point type T:
+floating point type <T>:
 
 12
-     function "*"(Left, Right : T) return T
-     function "/"(Left, Right : T) return T
+     function "*"(Left, Right : <T>) return <T>
+     function "/"(Left, Right : <T>) return <T>
 
 13
 The following multiplication and division operators, with an operand of
 the predefined type Integer, are predefined for every specific fixed
-point type T:
+point type <T>:
 
 14
-     function "*"(Left : T; Right : Integer) return T
-     function "*"(Left : Integer; Right : T) return T
-     function "/"(Left : T; Right : Integer) return T
+     function "*"(Left : <T>; Right : Integer) return <T>
+     function "*"(Left : Integer; Right : <T>) return <T>
+     function "/"(Left : <T>; Right : Integer) return <T>
 
 15
 [All of the above multiplying operators are usable with an operand of an
 appropriate universal numeric type.]  The following additional
-multiplying operators for root_real are predefined[, and are usable when
-both operands are of an appropriate universal or root numeric type, and
-the result is allowed to be of type root_real, as in a
+multiplying operators for <root_real> are predefined[, and are usable
+when both operands are of an appropriate universal or root numeric type,
+and the result is allowed to be of type <root_real>, as in a
 number_declaration]:
 
 15.a
           Ramification: These operators are analogous to the multiplying
           operators involving fixed or floating point types where
-          root_real substitutes for the fixed or floating point type,
-          and root_integer substitutes for Integer.  Only values of the
-          corresponding universal numeric types are implicitly
+          <root_real> substitutes for the fixed or floating point type,
+          and <root_integer> substitutes for Integer.  Only values of
+          the corresponding universal numeric types are implicitly
           convertible to these root numeric types, so these operators
           are really restricted to use with operands of a universal
           type, or the specified root numeric types.
 
 16
-     function "*"(Left, Right : root_real) return root_real
-     function "/"(Left, Right : root_real) return root_real
+     function "*"(Left, Right : <root_real>) return <root_real>
+     function "/"(Left, Right : <root_real>) return <root_real>
 
 17
-     function "*"(Left : root_real; Right : root_integer) return root_real
-     function "*"(Left : root_integer; Right : root_real) return root_real
-     function "/"(Left : root_real; Right : root_integer) return root_real
+     function "*"(Left : <root_real>; Right : <root_integer>) return 
<root_real>
+     function "*"(Left : <root_integer>; Right : <root_real>) return 
<root_real>
+     function "/"(Left : <root_real>; Right : <root_integer>) return 
<root_real>
 
 18
 Multiplication and division between any two fixed point types are
 provided by the following two predefined operators:
 
 18.a
-          Ramification: Universal_fixed is the universal type for the
+          Ramification: <Universal_fixed> is the universal type for the
           class of fixed point types, meaning that these operators take
           operands of any fixed point types (not necessarily the same)
           and return a result that is implicitly (or explicitly)
           convertible to any fixed point type.
 
 19
-     function "*"(Left, Right : universal_fixed) return universal_fixed
-     function "/"(Left, Right : universal_fixed) return universal_fixed
+     function "*"(Left, Right : <universal_fixed>) return <universal_fixed>
+     function "/"(Left, Right : <universal_fixed>) return <universal_fixed>
 
                         _Name Resolution Rules_
 
 19.1/2
-{AI95-00364-01AI95-00364-01} {AI95-00420-01AI95-00420-01} The above two
-fixed-fixed multiplying operators shall not be used in a context where
-the expected type for the result is itself universal_fixed [-- the
-context has to identify some other numeric type to which the result is
-to be converted, either explicitly or implicitly].  Unless the
+{<AI95-00364-01AI95-00364-01>} {<AI95-00420-01AI95-00420-01>} The above
+two fixed-fixed multiplying operators shall not be used in a context
+where the expected type for the result is itself <universal_fixed> [--
+the context has to identify some other numeric type to which the result
+is to be converted, either explicitly or implicitly].  Unless the
 predefined universal operator is identified using an expanded name with
 prefix denoting the package Standard, an explicit conversion is required
 on the result when using the above fixed-fixed multiplication operator
@@ -24784,43 +24859,43 @@ if either operand is of a type having a user-defined 
primitive
 multiplication operator such that:
 
 19.2/3
-   * {AI05-0020-1AI05-0020-1} {AI05-0209-1AI05-0209-1} it is declared
-     immediately within the same declaration list as the type or any
-     partial or incomplete view thereof; and
+   * {<AI05-0020-1AI05-0020-1>} {<AI05-0209-1AI05-0209-1>} it is
+     declared immediately within the same declaration list as the type
+     or any partial or incomplete view thereof; and
 
 19.3/2
    * both of its formal parameters are of a fixed-point type.
 
 19.4/2
-{AI95-00364-01AI95-00364-01} {AI95-00420-01AI95-00420-01} A
+{<AI95-00364-01AI95-00364-01>} {<AI95-00420-01AI95-00420-01>} A
 corresponding requirement applies to the universal fixed-fixed division
 operator.
 
 19.a/2
-          Discussion: The small of universal_fixed is infinitesimal; no
-          loss of precision is permitted.  However, fixed-fixed division
-          is impractical to implement when an exact result is required,
-          and multiplication will sometimes result in unanticipated
-          overflows in such circumstances, so we require an explicit
-          conversion to be inserted in expressions like A * B * C if A,
-          B, and C are each of some fixed point type.
+          Discussion: The <small> of <universal_fixed> is infinitesimal;
+          no loss of precision is permitted.  However, fixed-fixed
+          division is impractical to implement when an exact result is
+          required, and multiplication will sometimes result in
+          unanticipated overflows in such circumstances, so we require
+          an explicit conversion to be inserted in expressions like A *
+          B * C if A, B, and C are each of some fixed point type.
 
 19.b/2
           On the other hand, X := A * B; is permitted by this rule, even
           if X, A, and B are all of different fixed point types, since
           the expected type for the result of the multiplication is the
-          type of X, which is necessarily not universal_fixed.
+          type of X, which is necessarily not <universal_fixed>.
 
 19.c/2
-          {AI95-00364-01AI95-00364-01} {AI95-00420-01AI95-00420-01} We
-          have made these into Name Resolution rules to ensure that
+          {<AI95-00364-01AI95-00364-01>} {<AI95-00420-01AI95-00420-01>}
+          We have made these into Name Resolution rules to ensure that
           user-defined primitive fixed-fixed operators are not made
           unusable due to the presence of these universal fixed-fixed
           operators.  But we do allow these operators to be used if
           prefixed by package Standard, so that they can be used in the
           definitions of user-defined operators.
 
-Paragraph 20 was deleted.
+<Paragraph 20 was deleted.>
 
                           _Dynamic Semantics_
 
@@ -24829,15 +24904,15 @@ The multiplication and division operators for real 
types have their
 conventional meaning.  [For floating point types, the accuracy of the
 result is determined by the precision of the result type.  For decimal
 fixed point types, the result is truncated toward zero if the
-mathematical result is between two multiples of the small of the
+mathematical result is between two multiples of the <small> of the
 specific result type (possibly determined by context); for ordinary
 fixed point types, if the mathematical result is between two multiples
-of the small, it is unspecified which of the two is the result. ]
+of the <small>, it is unspecified which of the two is the result.  ]
 
 22
 The exception Constraint_Error is raised by integer division, rem, and
-mod if the right operand is zero.  [Similarly, for a real type T with
-T'Machine_Overflows True, division by zero raises Constraint_Error.]
+mod if the right operand is zero.  [Similarly, for a real type <T> with
+<T'>Machine_Overflows True, division by zero raises Constraint_Error.]
 
      NOTES
 
@@ -24882,7 +24957,7 @@ T'Machine_Overflows True, division by zero raises 
Constraint_Error.]
                               _Examples_
 
 31
-Examples of expressions involving multiplying operators:
+<Examples of expressions involving multiplying operators:>
 
 32
      I : Integer := 1;
@@ -24890,41 +24965,41 @@ Examples of expressions involving multiplying 
operators:
      K : Integer := 3;
 
 33
-     X : Real := 1.0;                      --     see *note 3.5.7::
+     X : Real := 1.0;                      --<     see *note 3.5.7::>
      Y : Real := 2.0;
 
 34
-     F : Fraction := 0.25;                 --     see *note 3.5.9::
+     F : Fraction := 0.25;                 --<     see *note 3.5.9::>
      G : Fraction := 0.5;
 
 35
-     Expression     Value     Result Type
+     <Expression>     <Value>     <Result Type>
 
-     I*J               2         same as I and J, that is, Integer
-     K/J               1         same as K and J, that is, Integer
-     K mod J     1         same as K and J, that is, Integer
+     I*J               2         <same as I and J, that is, Integer>
+     K/J               1         <same as K and J, that is, Integer>
+     K mod J     1         <same as K and J, that is, Integer>
 
-     X/Y               0.5       same as X and Y, that is, Real
-     F/2               0.125     same as F, that is, Fraction
+     X/Y               0.5       <same as X and Y, that is, Real>
+     F/2               0.125     <same as F, that is, Fraction>
 
-     3*F               0.75      same as F, that is, Fraction
-     0.75*G            0.375     universal_fixed, implicitly convertible
-                                 to any fixed point type
-     Fraction(F*G)     0.125     Fraction, as stated by the conversion
-     Real(J)*Y         4.0       Real, the type of both operands after
-                                 conversion of J
+     3*F               0.75      <same as F, that is, Fraction>
+     0.75*G            0.375     <universal_fixed, implicitly convertible>
+                                 <to any fixed point type>
+     Fraction(F*G)     0.125     <Fraction, as stated by the conversion>
+     Real(J)*Y         4.0       <Real, the type of both operands after>
+                                 <conversion of J>
 
                     _Incompatibilities With Ada 83_
 
 35.a.1/2
-          {AI95-00364-01AI95-00364-01} {AI95-00420-01AI95-00420-01} The
-          universal fixed-fixed multiplying operators are now directly
-          available (see below).  Any attempt to use user-defined
-          fixed-fixed multiplying operators will be ambiguous with the
-          universal ones.  The only way to use the user-defined
-          operators is to fully qualify them in a prefix call.  This
-          problem was not documented during the design of Ada 95, and
-          has been mitigated by Ada 2005.
+          {<AI95-00364-01AI95-00364-01>} {<AI95-00420-01AI95-00420-01>}
+          The universal fixed-fixed multiplying operators are now
+          directly available (see below).  Any attempt to use
+          user-defined fixed-fixed multiplying operators will be
+          ambiguous with the universal ones.  The only way to use the
+          user-defined operators is to fully qualify them in a prefix
+          call.  This problem was not documented during the design of
+          Ada 95, and has been mitigated by Ada 2005.
 
                         _Extensions to Ada 83_
 
@@ -24937,9 +25012,9 @@ Examples of expressions involving multiplying operators:
           multiply or divide was felt to be inappropriate.
 
 35.b
-          The type universal_fixed is covered by universal_real, so real
-          literals and fixed point operands may be multiplied or divided
-          directly, without any explicit conversions required.
+          The type <universal_fixed> is covered by <universal_real>, so
+          real literals and fixed point operands may be multiplied or
+          divided directly, without any explicit conversions required.
 
                      _Wording Changes from Ada 83_
 
@@ -24950,7 +25025,7 @@ Examples of expressions involving multiplying operators:
                     _Incompatibilities With Ada 95_
 
 35.d/2
-          {AI95-00364-01AI95-00364-01} We have changed the resolution
+          {<AI95-00364-01AI95-00364-01>} We have changed the resolution
           rules for the universal fixed-fixed multiplying operators to
           remove the incompatibility with Ada 83 discussed above.  The
           solution is to hide the universal operators in some
@@ -24964,15 +25039,15 @@ Examples of expressions involving multiplying 
operators:
                     _Wording Changes from Ada 2005_
 
 35.e/3
-          {AI05-0020-1AI05-0020-1} {AI05-0209-1AI05-0209-1} Correction:
-          Wording was added to clarify that universal_fixed "*" and "/"
-          does not apply if an appropriate operator is declared for a
-          partial (or incomplete) view of the designated type.
-          Otherwise, adding a partial (or incomplete) view could make
-          some "*" and "/" operators ambiguous.
+          {<AI05-0020-1AI05-0020-1>} {<AI05-0209-1AI05-0209-1>}
+          Correction: Wording was added to clarify that
+          <universal_fixed> "*" and "/" does not apply if an appropriate
+          operator is declared for a partial (or incomplete) view of the
+          designated type.  Otherwise, adding a partial (or incomplete)
+          view could make some "*" and "/" operators ambiguous.
 
 35.f/3
-          {AI05-0260-1AI05-0260-1} Correction: The wording for the mod
+          {<AI05-0260-1AI05-0260-1>} Correction: The wording for the mod
           operator was corrected so that a result of 0 does not have to
           have "the sign of B" (which is impossible if B is negative).
 
@@ -24986,19 +25061,19 @@ File: aarm2012.info,  Node: 4.5.6,  Next: 4.5.7,  
Prev: 4.5.5,  Up: 4.5
 
 1
 The highest precedence unary operator abs (absolute value) is predefined
-for every specific numeric type T, with the following specification:
+for every specific numeric type <T>, with the following specification:
 
 2
-     function "abs"(Right : T) return T
+     function "abs"(Right : <T>) return <T>
 
 3
 The highest precedence unary operator not (logical negation) is
-predefined for every boolean type T, every modular type T, and for every
-one-dimensional array type T whose components are of a boolean type,
-with the following specification:
+predefined for every boolean type <T>, every modular type <T>, and for
+every one-dimensional array type <T> whose components are of a boolean
+type, with the following specification:
 
 4
-     function "not"(Right : T) return T
+     function "not"(Right : <T>) return <T>
 
 5
 The result of the operator not for a modular type is defined as the
@@ -25012,32 +25087,32 @@ The operator not that applies to a one-dimensional 
array of boolean
 components yields a one-dimensional boolean array with the same bounds;
 each component of the result is obtained by logical negation of the
 corresponding component of the operand (that is, the component that has
-the same index value). A check is made that each component of the result
-belongs to the component subtype; the exception Constraint_Error is
-raised if this check fails.
+the same index value).  A check is made that each component of the
+result belongs to the component subtype; the exception Constraint_Error
+is raised if this check fails.
 
 6.a
           Discussion: The check against the component subtype is per
           AI83-00535.
 
 7
-The highest precedence exponentiation operator ** is predefined for
-every specific integer type T with the following specification:
+The highest precedence <exponentiation> operator ** is predefined for
+every specific integer type <T> with the following specification:
 
 8
-     function "**"(Left : T; Right : Natural) return T
+     function "**"(Left : <T>; Right : Natural) return <T>
 
 9
 Exponentiation is also predefined for every specific floating point type
-as well as root_real, with the following specification (where T is
-root_real or the floating point type):
+as well as <root_real>, with the following specification (where <T> is
+<root_real> or the floating point type):
 
 10
-     function "**"(Left : T; Right : Integer'Base) return T
+     function "**"(Left : <T>; Right : Integer'Base) return <T>
 
 11/3
-{AI05-0088-1AI05-0088-1} The right operand of an exponentiation is the
-exponent.  The value of X**N with the value of the exponent N positive
+{<AI05-0088-1AI05-0088-1>} The right operand of an exponentiation is the
+<exponent>.  The value of X**N with the value of the exponent N positive
 is the same as the value of X*X*...X (with N-1 multiplications) except
 that the multiplications are associated in an arbitrary order.  With N
 equal to zero, the result is one.  With the value of N negative [(only
@@ -25066,12 +25141,12 @@ generally be 0.0.)
 13
      19  As implied by the specification given above for exponentiation
      of an integer type, a check is made that the exponent is not
-     negative. Constraint_Error is raised if this check fails.
+     negative.  Constraint_Error is raised if this check fails.
 
                      _Inconsistencies With Ada 83_
 
 13.a.1/1
-          {8652/01008652/0100} {AI95-00018-01AI95-00018-01} The
+          {<8652/01008652/0100>} {<AI95-00018-01AI95-00018-01>} The
           definition of "**" allows arbitrary association of the
           multiplications which make up the result.  Ada 83 required
           left-to-right associations (confirmed by AI83-00137).  Thus it
@@ -25090,7 +25165,7 @@ generally be 0.0.)
                     _Wording Changes from Ada 2005_
 
 13.b/3
-          {AI05-0088-1AI05-0088-1} Correction: The equivalence
+          {<AI05-0088-1AI05-0088-1>} Correction: The equivalence
           definition for "**" was corrected so that it does not imply
           that the operands are evaluated multiple times.
 
@@ -25101,68 +25176,68 @@ File: aarm2012.info,  Node: 4.5.7,  Next: 4.5.8,  
Prev: 4.5.6,  Up: 4.5
 -----------------------------
 
 1/3
-{AI05-0147-1AI05-0147-1} {AI05-0188-1AI05-0188-1}
-{AI05-0262-1AI05-0262-1} A conditional_expression selects for evaluation
-at most one of the enclosed dependent_expressions, depending on a
-decision among the alternatives.  One kind of conditional_expression is
-the if_expression, which selects for evaluation a dependent_expression
-depending on the value of one or more corresponding conditions.  The
-other kind of conditional_expression is the case_expression, which
-selects for evaluation one of a number of alternative
-dependent_expressions; the chosen alternative is determined by the value
-of a selecting_expression.
+{<AI05-0147-1AI05-0147-1>} {<AI05-0188-1AI05-0188-1>}
+{<AI05-0262-1AI05-0262-1>} A conditional_expression selects for
+evaluation at most one of the enclosed <dependent_>expressions,
+depending on a decision among the alternatives.  One kind of
+conditional_expression is the if_expression, which selects for
+evaluation a <dependent_>expression depending on the value of one or
+more corresponding conditions.  The other kind of conditional_expression
+is the case_expression, which selects for evaluation one of a number of
+alternative <dependent_>expressions; the chosen alternative is
+determined by the value of a <selecting_>expression.
 
                      _Language Design Principles_
 
 1.a/3
-          {AI05-0188-1AI05-0188-1} As previously noted, there are two
+          {<AI05-0188-1AI05-0188-1>} As previously noted, there are two
           kinds of conditional_expression, if_expressions and
           case_expressions.  Whenever possible, we have written the
           rules in terms of conditional_expressions to avoid
           duplication.
 
 1.b/3
-          {AI05-0147-1AI05-0147-1} The rules for conditional_expressions
-          have been designed as much as possible to work similarly to a
-          parenthesized expression.  The intent is that as much as
-          possible, wherever a parenthesized expression would be
-          allowed, a conditional_expression would be allowed, and it
-          should work the same way.
+          {<AI05-0147-1AI05-0147-1>} The rules for
+          conditional_expressions have been designed as much as possible
+          to work similarly to a parenthesized expression.  The intent
+          is that as much as possible, wherever a parenthesized
+          expression would be allowed, a conditional_expression would be
+          allowed, and it should work the same way.
 
                                _Syntax_
 
 2/3
-     {AI05-0188-1AI05-0188-1} conditional_expression ::=
+     {<AI05-0188-1AI05-0188-1>} conditional_expression ::=
      if_expression | case_expression
 
 3/3
-     {AI05-0147-1AI05-0147-1} {AI05-0188-1AI05-0188-1} if_expression ::=
-
-        if condition then dependent_expression
-        {elsif condition then dependent_expression}
-        [else dependent_expression]
+     {<AI05-0147-1AI05-0147-1>} {<AI05-0188-1AI05-0188-1>} if_expression
+     ::=
+        if condition then <dependent_>expression
+        {elsif condition then <dependent_>expression}
+        [else <dependent_>expression]
 
 4/3
-     {AI05-0147-1AI05-0147-1} condition ::= boolean_expression
+     {<AI05-0147-1AI05-0147-1>} condition ::= <boolean_>expression
 
 5/3
-     {AI05-0188-1AI05-0188-1} case_expression ::=
-         case selecting_expression is
+     {<AI05-0188-1AI05-0188-1>} case_expression ::=
+         case <selecting_>expression is
          case_expression_alternative {,
          case_expression_alternative}
 
 6/3
-     {AI05-0188-1AI05-0188-1} case_expression_alternative ::=
+     {<AI05-0188-1AI05-0188-1>} case_expression_alternative ::=
          when discrete_choice_list =>
-             dependent_expression
+             <dependent_>expression
 
 7/3
-     {AI05-0147-1AI05-0147-1} Wherever the Syntax Rules allow an
+     {<AI05-0147-1AI05-0147-1>} Wherever the Syntax Rules allow an
      expression, a conditional_expression may be used in place of the
      expression, so long as it is immediately surrounded by parentheses.
 
 7.a/3
-          Discussion: {AI05-0147-1AI05-0147-1} The syntactic category
+          Discussion: {<AI05-0147-1AI05-0147-1>} The syntactic category
           conditional_expression appears only as a primary that is
           parenthesized.  The above rule allows it to additionally be
           used in other contexts where it would be directly surrounded
@@ -25172,8 +25247,8 @@ of a selecting_expression.
           The grammar makes the following directly legal:
 
 7.c/3
-               A := (if X then Y else Z); -- parentheses required
-               A := B + (if X then Y else Z) + C; -- parentheses required
+               A := (if X then Y else Z); --< parentheses required>
+               A := B + (if X then Y else Z) + C; --< parentheses required>
 
 7.d/3
           The following procedure calls are syntactically legal; the
@@ -25182,7 +25257,7 @@ of a selecting_expression.
 
 7.e/3
                P(if X then Y else Z);
-               P((if X then Y else Z)); -- redundant parentheses
+               P((if X then Y else Z)); --< redundant parentheses>
 
 7.f/3
                P((if X then Y else Z), Some_Other_Param);
@@ -25218,10 +25293,10 @@ of a selecting_expression.
           complete grammar is given in AI05-0147-1AI05-0147-1.
 
 7.l/3
-          Implementation Note: {AI05-0147-1AI05-0147-1} Implementers are
-          cautioned to consider error detection when implementing the
-          syntax for conditional_expressions.  An if_expression and an
-          if_statement are very similar syntactically, (as are a
+          Implementation Note: {<AI05-0147-1AI05-0147-1>} Implementers
+          are cautioned to consider error detection when implementing
+          the syntax for conditional_expressions.  An if_expression and
+          an if_statement are very similar syntactically, (as are a
           case_expression and a case_statement) and simple mistakes can
           appear to change one into the other, potentially causing
           errors to be moved far away from their actual location.  The
@@ -25231,18 +25306,18 @@ of a selecting_expression.
                         _Name Resolution Rules_
 
 8/3
-{AI05-0147-1AI05-0147-1} If a conditional_expression is expected to be
-of a type T, then each dependent_expression of the
-conditional_expression is expected to be of type T. Similarly, if a
+{<AI05-0147-1AI05-0147-1>} If a conditional_expression is expected to be
+of a type <T>, then each <dependent_>expression of the
+conditional_expression is expected to be of type <T>.  Similarly, if a
 conditional_expression is expected to be of some class of types, then
-each dependent_expression of the conditional_expression is subject to
+each <dependent_>expression of the conditional_expression is subject to
 the same expectation.  If a conditional_expression shall resolve to be
-of a type T, then each dependent_expression shall resolve to be of type
-T.
+of a type <T>, then each <dependent_>expression shall resolve to be of
+type <T>.
 
 9/3
-{AI05-0147-1AI05-0147-1} The possible types of a conditional_expression
-are further determined as follows:
+{<AI05-0147-1AI05-0147-1>} The possible types of a
+conditional_expression are further determined as follows:
 
 10/3
    * If the conditional_expression is the operand of a type conversion,
@@ -25251,7 +25326,7 @@ are further determined as follows:
 
 10.a/3
           Reason: This rule distributes an enclosing type conversion to
-          the dependent_expressions.  This means that
+          the <dependent_>expressions.  This means that
 
 10.b/3
                T(if C then A else B)
@@ -25263,59 +25338,63 @@ are further determined as follows:
                (if C then T(A) else T(B))
 
 11/3
-   * If all of the dependent_expressions are of the same type, the type
-     of the conditional_expression is that type; otherwise,
+   * If all of the <dependent_>expressions are of the same type, the
+     type of the conditional_expression is that type; otherwise,
 
 12/3
-   * If a dependent_expression is of an elementary type, the type of the
-     conditional_expression shall be covered by that type; otherwise,
+   * If a <dependent_>expression is of an elementary type, the type of
+     the conditional_expression shall be covered by that type;
+     otherwise,
 
 12.a/3
           Reason: This rule supports the use of numeric literals and
           universal expressions within a conditional_expression.
 
 13/3
-   * If the conditional_expression is expected to be of type T or shall
-     resolve to type T, then the conditional_expression is of type T.
+   * If the conditional_expression is expected to be of type <T> or
+     shall resolve to type <T>, then the conditional_expression is of
+     type <T>.
 
 13.a/3
           Ramification: If the type of the conditional_expression cannot
           be determined by one of these rules, then Name Resolution has
-          failed for that expression, even if the dependent_expressions
-          would resolve individually.
+          failed for that expression, even if the
+          <dependent_>expressions would resolve individually.
 
 14/3
-{AI05-0147-1AI05-0147-1} A condition is expected to be of any boolean
+{<AI05-0147-1AI05-0147-1>} A condition is expected to be of any boolean
 type.
 
 15/3
-{AI05-0188-1AI05-0188-1} The expected type for the selecting_expression
-and the discrete_choices are as for case statements (see *note 5.4::). 
+{<AI05-0188-1AI05-0188-1>} The expected type for the
+<selecting_>expression and the discrete_choices are as for case
+statements (see *note 5.4::).  
 
                            _Legality Rules_
 
 16/3
-{AI05-0147-1AI05-0147-1} {AI05-0188-1AI05-0188-1} All of the
-dependent_expressions shall be convertible (see *note 4.6::) to the type
-of the conditional_expression.
+{<AI05-0147-1AI05-0147-1>} {<AI05-0188-1AI05-0188-1>} All of the
+<dependent_>expressions shall be convertible (see *note 4.6::) to the
+type of the conditional_expression.
 
 17/3
-{AI05-0147-1AI05-0147-1} {AI05-0188-1AI05-0188-1}
-{AI05-0269-1AI05-0269-1} If the expected type of a
+{<AI05-0147-1AI05-0147-1>} {<AI05-0188-1AI05-0188-1>}
+{<AI05-0269-1AI05-0269-1>} If the expected type of a
 conditional_expression is a specific tagged type, all of the
-dependent_expressions of the conditional_expression shall be dynamically
-tagged, or none shall be dynamically tagged.  In this case, the
-conditional_expression is dynamically tagged if all of the
-dependent_expressions are dynamically tagged, is tag-indeterminate if
-all of the dependent_expressions are tag-indeterminate, and is
+<dependent_>expressions of the conditional_expression shall be
+dynamically tagged, or none shall be dynamically tagged.  In this case,
+the conditional_expression is dynamically tagged if all of the
+<dependent_>expressions are dynamically tagged, is tag-indeterminate if
+all of the <dependent_>expressions are tag-indeterminate, and is
 statically tagged otherwise.
 
 18/3
-{AI05-0147-1AI05-0147-1} {AI05-0262-1AI05-0262-1} If there is no else
-dependent_expression, the if_expression shall be of a boolean type.
+{<AI05-0147-1AI05-0147-1>} {<AI05-0262-1AI05-0262-1>} If there is no
+else <dependent_>expression, the if_expression shall be of a boolean
+type.
 
 19/3
-{AI05-0188-1AI05-0188-1} {AI05-0269-1AI05-0269-1} All Legality Rules
+{<AI05-0188-1AI05-0188-1>} {<AI05-0269-1AI05-0269-1>} All Legality Rules
 that apply to the discrete_choices of a case_statement (see *note 5.4::)
 also apply to the discrete_choices of a case_expression except within an
 instance of a generic unit.
@@ -25338,7 +25417,7 @@ instance of a generic unit.
                function Nat_Func return Natural is (123);
 
 19.d/3
-               package I is new G (Int_Func => Nat_Func); -- Legal
+               package I is new G (Int_Func => Nat_Func); -- <Legal>
 
 19.e/3
           Note that the Legality Rules still apply in the generic unit
@@ -25347,15 +25426,15 @@ instance of a generic unit.
                           _Dynamic Semantics_
 
 20/3
-{AI05-0147-1AI05-0147-1} {AI05-0188-1AI05-0188-1} For the evaluation of
-an if_expression, the condition specified after if, and any conditions
-specified after elsif, are evaluated in succession (treating a final
-else as elsif True then), until one evaluates to True or all conditions
-are evaluated and yield False.  If a condition evaluates to True, the
-associated dependent_expression is evaluated, converted to the type of
-the if_expression, and the resulting value is the value of the
-if_expression.  Otherwise (when there is no else clause), the value of
-the if_expression is True.
+{<AI05-0147-1AI05-0147-1>} {<AI05-0188-1AI05-0188-1>} For the evaluation
+of an if_expression, the condition specified after if, and any
+conditions specified after elsif, are evaluated in succession (treating
+a final else as elsif True then), until one evaluates to True or all
+conditions are evaluated and yield False.  If a condition evaluates to
+True, the associated <dependent_>expression is evaluated, converted to
+the type of the if_expression, and the resulting value is the value of
+the if_expression.  Otherwise (when there is no else clause), the value
+of the if_expression is True.
 
 20.a/3
           Ramification: Else is required unless the if_expression has a
@@ -25363,20 +25442,20 @@ the if_expression is True.
           if_expressions with a boolean type.
 
 21/3
-{AI05-0188-1AI05-0188-1} For the evaluation of a case_expression, the
-selecting_expression is first evaluated.  If the value of the
-selecting_expression is covered by the discrete_choice_list of some
-case_expression_alternative, then the dependent_expression of the
+{<AI05-0188-1AI05-0188-1>} For the evaluation of a case_expression, the
+<selecting_>expression is first evaluated.  If the value of the
+<selecting_>expression is covered by the discrete_choice_list of some
+case_expression_alternative, then the <dependent_>expression of the
 case_expression_alternative is evaluated, converted to the type of the
 case_expression, and the resulting value is the value of the
-case_expression. Otherwise (the value is not covered by any
+case_expression.  Otherwise (the value is not covered by any
 discrete_choice_list, perhaps due to being outside the base range),
 Constraint_Error is raised.
 
                        _Extensions to Ada 2005_
 
 21.a/3
-          {AI05-0147-1AI05-0147-1} If expressions and case expressions
+          {<AI05-0147-1AI05-0147-1>} If expressions and case expressions
           are new.
 
 
@@ -25386,25 +25465,25 @@ File: aarm2012.info,  Node: 4.5.8,  Prev: 4.5.7,  Up: 
4.5
 ----------------------------
 
 0.1/4
-{AI12-0158-1AI12-0158-1} Quantified expressions provide a way to write
+{<AI12-0158-1AI12-0158-1>} Quantified expressions provide a way to write
 universally and existentially quantified predicates over containers and
 arrays.
 
                                _Syntax_
 
 1/3
-     {AI05-0176-1AI05-0176-1} quantified_expression ::= for quantifier 
-     loop_parameter_specification => predicate
+     {<AI05-0176-1AI05-0176-1>} quantified_expression ::= for 
+     quantifier loop_parameter_specification => predicate
        | for quantifier iterator_specification => predicate
 
 2/3
      quantifier ::= all | some
 
 3/3
-     predicate ::= boolean_expression
+     predicate ::= <boolean_>expression
 
 4/3
-     {AI05-0176-1AI05-0176-1} Wherever the Syntax Rules allow an
+     {<AI05-0176-1AI05-0176-1>} Wherever the Syntax Rules allow an
      expression, a quantified_expression may be used in place of the
      expression, so long as it is immediately surrounded by parentheses.
 
@@ -25420,15 +25499,15 @@ arrays.
                         _Name Resolution Rules_
 
 5/3
-{AI05-0176-1AI05-0176-1} The expected type of a quantified_expression is
-any Boolean type.  The predicate in a quantified_expression is expected
-to be of the same type.
+{<AI05-0176-1AI05-0176-1>} The expected type of a quantified_expression
+is any Boolean type.  The predicate in a quantified_expression is
+expected to be of the same type.
 
                           _Dynamic Semantics_
 
 6/4
-{AI05-0176-1AI05-0176-1} {AI12-0158-1AI12-0158-1} For the evaluation of
-a quantified_expression, the loop_parameter_specification or
+{<AI05-0176-1AI05-0176-1>} {<AI12-0158-1AI12-0158-1>} For the evaluation
+of a quantified_expression, the loop_parameter_specification or
 iterator_specification is first elaborated.  The evaluation of a
 quantified_expression then evaluates the predicate for the values of the
 loop parameter in the order specified by the
@@ -25436,11 +25515,11 @@ loop_parameter_specification (see *note 5.5::) or 
iterator_specification
 (see *note 5.5.2::).
 
 7/3
-{AI05-0176-1AI05-0176-1} The value of the quantified_expression is
+{<AI05-0176-1AI05-0176-1>} The value of the quantified_expression is
 determined as follows:
 
 8/4
-   * {AI12-0158-1AI12-0158-1} If the quantifier is all, the expression
+   * {<AI12-0158-1AI12-0158-1>} If the quantifier is all, the expression
      is False if the evaluation of any predicate yields False;
      evaluation of the quantified_expression stops at that point.
      Otherwise (every predicate has been evaluated and yielded True),
@@ -25452,12 +25531,12 @@ determined as follows:
           values.
 
 9/4
-   * {AI12-0158-1AI12-0158-1} If the quantifier is some, the expression
-     is True if the evaluation of any predicate yields True; evaluation
-     of the quantified_expression stops at that point.  Otherwise (every
-     predicate has been evaluated and yielded False), the expression is
-     False.  Any exception raised by evaluation of the predicate is
-     propagated.
+   * {<AI12-0158-1AI12-0158-1>} If the quantifier is some, the
+     expression is True if the evaluation of any predicate yields True;
+     evaluation of the quantified_expression stops at that point.
+     Otherwise (every predicate has been evaluated and yielded False),
+     the expression is False.  Any exception raised by evaluation of the
+     predicate is propagated.
 
 9.a/3
           Ramification: The expression is False if the domain contains
@@ -25466,7 +25545,7 @@ determined as follows:
                               _Examples_
 
 10/3
-{AI05-0176-1AI05-0176-1} The postcondition for a sorting routine on an
+{<AI05-0176-1AI05-0176-1>} The postcondition for a sorting routine on an
 array A with an index subtype T can be written:
 
 11/3
@@ -25474,7 +25553,7 @@ array A with an index subtype T can be written:
         (for all I in A'First .. T'Pred(A'Last) => A (I) <= A (T'Succ (I))))
 
 12/3
-{AI05-0176-1AI05-0176-1} The assertion that a positive number is
+{<AI05-0176-1AI05-0176-1>} The assertion that a positive number is
 composite (as opposed to prime) can be written:
 
 13/3
@@ -25483,12 +25562,12 @@ composite (as opposed to prime) can be written:
                        _Extensions to Ada 2005_
 
 13.a/3
-          {AI05-0176-1AI05-0176-1} Quantified expressions are new.
+          {<AI05-0176-1AI05-0176-1>} Quantified expressions are new.
 
                     _Wording Changes from Ada 2012_
 
 13.b/4
-          {AI12-0158-1AI12-0158-1} Corrigendum: Revised the wording to
+          {<AI12-0158-1AI12-0158-1>} Corrigendum: Revised the wording to
           make it clear that the semantics is short-circuited, and what
           the result is when there are no values for the loop parameter.
 
@@ -25499,11 +25578,11 @@ File: aarm2012.info,  Node: 4.6,  Next: 4.7,  Prev: 
4.5,  Up: 4
 ====================
 
 1/3
-{AI05-0299-1AI05-0299-1} [Explicit type conversions, both value
+{<AI05-0299-1AI05-0299-1>} [Explicit type conversions, both value
 conversions and view conversions, are allowed between closely related
 types as defined below.  This subclause also defines rules for value and
 view conversions to a particular subtype of a type, both explicit ones
-and those implicit in other constructs. ]
+and those implicit in other constructs.  ]
 
                                _Syntax_
 
@@ -25513,15 +25592,15 @@ and those implicit in other constructs. ]
        | subtype_mark(name)
 
 3
-The target subtype of a type_conversion is the subtype denoted by the
-subtype_mark. The operand of a type_conversion is the expression or name
-within the parentheses; its type is the operand type.
+The <target subtype> of a type_conversion is the subtype denoted by the
+subtype_mark.  The <operand> of a type_conversion is the expression or
+name within the parentheses; its type is the <operand type>.
 
 4/3
-{AI05-0299-1AI05-0299-1} One type is convertible to a second type if a
-type_conversion with the first type as operand type and the second type
-as target type is legal according to the rules of this subclause.  Two
-types are convertible if each is convertible to the other.
+{<AI05-0299-1AI05-0299-1>} One type is <convertible> to a second type if
+a type_conversion with the first type as operand type and the second
+type as target type is legal according to the rules of this subclause.
+Two types are convertible if each is convertible to the other.
 
 4.a
           Ramification: Note that "convertible" is defined in terms of
@@ -25530,12 +25609,12 @@ types are convertible if each is convertible to the 
other.
           definition.
 
 5/2
-{8652/00178652/0017} {AI95-00184-01AI95-00184-01}
-{AI95-00330-01AI95-00330-01} A type_conversion whose operand is the name
-of an object is called a view conversion if both its target type and
-operand type are tagged, or if it appears in a call as an actual
-parameter of mode out or in out; other type_conversions are called value
-conversions. 
+{<8652/00178652/0017>} {<AI95-00184-01AI95-00184-01>}
+{<AI95-00330-01AI95-00330-01>} A type_conversion whose operand is the
+name of an object is called a <view conversion> if both its target type
+and operand type are tagged, or if it appears in a call as an actual
+parameter of mode out or in out; other type_conversions are called
+<value conversions>.  
 
 5.a
           Ramification: A view conversion to a tagged type can appear in
@@ -25548,8 +25627,8 @@ conversions.
           implementation burden.
 
 5.b/2
-          {AI95-00330-01AI95-00330-01} A type conversion appearing as an
-          in out parameter in a generic instantiation is not a view
+          {<AI95-00330-01AI95-00330-01>} A type conversion appearing as
+          an in out parameter in a generic instantiation is not a view
           conversion; the second part of the rule only applies to
           subprogram calls, not instantiations.
 
@@ -25569,14 +25648,14 @@ The operand of a view conversion is interpreted only 
as a name; the
 operand of a value conversion is interpreted as an expression.
 
 7.a/4
-          Reason: {AI12-0005-1AI12-0005-1} This formally resolves the
+          Reason: {<AI12-0005-1AI12-0005-1>} This formally resolves the
           syntactic ambiguity between the two forms of type_conversion.
           This matters as an expression that is a name is evaluated and
           represents a value while a name by itself can be an object; we
           want a view conversion to be an object.
 
 7.b/4
-          Ramification: {AI12-0005-1AI12-0005-1} This wording uses
+          Ramification: {<AI12-0005-1AI12-0005-1>} This wording uses
           "interpreted as" rather than "shall be" so that this rule is
           not used to resolve overloading; it is solely about evaluation
           as described above.
@@ -25584,8 +25663,8 @@ operand of a value conversion is interpreted as an 
expression.
                            _Legality Rules_
 
 8/2
-{AI95-00251-01AI95-00251-01} In a view conversion for an untagged type,
-the target type shall be convertible (back) to the operand type.
+{<AI95-00251-01AI95-00251-01>} In a view conversion for an untagged
+type, the target type shall be convertible (back) to the operand type.
 
 8.a/2
           Reason: Untagged view conversions appear only as [in] out
@@ -25594,10 +25673,10 @@ the target type shall be convertible (back) to the 
operand type.
           parameter, because (for example) actual parameters of an
           access type are always copied in anyway.
 
-Paragraphs 9 through 20 were reorganized and moved below.
+<Paragraphs 9 through 20 were reorganized and moved below.>
 
 8.b/2
-          Discussion: {AI95-00251-01AI95-00251-01} The entire Legality
+          Discussion: {<AI95-00251-01AI95-00251-01>} The entire Legality
           Rules section has been reorganized to eliminate an
           unintentional incompatibility with Ada 83.  In rare cases, a
           type conversion between two types related by derivation is not
@@ -25611,13 +25690,14 @@ Paragraphs 9 through 20 were reorganized and moved 
below.
           24.12, 24.13, 24.17, 24.19, 24.20, and 8.
 
 21/3
-{AI95-00251-01AI95-00251-01} {AI05-0115-1AI05-0115-1} If there is a type
-(other than a root numeric type) that is an ancestor of both the target
-type and the operand type, or both types are class-wide types, then at
-least one of the following rules shall apply:
+{<AI95-00251-01AI95-00251-01>} {<AI05-0115-1AI05-0115-1>} If there is a
+type (other than a root numeric type) that is an ancestor of both the
+target type and the operand type, or both types are class-wide types,
+then at least one of the following rules shall apply:
 
 21.1/2
-   * {AI95-00251-01AI95-00251-01} The target type shall be untagged; or
+   * {<AI95-00251-01AI95-00251-01>} The target type shall be untagged;
+     or
 
 22
    * The operand type shall be covered by or descended from the target
@@ -25628,8 +25708,8 @@ least one of the following rules shall apply:
           always safe.
 
 23/2
-   * {AI95-00251-01AI95-00251-01} The operand type shall be a class-wide
-     type that covers the target type; or
+   * {<AI95-00251-01AI95-00251-01>} The operand type shall be a
+     class-wide type that covers the target type; or
 
 23.a
           Ramification: This is a conversion of a class-wide type toward
@@ -25637,7 +25717,7 @@ least one of the following rules shall apply:
           Semantics.
 
 23.b/2
-          {AI95-00251-01AI95-00251-01} These two rules imply that a
+          {<AI95-00251-01AI95-00251-01>} These two rules imply that a
           conversion from an ancestor type to a type extension is not
           permitted, as this would require specifying the values for
           additional components, in general, and changing the tag.  An
@@ -25648,7 +25728,7 @@ least one of the following rules shall apply:
           operand's tag is a descendant of the target.
 
 23.1/2
-   * {AI95-00251-01AI95-00251-01} The operand and target types shall
+   * {<AI95-00251-01AI95-00251-01>} The operand and target types shall
      both be class-wide types and the specific type associated with at
      least one of them shall be an interface type.
 
@@ -25663,33 +25743,33 @@ least one of the following rules shall apply:
           the needed interface.
 
 24/3
-{AI95-00251-01AI95-00251-01} {AI05-0115-1AI05-0115-1} If there is no
+{<AI95-00251-01AI95-00251-01>} {<AI05-0115-1AI05-0115-1>} If there is no
 type (other than a root numeric type) that is the ancestor of both the
 target type and the operand type, and they are not both class-wide
 types, one of the following rules shall apply:
 
 24.1/2
-   * {AI95-00251-01AI95-00251-01} If the target type is a numeric type,
-     then the operand type shall be a numeric type.
+   * {<AI95-00251-01AI95-00251-01>} If the target type is a numeric
+     type, then the operand type shall be a numeric type.
 
 24.2/2
-   * {AI95-00251-01AI95-00251-01} If the target type is an array type,
+   * {<AI95-00251-01AI95-00251-01>} If the target type is an array type,
      then the operand type shall be an array type.  Further:
 
 24.3/2
-             * {AI95-00251-01AI95-00251-01} The types shall have the
+             * {<AI95-00251-01AI95-00251-01>} The types shall have the
                same dimensionality;
 
 24.4/2
-             * {AI95-00251-01AI95-00251-01} Corresponding index types
+             * {<AI95-00251-01AI95-00251-01>} Corresponding index types
                shall be convertible; 
 
 24.5/2
-             * {AI95-00251-01AI95-00251-01} The component subtypes shall
-               statically match; 
+             * {<AI95-00251-01AI95-00251-01>} The component subtypes
+               shall statically match; 
 
 24.6/2
-             * {AI95-00392-01AI95-00392-01} If the component types are
+             * {<AI95-00392-01AI95-00392-01>} If the component types are
                anonymous access types, then the accessibility level of
                the operand type shall not be statically deeper than that
                of the target type; 
@@ -25705,8 +25785,8 @@ types, one of the following rules shall apply:
           check will prevent problems.
 
 24.7/2
-             * {AI95-00246-01AI95-00246-01} Neither the target type nor
-               the operand type shall be limited;
+             * {<AI95-00246-01AI95-00246-01>} Neither the target type
+               nor the operand type shall be limited;
 
 24.c/2
           Reason: We cannot allow conversions between unrelated limited
@@ -25715,24 +25795,26 @@ types, one of the following rules shall apply:
           representations.
 
 24.8/2
-             * {AI95-00251-01AI95-00251-01} {AI95-00363-01AI95-00363-01}
-               If the target type of a view conversion has aliased
-               components, then so shall the operand type; and
+             * {<AI95-00251-01AI95-00251-01>}
+               {<AI95-00363-01AI95-00363-01>} If the target type of a
+               view conversion has aliased components, then so shall the
+               operand type; and
 
 24.d/2
-          Reason: {AI95-00363-01AI95-00363-01} We cannot allow a view
+          Reason: {<AI95-00363-01AI95-00363-01>} We cannot allow a view
           conversion from an object with unaliased components to an
           object with aliased components, because that would effectively
           allow pointers to unaliased components.  This rule was missing
           from Ada 95.
 
 24.9/2
-             * {AI95-00246-01AI95-00246-01} {AI95-00251-01AI95-00251-01}
-               The operand type of a view conversion shall not have a
-               tagged, private, or volatile subcomponent.
+             * {<AI95-00246-01AI95-00246-01>}
+               {<AI95-00251-01AI95-00251-01>} The operand type of a view
+               conversion shall not have a tagged, private, or volatile
+               subcomponent.
 
 24.e/2
-          Reason: {AI95-00246-01AI95-00246-01} We cannot allow view
+          Reason: {<AI95-00246-01AI95-00246-01>} We cannot allow view
           conversions between unrelated might-be-by-reference types, as
           they may have different representations, and a copy cannot be
           made to reconcile the representations.
@@ -25743,18 +25825,18 @@ types, one of the following rules shall apply:
           between related types.
 
 24.10/2
-   * {AI95-00230-01AI95-00230-01} If the target type is
-     universal_access, then the operand type shall be an access type.
+   * {<AI95-00230-01AI95-00230-01>} If the target type is
+     <universal_access>, then the operand type shall be an access type.
 
 24.g/2
           Discussion: Such a conversion cannot be written explicitly, of
           course, but it can be implicit (see below).
 
 24.11/2
-   * {AI95-00230-01AI95-00230-01} {AI95-00251-01AI95-00251-01} If the
-     target type is a general access-to-object type, then the operand
-     type shall be universal_access or an access-to-object type.
-     Further, if the operand type is not universal_access:
+   * {<AI95-00230-01AI95-00230-01>} {<AI95-00251-01AI95-00251-01>} If
+     the target type is a general access-to-object type, then the
+     operand type shall be <universal_access> or an access-to-object
+     type.  Further, if the operand type is not <universal_access>:
 
 24.h/2
           Discussion: The Legality Rules and Dynamic Semantics are
@@ -25765,7 +25847,7 @@ types, one of the following rules shall apply:
           whereas the attribute_reference would raise Constraint_Error.
 
 24.12/2
-             * {AI95-00251-01AI95-00251-01} If the target type is an
+             * {<AI95-00251-01AI95-00251-01>} If the target type is an
                access-to-variable type, then the operand type shall be
                an access-to-variable type;
 
@@ -25775,69 +25857,70 @@ types, one of the following rules shall apply:
           access-to-variable.
 
 24.13/2
-             * {AI95-00251-01AI95-00251-01} If the target designated
+             * {<AI95-00251-01AI95-00251-01>} If the target designated
                type is tagged, then the operand designated type shall be
                convertible to the target designated type; 
 
 24.14/2
-             * {AI95-00251-01AI95-00251-01} {AI95-00363-01AI95-00363-01}
-               If the target designated type is not tagged, then the
-               designated types shall be the same, and either:
+             * {<AI95-00251-01AI95-00251-01>}
+               {<AI95-00363-01AI95-00363-01>} If the target designated
+               type is not tagged, then the designated types shall be
+               the same, and either:
 
 24.15/2
-                  * {AI95-00363-01AI95-00363-01} the designated subtypes
-                    shall statically match; or
+                  * {<AI95-00363-01AI95-00363-01>} the designated
+                    subtypes shall statically match; or
 
 24.16/2
-                  * {AI95-00363-01AI95-00363-01}
-                    {AI95-00384-01AI95-00384-01} the designated type
+                  * {<AI95-00363-01AI95-00363-01>}
+                    {<AI95-00384-01AI95-00384-01>} the designated type
                     shall be discriminated in its full view and
                     unconstrained in any partial view, and one of the
                     designated subtypes shall be unconstrained;
 
 24.j/2
-          Ramification: {AI95-00363-01AI95-00363-01} This does not
+          Ramification: {<AI95-00363-01AI95-00363-01>} This does not
           require that types have a partial view in order to allow the
           conversion, simply that any partial view that does exist is
           unconstrained.
 
 24.k/2
-          {AI95-00384-01AI95-00384-01} This allows conversions both ways
-          (either subtype can be unconstrained); while Ada 95 only
+          {<AI95-00384-01AI95-00384-01>} This allows conversions both
+          ways (either subtype can be unconstrained); while Ada 95 only
           allowed the conversion if the target subtype is unconstrained.
           We generally want type conversions to be symmetric; which type
           is the target shouldn't matter for legality.
 
 24.l/2
-          Reason: {AI95-00363-01AI95-00363-01} If the visible partial
+          Reason: {<AI95-00363-01AI95-00363-01>} If the visible partial
           view is constrained, we do not allow conversion between
           unconstrained and constrained subtypes.  This means that
           whether the full type had discriminants is not visible to
           clients of the partial view.
 
 24.l.1/4
-          Discussion: {AI12-0095-1AI12-0095-1} We assume the worst in a
-          generic body whether or not a formal subtype has a constrained
-          partial view; specifically, in a generic body a discriminated
-          subtype is considered to have a constrained partial view if it
-          is a descendant of an untagged generic formal private or
-          derived type (see *note 12.5.1:: for the formal definition of
-          this rule).
+          Discussion: {<AI12-0095-1AI12-0095-1>} We assume the worst in
+          a generic body whether or not a formal subtype has a
+          constrained partial view; specifically, in a generic body a
+          discriminated subtype is considered to have a constrained
+          partial view if it is a descendant of an untagged generic
+          formal private or derived type (see *note 12.5.1:: for the
+          formal definition of this rule).
 
 24.m/2
           Reason: These rules are designed to ensure that aliased array
-          objects only need "dope" if their nominal subtype is
-          unconstrained, but they can always have dope if required by
+          objects only <need> "dope" if their nominal subtype is
+          unconstrained, but they can always <have> dope if required by
           the run-time model (since no sliding is permitted as part of
           access type conversion).  By contrast, aliased discriminated
-          objects will always need their discriminants stored with them,
-          even if nominally constrained.  (Here, we are assuming an
-          implementation that represents an access value as a single
+          objects will always <need> their discriminants stored with
+          them, even if nominally constrained.  (Here, we are assuming
+          an implementation that represents an access value as a single
           pointer.)
 
 24.17/4
-             * {AI95-00251-01AI95-00251-01} {AI05-0148-1AI05-0148-1}
-               {AI05-0248-1AI05-0248-1} {AI12-0027-1AI12-0027-1} The
+             * {<AI95-00251-01AI95-00251-01>} {<AI05-0148-1AI05-0148-1>}
+               {<AI05-0248-1AI05-0248-1>} {<AI12-0027-1AI12-0027-1>} The
                accessibility level of the operand type shall not be
                statically deeper than that of the target type, unless
                the target type is an anonymous access type of a
@@ -25847,7 +25930,7 @@ types, one of the following rules shall apply:
                the declaration of the stand-alone object.
 
 24.n/3
-          Ramification: {AI05-0148-1AI05-0148-1} The access parameter
+          Ramification: {<AI05-0148-1AI05-0148-1>} The access parameter
           case is handled by a run-time check.  Run-time checks are also
           done in instance bodies, and for stand-alone objects of
           anonymous access types.
@@ -25859,9 +25942,9 @@ types, one of the following rules shall apply:
           dangling accesses.
 
 24.18/2
-   * {AI95-00230-01AI95-00230-01} If the target type is a pool-specific
-     access-to-object type, then the operand type shall be
-     universal_access.
+   * {<AI95-00230-01AI95-00230-01>} If the target type is a
+     pool-specific access-to-object type, then the operand type shall be
+     <universal_access>.
 
 24.o/2
           Reason: This allows null to be converted to pool-specific
@@ -25872,18 +25955,18 @@ types, one of the following rules shall apply:
           derived or other related types.
 
 24.19/2
-   * {AI95-00230-01AI95-00230-01} {AI95-00251-01AI95-00251-01} If the
-     target type is an access-to-subprogram type, then the operand type
-     shall be universal_access or an access-to-subprogram type.
-     Further, if the operand type is not universal_access:
+   * {<AI95-00230-01AI95-00230-01>} {<AI95-00251-01AI95-00251-01>} If
+     the target type is an access-to-subprogram type, then the operand
+     type shall be <universal_access> or an access-to-subprogram type.
+     Further, if the operand type is not <universal_access>:
 
 24.20/3
-             * {AI95-00251-01AI95-00251-01} {AI05-0239-1AI05-0239-1} The
-               designated profiles shall be subtype conformant. 
+             * {<AI95-00251-01AI95-00251-01>} {<AI05-0239-1AI05-0239-1>}
+               The designated profiles shall be subtype conformant.  
 
 24.21/4
-             * {AI95-00251-01AI95-00251-01} {AI12-0027-1AI12-0027-1} The
-               accessibility level of the operand type shall not be
+             * {<AI95-00251-01AI95-00251-01>} {<AI12-0027-1AI12-0027-1>}
+               The accessibility level of the operand type shall not be
                statically deeper than that of the target type.  If the
                operand type is declared within a generic body, the
                target type shall be declared within the generic body.
@@ -25900,18 +25983,18 @@ types, one of the following rules shall apply:
           the instantiation.
 
 24.22/4
-{AI12-0027-1AI12-0027-1} In addition to the places where Legality Rules
-normally apply (see *note 12.3::), these rules apply also in the private
-part of an instance of a generic unit.
+{<AI12-0027-1AI12-0027-1>} In addition to the places where Legality
+Rules normally apply (see *note 12.3::), these rules apply also in the
+private part of an instance of a generic unit.
 
 24.q/4
-          Discussion: This applies to all of the Legality Rules in this
-          section.  It won't matter for the majority of these rules, but
-          in any case that it does, we want to apply the same recheck in
-          the private part.  (Ada got the default wrong for these, as
-          there is only one known case where we don't want to recheck in
-          the private part, see derivations without record extensions in
-          *note 3.4::.)
+          Discussion: This applies to <all> of the Legality Rules in
+          this section.  It won't matter for the majority of these
+          rules, but in any case that it does, we want to apply the same
+          recheck in the private part.  (Ada got the default wrong for
+          these, as there is only one known case where we don't want to
+          recheck in the private part, see derivations without record
+          extensions in *note 3.4::.)
 
                           _Static Semantics_
 
@@ -25920,7 +26003,7 @@ A type_conversion that is a value conversion denotes 
the value that is
 the result of converting the value of the operand to the target subtype.
 
 26/3
-{AI05-0264-1AI05-0264-1} A type_conversion that is a view conversion
+{<AI05-0264-1AI05-0264-1>} A type_conversion that is a view conversion
 denotes a view of the object denoted by the operand.  This view is a
 variable of the target type if the operand denotes a variable;
 otherwise, it is a constant of the target type.
@@ -25932,9 +26015,9 @@ The nominal subtype of a type_conversion is its target 
subtype.
 
 28
 For the evaluation of a type_conversion that is a value conversion, the
-operand is evaluated, and then the value of the operand is converted to
-a corresponding value of the target type, if any. If there is no value
-of the target type that corresponds to the operand value,
+operand is evaluated, and then the value of the operand is <converted>
+to a <corresponding> value of the target type, if any.  If there is no
+value of the target type that corresponds to the operand value,
 Constraint_Error is raised[; this can only happen on conversion to a
 modular type, and only when the operand value is outside the base range
 of the modular type.]  Additional rules follow:
@@ -25951,7 +26034,7 @@ of the modular type.]  Additional rules follow:
 31
              * If the target type is a decimal fixed point type, then
                the result is truncated (toward 0) if the value of the
-               operand is not a multiple of the small of the target
+               operand is not a multiple of the <small> of the target
                type.
 
 32
@@ -25973,7 +26056,7 @@ of the modular type.]  Additional rules follow:
                integers).
 
 33.a/2
-          Discussion: {AI95-00267-01AI95-00267-01} This was
+          Discussion: {<AI95-00267-01AI95-00267-01>} This was
           implementation defined in Ada 83.  There seems no reason to
           preserve the nonportability in Ada 95.  Round-away-from-zero
           is the conventional definition of rounding, and standard
@@ -26013,7 +26096,7 @@ of the modular type.]  Additional rules follow:
              * If the target subtype is an unconstrained array subtype,
                then the bounds of the result are obtained by converting
                each bound of the value of the operand to the
-               corresponding index type of the target type. For each
+               corresponding index type of the target type.  For each
                nonnull index range, a check is made that the bounds of
                the range belong to the corresponding index subtype.
 
@@ -26031,10 +26114,10 @@ of the modular type.]  Additional rules follow:
           initialized.
 
 39.1/2
-             * {AI95-00392-01AI95-00392-01} If the component types of
+             * {<AI95-00392-01AI95-00392-01>} If the component types of
                the array types are anonymous access types, then a check
                is made that the accessibility level of the operand type
-               is not deeper than that of the target type. 
+               is not deeper than that of the target type.  
 
 39.b/2
           Reason: This check is needed for operands that are access
@@ -26053,7 +26136,7 @@ of the modular type.]  Additional rules follow:
           initialized.
 
 42
-             * [The tag of the result is that of the operand.] If the
+             * [The tag of the result is that of the operand.]  If the
                operand type is class-wide, a check is made that the tag
                of the operand identifies a (specific) type that is
                covered by or descended from the target type.
@@ -26105,8 +26188,8 @@ of the modular type.]  Additional rules follow:
    * Access Type Conversion
 
 48/3
-             * {AI05-0148-1AI05-0148-1} {AI05-0248-1AI05-0248-1} For an
-               access-to-object type, a check is made that the
+             * {<AI05-0148-1AI05-0148-1>} {<AI05-0248-1AI05-0248-1>} For
+               an access-to-object type, a check is made that the
                accessibility level of the operand type is not deeper
                than that of the target type, unless the target type is
                an anonymous access type of a stand-alone object.  If the
@@ -26115,10 +26198,10 @@ of the modular type.]  Additional rules follow:
                is not deeper than that of the declaration of the
                stand-alone object[; then if the check succeeds, the
                accessibility level of the target type becomes that of
-               the operand type]. 
+               the operand type].  
 
 48.a/3
-          Ramification: {AI05-0148-1AI05-0148-1} This check is needed
+          Ramification: {<AI05-0148-1AI05-0148-1>} This check is needed
           for operands that are access parameters, for stand-alone
           anonymous access objects, and in instance bodies.
 
@@ -26128,9 +26211,10 @@ of the modular type.]  Additional rules follow:
           is done when calling a subprogram with an access parameter.
 
 49/2
-             * {AI95-00230-01AI95-00230-01} {AI95-00231-01AI95-00231-01}
-               If the operand value is null, the result of the
-               conversion is the null value of the target type.
+             * {<AI95-00230-01AI95-00230-01>}
+               {<AI95-00231-01AI95-00231-01>} If the operand value is
+               null, the result of the conversion is the null value of
+               the target type.
 
 49.a/2
           Ramification: A conversion to an anonymous access type happens
@@ -26150,9 +26234,9 @@ of the modular type.]  Additional rules follow:
           and operand designated subtypes statically match.
 
 51/4
-{AI95-00231-01AI95-00231-01} {AI05-0153-3AI05-0153-3}
-{AI05-0290-1AI05-0290-1} {AI12-0071-1AI12-0071-1} After conversion of
-the value to the target type, if the target subtype is constrained, a
+{<AI95-00231-01AI95-00231-01>} {<AI05-0153-3AI05-0153-3>}
+{<AI05-0290-1AI05-0290-1>} {<AI12-0071-1AI12-0071-1>} After conversion
+of the value to the target type, if the target subtype is constrained, a
 check is performed that the value satisfies this constraint.  If the
 target subtype excludes null, then a check is made that the value is not
 null.  If predicate checks are enabled for the target subtype (see *note
@@ -26160,7 +26244,7 @@ null.  If predicate checks are enabled for the target 
subtype (see *note
 of the target subtype.
 
 51.a/2
-          Ramification: {AI95-00231-01AI95-00231-01} The first check
+          Ramification: {<AI95-00231-01AI95-00231-01>} The first check
           above is a Range_Check for scalar subtypes, a
           Discriminant_Check or Index_Check for access subtypes, and a
           Discriminant_Check for discriminated subtypes.  The
@@ -26178,7 +26262,7 @@ performed as above for a value conversion.
 The properties of this new view are as follows:
 
 54/1
-   * {8652/00178652/0017} {AI95-00184-01AI95-00184-01} If the target
+   * {<8652/00178652/0017>} {<AI95-00184-01AI95-00184-01>} If the target
      type is composite, the bounds or discriminants (if any) of the view
      are as defined above for a value conversion; each nondiscriminant
      component of the view denotes the matching component of the operand
@@ -26196,21 +26280,21 @@ The properties of this new view are as follows:
      object (which might raise Constraint_Error); 
 
 56/4
-   * {AI12-0074-1AI12-0074-1} Reading the value of the view yields the
+   * {<AI12-0074-1AI12-0074-1>} Reading the value of the view yields the
      result of converting the value of the operand object to the target
      subtype (which might raise Constraint_Error), except if the object
      is of an elementary type and the view conversion is passed as an
      out parameter; in this latter case, the value of the operand object
      may be used to initialize the formal parameter without checking
      against any constraint of the target subtype (as described more
-     precisely in *note 6.4.1::). 
+     precisely in *note 6.4.1::).  
 
 56.a/4
-          Reason: {AI12-0074-1AI12-0074-1} This ensures that even an out
-          parameter of an elementary type is initialized reasonably.
+          Reason: {<AI12-0074-1AI12-0074-1>} This ensures that even an
+          out parameter of an elementary type is initialized reasonably.
 
 57/4
-{AI05-0290-1AI05-0290-1} {AI12-0096-1AI12-0096-1} If an
+{<AI05-0290-1AI05-0290-1>} {<AI12-0096-1AI12-0096-1>} If an
 Accessibility_Check fails, Program_Error is raised.  If a predicate
 check fails, the effect is as defined in subclause *note 3.2.4::, "*note
 3.2.4:: Subtype Predicates".  Any other check associated with a
@@ -26233,10 +26317,10 @@ subtype of the type.
           if the value is outside the base range of the type.
 
 58.1/4
-{AI12-0027-1AI12-0027-1} Evaluation of a value conversion of a composite
-type either creates a new anonymous object[ (similar to the object
-created by the evaluation of an aggregate or a function call)] or yields
-a new view of the operand object without creating a new object:
+{<AI12-0027-1AI12-0027-1>} Evaluation of a value conversion of a
+composite type either creates a new anonymous object[ (similar to the
+object created by the evaluation of an aggregate or a function call)] or
+yields a new view of the operand object without creating a new object:
 
 58.2/4
    * If the target type is a by-reference type and there is a type that
@@ -26252,7 +26336,7 @@ a new view of the operand object without creating a new 
object:
    * Otherwise, it is unspecified whether a new object is created.
 
 58.5/4
-{AI12-0027-1AI12-0027-1} If a new object is created, then the
+{<AI12-0027-1AI12-0027-1>} If a new object is created, then the
 initialization of that object is an assignment operation.
 
 58.b.1/4
@@ -26267,7 +26351,7 @@ initialization of that object is an assignment 
operation.
      performed implicitly in situations where the expected type and the
      actual type of a construct differ, as is permitted by the type
      resolution rules (see *note 8.6::).  For example, an integer
-     literal is of the type universal_integer, and is implicitly
+     literal is of the type <universal_integer>, and is implicitly
      converted when assigned to a target of some specific integer type.
      Similarly, an actual parameter of a specific tagged type is
      implicitly converted when the corresponding formal parameter is of
@@ -26281,7 +26365,7 @@ initialization of that object is an assignment 
operation.
      the constraints of the target subtype.
 
 61/2
-     21  {AI95-00230-01AI95-00230-01} A ramification of the overload
+     21  {<AI95-00230-01AI95-00230-01>} A ramification of the overload
      resolution rules is that the operand of an (explicit)
      type_conversion cannot be an allocator, an aggregate, a
      string_literal, a character_literal, or an attribute_reference for
@@ -26300,15 +26384,15 @@ initialization of that object is an assignment 
operation.
                               _Examples_
 
 63
-Examples of numeric type conversion:
+<Examples of numeric type conversion:>
 
 64
-     Real(2*J)      --  value is converted to floating point
-     Integer(1.6)   --  value is 2
-     Integer(-0.4)  --  value is 0
+     Real(2*J)      <--  value is converted to floating point>
+     Integer(1.6)   <--  value is 2>
+     Integer(-0.4)  <--  value is 0>
 
 65
-Example of conversion between derived types:
+<Example of conversion between derived types:>
 
 66
      type A_Form is new B_Form;
@@ -26319,10 +26403,10 @@ Example of conversion between derived types:
 
 68
      X := A_Form(Y);
-     Y := B_Form(X);  --  the reverse conversion 
+     Y := B_Form(X);  <--  the reverse conversion >
 
 69
-Examples of conversions between array types:
+<Examples of conversions between array types:>
 
 70
      type Sequence is array (Integer range <>) of Integer;
@@ -26330,9 +26414,9 @@ Examples of conversions between array types:
      Ledger : array(1 .. 100) of Integer;
 
 71
-     Sequence(Ledger)            --  bounds are those of Ledger
-     Sequence(Ledger(31 .. 42))  --  bounds are 31 and 42
-     Dozen(Ledger(31 .. 42))     --  bounds are those of Dozen 
+     Sequence(Ledger)            <--  bounds are those of Ledger>
+     Sequence(Ledger(31 .. 42))  <--  bounds are 31 and 42>
+     Dozen(Ledger(31 .. 42))     <--  bounds are those of Dozen >
 
                     _Incompatibilities With Ada 83_
 
@@ -26397,7 +26481,7 @@ Examples of conversions between array types:
           allowed as the operand of a type_conversion, except in a NOTE.
 
 71.i/3
-          {AI05-0299-1AI05-0299-1} The rules in this subclause subsume
+          {<AI05-0299-1AI05-0299-1>} The rules in this subclause subsume
           the rules for "parameters of the form of a type conversion,"
           and have been generalized to cover the use of a type
           conversion as a name.
@@ -26405,20 +26489,20 @@ Examples of conversions between array types:
                     _Incompatibilities With Ada 95_
 
 71.j/2
-          {AI95-00246-01AI95-00246-01} Amendment Correction: Conversions
-          between unrelated array types that are limited or (for view
-          conversions) might be by-reference types are now illegal.  The
-          representations of two such arrays may differ, making the
-          conversions impossible.  We make the check here, because
-          legality should not be based on representation properties.
-          Such conversions are likely to be rare, anyway.  There is a
-          potential that this change would make a working program
-          illegal (if the types have the same representation).
+          {<AI95-00246-01AI95-00246-01>} Amendment Correction:
+          Conversions between unrelated array types that are limited or
+          (for view conversions) might be by-reference types are now
+          illegal.  The representations of two such arrays may differ,
+          making the conversions impossible.  We make the check here,
+          because legality should not be based on representation
+          properties.  Such conversions are likely to be rare, anyway.
+          There is a potential that this change would make a working
+          program illegal (if the types have the same representation).
 
 71.k/2
-          {AI95-00363-01AI95-00363-01} If a discriminated full type has
-          a partial view (private type) that is constrained, we do not
-          allow conversion between access-to-unconstrained and
+          {<AI95-00363-01AI95-00363-01>} If a discriminated full type
+          has a partial view (private type) that is constrained, we do
+          not allow conversion between access-to-unconstrained and
           access-to-constrained subtypes designating the type.  Ada 95
           allowed this conversion and the declaration of various access
           subtypes, requiring that the designated object be constrained
@@ -26429,14 +26513,14 @@ Examples of conversions between array types:
                         _Extensions to Ada 95_
 
 71.l/2
-          {AI95-00230-01AI95-00230-01} Conversion rules for
-          universal_access were defined.  These allow the use of
+          {<AI95-00230-01AI95-00230-01>} Conversion rules for
+          <universal_access> were defined.  These allow the use of
           anonymous access values in equality tests (see *note 4.5.2::),
           and also allow the use of null in type conversions and other
           contexts that do not provide a single expected type.
 
 71.m/2
-          {AI95-00384-01AI95-00384-01} A type conversion from an
+          {<AI95-00384-01AI95-00384-01>} A type conversion from an
           access-to-discriminated and unconstrained object to an
           access-to-discriminated and constrained one is allowed.  Ada
           95 only allowed the reverse conversion, which was weird and
@@ -26446,33 +26530,34 @@ Examples of conversions between array types:
                      _Wording Changes from Ada 95_
 
 71.n/2
-          {8652/00178652/0017} {AI95-00184-01AI95-00184-01} Corrigendum:
-          Wording was added to ensure that view conversions are
-          constrained, and that a tagged view conversion has a tagged
-          object.  Both rules are needed to avoid having a way to change
-          the discriminants of a constrained object.
+          {<8652/00178652/0017>} {<AI95-00184-01AI95-00184-01>}
+          Corrigendum: Wording was added to ensure that view conversions
+          are constrained, and that a tagged view conversion has a
+          tagged object.  Both rules are needed to avoid having a way to
+          change the discriminants of a constrained object.
 
 71.o/2
-          {8652/00088652/0008} {AI95-00168-01AI95-00168-01} Corrigendum:
-          Wording was added to ensure that the aliased status of array
-          components cannot change in a view conversion.  This rule was
-          needed to avoid having a way to change the discriminants of an
-          aliased object.  This rule was repealed later, as Ada 2005
-          allows changing the discriminants of an aliased object.
+          {<8652/00088652/0008>} {<AI95-00168-01AI95-00168-01>}
+          Corrigendum: Wording was added to ensure that the aliased
+          status of array components cannot change in a view conversion.
+          This rule was needed to avoid having a way to change the
+          discriminants of an aliased object.  This rule was repealed
+          later, as Ada 2005 allows changing the discriminants of an
+          aliased object.
 
 71.p/2
-          {AI95-00231-01AI95-00231-01} Wording was added to check
+          {<AI95-00231-01AI95-00231-01>} Wording was added to check
           subtypes that exclude null (see *note 3.10::).
 
 71.q/2
-          {AI95-00251-01AI95-00251-01} The organization of the legality
-          rules was changed, both to make it clearer, and to eliminate
-          an unintentional incompatibility with Ada 83.  The old
-          organization prevented type conversions between some types
+          {<AI95-00251-01AI95-00251-01>} The organization of the
+          legality rules was changed, both to make it clearer, and to
+          eliminate an unintentional incompatibility with Ada 83.  The
+          old organization prevented type conversions between some types
           that were related by derivation (which Ada 83 always allowed).
 
 71.r/3
-          {AI95-00330-01AI95-00330-01} {AI05-0005-1AI05-0005-1}
+          {<AI95-00330-01AI95-00330-01>} {<AI05-0005-1AI05-0005-1>}
           Clarified that an untagged type conversion appearing as a
           generic actual parameter for a generic in out formal parameter
           is not a view conversion (and thus is illegal).  This confirms
@@ -26480,13 +26565,13 @@ Examples of conversions between array types:
           interpretation.
 
 71.s/2
-          {AI95-00363-01AI95-00363-01} Rules added by the Corrigendum to
-          eliminate problems with discriminants of aliased components
+          {<AI95-00363-01AI95-00363-01>} Rules added by the Corrigendum
+          to eliminate problems with discriminants of aliased components
           changing were removed, as we now generally allow discriminants
           of aliased components to be changed.
 
 71.t/2
-          {AI95-00392-01AI95-00392-01} Accessibility checks on
+          {<AI95-00392-01AI95-00392-01>} Accessibility checks on
           conversions involving types with anonymous access components
           were added.  These components have the level of the type, and
           conversions can be between types at different levels, which
@@ -26496,8 +26581,8 @@ Examples of conversions between array types:
                     _Inconsistencies With Ada 2005_
 
 71.u/3
-          {AI05-0148-1AI05-0148-1} A stand-alone object of an anonymous
-          access-to-object type now has dynamic accessibility.
+          {<AI05-0148-1AI05-0148-1>} A stand-alone object of an
+          anonymous access-to-object type now has dynamic accessibility.
           Normally, this will make programs legal that were illegal in
           Ada 2005.  However, it is possible that a program that
           previously raised Program_Error now will not.  It is very
@@ -26508,39 +26593,39 @@ Examples of conversions between array types:
                     _Wording Changes from Ada 2005_
 
 71.v/3
-          {AI05-0115-1AI05-0115-1} Correction: Clarified that a root
+          {<AI05-0115-1AI05-0115-1>} Correction: Clarified that a root
           numeric type is not considered a common ancestor for a
           conversion.
 
 71.w/3
-          {AI05-0153-3AI05-0153-3} {AI05-0290-1AI05-0290-1} Added rules
-          so that predicate aspects (see *note 3.2.4::) are enforced on
-          subtype conversion.
+          {<AI05-0153-3AI05-0153-3>} {<AI05-0290-1AI05-0290-1>} Added
+          rules so that predicate aspects (see *note 3.2.4::) are
+          enforced on subtype conversion.
 
                    _Incompatibilities With Ada 2012_
 
 71.x/4
-          {AI12-0095-1AI12-0095-1} Corrigendum: Because of a rule added
-          in *note 12.5.1::, the checks for the legality of an access
-          type conversion in a generic body were strengthened to use an
-          assume the worst rule.  This case is rather unlikely as a
-          formal private or derived type with discriminants is required
-          along with a conversion between two access types whose
-          designated types don't statically match, and any such programs
-          were at risk having objects disappear while valid access
-          values still pointed at them.
+          {<AI12-0095-1AI12-0095-1>} Corrigendum: Because of a rule
+          added in *note 12.5.1::, the checks for the legality of an
+          access type conversion in a generic body were strengthened to
+          use an assume the worst rule.  This case is rather unlikely as
+          a formal private or derived type with discriminants is
+          required along with a conversion between two access types
+          whose designated types don't statically match, and any such
+          programs were at risk having objects disappear while valid
+          access values still pointed at them.
 
                     _Wording Changes from Ada 2012_
 
 71.y/4
-          {AI12-0027-1AI12-0027-1} Corrigendum: Moved the generic
+          {<AI12-0027-1AI12-0027-1>} Corrigendum: Moved the generic
           boilerplate so that it covers all Legality Rules in this
           subclause.  This was always intended, but it is not expected
           to change anything other than conversions between unrelated
           arrays.
 
 71.z/4
-          {AI12-0027-1AI12-0027-1} Corrigendum: Added a formal
+          {<AI12-0027-1AI12-0027-1>} Corrigendum: Added a formal
           definition of the copy potentially created by a value
           conversion of a composite type, so properties like
           finalization and accessibility are properly defined.  This
@@ -26548,20 +26633,20 @@ Examples of conversions between array types:
           would not work), but it was not previously formally defined.
 
 71.aa/4
-          {AI12-0071-1AI12-0071-1} Corrigendum: Updated wording of type
-          conversions to use the new term "satisfies the predicates"
-          (see *note 3.2.4::).
+          {<AI12-0071-1AI12-0071-1>} Corrigendum: Updated wording of
+          type conversions to use the new term "satisfies the
+          predicates" (see *note 3.2.4::).
 
 71.bb/4
-          {AI12-0074-1AI12-0074-1} Corrigendum: Clarified the wording
+          {<AI12-0074-1AI12-0074-1>} Corrigendum: Clarified the wording
           describing the effect of view conversions of out parameters
           such that it is clear that the detailed effect is defined in
           *note 6.4.1::, not here.
 
 71.cc/4
-          {AI12-0096-1AI12-0096-1} Corrigendum: Updated wording of type
-          conversions so that the exception raise or other effect of a
-          failed predicate check is as defined in *note 3.2.4::; we
+          {<AI12-0096-1AI12-0096-1>} Corrigendum: Updated wording of
+          type conversions so that the exception raise or other effect
+          of a failed predicate check is as defined in *note 3.2.4::; we
           don't want to repeat those rules here.  This doesn't change
           the behavior for predicate checks possible in original Ada
           2012, only ones using the new aspect Predicate_Failure.
@@ -26575,7 +26660,7 @@ File: aarm2012.info,  Node: 4.7,  Next: 4.8,  Prev: 
4.6,  Up: 4
 1
 [A qualified_expression is used to state explicitly the type, and to
 verify the subtype, of an operand that is either an expression or an
-aggregate. ]
+aggregate.  ]
 
                                _Syntax_
 
@@ -26586,28 +26671,29 @@ aggregate. ]
                         _Name Resolution Rules_
 
 3
-The operand (the expression or aggregate) shall resolve to be of the
+The <operand> (the expression or aggregate) shall resolve to be of the
 type determined by the subtype_mark (*note 3.2.2: S0028.), or a
 universal type that covers it.
 
                           _Static Semantics_
 
 3.1/3
-{AI05-0003-1AI05-0003-1} [If the operand of a qualified_expression
+{<AI05-0003-1AI05-0003-1>} [If the operand of a qualified_expression
 denotes an object, the qualified_expression denotes a constant view of
 that object.]  The nominal subtype of a qualified_expression is the
 subtype denoted by the subtype_mark.
 
 3.a/3
-          Proof: {AI05-0003-1AI05-0003-1} This is stated in *note 3.3::.
+          Proof: {<AI05-0003-1AI05-0003-1>} This is stated in *note
+          3.3::.
 
                           _Dynamic Semantics_
 
 4/4
-{AI12-0100-1AI12-0100-1} The evaluation of a qualified_expression
+{<AI12-0100-1AI12-0100-1>} The evaluation of a qualified_expression
 evaluates the operand (and if of a universal type, converts it to the
 type determined by the subtype_mark) and checks that its value belongs
-to the subtype denoted by the subtype_mark. The exception
+to the subtype denoted by the subtype_mark.  The exception
 Constraint_Error is raised if this check fails.  Furthermore, if
 predicate checks are enabled for the subtype denoted by the
 subtype_mark, a check is performed as defined in subclause *note
@@ -26621,7 +26707,7 @@ predicates of the subtype.
           provided.
 
 4.a.1/4
-          {AI12-0100-1AI12-0100-1} The effect of a failed predicate
+          {<AI12-0100-1AI12-0100-1>} The effect of a failed predicate
           check is as defined in *note 3.2.4::; such a check could raise
           any exception, not just Constraint_Error or Assertion_Error.
 
@@ -26634,8 +26720,8 @@ predicates of the subtype.
           if subtype conversion is desired.
 
 4.c/4
-          {AI12-0100-1AI12-0100-1} We do a predicate check here so that
-          a qualified_expression never allows something that the
+          {<AI12-0100-1AI12-0100-1>} We do a predicate check here so
+          that a qualified_expression never allows something that the
           equivalent type_conversion would not allow.
 
      NOTES
@@ -26650,34 +26736,34 @@ predicates of the subtype.
                               _Examples_
 
 6
-Examples of disambiguating expressions using qualification:
+<Examples of disambiguating expressions using qualification:>
 
 7
      type Mask is (Fix, Dec, Exp, Signif);
      type Code is (Fix, Cla, Dec, Tnz, Sub);
 
 8
-     Print (Mask'(Dec));  --  Dec is of type Mask
-     Print (Code'(Dec));  --  Dec is of type Code 
+     Print (Mask'(Dec));  <--  Dec is of type Mask>
+     Print (Code'(Dec));  <--  Dec is of type Code >
 
 9
-     for J in Code'(Fix) .. Code'(Dec) loop ... -- qualification needed for 
either Fix or Dec
-     for J in Code range Fix .. Dec loop ...    -- qualification unnecessary
-     for J in Code'(Fix) .. Dec loop ...        -- qualification unnecessary 
for Dec
+     for J in Code'(Fix) .. Code'(Dec) loop ... <-- qualification needed for 
either Fix or Dec>
+     for J in Code range Fix .. Dec loop ...    <-- qualification unnecessary>
+     for J in Code'(Fix) .. Dec loop ...        <-- qualification unnecessary 
for Dec>
 
 10
-     Dozen'(1 | 3 | 5 | 7 => 2, others => 0) -- see *note 4.6:: 
+     Dozen'(1 | 3 | 5 | 7 => 2, others => 0) <-- see *note 4.6:: >
 
                     _Wording Changes from Ada 2005_
 
 10.a/3
-          {AI05-0003-1AI05-0003-1} Added a definition of the nominal
+          {<AI05-0003-1AI05-0003-1>} Added a definition of the nominal
           subtype of a qualified_expression.
 
                     _Inconsistencies With Ada 2012_
 
 10.b/4
-          {AI12-0100-1AI12-0100-1} Corrigendum: A qualified_expression
+          {<AI12-0100-1AI12-0100-1>} Corrigendum: A qualified_expression
           now performs a predicate check for the named subtype (if it is
           enabled).  Original Ada 2012 did not include that check (an
           omission).  While this is formally inconsistent (an exception
@@ -26695,21 +26781,21 @@ File: aarm2012.info,  Node: 4.8,  Next: 4.9,  Prev: 
4.7,  Up: 4
 
 1
 [The evaluation of an allocator creates an object and yields an access
-value that designates the object. ]
+value that designates the object.  ]
 
                                _Syntax_
 
 2/3
-     {AI05-0111-3AI05-0111-3} allocator ::=
+     {<AI05-0111-3AI05-0111-3>} allocator ::=
         new [subpool_specification] subtype_indication
       | new [subpool_specification] qualified_expression
 
 2.1/3
-     {AI05-0111-3AI05-0111-3} subpool_specification ::= (subpool_handle_
-     name)
+     {<AI05-0111-3AI05-0111-3>} subpool_specification ::=
+     (<subpool_handle_>name)
 
 2.2/3
-     {AI05-0104-1AI05-0104-1} For an allocator with a
+     {<AI05-0104-1AI05-0104-1>} For an allocator with a
      subtype_indication, the subtype_indication shall not specify a
      null_exclusion.
 
@@ -26723,16 +26809,16 @@ value that designates the object. ]
                         _Name Resolution Rules_
 
 3/3
-{8652/00108652/0010} {AI95-00127-01AI95-00127-01}
-{AI05-0111-3AI05-0111-3} {AI05-0269-1AI05-0269-1} The expected type for
-an allocator shall be a single access-to-object type with designated
-type D such that either D covers the type determined by the subtype_mark
-of the subtype_indication (*note 3.2.2: S0027.) or qualified_expression
-(*note 4.7: S0142.), or the expected type is anonymous and the
-determined type is D'Class.  A subpool_handle_name is expected to be of
-any type descended from Subpool_Handle, which is the type used to
-identify a subpool, declared in package System.Storage_Pools.Subpools
-(see *note 13.11.4::).
+{<8652/00108652/0010>} {<AI95-00127-01AI95-00127-01>}
+{<AI05-0111-3AI05-0111-3>} {<AI05-0269-1AI05-0269-1>} The expected type
+for an allocator shall be a single access-to-object type with designated
+type <D> such that either <D> covers the type determined by the
+subtype_mark of the subtype_indication (*note 3.2.2: S0027.) or
+qualified_expression (*note 4.7: S0142.), or the expected type is
+anonymous and the determined type is <D>'Class.  A <subpool_handle_>name
+is expected to be of any type descended from Subpool_Handle, which is
+the type used to identify a subpool, declared in package
+System.Storage_Pools.Subpools (see *note 13.11.4::).
 
 3.a
           Discussion: See *note 8.6::, "*note 8.6:: The Context of
@@ -26740,20 +26826,19 @@ identify a subpool, declared in package 
System.Storage_Pools.Subpools
           type whose ..."
 
 3.a.1/1
-          Ramification: {8652/00108652/0010}
-          {AI95-00127-01AI95-00127-01} An allocator is allowed as a
+          Ramification: {<8652/00108652/0010>}
+          {<AI95-00127-01AI95-00127-01>} An allocator is allowed as a
           controlling parameter of a dispatching call (see *note
           3.9.2::).
 
                            _Legality Rules_
 
 4
-An initialized allocator is an allocator with a qualified_expression. An
-uninitialized allocator is one with a subtype_indication.  In the
+An <initialized> allocator is an allocator with a qualified_expression.An 
<uninitialized> allocator is one with a subtype_indication.  In the
 subtype_indication of an uninitialized allocator, a constraint is
 permitted only if the subtype_mark denotes an [unconstrained] composite
 subtype; if there is no constraint, then the subtype_mark shall denote a
-definite subtype. 
+definite subtype.  
 
 4.a
           Ramification: For example, ...  new S'Class ...  (with no
@@ -26763,20 +26848,20 @@ definite subtype.
           have a constraint.)
 
 5/2
-{AI95-00287-01AI95-00287-01} If the type of the allocator is an
+{<AI95-00287-01AI95-00287-01>} If the type of the allocator is an
 access-to-constant type, the allocator shall be an initialized
 allocator.
 
 5.a/2
-          This paragraph was deleted.{AI95-00287-01AI95-00287-01}
+          <This paragraph was deleted.>{<AI95-00287-01AI95-00287-01>}
 
 5.1/3
-{AI05-0111-3AI05-0111-3} If a subpool_specification is given, the type
+{<AI05-0111-3AI05-0111-3>} If a subpool_specification is given, the type
 of the storage pool of the access type shall be a descendant of
 Root_Storage_Pool_With_Subpools.
 
 5.2/3
-{AI95-00344-01AI95-00344-01} If the designated type of the type of the
+{<AI95-00344-01AI95-00344-01>} If the designated type of the type of the
 allocator is class-wide, the accessibility level of the type determined
 by the subtype_indication or qualified_expression shall not be
 statically deeper than that of the type of the allocator.
@@ -26786,7 +26871,7 @@ statically deeper than that of the type of the 
allocator.
           type.
 
 5.3/3
-{AI95-00416-01AI95-00416-01} {AI05-0051-1AI05-0051-1} If the subtype
+{<AI95-00416-01AI95-00416-01>} {<AI05-0051-1AI05-0051-1>} If the subtype
 determined by the subtype_indication or qualified_expression of the
 allocator has one or more access discriminants, then the accessibility
 level of the anonymous access type of each access discriminant shall not
@@ -26798,10 +26883,10 @@ be statically deeper than that of the type of the 
allocator (see *note
           discriminants.
 
 5.4/3
-{AI95-00366-01AI95-00366-01} {AI05-0052-1AI05-0052-1}
-{AI05-0157-1AI05-0157-1} An allocator shall not be of an access type for
-which the Storage_Size has been specified by a static expression with
-value zero or is defined by the language to be zero.
+{<AI95-00366-01AI95-00366-01>} {<AI05-0052-1AI05-0052-1>}
+{<AI05-0157-1AI05-0157-1>} An allocator shall not be of an access type
+for which the Storage_Size has been specified by a static expression
+with value zero or is defined by the language to be zero.
 
 5.d/2
           Reason: An allocator for an access type that has Storage_Size
@@ -26813,19 +26898,19 @@ value zero or is defined by the language to be zero.
           would represent state.
 
 5.e/3
-          {AI05-0157-1AI05-0157-1} We don't need a special rule to cover
-          generic formals (unlike many other similar Legality Rules).
-          There are only two cases of interest.  For formal access
-          types, the Storage_Size property is not known in the generic,
-          and surely isn't static, so this Legality Rule can never
-          apply.  For a formal derived type, this Legality Rule can only
-          be triggered by a parent type having one of the appropriate
-          properties.  But Storage_Size can never be specified for a
-          derived access type, so it always has the same value for all
-          child types; additionally, a type derived from a remote access
-          type (which has Storage_Size defined to be zero) is also a
-          remote access type.  That means that any actual that would
-          match the formal derived type necessarily has the same
+          {<AI05-0157-1AI05-0157-1>} We don't need a special rule to
+          cover generic formals (unlike many other similar Legality
+          Rules).  There are only two cases of interest.  For formal
+          access types, the Storage_Size property is not known in the
+          generic, and surely isn't static, so this Legality Rule can
+          never apply.  For a formal derived type, this Legality Rule
+          can only be triggered by a parent type having one of the
+          appropriate properties.  But Storage_Size can never be
+          specified for a derived access type, so it always has the same
+          value for all child types; additionally, a type derived from a
+          remote access type (which has Storage_Size defined to be zero)
+          is also a remote access type.  That means that any actual that
+          would match the formal derived type necessarily has the same
           Storage_Size properties, so it is harmless (and preferable) to
           check them in the body - they are always known in that case.
           For other formal types,allocators are not allowed, so we don't
@@ -26833,7 +26918,7 @@ value zero or is defined by the language to be zero.
           rule here.
 
 5.5/3
-{AI05-0052-1AI05-0052-1} If the designated type of the type of the
+{<AI05-0052-1AI05-0052-1>} If the designated type of the type of the
 allocator is limited, then the allocator shall not be used to define the
 value of an access discriminant, unless the discriminated type is
 immutably limited (see *note 7.5::).
@@ -26850,9 +26935,9 @@ immutably limited (see *note 7.5::).
           containing object is of a type that is always limited.
 
 5.6/3
-{AI05-0052-1AI05-0052-1} In addition to the places where Legality Rules
-normally apply (see *note 12.3::), these rules apply also in the private
-part of an instance of a generic unit.
+{<AI05-0052-1AI05-0052-1>} In addition to the places where Legality
+Rules normally apply (see *note 12.3::), these rules apply also in the
+private part of an instance of a generic unit.
 
 5.g/3
           Discussion: This applies to all of the Legality Rules of this
@@ -26861,27 +26946,28 @@ part of an instance of a generic unit.
                           _Static Semantics_
 
 6/3
-{AI95-00363-01AI95-00363-01} {AI05-0041-1AI05-0041-1} If the designated
-type of the type of the allocator is elementary, then the subtype of the
-created object is the designated subtype.  If the designated type is
-composite, then the subtype of the created object is the designated
-subtype when the designated subtype is constrained or there is an
-ancestor of the designated type that has a constrained partial view;
-otherwise, the created object is constrained by its initial value [(even
-if the designated subtype is unconstrained with defaults)]. 
+{<AI95-00363-01AI95-00363-01>} {<AI05-0041-1AI05-0041-1>} If the
+designated type of the type of the allocator is elementary, then the
+subtype of the created object is the designated subtype.  If the
+designated type is composite, then the subtype of the created object is
+the designated subtype when the designated subtype is constrained or
+there is an ancestor of the designated type that has a constrained
+partial view; otherwise, the created object is constrained by its
+initial value [(even if the designated subtype is unconstrained with
+defaults)].  
 
 6.a
           Discussion: See AI83-00331.
 
 6.b/2
-          Reason: {AI95-00363-01AI95-00363-01} All objects created by an
-          allocator are aliased, and most aliased composite objects need
-          to be constrained so that access subtypes work reasonably.
-          Problematic access subtypes are prohibited for types with a
-          constrained partial view.
+          Reason: {<AI95-00363-01AI95-00363-01>} All objects created by
+          an allocator are aliased, and most aliased composite objects
+          need to be constrained so that access subtypes work
+          reasonably.  Problematic access subtypes are prohibited for
+          types with a constrained partial view.
 
 6.c/2
-          Discussion: {AI95-00363-01AI95-00363-01} If there is a
+          Discussion: {<AI95-00363-01AI95-00363-01>} If there is a
           constrained partial view of the type, this allows the objects
           to be unconstrained.  This eliminates privacy breaking (we
           don't want the objects to act differently simply because
@@ -26898,11 +26984,11 @@ if the designated subtype is unconstrained with 
defaults)].
                           _Dynamic Semantics_
 
 7/2
-{AI95-00373-01AI95-00373-01} For the evaluation of an initialized
+{<AI95-00373-01AI95-00373-01>} For the evaluation of an initialized
 allocator, the evaluation of the qualified_expression is performed
-first. An object of the designated type is created and the value of the
+first.  An object of the designated type is created and the value of the
 qualified_expression is converted to the designated subtype and assigned
-to the object. 
+to the object.  
 
 7.a
           Ramification: The conversion might raise Constraint_Error.
@@ -26912,19 +26998,19 @@ For the evaluation of an uninitialized allocator, the 
elaboration of the
 subtype_indication is performed first.  Then:
 
 9/2
-   * {AI95-00373-01AI95-00373-01} If the designated type is elementary,
-     an object of the designated subtype is created and any implicit
-     initial value is assigned;
+   * {<AI95-00373-01AI95-00373-01>} If the designated type is
+     elementary, an object of the designated subtype is created and any
+     implicit initial value is assigned;
 
 10/2
-   * {8652/00028652/0002} {AI95-00171-01AI95-00171-01}
-     {AI95-00373-01AI95-00373-01} If the designated type is composite,
+   * {<8652/00028652/0002>} {<AI95-00171-01AI95-00171-01>}
+     {<AI95-00373-01AI95-00373-01>} If the designated type is composite,
      an object of the designated type is created with tag, if any,
      determined by the subtype_mark of the subtype_indication.  This
      object is then initialized by default (see *note 3.3.1::) using the
-     subtype_indication to determine its nominal subtype. A check is
+     subtype_indication to determine its nominal subtype.  A check is
      made that the value of the object belongs to the designated
-     subtype. Constraint_Error is raised if this check fails.  This
+     subtype.  Constraint_Error is raised if this check fails.  This
      check and the initialization of the object are performed in an
      arbitrary order.
 
@@ -26932,9 +27018,9 @@ subtype_indication is performed first.  Then:
           Discussion: AI83-00150.
 
 10.1/3
-{AI95-00344-01AI95-00344-01} {AI95-00416-01AI95-00416-01}
-{AI05-0024-1AI05-0024-1} {AI05-0051-1AI05-0051-1}
-{AI05-0234-1AI05-0234-1} For any allocator, if the designated type of
+{<AI95-00344-01AI95-00344-01>} {<AI95-00416-01AI95-00416-01>}
+{<AI05-0024-1AI05-0024-1>} {<AI05-0051-1AI05-0051-1>}
+{<AI05-0234-1AI05-0234-1>} For any allocator, if the designated type of
 the type of the allocator is class-wide, then a check is made that the
 master of the type determined by the subtype_indication, or by the tag
 of the value of the qualified_expression, includes the elaboration of
@@ -26944,21 +27030,22 @@ tag of the value if the type of the 
qualified_expression is class-wide)
 has one or more access discriminants, then a check is made that the
 accessibility level of the anonymous access type of each access
 discriminant is not deeper than that of the type of the allocator.
-Program_Error is raised if either such check fails. 
+Program_Error is raised if either such check fails.  
 
 10.b/3
-          Reason: {AI95-00344-01AI95-00344-01} {AI05-0024-1AI05-0024-1}
-          The master check on class-wide types prevents the allocated
-          object from outliving its type.  We need the run-time check in
-          instance bodies, or when the type of the qualified_expression
-          is class-wide (other cases are statically detected).
+          Reason: {<AI95-00344-01AI95-00344-01>}
+          {<AI05-0024-1AI05-0024-1>} The master check on class-wide
+          types prevents the allocated object from outliving its type.
+          We need the run-time check in instance bodies, or when the
+          type of the qualified_expression is class-wide (other cases
+          are statically detected).
 
 10.b.1/3
-          {AI05-0024-1AI05-0024-1} We can't use the normal accessibility
-          level "deeper than" check here because we may have
-          "incomparable" levels if the appropriate master and the type
-          declaration belong to two different tasks.  This can happen
-          when checking the master of the tag for an allocator
+          {<AI05-0024-1AI05-0024-1>} We can't use the normal
+          accessibility level "deeper than" check here because we may
+          have "incomparable" levels if the appropriate master and the
+          type declaration belong to two different tasks.  This can
+          happen when checking the master of the tag for an allocator
           initialized by a parameter passed in to an accept statement,
           if the type of the allocator is an access type declared in the
           enclosing task body.  For example:
@@ -26970,22 +27057,22 @@ Program_Error is raised if either such check fails.
                begin
                   accept E(X : T'Class) do
                      P := new T'Class'(X);
-                        --  Master check on tag of X.
-                        --  Can't use "accessibility levels" since they might 
be incomparable.
-                        --  Must revert to checking that the master of the 
type identified by
-                        --  X'tag includes the elaboration of Acc_TC, so it is 
sure to outlive it.
+                        <--  Master check on tag of X.>
+                        <--  Can't use "accessibility levels" since they might 
be incomparable.>
+                        <--  Must revert to checking that the master of the 
type identified by>
+                        <--  X'tag includes the elaboration of Acc_TC, so it 
is sure to outlive it.>
                   end E;
 
 10.c/2
-          {AI95-00416-01AI95-00416-01} The accessibility check on access
-          discriminants prevents the allocated object from outliving its
-          discriminants.
+          {<AI95-00416-01AI95-00416-01>} The accessibility check on
+          access discriminants prevents the allocated object from
+          outliving its discriminants.
 
 10.2/2
-{AI95-00280-01AI95-00280-01} If the object to be created by an allocator
-has a controlled or protected part, and the finalization of the
-collection of the type of the allocator (see *note 7.6.1::) has started,
-Program_Error is raised. 
+{<AI95-00280-01AI95-00280-01>} If the object to be created by an
+allocator has a controlled or protected part, and the finalization of
+the collection of the type of the allocator (see *note 7.6.1::) has
+started, Program_Error is raised.  
 
 10.d/2
           Reason: If the object has a controlled or protected part, its
@@ -27005,10 +27092,10 @@ Program_Error is raised.
           allocating them.
 
 10.3/2
-{AI95-00280-01AI95-00280-01} If the object to be created by an allocator
-contains any tasks, and the master of the type of the allocator is
-completed, and all of the dependent tasks of the master are terminated
-(see *note 9.3::), then Program_Error is raised. 
+{<AI95-00280-01AI95-00280-01>} If the object to be created by an
+allocator contains any tasks, and the master of the type of the
+allocator is completed, and all of the dependent tasks of the master are
+terminated (see *note 9.3::), then Program_Error is raised.  
 
 10.f/2
           Reason: A task created after waiting for tasks has finished
@@ -27016,10 +27103,11 @@ completed, and all of the dependent tasks of the 
master are terminated
           never be awaited.
 
 10.4/3
-{AI05-0111-3AI05-0111-3} If the allocator includes a
-subpool_handle_name, Constraint_Error is raised if the subpool handle is
-null.  Program_Error is raised if the subpool does not belong (see *note
-13.11.4::) to the storage pool of the access type of the allocator. 
+{<AI05-0111-3AI05-0111-3>} If the allocator includes a
+<subpool_handle_>name, Constraint_Error is raised if the subpool handle
+is null.  Program_Error is raised if the subpool does not <belong> (see
+*note 13.11.4::) to the storage pool of the access type of the
+allocator.  
 
 10.g/3
           Implementation Note: This can be implemented by comparing the
@@ -27044,10 +27132,10 @@ returned.
                       _Bounded (Run-Time) Errors_
 
 11.1/2
-{AI95-00280-01AI95-00280-01}  It is a bounded error if the finalization
-of the collection of the type (see *note 7.6.1::) of the allocator has
-started.  If the error is detected, Program_Error is raised.  Otherwise,
-the allocation proceeds normally.
+{<AI95-00280-01AI95-00280-01>}  It is a bounded error if the
+finalization of the collection of the type (see *note 7.6.1::) of the
+allocator has started.  If the error is detected, Program_Error is
+raised.  Otherwise, the allocation proceeds normally.
 
 11.a/2
           Discussion: This check is required in some cases; see above.
@@ -27066,14 +27154,14 @@ the allocation proceeds normally.
 14
      26  As explained in *note 13.11::, "*note 13.11:: Storage
      Management", the storage for an object allocated by an allocator
-     comes from a storage pool (possibly user defined). The exception
+     comes from a storage pool (possibly user defined).  The exception
      Storage_Error is raised by an allocator if there is not enough
      storage.  Instances of Unchecked_Deallocation may be used to
      explicitly reclaim storage.
 
 15/3
-     27  {AI05-0229-1AI05-0229-1} Implementations are permitted, but not
-     required, to provide garbage collection.
+     27  {<AI05-0229-1AI05-0229-1>} Implementations are permitted, but
+     not required, to provide garbage collection.
 
 15.a
           Ramification: Note that in an allocator, the exception
@@ -27090,24 +27178,24 @@ the allocation proceeds normally.
                               _Examples_
 
 16
-Examples of allocators:
+<Examples of allocators:>
 
 17
-     new Cell'(0, null, null)                          -- initialized 
explicitly, see *note 3.10.1::
-     new Cell'(Value => 0, Succ => null, Pred => null) -- initialized 
explicitly
-     new Cell                                          -- not initialized
+     new Cell'(0, null, null)                          <-- initialized 
explicitly, see *note 3.10.1::>
+     new Cell'(Value => 0, Succ => null, Pred => null) <-- initialized 
explicitly>
+     new Cell                                          <-- not initialized>
 
 18
-     new Matrix(1 .. 10, 1 .. 20)                      -- the bounds only are 
given
-     new Matrix'(1 .. 10 => (1 .. 20 => 0.0))          -- initialized 
explicitly
+     new Matrix(1 .. 10, 1 .. 20)                      <-- the bounds only are 
given>
+     new Matrix'(1 .. 10 => (1 .. 20 => 0.0))          <-- initialized 
explicitly>
 
 19
-     new Buffer(100)                                   -- the discriminant 
only is given
-     new Buffer'(Size => 80, Pos => 0, Value => (1 .. 80 => 'A')) -- 
initialized explicitly
+     new Buffer(100)                                   <-- the discriminant 
only is given>
+     new Buffer'(Size => 80, Pos => 0, Value => (1 .. 80 => 'A')) <-- 
initialized explicitly>
 
 20
-     Expr_Ptr'(new Literal)                  -- allocator for 
access-to-class-wide type, see *note 3.9.1::
-     Expr_Ptr'(new Literal'(Expression with 3.5))      -- initialized 
explicitly
+     Expr_Ptr'(new Literal)                  <-- allocator for 
access-to-class-wide type, see *note 3.9.1::>
+     Expr_Ptr'(new Literal'(Expression with 3.5))      <-- initialized 
explicitly>
 
                     _Incompatibilities With Ada 83_
 
@@ -27120,9 +27208,9 @@ Examples of allocators:
                         _Extensions to Ada 83_
 
 20.b
-          Allocators creating objects of type T are now overloaded on
-          access types designating T'Class and all class-wide types that
-          cover T.
+          Allocators creating objects of type <T> are now overloaded on
+          access types designating <T'>Class and all class-wide types
+          that cover <T>.
 
 20.c
           Implicit array subtype conversion (sliding) is now performed
@@ -27143,7 +27231,7 @@ Examples of allocators:
                      _Inconsistencies With Ada 95_
 
 20.f/2
-          {AI95-00363-01AI95-00363-01} If the designated type has a
+          {<AI95-00363-01AI95-00363-01>} If the designated type has a
           constrained partial view, the allocated object can be
           unconstrained.  This might cause the object to take up a
           different amount of memory, and might cause the operations to
@@ -27157,7 +27245,7 @@ Examples of allocators:
                     _Incompatibilities With Ada 95_
 
 20.g/2
-          {AI95-00366-01AI95-00366-01} An allocator for an access type
+          {<AI95-00366-01AI95-00366-01>} An allocator for an access type
           that has Storage_Size specified to be zero is now illegal.
           Ada 95 allowed the allocator, but it had to raise
           Storage_Error if executed.  The primary impact of this change
@@ -27166,23 +27254,23 @@ Examples of allocators:
                         _Extensions to Ada 95_
 
 20.h/2
-          {8652/00108652/0010} {AI95-00127-01AI95-00127-01} Corrigendum:
-          An allocator can be a controlling parameter of a dispatching
-          call.  This was an oversight in Ada 95.
+          {<8652/00108652/0010>} {<AI95-00127-01AI95-00127-01>}
+          Corrigendum: An allocator can be a controlling parameter of a
+          dispatching call.  This was an oversight in Ada 95.
 
 20.i/2
-          {AI95-00287-01AI95-00287-01} Initialized allocators are
+          {<AI95-00287-01AI95-00287-01>} Initialized allocators are
           allowed when the designated type is limited.
 
                      _Wording Changes from Ada 95_
 
 20.j/2
-          {8652/00028652/0002} {AI95-00171-01AI95-00171-01} Corrigendum:
-          Clarified the elaboration of per-object constraints for an
-          uninitialized allocator.
+          {<8652/00028652/0002>} {<AI95-00171-01AI95-00171-01>}
+          Corrigendum: Clarified the elaboration of per-object
+          constraints for an uninitialized allocator.
 
 20.k/2
-          {AI95-00280-01AI95-00280-01} Program_Error is now raised if
+          {<AI95-00280-01AI95-00280-01>} Program_Error is now raised if
           the allocator occurs after the finalization of the collection
           or the waiting for tasks.  This is not listed as an
           incompatibility as the Ada 95 behavior was unspecified, and
@@ -27190,20 +27278,20 @@ Examples of allocators:
           this case.
 
 20.l/2
-          {AI95-00344-01AI95-00344-01} Added accessibility checks to
+          {<AI95-00344-01AI95-00344-01>} Added accessibility checks to
           class-wide allocators.  These checks could not fail in Ada 95
           (as all of the designated types had to be declared at the same
           level, so the access type would necessarily have been at the
           same level or more nested than the type of allocated object).
 
 20.m/2
-          {AI95-00373-01AI95-00373-01} Revised the description of
+          {<AI95-00373-01AI95-00373-01>} Revised the description of
           evaluation of uninitialized allocators to use "initialized by
           default" so that the ordering requirements are the same for
           all kinds of objects that are default-initialized.
 
 20.n/2
-          {AI95-00416-01AI95-00416-01} Added accessibility checks to
+          {<AI95-00416-01AI95-00416-01>} Added accessibility checks to
           access discriminants of allocators.  These checks could not
           fail in Ada 95 as the discriminants always have the
           accessibility of the object.
@@ -27211,7 +27299,7 @@ Examples of allocators:
                    _Incompatibilities With Ada 2005_
 
 20.o/3
-          {AI05-0052-1AI05-0052-1} Correction: Added a rule to prevent
+          {<AI05-0052-1AI05-0052-1>} Correction: Added a rule to prevent
           limited coextensions of nonlimited types.  Allowing this would
           have far-reaching implementation costs.  Because of those
           costs, it seems unlikely that any implementation ever
@@ -27219,7 +27307,7 @@ Examples of allocators:
           existing code depends on this capability.
 
 20.p/3
-          {AI05-0104-1AI05-0104-1} Correction: Added a rule to make
+          {<AI05-0104-1AI05-0104-1>} Correction: Added a rule to make
           null_exclusions illegal for uninitialized allocators, as such
           an allocator would always raise Constraint_Error.  Programs
           that depend on the unconditional raising of a predefined
@@ -27228,27 +27316,28 @@ Examples of allocators:
                        _Extensions to Ada 2005_
 
 20.q/3
-          {AI05-0111-3AI05-0111-3} Subpool handles (see *note 13.11.4::)
-          can be specified in an allocator.
+          {<AI05-0111-3AI05-0111-3>} Subpool handles (see *note
+          13.11.4::) can be specified in an allocator.
 
                     _Wording Changes from Ada 2005_
 
 20.r/3
-          {AI05-0024-1AI05-0024-1} Correction: Corrected the master
+          {<AI05-0024-1AI05-0024-1>} Correction: Corrected the master
           check for tags since the masters may be for different tasks
           and thus incomparable.
 
 20.s/3
-          {AI05-0041-1AI05-0041-1} Correction: Corrected the rules for
+          {<AI05-0041-1AI05-0041-1>} Correction: Corrected the rules for
           when a designated object is constrained by its initial value
           so that types derived from a partial view are handled
           properly.
 
 20.t/3
-          {AI05-0051-1AI05-0051-1} {AI05-0234-1AI05-0234-1} Correction:
-          Corrected the accessibility check for access discriminants so
-          that it does not depend on the designated type (which might
-          not have discriminants when the allocated type does).
+          {<AI05-0051-1AI05-0051-1>} {<AI05-0234-1AI05-0234-1>}
+          Correction: Corrected the accessibility check for access
+          discriminants so that it does not depend on the designated
+          type (which might not have discriminants when the allocated
+          type does).
 
 
 File: aarm2012.info,  Node: 4.9,  Prev: 4.8,  Up: 4
@@ -27259,9 +27348,9 @@ File: aarm2012.info,  Node: 4.9,  Prev: 4.8,  Up: 4
 1
 Certain expressions of a scalar or string type are defined to be static.
 Similarly, certain discrete ranges are defined to be static, and certain
-scalar and string subtypes are defined to be static subtypes.  [ Static
-means determinable at compile time, using the declared properties or
-values of the program entities.] 
+scalar and string subtypes are defined to be static subtypes.  [
+<Static> means determinable at compile time, using the declared
+properties or values of the program entities.]  
 
 1.a
           Discussion: As opposed to more elaborate data flow analysis,
@@ -27321,9 +27410,9 @@ the following:
           the function_call case.
 
 6
-   * a function_call whose function_name or function_prefix statically
-     denotes a static function, and whose actual parameters, if any
-     (whether given explicitly or by default), are all static
+   * a function_call whose <function_>name or <function_>prefix
+     statically denotes a static function, and whose actual parameters,
+     if any (whether given explicitly or by default), are all static
      expressions;
 
 6.a
@@ -27337,7 +27426,7 @@ the following:
 7.a
           Ramification: Note that this does not include the case of an
           attribute that is a function; a reference to such an attribute
-          is not even an expression.  See above for function calls.
+          is not even an expression.  See above for function <calls>.
 
 7.b
           An implementation may define the staticness and other
@@ -27365,11 +27454,11 @@ the following:
           it nonstatic, even for strings.
 
 11/4
-   * {AI05-0158-1AI05-0158-1} {AI05-0269-1AI05-0269-1}
-     {AI12-0039-1AI12-0039-1} a membership test whose
-     tested_simple_expression is a static expression, and whose
+   * {<AI05-0158-1AI05-0158-1>} {<AI05-0269-1AI05-0269-1>}
+     {<AI12-0039-1AI12-0039-1>} a membership test whose
+     <tested_>simple_expression is a static expression, and whose
      membership_choice_list consists only of membership_choices that are
-     either static choice_simple_expressions, static ranges, or
+     either static <choice_>simple_expressions, static ranges, or
      subtype_marks that denote a static [(scalar or string)] subtype;
 
 11.a
@@ -27381,17 +27470,17 @@ the following:
      expressions;
 
 12.1/3
-   * {AI05-0147-1AI05-0147-1} {AI05-0188-1AI05-0188-1} a
+   * {<AI05-0147-1AI05-0147-1>} {<AI05-0188-1AI05-0188-1>} a
      conditional_expression all of whose conditions,
-     selecting_expressions, and dependent_expressions are static
+     <selecting_>expressions, and <dependent_>expressions are static
      expressions;
 
 13
    * a static expression enclosed in parentheses.
 
 13.a
-          Discussion: Informally, we talk about a static value.  When we
-          do, we mean a value specified by a static expression.
+          Discussion: Informally, we talk about a <static value>.  When
+          we do, we mean a value specified by a static expression.
 
 13.b
           Ramification: The language requires a static expression in a
@@ -27402,7 +27491,7 @@ the following:
           extension_aggregate.
 
 14
-A name statically denotes an entity if it denotes the entity and:
+A name <statically denotes> an entity if it denotes the entity and:
 
 15
    * It is a direct_name, expanded name, or character_literal, and it
@@ -27421,7 +27510,7 @@ A name statically denotes an entity if it denotes the 
entity and:
           and indexed_components do not statically denote things.
 
 18
-A static function is one of the following:
+A <static function> is one of the following:
 
 18.a
           Ramification: These are the functions whose calls can be
@@ -27447,7 +27536,7 @@ A static function is one of the following:
 In any case, a generic formal subprogram is not a static function.
 
 24
-A static constant is a constant view declared by a full constant
+A <static constant> is a constant view declared by a full constant
 declaration or an object_renaming_declaration (*note 8.5.1: S0200.) with
 a static nominal subtype, having a value defined by a static scalar
 expression or by a static string expression whose value has a length not
@@ -27460,7 +27549,7 @@ the implementation.
           be static.
 
 24.b/3
-          Reason: {AI05-0229-1AI05-0229-1} The reason for restricting
+          Reason: {<AI05-0229-1AI05-0229-1>} The reason for restricting
           the length of static string constants is so that compilers
           don't have to store giant strings in their symbol tables.
           Since most string constants will be initialized from
@@ -27478,26 +27567,27 @@ the implementation.
           quotes don't count.
 
 25
-A static range is a range whose bounds are static expressions, [or a
+A <static range> is a range whose bounds are static expressions, [or a
 range_attribute_reference (*note 4.1.4: S0102.) that is equivalent to
-such a range.] A static discrete_range (*note 3.6.1: S0058.) is one that
-is a static range or is a subtype_indication (*note 3.2.2: S0027.) that
-defines a static scalar subtype.  The base range of a scalar type is a
-static range, unless the type is a descendant of a formal scalar type.
+such a range.]  A <static discrete_range (*note 3.6.1: S0058.)> is one
+that is a static range or is a subtype_indication (*note 3.2.2: S0027.)
+that defines a static scalar subtype.  The base range of a scalar type
+is a static range, unless the type is a descendant of a formal scalar
+type.
 
 26/3
-{AI95-00263-01AI95-00263-01} {AI05-0153-3AI05-0153-3} A static subtype
-is either a static scalar subtype or a static string subtype. A static
-scalar subtype is an unconstrained scalar subtype whose type is not a
-descendant of a formal type, or a constrained scalar subtype formed by
-imposing a compatible static constraint on a static scalar subtype. A
-static string subtype is an unconstrained string subtype whose index
-subtype and component subtype are static, or a constrained string
+{<AI95-00263-01AI95-00263-01>} {<AI05-0153-3AI05-0153-3>} A <static
+subtype> is either a <static scalar subtype> or a <static string
+subtype>.  A static scalar subtype is an unconstrained scalar subtype
+whose type is not a descendant of a formal type, or a constrained scalar
 subtype formed by imposing a compatible static constraint on a static
-string subtype.  In any case, the subtype of a generic formal object of
-mode in out, and the result subtype of a generic formal function, are
-not static.  Also, a subtype is not static if any Dynamic_Predicate
-specifications apply to it.
+scalar subtype.  A static string subtype is an unconstrained string
+subtype whose index subtype and component subtype are static, or a
+constrained string subtype formed by imposing a compatible static
+constraint on a static string subtype.  In any case, the subtype of a
+generic formal object of mode in out, and the result subtype of a
+generic formal function, are not static.  Also, a subtype is not static
+if any Dynamic_Predicate specifications apply to it.
 
 26.a
           Ramification: String subtypes are the only composite subtypes
@@ -27522,13 +27612,13 @@ specifications apply to it.
                begin
                    case F is
                        when 1..10 => null;
-                       -- Illegal!
+                       --< Illegal!>
                    end case;
                end G;
 
 26.f
                X : Integer range 1..20;
-               procedure I is new G(F => X); -- OK.
+               procedure I is new G(F => X); --< OK.>
 
 26.g
           The case_statement is illegal, because the subtype of F is not
@@ -27538,7 +27628,7 @@ specifications apply to it.
           names.
 
 27
-The different kinds of static constraint are defined as follows:
+The different kinds of <static constraint> are defined as follows:
 
 28
    * A null constraint is always static;
@@ -27557,42 +27647,42 @@ The different kinds of static constraint are defined 
as follows:
      static.
 
 31.1/2
-{AI95-00311-01AI95-00311-01} In any case, the constraint of the first
+{<AI95-00311-01AI95-00311-01>} In any case, the constraint of the first
 subtype of a scalar formal type is neither static nor null.
 
 32
-A subtype is statically constrained if it is constrained, and its
-constraint is static.  An object is statically constrained if its
+A subtype is <statically constrained> if it is constrained, and its
+constraint is static.  An object is <statically constrained> if its
 nominal subtype is statically constrained, or if it is a static string
 constant.
 
                            _Legality Rules_
 
 32.1/3
-{AI05-0147-1AI05-0147-1} An expression is statically unevaluated if it
-is part of:
+{<AI05-0147-1AI05-0147-1>} An expression is <statically unevaluated> if
+it is part of:
 
 32.2/3
-   * {AI05-0147-1AI05-0147-1} the right operand of a static
+   * {<AI05-0147-1AI05-0147-1>} the right operand of a static
      short-circuit control form whose value is determined by its left
      operand; or
 
 32.3/3
-   * {AI05-0147-1AI05-0147-1} {AI05-0188-1AI05-0188-1} a
-     dependent_expression of an if_expression whose associated condition
-     is static and equals False; or
+   * {<AI05-0147-1AI05-0147-1>} {<AI05-0188-1AI05-0188-1>} a
+     <dependent_>expression of an if_expression whose associated
+     condition is static and equals False; or
 
 32.4/3
-   * {AI05-0147-1AI05-0147-1} {AI05-0188-1AI05-0188-1} a condition or
-     dependent_expression of an if_expression where the condition
-     corresponding to at least one preceding dependent_expression of the
-     if_expression is static and equals True; or
+   * {<AI05-0147-1AI05-0147-1>} {<AI05-0188-1AI05-0188-1>} a condition
+     or <dependent_>expression of an if_expression where the condition
+     corresponding to at least one preceding <dependent_>expression of
+     the if_expression is static and equals True; or
 
 32.a/3
           Reason: We need this bullet so that only a single
-          dependent_expression is evaluated in a static if_expression if
-          there is more than one condition that evaluates to True.  The
-          part about conditions makes
+          <dependent_>expression is evaluated in a static if_expression
+          if there is more than one condition that evaluates to True.
+          The part about conditions makes
 
 32.b/3
                (if N = 0 then Min elsif 10_000/N > Min then 10_000/N else Min)
@@ -27601,77 +27691,78 @@ is part of:
           legal if N and Min are static and N = 0.
 
 32.d/3
-          Discussion: {AI05-0147-1AI05-0147-1} {AI05-0188-1AI05-0188-1}
-          We need the "of the if_expression" here so there is no
-          confusion for nested if_expressions; this rule only applies to
-          the conditions and dependent_expressions of a single
-          if_expression.  Similar reasoning applies to the "of a
-          case_expression" of the last bullet.
+          Discussion: {<AI05-0147-1AI05-0147-1>}
+          {<AI05-0188-1AI05-0188-1>} We need the "of the if_expression"
+          here so there is no confusion for nested if_expressions; this
+          rule only applies to the conditions and
+          <dependent_>expressions of a single if_expression.  Similar
+          reasoning applies to the "of a case_expression" of the last
+          bullet.
 
 32.5/3
-   * {AI05-0188-1AI05-0188-1} {AI05-0269-1AI05-0269-1} a
-     dependent_expression of a case_expression whose
-     selecting_expression is static and whose value is not covered by
+   * {<AI05-0188-1AI05-0188-1>} {<AI05-0269-1AI05-0269-1>} a
+     <dependent_>expression of a case_expression whose
+     <selecting_>expression is static and whose value is not covered by
      the corresponding discrete_choice_list; or
 
 32.6/4
-   * {AI05-0158-1AI05-0158-1} {AI12-0039-1AI12-0039-1} a
-     choice_simple_expression (or a simple_expression of a range that
+   * {<AI05-0158-1AI05-0158-1>} {<AI12-0039-1AI12-0039-1>} a
+     <choice_>simple_expression (or a simple_expression of a range that
      occurs as a membership_choice of a membership_choice_list) of a
      static membership test that is preceded in the enclosing
      membership_choice_list by another item whose individual membership
      test (see *note 4.5.2::) statically yields True.
 
 33/3
-{AI05-0147-1AI05-0147-1} A static expression is evaluated at compile
+{<AI05-0147-1AI05-0147-1>} A static expression is evaluated at compile
 time except when it is statically unevaluated.  The compile-time
 evaluation of a static expression is performed exactly, without
 performing Overflow_Checks.  For a static expression that is evaluated:
 
 34/3
-   * {AI05-0262-1AI05-0262-1} The expression is illegal if its
+   * {<AI05-0262-1AI05-0262-1>} The expression is illegal if its
      evaluation fails a language-defined check other than
      Overflow_Check.  For the purposes of this evaluation, the assertion
      policy is assumed to be Check.
 
 34.a/3
-          Reason: {AI05-0262-1AI05-0262-1} Assertion policies can
+          Reason: {<AI05-0262-1AI05-0262-1>} Assertion policies can
           control whether checks are made, but we don't want assertion
           policies to affect legality.  For Ada 2012, subtype predicates
           are the only checks controlled by the assertion policy that
           can appear in static expressions.
 
 35/2
-   * {AI95-00269-01AI95-00269-01} If the expression is not part of a
+   * {<AI95-00269-01AI95-00269-01>} If the expression is not part of a
      larger static expression and the expression is expected to be of a
      single specific type, then its value shall be within the base range
      of its expected type.  Otherwise, the value may be arbitrarily
      large or small.
 
 35.a/2
-          Ramification: {AI95-00269-01AI95-00269-01} If the expression
+          Ramification: {<AI95-00269-01AI95-00269-01>} If the expression
           is expected to be of a universal type, or of "any integer
           type", there are no limits on the value of the expression.
 
 36/2
-   * {AI95-00269-01AI95-00269-01} If the expression is of type
-     universal_real and its expected type is a decimal fixed point type,
-     then its value shall be a multiple of the small of the decimal
-     type.  This restriction does not apply if the expected type is a
-     descendant of a formal scalar type (or a corresponding actual type
-     in an instance).
+   * {<AI95-00269-01AI95-00269-01>} If the expression is of type
+     <universal_real> and its expected type is a decimal fixed point
+     type, then its value shall be a multiple of the <small> of the
+     decimal type.  This restriction does not apply if the expected type
+     is a descendant of a formal scalar type (or a corresponding actual
+     type in an instance).
 
 36.a
           Ramification: This means that a numeric_literal for a decimal
           type cannot have "extra" significant digits.
 
 36.b/2
-          Reason: {AI95-00269-01AI95-00269-01} The small is not known
+          Reason: {<AI95-00269-01AI95-00269-01>} The small is not known
           for a generic formal type, so we have to exclude formal types
           from this check.
 
 37/2
-{AI95-00269-01AI95-00269-01} In addition to the places where Legality
+{<AI95-00269-01AI95-00269-01>} In addition to the places where Legality
 Rules normally apply (see *note 12.3::), the above restrictions also
 apply in the private part of an instance of a generic unit.
 
@@ -27689,7 +27780,7 @@ apply in the private part of an instance of a generic 
unit.
 
 37.c
                N: constant := 0.0;
-               X: constant Boolean := (N = 0.0) or else (1.0/N > 0.5); -- 
Static.
+               X: constant Boolean := (N = 0.0) or else (1.0/N > 0.5); --< 
Static.>
 
 37.d
           The declaration of X is legal, since the divide-by-zero part
@@ -27699,7 +27790,7 @@ apply in the private part of an instance of a generic 
unit.
                      _Implementation Requirements_
 
 38/2
-{AI95-00268-01AI95-00268-01} {AI95-00269-01AI95-00269-01} For a real
+{<AI95-00268-01AI95-00268-01>} {<AI95-00269-01AI95-00269-01>} For a real
 static expression that is not part of a larger static expression, and
 whose expected type is not a descendant of a formal type, the
 implementation shall round or truncate the value (according to the
@@ -27717,7 +27808,7 @@ rules apply (see *note Annex G::).
           which are exactly half-way between two machine numbers.
 
 38.a/2
-          Reason: {AI95-00268-01AI95-00268-01} Discarding extended
+          Reason: {<AI95-00268-01AI95-00268-01>} Discarding extended
           precision enhances portability by ensuring that the value of a
           static constant of a real type is always a machine number of
           the type.
@@ -27731,12 +27822,12 @@ rules apply (see *note Annex G::).
           rules apply for descendants of a formal fixed point type.
 
 38.b.1/2
-          {AI95-00269-01AI95-00269-01} There is no requirement for exact
-          evaluation or special rounding in an instance body (unless the
-          expression is static in the generic body).  This eliminates a
-          potential contract issue where the exact value of a static
-          expression depends on the actual parameters (which could then
-          affect the legality of other code).
+          {<AI95-00269-01AI95-00269-01>} There is no requirement for
+          exact evaluation or special rounding in an instance body
+          (unless the expression is static in the generic body).  This
+          eliminates a potential contract issue where the exact value of
+          a static expression depends on the actual parameters (which
+          could then affect the legality of other code).
 
 38.c
           Implementation Note: Note that the implementation of static
@@ -27744,7 +27835,7 @@ rules apply (see *note Annex G::).
           type whose Signed_Zeros attribute is True.
 
 38.d/2
-          {AI95-00100-01AI95-00100-01} Note that the only machine
+          {<AI95-00100-01AI95-00100-01>} Note that the only machine
           numbers of a fixed point type are the multiples of the small,
           so a static conversion to a fixed-point type, or division by
           an integer, must do truncation to a multiple of small.  It is
@@ -27754,7 +27845,7 @@ rules apply (see *note Annex G::).
                         _Implementation Advice_
 
 38.1/2
-{AI95-00268-01AI95-00268-01} For a real static expression that is not
+{<AI95-00268-01AI95-00268-01>} For a real static expression that is not
 part of a larger static expression, and whose expected type is not a
 descendant of a formal type, the rounding should be the same as the
 default rounding for the target system.
@@ -27811,21 +27902,21 @@ default rounding for the target system.
                               _Examples_
 
 41
-Examples of static expressions:
+<Examples of static expressions:>
 
 42
-     1 + 1       -- 2
-     abs(-10)*3  -- 30
+     1 + 1       <-- 2>
+     abs(-10)*3  <-- 30>
 
 43
      Kilo : constant := 1000;
-     Mega : constant := Kilo*Kilo;   -- 1_000_000
+     Mega : constant := Kilo*Kilo;   <-- 1_000_000>
      Long : constant := Float'Digits*2;
 
 44
-     Half_Pi    : constant := Pi/2;           -- see *note 3.3.2::
+     Half_Pi    : constant := Pi/2;           <-- see *note 3.3.2::>
      Deg_To_Rad : constant := Half_Pi/90;
-     Rad_To_Deg : constant := 1.0/Deg_To_Rad; -- equivalent to 
1.0/((3.14159_26536/2)/90)
+     Rad_To_Deg : constant := 1.0/Deg_To_Rad; <-- equivalent to 
1.0/((3.14159_26536/2)/90)>
 
                         _Extensions to Ada 83_
 
@@ -27908,7 +27999,7 @@ Examples of static expressions:
                      _Wording Changes from Ada 83_
 
 44.n/3
-          {AI05-0299-1AI05-0299-1} This subclause (and *note 4.5.5::,
+          {<AI05-0299-1AI05-0299-1>} This subclause (and *note 4.5.5::,
           "*note 4.5.5:: Multiplying Operators") subsumes the RM83
           section on Universal Expressions.
 
@@ -27930,7 +28021,7 @@ Examples of static expressions:
           an exception.  Thus, for example:
 
 44.q
-               Bad: constant := 1/0; -- Illegal!
+               Bad: constant := 1/0; --< Illegal!>
 
 44.r
           was illegal because 1/0 was not static.  In Ada 95, the above
@@ -27941,55 +28032,57 @@ Examples of static expressions:
                      _Inconsistencies With Ada 95_
 
 44.s/2
-          {AI95-00268-01AI95-00268-01} Amendment Correction: Rounding of
-          static real expressions is implementation-defined in Ada 2005,
-          while it was specified as away from zero in (original) Ada 95.
-          This could make subtle differences in programs.  However, the
-          original Ada 95 rule required rounding that (probably)
-          differed from the target processor, thus creating anomalies
-          where the value of a static expression was required to be
-          different than the same expression evaluated at run-time.
+          {<AI95-00268-01AI95-00268-01>} Amendment Correction: Rounding
+          of static real expressions is implementation-defined in Ada
+          2005, while it was specified as away from zero in (original)
+          Ada 95.  This could make subtle differences in programs.
+          However, the original Ada 95 rule required rounding that
+          (probably) differed from the target processor, thus creating
+          anomalies where the value of a static expression was required
+          to be different than the same expression evaluated at
+          run-time.
 
                      _Wording Changes from Ada 95_
 
 44.t/2
-          {AI95-00263-01AI95-00263-01} {AI95-00268-01AI95-00268-01} The
-          Ada 95 wording that defined static subtypes unintentionally
-          failed to exclude formal derived types that happen to be
-          scalar (these aren't formal scalar types); and had a
-          parenthetical remark excluding formal string types - but that
-          was neither necessary nor parenthetical (it didn't follow from
-          other wording).  This issue also applies to the rounding rules
-          for real static expressions.
+          {<AI95-00263-01AI95-00263-01>} {<AI95-00268-01AI95-00268-01>}
+          The Ada 95 wording that defined static subtypes
+          unintentionally failed to exclude formal derived types that
+          happen to be scalar (these aren't formal scalar types); and
+          had a parenthetical remark excluding formal string types - but
+          that was neither necessary nor parenthetical (it didn't follow
+          from other wording).  This issue also applies to the rounding
+          rules for real static expressions.
 
 44.u/2
-          {AI95-00269-01AI95-00269-01} Ada 95 didn't clearly define the
-          bounds of a value of a static expression for universal types
-          and for "any integer/float/fixed type".  We also make it clear
-          that we do not intend exact evaluation of static expressions
-          in an instance body if the expressions aren't static in the
-          generic body.
+          {<AI95-00269-01AI95-00269-01>} Ada 95 didn't clearly define
+          the bounds of a value of a static expression for universal
+          types and for "any integer/float/fixed type".  We also make it
+          clear that we do not intend exact evaluation of static
+          expressions in an instance body if the expressions aren't
+          static in the generic body.
 
 44.v/2
-          {AI95-00311-01AI95-00311-01} We clarify that the first subtype
-          of a scalar formal type has a nonstatic, nonnull constraint.
+          {<AI95-00311-01AI95-00311-01>} We clarify that the first
+          subtype of a scalar formal type has a nonstatic, nonnull
+          constraint.
 
                     _Wording Changes from Ada 2005_
 
 44.w/3
-          {AI05-0147-1AI05-0147-1} {AI05-0188-1AI05-0188-1} Added
+          {<AI05-0147-1AI05-0147-1>} {<AI05-0188-1AI05-0188-1>} Added
           wording to define staticness and the lack of evaluation for
           if_expressions and case_expressions.  These are new and
           defined elsewhere.
 
 44.x/3
-          {AI05-0153-3AI05-0153-3} Added wording to prevent subtypes
+          {<AI05-0153-3AI05-0153-3>} Added wording to prevent subtypes
           that have dynamic predicates (see *note 3.2.4::) from being
           static.
 
 44.y/3
-          {AI05-0158-1AI05-0158-1} Revised wording for membership tests
-          to allow for the new possibilities allowed by the
+          {<AI05-0158-1AI05-0158-1>} Revised wording for membership
+          tests to allow for the new possibilities allowed by the
           membership_choice_list.
 
 * Menu:
@@ -28005,7 +28098,7 @@ File: aarm2012.info,  Node: 4.9.1,  Up: 4.9
                           _Static Semantics_
 
 1/2
-{AI95-00311-01AI95-00311-01} A constraint statically matches another
+{<AI95-00311-01AI95-00311-01>} A constraint <statically matches> another
 constraint if:
 
 1.1/2
@@ -28022,14 +28115,14 @@ constraint if:
      3.6: S0055.); or
 
 1.4/2
-   * {AI95-00311-01AI95-00311-01} both are nonstatic and come from the
+   * {<AI95-00311-01AI95-00311-01>} both are nonstatic and come from the
      same formal_type_declaration.
 
 2/3
-{AI95-00231-01AI95-00231-01} {AI95-00254-01AI95-00254-01}
-{AI05-0153-3AI05-0153-3} A subtype statically matches another subtype of
-the same type if they have statically matching constraints, all
-predicate specifications that apply to them come from the same
+{<AI95-00231-01AI95-00231-01>} {<AI95-00254-01AI95-00254-01>}
+{<AI05-0153-3AI05-0153-3>} A subtype <statically matches> another
+subtype of the same type if they have statically matching constraints,
+all predicate specifications that apply to them come from the same
 declarations, and, for access subtypes, either both or neither exclude
 null.  Two anonymous access-to-object subtypes statically match if their
 designated subtypes statically match, and either both or neither exclude
@@ -28051,7 +28144,7 @@ null.
           conform, so they couldn't be used in separate specifications.
 
 3
-Two ranges of the same type statically match if both result from the
+Two ranges of the same type <statically match> if both result from the
 same evaluation of a range, or if both are static and have equal
 corresponding bounds.
 
@@ -28062,12 +28155,12 @@ corresponding bounds.
           have to statically match.
 
 4/3
-{AI05-0086-1AI05-0086-1} {AI05-0153-3AI05-0153-3} A constraint is
-statically compatible with a scalar subtype if it statically matches the
-constraint of the subtype, or if both are static and the constraint is
-compatible with the subtype. A constraint is statically compatible with
-an access or composite subtype if it statically matches the constraint
-of the subtype, or if the subtype is unconstrained.
+{<AI05-0086-1AI05-0086-1>} {<AI05-0153-3AI05-0153-3>} A constraint is
+<statically compatible> with a scalar subtype if it statically matches
+the constraint of the subtype, or if both are static and the constraint
+is compatible with the subtype.  A constraint is <statically compatible>
+with an access or composite subtype if it statically matches the
+constraint of the subtype, or if the subtype is unconstrained.
 
 4.a
           Discussion: Static compatibility is required when constraining
@@ -28081,31 +28174,31 @@ of the subtype, or if the subtype is unconstrained.
           different contexts.
 
 5/3
-{AI05-0153-3AI05-0153-3} Two statically matching subtypes are statically
-compatible with each other.  In addition, a subtype S1 is statically
-compatible with a subtype S2 if:
+{<AI05-0153-3AI05-0153-3>} Two statically matching subtypes are
+statically compatible with each other.  In addition, a subtype <S1> is
+statically compatible with a subtype <S2> if:
 
 6/3
-   * the constraint of S1 is statically compatible with S2, and
+   * the constraint of <S1> is statically compatible with <S2>, and
 
 7/3
-   * {AI05-0086-1AI05-0086-1} if S2 excludes null, so does S1, and
+   * {<AI05-0086-1AI05-0086-1>} if <S2> excludes null, so does <S1>, and
 
 8/3
    * either:
 
 9/3
-             * all predicate specifications that apply to S2 apply also
-               to S1, or
+             * all predicate specifications that apply to <S2> apply
+               also to <S1>, or
 
 10/4
-             * {AI05-0290-1AI05-0290-1} {AI12-0071-1AI12-0071-1} both
-               subtypes are static, every value that satisfies the
-               predicates of S1 also satisfies the predicates of S2, and
-               it is not the case that both types each have at least one
-               applicable predicate specification, predicate checks are
-               enabled (see *note 11.4.2::) for S2, and predicate checks
-               are not enabled for S1.
+             * {<AI05-0290-1AI05-0290-1>} {<AI12-0071-1AI12-0071-1>}
+               both subtypes are static, every value that satisfies the
+               predicates of <S1> also satisfies the predicates of <S2>,
+               and it is not the case that both types each have at least
+               one applicable predicate specification, predicate checks
+               are enabled (see *note 11.4.2::) for <S2>, and predicate
+               checks are not enabled for <S1>.
 
                      _Wording Changes from Ada 83_
 
@@ -28115,19 +28208,19 @@ compatible with a subtype S2 if:
                      _Wording Changes from Ada 95_
 
 10.b/2
-          {AI95-00231-01AI95-00231-01} {AI95-00254-01AI95-00254-01}
+          {<AI95-00231-01AI95-00231-01>} {<AI95-00254-01AI95-00254-01>}
           Added static matching rules for null exclusions and anonymous
           access-to-subprogram types; both of these are new.
 
 10.c/2
-          {AI95-00311-01AI95-00311-01} We clarify that the constraint of
-          the first subtype of a scalar formal type statically matches
-          itself.
+          {<AI95-00311-01AI95-00311-01>} We clarify that the constraint
+          of the first subtype of a scalar formal type statically
+          matches itself.
 
                    _Incompatib