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

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

[elpa] externals/ada-ref-man 539f2fe 07/18: Add ada-ref-man document and


From: Stefan Monnier
Subject: [elpa] externals/ada-ref-man 539f2fe 07/18: Add ada-ref-man document and program sources
Date: Sun, 29 Nov 2020 19:04:43 -0500 (EST)

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

    Add ada-ref-man document and program sources
    
    * packages/ada-ref-man/README: Describe upstream sources, local copies.
    
    * packages/ada-ref-man/.elpaignore: New file.
    
    * packages/ada-ref-man/progs/: New directory; Ada files to process ARM
    sources into info and other formats.
    
    * packages/ada-ref-man/source_2012/: New directory; ARM sources.
---
 .elpaignore                    |     2 +
 README                         |     8 +
 progs/alkc.bat                 |     7 +
 progs/arm_cont.adb             |   669 +++
 progs/arm_cont.ads             |   187 +
 progs/arm_corr.adb             |  1719 ++++++
 progs/arm_corr.ads             |   432 ++
 progs/arm_db.adb               |   327 ++
 progs/arm_db.ads               |   118 +
 progs/arm_file.adb             |   186 +
 progs/arm_file.ads             |   100 +
 progs/arm_form.ada             |   329 ++
 progs/arm_frm.adb              | 11211 +++++++++++++++++++++++++++++++++++++++
 progs/arm_frm.ads              |   476 ++
 progs/arm_frmd.adb             |   552 ++
 progs/arm_frmd.ads             |   319 ++
 progs/arm_frms.adb             |  1016 ++++
 progs/arm_html.adb             |  5755 ++++++++++++++++++++
 progs/arm_html.ads             |   617 +++
 progs/arm_indx.adb             |  1050 ++++
 progs/arm_indx.ads             |   110 +
 progs/arm_inp.adb              |   444 ++
 progs/arm_inp.ads              |   170 +
 progs/arm_mast.adb             |  1456 +++++
 progs/arm_mast.ads             |    58 +
 progs/arm_out.ads              |   633 +++
 progs/arm_rtf.adb              |  6242 ++++++++++++++++++++++
 progs/arm_rtf.ads              |   524 ++
 progs/arm_str.adb              |   172 +
 progs/arm_str.ads              |    98 +
 progs/arm_sub.adb              |   773 +++
 progs/arm_sub.ads              |    91 +
 progs/arm_syn.adb              |   452 ++
 progs/arm_syn.ads              |   109 +
 progs/arm_texi.adb             |  1832 +++++++
 progs/arm_texi.ads             |   304 ++
 progs/arm_text.adb             |  1547 ++++++
 progs/arm_text.ads             |   453 ++
 progs/command.txt              |  1360 +++++
 progs/gpl-3-0.txt              |   674 +++
 progs/makeana.bat              |     1 +
 progs/makearm.bat              |     1 +
 progs/mklnk.bat                |     3 +
 progs/rtf2form.ada             |   686 +++
 source_2012/01.mss             |  2387 +++++++++
 source_2012/02.mss             |  2186 ++++++++
 source_2012/03a.mss            |  7529 ++++++++++++++++++++++++++
 source_2012/03b.mss            |  2745 ++++++++++
 source_2012/03c.mss            |  6595 +++++++++++++++++++++++
 source_2012/04a.mss            |  5748 ++++++++++++++++++++
 source_2012/04b.mss            |  3082 +++++++++++
 source_2012/05.mss             |  1942 +++++++
 source_2012/06.mss             |  5368 +++++++++++++++++++
 source_2012/07.mss             |  4924 +++++++++++++++++
 source_2012/08.mss             |  3841 ++++++++++++++
 source_2012/09.mss             |  5936 +++++++++++++++++++++
 source_2012/10.mss             |  4083 ++++++++++++++
 source_2012/11.mss             |  2650 +++++++++
 source_2012/12.mss             |  3897 ++++++++++++++
 source_2012/13a.mss            |  5165 ++++++++++++++++++
 source_2012/13b.mss            |  7071 ++++++++++++++++++++++++
 source_2012/aa-aarm.msm        |   110 +
 source_2012/aa-rm.msm          |   111 +
 source_2012/aarm.msm           |   106 +
 source_2012/attribs.mss        |    41 +
 source_2012/ds.mss             |  2441 +++++++++
 source_2012/front_matter.mss   |  1576 ++++++
 source_2012/glossary.mss       |    19 +
 source_2012/impldef.mss        |    83 +
 source_2012/index.mss          |    29 +
 source_2012/infosys.mss        |  1349 +++++
 source_2012/interface.mss      |  3669 +++++++++++++
 source_2012/iso-rm.msm         |   107 +
 source_2012/langdef.mss        |    81 +
 source_2012/library.mss        |     9 +
 source_2012/numerics.mss       |  4383 +++++++++++++++
 source_2012/obsolescent.mss    |  1873 +++++++
 source_2012/pragmas.mss        |    20 +
 source_2012/pre.mss            |   426 ++
 source_2012/pre_ada.mss        |    53 +
 source_2012/pre_chars.mss      |  1346 +++++
 source_2012/pre_cmdln.mss      |   128 +
 source_2012/pre_con2.mss       |  5147 ++++++++++++++++++
 source_2012/pre_containers.mss |  9389 ++++++++++++++++++++++++++++++++
 source_2012/pre_dirs.mss       |  1561 ++++++
 source_2012/pre_environ.mss    |   259 +
 source_2012/pre_io.mss         |  4096 ++++++++++++++
 source_2012/pre_locales.mss    |   132 +
 source_2012/pre_math.mss       |   927 ++++
 source_2012/pre_standard.mss   |   497 ++
 source_2012/pre_strings.mss    |  4052 ++++++++++++++
 source_2012/real_attribs.mss   |   732 +++
 source_2012/rm.msm             |   107 +
 source_2012/rt.mss             |  6683 +++++++++++++++++++++++
 source_2012/safety.mss         |  1373 +++++
 source_2012/sp.mss             |  2670 ++++++++++
 source_2012/syntax.mss         |    40 +
 source_2012/title.mss          |   289 +
 98 files changed, 174336 insertions(+)

diff --git a/.elpaignore b/.elpaignore
new file mode 100755
index 0000000..4c65740
--- /dev/null
+++ b/.elpaignore
@@ -0,0 +1,2 @@
+source_2012
+progs
diff --git a/README b/README
index 536b7b1..f33558c 100644
--- a/README
+++ b/README
@@ -1,3 +1,11 @@
 Emacs info version of Ada Reference Manual 2012 TC1
 
+The upstream source for the ARM is http://www.ada-auth.org/arm-files/;
+ELPA git copy in packages/ada-ref-man/source_2012.
+
+The upstream source for the Ada code that processes the ARM source is
+in the ada-france monotone repository; access information is given at
+http://stephe-leake.org/ada/arm.html. ELPA git copy in
+packages/ada-ref-man/progs.
+
 
diff --git a/progs/alkc.bat b/progs/alkc.bat
new file mode 100755
index 0000000..f2b8b64
--- /dev/null
+++ b/progs/alkc.bat
@@ -0,0 +1,7 @@
+Move .\Object\%1.Obj .
+link  -subsystem:console -entry:mainCRTStartup -out:%1.exe %1.obj libc.lib 
kernel32.lib -map:%1.map
+Del %1.Obj
+Rem Del %1.Map
+Copy %1.Exe \RRS\Docs
+Move %1.Exe ..\Source
+Move .\Object\%1.Dbg ..\Source
diff --git a/progs/arm_cont.adb b/progs/arm_cont.adb
new file mode 100755
index 0000000..624111a
--- /dev/null
+++ b/progs/arm_cont.adb
@@ -0,0 +1,669 @@
+with Ada.Characters.Handling;
+--with Ada.Text_IO; -- Debug.
+--with Ada.Exceptions;
+package body ARM_Contents is
+
+    --
+    -- Ada reference manual formatter (ARM_Form).
+    --
+    -- This package contains the routines to manage section/clause/subclause
+    -- references.
+    --
+    -- ---------------------------------------
+    -- Copyright 2000, 2004, 2005, 2006, 2007, 2008, 2009, 2011, 2012
+    --   AXE Consultants. All rights reserved.
+    -- P.O. Box 1512, Madison WI  53701
+    -- E-Mail: randy@rrsoftware.com
+    --
+    -- ARM_Form is free software: you can redistribute it and/or modify
+    -- it under the terms of the GNU General Public License version 3
+    -- as published by the Free Software Foundation.
+    --
+    -- AXE CONSULTANTS MAKES THIS TOOL AND SOURCE CODE AVAILABLE ON AN "AS IS"
+    -- BASIS AND MAKES NO WARRANTY, EXPRESS OR IMPLIED, AS TO THE ACCURACY,
+    -- CAPABILITY, EFFICIENCY, MERCHANTABILITY, OR FUNCTIONING OF THIS TOOL.
+    -- IN NO EVENT WILL AXE CONSULTANTS BE LIABLE FOR ANY GENERAL,
+    -- CONSEQUENTIAL, INDIRECT, INCIDENTAL, EXEMPLARY, OR SPECIAL DAMAGES,
+    -- EVEN IF AXE CONSULTANTS HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
+    -- DAMAGES.
+    --
+    -- A copy of the GNU General Public License is available in the file
+    -- gpl-3-0.txt in the standard distribution of the ARM_Form tool.
+    -- Otherwise, see <http://www.gnu.org/licenses/>.
+    --
+    -- If the GPLv3 license is not satisfactory for your needs, a commercial
+    -- use license is available for this tool. Contact Randy at AXE Consultants
+    -- for more information.
+    --
+    -- ---------------------------------------
+    --
+    -- Edit History:
+    --
+    --  4/19/00 - RLB - Created base package.
+    --  4/26/00 - RLB - Added Previous_Clause and Next_Clause.
+    --  5/15/00 - RLB - Added rules about unnumbered sections.
+    --  5/22/00 - RLB - Added Unnumbered_Section level.
+    --  8/22/00 - RLB - Added Old_Title handling.
+    --  9/ 9/04 - RLB - Removed unused with.
+    --  2/ 2/05 - RLB - Allowed more old titles.
+    --  1/16/06 - RLB - Added debugging.
+    --  9/22/06 - RLB - Created type Clause_Number_Type and added SubSubClause.
+    -- 10/12/07 - RLB - Extended the range of properly formatted clause 
numbers.
+    -- 12/18/07 - RLB - Added Plain_Annex.
+    -- 10/24/08 - RLB - More old titles.
+    --  5/07/09 - RLB - Added Dead_Clause.
+    -- 10/18/11 - RLB - Changed to GPLv3 license.
+    -- 10/19/11 - RLB - Added Parent_Clause from Stephen Leake's version.
+    -- 10/25/11 - RLB - Added version to Old name strings.
+    --  8/30/12 - RLB - Added traps if we're reading Section = UNKNOWN.
+
+    function "<" (Left, Right : Clause_Number_Type) return Boolean is
+       -- True if Left comes before Right in the collating order.
+    begin
+       if Left.Section = UNKNOWN then
+           raise Bad_Clause_Error with "Left has Unknown section";
+       elsif Right.Section = UNKNOWN then
+           raise Bad_Clause_Error with "Right has Unknown section";
+       elsif Left.Section < Right.Section then
+           return True;
+       elsif Left.Section > Right.Section then
+           return False;
+       elsif Left.Clause < Right.Clause then
+           return True;
+       elsif Left.Clause > Right.Clause then
+           return False;
+       elsif Left.Subclause < Right.Subclause then
+           return True;
+       elsif Left.Subclause > Right.Subclause then
+           return False;
+       elsif Left.Subsubclause < Right.Subsubclause then
+           return True;
+       else
+           return False;
+       end if;
+    end "<";
+
+    function ">" (Left, Right : Clause_Number_Type) return Boolean is
+       -- True if Left comes after Right in the collating order.
+    begin
+       return Right < Left;
+    end ">";
+
+    function "<=" (Left, Right : Clause_Number_Type) return Boolean is
+       -- True if Left comes before or is the same as Right in the
+       -- collating order.
+    begin
+       return not (Right < Left);
+    end "<=";
+
+    function ">=" (Left, Right : Clause_Number_Type) return Boolean is
+       -- True if Left comes after or is the same as Right in the
+       -- collating order.
+    begin
+       return not (Left < Right);
+    end ">=";
+
+
+    type Title_Record is record
+       Title : Title_Type; -- Title in original format.
+       Search_Title : Title_Type; -- Title in all lower case.
+       Level : Level_Type;
+       Clause_Number : Clause_Number_Type;
+        Version : ARM_Contents.Change_Version_Type := '0';
+    end record;
+
+    Title_List : array (1 .. 900) of Title_Record;
+    Last_Title : Natural;
+
+    Old_Title_List : array (1 .. 300) of Title_Record;
+    Last_Old_Title : Natural;
+
+    procedure Initialize is
+       -- Initialize this package; make sure the contents are empty.
+    begin
+       Last_Title := 0;
+    end Initialize;
+
+
+    procedure Add (Title : in Title_Type;
+                  Level : in Level_Type;
+                  Clause_Number : in Clause_Number_Type;
+                   Version : in ARM_Contents.Change_Version_Type := '0') is
+       -- Add a section or clause to the contents. It has the specified
+       -- characteristics.
+    begin
+       if Level /= Subsubclause and then Clause_Number.Subsubclause /= 0 then
+           raise Bad_Clause_Error with "not a subsubclause but non-zero 
subsubclause number";
+       end if;
+       if Level /= Subsubclause and then
+          Level /= Subclause and then Clause_Number.Subclause /= 0 then
+           raise Bad_Clause_Error with "not a subclause but non-zero subclause 
number";
+       end if;
+       if (Level /= Subsubclause and then Level /= Subclause and then
+           Level /= Clause and then Level /= Unnumbered_Section and then
+           Level /= Dead_Clause) and then
+          Clause_Number.Clause /= 0 then
+           raise Bad_Clause_Error with "not a clause but non-zero clause 
number";
+       end if;
+       Last_Title := Last_Title + 1;
+       Title_List (Last_Title) :=
+           (Title => Title,
+            Search_Title => Ada.Characters.Handling.To_Lower (Title),
+            Level => Level,
+            Clause_Number => Clause_Number,
+             Version => Version);
+--Ada.Text_IO.Put_Line ("  Add " & Title &
+-- " Index=" & Natural'Image(Last_Title) & " Level=" & 
Level_Type'Image(Level));
+--Ada.Text_IO.Put_Line ("    Section" & 
Section_Number_Type'Image(Clause_Number.Section) &
+-- " Clause" & Natural'Image(Clause_Number.Clause) & " Subclause" & 
Natural'Image(Clause_Number.Subclause) &
+-- " Subsubclause" & Natural'Image(Clause_Number.Subsubclause));
+    end Add;
+
+
+    procedure Add_Old (Old_Title : in Title_Type;
+                      Level : in Level_Type;
+                      Clause_Number : in Clause_Number_Type;
+                       Version : in ARM_Contents.Change_Version_Type := '0') is
+       -- Add an old title for a section or clause to the contents. It has
+       -- the specified characteristics; the version is the version for which
+       -- it first was present in the document.
+    begin
+       if Level /= Subsubclause and then Clause_Number.Subsubclause /= 0 then
+           raise Bad_Clause_Error with "not a subsubclause but non-zero 
subsubclause number";
+       end if;
+       if Level /= Subsubclause and then
+          Level /= Subclause and then Clause_Number.Subclause /= 0 then
+           raise Bad_Clause_Error with "not a subclause but non-zero subclause 
number";
+       end if;
+       if (Level /= Subsubclause and then Level /= Subclause and then
+           Level /= Clause and then Level /= Unnumbered_Section and then
+           Level /= Dead_Clause) and then
+          Clause_Number.Clause /= 0 then
+           raise Bad_Clause_Error with "not a clause but non-zero clause 
number";
+       end if;
+       Last_Old_Title := Last_Old_Title + 1;
+       Old_Title_List (Last_Old_Title) :=
+           (Title => Old_Title,
+            Search_Title => Ada.Characters.Handling.To_Lower (Old_Title),
+            Level => Level,
+            Clause_Number => Clause_Number,
+             Version => Version);
+--Ada.Text_IO.Put_Line ("  Add_Old " & Old_Title &
+-- " Index=" & Natural'Image(Last_Old_Title) & " Level=" & 
Level_Type'Image(Level));
+--Ada.Text_IO.Put_Line ("    Section" & 
Section_Number_Type'Image(Section_Number) &
+-- " Clause" & Natural'Image(Clause_Number.Clause) & " Subclause" & 
Natural'Image(Clause_Number.Subclause) &
+-- " Subsubclause" & Natural'Image(Clause_Number.Subsubclause));
+    end Add_Old;
+
+
+    function Make_Clause_Number (Level : in Level_Type;
+                  Clause_Number : in Clause_Number_Type) return String is
+       -- Returns a properly formatted Section or clause number reference.
+    begin
+       if Clause_Number.Section = UNKNOWN then
+           raise Bad_Clause_Error with "unknown section number";
+       -- else not unknown
+       end if;
+       case Level is
+           when Plain_Annex | Normative_Annex | Informative_Annex =>
+               if Clause_Number.Clause /= 0 or else Clause_Number.Subclause /= 
0 or else
+                  Clause_Number.Subsubclause /= 0 or else 
Clause_Number.Section <= 30 then
+                   raise Bad_Clause_Error; -- Illegal numbers.
+               end if;
+               return "Annex " & Character'Val (Character'Pos('A') + 
(Clause_Number.Section - ANNEX_START));
+           when Section =>
+               if Clause_Number.Clause /= 0 or else Clause_Number.Subclause /= 
0 or else
+                  Clause_Number.Section >= ANNEX_START then
+                   raise Bad_Clause_Error; -- Illegal numbers.
+               end if;
+               if Clause_Number.Section < 10 then
+                   return Character'Val (Character'Pos('0') + 
Clause_Number.Section) & "";
+               elsif Clause_Number.Section < 20 then
+                   return "1" & Character'Val (Character'Pos('0') + 
Clause_Number.Section - 10);
+               elsif Clause_Number.Section < 30 then
+                   return "2" & Character'Val (Character'Pos('0') + 
Clause_Number.Section - 20);
+               else
+                   return "3" & Character'Val (Character'Pos('0') + 
Clause_Number.Section - 30);
+               end if;
+           when Unnumbered_Section =>
+               if Clause_Number.Clause = 0 or else Clause_Number.Subclause /= 
0 or else
+                  Clause_Number.Section /= 0 then
+                   raise Bad_Clause_Error; -- Illegal numbers.
+               end if;
+               if Clause_Number.Clause < 10 then
+                   return "0." & Character'Val (Character'Pos('0') + 
Clause_Number.Clause);
+               elsif Clause_Number.Clause < 20 then
+                   return "0.1" & Character'Val (Character'Pos('0') + 
Clause_Number.Clause - 10);
+               elsif Clause_Number.Clause < 30 then
+                   return "0.2" & Character'Val (Character'Pos('0') + 
Clause_Number.Clause - 20);
+               else
+                   return "0.3" & Character'Val (Character'Pos('0') + 
Clause_Number.Clause - 30);
+               end if;
+           when Clause =>
+               if Clause_Number.Subclause /= 0 then
+                   raise Bad_Clause_Error; -- Illegal number.
+               end if;
+               if Clause_Number.Section < 10 then
+                   if Clause_Number.Clause < 10 then
+                       return Character'Val (Character'Pos('0') + 
Clause_Number.Section) &
+                           "." & Character'Val (Character'Pos('0') + 
Clause_Number.Clause);
+                   elsif Clause_Number.Clause < 20 then
+                       return Character'Val (Character'Pos('0') + 
Clause_Number.Section) &
+                           ".1" & Character'Val (Character'Pos('0') + 
Clause_Number.Clause - 10);
+                   elsif Clause_Number.Clause < 30 then
+                       return Character'Val (Character'Pos('0') + 
Clause_Number.Section) &
+                           ".2" & Character'Val (Character'Pos('0') + 
Clause_Number.Clause - 20);
+                   elsif Clause_Number.Clause < 40 then
+                       return Character'Val (Character'Pos('0') + 
Clause_Number.Section) &
+                           ".3" & Character'Val (Character'Pos('0') + 
Clause_Number.Clause - 30);
+                   elsif Clause_Number.Clause < 50 then
+                       return Character'Val (Character'Pos('0') + 
Clause_Number.Section) &
+                           ".4" & Character'Val (Character'Pos('0') + 
Clause_Number.Clause - 40);
+                   elsif Clause_Number.Clause < 60 then
+                       return Character'Val (Character'Pos('0') + 
Clause_Number.Section) &
+                           ".5" & Character'Val (Character'Pos('0') + 
Clause_Number.Clause - 50);
+                   else
+                       raise Bad_Clause_Error; -- Out of range.
+                   end if;
+               elsif Clause_Number.Section < 20 then
+                   if Clause_Number.Clause < 10 then
+                       return "1" & Character'Val (Character'Pos('0') + 
Clause_Number.Section - 10) &
+                           "." & Character'Val (Character'Pos('0') + 
Clause_Number.Clause);
+                   elsif Clause_Number.Clause < 20 then
+                       return "1" & Character'Val (Character'Pos('0') + 
Clause_Number.Section - 10) &
+                           ".1" & Character'Val (Character'Pos('0') + 
Clause_Number.Clause - 10);
+                   elsif Clause_Number.Clause < 30 then
+                       return "1" & Character'Val (Character'Pos('0') + 
Clause_Number.Section - 10) &
+                           ".2" & Character'Val (Character'Pos('0') + 
Clause_Number.Clause - 20);
+                   elsif Clause_Number.Clause < 40 then
+                       return "1" & Character'Val (Character'Pos('0') + 
Clause_Number.Section - 10) &
+                           ".3" & Character'Val (Character'Pos('0') + 
Clause_Number.Clause - 30);
+                   elsif Clause_Number.Clause < 50 then
+                       return "1" & Character'Val (Character'Pos('0') + 
Clause_Number.Section - 10) &
+                           ".4" & Character'Val (Character'Pos('0') + 
Clause_Number.Clause - 40);
+                   elsif Clause_Number.Clause < 60 then
+                       return "1" & Character'Val (Character'Pos('0') + 
Clause_Number.Section - 10) &
+                           ".5" & Character'Val (Character'Pos('0') + 
Clause_Number.Clause - 50);
+                   else
+                       raise Bad_Clause_Error; -- Out of range.
+                   end if;
+               elsif Clause_Number.Section < 30 then
+                   if Clause_Number.Clause < 10 then
+                       return "2" & Character'Val (Character'Pos('0') + 
Clause_Number.Section - 20) &
+                           "." & Character'Val (Character'Pos('0') + 
Clause_Number.Clause);
+                   elsif Clause_Number.Clause < 20 then
+                       return "2" & Character'Val (Character'Pos('0') + 
Clause_Number.Section - 20) &
+                           ".1" & Character'Val (Character'Pos('0') + 
Clause_Number.Clause - 10);
+                   elsif Clause_Number.Clause < 30 then
+                       return "2" & Character'Val (Character'Pos('0') + 
Clause_Number.Section - 20) &
+                           ".2" & Character'Val (Character'Pos('0') + 
Clause_Number.Clause - 20);
+                   elsif Clause_Number.Clause < 40 then
+                       return "2" & Character'Val (Character'Pos('0') + 
Clause_Number.Section - 20) &
+                           ".3" & Character'Val (Character'Pos('0') + 
Clause_Number.Clause - 30);
+                   elsif Clause_Number.Clause < 50 then
+                       return "2" & Character'Val (Character'Pos('0') + 
Clause_Number.Section - 20) &
+                           ".4" & Character'Val (Character'Pos('0') + 
Clause_Number.Clause - 40);
+                   elsif Clause_Number.Clause < 60 then
+                       return "2" & Character'Val (Character'Pos('0') + 
Clause_Number.Section - 20) &
+                           ".5" & Character'Val (Character'Pos('0') + 
Clause_Number.Clause - 50);
+                   else
+                       raise Bad_Clause_Error; -- Out of range.
+                   end if;
+               elsif Clause_Number.Section = 30 then
+                   if Clause_Number.Clause < 10 then
+                       return "30." & Character'Val (Character'Pos('0') + 
Clause_Number.Clause);
+                   elsif Clause_Number.Clause < 20 then
+                       return "30.1" & Character'Val (Character'Pos('0') + 
Clause_Number.Clause - 10);
+                   elsif Clause_Number.Clause < 30 then
+                       return "30.2" & Character'Val (Character'Pos('0') + 
Clause_Number.Clause - 20);
+                   elsif Clause_Number.Clause < 40 then
+                       return "30.3" & Character'Val (Character'Pos('0') + 
Clause_Number.Clause - 30);
+                   elsif Clause_Number.Clause < 50 then
+                       return "30.4" & Character'Val (Character'Pos('0') + 
Clause_Number.Clause - 40);
+                   elsif Clause_Number.Clause < 60 then
+                       return "30.5" & Character'Val (Character'Pos('0') + 
Clause_Number.Clause - 50);
+                   else
+                       raise Bad_Clause_Error; -- Out of range.
+                   end if;
+               else
+                   if Clause_Number.Clause < 10 then
+                       return Character'Val (Character'Pos('A') + 
(Clause_Number.Section - ANNEX_START)) &
+                           "." & Character'Val (Character'Pos('0') + 
Clause_Number.Clause);
+                   elsif Clause_Number.Clause < 20 then
+                       return Character'Val (Character'Pos('A') + 
(Clause_Number.Section - ANNEX_START)) &
+                           ".1" & Character'Val (Character'Pos('0') + 
Clause_Number.Clause - 10);
+                   elsif Clause_Number.Clause < 30 then
+                       return Character'Val (Character'Pos('A') + 
(Clause_Number.Section - ANNEX_START)) &
+                           ".2" & Character'Val (Character'Pos('0') + 
Clause_Number.Clause - 20);
+                   elsif Clause_Number.Clause < 40 then
+                       return Character'Val (Character'Pos('A') + 
(Clause_Number.Section - ANNEX_START)) &
+                           ".3" & Character'Val (Character'Pos('0') + 
Clause_Number.Clause - 30);
+                   elsif Clause_Number.Clause < 50 then
+                       return Character'Val (Character'Pos('A') + 
(Clause_Number.Section - ANNEX_START)) &
+                           ".4" & Character'Val (Character'Pos('0') + 
Clause_Number.Clause - 40);
+                   elsif Clause_Number.Clause < 60 then
+                       return Character'Val (Character'Pos('A') + 
(Clause_Number.Section - ANNEX_START)) &
+                           ".4" & Character'Val (Character'Pos('0') + 
Clause_Number.Clause - 50);
+                   else
+                       raise Bad_Clause_Error; -- Out of range.
+                   end if;
+               end if;
+           when Subclause =>
+               if Clause_Number.Section = UNKNOWN then
+                   raise Bad_Clause_Error with "unknown section number";
+               elsif Clause_Number.Subclause < 10 then
+                   return Make_Clause_Number (Clause, (Clause_Number.Section, 
Clause_Number.Clause, 0, 0)) &
+                       "." & Character'Val (Character'Pos('0') + 
Clause_Number.Subclause);
+               elsif Clause_Number.Subclause < 20 then
+                   return Make_Clause_Number (Clause, (Clause_Number.Section, 
Clause_Number.Clause, 0, 0)) &
+                       ".1" & Character'Val (Character'Pos('0') + 
Clause_Number.Subclause - 10);
+               elsif Clause_Number.Subclause < 30 then
+                   return Make_Clause_Number (Clause, (Clause_Number.Section, 
Clause_Number.Clause, 0, 0)) &
+                       ".2" & Character'Val (Character'Pos('0') + 
Clause_Number.Subclause - 20);
+               elsif Clause_Number.Subclause < 40 then
+                   return Make_Clause_Number (Clause, (Clause_Number.Section, 
Clause_Number.Clause, 0, 0)) &
+                       ".3" & Character'Val (Character'Pos('0') + 
Clause_Number.Subclause - 30);
+               elsif Clause_Number.Subclause < 50 then
+                   return Make_Clause_Number (Clause, (Clause_Number.Section, 
Clause_Number.Clause, 0, 0)) &
+                       ".4" & Character'Val (Character'Pos('0') + 
Clause_Number.Subclause - 40);
+               else
+                   raise Bad_Clause_Error; -- Out of range.
+               end if;
+           when Subsubclause =>
+               if Clause_Number.Subsubclause < 10 then
+                   return Make_Clause_Number (Subclause, 
(Clause_Number.Section, Clause_Number.Clause, Clause_Number.Subclause, 0)) &
+                       "." & Character'Val (Character'Pos('0') + 
Clause_Number.Subsubclause);
+               elsif Clause_Number.Subclause < 20 then
+                   return Make_Clause_Number (Subclause, 
(Clause_Number.Section, Clause_Number.Clause, Clause_Number.Subclause, 0)) &
+                       ".1" & Character'Val (Character'Pos('0') + 
Clause_Number.Subsubclause - 10);
+               elsif Clause_Number.Subclause < 30 then
+                   return Make_Clause_Number (Subclause, 
(Clause_Number.Section, Clause_Number.Clause, Clause_Number.Subclause, 0)) &
+                       ".2" & Character'Val (Character'Pos('0') + 
Clause_Number.Subsubclause - 20);
+               elsif Clause_Number.Subclause < 40 then
+                   return Make_Clause_Number (Subclause, 
(Clause_Number.Section, Clause_Number.Clause, Clause_Number.Subclause, 0)) &
+                       ".3" & Character'Val (Character'Pos('0') + 
Clause_Number.Subsubclause - 30);
+               elsif Clause_Number.Subclause < 50 then
+                   return Make_Clause_Number (Subclause, 
(Clause_Number.Section, Clause_Number.Clause, Clause_Number.Subclause, 0)) &
+                       ".4" & Character'Val (Character'Pos('0') + 
Clause_Number.Subsubclause - 40);
+               else
+                   raise Bad_Clause_Error; -- Out of range.
+               end if;
+           when Dead_Clause =>
+               return "X.X";
+       end case;
+    end Make_Clause_Number;
+
+
+    procedure Make_Clause (Clause_String : in String;
+                          Clause_Number : out Clause_Number_Type) is
+       -- Returns the clause number for a properly formatted Section or
+       -- clause string.
+
+       Next : Positive;
+       function Get_Section_Number return Section_Number_Type is
+           -- Extract the section number:
+       begin
+           if Clause_String'Length = 1 or else
+               Clause_String(Clause_String'First + 1) = '.' then
+               Next := Clause_String'First + 2;
+               if Clause_String (Clause_String'First) in '0' .. '9' then
+                   return Character'Pos(Clause_String (Clause_String'First)) - 
Character'Pos('0');
+               else
+                   return Character'Pos(Clause_String (Clause_String'First)) - 
Character'Pos('A') + ANNEX_START;
+               end if;
+           else
+               Next := Clause_String'First + 3;
+               return (Character'Pos(Clause_String (Clause_String'First)) - 
Character'Pos('0')) * 10 +
+                   Character'Pos(Clause_String (Clause_String'First + 1)) - 
Character'Pos('0');
+           end if;
+       end Get_Section_Number;
+
+       function Get_Clause_Number return Natural is
+           -- Extract the clause:
+       begin
+           if Clause_String'Last - Next + 1 = 1 or else
+               Clause_String(Next + 1) = '.' then
+               Next := Next + 2;
+               return Character'Pos(Clause_String (Next - 2)) - 
Character'Pos('0');
+           else
+               Next := Next + 3;
+               return (Character'Pos(Clause_String (Next - 3)) - 
Character'Pos('0')) * 10 +
+                   Character'Pos(Clause_String (Next - 3 + 1)) - 
Character'Pos('0');
+           end if;
+       end Get_Clause_Number;
+
+    begin
+       if Clause_String'Length = 7 and then
+          Clause_String (Clause_String'First .. Clause_String'First + 5) =
+           "Annex " then -- Annex clauses.
+           Clause_Number :=
+               (Section => Character'Pos(Clause_String (Clause_String'First + 
6)) - Character'Pos('A') + ANNEX_START,
+                Clause | Subclause | Subsubclause => 0);
+       elsif Clause_String'Length = 1 then
+           Clause_Number :=
+               (Section => Get_Section_Number,
+                Clause | Subclause | Subsubclause => 0);
+       elsif Clause_String'Length = 2 then
+           Clause_Number :=
+               (Section => Get_Section_Number,
+                Clause | Subclause | Subsubclause => 0);
+       else
+           Clause_Number :=
+               (Section => Get_Section_Number,
+                Clause | Subclause | Subsubclause => 0);
+           -- Next is now the start of the Clause:
+           if Clause_String'Last - Next + 1 = 1 then
+               Clause_Number.Clause := Get_Clause_Number;
+           elsif Clause_String'Last - Next + 1 = 2 then
+               Clause_Number.Clause := Get_Clause_Number;
+           else
+               Clause_Number.Clause := Get_Clause_Number;
+               -- Next is now the start of the Subclause:
+               if Clause_String'Last - Next + 1 = 1 then
+                   Clause_Number.Subclause := Character'Pos(Clause_String 
(Next)) - Character'Pos('0');
+               elsif Clause_String'Last - Next + 1 = 2 then
+                   Clause_Number.Subclause := (Character'Pos(Clause_String 
(Next)) -
+                       Character'Pos('0')) * 10 +
+                           Character'Pos(Clause_String (Next + 1)) - 
Character'Pos('0');
+               else
+                   if Clause_String'Last - Next + 1 = 1 or else
+                       Clause_String(Next + 1) = '.' then
+                       Next := Next + 2;
+                       Clause_Number.Subclause := Character'Pos(Clause_String 
(Next - 2)) - Character'Pos('0');
+                   else
+                       Next := Next + 3;
+                       Clause_Number.Subclause := (Character'Pos(Clause_String 
(Next - 3)) - Character'Pos('0')) * 10 +
+                           Character'Pos(Clause_String (Next - 3 + 1)) - 
Character'Pos('0');
+                   end if;
+                   if Clause_String'Last - Next + 1 = 1 then
+                       Clause_Number.Subsubclause := 
Character'Pos(Clause_String (Next)) - Character'Pos('0');
+                   else -- Two digit.
+                       Clause_Number.Subsubclause := 
(Character'Pos(Clause_String (Next)) -
+                           Character'Pos('0')) * 10 +
+                               Character'Pos(Clause_String (Next + 1)) - 
Character'Pos('0');
+                   end if;
+               end if;
+           end if;
+       end if;
+       if Clause_Number.Section = UNKNOWN then
+           raise Bad_Clause_Error with "unknown section number";
+       -- else not unknown
+       end if;
+    end Make_Clause;
+
+
+    function Lookup_Clause_Number (Title : in Title_Type) return String is
+       -- Given the title of a clause, returns the formatted Section or
+       -- clause number reference for that title. The Title must match
+       -- exactly, except for case. Raises Not_Found_Error if not found.
+       Lower_Title : constant Title_Type := Ada.Characters.Handling.To_Lower 
(Title);
+    begin
+       for I in 1 .. Last_Title loop
+           if Lower_Title = Title_List(I).Search_Title then
+               return Make_Clause_Number (Title_List(I).Level,
+                                          Title_List(I).Clause_Number);
+           end if;
+       end loop;
+       raise Not_Found_Error;
+    end Lookup_Clause_Number;
+
+
+    function Lookup_Level (Title : in Title_Type) return Level_Type is
+       -- Given the title of a clause, returns the level for that title. The 
Title must match
+       -- exactly, except for case. Raises Not_Found_Error if not found.
+       Lower_Title : constant Title_Type := Ada.Characters.Handling.To_Lower 
(Title);
+    begin
+       for I in 1 .. Last_Title loop
+           if Lower_Title = Title_List(I).Search_Title then
+               return Title_List(I).Level;
+           end if;
+       end loop;
+       raise Not_Found_Error;
+    end Lookup_Level;
+
+
+    function Lookup_Title (Level : in Level_Type;
+                          Clause_Number : in Clause_Number_Type) return 
Title_Type is
+       -- Given the level and clause numbers, return the appropriate
+       -- title. Raises Not_Found_Error if not found.
+    begin
+       if Clause_Number.Section = UNKNOWN then
+           raise Bad_Clause_Error with "unknown section number";
+       -- else not unknown
+       end if;
+       for I in 1 .. Last_Title loop
+           if Title_List(I).Level = Level and then
+              Title_List(I).Clause_Number = Clause_Number then
+               return Title_List(I).Title;
+           end if;
+       end loop;
+       raise Not_Found_Error;
+    end Lookup_Title;
+
+
+    function Lookup_Old_Title (Level : in Level_Type;
+                  Clause_Number : in Clause_Number_Type) return Title_Type is
+       -- Given the level and clause numbers, return the appropriate
+       -- old title. Calls Lookup_Title if not found (thus returning the
+       -- regular (new) title.
+    begin
+       if Clause_Number.Section = UNKNOWN then
+           raise Bad_Clause_Error with "unknown section number";
+       -- else not unknown
+       end if;
+       for I in 1 .. Last_Old_Title loop
+           if Old_Title_List(I).Level = Level and then
+              Old_Title_List(I).Clause_Number = Clause_Number then
+               return Old_Title_List(I).Title;
+           end if;
+       end loop;
+       return Lookup_Title (Level, Clause_Number);
+    end Lookup_Old_Title;
+
+
+    function Previous_Clause (Clause : in String) return String is
+       -- Returns the string of the previous clause (in the table of contents)
+       -- for the properly formatted clause string Clause.
+       -- Raises Not_Found_Error if not found.
+        Clause_Number : Clause_Number_Type;
+    begin
+       Make_Clause (Clause, Clause_Number);
+       for I in 1 .. Last_Title loop
+           if Title_List(I).Clause_Number = Clause_Number then
+               for J in reverse 1 .. I - 1 loop
+                   if Title_List(J).Level /= Dead_Clause then
+                       return Make_Clause_Number (Title_List(J).Level,
+                                                  Title_List(J).Clause_Number);
+                   -- else skip it and continue.
+                   end if;
+               end loop;
+               -- If we get here, it was not found.
+               raise Not_Found_Error;
+           end if;
+       end loop;
+       raise Not_Found_Error;
+    end Previous_Clause;
+
+
+    function Next_Clause (Clause : in String) return String is
+       -- Returns the string of the next clause (in the table of contents)
+       -- for the properly formatted clause string Clause.
+       -- Raises Not_Found_Error if not found.
+        Clause_Number : Clause_Number_Type;
+    begin
+       Make_Clause (Clause, Clause_Number);
+       for I in 1 .. Last_Title loop
+           if Title_List(I).Clause_Number = Clause_Number then
+               for J in I + 1 .. Last_Title loop
+                   if Title_List(J).Level /= Dead_Clause then
+                       return Make_Clause_Number (Title_List(J).Level,
+                                                  Title_List(J).Clause_Number);
+                   -- else skip it and continue.
+                   end if;
+               end loop;
+               -- If we get here, it was not found.
+               raise Not_Found_Error;
+           end if;
+       end loop;
+       raise Not_Found_Error;
+    end Next_Clause;
+
+
+    function Parent_Clause (Clause : in String) return String is
+        -- Returns the string of the parent clause (in the table of contents)
+        -- for the properly formatted clause string Clause.
+        --
+        -- Result is a null string if Clause is a top level clause;
+        -- Section, Unnumbered_Section, Normative_Annex,
+        -- Informative_Annex, Plain_Annex.
+        Clause_Number : Clause_Number_Type;
+    begin
+       Make_Clause (Clause, Clause_Number);
+
+       if Clause_Number.Clause = 0 then
+          -- Clause is a section; no parent
+          return "";
+
+       elsif Clause_Number.Subclause = 0 then
+          -- Clause is a clause; parent is Section or Annex
+          if Clause_Number.Section >= ANNEX_START then
+             return Make_Clause_Number (Normative_Annex, 
(Clause_Number.Section, 0, 0, 0));
+          else
+             return Make_Clause_Number (Section, (Clause_Number.Section, 0, 0, 
0));
+          end if;
+
+       elsif Clause_Number.Subsubclause = 0 then
+          -- Clause is a subclause; clause is parent
+          return Make_Clause_Number (ARM_Contents.Clause, 
(Clause_Number.Section, Clause_Number.Clause, 0, 0));
+
+       else
+          -- Clause is a subsubclause; subclause is parent
+          return Make_Clause_Number
+            (Subclause, (Clause_Number.Section, Clause_Number.Clause, 
Clause_Number.Subclause, 0));
+       end if;
+    end Parent_Clause;
+
+
+    procedure For_Each is
+       -- Call Operate for each title in the contents, in the order that
+       -- they were added to the contents (other than dead clauses). If the
+       -- Quit parameter to Operate is True when Operate returns, the
+       -- iteration is abandoned.
+       Quit : Boolean := False;
+    begin
+       for I in 1 .. Last_Title loop
+           if Title_List(I).Level /= Dead_Clause then
+               Operate (Title_List(I).Title,
+                        Title_List(I).Level,
+                        Title_List(I).Clause_Number,
+                        Title_List(I).Version,
+                        Quit);
+           -- else skip it.
+           end if;
+           if Quit then
+               return;
+           end if;
+       end loop;
+    end For_Each;
+
+end ARM_Contents;
diff --git a/progs/arm_cont.ads b/progs/arm_cont.ads
new file mode 100755
index 0000000..aeca794
--- /dev/null
+++ b/progs/arm_cont.ads
@@ -0,0 +1,187 @@
+with Ada.Strings.Unbounded;
+package ARM_Contents is
+
+    --
+    -- Ada reference manual formatter (ARM_Form).
+    --
+    -- This package contains the routines to manage section/clause/subclause
+    -- references.
+    --
+    -- ---------------------------------------
+    -- Copyright 2000, 2004, 2006, 2007, 2009, 2011, 2012
+    --   AXE Consultants. All rights reserved.
+    -- P.O. Box 1512, Madison WI  53701
+    -- E-Mail: randy@rrsoftware.com
+    --
+    -- ARM_Form is free software: you can redistribute it and/or modify
+    -- it under the terms of the GNU General Public License version 3
+    -- as published by the Free Software Foundation.
+    --
+    -- AXE CONSULTANTS MAKES THIS TOOL AND SOURCE CODE AVAILABLE ON AN "AS IS"
+    -- BASIS AND MAKES NO WARRANTY, EXPRESS OR IMPLIED, AS TO THE ACCURACY,
+    -- CAPABILITY, EFFICIENCY, MERCHANTABILITY, OR FUNCTIONING OF THIS TOOL.
+    -- IN NO EVENT WILL AXE CONSULTANTS BE LIABLE FOR ANY GENERAL,
+    -- CONSEQUENTIAL, INDIRECT, INCIDENTAL, EXEMPLARY, OR SPECIAL DAMAGES,
+    -- EVEN IF AXE CONSULTANTS HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
+    -- DAMAGES.
+    --
+    -- A copy of the GNU General Public License is available in the file
+    -- gpl-3-0.txt in the standard distribution of the ARM_Form tool.
+    -- Otherwise, see <http://www.gnu.org/licenses/>.
+    --
+    -- If the GPLv3 license is not satisfactory for your needs, a commercial
+    -- use license is available for this tool. Contact Randy at AXE Consultants
+    -- for more information.
+    --
+    -- ---------------------------------------
+    --
+    -- Edit History:
+    --
+    --  4/19/00 - RLB - Created base package.
+    --  4/26/00 - RLB - Added Previous_Clause and Next_Clause.
+    --  5/15/00 - RLB - Added rules about unnumbered sections.
+    --  5/22/00 - RLB - Added Unnumbered_Section level.
+    --  8/ 7/00 - RLB - Made Make_Clause visible.
+    --  8/22/00 - RLB - Added Old_Title handling.
+    --  9/14/04 - RLB - Moved Change_Version_Type here, to avoid mutual
+    --                 dependence.
+    --         - RLB - Added version to changes.
+    --  9/22/06 - RLB - Created type Clause_Number_Type and added SubSubClause.
+    -- 12/18/07 - RLB - Added Plain_Annex.
+    --  5/06/09 - RLB - Added Versioned_String.
+    --  5/07/09 - RLB - Added Dead_Clause.
+    -- 10/18/11 - RLB - Changed to GPLv3 license.
+    -- 10/19/11 - RLB - Added Parent_Clause from Stephen Leake's version.
+    -- 10/25/11 - RLB - Added version to Old name strings.
+    --  8/30/12 - RLB - Added initialization of Section to UNKNOWN to
+    --                 detect bugs earlier.
+
+    subtype Title_Type is String (1 .. 80);
+       -- The type of a title.
+
+    type Section_Number_Type is range 0 .. 58;
+       -- Values > 30 represent annex letters (31 => A, 32 => B, etc.)
+       -- Value = 0 represents the preface, introduction, etc. No
+       -- number is generated if Section_Number = 0.
+    ANNEX_START : constant := 31; -- First annex section number.
+    UNKNOWN : constant Section_Number_Type := 58; -- Uninitialized sections 
get this.
+
+    subtype Change_Version_Type is Character range '0' .. '9';
+       -- Defines the change version. Version 0 is the original text.
+
+    type Versioned_String is array (ARM_Contents.Change_Version_Type) of
+       Ada.Strings.Unbounded.Unbounded_String;
+
+    type Clause_Number_Type is record
+       Section : Section_Number_Type := UNKNOWN;
+       Clause : Natural := 0;
+       Subclause : Natural := 0;
+       Subsubclause : Natural := 0;
+    end record;
+
+    Not_Found_Error  : exception;
+
+    Bad_Clause_Error : exception;
+       -- Raised by any of the below if the Clause_Number is
+       -- invalid (potentially depending on the other parameters,
+       -- like the level).
+
+    procedure Initialize;
+       -- Initialize this package; make sure the contents are empty.
+
+    type Level_Type is (Section, Unnumbered_Section, Plain_Annex,
+                       Normative_Annex, Informative_Annex,
+                       Clause, Subclause, Subsubclause, Dead_Clause);
+       -- Defines the level of a clause header.
+       -- Clause is "xx.nn"; Subclause is "xx.nn.nn"; Subsubclause is 
"xx.nn.nn.nn".
+
+    function "<" (Left, Right : Clause_Number_Type) return Boolean;
+       -- True if Left comes before Right in the collating order.
+
+    function ">" (Left, Right : Clause_Number_Type) return Boolean;
+       -- True if Left comes after Right in the collating order.
+
+    function "<=" (Left, Right : Clause_Number_Type) return Boolean;
+       -- True if Left comes before or is the same as Right in the
+       -- collating order.
+
+    function ">=" (Left, Right : Clause_Number_Type) return Boolean;
+       -- True if Left comes after or is the same as Right in the
+       -- collating order.
+
+    procedure Add (Title : in Title_Type;
+                  Level : in Level_Type;
+                  Clause_Number : in Clause_Number_Type;
+                   Version : in ARM_Contents.Change_Version_Type := '0');
+       -- Add a section or clause to the contents. It has the specified
+       -- characteristics.
+
+    procedure Add_Old (Old_Title : in Title_Type;
+                      Level : in Level_Type;
+                      Clause_Number : in Clause_Number_Type;
+                       Version : in ARM_Contents.Change_Version_Type := '0');
+       -- Add an old title for a section or clause to the contents. It has
+       -- the specified characteristics; the version is the version for which
+       -- it first was present in the document.
+
+    function Make_Clause_Number (Level : in Level_Type;
+                  Clause_Number : in Clause_Number_Type) return String;
+       -- Returns a properly formatted Section or clause number reference.
+       -- Note that an unnumbered section returns a number with a
+       -- Section_Number of zero (for sorting purposes).
+
+    procedure Make_Clause (Clause_String : in String;
+                          Clause_Number : out Clause_Number_Type);
+       -- Returns the clause number for a properly formatted Section or
+       -- clause string.
+
+    function Lookup_Clause_Number (Title : in Title_Type) return String;
+       -- Given the title of a clause, returns the formatted Section or
+       -- clause number reference for that title. The Title must match
+       -- exactly, except for case. Raises Not_Found_Error if not found.
+
+    function Lookup_Level (Title : in Title_Type) return Level_Type;
+       -- Given the title of a clause, returns the level for that title. The 
Title must match
+       -- exactly, except for case. Raises Not_Found_Error if not found.
+
+    function Lookup_Title (Level : in Level_Type;
+                          Clause_Number : in Clause_Number_Type) return 
Title_Type;
+       -- Given the level and clause numbers, return the appropriate
+       -- title. Raises Not_Found_Error if not found.
+
+    function Lookup_Old_Title (Level : in Level_Type;
+                  Clause_Number : in Clause_Number_Type) return Title_Type;
+       -- Given the level and clause numbers, return the appropriate
+       -- old title. Calls Lookup_Title if not found (thus returning the
+       -- regular (new) title.
+
+    function Previous_Clause (Clause : in String) return String;
+       -- Returns the string of the previous clause (in the table of contents)
+       -- for the properly formatted clause string Clause.
+       -- Raises Not_Found_Error if not found.
+
+    function Next_Clause (Clause : in String) return String;
+       -- Returns the string of the next clause (in the table of contents)
+       -- for the properly formatted clause string Clause.
+       -- Raises Not_Found_Error if not found.
+
+    function Parent_Clause (Clause : in String) return String;
+        -- Returns the string of the parent clause (in the table of contents)
+        -- for the properly formatted clause string Clause.
+        --
+        -- Result is a null string if Clause is a top level clause;
+        -- Section, Unnumbered_Section, Normative_Annex,
+        -- Informative_Annex, Plain_Annex.
+
+    generic
+       with procedure Operate (Title : in Title_Type;
+                  Level : in Level_Type;
+                  Clause_Number : in Clause_Number_Type;
+                   Version : in ARM_Contents.Change_Version_Type;
+                  Quit : out Boolean) is <>;
+    procedure For_Each;
+       -- Call Operate for each title in the contents, in the order that
+       -- they were added to the contents. If the Quit parameter to Operate
+       -- is True when Operate returns, the iteration is abandoned.
+
+end ARM_Contents;
diff --git a/progs/arm_corr.adb b/progs/arm_corr.adb
new file mode 100755
index 0000000..57dcf3f
--- /dev/null
+++ b/progs/arm_corr.adb
@@ -0,0 +1,1719 @@
+with --ARM_Output,
+     --ARM_Contents,
+     --Ada.Text_IO,
+     Ada.Exceptions,
+     Ada.Strings.Fixed,
+     Ada.Strings.Maps;
+package body ARM_Corr is
+
+    --
+    -- Ada reference manual formatter (ARM_Form).
+    --
+    -- This package defines the text output object.
+    -- Output objects are responsible for implementing the details of
+    -- a particular format.
+    --
+    -- ---------------------------------------
+    -- Copyright 2000, 2002, 2004, 2005, 2006, 2007, 2011, 2012
+    --   AXE Consultants. All rights reserved.
+    -- P.O. Box 1512, Madison WI  53701
+    -- E-Mail: randy@rrsoftware.com
+    --
+    -- ARM_Form is free software: you can redistribute it and/or modify
+    -- it under the terms of the GNU General Public License version 3
+    -- as published by the Free Software Foundation.
+    --
+    -- AXE CONSULTANTS MAKES THIS TOOL AND SOURCE CODE AVAILABLE ON AN "AS IS"
+    -- BASIS AND MAKES NO WARRANTY, EXPRESS OR IMPLIED, AS TO THE ACCURACY,
+    -- CAPABILITY, EFFICIENCY, MERCHANTABILITY, OR FUNCTIONING OF THIS TOOL.
+    -- IN NO EVENT WILL AXE CONSULTANTS BE LIABLE FOR ANY GENERAL,
+    -- CONSEQUENTIAL, INDIRECT, INCIDENTAL, EXEMPLARY, OR SPECIAL DAMAGES,
+    -- EVEN IF AXE CONSULTANTS HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
+    -- DAMAGES.
+    --
+    -- A copy of the GNU General Public License is available in the file
+    -- gpl-3-0.txt in the standard distribution of the ARM_Form tool.
+    -- Otherwise, see <http://www.gnu.org/licenses/>.
+    --
+    -- If the GPLv3 license is not satisfactory for your needs, a commercial
+    -- use license is available for this tool. Contact Randy at AXE Consultants
+    -- for more information.
+    --
+    -- ---------------------------------------
+    --
+    -- Edit History:
+    --
+    --  6/ 2/05 - RLB - Created package from text and HTML versions.
+    --  1/11/06 - RLB - Eliminated dispatching Create in favor of tailored
+    --                 versions.
+    --  1/18/06 - RLB - Added additional styles.
+    --  2/ 8/06 - RLB - Added additional parameters to the table command.
+    --  2/10/06 - RLB - Added even more additional parameters to the
+    --                 table command.
+    --         - RLB - Added picture command.
+    --  9/22/06 - RLB - Added missing with.
+    --  9/25/06 - RLB - Handled optional renaming of TOC.
+    --         - RLB - Added Last_Column_Width to Start_Table.
+    -- 10/13/06 - RLB - Added Local_Link_Start and Local_Link_End to allow
+    --                 formatting in the linked text.
+    --  2/ 9/07 - RLB - Changed comments on AI_Reference.
+    --  2/13/07 - RLB - Revised to separate style and indent information
+    --                 for paragraphs.
+    -- 12/18/07 - RLB - Added Plain_Annex.
+    -- 12/19/07 - RLB - Added limited colors to Text_Format.
+    -- 10/18/11 - RLB - Changed to GPLv3 license.
+    -- 10/25/11 - RLB - Added old insertion version to Revised_Clause_Header.
+    --  8/31/12 - RLB - Added Output_Path.
+    -- 10/18/12 - RLB - Added additional hanging styles.
+    -- 11/26/12 - RLB - Added subdivision names to Clause_Header and
+    --                 Revised_Clause_Header.
+
+    LINE_LENGTH : constant := 78;
+       -- Maximum intended line length.
+
+    Special_Set : constant Ada.Strings.Maps.Character_Set :=
+         Ada.Strings.Maps."or" (Ada.Strings.Maps.To_Set ('>'),
+           Ada.Strings.Maps.To_Set ('@'));
+
+    procedure Create (Output_Object : in out Corr_Output_Type;
+                     File_Prefix : in String;
+                     Output_Path : in String;
+                     Title : in String := "") is
+       -- Create an Output_Object for a document.
+       -- The prefix of the output file names is File_Prefix - this
+       -- should be no more then 5 characters allowed in file names.
+       -- The result files will be written to Output_Path.
+       -- The title of the document is Title.
+    begin
+       if Output_Object.Is_Valid then
+           Ada.Exceptions.Raise_Exception (ARM_Output.Not_Valid_Error'Identity,
+               "Already valid object");
+       end if;
+       Output_Object.Is_Valid := True;
+       Ada.Strings.Fixed.Move (Target => Output_Object.File_Prefix,
+                               Source => File_Prefix);
+       Ada.Strings.Fixed.Move (Target => Output_Object.Output_Path,
+                               Source => Output_Path);
+        Output_Object.Output_Path_Len := Output_Path'Length;
+       -- We don't use the title.
+    end Create;
+
+
+    procedure Close (Output_Object : in out Corr_Output_Type) is
+       -- Close an Output_Object. No further output to the object is
+       -- allowed after this call.
+    begin
+       if not Output_Object.Is_Valid then
+           Ada.Exceptions.Raise_Exception (ARM_Output.Not_Valid_Error'Identity,
+               "Not valid object");
+       end if;
+       if Ada.Text_IO.Is_Open (Output_Object.Output_File) then
+           Ada.Text_IO.Close (Output_Object.Output_File);
+       end if;
+       Output_Object.Is_Valid := False;
+    end Close;
+
+
+    procedure Section (Output_Object : in out Corr_Output_Type;
+                      Section_Title : in String;
+                      Section_Name : in String) is
+       -- Start a new section. The title is Section_Title (this is
+       -- intended for humans). The name is Section_Name (this is
+       -- intended to be suitable to be a portion of a file name).
+    begin
+       if not Output_Object.Is_Valid then
+           Ada.Exceptions.Raise_Exception (ARM_Output.Not_Valid_Error'Identity,
+               "Not valid object");
+       end if;
+       if Output_Object.Is_In_Paragraph then
+           Ada.Exceptions.Raise_Exception (ARM_Output.Not_Valid_Error'Identity,
+               "Section in paragraph");
+       end if;
+       if Ada.Text_IO.Is_Open (Output_Object.Output_File) then
+           Ada.Text_IO.Close (Output_Object.Output_File);
+       end if;
+       -- Create a new file for this section:
+        -- Unix directory separator for Windows and Debian
+       Ada.Text_IO.Create (Output_Object.Output_File, Ada.Text_IO.Out_File,
+            Output_Object.Output_Path(1..Output_Object.Output_Path_Len) &
+               Ada.Strings.Fixed.Trim (Output_Object.File_Prefix, 
Ada.Strings.Right) &
+               "-Corr-" & Section_Name & ".TXT");
+       Ada.Text_IO.New_Line (Output_Object.Output_File);
+    end Section;
+
+
+    procedure Set_Columns (Output_Object : in out Corr_Output_Type;
+                          Number_of_Columns : in ARM_Output.Column_Count) is
+       -- Set the number of columns.
+       -- Raises Not_Valid_Error if in a paragraph.
+    begin
+       if not Output_Object.Is_Valid then
+           Ada.Exceptions.Raise_Exception (ARM_Output.Not_Valid_Error'Identity,
+               "Not valid object");
+       end if;
+       if Output_Object.Is_In_Paragraph then
+           Ada.Exceptions.Raise_Exception (ARM_Output.Not_Valid_Error'Identity,
+               "In paragraph");
+       end if;
+       -- No columns in text format.
+    end Set_Columns;
+
+
+    procedure Make_Indent (Output_Object : in out Corr_Output_Type) is
+       -- Internal:
+       -- Output the appropriate indent after a New_Line or Put_Line.
+    begin
+--Ada.Text_IO.Put_Line("Make_Indent: Amount=" & 
Natural'Image(Output_Object.Indent_Amount));
+        for I in 1 .. Output_Object.Indent_Amount loop
+           Ada.Text_IO.Put (Output_Object.Output_File, ' ');
+        end loop;
+        Output_Object.Char_Count := Output_Object.Indent_Amount;
+        Output_Object.Out_Char_Count := Output_Object.Indent_Amount;
+       Output_Object.Output_Buffer_Space_Before := False;
+    end Make_Indent;
+
+
+    procedure Spill (Output_Object : in out Corr_Output_Type) is
+       -- Internal:
+       -- Empty the output buffer in preperation for a New_Line or Put_Line.
+    begin
+        if Output_Object.Output_Buffer_Space_Before then
+           Ada.Text_IO.Put (Output_Object.Output_File, ' ');
+           Output_Object.Char_Count := Output_Object.Char_Count + 1; -- Count 
the space.
+           Output_Object.Out_Char_Count := Output_Object.Out_Char_Count + 1; 
-- Count the space.
+        end if;
+       if Output_Object.Output_Buffer_Len /= 0 then
+           Ada.Text_IO.Put (Output_Object.Output_File,
+               Output_Object.Output_Buffer (1 .. 
Output_Object.Output_Buffer_Len));
+--Ada.Text_IO.Put_Line("Spill: Len=" & 
Natural'Image(Output_Object.Output_Buffer_Len) &
+--     " Space added=" &  
Boolean'Image(Output_Object.Output_Buffer_Space_Before) & " Text=" &
+--     Output_Object.Output_Buffer (1 .. Output_Object.Output_Buffer_Len));
+           Output_Object.Output_Buffer_Len := 0;
+           Output_Object.Out_Char_Count := Output_Object.Out_Char_Count +
+               Output_Object.Output_Buffer_Len;
+       end if;
+        Output_Object.Output_Buffer_Space_Before := False;
+    end Spill;
+
+
+    procedure Buffer (Output_Object : in out Corr_Output_Type;
+                     Char : in Character) is
+       -- Internal:
+       -- Add Char to the output buffer. Char will *not* be a word break
+       -- character.
+    begin
+       if Output_Object.Output_Buffer_Len = Output_Object.Output_Buffer'Last 
then
+           -- Oops, buffer is full. Spill it, and this character.
+--Ada.Text_IO.Put_Line("** Buffer overflow!!");
+           Spill (Output_Object);
+           Ada.Text_IO.Put (Output_Object.Output_File, Char);
+           Output_Object.Char_Count := Output_Object.Char_Count + 1;
+           Output_Object.Out_Char_Count := Output_Object.Out_Char_Count + 1;
+           return;
+       end if;
+       Output_Object.Output_Buffer_Len := Output_Object.Output_Buffer_Len + 1;
+       Output_Object.Output_Buffer(Output_Object.Output_Buffer_Len) := Char;
+        Output_Object.Char_Count := Output_Object.Char_Count + 1;
+    end Buffer;
+
+
+    procedure Buffer (Output_Object : in out Corr_Output_Type;
+                     Str : in String) is
+       -- Internal:
+       -- Add Char to the output buffer. String will *not* include a word
+       -- break character.
+    begin
+       if Output_Object.Output_Buffer_Len+Str'Length >= 
Output_Object.Output_Buffer'Last then
+           -- Oops, buffer is full. Spill it.
+--Ada.Text_IO.Put_Line("** Buffer overflow!!");
+           Spill (Output_Object);
+       end if;
+       
Output_Object.Output_Buffer(Output_Object.Output_Buffer_Len+1..Output_Object.Output_Buffer_Len+Str'Length)
+           := Str;
+       Output_Object.Output_Buffer_Len := Output_Object.Output_Buffer_Len + 
Str'Length;
+        Output_Object.Char_Count := Output_Object.Char_Count + Str'Length;
+    end Buffer;
+
+
+    procedure Start_Paragraph (Output_Object : in out Corr_Output_Type;
+                              Style     : in ARM_Output.Paragraph_Style_Type;
+                              Indent    : in ARM_Output.Paragraph_Indent_Type;
+                              Number    : in String;
+                              No_Prefix : in Boolean := False;
+                              Tab_Stops : in ARM_Output.Tab_Info := 
ARM_Output.NO_TABS;
+                              No_Breaks : in Boolean := False;
+                              Keep_with_Next : in Boolean := False;
+                              Space_After : in ARM_Output.Space_After_Type
+                                  := ARM_Output.Normal;
+                              Justification : in ARM_Output.Justification_Type
+                                  := ARM_Output.Default) is
+       -- Start a new paragraph. The style and indent of the paragraph is as
+       -- specified. The (AA)RM paragraph number (which might include update
+       -- and version numbers as well: [12.1/1]) is Number. If the format is
+       -- a type with a prefix (bullets, hangining items), the prefix is
+       -- omitted if No_Prefix is true. Tab_Stops defines the tab stops for
+       -- the paragraph. If No_Breaks is True, we will try to avoid page breaks
+       -- in the paragraph. If Keep_with_Next is true, we will try to avoid
+       -- separating this paragraph and the next one. (These may have no
+       -- effect in formats that don't have page breaks). Space_After
+       -- specifies the amount of space following the paragraph. Justification
+       -- specifies the text justification for the paragraph. Not_Valid_Error
+       -- is raised if Tab_Stops /= NO_TABS for a hanging or bulleted format.
+       use type ARM_Output.Paragraph_Indent_Type;
+    begin
+       if not Output_Object.Is_Valid then
+           Ada.Exceptions.Raise_Exception (ARM_Output.Not_Valid_Error'Identity,
+               "Not valid object");
+       end if;
+       if Output_Object.Is_In_Paragraph then
+           Ada.Exceptions.Raise_Exception (ARM_Output.Not_Valid_Error'Identity,
+               "Already in paragraph");
+       end if;
+       Output_Object.Is_In_Paragraph := True;
+       Output_Object.Is_Hanging := False;
+       Output_Object.Saw_Hang_End := False;
+       Output_Object.Char_Count := 0;
+       Output_Object.Out_Char_Count := 0;
+       Output_Object.Output_Buffer_Space_Before := False; -- Nothing in it or 
on the line.
+       Output_Object.Output_Buffer_Len := 0;
+        Output_Object.Font := ARM_Output.Default;
+        Output_Object.Is_Bold := False;
+        Output_Object.Is_Italic := False;
+        Output_Object.Size := 0;
+        Output_Object.Para_Style := Style;
+        Output_Object.Para_Indent := Indent;
+        Output_Object.Is_Fixed_Format := False;
+
+       if Output_Object.Clause_Len /= 0 and then
+          Number /= "" then
+           Ada.Text_IO.New_Line (Output_Object.Output_File);
+           Ada.Text_IO.Put (Output_Object.Output_File, "!paragraph ");
+           Ada.Text_IO.Put (Output_Object.Output_File, 
Output_Object.Clause_Num(1..Output_Object.Clause_Len));
+           Ada.Text_IO.Put (Output_Object.Output_File, '(');
+           Ada.Text_IO.Put (Output_Object.Output_File, Number);
+           Ada.Text_IO.Put (Output_Object.Output_File, ") [");
+           Ada.Text_IO.Put (Output_Object.Output_File, 
ARM_Output.Paragraph_Style_Type'Image(Style) &
+                       " :" & ARM_Output.Paragraph_Indent_Type'Image(Indent));
+           Ada.Text_IO.Put_Line (Output_Object.Output_File, "]");
+           Ada.Text_IO.New_Line (Output_Object.Output_File);
+       else
+           Ada.Text_IO.New_Line (Output_Object.Output_File);
+       end if;
+
+        Output_Object.Indent_Amount := Integer(Indent)*4 + 2;
+
+       case Style is
+           when ARM_Output.Normal =>
+               if Indent = 0 then
+                   null; -- %% Temp.
+                   Output_Object.Indent_Amount := 0; -- %% Temp.
+               elsif Indent = 3 then
+                   Ada.Text_IO.Put (Output_Object.Output_File, "@xindent<");
+                   Output_Object.Char_Count := 9;
+                   Output_Object.Indent_Amount := 0; -- %% Temp.
+               else -- Unknown case.
+                   null; -- ** Tbd.
+               end if;
+           when ARM_Output.Wide_Above => null;
+               if Indent = 0 then
+                   null; -- %% Temp.
+                   Output_Object.Indent_Amount := 0; -- %% Temp.
+               else -- Unknown case.
+                   null; -- ** Tbd.
+               end if;
+
+           when ARM_Output.Small =>
+               if Indent = 1 then -- Notes.
+                   Ada.Text_IO.Put (Output_Object.Output_File, 
"@xindent<@s9<");
+                   Output_Object.Char_Count := 13;
+                   Output_Object.Indent_Amount := 0; -- %% Temp.
+               else -- Unknown case.
+                   null; -- ** Tbd.
+               end if;
+           when ARM_Output.Small_Wide_Above =>
+               null; -- ** TBD (Unknown cases).
+
+           when ARM_Output.Header =>
+               null; -- ** TBD (Unknown cases).
+
+           when ARM_Output.Small_Header =>
+               if Indent = 1 then -- Notes Header.
+                   null;
+                   --Output_Object.Indent_Amount := 6; --** TBD.
+               else -- Unknown case.
+                   null; -- ** Tbd.
+               end if;
+
+           when ARM_Output.Index => null; --** TBD.
+           when ARM_Output.Syntax_Summary => null; --** TBD.
+           when ARM_Output.Title =>
+               null; -- ** TBD (Unknown cases).
+
+           when ARM_Output.Examples =>
+               if Indent = 1 then
+                   Ada.Text_IO.Put (Output_Object.Output_File, "@xcode<");
+                   Output_Object.Char_Count := 7;
+                   Output_Object.Is_Fixed_Format := True;
+                   Output_Object.Indent_Amount := 0; -- %% Temp.
+               else -- Unknown case.
+                   null; -- ** Tbd.
+               end if;
+
+           when ARM_Output.Small_Examples => null; --** TBD.
+
+           when ARM_Output.Swiss_Examples =>
+               if Indent = 1 then
+                   Ada.Text_IO.Put (Output_Object.Output_File, "@xcode<");
+                   Output_Object.Char_Count := 7;
+                   Output_Object.Is_Fixed_Format := True;
+                   Output_Object.Indent_Amount := 0; -- %% Temp.
+               else -- Unknown case.
+                   null; -- ** Tbd.
+               end if;
+
+           when ARM_Output.Small_Swiss_Examples => null; --** TBD.
+
+           when ARM_Output.Bulleted =>
+               if Indent = 1 then
+                   Output_Object.Indent_Amount := 0; -- %% Temp.
+                   if No_Prefix then
+                       Ada.Text_IO.Put (Output_Object.Output_File, 
"@xindent<");
+                       Output_Object.Char_Count := 9;
+                   else
+                       Ada.Text_IO.Put (Output_Object.Output_File, 
"@xbullet<");
+                       Output_Object.Char_Count := 9;
+                   end if;
+               else -- Unknown/unimplemented case.
+                   null; -- ** Tbd.
+               end if;
+
+           when ARM_Output.Nested_Bulleted => null; --** TBD.
+
+           when ARM_Output.Small_Bulleted => null; --** TBD.
+
+           when ARM_Output.Small_Nested_Bulleted => null; --** TBD.
+
+           when ARM_Output.Giant_Hanging => null; --** TBD.
+
+           when ARM_Output.Wide_Hanging =>
+               if Indent = 3 then
+                   Output_Object.Indent_Amount := 0; -- %% Temp.
+                   Output_Object.Is_Hanging := True;
+                   if No_Prefix then
+                       Output_Object.Saw_Hang_End := True;
+                       Output_Object.Char_Count := 0;
+                   else -- Has prefix
+                       -- No units on first line.
+                       Output_Object.Saw_Hang_End := False;
+                       Ada.Text_IO.Put (Output_Object.Output_File, 
"@xhang<@xterm<");
+                       Output_Object.Char_Count := 14;
+                   end if;
+               else -- Unknown/unimplemented case.
+                   null; -- ** Tbd.
+               end if;
+
+           when ARM_Output.Medium_Hanging => null; --** TBD.
+
+           when ARM_Output.Narrow_Hanging => null; --** TBD.
+
+           when ARM_Output.Hanging_in_Bulleted => null; --** TBD.
+
+           when ARM_Output.Small_Giant_Hanging => null; --** TBD.
+
+           when ARM_Output.Small_Wide_Hanging => null; --** TBD.
+
+           when ARM_Output.Small_Medium_Hanging => null; --** TBD.
+
+           when ARM_Output.Small_Narrow_Hanging => null; --** TBD.
+
+           when ARM_Output.Small_Hanging_in_Bulleted => null; --** TBD.
+
+           when ARM_Output.Enumerated => null; --** TBD.
+
+           when ARM_Output.Small_Enumerated => null; --** TBD.
+
+       end case;
+
+       if Output_Object.Indent_Amount > 6 then
+           for I in 1 .. (Output_Object.Indent_Amount-6)/4 loop
+               Ada.Text_IO.Put (Output_Object.Output_File, "    ");
+               Output_Object.Char_Count := Output_Object.Char_Count + 4;
+           end loop;
+       end if;
+
+       case Style is
+           when ARM_Output.Normal | ARM_Output.Wide_Above |
+                ARM_Output.Small | ARM_Output.Small_Wide_Above |
+                ARM_Output.Header | ARM_Output.Small_Header |
+                ARM_Output.Index | ARM_Output.Syntax_Summary |
+                ARM_Output.Title |
+                ARM_Output.Examples | ARM_Output.Small_Examples |
+                ARM_Output.Swiss_Examples | ARM_Output.Small_Swiss_Examples =>
+               Output_Object.Tab_Stops := Tab_Stops;
+                   -- We'll expand proportional stops here (text characters
+                   -- are larger than the variable ones these are set up for).
+               for I in 1 .. Tab_Stops.Number loop
+                   if ARM_Output."=" (Tab_Stops.Stops(I).Kind,
+                                      ARM_Output.Left_Proportional) then
+                       Output_Object.Tab_Stops.Stops(I).Stop :=
+                               (Tab_Stops.Stops(I).Stop * 5 / 4) + 
Output_Object.Indent_Amount;
+                   else
+                       Output_Object.Tab_Stops.Stops(I).Stop :=
+                               Tab_Stops.Stops(I).Stop + 
Output_Object.Indent_Amount;
+                   end if;
+               end loop;
+           when ARM_Output.Bulleted | ARM_Output.Nested_Bulleted |
+                ARM_Output.Small_Bulleted | ARM_Output.Small_Nested_Bulleted |
+                ARM_Output.Giant_Hanging | ARM_Output.Wide_Hanging |
+                ARM_Output.Medium_Hanging | ARM_Output.Narrow_Hanging |
+                ARM_Output.Hanging_in_Bulleted |
+                ARM_Output.Small_Giant_Hanging | ARM_Output.Small_Wide_Hanging 
|
+                ARM_Output.Small_Medium_Hanging | 
ARM_Output.Small_Narrow_Hanging |
+                ARM_Output.Small_Hanging_in_Bulleted |
+                ARM_Output.Enumerated | ARM_Output.Small_Enumerated =>
+               if Tab_Stops.Number /= 0 then
+                   Ada.Exceptions.Raise_Exception 
(ARM_Output.Not_Valid_Error'Identity,
+                       "Tabs in hanging/bulleted paragraph");
+               end if;
+       end case;
+       Output_Object.Out_Char_Count := Output_Object.Char_Count;
+
+       -- Note: No_Breaks, Keep_with_Next, and Justification have no effect
+       -- here.
+--Ada.Text_IO.Put_Line ("Start_Paragraph - Indent=" & 
Natural'Image(Output_Object.Indent_Amount) & " Cnt=" &
+--    Natural'Image(Output_Object.Char_Count));
+    end Start_Paragraph;
+
+
+    procedure End_Paragraph (Output_Object : in out Corr_Output_Type) is
+       -- End a paragraph.
+       use type ARM_Output.Paragraph_Indent_Type;
+    begin
+       if not Output_Object.Is_Valid then
+           Ada.Exceptions.Raise_Exception (ARM_Output.Not_Valid_Error'Identity,
+               "Not valid object");
+       end if;
+       if not Output_Object.Is_In_Paragraph then
+           Ada.Exceptions.Raise_Exception (ARM_Output.Not_Valid_Error'Identity,
+               "Not in paragraph");
+       end if;
+       case Output_Object.Para_Style is
+           when ARM_Output.Normal =>
+               if Output_Object.Para_Indent = 0 then
+                   null;
+               elsif Output_Object.Para_Indent = 3 then
+                   Buffer (Output_Object, '>');
+               else -- Unknown case.
+                   null; -- ** Tbd.
+               end if;
+           when ARM_Output.Wide_Above => null;
+               if Output_Object.Para_Indent = 0 then
+                   null; -- %% Temp.
+               else -- Unknown case.
+                   null; -- ** Tbd.
+               end if;
+
+           when ARM_Output.Small =>
+               if Output_Object.Para_Indent = 1 then -- Notes.
+                   Buffer (Output_Object, ">>");
+               else -- Unknown case.
+                   null; -- ** Tbd.
+               end if;
+           when ARM_Output.Small_Wide_Above =>
+               null; -- ** TBD (Unknown cases).
+
+           when ARM_Output.Header =>
+               null; -- ** TBD (Unknown cases).
+
+           when ARM_Output.Small_Header =>
+               if Output_Object.Para_Indent = 1 then -- Notes Header.
+                   null;
+               else -- Unknown case.
+                   null; -- ** Tbd.
+               end if;
+
+           when ARM_Output.Index => null; --** TBD.
+           when ARM_Output.Syntax_Summary => null; --** TBD.
+           when ARM_Output.Title => null; --** TBD.
+           when ARM_Output.Examples =>
+               if Output_Object.Para_Indent = 1 then
+                   Buffer (Output_Object, '>');
+               else -- Unknown case.
+                   null; -- ** Tbd.
+               end if;
+
+           when ARM_Output.Small_Examples => null; --** TBD.
+
+           when ARM_Output.Swiss_Examples =>
+               if Output_Object.Para_Indent = 1 then
+                   Buffer (Output_Object, '>');
+               else -- Unknown case.
+                   null; -- ** Tbd.
+               end if;
+
+           when ARM_Output.Small_Swiss_Examples => null; --** TBD.
+
+           when ARM_Output.Bulleted =>
+               if Output_Object.Para_Indent = 1 then
+                   Buffer (Output_Object, '>');
+               else -- Unknown/unimplemented case.
+                   null; -- ** Tbd.
+               end if;
+
+           when ARM_Output.Nested_Bulleted => null; --** TBD.
+
+           when ARM_Output.Small_Bulleted => null; --** TBD.
+
+           when ARM_Output.Small_Nested_Bulleted => null; --** TBD.
+
+           when ARM_Output.Giant_Hanging => null; --** TBD.
+
+           when ARM_Output.Wide_Hanging =>
+               if Output_Object.Para_Indent = 3 then
+                   Buffer (Output_Object, '>');
+               else -- Unknown/unimplemented case.
+                   null; -- ** Tbd.
+               end if;
+
+           when ARM_Output.Medium_Hanging => null; --** TBD.
+
+           when ARM_Output.Narrow_Hanging => null; --** TBD.
+
+           when ARM_Output.Hanging_in_Bulleted => null; --** TBD.
+
+           when ARM_Output.Small_Giant_Hanging => null; --** TBD.
+
+           when ARM_Output.Small_Wide_Hanging => null; --** TBD.
+
+           when ARM_Output.Small_Medium_Hanging => null; --** TBD.
+
+           when ARM_Output.Small_Narrow_Hanging => null; --** TBD.
+
+           when ARM_Output.Small_Hanging_in_Bulleted => null; --** TBD.
+
+           when ARM_Output.Enumerated => null; --** TBD.
+
+           when ARM_Output.Small_Enumerated => null; --** TBD.
+
+       end case;
+
+       if Output_Object.Output_Buffer_Len /= 0 then
+           Spill (Output_Object);
+       end if;
+       Output_Object.Is_In_Paragraph := False;
+       Ada.Text_IO.New_Line (Output_Object.Output_File, 2); -- Double space 
paragraphs.
+    end End_Paragraph;
+
+
+    procedure Category_Header (Output_Object : in out Corr_Output_Type;
+                              Header_Text : String) is
+       -- Output a Category header (that is, "Legality Rules",
+       -- "Dynamic Semantics", etc.)
+       -- (Note: We did not use a enumeration here to insure that these
+       -- headers are spelled the same in all output versions).
+       -- Raises Not_Valid_Error if in a paragraph.
+    begin
+       if not Output_Object.Is_Valid then
+           Ada.Exceptions.Raise_Exception (ARM_Output.Not_Valid_Error'Identity,
+               "Not valid object");
+       end if;
+       if Output_Object.Is_In_Paragraph then
+           Ada.Exceptions.Raise_Exception (ARM_Output.Not_Valid_Error'Identity,
+               "Header in paragraph");
+       end if;
+       Ada.Text_IO.New_Line (Output_Object.Output_File);
+       Ada.Text_IO.Put_Line (Output_Object.Output_File, "!subheader");
+       Ada.Text_IO.Put (Output_Object.Output_File, "@i<@s8<");
+       if Ada.Strings.Fixed.Count (Header_Text, Special_Set) = 0 then
+            Ada.Text_IO.Put (Output_Object.Output_File, Header_Text);
+       else
+           for I in Header_Text'Range loop
+               if Header_Text(I) = '>' then
+                   Ada.Text_IO.Put (Output_Object.Output_File, "@>");
+               elsif Header_Text(I) = '@' then
+                   Ada.Text_IO.Put (Output_Object.Output_File, "@@");
+               else
+                   Ada.Text_IO.Put (Output_Object.Output_File, Header_Text(I));
+               end if;
+           end loop;
+       end if;
+       Ada.Text_IO.Put (Output_Object.Output_File, ">>");
+       Ada.Text_IO.New_Line (Output_Object.Output_File);
+       Output_Object.Char_Count := 0;
+       Output_Object.Out_Char_Count := 0;
+    end Category_Header;
+
+
+    procedure Clause_Header (Output_Object     : in out Corr_Output_Type;
+                            Header_Text       : in String;
+                            Level             : in ARM_Contents.Level_Type;
+                            Clause_Number     : in String;
+                            Top_Level_Subdivision_Name : in 
ARM_Output.Top_Level_Subdivision_Name_Kind;
+                            No_Page_Break     : in Boolean := False) is
+       -- Output a Clause header. The level of the header is specified
+       -- in Level. The Clause Number is as specified; the top-level (and
+       -- other) subdivision names are as specified. These should appear in
+       -- the table of contents.
+       -- For hyperlinked formats, this should generate a link target.
+       -- If No_Page_Break is True, suppress any page breaks.
+       -- Raises Not_Valid_Error if in a paragraph.
+    begin
+       if not Output_Object.Is_Valid then
+           Ada.Exceptions.Raise_Exception (ARM_Output.Not_Valid_Error'Identity,
+               "Not valid object");
+       end if;
+       if Output_Object.Is_In_Paragraph then
+           Ada.Exceptions.Raise_Exception (ARM_Output.Not_Valid_Error'Identity,
+               "Header in paragraph");
+       end if;
+        Ada.Text_IO.New_Line (Output_Object.Output_File);
+
+       Output_Object.Clause_Len := Clause_Number'Length;
+       Output_Object.Clause_Num(1..Output_Object.Clause_Len) :=
+           Clause_Number;
+       -- Special for table of contents:
+       if Clause_Number = "" and then
+               (Header_Text = "Table of Contents" or else
+                Header_Text = "Contents") then
+           Ada.Text_IO.Put (Output_Object.Output_File,
+                              "!clause ");
+           Ada.Text_IO.Put_Line (Output_Object.Output_File,
+                              Header_Text);
+           Ada.Text_IO.New_Line (Output_Object.Output_File, 2);
+           Output_Object.Char_Count := 0;
+           Output_Object.Out_Char_Count := 0;
+           return;
+       end if;
+
+        Ada.Text_IO.Put (Output_Object.Output_File,
+                        "!clause ");
+       case Level is
+           when ARM_Contents.Plain_Annex =>
+               Ada.Text_IO.Put_Line (Output_Object.Output_File,
+                                  Clause_Number); -- Note: Clause_Number 
includes "Annex"
+               Ada.Text_IO.Put_Line (Output_Object.Output_File,
+                                  Header_Text);
+           when ARM_Contents.Normative_Annex =>
+               Ada.Text_IO.Put_Line (Output_Object.Output_File,
+                                  Clause_Number); -- Note: Clause_Number 
includes "Annex"
+               Ada.Text_IO.Put_Line (Output_Object.Output_File,
+                                  "(normative)");
+               Ada.Text_IO.New_Line (Output_Object.Output_File);
+               Ada.Text_IO.Put_Line (Output_Object.Output_File,
+                                  Header_Text);
+           when ARM_Contents.Informative_Annex =>
+               Ada.Text_IO.Put_Line (Output_Object.Output_File,
+                                  Clause_Number); -- Note: Clause_Number 
includes "Annex"
+               Ada.Text_IO.Put_Line (Output_Object.Output_File,
+                                  "(informative)");
+               Ada.Text_IO.New_Line (Output_Object.Output_File);
+               Ada.Text_IO.Put_Line (Output_Object.Output_File,
+                                  Header_Text);
+           when ARM_Contents.Section =>
+               case Top_Level_Subdivision_Name is
+                   when ARM_Output.Chapter =>
+                       Ada.Text_IO.Put_Line (Output_Object.Output_File,
+                                             "Chapter " & Clause_Number & ": " 
& Header_Text);
+                   when ARM_Output.Section =>
+                       Ada.Text_IO.Put_Line (Output_Object.Output_File,
+                                             "Section " & Clause_Number & ": " 
& Header_Text);
+                   when ARM_Output.Clause =>
+                       Ada.Text_IO.Put_Line (Output_Object.Output_File,
+                                             Clause_Number & "   " & 
Header_Text);
+               end case;
+           when ARM_Contents.Unnumbered_Section =>
+               if Header_Text /= "" then
+                   Ada.Text_IO.Put_Line (Output_Object.Output_File,
+                                      Header_Text);
+               end if;
+           when ARM_Contents.Clause | ARM_Contents.Subclause |
+                ARM_Contents.Subsubclause =>
+               Ada.Text_IO.Put_Line (Output_Object.Output_File,
+                                     Clause_Number & ' ' & Header_Text);
+           when ARM_Contents.Dead_Clause =>
+               raise Program_Error; -- No headers for dead clauses.
+       end case;
+       Ada.Text_IO.New_Line (Output_Object.Output_File, 2);
+       Output_Object.Char_Count := 0;
+       Output_Object.Out_Char_Count := 0;
+       -- We don't have any page breaks here to suppress.
+    end Clause_Header;
+
+
+    procedure Revised_Clause_Header
+                           (Output_Object     : in out Corr_Output_Type;
+                            New_Header_Text   : in String;
+                            Old_Header_Text   : in String;
+                            Level             : in ARM_Contents.Level_Type;
+                            Clause_Number     : in String;
+                            Version           : in 
ARM_Contents.Change_Version_Type;
+                            Old_Version       : in 
ARM_Contents.Change_Version_Type;
+                            Top_Level_Subdivision_Name : in 
ARM_Output.Top_Level_Subdivision_Name_Kind;
+                            No_Page_Break     : in Boolean := False) is
+       -- Output a revised clause header. Both the original and new text will
+       -- be output. The level of the header is specified in Level. The Clause
+       -- Number is as specified; the top-level (and other) subdivision names
+       -- are as specified. These should appear in the table of contents.
+       -- For hyperlinked formats, this should generate a link target.
+       -- Version is the insertion version of the new text; Old_Version is
+       -- the insertion version of the old text.
+       -- If No_Page_Break is True, suppress any page breaks.
+       -- Raises Not_Valid_Error if in a paragraph.
+       function Header_Text return String is
+           -- Note: Version and Old_Version are not used.
+       begin
+           return '{' & New_Header_Text & "} [" & Old_Header_Text & ']';
+       end Header_Text;
+    begin
+       if not Output_Object.Is_Valid then
+           Ada.Exceptions.Raise_Exception (ARM_Output.Not_Valid_Error'Identity,
+               "Not valid object");
+       end if;
+       if Output_Object.Is_In_Paragraph then
+           Ada.Exceptions.Raise_Exception (ARM_Output.Not_Valid_Error'Identity,
+               "Header in paragraph");
+       end if;
+        Ada.Text_IO.New_Line (Output_Object.Output_File);
+
+       Output_Object.Clause_Len := Clause_Number'Length;
+       Output_Object.Clause_Num(1..Output_Object.Clause_Len) :=
+           Clause_Number;
+       -- Special for table of contents:
+       if Clause_Number = "" and then
+               (Header_Text = "Table of Contents" or else -- Ada 95 format
+                Header_Text = "Contents") then -- ISO 2004 format.
+            Ada.Text_IO.Put (Output_Object.Output_File,
+                            "!clause ");
+           Ada.Text_IO.Put_Line (Output_Object.Output_File,
+                              Header_Text);
+           Ada.Text_IO.New_Line (Output_Object.Output_File, 2);
+           Output_Object.Char_Count := 0;
+           Output_Object.Out_Char_Count := 0;
+           return;
+       end if;
+
+        Ada.Text_IO.Put (Output_Object.Output_File,
+                        "!clause ");
+       case Level is
+           when ARM_Contents.Plain_Annex =>
+               Ada.Text_IO.Put_Line (Output_Object.Output_File,
+                                  Clause_Number); -- Note: Clause_Number 
includes "Annex"
+               Ada.Text_IO.Put_Line (Output_Object.Output_File,
+                                  Header_Text);
+           when ARM_Contents.Normative_Annex =>
+               Ada.Text_IO.Put_Line (Output_Object.Output_File,
+                                  Clause_Number); -- Note: Clause_Number 
includes "Annex"
+               Ada.Text_IO.Put_Line (Output_Object.Output_File,
+                                  "(normative)");
+               Ada.Text_IO.New_Line (Output_Object.Output_File);
+               Ada.Text_IO.Put_Line (Output_Object.Output_File,
+                                  Header_Text);
+           when ARM_Contents.Informative_Annex =>
+               Ada.Text_IO.Put_Line (Output_Object.Output_File,
+                                  Clause_Number); -- Note: Clause_Number 
includes "Annex"
+               Ada.Text_IO.Put_Line (Output_Object.Output_File,
+                                  "(informative)");
+               Ada.Text_IO.New_Line (Output_Object.Output_File);
+               Ada.Text_IO.Put_Line (Output_Object.Output_File,
+                                  Header_Text);
+           when ARM_Contents.Section =>
+               case Top_Level_Subdivision_Name is
+                   when ARM_Output.Chapter =>
+                       Ada.Text_IO.Put_Line (Output_Object.Output_File,
+                                             "Chapter " & Clause_Number & ": " 
& Header_Text);
+                   when ARM_Output.Section =>
+                       Ada.Text_IO.Put_Line (Output_Object.Output_File,
+                                             "Section " & Clause_Number & ": " 
& Header_Text);
+                   when ARM_Output.Clause =>
+                       Ada.Text_IO.Put_Line (Output_Object.Output_File,
+                                             Clause_Number & "   " & 
Header_Text);
+               end case;
+
+           when ARM_Contents.Unnumbered_Section =>
+               if Header_Text /= "" then
+                   Ada.Text_IO.Put_Line (Output_Object.Output_File,
+                                      Header_Text);
+               end if;
+           when ARM_Contents.Clause | ARM_Contents.Subclause |
+                ARM_Contents.Subsubclause =>
+               Ada.Text_IO.Put_Line (Output_Object.Output_File,
+                                     Clause_Number & ' ' & Header_Text);
+           when ARM_Contents.Dead_Clause =>
+               raise Program_Error; -- No headers for dead clauses.
+       end case;
+       Ada.Text_IO.New_Line (Output_Object.Output_File, 2);
+       Output_Object.Char_Count := 0;
+       Output_Object.Out_Char_Count := 0;
+       -- We don't have any page breaks here to suppress.
+    end Revised_Clause_Header;
+
+
+    procedure TOC_Marker (Output_Object : in out Corr_Output_Type;
+                         For_Start : in Boolean) is
+       -- Mark the start (if For_Start is True) or end (if For_Start is
+       -- False) of the table of contents data. Output objects that
+       -- auto-generate the table of contents can use this to do needed
+       -- actions.
+    begin
+       if not Output_Object.Is_Valid then
+           Ada.Exceptions.Raise_Exception (ARM_Output.Not_Valid_Error'Identity,
+               "Not valid object");
+       end if;
+       null; -- We don't care about this.
+    end TOC_Marker;
+
+
+    procedure New_Page (Output_Object : in out Corr_Output_Type;
+                       Kind : ARM_Output.Page_Kind_Type := 
ARM_Output.Any_Page) is
+       -- Output a page break.
+       -- Note that this has no effect on non-printing formats.
+       -- Any_Page breaks to the top of the next page (whatever it is);
+       -- Odd_Page_Only breaks to the top of the odd-numbered page;
+       -- Soft_Page allows a page break but does not force one (use in
+       -- "No_Breaks" paragraphs.)
+       -- Raises Not_Valid_Error if in a paragraph if Kind = Any_Page or
+       -- Odd_Page, and if not in a paragraph if Kind = Soft_Page.
+    begin
+       if not Output_Object.Is_Valid then
+           Ada.Exceptions.Raise_Exception (ARM_Output.Not_Valid_Error'Identity,
+               "Not valid object");
+       end if;
+       case Kind is
+           when ARM_Output.Any_Page | ARM_Output.Odd_Page_Only =>
+               if Output_Object.Is_In_Paragraph then
+                   Ada.Exceptions.Raise_Exception 
(ARM_Output.Not_Valid_Error'Identity,
+                       "Page in paragraph");
+               end if;
+               Ada.Text_IO.New_Line (Output_Object.Output_File, 2);
+           when ARM_Output.Soft_Page =>
+               if not Output_Object.Is_In_Paragraph then
+                   Ada.Exceptions.Raise_Exception 
(ARM_Output.Not_Valid_Error'Identity,
+                       "Soft page not in paragraph");
+               end if;
+               null; -- No page breaks.
+               Spill (Output_Object);
+       end case;
+    end New_Page;
+
+
+    procedure New_Column (Output_Object : in out Corr_Output_Type) is
+       -- Output a column break.
+       -- Raises Not_Valid_Error if in a paragraph, or if the number of
+       -- columns is 1.
+    begin
+       if not Output_Object.Is_Valid then
+           Ada.Exceptions.Raise_Exception (ARM_Output.Not_Valid_Error'Identity,
+               "Not valid object");
+       end if;
+       if Output_Object.Is_In_Paragraph then
+           Ada.Exceptions.Raise_Exception (ARM_Output.Not_Valid_Error'Identity,
+               "New column in paragraph");
+       end if;
+       -- No columns in text format.
+       Ada.Text_IO.New_Line (Output_Object.Output_File);
+    end New_Column;
+
+
+    procedure Start_Table (Output_Object : in out Corr_Output_Type;
+                          Columns : in ARM_Output.Column_Count;
+                          First_Column_Width : in ARM_Output.Column_Count;
+                          Last_Column_Width : in ARM_Output.Column_Count;
+                          Alignment : in ARM_Output.Column_Text_Alignment;
+                          No_Page_Break : in Boolean;
+                          Has_Border : in Boolean;
+                          Small_Text_Size : in Boolean;
+                          Header_Kind : in ARM_Output.Header_Kind_Type) is
+       -- Starts a table. The number of columns is Columns; the first
+       -- column has First_Column_Width times the normal column width, and
+       -- the last column has Last_Column_Width times the normal column width.
+       -- Alignment is the horizontal text alignment within the columns.
+       -- No_Page_Break should be True to keep the table intact on a single
+       -- page; False to allow it to be split across pages.
+       -- Has_Border should be true if a border is desired, false otherwise.
+       -- Small_Text_Size means that the contents will have the AARM size;
+       -- otherwise it will have the normal size.
+       -- Header_Kind determines whether the table has headers.
+       -- This command starts a paragraph; the entire table is a single
+       -- paragraph. Text will be considered part of the caption until the
+       -- next table marker call.
+       -- Raises Not_Valid_Error if in a paragraph.
+    begin
+       -- Alignment, No_Page_Break, Border, Small_Text_Size, and Header_Kind
+       -- not used here.
+       if not Output_Object.Is_Valid then
+           Ada.Exceptions.Raise_Exception (ARM_Output.Not_Valid_Error'Identity,
+               "Not valid object");
+       end if;
+       if Output_Object.Is_In_Paragraph then
+           Ada.Exceptions.Raise_Exception (ARM_Output.Not_Valid_Error'Identity,
+               "Table in paragraph");
+       end if;
+
+       Output_Object.Tab_Stops.Number := Columns;
+       declare
+            Column_Units : constant ARM_Output.Column_Count :=
+               Columns+First_Column_Width+Last_Column_Width-2;
+            Width : Natural :=
+               (72/(Column_Units));
+       begin
+           if Column_Units <= 3 then -- Keep it from getting too wide.
+               Width := 22;
+           end if;
+           for I in 1 .. Columns loop
+               Output_Object.Tab_Stops.Stops(I) := (Kind => 
ARM_Output.Left_Fixed,
+                                                    Stop => 
Width*(I+First_Column_Width-1)+10);
+           end loop;
+       end;
+
+       Output_Object.Indent_Amount := 10;
+        Ada.Text_IO.Put (Output_Object.Output_File, "          ");
+       Output_Object.Char_Count := 10;
+       Output_Object.Out_Char_Count := 10;
+
+       Output_Object.Is_In_Paragraph := True;
+       Output_Object.Is_In_Table := True;
+    end Start_Table;
+
+
+    procedure Table_Marker (Output_Object : in out Corr_Output_Type;
+                           Marker : in ARM_Output.Table_Marker_Type) is
+       -- Marks the end of an entity in a table.
+       -- If Marker is End_Caption, the table caption ends and the
+       --      future text is part of the table header.
+       -- If Marker is End_Header, the table header ends and the
+       --      future text is part of the table body.
+       -- If Marker is End_Row, a row in the table is completed, and another
+       --      row started.
+       -- If Marker is End_Row_Next_Is_Last, a row in the table is completed,
+       --      and another row started. That row is the last row in the table.
+       -- If Marker is End_Item, an item in the table header or body is ended,
+       --      and another started.
+       -- If Marker is End_Table, the entire table is finished.
+       -- Raises Not_Valid_Error if not in a table.
+    begin
+       if not Output_Object.Is_Valid then
+           Ada.Exceptions.Raise_Exception (ARM_Output.Not_Valid_Error'Identity,
+               "Not valid object");
+       end if;
+       if (not Output_Object.Is_In_Paragraph) or (not 
Output_Object.Is_In_Table) then
+           Ada.Exceptions.Raise_Exception (ARM_Output.Not_Valid_Error'Identity,
+               "Table marker not in table");
+       end if;
+       case Marker is
+           when ARM_Output.End_Item =>
+               -- Just tab over one row:
+               Spill (Output_Object);
+               Ada.Text_IO.Put_Line (Output_Object.Output_File, " ");
+               Output_Object.Char_Count := Output_Object.Char_Count + 1;
+               Output_Object.Out_Char_Count := Output_Object.Out_Char_Count + 
1;
+               for I in 1 .. Output_Object.Tab_Stops.Number loop
+                   if Output_Object.Tab_Stops.Stops(I).Stop > 
Output_Object.Char_Count then
+                       for J in Output_Object.Char_Count+1 .. 
Output_Object.Tab_Stops.Stops(I).Stop-1 loop
+                           Ada.Text_IO.Put_Line (Output_Object.Output_File, " 
");
+                           Output_Object.Char_Count := 
Output_Object.Char_Count + 1;
+                           Output_Object.Out_Char_Count := 
Output_Object.Out_Char_Count + 1;
+                       end loop;
+                   end if;
+               end loop;
+
+           when ARM_Output.End_Caption =>
+               Spill (Output_Object);
+               Ada.Text_IO.New_Line (Output_Object.Output_File, 2);
+               Ada.Text_IO.Put (Output_Object.Output_File, "          ");
+               Output_Object.Char_Count := 10;
+               Output_Object.Out_Char_Count := 10;
+           when ARM_Output.End_Header =>
+               Spill (Output_Object);
+               Ada.Text_IO.New_Line (Output_Object.Output_File, 2);
+               Ada.Text_IO.Put (Output_Object.Output_File, "          ");
+               Output_Object.Char_Count := 10;
+               Output_Object.Out_Char_Count := 10;
+           when ARM_Output.End_Row | ARM_Output.End_Row_Next_Is_Last =>
+               Spill (Output_Object);
+               Ada.Text_IO.New_Line (Output_Object.Output_File, 1);
+               Ada.Text_IO.Put (Output_Object.Output_File, "          ");
+               Output_Object.Char_Count := 10;
+               Output_Object.Out_Char_Count := 10;
+           when ARM_Output.End_Table =>
+               Spill (Output_Object);
+               Output_Object.Is_In_Paragraph := False;
+               Output_Object.Is_In_Table := False;
+               Ada.Text_IO.New_Line (Output_Object.Output_File);
+               Output_Object.Tab_Stops := ARM_Output.NO_TABS;
+       end case;
+    end Table_Marker;
+
+
+    procedure Separator_Line (Output_Object : in out Corr_Output_Type;
+                             Is_Thin : Boolean := True) is
+       -- Output a separator line. It is thin if "Is_Thin" is true.
+       -- Raises Not_Valid_Error if in a paragraph.
+    begin
+       if not Output_Object.Is_Valid then
+           Ada.Exceptions.Raise_Exception (ARM_Output.Not_Valid_Error'Identity,
+               "Not valid object");
+       end if;
+       if Output_Object.Is_In_Paragraph then
+           Ada.Exceptions.Raise_Exception (ARM_Output.Not_Valid_Error'Identity,
+               "Separator in paragraph");
+       end if;
+       Ada.Text_IO.New_Line (Output_Object.Output_File);
+       if Is_Thin then
+           Ada.Text_IO.Put_Line (Output_Object.Output_File, 
"---------------------------------------------------------------------");
+       else
+           Ada.Text_IO.Put_Line (Output_Object.Output_File, 
"=====================================================================");
+       end if;
+       Ada.Text_IO.New_Line (Output_Object.Output_File);
+    end Separator_Line;
+
+
+    -- Text output: These are only allowed after a Start_Paragraph and
+    -- before any End_Paragraph. Raises Not_Valid_Error if not allowed.
+
+    procedure Ordinary_Text (Output_Object : in out Corr_Output_Type;
+                            Text : in String) is
+       -- Output ordinary text.
+       -- The text must end at a word break, never in the middle of a word.
+    begin
+       if not Output_Object.Is_Valid then
+           Ada.Exceptions.Raise_Exception (ARM_Output.Not_Valid_Error'Identity,
+               "Not valid object");
+       end if;
+       if not Output_Object.Is_In_Paragraph then
+           Ada.Exceptions.Raise_Exception (ARM_Output.Not_Valid_Error'Identity,
+               "Not in paragraph");
+       end if;
+--Ada.Text_IO.Put_Line ("Ordinary_Text: Cnt=" & 
Natural'Image(Output_Object.Char_Count) &
+--" Buffer=" & Natural'Image(Output_Object.Output_Buffer_Len));
+       if Output_Object.Char_Count + Text'Length >= LINE_LENGTH - 2 and then
+          Output_Object.Out_Char_Count > Output_Object.Indent_Amount then
+           -- We want a line break here if the line is too long and something 
was output:
+           Ada.Text_IO.New_Line (Output_Object.Output_File);
+           Make_Indent (Output_Object);
+           --Output_Object.Output_Buffer_Space_Before := False;
+               -- Start of line, this is done by Make_Indent.
+           Spill (Output_Object);
+       else
+           Spill (Output_Object);
+       end if;
+       if Ada.Strings.Fixed.Count (Text, Special_Set) = 0 then
+            Ada.Text_IO.Put (Output_Object.Output_File, Text);
+            Output_Object.Char_Count := Output_Object.Char_Count + Text'Length;
+            Output_Object.Out_Char_Count := Output_Object.Out_Char_Count + 
Text'Length;
+       else
+           for I in Text'Range loop
+               if Text(I) = '>' then
+                   Ada.Text_IO.Put (Output_Object.Output_File, "@>");
+                   Output_Object.Char_Count := Output_Object.Char_Count + 2;
+                   Output_Object.Out_Char_Count := 
Output_Object.Out_Char_Count + 2;
+               elsif Text(I) = '@' then
+                   Ada.Text_IO.Put (Output_Object.Output_File, "@@");
+                   Output_Object.Char_Count := Output_Object.Char_Count + 2;
+                   Output_Object.Out_Char_Count := 
Output_Object.Out_Char_Count + 2;
+               else
+                   Ada.Text_IO.Put (Output_Object.Output_File, Text(I));
+                   Output_Object.Char_Count := Output_Object.Char_Count + 1;
+                   Output_Object.Out_Char_Count := 
Output_Object.Out_Char_Count + 1;
+               end if;
+           end loop;
+       end if;
+        Output_Object.Output_Buffer_Space_Before := False; -- No space between
+                                                          -- this and any 
following text.
+    end Ordinary_Text;
+
+
+    procedure Ordinary_Character (Output_Object : in out Corr_Output_Type;
+                                 Char : in Character) is
+       -- Output an ordinary character.
+       -- Spaces will be used to break lines as needed.
+    begin
+       if not Output_Object.Is_Valid then
+           Ada.Exceptions.Raise_Exception (ARM_Output.Not_Valid_Error'Identity,
+               "Not valid object");
+       end if;
+       if not Output_Object.Is_In_Paragraph then
+           Ada.Exceptions.Raise_Exception (ARM_Output.Not_Valid_Error'Identity,
+               "Not in paragraph");
+       end if;
+
+       if Output_Object.Char_Count >= LINE_LENGTH and then
+          Output_Object.Out_Char_Count > Output_Object.Indent_Amount then
+           -- Insert a break here if anything has been output (but don't
+           -- Spill the buffer):
+--Ada.Text_IO.Put_Line ("Ordinary_Char [Break, no spill]: Cnt=" & 
Natural'Image(Output_Object.Char_Count));
+           Ada.Text_IO.New_Line (Output_Object.Output_File);
+           Make_Indent (Output_Object);
+           --Output_Object.Output_Buffer_Space_Before := False;
+               -- Start of line, this is done by Make_Indent.
+               -- Note that this may make the space disappear.
+           -- Add the contents of the buffer to the character count for this 
line:
+           Output_Object.Char_Count := Output_Object.Char_Count +
+               Output_Object.Output_Buffer_Len;
+           if Char = '>' then
+               Buffer (Output_Object, "@>");
+           elsif Char = '@' then
+               Buffer (Output_Object, "@@");
+           elsif Char /= ' ' then
+               Buffer (Output_Object, Char);
+           else -- Break character, spill on the new line:
+               if Output_Object.Output_Buffer_Len /= 0 then
+                   Spill (Output_Object); -- Output the buffer up to the space.
+                   Output_Object.Output_Buffer_Space_Before := True; -- 
Mid-line now.
+               -- else nothing in buffer, so nothing to output; just skip it.
+               end if;
+           end if;
+       elsif Char = ' ' then
+           -- Break character, and it fits on this line:
+           if Output_Object.Output_Buffer_Len /= 0 then
+--Ada.Text_IO.Put_Line ("Ordinary_Char [Space spill]: Cnt=" & 
Natural'Image(Output_Object.Char_Count));
+               Spill (Output_Object); -- Output the buffer up to the space.
+               Output_Object.Output_Buffer_Space_Before := True; -- Mid-line 
now.
+           else -- nothing in buffer.
+               -- nothing to output. But make sure we display a space before
+               -- the next item.
+               Output_Object.Output_Buffer_Space_Before := True; -- Mid-line 
now.
+           end if;
+        elsif Char = '>' then
+           Buffer (Output_Object, "@>");
+        elsif Char = '@' then
+           Buffer (Output_Object, "@@");
+       else
+           Buffer (Output_Object, Char);
+       end if;
+    end Ordinary_Character;
+
+
+    procedure Hard_Space (Output_Object : in out Corr_Output_Type) is
+       -- Output a hard space. No line break should happen at a hard space.
+    begin
+       if not Output_Object.Is_Valid then
+           Ada.Exceptions.Raise_Exception (ARM_Output.Not_Valid_Error'Identity,
+               "Not valid object");
+       end if;
+       if not Output_Object.Is_In_Paragraph then
+           Ada.Exceptions.Raise_Exception (ARM_Output.Not_Valid_Error'Identity,
+               "Not in paragraph");
+       end if;
+       if Output_Object.Is_Fixed_Format then
+           -- In this format, all spaces are hard spaces.
+           Buffer (Output_Object, ' ');
+       else -- A hard space command.
+           Buffer (Output_Object, "@ ");
+       end if;
+    end Hard_Space;
+
+
+    procedure Line_Break (Output_Object : in out Corr_Output_Type) is
+       -- Output a line break. This does not start a new paragraph.
+       -- This corresponds to a "<BR>" in HTML.
+    begin
+       if not Output_Object.Is_Valid then
+           Ada.Exceptions.Raise_Exception (ARM_Output.Not_Valid_Error'Identity,
+               "Not valid object");
+       end if;
+       if not Output_Object.Is_In_Paragraph then
+           Ada.Exceptions.Raise_Exception (ARM_Output.Not_Valid_Error'Identity,
+               "Not in paragraph");
+       end if;
+--Ada.Text_Io.Put_Line ("Line_Break");
+       if Output_Object.Is_Fixed_Format then
+           -- In this format, all line breaks are significant.
+           null;
+       else -- A hard space command.
+            Buffer (Output_Object, "@hr");
+       end if;
+       if Output_Object.Output_Buffer_Len /= 0 then
+           Spill (Output_Object);
+       end if;
+       Ada.Text_IO.New_Line (Output_Object.Output_File);
+        Make_Indent (Output_Object);
+    end Line_Break;
+
+
+    procedure Index_Line_Break (Output_Object : in out Corr_Output_Type;
+                               Clear_Keep_with_Next : in Boolean) is
+       -- Output a line break for the index. This does not start a new
+       -- paragraph in terms of spacing. This corresponds to a "<BR>"
+       -- in HTML. If Clear_Keep_with_Next is true, insure that the next
+       -- line does not require the following line to stay with it.
+       -- Raises Not_Valid_Error if the paragraph is not in the index format.
+    begin
+       Line_Break (Output_Object);
+    end Index_Line_Break;
+
+
+    procedure Soft_Line_Break (Output_Object : in out Corr_Output_Type) is
+       -- Output a soft line break. This is a place (in the middle of a
+       -- "word") that we allow a line break. It is usually used after
+       -- underscores in long non-terminals.
+    begin
+       if not Output_Object.Is_Valid then
+           Ada.Exceptions.Raise_Exception (ARM_Output.Not_Valid_Error'Identity,
+               "Not valid object");
+       end if;
+       if not Output_Object.Is_In_Paragraph then
+           Ada.Exceptions.Raise_Exception (ARM_Output.Not_Valid_Error'Identity,
+               "Not in paragraph");
+       end if;
+--     if Output_Object.Char_Count >= LINE_LENGTH - 10 then
+--         if Output_Object.Output_Buffer_Len /= 0 then
+--             Spill (Output_Object);
+--         end if;
+--         Ada.Text_IO.New_Line (Output_Object.Output_File);
+--            Make_Indent (Output_Object);
+--     -- else we don't need a line break.
+--     end if;
+       null; -- Ignore this, there is no counterpart in Corrigendum formatting.
+    end Soft_Line_Break;
+
+
+    procedure Soft_Hyphen_Break (Output_Object : in out Corr_Output_Type) is
+       -- Output a soft line break, with a hyphen. This is a place (in the 
middle of
+       -- a "word") that we allow a line break. If the line break is used,
+       -- a hyphen will be added to the text.
+    begin
+       if not Output_Object.Is_Valid then
+           Ada.Exceptions.Raise_Exception (ARM_Output.Not_Valid_Error'Identity,
+               "Not valid object");
+       end if;
+       if not Output_Object.Is_In_Paragraph then
+           Ada.Exceptions.Raise_Exception (ARM_Output.Not_Valid_Error'Identity,
+               "Not in paragraph");
+       end if;
+--     if Output_Object.Char_Count >= LINE_LENGTH - 8 then
+--         Spill (Output_Object);
+--         Ada.Text_IO.Put_Line (Output_Object.Output_File, "-"); -- Add the 
hyphen and break.
+--            Make_Indent (Output_Object);
+--     -- else we don't need a line break.
+--     end if;
+       null; -- Ignore this, there is no counterpart in Corrigendum formatting.
+    end Soft_Hyphen_Break;
+
+
+    procedure Tab (Output_Object : in out Corr_Output_Type) is
+       -- Output a tab, inserting space up to the next tab stop.
+       -- Raises Not_Valid_Error if the paragraph was created with
+       -- Tab_Stops = ARM_Output.NO_TABS.
+    begin
+       if not Output_Object.Is_Valid then
+           Ada.Exceptions.Raise_Exception (ARM_Output.Not_Valid_Error'Identity,
+               "Not valid object");
+       end if;
+       if not Output_Object.Is_In_Paragraph then
+           Ada.Exceptions.Raise_Exception (ARM_Output.Not_Valid_Error'Identity,
+               "Not in paragraph");
+       end if;
+       if ARM_Output."="(Output_Object.Tab_Stops, ARM_Output.NO_TABS) then
+           Ada.Exceptions.Raise_Exception (ARM_Output.Not_Valid_Error'Identity,
+               "Tab, but none set");
+       end if;
+       -- We use the tab stops as characters here, and fixed and proportional
+       -- stops are treated identically.
+       -- Find the first stop greater than the current character count. (After
+       -- writing a space).
+--Ada.Text_IO.Put_Line ("Tab");
+        Buffer (Output_Object, "@tab");
+       Output_Object.Output_Buffer_Space_Before := False; -- Spaces needed 
were output.
+    end Tab;
+
+
+    procedure Special_Character (Output_Object : in out Corr_Output_Type;
+                                Char : in ARM_Output.Special_Character_Type) is
+       -- Output an special character.
+    begin
+       --** Could use Latin1 and Unicode equivalents for most of these.
+       case Char is
+           when ARM_Output.EM_Dash =>
+               Buffer (Output_Object, "@emdash");
+           when ARM_Output.EN_Dash =>
+               Buffer (Output_Object, "@endash");
+           when ARM_Output.GEQ =>
+               Ordinary_Text (Output_Object, ">="); -- Not available in 
Corrigendum, use the Ada one.
+           when ARM_Output.LEQ =>
+               Ordinary_Text (Output_Object, "<="); -- Not available in 
Corrigendum, use the Ada one.
+           when ARM_Output.NEQ =>
+               Ordinary_Text (Output_Object, "/="); -- Not available in 
Corrigendum, use the Ada one.
+           when ARM_Output.PI =>
+               Buffer (Output_Object, "@pi");
+           when ARM_Output.Left_Ceiling =>
+               Ordinary_Text (Output_Object, "Ceiling("); -- Not available in 
Corrigendum.
+           when ARM_Output.Right_Ceiling =>
+               Ordinary_Text (Output_Object, ")"); -- Not available in 
Corrigendum.
+           when ARM_Output.Left_Floor =>
+               Ordinary_Text (Output_Object, "Floor("); -- Not available in 
Corrigendum.
+           when ARM_Output.Right_Floor =>
+               Ordinary_Text (Output_Object, ")"); -- Not available in 
Corrigendum.
+           when ARM_Output.Thin_Space =>
+               Ordinary_Text (Output_Object, " "); -- Not available in 
Corrigendum.
+           when ARM_Output.Left_Quote =>
+               Buffer (Output_Object, "@lquote");
+           when ARM_Output.Right_Quote =>
+               Buffer (Output_Object, "@rquote");
+           when ARM_Output.Left_Double_Quote =>
+               Ordinary_Text (Output_Object, """"); -- Not available in 
Corrigendum, use double quote.
+           when ARM_Output.Right_Double_Quote =>
+               Ordinary_Text (Output_Object, """"); -- Not available in 
Corrigendum, use double quote.
+           when ARM_Output.Small_Dotless_I =>
+               Ordinary_Text (Output_Object, "i"); -- Not available in 
Corrigendum, use the nearest text.
+           when ARM_Output.Capital_Dotted_I =>
+               Ordinary_Text (Output_Object, "I"); -- Not available in 
Corrigendum, use the nearest text.
+       end case;
+    end Special_Character;
+
+
+    procedure Unicode_Character (Output_Object : in out Corr_Output_Type;
+                                Char : in ARM_Output.Unicode_Type) is
+       -- Output a Unicode character, with code position Char.
+       Char_Code : constant String := ARM_Output.Unicode_Type'Image(Char);
+    begin
+       -- We don't check, but we assume this is not a normal character.
+       Buffer (Output_Object, "@unicode<" & Char_Code(2..Char_Code'Last) & 
">");
+    end Unicode_Character;
+
+
+    procedure End_Hang_Item (Output_Object : in out Corr_Output_Type) is
+       -- Marks the end of a hanging item. Call only once per paragraph.
+       -- Raises Not_Valid_Error if the paragraph style is not in
+       -- Text_Prefixed_Style_Subtype, or if this has already been
+       -- called for the current paragraph, or if the paragraph was started
+       -- with No_Prefix = True.
+    begin
+       if not Output_Object.Is_Valid then
+           Ada.Exceptions.Raise_Exception (ARM_Output.Not_Valid_Error'Identity,
+               "Not valid object");
+       end if;
+       if not Output_Object.Is_In_Paragraph then
+           Ada.Exceptions.Raise_Exception (ARM_Output.Not_Valid_Error'Identity,
+               "Not in paragraph");
+       end if;
+       if not Output_Object.Is_Hanging then
+           Ada.Exceptions.Raise_Exception (ARM_Output.Not_Valid_Error'Identity,
+               "Not a hanging paragraph");
+       end if;
+       if Output_Object.Saw_Hang_End then
+           Ada.Exceptions.Raise_Exception (ARM_Output.Not_Valid_Error'Identity,
+               "Already saw the end of the hanging part");
+       end if;
+       Output_Object.Saw_Hang_End := True;
+
+        Buffer (Output_Object, ">"); -- Close @Xterm<
+    end End_Hang_Item;
+
+
+    procedure Text_Format (Output_Object : in out Corr_Output_Type;
+                          Format : in ARM_Output.Format_Type) is
+       -- Change the text format so that all of the properties are as 
specified.
+       -- Note: Changes to these properties ought be stack-like; that is,
+       -- Bold on, Italic on, Italic off, Bold off is OK; Bold on, Italic on,
+       -- Bold off, Italic off should be avoided (as separate commands).
+       use type ARM_Output.Change_Type;
+       use type ARM_Output.Location_Type;
+       use type ARM_Output.Size_Type;
+       -- Note: We ignore colors here, no colors in !Corrigendum markup.
+    begin
+       if not Output_Object.Is_Valid then
+           Ada.Exceptions.Raise_Exception (ARM_Output.Not_Valid_Error'Identity,
+               "Not valid object");
+       end if;
+       if not Output_Object.Is_In_Paragraph then
+           Ada.Exceptions.Raise_Exception (ARM_Output.Not_Valid_Error'Identity,
+               "Not in paragraph");
+       end if;
+
+       if not Format.Bold and Output_Object.Is_Bold then
+           Buffer (Output_Object, '>');
+           Output_Object.Is_Bold := False;
+       end if;
+
+       if not Format.Italic and Output_Object.Is_Italic then
+           Buffer (Output_Object, '>');
+           Output_Object.Is_Italic := False;
+       end if;
+
+       if Format.Size /= Output_Object.Size then
+           if Output_Object.Size /= 0 then
+               Buffer (Output_Object, '>');
+           end if;
+       end if;
+
+       if Format.Location /= Output_Object.Location then
+           if Output_Object.Location /= ARM_Output.Normal then
+               --Buffer (Output_Object, '>');
+               null; -- Corrigendum doesn't support this.
+           end if;
+       end if;
+
+       if ARM_Output."/=" (Format.Font, Output_Object.Font) then
+           case Output_Object.Font is
+               when ARM_Output.Default => null;
+               when ARM_Output.Fixed =>
+                   Buffer (Output_Object, '>');
+               when ARM_Output.Roman =>
+                   Buffer (Output_Object, '>');
+               when ARM_Output.Swiss =>
+                   Buffer (Output_Object, '>');
+           end case;
+       end if;
+
+       -- For the intended purpose, there should be no Change commands.
+       if Format.Change /= Output_Object.Change then
+           if Format.Change = ARM_Output.Both then
+               -- Open only the one(s) needed:
+               case Output_Object.Change is
+                   -- Note: Version is not used.
+                   when ARM_Output.Insertion =>
+                       -- Open the deletion:
+                       Buffer(Output_Object, '[');
+                   when ARM_Output.Deletion =>
+                       -- Open the insertion:
+                       Buffer(Output_Object, '{');
+                   when ARM_Output.None =>
+                       Buffer(Output_Object, '{');
+                       Buffer(Output_Object, '[');
+                   when ARM_Output.Both =>
+                       null;
+               end case;
+           elsif Output_Object.Change = ARM_Output.Both then
+               -- Close only the one(s) needed:
+               case Format.Change is
+                   -- Note: Version is not used.
+                   when ARM_Output.Insertion =>
+                       -- Close the deletion:
+                       Buffer(Output_Object, ']');
+                   when ARM_Output.Deletion =>
+                       -- Close the insertion:
+                       Buffer(Output_Object, '}');
+                   when ARM_Output.None =>
+                       Buffer(Output_Object, ']');
+                       Buffer(Output_Object, '}');
+                   when ARM_Output.Both =>
+                       null;
+               end case;
+           else -- Both can't get here.
+               case Output_Object.Change is
+                   when ARM_Output.Insertion =>
+                       Buffer(Output_Object, '}');
+                   when ARM_Output.Deletion =>
+                       Buffer(Output_Object, ']');
+                   when ARM_Output.None =>
+                       null;
+                   when ARM_Output.Both =>
+                       Buffer(Output_Object, ']');
+                       Buffer(Output_Object, '}');
+               end case;
+               case Format.Change is
+                   -- Note: Version is not used.
+                   when ARM_Output.Insertion =>
+                       Buffer(Output_Object, '{');
+                   when ARM_Output.Deletion =>
+                       Buffer(Output_Object, '[');
+                   when ARM_Output.None =>
+                       null;
+                   when ARM_Output.Both =>
+                       Buffer(Output_Object, '{');
+                       Buffer(Output_Object, '[');
+               end case;
+           end if;
+           Output_Object.Change := Format.Change;
+       end if;
+       if ARM_Output."/=" (Format.Font, Output_Object.Font) then
+           case Format.Font is
+               when ARM_Output.Default => null;
+               when ARM_Output.Fixed =>
+                   Buffer (Output_Object, "@fc<");
+               when ARM_Output.Roman =>
+                   Buffer (Output_Object, "@ft<");
+               when ARM_Output.Swiss =>
+                   Buffer (Output_Object, "@fa<");
+           end case;
+           Output_Object.Font := Format.Font;
+       end if;
+
+       if Format.Location /= Output_Object.Location then
+           case Format.Location is
+               when ARM_Output.Superscript =>
+                   --Buffer (Output_Object, "@+<");
+                   null; -- Corrigendum doesn't support this.
+               when ARM_Output.Subscript =>
+                   --Buffer (Output_Object, "@+<");
+                   null; -- Corrigendum doesn't support this.
+               when ARM_Output.Normal =>
+                   null;
+           end case;
+           Output_Object.Location := Format.Location;
+       end if;
+
+       if Format.Size /= Output_Object.Size then
+           if Format.Size < 0 then
+               Buffer (Output_Object, "@s" & 
Character'Val(10+Format.Size+Character'Pos('0')) & '<');
+           else
+               Buffer (Output_Object, "@s1" & 
Character'Val(Format.Size+Character'Pos('0')) & '<');
+           end if;
+           Output_Object.Size := Format.Size;
+       end if;
+
+       if Format.Italic and (not Output_Object.Is_Italic) then
+           Buffer (Output_Object, "@i<");
+           Output_Object.Is_Italic := True;
+       end if;
+       if Format.Bold and (not Output_Object.Is_Bold) then
+           Buffer (Output_Object, "@b<");
+           Output_Object.Is_Bold := True;
+       end if;
+
+    end Text_Format;
+
+
+    procedure Clause_Reference (Output_Object : in out Corr_Output_Type;
+                               Text : in String;
+                               Clause_Number : in String) is
+       -- Generate a reference to a clause in the standard. The text of
+       -- the reference is "Text", and the number of the clause is
+       -- Clause_Number. For hyperlinked formats, this should generate
+       -- a link; for other formats, the text alone is generated.
+    begin
+       Ordinary_Text (Output_Object, Text); -- Nothing special in this format.
+    end Clause_Reference;
+
+
+    procedure Index_Target (Output_Object : in out Corr_Output_Type;
+                           Index_Key : in Natural) is
+       -- Generate a index target. This marks the location where an index
+       -- reference occurs. Index_Key names the index item involved.
+       -- For hyperlinked formats, this should generate a link target;
+       -- for other formats, nothing is generated.
+    begin
+       if not Output_Object.Is_Valid then
+           Ada.Exceptions.Raise_Exception (ARM_Output.Not_Valid_Error'Identity,
+               "Not valid object");
+       end if;
+       if not Output_Object.Is_In_Paragraph then
+           Ada.Exceptions.Raise_Exception (ARM_Output.Not_Valid_Error'Identity,
+               "Not in paragraph");
+       end if;
+       null; -- Nothing to do for plain text.
+    end Index_Target;
+
+
+    procedure Index_Reference (Output_Object : in out Corr_Output_Type;
+                              Text : in String;
+                              Index_Key : in Natural;
+                              Clause_Number : in String) is
+       -- Generate a reference to an index target in the standard. The text
+       -- of the reference is "Text", and Index_Key and Clause_Number denotes
+       -- the target. For hyperlinked formats, this should generate
+       -- a link; for other formats, the text alone is generated.
+    begin
+       Ordinary_Text (Output_Object, Text); -- Nothing special in this format.
+    end Index_Reference;
+
+
+    procedure DR_Reference (Output_Object : in out Corr_Output_Type;
+                           Text : in String;
+                           DR_Number : in String) is
+       -- Generate a reference to an DR from the standard. The text
+       -- of the reference is "Text", and DR_Number denotes
+       -- the target. For hyperlinked formats, this should generate
+       -- a link; for other formats, the text alone is generated.
+    begin
+       Ordinary_Text (Output_Object, Text); -- Nothing special in this format.
+    end DR_Reference;
+
+
+    procedure AI_Reference (Output_Object : in out Corr_Output_Type;
+                           Text : in String;
+                           AI_Number : in String) is
+       -- Generate a reference to an AI from the standard. The text
+       -- of the reference is "Text", and AI_Number denotes
+       -- the target (in unfolded format). For hyperlinked formats, this
+       -- should generate a link; for other formats, the text alone is
+       -- generated.
+    begin
+       Ordinary_Text (Output_Object, Text); -- Nothing special in this format.
+    end AI_Reference;
+
+
+    procedure Local_Target (Output_Object : in out Corr_Output_Type;
+                           Text : in String;
+                           Target : in String) is
+       -- Generate a local target. This marks the potential target of local
+       -- links identified by "Target". Text is the text of the target.
+       -- For hyperlinked formats, this should generate a link target;
+       -- for other formats, only the text is generated.
+    begin
+       Ordinary_Text (Output_Object, Text); -- Nothing special in this format.
+    end Local_Target;
+
+
+    procedure Local_Link (Output_Object : in out Corr_Output_Type;
+                         Text : in String;
+                         Target : in String;
+                         Clause_Number : in String) is
+       -- Generate a local link to the target and clause given.
+       -- Text is the text of the link.
+       -- For hyperlinked formats, this should generate a link;
+       -- for other formats, only the text is generated.
+    begin
+       Ordinary_Text (Output_Object, Text); -- Nothing special in this format.
+    end Local_Link;
+
+
+    procedure Local_Link_Start (Output_Object : in out Corr_Output_Type;
+                               Target : in String;
+                               Clause_Number : in String) is
+       -- Generate a local link to the target and clause given.
+       -- The link will surround text until Local_Link_End is called.
+       -- Local_Link_End must be called before this routine can be used again.
+       -- For hyperlinked formats, this should generate a link;
+       -- for other formats, only the text is generated.
+    begin
+       null; -- No link, nothing to do.
+    end Local_Link_Start;
+
+
+    procedure Local_Link_End (Output_Object : in out Corr_Output_Type;
+                             Target : in String;
+                             Clause_Number : in String) is
+       -- End a local link for the target and clause given.
+       -- This must be in the same paragraph as the Local_Link_Start.
+       -- For hyperlinked formats, this should generate a link;
+       -- for other formats, only the text is generated.
+    begin
+       null; -- No link, nothing to do.
+    end Local_Link_End;
+
+
+    procedure URL_Link (Output_Object : in out Corr_Output_Type;
+                       Text : in String;
+                       URL : in String) is
+       -- Generate a link to the URL given.
+       -- Text is the text of the link.
+       -- For hyperlinked formats, this should generate a link;
+       -- for other formats, only the text is generated.
+    begin
+       Ordinary_Text (Output_Object, Text); -- Nothing special in this format.
+    end URL_Link;
+
+
+    procedure Picture  (Output_Object : in out Corr_Output_Type;
+                       Name  : in String;
+                       Descr : in String;
+                       Alignment : in ARM_Output.Picture_Alignment;
+                       Height, Width : in Natural;
+                       Border : in ARM_Output.Border_Kind) is
+       -- Generate a picture.
+       -- Name is the (simple) file name of the picture; Descr is a
+       -- descriptive name for the picture (it will appear in some web
+       -- browsers).
+       -- We assume that it is a .GIF or .JPG and that it will be present
+       -- in the same directory as the input files and the same directory as
+       -- the .HTML output files.
+       -- Alignment specifies the picture alignment.
+       -- Height and Width specify the picture size in pixels.
+       -- Border specifies the kind of border.
+    begin
+       Ordinary_Text (Output_Object, "[Picture: " & Name &
+         " - " & Descr & "]");
+    end Picture;
+
+end ARM_Corr;
diff --git a/progs/arm_corr.ads b/progs/arm_corr.ads
new file mode 100755
index 0000000..e6f7bcf
--- /dev/null
+++ b/progs/arm_corr.ads
@@ -0,0 +1,432 @@
+with ARM_Output,
+     ARM_Contents,
+     Ada.Text_IO;
+package ARM_Corr is
+
+    --
+    -- Ada reference manual formatter (ARM_Form).
+    --
+    -- This package defines the text output object.
+    -- Output objects are responsible for implementing the details of
+    -- a particular format.
+    --
+    -- ---------------------------------------
+    -- Copyright 2000, 2002, 2004, 2005, 2006, 2007, 2011, 2012
+    --   AXE Consultants. All rights reserved.
+    -- P.O. Box 1512, Madison WI  53701
+    -- E-Mail: randy@rrsoftware.com
+    --
+    -- ARM_Form is free software: you can redistribute it and/or modify
+    -- it under the terms of the GNU General Public License version 3
+    -- as published by the Free Software Foundation.
+    --
+    -- AXE CONSULTANTS MAKES THIS TOOL AND SOURCE CODE AVAILABLE ON AN "AS IS"
+    -- BASIS AND MAKES NO WARRANTY, EXPRESS OR IMPLIED, AS TO THE ACCURACY,
+    -- CAPABILITY, EFFICIENCY, MERCHANTABILITY, OR FUNCTIONING OF THIS TOOL.
+    -- IN NO EVENT WILL AXE CONSULTANTS BE LIABLE FOR ANY GENERAL,
+    -- CONSEQUENTIAL, INDIRECT, INCIDENTAL, EXEMPLARY, OR SPECIAL DAMAGES,
+    -- EVEN IF AXE CONSULTANTS HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
+    -- DAMAGES.
+    --
+    -- A copy of the GNU General Public License is available in the file
+    -- gpl-3-0.txt in the standard distribution of the ARM_Form tool.
+    -- Otherwise, see <http://www.gnu.org/licenses/>.
+    --
+    -- If the GPLv3 license is not satisfactory for your needs, a commercial
+    -- use license is available for this tool. Contact Randy at AXE Consultants
+    -- for more information.
+    --
+    -- ---------------------------------------
+    --
+    -- Edit History:
+    --
+    --  6/ 2/05 - RLB - Created base package from text and HTML versions.
+    --  1/11/06 - RLB - Eliminated dispatching Create in favor of tailored
+    --                 versions.
+    --  1/13/06 - RLB - Added new Link operations.
+    --  2/ 8/06 - RLB - Added additional parameters to the table command.
+    --  2/10/06 - RLB - Added even more additional parameters to the
+    --                 table command.
+    --         - RLB - Added picture command.
+    --  9/25/06 - RLB - Added Last_Column_Width to Start_Table.
+    -- 10/13/06 - RLB - Added Local_Link_Start and Local_Link_End to allow
+    --                 formatting in the linked text.
+    --  2/ 9/07 - RLB - Changed comments on AI_Reference.
+    --  2/13/07 - RLB - Revised to separate style and indent information
+    --                 for paragraphs.
+    -- 12/19/07 - RLB - Added limited colors to Text_Format.
+    -- 10/18/11 - RLB - Changed to GPLv3 license.
+    -- 10/25/11 - RLB - Added old insertion version to Revised_Clause_Header.
+    --  8/31/12 - RLB - Added Output_Path.
+    -- 11/26/12 - RLB - Added subdivision names to Clause_Header and
+    --                 Revised_Clause_Header.
+
+    type Corr_Output_Type is new ARM_Output.Output_Type with private;
+
+    procedure Create (Output_Object : in out Corr_Output_Type;
+                     File_Prefix : in String;
+                     Output_Path : in String;
+                     Title : in String := "");
+       -- Create an Output_Object for a document.
+       -- The prefix of the output file names is File_Prefix - this
+       -- should be no more then 5 characters allowed in file names.
+       -- The result files will be written to Output_Path.
+       -- The title of the document is Title.
+
+    procedure Close (Output_Object : in out Corr_Output_Type);
+       -- Close an Output_Object. No further output to the object is
+       -- allowed after this call.
+
+
+    procedure Section (Output_Object : in out Corr_Output_Type;
+                      Section_Title : in String;
+                      Section_Name : in String);
+       -- Start a new section. The title is Section_Title (this is
+       -- intended for humans). The name is Section_Name (this is
+       -- intended to be suitable to be a portion of a file name).
+
+    procedure Set_Columns (Output_Object : in out Corr_Output_Type;
+                          Number_of_Columns : in ARM_Output.Column_Count);
+       -- Set the number of columns.
+       -- Raises Not_Valid_Error if in a paragraph.
+
+    procedure Start_Paragraph (Output_Object : in out Corr_Output_Type;
+                              Style     : in ARM_Output.Paragraph_Style_Type;
+                              Indent    : in ARM_Output.Paragraph_Indent_Type;
+                              Number    : in String;
+                              No_Prefix : in Boolean := False;
+                              Tab_Stops : in ARM_Output.Tab_Info := 
ARM_Output.NO_TABS;
+                              No_Breaks : in Boolean := False;
+                              Keep_with_Next : in Boolean := False;
+                              Space_After : in ARM_Output.Space_After_Type
+                                  := ARM_Output.Normal;
+                              Justification : in ARM_Output.Justification_Type
+                                  := ARM_Output.Default);
+       -- Start a new paragraph. The style and indent of the paragraph is as
+       -- specified. The (AA)RM paragraph number (which might include update
+       -- and version numbers as well: [12.1/1]) is Number. If the format is
+       -- a type with a prefix (bullets, hangining items), the prefix is
+       -- omitted if No_Prefix is true. Tab_Stops defines the tab stops for
+       -- the paragraph. If No_Breaks is True, we will try to avoid page breaks
+       -- in the paragraph. If Keep_with_Next is true, we will try to avoid
+       -- separating this paragraph and the next one. (These may have no
+       -- effect in formats that don't have page breaks). Space_After
+       -- specifies the amount of space following the paragraph. Justification
+       -- specifies the text justification for the paragraph. Not_Valid_Error
+       -- is raised if Tab_Stops /= NO_TABS for a hanging or bulleted format.
+
+    procedure End_Paragraph (Output_Object : in out Corr_Output_Type);
+       -- End a paragraph.
+
+    procedure Category_Header (Output_Object : in out Corr_Output_Type;
+                              Header_Text : String);
+       -- Output a Category header (that is, "Legality Rules",
+       -- "Dynamic Semantics", etc.)
+       -- (Note: We did not use a enumeration here to insure that these
+       -- headers are spelled the same in all output versions).
+       -- Raises Not_Valid_Error if in a paragraph.
+
+    procedure Clause_Header (Output_Object     : in out Corr_Output_Type;
+                            Header_Text       : in String;
+                            Level             : in ARM_Contents.Level_Type;
+                            Clause_Number     : in String;
+                            Top_Level_Subdivision_Name : in 
ARM_Output.Top_Level_Subdivision_Name_Kind;
+                            No_Page_Break     : in Boolean := False);
+       -- Output a Clause header. The level of the header is specified
+       -- in Level. The Clause Number is as specified; the top-level (and
+       -- other) subdivision names are as specified. These should appear in
+       -- the table of contents.
+       -- For hyperlinked formats, this should generate a link target.
+       -- If No_Page_Break is True, suppress any page breaks.
+       -- Raises Not_Valid_Error if in a paragraph.
+
+    procedure Revised_Clause_Header
+                           (Output_Object     : in out Corr_Output_Type;
+                            New_Header_Text   : in String;
+                            Old_Header_Text   : in String;
+                            Level             : in ARM_Contents.Level_Type;
+                            Clause_Number     : in String;
+                            Version           : in 
ARM_Contents.Change_Version_Type;
+                            Old_Version       : in 
ARM_Contents.Change_Version_Type;
+                            Top_Level_Subdivision_Name : in 
ARM_Output.Top_Level_Subdivision_Name_Kind;
+                            No_Page_Break     : in Boolean := False);
+       -- Output a revised clause header. Both the original and new text will
+       -- be output. The level of the header is specified in Level. The Clause
+       -- Number is as specified; the top-level (and other) subdivision names
+       -- are as specified. These should appear in the table of contents.
+       -- For hyperlinked formats, this should generate a link target.
+       -- Version is the insertion version of the new text; Old_Version is
+       -- the insertion version of the old text.
+       -- If No_Page_Break is True, suppress any page breaks.
+       -- Raises Not_Valid_Error if in a paragraph.
+
+    procedure TOC_Marker (Output_Object : in out Corr_Output_Type;
+                         For_Start : in Boolean);
+       -- Mark the start (if For_Start is True) or end (if For_Start is
+       -- False) of the table of contents data. Output objects that
+       -- auto-generate the table of contents can use this to do needed
+       -- actions.
+
+    procedure New_Page (Output_Object : in out Corr_Output_Type;
+                       Kind : ARM_Output.Page_Kind_Type := 
ARM_Output.Any_Page);
+       -- Output a page break.
+       -- Note that this has no effect on non-printing formats.
+       -- Any_Page breaks to the top of the next page (whatever it is);
+       -- Odd_Page_Only breaks to the top of the odd-numbered page;
+       -- Soft_Page allows a page break but does not force one (use in
+       -- "No_Breaks" paragraphs.)
+       -- Raises Not_Valid_Error if in a paragraph if Kind = Any_Page or
+       -- Odd_Page, and if not in a paragraph if Kind = Soft_Page.
+
+    procedure New_Column (Output_Object : in out Corr_Output_Type);
+       -- Output a column break.
+       -- Raises Not_Valid_Error if in a paragraph, or if the number of
+       -- columns is 1.
+
+    procedure Separator_Line (Output_Object : in out Corr_Output_Type;
+                             Is_Thin : Boolean := True);
+       -- Output a separator line. It is thin if "Is_Thin" is true.
+       -- Raises Not_Valid_Error if in a paragraph.
+
+    procedure Start_Table (Output_Object : in out Corr_Output_Type;
+                          Columns : in ARM_Output.Column_Count;
+                          First_Column_Width : in ARM_Output.Column_Count;
+                          Last_Column_Width : in ARM_Output.Column_Count;
+                          Alignment : in ARM_Output.Column_Text_Alignment;
+                          No_Page_Break : in Boolean;
+                          Has_Border : in Boolean;
+                          Small_Text_Size : in Boolean;
+                          Header_Kind : in ARM_Output.Header_Kind_Type);
+       -- Starts a table. The number of columns is Columns; the first
+       -- column has First_Column_Width times the normal column width, and
+       -- the last column has Last_Column_Width times the normal column width.
+       -- Alignment is the horizontal text alignment within the columns.
+       -- No_Page_Break should be True to keep the table intact on a single
+       -- page; False to allow it to be split across pages.
+       -- Has_Border should be true if a border is desired, false otherwise.
+       -- Small_Text_Size means that the contents will have the AARM size;
+       -- otherwise it will have the normal size.
+       -- Header_Kind determines whether the table has headers.
+       -- This command starts a paragraph; the entire table is a single
+       -- paragraph. Text will be considered part of the caption until the
+       -- next table marker call.
+       -- Raises Not_Valid_Error if in a paragraph.
+
+    procedure Table_Marker (Output_Object : in out Corr_Output_Type;
+                           Marker : in ARM_Output.Table_Marker_Type);
+       -- Marks the end of an entity in a table.
+       -- If Marker is End_Caption, the table caption ends and the
+       --      future text is part of the table header.
+       -- If Marker is End_Header, the table header ends and the
+       --      future text is part of the table body.
+       -- If Marker is End_Row, a row in the table is completed, and another
+       --      row started.
+       -- If Marker is End_Item, an item in the table header or body is ended,
+       --      and another started.
+       -- If Marker is End_Table, the entire table is finished.
+       -- Raises Not_Valid_Error if not in a table.
+
+    -- Text output: These are only allowed after a Start_Paragraph and
+    -- before any End_Paragraph. Raises Not_Valid_Error if not allowed.
+
+    procedure Ordinary_Text (Output_Object : in out Corr_Output_Type;
+                            Text : in String);
+       -- Output ordinary text.
+       -- The text must end at a word break, never in the middle of a word.
+
+    procedure Ordinary_Character (Output_Object : in out Corr_Output_Type;
+                                 Char : in Character);
+       -- Output an ordinary character.
+       -- Spaces will be used to break lines as needed.
+
+    procedure Hard_Space (Output_Object : in out Corr_Output_Type);
+       -- Output a hard space. No line break should happen at a hard space.
+
+    procedure Line_Break (Output_Object : in out Corr_Output_Type);
+       -- Output a line break. This does not start a new paragraph.
+       -- This corresponds to a "<BR>" in HTML.
+
+    procedure Index_Line_Break (Output_Object : in out Corr_Output_Type;
+                               Clear_Keep_with_Next : in Boolean);
+       -- Output a line break for the index. This does not start a new
+       -- paragraph in terms of spacing. This corresponds to a "<BR>"
+       -- in HTML. If Clear_Keep_with_Next is true, insure that the next
+       -- line does not require the following line to stay with it.
+
+    procedure Soft_Line_Break (Output_Object : in out Corr_Output_Type);
+       -- Output a soft line break. This is a place (in the middle of a
+       -- "word") that we allow a line break. It is usually used after
+       -- underscores in long non-terminals.
+
+    procedure Soft_Hyphen_Break (Output_Object : in out Corr_Output_Type);
+       -- Output a soft line break, with a hyphen. This is a place (in the 
middle of
+       -- a "word") that we allow a line break. If the line break is used,
+       -- a hyphen will be added to the text.
+
+    procedure Tab (Output_Object : in out Corr_Output_Type);
+       -- Output a tab, inserting space up to the next tab stop.
+       -- Raises Not_Valid_Error if the paragraph was created with
+       -- Tab_Stops = ARM_Output.NO_TABS.
+
+    procedure Special_Character (Output_Object : in out Corr_Output_Type;
+                                Char : in ARM_Output.Special_Character_Type);
+       -- Output an special character.
+
+    procedure Unicode_Character (Output_Object : in out Corr_Output_Type;
+                                Char : in ARM_Output.Unicode_Type);
+       -- Output a Unicode character, with code position Char.
+
+    procedure End_Hang_Item (Output_Object : in out Corr_Output_Type);
+       -- Marks the end of a hanging item. Call only once per paragraph.
+       -- Raises Not_Valid_Error if the paragraph style is not in
+       -- Text_Prefixed_Style_Subtype, or if this has already been
+       -- called for the current paragraph, or if the paragraph was started
+       -- with No_Prefix = True.
+
+    procedure Text_Format (Output_Object : in out Corr_Output_Type;
+                          Format : in ARM_Output.Format_Type);
+       -- Change the text format so that all of the properties are as 
specified.
+       -- Note: Changes to these properties ought be stack-like; that is,
+       -- Bold on, Italic on, Italic off, Bold off is OK; Bold on, Italic on,
+       -- Bold off, Italic off should be avoided (as separate commands).
+
+    procedure Clause_Reference (Output_Object : in out Corr_Output_Type;
+                               Text : in String;
+                               Clause_Number : in String);
+       -- Generate a reference to a clause in the standard. The text of
+       -- the reference is "Text", and the number of the clause is
+       -- Clause_Number. For hyperlinked formats, this should generate
+       -- a link; for other formats, the text alone is generated.
+
+    procedure Index_Target (Output_Object : in out Corr_Output_Type;
+                           Index_Key : in Natural);
+       -- Generate a index target. This marks the location where an index
+       -- reference occurs. Index_Key names the index item involved.
+       -- For hyperlinked formats, this should generate a link target;
+       -- for other formats, nothing is generated.
+
+    procedure Index_Reference (Output_Object : in out Corr_Output_Type;
+                              Text : in String;
+                              Index_Key : in Natural;
+                              Clause_Number : in String);
+       -- Generate a reference to an index target in the standard. The text
+       -- of the reference is "Text", and Index_Key and Clause_Number denotes
+       -- the target. For hyperlinked formats, this should generate
+       -- a link; for other formats, the text alone is generated.
+
+    procedure DR_Reference (Output_Object : in out Corr_Output_Type;
+                           Text : in String;
+                           DR_Number : in String);
+       -- Generate a reference to an DR from the standard. The text
+       -- of the reference is "Text", and DR_Number denotes
+       -- the target. For hyperlinked formats, this should generate
+       -- a link; for other formats, the text alone is generated.
+
+    procedure AI_Reference (Output_Object : in out Corr_Output_Type;
+                           Text : in String;
+                           AI_Number : in String);
+       -- Generate a reference to an AI from the standard. The text
+       -- of the reference is "Text", and AI_Number denotes
+       -- the target (in unfolded format). For hyperlinked formats, this should
+       -- generate a link; for other formats, the text alone is generated.
+
+    procedure Local_Target (Output_Object : in out Corr_Output_Type;
+                           Text : in String;
+                           Target : in String);
+       -- Generate a local target. This marks the potential target of local
+       -- links identified by "Target". Text is the text of the target.
+       -- For hyperlinked formats, this should generate a link target;
+       -- for other formats, only the text is generated.
+
+    procedure Local_Link (Output_Object : in out Corr_Output_Type;
+                         Text : in String;
+                         Target : in String;
+                         Clause_Number : in String);
+       -- Generate a local link to the target and clause given.
+       -- Text is the text of the link.
+       -- For hyperlinked formats, this should generate a link;
+       -- for other formats, only the text is generated.
+
+    procedure Local_Link_Start (Output_Object : in out Corr_Output_Type;
+                               Target : in String;
+                               Clause_Number : in String);
+       -- Generate a local link to the target and clause given.
+       -- The link will surround text until Local_Link_End is called.
+       -- Local_Link_End must be called before this routine can be used again.
+       -- For hyperlinked formats, this should generate a link;
+       -- for other formats, only the text is generated.
+
+    procedure Local_Link_End (Output_Object : in out Corr_Output_Type;
+                             Target : in String;
+                             Clause_Number : in String);
+       -- End a local link for the target and clause given.
+       -- This must be in the same paragraph as the Local_Link_Start.
+       -- For hyperlinked formats, this should generate a link;
+       -- for other formats, only the text is generated.
+
+    procedure URL_Link (Output_Object : in out Corr_Output_Type;
+                       Text : in String;
+                       URL : in String);
+       -- Generate a link to the URL given.
+       -- Text is the text of the link.
+       -- For hyperlinked formats, this should generate a link;
+       -- for other formats, only the text is generated.
+
+    procedure Picture  (Output_Object : in out Corr_Output_Type;
+                       Name  : in String;
+                       Descr : in String;
+                       Alignment : in ARM_Output.Picture_Alignment;
+                       Height, Width : in Natural;
+                       Border : in ARM_Output.Border_Kind);
+       -- Generate a picture.
+       -- Name is the (simple) file name of the picture; Descr is a
+       -- descriptive name for the picture (it will appear in some web
+       -- browsers).
+       -- We assume that it is a .GIF or .JPG and that it will be present
+       -- in the same directory as the output files.
+       -- Alignment specifies the picture alignment.
+       -- Height and Width specify the picture size in pixels.
+       -- Border specifies the kind of border.
+
+private
+
+    subtype Buffer_String is String (1 .. 120);
+    subtype Prefix_String is String(1..5);
+    subtype Clause_String is String(1..20);
+    type Corr_Output_Type is new ARM_Output.Output_Type with record
+       Is_Valid : Boolean := False;
+       Is_In_Paragraph : Boolean := False;
+       Is_In_Table : Boolean := False; -- Are we processing a table?
+       Is_Hanging : Boolean := False; -- If we are in a paragraph,
+                                      -- is it a hanging paragraph?
+       Saw_Hang_End : Boolean := False; -- If we are in a hanging paragraph,
+                                      -- have we seen the end of the hanging 
part yet?
+       Output_Buffer : Buffer_String;  -- Output buffer to make smarter breaks.
+       Output_Buffer_Len : Natural := 0; -- This should be empty between 
paragraphs.
+                       -- The idea is that the buffer is always logically
+                       -- preceeded by a space. Thus it is always OK to
+                       -- move the text in the buffer to the next line.
+       Output_Buffer_Space_Before : Boolean := False;
+                       -- Do we need to output a space before the buffer?
+       Output_File : Ada.Text_IO.File_Type;
+       Output_Path : Buffer_String;
+       Output_Path_Len : Natural := 0;
+       File_Prefix : Prefix_String; -- Blank padded.
+       Char_Count : Natural := 0; -- Characters on current line.
+       Out_Char_Count : Natural := 0; -- Characters output on current line.
+       Indent_Amount : Natural := 0; -- Amount to indent paragraphs.
+       Para_Style : ARM_Output.Paragraph_Style_Type := ARM_Output.Normal;
+       Para_Indent : ARM_Output.Paragraph_Indent_Type := 0; -- Specified 
indent.
+       Is_Fixed_Format : Boolean; -- Is the text currently in a fixed format? 
(@Xcode)
+       Is_Bold : Boolean; -- Is the text currently bold?
+       Is_Italic : Boolean; -- Is the text current italics?
+       Font : ARM_Output.Font_Family_Type; -- What is the current font family?
+       Size : ARM_Output.Size_Type; -- What is the current relative size?
+       Change : ARM_Output.Change_Type := ARM_Output.None;
+       Location : ARM_Output.Location_Type := ARM_Output.Normal;
+       Tab_Stops : ARM_Output.Tab_Info := ARM_Output.NO_TABS;
+       Clause_Num : Clause_String; -- The number of the current clause
+       Clause_Len : Natural := 0;
+    end record;
+
+end ARM_Corr;
diff --git a/progs/arm_db.adb b/progs/arm_db.adb
new file mode 100755
index 0000000..502e6c5
--- /dev/null
+++ b/progs/arm_db.adb
@@ -0,0 +1,327 @@
+--  with Ada.Text_IO; -- Debug.
+with Ada.Unchecked_Deallocation,
+     Ada.Strings.Fixed,
+     Ada.Characters.Handling;
+package body ARM_Database is
+
+    --
+    -- Ada reference manual formatter (ARM_Form).
+    --
+    -- This package contains the database to store items for non-normative
+    -- appendixes.
+    --
+    -- ---------------------------------------
+    -- Copyright 2000, 2004, 2005, 2006, 2009, 2011, 2012
+    --   AXE Consultants. All rights reserved.
+    -- P.O. Box 1512, Madison WI  53701
+    -- E-Mail: randy@rrsoftware.com
+    --
+    -- ARM_Form is free software: you can redistribute it and/or modify
+    -- it under the terms of the GNU General Public License version 3
+    -- as published by the Free Software Foundation.
+    --
+    -- AXE CONSULTANTS MAKES THIS TOOL AND SOURCE CODE AVAILABLE ON AN "AS IS"
+    -- BASIS AND MAKES NO WARRANTY, EXPRESS OR IMPLIED, AS TO THE ACCURACY,
+    -- CAPABILITY, EFFICIENCY, MERCHANTABILITY, OR FUNCTIONING OF THIS TOOL.
+    -- IN NO EVENT WILL AXE CONSULTANTS BE LIABLE FOR ANY GENERAL,
+    -- CONSEQUENTIAL, INDIRECT, INCIDENTAL, EXEMPLARY, OR SPECIAL DAMAGES,
+    -- EVEN IF AXE CONSULTANTS HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
+    -- DAMAGES.
+    --
+    -- A copy of the GNU General Public License is available in the file
+    -- gpl-3-0.txt in the standard distribution of the ARM_Form tool.
+    -- Otherwise, see <http://www.gnu.org/licenses/>.
+    --
+    -- If the GPLv3 license is not satisfactory for your needs, a commercial
+    -- use license is available for this tool. Contact Randy at AXE Consultants
+    -- for more information.
+    --
+    -- ---------------------------------------
+    --
+    -- Edit History:
+    --
+    --  5/16/00 - RLB - Created package.
+    --  8/28/00 - RLB - Added revision info to database.
+    -- 10/28/04 - RLB - Added Inserted_Normal_Number change kind.
+    -- 11/02/04 - RLB - Added Deleted_Inserted_Number change kind.
+    -- 12/06/04 - RLB - Added Revised_Inserted_Number change kind.
+    -- 12/14/04 - RLB - Made the hang item bigger.
+    --  1/19/05 - RLB - Added Added_Version.
+    -- 10/17/05 - RLB - Fixed indexing of the Glossary.
+    -- 10/18/06 - RLB - Added No_Deleted_Paragraph_Messages to Report.
+    -- 11/30/09 - RLB - Made the hang item bigger again (to make room to
+    --                 handle commands like @ChgAdded).
+    -- 10/18/11 - RLB - Changed to GPLv3 license.
+    -- 10/20/11 - RLB - Added Initial_Version parameter.
+    --  3/19/12 - RLB - Added code to suppress indexing of deleted glossary 
items.
+
+    type String_Ptr is access String;
+    type Item is record
+       Next : Item_List;
+       Sort_Key : String(1 .. 50);
+       Hang : String(1 .. 75);
+       Hang_Len : Natural;
+       Text : String_Ptr;
+       Change_Kind : Paragraph_Change_Kind_Type;
+       Version : Character;
+       Initial_Version : Character;
+    end record;
+
+    procedure Free is new Ada.Unchecked_Deallocation (Item, Item_List);
+    procedure Free is new Ada.Unchecked_Deallocation (String, String_Ptr);
+
+    procedure Create (Database_Object : in out Database_Type) is
+       -- Initialize a database object.
+    begin
+       Database_Object.Is_Valid := True;
+       Database_Object.List := null;
+       Database_Object.Item_Count := 0;
+    end Create;
+
+
+    procedure Destroy (Database_Object : in out Database_Type) is
+       -- Destroy a database object, freeing any resources used.
+       Temp : Item_List;
+    begin
+       if not Database_Object.Is_Valid then
+           raise Not_Valid_Error;
+       end if;
+       while Database_Object.List /= null loop
+           Temp := Database_Object.List;
+           Database_Object.List := Temp.Next;
+           Free (Temp.Text);
+           Free (Temp);
+       end loop;
+       Database_Object.Is_Valid := False;
+    end Destroy;
+
+
+    procedure Insert (Database_Object : in out Database_Type;
+                     Sort_Key : in String;
+                     Hang_Item : in String;
+                     Text : in String;
+                     Change_Kind : in Paragraph_Change_Kind_Type := 
ARM_Database.None;
+                     Version : in Character := '0';
+                     Initial_Version : in Character := '0') is
+       -- Insert an item into the database object.
+       -- Sort_Key is the string on which this item will be sorted (if it
+       -- is sorted). Hang_Item is the item which hangs out for the item
+       -- in the report (if any). Text is the text for the item; the text
+       -- may include formatting codes. Change_Kind and Version are the
+       -- revision status for this item. Initial_Version is the version of
+       -- the initial text for this item.
+       Temp_Item : Item;
+    begin
+       if not Database_Object.Is_Valid then
+           raise Not_Valid_Error;
+       end if;
+       Ada.Strings.Fixed.Move (Target => Temp_Item.Sort_Key,
+                               Source => 
Ada.Characters.Handling.To_Lower(Sort_Key),
+                               Drop   => Ada.Strings.Right,
+                               Pad    => ' ');
+       Ada.Strings.Fixed.Move (Target => Temp_Item.Hang,
+                               Source => Hang_Item,
+                               Drop   => Ada.Strings.Error,
+                               Pad    => ' ');
+       Temp_Item.Hang_Len := Hang_Item'Length;
+           -- Note: If this second item doesn't fit, we error so we can make
+           -- the size larger.
+       Temp_Item.Text := new String'(Text);
+       Temp_Item.Change_Kind := Change_Kind;
+       Temp_Item.Version := Version;
+       Temp_Item.Initial_Version := Initial_Version;
+       Temp_Item.Next := Database_Object.List;
+        Database_Object.List := new Item'(Temp_Item);
+       Database_Object.Item_Count := Database_Object.Item_Count + 1;
+    end Insert;
+
+
+    --generic
+    -- with procedure Format_Text (Text : in String;
+    --                             Text_Name : in String);
+    procedure Report (Database_Object : in out Database_Type;
+                     In_Format : in Format_Type;
+                     Sorted : in Boolean;
+                     Added_Version : Character := '0';
+                     No_Deleted_Paragraph_Messages : in Boolean := False) is
+       -- Output the items with the appropriate format to the
+       -- "Format_Text" routine. "Format_Text" allows all commands
+       -- for the full formatter. (Text_Name is an identifying name
+       -- for error messages). This is an added list for Added_Version
+       -- ('0' meaning it is not added); in that case, use normal numbers
+       -- for items with a version less than or equal to Added_Version.
+       -- (This is intended to be used to output the items to
+       -- appropriate Format and Output objects; but we can't do that
+       -- directly because that would make this unit recursive with
+       -- ARM_Format.
+       -- No paragraphs will be have deleted paragraph messages if
+       -- No_Deleted_Paragraph_Messages is True.
+       Temp : Item_List;
+
+       function Change_if_Needed (Item : in Item_List) return String is
+       begin
+           -- Note: In the report, we always decide inserted/not inserted
+           -- as determined by the initial version number, and not the
+           -- original class.
+           case Item.Change_Kind is
+               when None => return "";
+               when Inserted | Inserted_Normal_Number =>
+                   if Item.Initial_Version <= Added_Version then
+                       return "@ChgRef{Version=[" & Item.Version &
+                           "],Kind=[AddedNormal]}";
+                   else
+                       return "@ChgRef{Version=[" & Item.Version &
+                           "],Kind=[Added]}";
+                   end if;
+               when Revised | Revised_Inserted_Number =>
+                   if Item.Initial_Version <= Added_Version then
+                       return "@ChgRef{Version=[" & Item.Version &
+                           "],Kind=[Revised]}";
+                   else
+                       return "@ChgRef{Version=[" & Item.Version &
+                           "],Kind=[RevisedAdded]}";
+                   end if;
+               when Deleted | Deleted_Inserted_Number =>
+                   if Item.Initial_Version <= Added_Version then
+                       if No_Deleted_Paragraph_Messages then
+                           return "@ChgRef{Version=[" & Item.Version &
+                               "],Kind=[DeletedNoDelMsg]}";
+                       else
+                           return "@ChgRef{Version=[" & Item.Version &
+                               "],Kind=[Deleted]}";
+                       end if;
+                   else
+                       if No_Deleted_Paragraph_Messages then
+                           return "@ChgRef{Version=[" & Item.Version &
+                               "],Kind=[DeletedAddedNoDelMsg]}";
+                       else
+                           return "@ChgRef{Version=[" & Item.Version &
+                               "],Kind=[DeletedAdded]}";
+                       end if;
+                   end if;
+               when Deleted_No_Delete_Message |
+                    Deleted_Inserted_Number_No_Delete_Message =>
+                   if Item.Initial_Version <= Added_Version then
+                       return "@ChgRef{Version=[" & Item.Version &
+                           "],Kind=[DeletedNoDelMsg]}";
+                   else
+                       return "@ChgRef{Version=[" & Item.Version &
+                           "],Kind=[DeletedAddedNoDelMsg]}";
+                   end if;
+           end case;
+       end Change_if_Needed;
+
+    begin
+       if not Database_Object.Is_Valid then
+           raise Not_Valid_Error;
+       end if;
+       if Sorted then
+           declare
+               Items : array (1..Database_Object.Item_Count) of Item_List;
+           begin
+               -- Load the items:
+               Temp := Database_Object.List;
+               for I in Items'range loop
+                   Items(I) := Temp;
+                   Temp := Temp.Next;
+               end loop;
+
+               -- Sort the items array (use an insertion sort because it is
+               -- stable):
+               declare
+                   Left : Natural;  -- Left sorting stop
+               begin
+                   for Right In Items'First+1 .. Items'Last loop -- Right 
sorting stop
+                       Temp := Items(Right);
+                       Left := Right - 1;
+                       while Temp.Sort_Key <= Items(Left).Sort_Key loop -- 
Switch items
+                           Items(Left + 1) := Items(Left);
+                           Left := Left - 1;
+                           exit when Left = 0;
+                       end loop;
+                       Items(Left + 1) := Temp;
+                   end loop;
+               end;
+
+               -- Relink the items in the sorted order:
+               for I in Items'First .. Items'Last - 1 loop
+                   Items(I).Next := Items(I+1);
+               end loop;
+               if Items'Length > 0 then
+                   Items(Items'Last).Next := null;
+                   Database_Object.List := Items(1);
+               else
+                   Database_Object.List := null;
+               end if;
+           end;
+       end if;
+       case In_Format is
+           when Hanging_List =>
+               Format_Text ("@begin(description)" & Ascii.LF, "Prefix");
+               Temp := Database_Object.List;
+               while Temp /= null loop
+--** Debug:
+--Ada.Text_IO.Put_Line ("^^ " & 
Paragraph_Change_Kind_Type'Image(Temp.Change_Kind) &
+--   " for " & Temp.Hang(1..Temp.Hang_Len) & " ref=" & Change_if_Needed 
(Temp));
+--Ada.Text_IO.Put_Line ("   " & Change_if_Needed (Temp) &
+--Temp.Hang(1..Temp.Hang_Len) & "@\" &
+--Temp.Text.all & Ascii.LF & Ascii.LF);
+                   Format_Text (Change_if_Needed (Temp) &
+                       Temp.Hang(1..Temp.Hang_Len) & "@\" &
+                       Temp.Text.all & Ascii.LF & Ascii.LF, Temp.Sort_Key);
+                   Temp := Temp.Next;
+               end loop;
+               Format_Text ("@end(description)" & Ascii.LF, "Suffix");
+           when Bullet_List =>
+               Format_Text ("@begin(itemize)" & Ascii.LF, "Prefix");
+               Temp := Database_Object.List;
+               while Temp /= null loop
+                   Format_Text (Change_if_Needed (Temp) &
+                                Temp.Text.all & Ascii.LF & Ascii.LF, 
Temp.Sort_Key);
+                   Temp := Temp.Next;
+               end loop;
+               Format_Text ("@end(itemize)" & Ascii.LF, "Suffix");
+           when Normal_List =>
+               Format_Text ("@begin(intro)" & Ascii.LF, "Prefix");
+               Temp := Database_Object.List;
+               while Temp /= null loop
+                   Format_Text (Change_if_Needed (Temp) &
+                                Temp.Text.all & Ascii.LF & Ascii.LF, 
Temp.Sort_Key);
+                   Temp := Temp.Next;
+               end loop;
+               Format_Text ("@end(intro)" & Ascii.LF, "Suffix");
+           when Normal_Indexed_List =>
+               Format_Text ("@begin(intro)" & Ascii.LF, "Prefix");
+               Temp := Database_Object.List;
+               while Temp /= null loop
+                   case Temp.Change_Kind is
+                       when None |
+                            Inserted | Inserted_Normal_Number |
+                            Revised | Revised_Inserted_Number =>
+--** Debug:
+--Ada.Text_IO.Put_Line("Format " & Change_if_Needed (Temp) &
+--                     "@defn{" & Ada.Strings.Fixed.Trim (Temp.Sort_Key, 
Ada.Strings.Right) & "}" & Ascii.LF &
+--                     Temp.Text.all);
+                           -- Index this item.
+                           Format_Text (Change_if_Needed (Temp) &
+                               "@defn{" & Ada.Strings.Fixed.Trim 
(Temp.Sort_Key, Ada.Strings.Right) & "}" & Ascii.LF &
+                               Temp.Text.all & Ascii.LF & Ascii.LF, 
Temp.Sort_Key);
+                       when Deleted | Deleted_Inserted_Number |
+                            Deleted_No_Delete_Message |
+                            Deleted_Inserted_Number_No_Delete_Message =>
+--** Debug:
+--Ada.Text_IO.Put_Line("Format " & Change_if_Needed (Temp) & Ascii.LF &
+--                     Temp.Text.all);
+                           -- Don't index deleted items.
+                           Format_Text (Change_if_Needed (Temp) & Ascii.LF &
+                               Temp.Text.all & Ascii.LF & Ascii.LF, 
Temp.Sort_Key);
+                   end case;
+                   Temp := Temp.Next;
+               end loop;
+               Format_Text ("@end(intro)" & Ascii.LF, "Suffix");
+       end case;
+    end Report;
+
+end ARM_Database;
+
+
diff --git a/progs/arm_db.ads b/progs/arm_db.ads
new file mode 100755
index 0000000..4adf04b
--- /dev/null
+++ b/progs/arm_db.ads
@@ -0,0 +1,118 @@
+package ARM_Database is
+
+    --
+    -- Ada reference manual formatter (ARM_Form).
+    --
+    -- This package contains the database to store items for non-normative
+    -- appendixes.
+    --
+    -- ---------------------------------------
+    -- Copyright 2000, 2004, 2005, 2006, 2011
+    --   AXE Consultants. All rights reserved.
+    -- P.O. Box 1512, Madison WI  53701
+    -- E-Mail: randy@rrsoftware.com
+    --
+    -- ARM_Form is free software: you can redistribute it and/or modify
+    -- it under the terms of the GNU General Public License version 3
+    -- as published by the Free Software Foundation.
+    --
+    -- AXE CONSULTANTS MAKES THIS TOOL AND SOURCE CODE AVAILABLE ON AN "AS IS"
+    -- BASIS AND MAKES NO WARRANTY, EXPRESS OR IMPLIED, AS TO THE ACCURACY,
+    -- CAPABILITY, EFFICIENCY, MERCHANTABILITY, OR FUNCTIONING OF THIS TOOL.
+    -- IN NO EVENT WILL AXE CONSULTANTS BE LIABLE FOR ANY GENERAL,
+    -- CONSEQUENTIAL, INDIRECT, INCIDENTAL, EXEMPLARY, OR SPECIAL DAMAGES,
+    -- EVEN IF AXE CONSULTANTS HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
+    -- DAMAGES.
+    --
+    -- A copy of the GNU General Public License is available in the file
+    -- gpl-3-0.txt in the standard distribution of the ARM_Form tool.
+    -- Otherwise, see <http://www.gnu.org/licenses/>.
+    --
+    -- If the GPLv3 license is not satisfactory for your needs, a commercial
+    -- use license is available for this tool. Contact Randy at AXE Consultants
+    -- for more information.
+    --
+    -- ---------------------------------------
+    --
+    -- Edit History:
+    --
+    --  5/16/00 - RLB - Created package.
+    --  8/10/00 - RLB - Added Normal_Indexed_List to fix glossary problems.
+    --  8/28/00 - RLB - Added revision info to database.
+    -- 10/28/04 - RLB - Added Inserted_Normal_Number change kind.
+    -- 11/02/04 - RLB - Added Deleted_Inserted_Number change kind.
+    -- 12/06/04 - RLB - Added Revised_Inserted_Number change kind.
+    --  1/19/05 - RLB - Added Added_Version.
+    --  2/15/06 - RLB - Added Deleted_No_Delete_Message and
+    --                 Deleted_Inserted_Number_No_Delete_Message change kinds.
+    -- 10/18/06 - RLB - Added No_Deleted_Paragraph_Messages to Report.
+    -- 10/18/11 - RLB - Changed to GPLv3 license.
+    -- 10/20/11 - RLB - Added Initial_Version parameter.
+
+    type Database_Type is tagged limited private;
+
+    type Paragraph_Change_Kind_Type is (None, Inserted, Inserted_Normal_Number,
+       Deleted, Deleted_Inserted_Number,
+       Deleted_No_Delete_Message,
+       Deleted_Inserted_Number_No_Delete_Message,
+       Revised, Revised_Inserted_Number);
+
+    Not_Valid_Error : exception;
+
+    procedure Create (Database_Object : in out Database_Type);
+       -- Initialize a database object.
+
+    procedure Destroy (Database_Object : in out Database_Type);
+       -- Destroy a database object, freeing any resources used.
+
+    procedure Insert (Database_Object : in out Database_Type;
+                     Sort_Key : in String;
+                     Hang_Item : in String;
+                     Text : in String;
+                     Change_Kind : in Paragraph_Change_Kind_Type := 
ARM_Database.None;
+                     Version : in Character := '0';
+                     Initial_Version : in Character := '0');
+       -- Insert an item into the database object.
+       -- Sort_Key is the string on which this item will be sorted (if it
+       -- is sorted). Hang_Item is the item which hangs out for the item
+       -- in the report (if any). Text is the text for the item; the text
+       -- may include formatting codes. Change_Kind and Version are the
+       -- revision status for this item. Initial_Version is the version of
+       -- the initial text for this item.
+
+    type Format_Type is
+       (Normal_List, Normal_Indexed_List, Bullet_List, Hanging_List);
+
+    generic
+       with procedure Format_Text (Text : in String;
+                                   Text_Name : in String);
+    procedure Report (Database_Object : in out Database_Type;
+                     In_Format : in Format_Type;
+                     Sorted : in Boolean;
+                     Added_Version : Character := '0';
+                     No_Deleted_Paragraph_Messages : in Boolean := False);
+       -- Output the items with the appropriate format to the
+       -- "Format_Text" routine. "Format_Text" allows all commands
+       -- for the full formatter. (Text_Name is an identifying name
+       -- for error messages). This is an added list for Added_Version
+       -- ('0' meaning it is not added); in that case, use normal numbers
+       -- for items with a version less than or equal to Added_Version.
+       -- (This is intended to be used to output the items to
+       -- appropriate Format and Output objects; but we can't do that
+       -- directly because that would make this unit recursive with
+       -- ARM_Format.
+       -- No paragraphs will be have deleted paragraph messages if
+       -- No_Deleted_Paragraph_Messages is True.
+private
+
+    type Item;
+    type Item_List is access all Item;
+    type Database_Type is tagged limited record
+       Is_Valid : Boolean := False;
+       List : Item_List;
+       Item_Count : Natural;
+    end record;
+
+end ARM_Database;
+
+
diff --git a/progs/arm_file.adb b/progs/arm_file.adb
new file mode 100755
index 0000000..8e0d971
--- /dev/null
+++ b/progs/arm_file.adb
@@ -0,0 +1,186 @@
+--with ARM_Input,
+--     Ada.Text_IO;
+package body ARM_File is
+
+    --
+    -- Ada reference manual formatter (ARM_Form).
+    --
+    -- This package contains the definition of reading an input file.
+    --
+    -- ---------------------------------------
+    -- Copyright 2000, 2011
+    --   AXE Consultants. All rights reserved.
+    -- P.O. Box 1512, Madison WI  53704
+    -- E-Mail: randy@rrsoftware.com
+    --
+    -- ARM_Form is free software: you can redistribute it and/or modify
+    -- it under the terms of the GNU General Public License version 3
+    -- as published by the Free Software Foundation.
+    --
+    -- AXE CONSULTANTS MAKES THIS TOOL AND SOURCE CODE AVAILABLE ON AN "AS IS"
+    -- BASIS AND MAKES NO WARRANTY, EXPRESS OR IMPLIED, AS TO THE ACCURACY,
+    -- CAPABILITY, EFFICIENCY, MERCHANTABILITY, OR FUNCTIONING OF THIS TOOL.
+    -- IN NO EVENT WILL AXE CONSULTANTS BE LIABLE FOR ANY GENERAL,
+    -- CONSEQUENTIAL, INDIRECT, INCIDENTAL, EXEMPLARY, OR SPECIAL DAMAGES,
+    -- EVEN IF AXE CONSULTANTS HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
+    -- DAMAGES.
+    --
+    -- A copy of the GNU General Public License is available in the file
+    -- gpl-3-0.txt in the standard distribution of the ARM_Form tool.
+    -- Otherwise, see <http://www.gnu.org/licenses/>.
+    --
+    -- If the GPLv3 license is not satisfactory for your needs, a commercial
+    -- use license is available for this tool. Contact Randy at AXE Consultants
+    -- for more information.
+    --
+    -- ---------------------------------------
+    --
+    -- Edit History:
+    --
+    --  5/15/00 - RLB - Created package.
+    -- 10/18/11 - RLB - Changed to GPLv3 license.
+
+    procedure Open (Input_Object : in out File_Input_Type;
+                   File_Name : in String) is
+       -- Open an input object for a file.
+       -- This may propagate file exceptions.
+    begin
+        Ada.Text_IO.Open (Input_Object.Fyle, Ada.Text_IO.In_File, File_Name);
+        Input_Object.Line_Counter := 0;
+        Input_Object.Buffer_Last := 0;
+        Input_Object.Buffer_Index := 0;
+        Input_Object.Is_Valid := True;
+       if File_Name'Length > Input_Object.Name'Length then
+           Input_Object.Name := File_Name(File_Name'First .. File_Name'First + 
Input_Object.Name'Length - 1);
+           Input_Object.Name_Len := Input_Object.Name'Length;
+       else
+           Input_Object.Name(1..File_Name'Length) := File_Name;
+           Input_Object.Name_Len := File_Name'Length;
+       end if;
+    end Open;
+
+
+    procedure Close (Input_Object : in out File_Input_Type) is
+       -- Close the input object (entity).
+       -- May propagate exceptions from the underlying implementation
+       -- (that is, I/O exceptions).
+    begin
+       if not Input_Object.Is_Valid then
+           raise ARM_Input.Not_Valid_Error;
+       end if;
+       Input_Object.Is_Valid := False;
+        Ada.Text_IO.Close (Input_Object.Fyle);
+    end Close;
+
+
+    procedure Get_Char (Input_Object : in out File_Input_Type;
+                       Char : out Character) is
+        -- We represent end of line by Ascii.LF.
+        -- Raises: End_Error when the end of file is reached.
+       --         Not_Valid_Error if Input_Object is not valid (open).
+    begin
+       if not Input_Object.Is_Valid then
+           raise ARM_Input.Not_Valid_Error;
+       end if;
+        if Input_Object.Buffer_Index >= Input_Object.Buffer_Last then
+           begin
+               Ada.Text_IO.Get_Line (Input_Object.Fyle,
+                                     Input_Object.Buffer,
+                                     Input_Object.Buffer_Last);
+                   -- Raises End_Error when the end of the file is reached.
+           exception
+               when Ada.Text_IO.End_Error =>
+                   -- Set so we can do a Replace_Char on this.
+                   Input_Object.Buffer_Index := 1;
+                   Input_Object.Buffer_Last := 1;
+                   Input_Object.Buffer(1) := Ascii.SUB; -- File end marker.
+                   Char := Ascii.SUB;
+                   return;
+           end;
+           if Input_Object.Buffer_Last < Input_Object.Buffer'Last then
+               Input_Object.Buffer_Last := Input_Object.Buffer_Last + 1;
+               Input_Object.Buffer(Input_Object.Buffer_Last) := Ascii.LF; -- 
Line end marker.
+           -- else broken line, no end needed.
+           end if;
+           --Ada.Text_IO.Put(Natural'Image(Input_Object.Line_Counter) & ":");
+           --Ada.Text_IO.Put_Line ("&& " & 
Input_Object.Buffer(1..Input_Object.Buffer_Last));
+           Input_Object.Buffer_Index := 0;
+           Input_Object.Line_Counter := Input_Object.Line_Counter + 1;
+        end if;
+        Input_Object.Buffer_Index := Input_Object.Buffer_Index + 1;
+        if Input_Object.Recording then
+           Input_Object.Recording_Len := Input_Object.Recording_Len + 1;
+           Input_Object.Recording_Buffer(Input_Object.Recording_Len) :=
+               Input_Object.Buffer(Input_Object.Buffer_Index);
+        end if;
+        Char := Input_Object.Buffer(Input_Object.Buffer_Index);
+    end Get_Char;
+
+
+    procedure Replace_Char (Input_Object : in out File_Input_Type) is
+       -- Replaces the last character read (with Get_Char); the next call
+       -- to Get_Char will return it.
+        -- Raises: Not_Valid_Error if Input_Object is not valid (open).
+    begin
+       if not Input_Object.Is_Valid then
+           raise ARM_Input.Not_Valid_Error;
+       end if;
+        if Input_Object.Buffer_Index = 0 then
+           raise Program_Error; -- Called twice or before any calls to 
Get_Char.
+        end if;
+        Input_Object.Buffer_Index := Input_Object.Buffer_Index - 1;
+        if Input_Object.Recording then
+           Input_Object.Recording_Len := Input_Object.Recording_Len - 1;
+        end if;
+    end Replace_Char;
+
+
+    function Line_String (Input_Object : in File_Input_Type) return String is
+        -- Returns a string representing the line number and entity.
+       -- Usually used in error messages.
+        -- Raises: Not_Valid_Error if Input_Object is not valid (open).
+    begin
+       if not Input_Object.Is_Valid then
+           raise ARM_Input.Not_Valid_Error;
+       end if;
+        return Natural'Image(Input_Object.Line_Counter) & " - " &
+               Input_Object.Name(1..Input_Object.Name_Len);
+    end Line_String;
+
+
+    procedure Start_Recording (Input_Object : in out File_Input_Type) is
+        -- Start recording all characters read into a local buffer.
+        -- Use this when text needs to be formatted into the output
+        -- file *and* be saved for future use.
+        -- Raises: Not_Valid_Error if Input_Object is not valid (open).
+    begin
+       if not Input_Object.Is_Valid then
+           raise ARM_Input.Not_Valid_Error;
+       end if;
+        Input_Object.Recording := True;
+        Input_Object.Recording_Len := 0;
+    end Start_Recording;
+
+
+    procedure Stop_Recording_and_Read_Result
+        (Input_Object : in out File_Input_Type; Result : out String;
+        Len : out Natural) is
+        -- Stop recording characters read. Put the result into Result,
+        -- and the number of characters written into Len.
+        -- Raises: Not_Valid_Error if Input_Object is not valid (open).
+    begin
+       if not Input_Object.Is_Valid then
+           raise ARM_Input.Not_Valid_Error;
+       end if;
+        if Input_Object.Recording_Len > Result'Length then
+           Ada.Text_IO.Put_Line ("  ** Too many characters recorded on line " 
& Line_String (Input_Object));
+           Len := 0;
+        else
+           Result (Result'First .. Result'First + Input_Object.Recording_Len - 
1) :=
+                Input_Object.Recording_Buffer (1 .. 
Input_Object.Recording_Len);
+           Len := Input_Object.Recording_Len;
+        end if;
+        Input_Object.Recording := False;
+    end Stop_Recording_and_Read_Result;
+
+end ARM_File;
diff --git a/progs/arm_file.ads b/progs/arm_file.ads
new file mode 100755
index 0000000..d3e509f
--- /dev/null
+++ b/progs/arm_file.ads
@@ -0,0 +1,100 @@
+with ARM_Input,
+     Ada.Text_IO;
+package ARM_File is
+
+    --
+    -- Ada reference manual formatter (ARM_Form).
+    --
+    -- This package contains the definition of reading an input file.
+    --
+    -- ---------------------------------------
+    -- Copyright 2000, 2011
+    --   AXE Consultants. All rights reserved.
+    -- P.O. Box 1512, Madison WI  53704
+    -- E-Mail: randy@rrsoftware.com
+    --
+    -- ARM_Form is free software: you can redistribute it and/or modify
+    -- it under the terms of the GNU General Public License version 3
+    -- as published by the Free Software Foundation.
+    --
+    -- AXE CONSULTANTS MAKES THIS TOOL AND SOURCE CODE AVAILABLE ON AN "AS IS"
+    -- BASIS AND MAKES NO WARRANTY, EXPRESS OR IMPLIED, AS TO THE ACCURACY,
+    -- CAPABILITY, EFFICIENCY, MERCHANTABILITY, OR FUNCTIONING OF THIS TOOL.
+    -- IN NO EVENT WILL AXE CONSULTANTS BE LIABLE FOR ANY GENERAL,
+    -- CONSEQUENTIAL, INDIRECT, INCIDENTAL, EXEMPLARY, OR SPECIAL DAMAGES,
+    -- EVEN IF AXE CONSULTANTS HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
+    -- DAMAGES.
+    --
+    -- A copy of the GNU General Public License is available in the file
+    -- gpl-3-0.txt in the standard distribution of the ARM_Form tool.
+    -- Otherwise, see <http://www.gnu.org/licenses/>.
+    --
+    -- If the GPLv3 license is not satisfactory for your needs, a commercial
+    -- use license is available for this tool. Contact Randy at AXE Consultants
+    -- for more information.
+    --
+    -- ---------------------------------------
+    --
+    -- Edit History:
+    --
+    --  5/15/00 - RLB - Created package.
+    -- 10/18/11 - RLB - Changed to GPLv3 license.
+
+    type File_Input_Type is new ARM_Input.Input_Type with private;
+
+    procedure Open (Input_Object : in out File_Input_Type;
+                   File_Name : in String);
+       -- Open an input object for a file.
+       -- This may propagate file exceptions.
+
+    procedure Close (Input_Object : in out File_Input_Type);
+       -- Close the input object (entity).
+       -- May propagate exceptions from the underlying implementation
+       -- (that is, I/O exceptions).
+
+    procedure Get_Char (Input_Object : in out File_Input_Type;
+                       Char : out Character);
+        -- We represent end of line by Ascii.LF.
+        -- Raises: End_Error when the end of file is reached.
+       --         Not_Valid_Error if Input_Object is not valid (open).
+
+    procedure Replace_Char (Input_Object : in out File_Input_Type);
+       -- Replaces the last character read (with Get_Char); the next call
+       -- to Get_Char will return it.
+        -- Raises: Not_Valid_Error if Input_Object is not valid (open).
+
+    function Line_String (Input_Object : in File_Input_Type) return String;
+        -- Returns a string representing the line number and entity.
+       -- Usually used in error messages.
+        -- Raises: Not_Valid_Error if Input_Object is not valid (open).
+
+    procedure Start_Recording (Input_Object : in out File_Input_Type);
+        -- Start recording all characters read into a local buffer.
+        -- Use this when text needs to be formatted into the output
+        -- file *and* be saved for future use.
+        -- Raises: Not_Valid_Error if Input_Object is not valid (open).
+
+    procedure Stop_Recording_and_Read_Result
+        (Input_Object : in out File_Input_Type; Result : out String;
+        Len : out Natural);
+        -- Stop recording characters read. Put the result into Result,
+        -- and the number of characters written into Len.
+        -- Raises: Not_Valid_Error if Input_Object is not valid (open).
+
+private
+    type File_Input_Type is new ARM_Input.Input_Type with record
+       Is_Valid : Boolean := False;
+       Fyle : Ada.Text_IO.File_Type;
+       Line_Counter : Natural := 0;
+       Buffer : String(1..250);
+       Buffer_Last : Natural := 0;
+       Buffer_Index : Natural := 0; -- Last character read from buffer.
+       -- For recording:
+       Recording : Boolean := False;
+       Recording_Buffer : String(1..ARM_Input.MAX_RECORDING_SIZE);
+       Recording_Len : Natural := 0;
+       -- Name:
+       Name : String(1..120);
+       Name_Len : Natural;
+    end record;
+end ARM_File;
diff --git a/progs/arm_form.ada b/progs/arm_form.ada
new file mode 100755
index 0000000..3606442
--- /dev/null
+++ b/progs/arm_form.ada
@@ -0,0 +1,329 @@
+with Ada.Text_IO,
+     Ada.Strings.Fixed,
+     Ada.Strings.Unbounded,
+     Ada.Characters.Handling,
+     Ada.Command_Line;
+with ARM_Master,
+     ARM_Contents,
+     ARM_Format;
+procedure ARM_Formatter is
+
+    --
+    -- Ada reference manual formatter (ARM_Form).
+    --
+    -- This is the main subprogram: format the sources for the
+    -- Ada reference manual and other documents
+    -- (in a vaguely Scribe-like macro language) into the actual
+    -- reference manual files (in various formats).
+    --
+    -- ---------------------------------------
+    -- Copyright 2000, 2002, 2004, 2005, 2006, 2011, 2012, 2016
+    --   AXE Consultants. All rights reserved.
+    -- P.O. Box 1512, Madison WI  53701
+    -- E-Mail: randy@rrsoftware.com
+    --
+    -- ARM_Form is free software: you can redistribute it and/or modify
+    -- it under the terms of the GNU General Public License version 3
+    -- as published by the Free Software Foundation.
+    --
+    -- AXE CONSULTANTS MAKES THIS TOOL AND SOURCE CODE AVAILABLE ON AN "AS IS"
+    -- BASIS AND MAKES NO WARRANTY, EXPRESS OR IMPLIED, AS TO THE ACCURACY,
+    -- CAPABILITY, EFFICIENCY, MERCHANTABILITY, OR FUNCTIONING OF THIS TOOL.
+    -- IN NO EVENT WILL AXE CONSULTANTS BE LIABLE FOR ANY GENERAL,
+    -- CONSEQUENTIAL, INDIRECT, INCIDENTAL, EXEMPLARY, OR SPECIAL DAMAGES,
+    -- EVEN IF AXE CONSULTANTS HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
+    -- DAMAGES.
+    --
+    -- A copy of the GNU General Public License is available in the file
+    -- gpl-3-0.txt in the standard distribution of the ARM_Form tool.
+    -- Otherwise, see <http://www.gnu.org/licenses/>.
+    --
+    -- If the GPLv3 license is not satisfactory for your needs, a commercial
+    -- use license is available for this tool. Contact Randy at AXE Consultants
+    -- for more information.
+    --
+    -- ---------------------------------------
+    --
+    -- Edit History:
+    --
+    --  3/ 9/00 - RLB - Created base program.
+    --  4/14/00 - RLB - Created from analysis program.
+    --  4/18/00 - RLB - Added scanning pass.
+    --  4/19/00 - RLB - Split 03 into two files. Added HTML output object.
+    --  4/24/00 - RLB - Added Change_Kind and Display_Index_Entries.
+    --  5/15/00 - RLB - Split formatter from input.
+    --  5/16/00 - RLB - Added missing Destroy for formatting objects.
+    --  5/18/00 - RLB - Added RTF output object.
+    --  5/25/00 - RLB - Added the Big-Files option. Added the library 
separator.
+    --  5/28/00 - RLB - Added index.
+    --  8/31/00 - RLB - Added the New-Changes option.
+    --  7/18/02 - RLB - Changed copyright date.
+    --          - RLB - Changed Creates to include title and header.
+    --          - RLB - Added Version parameter to command line and formatting
+    --                  commands.
+    --  9/10/04 - RLB - Updated descriptions of standard commands.
+    --  9/14/04 - RLB - Moved version to ARM_Contents.
+    -- 12/05/04 - RLB - Split/added various source files.
+    --  6/ 2/05 - RLB - Added Corrigendum output module for comparisons to
+    --                  Amendment document.
+    -- 10/12/05 - RLB - Changed the title to reflect what we learned from ISO.
+    -- 10/28/05 - RLB - Added Annex Q.
+    --  1/ 5/06 - RLB - Revised to use master files, rather than hard-coded
+    --                  properties.
+    --  1/12/06 - RLB - Removed Document completely.
+    -- 10/18/11 - RLB - Changed to GPLv3 license.
+    -- 10/19/11 - RLB - Removed junk withs (now in master file handler).
+    --  4/ 3/12 - RLB - Removed dead variable.
+    --  8/31/12 - RLB - Added output path parameter.
+    --  3/17/16 - RLB - Added lower version to command line.
+
+    -- Standard commands for Ada standards:
+    -- For Original (Ada 95) RM:
+    --     Arm_Form RM <Format> No-Changes 0 0
+    -- For Original AARM:
+    --     Arm_Form AARM <Format> No-Changes 0 0
+    -- For RM with Corr:
+    --     [With change bars for Word 97/2000:]
+    --     Arm_Form RM RTF New-Changes 1 1
+    --     [Final versions with no changes:]
+    --     Arm_Form RM <Format> New-Only 1 1
+    -- For AARM with Corr:
+    --     [HTML; RTF for display]:
+    --        Arm_Form AARM <Format> Show-Changes 1 1
+    --     [TXT; RTF for printing]:
+    --        Arm_Form AARM <Format> New-Only 1 1
+    -- For RM with Corr and Amd:
+    --     [With change bars for Word 97/2000:]
+    --     Arm_Form RM RTF New-Changes 1 2
+    --     [With change ballons for Word XP/2003:]
+    --     Arm_Form RM RTF Show-Changes 1 2
+    --     [Final versions with no changes:]
+    --     Arm_Form RM <Format> New-Only 1 2
+    -- For AARM with Corr and Amd:
+    --     [HTML; RTF for display]:
+    --        Arm_Form AARM <Format> Show-Changes 2 2
+    --        (for only Amd changes) or
+    --        Arm_Form AARM <Format> Show-Changes 1 2
+    --        (for all changes)
+    --     [TXT; RTF for printing]:
+    --        Arm_Form AARM <Format> New-Only 2 2
+    -- For Ada 2012 RM: (To include TC1, change 3 to 4).
+    --     [With change ballons for Word XP/2003:]
+    --     Arm_Form RM RTF Show-Changes 1 3
+    --     [For change bar version for Word 97/2000:]
+    --     Arm_Form RM RTF Show-Changes 3 3
+    --     [Final versions with no changes:]
+    --     Arm_Form RM <Format> New-Only 3 3
+    -- For Ada 2012 AARM: (To include TC1, change 3 to 4).
+    --     [HTML; RTF for display]:
+    --        Arm_Form AARM <Format> Show-Changes 3 3
+    --        (for only Amd 2012 changes) or
+    --        Arm_Form AARM <Format>  Show-Changes 1 3
+    --        (for all changes)
+    --     [TXT; RTF for printing]:
+    --        Arm_Form AARM <Format> New-Only 1 3
+    -- For Ada 202x RM:
+    --     [For change bar version:]
+    --     Arm_Form RM RTF Show-Changes 4 5
+    --     [Final versions with no changes:]
+    --     Arm_Form RM <Format> New-Only 5 5
+    -- For Ada 202x AARM with:
+    --     [HTML; RTF for display]:
+    --        Arm_Form AARM <Format> Show-Changes 4 5
+    --        (for only Amd 2012 changes) or
+    --        Arm_Form AARM <Format>  Show-Changes 1 5
+    --        (for all changes)
+    --     [TXT; RTF for printing]:
+    --        Arm_Form AARM <Format> New-Only 5 5
+
+
+    No_Command_Error : exception;
+
+    Format : ARM_Master.Output_Format_Type; -- Format to generate.
+    Master_File : Ada.Strings.Unbounded.Unbounded_String; -- Master file for 
document to generate.
+    Change_Kind : ARM_Format.Change_Kind; -- Changes to generate.
+    Base_Change_Version : ARM_Contents.Change_Version_Type; -- Lower Change 
version.
+    Change_Version : ARM_Contents.Change_Version_Type; -- (Upper) Change 
version.
+    Output_Path : Ada.Strings.Unbounded.Unbounded_String; -- Output path.
+
+    procedure Get_Commands is
+        -- Process the command line for this program.
+    begin
+        if Ada.Command_Line.Argument_Count not in 1 .. 6 then
+            Ada.Text_IO.Put_Line ("** Wrong number of arguments");
+            raise No_Command_Error;
+        end if;
+        if Ada.Command_Line.Argument_Count >= 6 then
+            Output_Path := Ada.Strings.Unbounded.To_Unbounded_String(
+                    Ada.Strings.Fixed.Trim (Ada.Command_Line.Argument(6),
+                       Ada.Strings.Right));
+            -- Check that the Output_Path ends with a path separator.
+            -- Note: This is a simple Windows check; it doesn't check for and
+            -- allow bare disk names. This check works on Linux but allows
+            -- ending with '\' which does not work on Linux (that will be
+            -- failed when the files are opened).
+            declare
+                Last : constant Character :=
+                    Ada.Strings.Unbounded.Element (Ada.Strings.Unbounded.Tail 
(Output_Path, 1), 1);
+            begin
+                if Last = '/' or else Last = '\' then
+                    null; -- OK; this ends with a path separator.
+                else
+                    Ada.Text_IO.Put_Line ("** Output path does not end with a 
path separator: " &
+                        Ada.Strings.Unbounded.To_String (Output_Path));
+                    raise No_Command_Error;
+                end if;
+            end;
+        else
+            Output_Path := Ada.Strings.Unbounded.To_Unbounded_String
+                ("./output/"); -- Use '/' so this works on Linux and Windows.
+        end if;
+        if Ada.Command_Line.Argument_Count >= 5 then
+            declare
+                Version_Arg : String :=
+                     Ada.Characters.Handling.To_Lower (
+                        Ada.Strings.Fixed.Trim (Ada.Command_Line.Argument(5),
+                        Ada.Strings.Right));
+            begin
+                if Version_Arg'Length = 1 and then
+                   Version_Arg(Version_Arg'First) in 
ARM_Contents.Change_Version_Type then
+                    Change_Version := Version_Arg(Version_Arg'First);
+                else
+                    Ada.Text_IO.Put_Line ("** Unrecognized change version: " & 
Version_Arg);
+                    raise No_Command_Error;
+                end if;
+            end;
+        else
+            Change_Version := '0';
+        end if;
+        if Ada.Command_Line.Argument_Count >= 4 then
+            declare
+                Version_Arg : String :=
+                     Ada.Characters.Handling.To_Lower (
+                        Ada.Strings.Fixed.Trim (Ada.Command_Line.Argument(4),
+                        Ada.Strings.Right));
+            begin
+                if Version_Arg'Length = 1 and then
+                   Version_Arg(Version_Arg'First) in 
ARM_Contents.Change_Version_Type then
+                    Base_Change_Version := Version_Arg(Version_Arg'First);
+                else
+                    Ada.Text_IO.Put_Line ("** Unrecognized change version: " & 
Version_Arg);
+                    raise No_Command_Error;
+                end if;
+            end;
+        else
+            Base_Change_Version := '0';
+        end if;
+        if Ada.Command_Line.Argument_Count >= 3 then
+            declare
+                Changes_Arg : String :=
+                     Ada.Characters.Handling.To_Lower (
+                        Ada.Strings.Fixed.Trim (Ada.Command_Line.Argument(3),
+                        Ada.Strings.Right));
+            begin
+                if Changes_Arg = "no-changes" then
+                    Change_Kind := ARM_Format.Old_Only;
+                elsif Changes_Arg = "new-only" then
+                    Change_Kind := ARM_Format.New_Only;
+                elsif Changes_Arg = "show-changes" then
+                    Change_Kind := ARM_Format.Show_Changes;
+                elsif Changes_Arg = "new-changes" then
+                    Change_Kind := ARM_Format.New_Changes;
+                else
+                    Ada.Text_IO.Put_Line ("** Unrecognized changes: " & 
Changes_Arg);
+                    raise No_Command_Error;
+                end if;
+            end;
+        else
+            Change_Kind := ARM_Format.New_Only;
+        end if;
+        if Ada.Command_Line.Argument_Count >= 2 then
+            declare
+                Format_Arg : String :=
+                     Ada.Characters.Handling.To_Lower (
+                        Ada.Strings.Fixed.Trim (Ada.Command_Line.Argument(2),
+                        Ada.Strings.Right));
+            begin
+                if Format_Arg = "rtf" then
+                    Format := ARM_Master.RTF;
+                elsif Format_Arg = "html" then
+                    Format := ARM_Master.HTML;
+                elsif Format_Arg = "text" then
+                    Format := ARM_Master.Text;
+                elsif Format_Arg = "corr" then
+                    Format := ARM_Master.Corr;
+                elsif Format_Arg = "info" then
+                    Format := ARM_Master.Info;
+                else
+                    Ada.Text_IO.Put_Line ("** Unrecognized format: " & 
Format_Arg);
+                    raise No_Command_Error;
+                end if;
+            end;
+        else
+            Format := ARM_Master.HTML;
+        end if;
+        declare
+            use type Ada.Strings.Unbounded.Unbounded_String;
+        begin
+            Master_File := Ada.Strings.Unbounded.To_Unbounded_String
+              (Ada.Characters.Handling.To_Lower
+                 (Ada.Strings.Fixed.Trim (Ada.Command_Line.Argument(1), 
Ada.Strings.Right)));
+            if Ada.Strings.Unbounded.Index (Master_File, ".") = 0 then
+                -- Add extension if it is missing.
+                Master_File := Master_File & ".msm";
+            end if;
+        end;
+    exception
+        when No_Command_Error =>
+            Ada.Text_IO.Put_Line ("  Usage: Arm_Form <Master_File> [<Format>[ 
<Changes>[ <BaseVers>[ <ChgVers>[ <Output Path>]]]]]}");
+            Ada.Text_IO.Put_Line ("     where: <Master_File> is the file name 
(and optional path) for the master file");
+            Ada.Text_IO.Put_Line ("                        for the document;");
+            Ada.Text_IO.Put_Line ("     where: <Format> = 'Text' (text 
files),");
+            Ada.Text_IO.Put_Line ("                       'HTML' (HTML 
files),");
+            Ada.Text_IO.Put_Line ("                       'RTF' (RTF files for 
Word 97 or later),");
+            Ada.Text_IO.Put_Line ("                       'Corr' 
(Corrigendum-style command files for comparisons);");
+            Ada.Text_IO.Put_Line ("     where: <Changes> = 'No-Changes' 
(Original RM text),");
+            Ada.Text_IO.Put_Line ("                        'New-Only' (Revised 
RM text only up to <ChgVers>),");
+            Ada.Text_IO.Put_Line ("                        'Show-Changes' 
(Text with changes marked between");
+            Ada.Text_IO.Put_Line ("                                        
<BaseVers> and <ChgVers>),");
+            Ada.Text_IO.Put_Line ("                        'New-Changes' (Text 
with insertions marked between");
+            Ada.Text_IO.Put_Line ("                                        
<BaseVers> and <ChgVers>);");
+            Ada.Text_IO.Put_Line ("     where: <BaseVers> and <ChgVers> = a 
value in 0 .. 9 representing the");
+            Ada.Text_IO.Put_Line ("                        base and primary 
change versions, respectively");
+            Ada.Text_IO.Put_Line ("                        0-Original Ada 95 
(equivalent to No-Changes)");
+            Ada.Text_IO.Put_Line ("                        1-Technical 
Corrigendum 1");
+            Ada.Text_IO.Put_Line ("                        2-Amendment 1");
+            Ada.Text_IO.Put_Line ("                        3-Ada 2012");
+            Ada.Text_IO.Put_Line ("                        4-Ada 2012 
Technical Corrigendum 1");
+            Ada.Text_IO.Put_Line ("                        5-Ada 202x");
+            Ada.Text_IO.Put_Line ("     where: <Output_Path> = it the path 
where to write the result files. This must");
+            Ada.Text_IO.Put_Line ("                        end with a path 
separator. It defaults to ./output/");
+            raise No_Command_Error;
+    end Get_Commands;
+
+
+begin
+    Ada.Text_IO.Put_Line ("Ada Manual formatter");
+    Ada.Text_IO.Put_Line ("  Copyright 2000, 2002, 2004, 2005, 2006, 2011, 
2012, 2016  AXE Consultants");
+    Ada.Text_IO.Put_Line ("  P.O. Box 1512, Madison WI  53701");
+
+    Get_Commands;
+
+Ada.Text_IO.Put_Line ("  Master File = " & 
Ada.Strings.Unbounded.To_String(Master_File));
+Ada.Text_IO.Put_Line ("  Format = " & 
ARM_Master.Output_Format_Type'Image(Format));
+Ada.Text_IO.Put_Line ("  Changes = " & 
ARM_Format.Change_Kind'Image(Change_Kind));
+Ada.Text_IO.Put_Line ("  Version = " & Change_Version);
+
+    ARM_Master.Read_and_Process_Master_File (
+                File_Name => Ada.Strings.Unbounded.To_String(Master_File),
+                The_Change_Kind => Change_Kind,
+                The_Change_Version => Change_Version,
+                The_Base_Change_Version => Base_Change_Version,
+                Output_Format => Format,
+                Output_Path => Ada.Strings.Unbounded.To_String(Output_Path));
+
+    Ada.Text_IO.Put_Line ("Ada document created");
+exception
+    when No_Command_Error =>
+        null; -- Error message displayed by command line processor.
+end ARM_Formatter;
diff --git a/progs/arm_frm.adb b/progs/arm_frm.adb
new file mode 100755
index 0000000..f730483
--- /dev/null
+++ b/progs/arm_frm.adb
@@ -0,0 +1,11211 @@
+with -- ARM_Output, -- redudant with spec
+--   ARM_Input,
+     ARM_File,
+     ARM_String,
+--   ARM_Contents,
+--   ARM_Database,
+     ARM_Syntax,
+     ARM_Index,
+--   ARM_Subindex,
+     ARM_Format.Data,
+     Ada.Text_IO,
+     Ada.Characters.Handling,
+     Ada.Strings.Fixed;
+package body ARM_Format is
+
+    --
+    -- Ada reference manual formatter (ARM_Form).
+    --
+    -- This package contains the routines to parse the input files, and
+    -- determine what to output.
+    --
+    -- ---------------------------------------
+    -- Copyright 2000, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
+    --           2010, 2011, 2012, 2013, 2016
+    -- AXE Consultants. All rights reserved.
+    -- P.O. Box 1512, Madison WI  53701
+    -- E-Mail: randy@rrsoftware.com
+    --
+    -- ARM_Form is free software: you can redistribute it and/or modify
+    -- it under the terms of the GNU General Public License version 3
+    -- as published by the Free Software Foundation.
+    --
+    -- AXE CONSULTANTS MAKES THIS TOOL AND SOURCE CODE AVAILABLE ON AN "AS IS"
+    -- BASIS AND MAKES NO WARRANTY, EXPRESS OR IMPLIED, AS TO THE ACCURACY,
+    -- CAPABILITY, EFFICIENCY, MERCHANTABILITY, OR FUNCTIONING OF THIS TOOL.
+    -- IN NO EVENT WILL AXE CONSULTANTS BE LIABLE FOR ANY GENERAL,
+    -- CONSEQUENTIAL, INDIRECT, INCIDENTAL, EXEMPLARY, OR SPECIAL DAMAGES,
+    -- EVEN IF AXE CONSULTANTS HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
+    -- DAMAGES.
+    --
+    -- A copy of the GNU General Public License is available in the file
+    -- gpl-3-0.txt in the standard distribution of the ARM_Form tool.
+    -- Otherwise, see <http://www.gnu.org/licenses/>.
+    --
+    -- If the GPLv3 license is not satisfactory for your needs, a commercial
+    -- use license is available for this tool. Contact Randy at AXE Consultants
+    -- for more information.
+    --
+    -- ---------------------------------------
+    --
+    -- Edit History:
+    --
+    --  4/14/00 - RLB - Created base package.
+    --  4/17/00 - RLB - Starting implementation of commands.
+    --  4/19/00 - RLB - Implemented contents package and section references.
+    --  4/21/00 - RLB - Added hard_space and line_break output routines.
+    --  4/24/00 - RLB - Added Change_Kind and Display_Index_Entries.
+    --         - RLB - Added Change and ChgRef.
+    --  4/26/00 - RLB - Added paragraph commands and formats.
+    --  4/29/00 - RLB - Loose ends: "Part", fixes for the example format,
+    --                 "DescribeCode" and "Itemize".
+    --  5/10/00 - RLB - Added missing "MetricsName" and "MetricsTitle".
+    --                 Added additional paragraph format kinds.
+    --  5/11/00 - RLB - Implemented numbers on enumerated paragraphs.
+    -- 5/12/00 - RLB - Added NoPrefix.
+    --         - RLB - Added attribute commands.
+    --  5/13/00 - RLB - Added various character macros.
+    --  5/15/00 - RLB - Split input from parsing/formatting.
+    --  5/16/00 - RLB - Added database objects and Destroy.
+    --         - RLB - Implemented pragma commands.
+    --  5/17/00 - RLB - Implemented syntax commands.
+    --  5/19/00 - RLB - Added hinge analysis.
+    --  5/23/00 - RLB - Added column commands.
+    --         - RLB - Added tab commands.
+    --  5/24/00 - RLB - Implemented subscript/superscript commands.
+    --  5/25/00 - RLB - Added more formatting commands and styles.
+    --  5/26/00 - RLB - Removed hinge analysis, other junk.
+    --  5/28/00 - RLB - Implemented index operations.
+    --  6/ 2/00 - RLB - Implemented @|.
+    --         - RLB - Added AdaDefn and AdaSubDefn commands, and unit saving.
+    --  8/ 2/00 - RLB - Implemented @! (as @| doesn't work); implemented
+    --                 lquote, etc.
+    --  8/ 4/00 - RLB - Added additional styles.
+    --  8/ 8/00 - RLB - Added Attribute_Leading.
+    --  8/11/00 - RLB - Fixed glossary report.
+    --         - RLB - Added Hanging_in_Bulleted low-level style.
+    --  8/15/00 - RLB - Replaced "LangDefType" with "AdaTypeDefn" (much 
smaller).
+    --  8/16/00 - RLB - Added double nesting support for InnerItemize.
+    --         - RLB - Added "noparanum" command; removed no paranum formats.
+    --  8/17/00 - RLB - Changed Leading flag to Space_After, added Trailing 
command.
+    --         - RLB - Added Nested_Enumerated styles.
+    --  8/18/00 - RLB - Fixed a variety of errors in the AARM paragraph 
numbering.
+    --         - RLB - Fixed Display_Index_Entry so it would work right when
+    --                 given in an insertion or deletion.
+    --  8/21/00 - RLB - Fixed so send and later references in a ChgReg command
+    --                 don't accidentally include all preceding ones.
+    --  8/22/00 - RLB - Added Labeled_Revised_Clause and
+    --                 Labeled_Revised_Subclause commands.
+    --  8/23/00 - RLB - Fixed Syntax_Rules to allow @Chg commands in the
+    --                 LHS.
+    --         - RLB - Fixed error in display of Defn2 index entries.
+    --  8/28/00 - RLB - Added implementation-defined changes command.
+    --  8/30/00 - RLB - Adjusted code in index entries to match old AARM.
+    --         - RLB - Made the deleted paragraph text appear in all new
+    --                 versions.
+    --         - RLB - Added AddedSubheading.
+    --  8/31/00 - RLB - Added the New_Changes change kind.
+    --         - RLB - Added RM_New_Page command.
+    --  9/ 1/00 - RLB - Fixed bugs that prevented "deleted paragraph" messages
+    --                 from appearing and caused junk headers to appear for
+    --                 sections not appearing in the old document.
+    --  9/ 8/00 - RLB - Added information about the language-defined
+    --                 subprograms to the index introduction.
+    --  9/26/00 - RLB - Added Syntax_Display format.
+    --  9/28/00 - RLB - Added RefSecbyNum command.
+    -- 10/30/00 - RLB - Added ISOOnly paragraph grouping.
+    --         - RLB - Fixed inserted paragraph numbers to support more than 9.
+    --  6/17/02 - RLB - Added Ada95 changes sections.
+    --  7/18/02 - RLB - Moved document type here.
+    --         - RLB - Added ARef= parameter to ChgRef.
+    --          - RLB - Added Changes_Only and versioning for individual 
changes.
+    --  4/10/03 - RLB - Fixed Index_Pragma to include "<name> pragma".
+    --  4/11/03 - RLB - Fixed order of removal for formatting for Heading and
+    --                 Subheading, so that the nesting is right (it needs to
+    --                 be exactly like the order of application).
+    --         - RLB - Fixed code so that parameter version numbers aren't
+    --                 displayed higher than the item we're generating.
+    --         - RLB - Fixed ChgRef and others not to generate anything if
+    --                 we're not generating the version that the reference is
+    --                 for. Similarly, avoid changing the paragraph kind if
+    --                 we're not going to use the changes.
+    --         - RLB - Fixed font for changing non-terminals in @Syn.
+    --  9/09/04 - RLB - Removed unused junk noticed by Stephen Leake.
+    --  9/10/04 - RLB - Added Version to many Text_Format commands.
+    --         - RLB - Fixed Get_NT to allow the Version parameter in @Chg.
+    --         - RLB - Updated to allow @Chg nesting.
+    --  9/14/04 - RLB - Moved Change_Version_Type to ARM_Contents.
+    --         - RLB - Added version number parameters to revised header
+    --                 commands; added additional header commands.
+    --         - RLB - Added code so that section references in Annex L and M
+    --                 are links.
+    --  9/15/04 - RLB - Fixed incorrect name for LabeledAddedSubClause command.
+    --         - RLB - Fixed to lift limit on number of inserted paragraphs.
+    -- 10/28/04 - RLB - Replaced double single quotes with double quotes,
+    --                 as directed by the ARG.
+    --         - RLB - Added "AddedNormal" ChgRef kind.
+    -- 10/29/04 - RLB - Added code so that section references in Annex K are
+    --                 links.
+    -- 11/02/04 - RLB - Added "DeletedAdded" ChgRef kind.
+    -- 11/03/04 - RLB - Fixed @Chg nesting glitch.
+    --         - RLB - Added InnerInnerItemize == Nested_X2_Bulleted.
+    -- 11/04/04 - RLB - Fixed a problem that reset the insertion number for
+    --                 paragraphs have a normal AARM para. was encountered.
+    -- 11/15/04 - RLB - Added Indented_Nested_Bulleted style.
+    -- 12/06/04 - RLB - Added "RevisedAdded" ChgRef kind.
+    --         - RLB - Delayed generation of references until the start of
+    --                 the paragraph. That avoids "pinning" problems,
+    --                 especially for multiple changes in a single paragraph.
+    --         - RLB - Allow multiple Ref and ARef params in ChgAttribute.
+    --         - RLB - Added ChgAdded and ChgDeleted for entire paragraph
+    --                 operations.
+    -- 12/11/04 - RLB - Fixed brackets in Added_Pragma_Syntax to allow {} in
+    --                 text.
+    --         - RLB - Implemented attribute adding in Change_Attribute.
+    -- 12/13/04 - RLB - Fixed problems in the new change commands.
+    -- 12/15/04 - RLB - Fixed so a change is not left open across
+    --                 an End_Hang_Item.
+    --         - RLB - Fixed glitches with deleted paragraphs.
+    --  1/19/05 - RLB - Added LabeledRevisedInformativeAnnex.
+    --         - RLB - Fixed AARM paragraph numbers to allow more than 52,
+    --                 and to put out an error message if we exceed the 
maximum.
+    --         - RLB - Added ChgDocReq and ChgImplAdvice.
+    --         - RLB - Added AddedDocReqList and AddedImplAdviceList.
+    --  1/20/05 - RLB - Added debugging for stack overflows.
+    --  1/24/05 - RLB - Added Inner_Indented.
+    -- 1/25/05 - RLB - Added AddedSyn and DeleteSyn commands.
+    --  2/ 1/05 - RLB - Added Turkish Is.
+    --  2/ 2/05 - RLB - Corrected so normal AARM numbers don't reset the
+    --                 RM insertion number.
+    --  3/15/05 - RLB - Corrected spelling.
+    --  5/27/05 - RLB - Added @Unicode command for examples.
+    --  8/ 9/05 - RLB - Changed the capitalization of some AARM note headers.
+    -- 10/17/05 - RLB - Added Glossary change commands.
+    -- 10/28/05 - RLB - Made index changes for Ada 200Y.
+    --         - RLB - Added added Annex headers.
+    --         - RLB - Added Language-Defined Entity indexes.
+    -- 10/31/05 - RLB - Fixed the "this paragraph was deleted" code to
+    --                 not change the version; it's not necessarily
+    --                 initialized, and the Kind isn't set anyway if the
+    --                 version is too new.
+    --  1/ 5/06 - RLB - Corrected a comment.
+    --  1/12/06 - RLB - Replaced "Document" with a number of new more general
+    --                 properties.
+    --  1/13/06 - RLB - Added various link commands.
+    --  1/16/06 - RLB - Added missing initializations.
+    --         - RLB - Added IndexList command.
+    --         - RLB - Added Unnumbered_Section counter to ensure that
+    --                 such sections are uniquely named.
+    --  1/18/06 - RLB - Added "Example_Font".
+    --         - RLB - Redid formatting command nesting so that closing
+    --                 restores to the initial state for the command, not the
+    --                 default state.
+    --  1/20/06 - RLB - Added AILink command.
+    --  2/ 8/06 - RLB - Added command checking at the end of each table row.
+    --  2/ 9/06 - RLB - Implemented enhanced Table command.
+    --  2/10/06 - RLB - Split scanning phase into a separate file.
+    --         - RLB - Added additional features to the Table command.
+    --         - RLB - Added the picture command.
+    -- 2/15/06 - RLB - Added code to prevent the generation of note numbers
+    --                 for deleted notes in final documents.
+    --  2/17/06 - RLB - Tracked down issues with @ChgImplDef.
+    --         - RLB - Added code so that index entries don't display soft
+    --                 hyphens.
+    --         - RLB - Fixed glossary entries to not display insertions if
+    --                 the mode would prevent that.
+    --  6/22/06 - RLB - Added non-terminal linking.
+    --  8/ 4/06 - RLB - Added checking for bad unit indexing.
+    --  9/22/06 - RLB - Added "Use_ISO_2004_Note_Format", and implemented that
+    --                 format.
+    --         - RLB - Revised to use Clause_Number_Type, and to support
+    --                 Subsubclauses.
+    --  9/25/06 - RLB - Added "Use_ISO_2004_Contents_Format".
+    --         - RLB - Added LastColWidth to @Table.
+    --         - RLB - Fixed Enumerated in Notes styles.
+    --  9/29/06 - RLB - Added Element_Ref and Child_Ref for ASIS.
+    -- 10/04/06 - RLB - Added and implemented "Use_ISO_2004_List_Format".
+    --         - RLB - Added "InnerEnumerate" text block.
+    -- 10/13/06 - RLB - Added the @ntf command to handle cases where the
+    --                 text needs to look like a non-terminal but it isn't
+    --                 a real non-terminal.
+    --         - RLB - Added code to handle simple embedded commands in
+    --                 @nt{} to generate links.
+    -- 10/16/06 - RLB - Added code to register deleted non-terminals (so
+    --                 that they can be linked).
+    -- 10/18/06 - RLB - Fixed so that deleted glossary items still get
+    --                 deleted paragraph numbers.
+    --  2/ 5/07 - RLB - Added a paragraph kind, and changed ones that
+    --                 appear in ASIS. Also renamed "Wide" to "Wide_Above"
+    --                 so the purpose is more obvious.
+    --  2/ 9/07 - RLB - Moved AI interpretation and folding to the HTML
+    --                 driver, as constructing the link should be its
+    --                 responsibility. This also allows new kinds of AI here.
+    --  2/13/07 - RLB - Redid output formating to use an explict indent;
+    --                  added ChildExample.
+    --  2/16/07 - RLB - Added Indent format.
+    --  2/19/07 - RLB - Added Title format.
+    -- 12/18/07 - RLB - Initialized Version in some cases.
+    --         - RLB - Added check for open formatting commands
+    --                 in Check_End_Paragraph.
+    --         - RLB - Added Plain_Annex and associated commands.
+    -- 12/19/07 - RLB - Added color commands.
+    --  6/12/08 - RLB - Corrected handling of the ChgGlossary command.
+    --  3/ 4/09 - RLB - Added code to suppress bullets and the like when
+    --                 displaying a deleted paragraph in New-Only mode
+    --                 and no paragraph numbers are shown.
+    --  5/ 6/09 - RLB - Added Labeled_Deleted_xxx.
+    --  5/15/09 - RLB - Fixed missing code for note numbers in revised/added 
clauses.
+    --  4/23/10 - RLB - Added Ada 2005 clause headers for Ada 2012 edition.
+    --  8/ 8/11 - RLB - Split various data items to reduce the size of this
+    --                 package.
+    -- 10/18/11 - RLB - Changed to GPLv3 license.
+    -- 10/19/11 - RLB - Added AspectDefn command.
+    -- 10/20/11 - RLB - Added optional initial version parameter to ChgImplDef
+    --                 and related commands.
+    --         - RLB - Added DeletedPragmaSyn command.
+    -- 10/25/11 - RLB - Added optional initial version parameter to
+    --                 LabeledRevisedSomething commands.
+    -- 10/26/11 - RLB - Added versioned break commands.
+    --  3/19/12 - RLB - Fixed bug that occurred only when paragraph numbers
+    --                 are off (ISO versions). Fixed sort order of attributes.
+    --  3/27/12 - RLB - Added more versioned break commands.
+    --  4/ 3/12 - RLB - Removed dead variables.
+    --  8/31/12 - RLB - Put glossary components into a subrecord to prevent
+    --                 inappropriate usage.
+    -- 10/18/12 - RLB - Put impdef components into a subrecord to prevent
+    --                 inappropriate usage. Fixed problem caused by putting
+    --                 newer items than the generated version into the DB.
+    --         - RLB - Added four specific indent hanging formats and
+    --                 "small" format.
+    -- 11/ 5/12 - RLB - Added stupidly missing compare for "small" format.
+    -- 11/26/12 - RLB - Added subdivision names.
+    --  7/ 5/13 - RLB - Added a nasty hack so added aspect names are marked
+    --                 as such in Show_Changes versions.
+    -- 12/13/13 - RLB - Added InitialVersion parameter to ChgAttrib.
+    --  3/17/16 - RLB - Removed Changes_Only, added Base_Change_Version.
+
+    type Command_Kind_Type is (Normal, Begin_Word, Parameter);
+
+    use ARM_Format.Data; -- use all type ARM_Format.Data.Command_Type;
+       -- Make the enumeration literals visible.
+
+    Free_References : Reference_Ptr := null; -- Unused reference objects.
+       -- We don't expect there ever to be many of these, so we don't try
+       -- to deallocate them.
+    Allocated_Reference_Count : Natural := 0;
+
+    function Allocate_Reference return Reference_Ptr is
+       -- Allocate a reference object from either the free list, or allocate
+       -- it.
+       T : Reference_Ptr;
+    begin
+       if Free_References /= null then
+           T := Free_References;
+           Free_References := Free_References.Next;
+           return T;
+       else
+           Allocated_Reference_Count := Allocated_Reference_Count + 1;
+           if Allocated_Reference_Count > 20 then -- Never more than this on 
one paragraph.
+                Ada.Text_IO.Put_Line ("  ** Too many references allocated");
+           end if;
+           return new Reference;
+       end if;
+    end Allocate_Reference;
+
+
+    procedure Free_Reference (Reference : in out Reference_Ptr) is
+       -- Put a reference object on the free list; setting Reference to null.
+    begin
+       Reference.Next := Free_References;
+       Free_References := Reference;
+       Reference.Ref_Len := 0; -- Clear length, so we don't reuse by accident.
+       Reference := null;
+    end Free_Reference;
+
+
+    procedure Create (Format_Object : in out Format_Type;
+                     Changes : in ARM_Format.Change_Kind;
+                     Change_Version : in ARM_Contents.Change_Version_Type;
+                     Base_Change_Version : in ARM_Contents.Change_Version_Type;
+                     Display_Index_Entries : in Boolean;
+                     Include_Annotations : in Boolean;
+                     Include_ISO : in Boolean;
+                     Link_Non_Terminals : in Boolean;
+                     Number_Paragraphs : in Boolean;
+                     Examples_Font : in ARM_Output.Font_Family_Type;
+                     Use_ISO_2004_Note_Format : in Boolean;
+                     Use_ISO_2004_Contents_Format : in Boolean;
+                     Use_ISO_2004_List_Format : in Boolean;
+                     Top_Level_Subdivision_Name : in 
ARM_Output.Top_Level_Subdivision_Name_Kind) is
+       -- Initialize an input object. Changes, Change_Version,
+       -- and Base_Change_Version determine
+       -- which changes should be displayed. If Display_Index_Entries is True,
+       -- index entries will be printed in the document; otherwise, they
+       -- will not generate any visible text (although they might generate
+       -- a link anchor). If Include_Annotations is True, annotations (AARM
+       -- text) will be included in the output; otherwise it will not be.
+       -- If Include_ISO is True, ISOOnly text will be included in the output
+       -- (and NotISO text will not); otherwise the reverse is true.
+       -- If Link_Non_Terminals is True, links will be generated for
+       -- each Non_Terminal, linking it to its definition.
+       -- If Number_Paragraphs is true, paragraphs will be numbered (per
+       -- subclause); otherwise they will not be.
+       -- Example_Font specifies the font that examples will be set in.
+       -- If Use_ISO_2004_Note_Format is true, that format will be used;
+       -- else the Ada95 standard's format will be used for notes.
+       -- If Use_ISO_2004_Contents_Format is true, that format will be used;
+       -- else the Ada95 standard's format will be used for the table of 
contents.
+       -- If Use_ISO_2004_List_Format is true, then lists will be lettered;
+       -- else the Ada95 standard's numbering format will be used for
+       -- enumerated lists.
+        -- The top-level (and other) subdivision names are as specified
+        -- in Top_Level_Subdivision_Name.
+    begin
+       Format_Object.Changes := Changes;
+       Format_Object.Change_Version := Change_Version;
+       Format_Object.Base_Change_Version := Base_Change_Version;
+       Format_Object.Display_Index_Entries := Display_Index_Entries;
+       Format_Object.Include_Annotations := Include_Annotations;
+       Format_Object.Include_ISO := Include_ISO;
+       Format_Object.Link_Non_Terminals := Link_Non_Terminals;
+       Format_Object.Number_Paragraphs := Number_Paragraphs;
+       Format_Object.Examples_Font := Examples_Font;
+       Format_Object.Use_ISO_2004_Note_Format := Use_ISO_2004_Note_Format;
+       Format_Object.Use_ISO_2004_Contents_Format := 
Use_ISO_2004_Contents_Format;
+       Format_Object.Use_ISO_2004_List_Format := Use_ISO_2004_List_Format;
+       Format_Object.Top_Level_Subdivision_Name := Top_Level_Subdivision_Name;
+
+       Format_Object.Clause_Number := (Section => 0, Clause => 0,
+                                       Subclause => 0, Subsubclause => 0);
+       Format_Object.Unnumbered_Section := 0;
+        Format_Object.Next_Note := 1;
+        Format_Object.Next_Paragraph := 1;
+        Format_Object.Next_Insert_Para := 1;
+        Format_Object.Next_AARM_Sub := 'a';
+        Format_Object.Next_AARM_Insert_Para := 1;
+        Format_Object.Next_Enumerated_Num := 1;
+        Format_Object.Enumerated_Level := 0;
+        Format_Object.Last_Paragraph_Subhead_Type := Plain;
+        Format_Object.Next_Paragraph_Subhead_Type := Plain;
+        Format_Object.Next_Paragraph_Format_Type := Plain;
+       ARM_Database.Create (Format_Object.Aspect_DB);
+       ARM_Database.Create (Format_Object.Attr_DB);
+       ARM_Database.Create (Format_Object.Pragma_DB);
+       ARM_Database.Create (Format_Object.Glossary_DB);
+       ARM_Database.Create (Format_Object.Impdef_DB);
+       ARM_Database.Create (Format_Object.Impladv_DB);
+       ARM_Database.Create (Format_Object.Docreq_DB);
+       ARM_Syntax.Create;
+       ARM_Index.Create;
+       ARM_Subindex.Create (Format_Object.Package_Index);
+       ARM_Subindex.Create (Format_Object.Type_Index);
+       ARM_Subindex.Create (Format_Object.Subprogram_Index);
+       ARM_Subindex.Create (Format_Object.Exception_Index);
+       ARM_Subindex.Create (Format_Object.Object_Index);
+    end Create;
+
+
+    procedure Destroy (Format_Object : in out Format_Type) is
+       -- Destroy a format object, releasing any resources.
+    begin
+       ARM_Database.Destroy (Format_Object.Aspect_DB);
+       ARM_Database.Destroy (Format_Object.Attr_DB);
+       ARM_Database.Destroy (Format_Object.Pragma_DB);
+       ARM_Database.Destroy (Format_Object.Glossary_DB);
+       ARM_Database.Destroy (Format_Object.Impdef_DB);
+       ARM_Database.Destroy (Format_Object.Impladv_DB);
+       ARM_Database.Destroy (Format_Object.Docreq_DB);
+       ARM_Syntax.Destroy;
+       ARM_Index.Destroy;
+       ARM_Subindex.Destroy (Format_Object.Package_Index);
+       ARM_Subindex.Destroy (Format_Object.Type_Index);
+       ARM_Subindex.Destroy (Format_Object.Subprogram_Index);
+       ARM_Subindex.Destroy (Format_Object.Exception_Index);
+       ARM_Subindex.Destroy (Format_Object.Object_Index);
+    end Destroy;
+
+
+    function Clause_String (Format_Object : in Format_Type) return String is
+        -- Returns a string for a clause reference.
+        use type ARM_Contents.Section_Number_Type;
+    begin
+        if Format_Object.Clause_Number.Subsubclause /= 0 then
+           return ARM_Contents.Make_Clause_Number (
+                   ARM_Contents.SubSubClause,
+                   Format_Object.Clause_Number);
+        elsif Format_Object.Clause_Number.Subclause /= 0 then
+           return ARM_Contents.Make_Clause_Number (
+                   ARM_Contents.SubClause,
+                   Format_Object.Clause_Number);
+        elsif Format_Object.Clause_Number.Clause /= 0 then
+           return ARM_Contents.Make_Clause_Number (
+                   ARM_Contents.Clause,
+                   Format_Object.Clause_Number);
+        else
+           if Format_Object.Clause_Number.Section = 0 then
+               return ARM_Contents.Make_Clause_Number (
+                       ARM_Contents.Unnumbered_Section,
+                       Format_Object.Clause_Number);
+           elsif Format_Object.Clause_Number.Section < 
ARM_Contents.ANNEX_START then
+               return ARM_Contents.Make_Clause_Number (
+                       ARM_Contents.Section,
+                       Format_Object.Clause_Number);
+           else
+               return ARM_Contents.Make_Clause_Number (
+                       ARM_Contents.Plain_Annex, -- Same for all kinds of 
annex.
+                       Format_Object.Clause_Number);
+           end if;
+        end if;
+    end Clause_String;
+
+
+    Do_Not_Display_Text : constant ARM_Output.Change_Type := ARM_Output.Both;
+        -- Special meaning for Calc_Change_Disposition, below.
+    procedure Calc_Change_Disposition
+               (Format_Object : in Format_Type;
+                Version       : in ARM_Contents.Change_Version_Type;
+                Operation     : in ARM_Output.Change_Type;
+                Text_Kind     : out ARM_Output.Change_Type) is
+        -- Determine the appropriate disposition for text.
+        -- The text is to be inserted if Operation is Insertion;
+        -- and deleted if Operation is Deletion.
+        -- The appropriate Change_Type to use is returned in Text_Kind.
+        -- If Text_Kind is None, the text should be displayed normally.
+        -- If Text_Kind is Insertion, the text should be displayed as inserted.
+        -- If Text_Kind is Deletion, the text should be displayed as deletion.
+        -- If Text_Kind is Do_Not_Display_Text (same as Both), the
+        --   text should not be shown at all.
+        -- Program_Error is raised if Operation is None or Both.
+        -- This routine assumes that we are not nested
+        -- in some other change item.
+        use type ARM_Output.Change_Type;
+    begin
+        if Operation = ARM_Output.None or else
+          Operation = ARM_Output.Both then
+           raise Program_Error;
+        end if;
+        -- We can't check for nesting, because in some cases it happens
+        -- harmlessly (i.e. Added_Pragma_Syn).
+
+        case Format_Object.Changes is
+           when ARM_Format.Old_Only =>
+               -- Display only the original version ('0').
+               if Operation = ARM_Output.Insertion then
+                   if Version > '0' then
+                       Text_Kind := Do_Not_Display_Text; -- Newer than 
original.
+                   else
+                       Text_Kind := ARM_Output.None; -- Display normally.
+                   end if;
+               else -- Deletion
+                   if Version > '0' then
+                       Text_Kind := ARM_Output.None; -- Display normally, not 
deleted in original code.
+                   else
+                       Text_Kind := Do_Not_Display_Text; -- Deleted in 
original.
+                   end if;
+               end if;
+           when ARM_Format.New_Only =>
+               -- Display only the version
+               -- Format_Object.Change_Version, no insertions or deletions.
+               if Operation = ARM_Output.Insertion then
+                   if Version > Format_Object.Change_Version then
+                       -- Change version newer than we're displaying;
+                       -- ignore the item.
+                       Text_Kind := Do_Not_Display_Text;
+                   else
+                       -- Display the change normally.
+                       Text_Kind := ARM_Output.None;
+                   end if;
+               else -- Deletion
+                   if Version > Format_Object.Change_Version then
+                       -- Change version newer than we're displaying;
+                       -- leave the item in and display normally.
+                       Text_Kind := ARM_Output.None;
+                   else
+                       -- Delete the item.
+                       Text_Kind := Do_Not_Display_Text;
+                   end if;
+               end if;
+           when ARM_Format.Show_Changes |
+                ARM_Format.New_Changes =>
+               -- Display only the the changes for versions
+               -- Format_Object.Base_Change_Version ..
+               -- Format_Object.Change_Version, older changes
+               -- are applied and newer changes are ignored.
+               -- (New_Changes shows deletions as a single
+               -- character for older versions of Word, but otherwise
+               -- is the same.)
+               if Operation = ARM_Output.Insertion then
+                   if Version > Format_Object.Change_Version then
+                       -- Change version is newer than we're displaying;
+                       -- ignore the item.
+                       Text_Kind := Do_Not_Display_Text;
+                   elsif Version < Format_Object.Base_Change_Version then
+                       -- Change version is older than we're displaying;
+                       -- display the change normally.
+                       Text_Kind := ARM_Output.None;
+                   else
+                       -- This version or older, display the change
+                       -- as an insertion.
+                       Text_Kind := ARM_Output.Insertion;
+                   end if;
+               else -- Deletion.
+                   if Version > Format_Object.Change_Version then
+                       -- Change version is newer than we're displaying;
+                       -- the item isn't deleted yet, display the change
+                       -- normally.
+                       Text_Kind := ARM_Output.None;
+                   elsif Version < Format_Object.Base_Change_Version then
+                       -- Change version is older than we're displaying;
+                       -- the item is deleted, so ignore the item.
+                       Text_Kind := Do_Not_Display_Text;
+                   else
+                       -- The correct version, display the change
+                       -- as a deletion.
+                       Text_Kind := ARM_Output.Deletion;
+                   end if;
+               end if;
+        end case;
+    end Calc_Change_Disposition;
+
+
+    function Get_Current_Item (Format_Object : in Format_Type;
+                              Input_Object : in ARM_Input.Input_Type'Class;
+                              Item : in String) return String is
+        -- Return the "current" item from Item. This is Item itself,
+       -- unless Item includes an @Chg.
+       New_Pos : Natural;
+        Close_Ch : Character;
+        Open_Cnt : Natural;
+       My_Item : constant String (1 .. Item'Length) := Item;
+               -- Just to slide the bounds.
+       Version : ARM_Contents.Change_Version_Type := '0';
+       Disposition : ARM_Output.Change_Type;
+        use type ARM_Output.Change_Type;
+    begin
+        if My_Item'Length < 11 or else
+          My_Item (1) /= '@' or else
+          Ada.Characters.Handling.To_Lower (My_Item (2 .. 4)) /= "chg" then
+           -- No @Chg command here.
+           return My_Item;
+       end if;
+       if Ada.Characters.Handling.To_Lower (My_Item (6 .. 9)) = "new=" then
+           -- No version parameter:
+           New_Pos := 6;
+           Version := '1';
+       elsif My_Item'Length > 22 and then
+           Ada.Characters.Handling.To_Lower (My_Item (6 .. 14)) = "version=[" 
and then
+           Ada.Characters.Handling.To_Lower (My_Item (16 .. 21)) = "],new=" 
then
+           New_Pos := 18;
+           Version := My_Item(15);
+       else
+Ada.Text_IO.Put_Line ("%% Oops, can't find either Version or New in item chg 
command, line " & ARM_Input.Line_String (Input_Object));
+           return My_Item;
+       end if;
+
+       Calc_Change_Disposition (Format_Object => Format_Object,
+                Version => Version,
+                Operation => ARM_Output.Insertion,
+                Text_Kind => Disposition);
+
+       if Disposition = Do_Not_Display_Text then
+           -- Find the end of the "New" parameter, and return the "Old"
+           -- parameter.
+           Close_Ch := ARM_Input.Get_Close_Char (
+               My_Item(New_Pos+4));
+           Open_Cnt := 1;
+           for I in New_Pos+5 .. My_Item'Last loop
+               if My_Item(I) = My_Item(New_Pos+4) then
+                   Open_Cnt := Open_Cnt + 1;
+               elsif My_Item(I) = Close_Ch then
+                   if Open_Cnt <= 1 then
+                       -- OK, the end of the "New" parameter is at 'I'.
+                       if My_Item'Last < I+7 or else
+                          My_Item (I+1) /= ',' or else
+                          Ada.Characters.Handling.To_Lower (My_Item (I+2 .. 
I+4)) /= "old" or else
+                          My_Item (I+5) /= '=' then
+                           exit; -- Heck if I know.
+                       end if;
+                       Close_Ch := ARM_Input.Get_Close_Char (
+                           My_Item(I+6));
+                       Open_Cnt := 1;
+                       for J in I+7 .. My_Item'Last loop
+                           if My_Item(J) = My_Item(I+6) then
+                               Open_Cnt := Open_Cnt + 1;
+                           elsif My_Item(J) = Close_Ch then
+                               if Open_Cnt <= 1 then
+                                   return My_Item (I + 7 .. J - 1);
+                               else
+                                   Open_Cnt := Open_Cnt - 1;
+                               end if;
+                           -- else continue looking.
+                           end if;
+                       end loop;
+Ada.Text_IO.Put_Line ("%% Oops, can't find end of item chg old command, line " 
& ARM_Input.Line_String (Input_Object));
+                       return My_Item (I + 7 .. My_Item'Last);
+                   else
+                       Open_Cnt := Open_Cnt - 1;
+                   end if;
+               -- else continue looking.
+               end if;
+           end loop;
+Ada.Text_IO.Put_Line ("%% Oops, can't find end of item chg new command, line " 
& ARM_Input.Line_String (Input_Object));
+           return My_Item (New_Pos+5 .. My_Item'Length);
+        else -- Some new format, use the new name.
+           -- Find the end of the "New" parameter, and
+           -- return it.
+           Close_Ch := ARM_Input.Get_Close_Char (My_Item(New_Pos+4));
+           Open_Cnt := 1;
+           for I in New_Pos+5 .. My_Item'Last loop
+               if My_Item(I) = My_Item(New_Pos+4) then
+                   Open_Cnt := Open_Cnt + 1;
+               elsif My_Item(I) = Close_Ch then
+                   if Open_Cnt <= 1 then
+                       return My_Item (New_Pos+5 .. I - 1);
+                   else
+                       Open_Cnt := Open_Cnt - 1;
+                   end if;
+               -- else continue looking.
+               end if;
+           end loop;
+           -- Weird if we get here, can't find end of parameter.
+Ada.Text_IO.Put_Line ("%% Oops, can't find end of NT chg new command, line " & 
ARM_Input.Line_String (Input_Object));
+           return My_Item (New_Pos+5 .. My_Item'Last);
+        end if;
+    end Get_Current_Item;
+
+
+    function Get_Old_Item (Format_Object : in Format_Type;
+                          Input_Object : in ARM_Input.Input_Type'Class;
+                          Item : in String) return String is
+        -- Return the "old" item from Item, or nothing if there is no
+       -- old item. This is nothing unless Item includes an @Chg,
+       -- *and* the new item in the @Chg is displayed.
+       New_Pos : Natural;
+        Close_Ch : Character;
+        Open_Cnt : Natural;
+       My_Item : constant String (1 .. Item'Length) := Item;
+               -- Just to slide the bounds.
+       Version : ARM_Contents.Change_Version_Type := '0';
+       Disposition : ARM_Output.Change_Type;
+        use type ARM_Output.Change_Type;
+    begin
+        if My_Item'Length < 11 or else
+          My_Item (1) /= '@' or else
+          Ada.Characters.Handling.To_Lower (My_Item (2 .. 4)) /= "chg" then
+           -- No @Chg command here.
+           return "";
+       end if;
+       if Ada.Characters.Handling.To_Lower (My_Item (6 .. 9)) = "new=" then
+           -- No version parameter:
+           New_Pos := 6;
+           Version := '1';
+       elsif My_Item'Length > 22 and then
+           Ada.Characters.Handling.To_Lower (My_Item (6 .. 14)) = "version=[" 
and then
+           Ada.Characters.Handling.To_Lower (My_Item (16 .. 21)) = "],new=" 
then
+           New_Pos := 18;
+           Version := My_Item(15);
+       else
+Ada.Text_IO.Put_Line ("%% Oops, can't find either Version or New in item chg 
command, line " & ARM_Input.Line_String (Input_Object));
+           return "";
+       end if;
+
+       Calc_Change_Disposition (Format_Object => Format_Object,
+                Version => Version,
+                Operation => ARM_Output.Insertion,
+                Text_Kind => Disposition);
+
+       if Disposition /= Do_Not_Display_Text then
+           -- Some new item was shown.
+           -- Find the end of the "New" parameter, and return the "Old"
+           -- parameter.
+           Close_Ch := ARM_Input.Get_Close_Char (
+               My_Item(New_Pos+4));
+           Open_Cnt := 1;
+           for I in New_Pos+5 .. My_Item'Last loop
+               if My_Item(I) = My_Item(New_Pos+4) then
+                   Open_Cnt := Open_Cnt + 1;
+               elsif My_Item(I) = Close_Ch then
+                   if Open_Cnt <= 1 then
+                       -- OK, the end of the "New" parameter is at 'I'.
+                       if My_Item'Last < I+7 or else
+                          My_Item (I+1) /= ',' or else
+                          Ada.Characters.Handling.To_Lower (My_Item (I+2 .. 
I+4)) /= "old" or else
+                          My_Item (I+5) /= '=' then
+                           exit; -- Heck if I know.
+                       end if;
+                       Close_Ch := ARM_Input.Get_Close_Char (
+                           My_Item(I+6));
+                       Open_Cnt := 1;
+                       for J in I+7 .. My_Item'Last loop
+                           if My_Item(J) = My_Item(I+6) then
+                               Open_Cnt := Open_Cnt + 1;
+                           elsif My_Item(J) = Close_Ch then
+                               if Open_Cnt <= 1 then
+                                   return My_Item (I + 7 .. J - 1);
+                               else
+                                   Open_Cnt := Open_Cnt - 1;
+                               end if;
+                           -- else continue looking.
+                           end if;
+                       end loop;
+Ada.Text_IO.Put_Line ("%% Oops, can't find end of item chg old command, line " 
& ARM_Input.Line_String (Input_Object));
+                       return My_Item (I + 7 .. My_Item'Last);
+                   else
+                       Open_Cnt := Open_Cnt - 1;
+                   end if;
+               -- else continue looking.
+               end if;
+           end loop;
+Ada.Text_IO.Put_Line ("%% Oops, can't find end of item chg new command, line " 
& ARM_Input.Line_String (Input_Object));
+           return "";
+        else -- The new item wasn't displayed, so we already have used the
+            -- old item.
+           return "";
+        end if;
+    end Get_Old_Item;
+
+
+    procedure Scan (Format_Object : in out Format_Type;
+                   File_Name : in String;
+                   Section_Number : in ARM_Contents.Section_Number_Type;
+                   Starts_New_Section : in Boolean) is separate;
+       -- Scans the contents for File_Name, determining the table of contents
+       -- for the section. The results are written to the contents package.
+       -- Starts_New_Section is True if the file starts a new section.
+       -- Section_Number is the number (or letter) of the section.
+       -- See ARM_FRMS.ADB.
+
+
+    procedure Write_Table_of_Contents (
+                      Format_Object : in out Format_Type;
+                      Output_Object : in out ARM_Output.Output_Type'Class) is
+       -- Writes the table of contents for the document. (It will have
+       -- a section name of "TOC"). This should be done after all calls to
+       -- Scan and before any calls to Process.
+
+       In_Paragraph : Boolean := False;
+
+       procedure Write_It (Title : in ARM_Contents.Title_Type;
+                  Level : in ARM_Contents.Level_Type;
+                  Clause_Number : in ARM_Contents.Clause_Number_Type;
+                   Version : in ARM_Contents.Change_Version_Type;
+                  Quit : out Boolean) is
+           Clause_Text : constant String :=
+               ARM_Contents.Make_Clause_Number (Level, Clause_Number);
+           Old_Title : ARM_Contents.Title_Type :=
+                       ARM_Contents.Lookup_Old_Title (
+                           Level, Clause_Number);
+       begin
+           Quit := False;
+           if Old_Title = ARM_Contents.Title_Type'(others => ' ') and then
+              (Format_Object.Change_Version < Version or else
+               ARM_Format."=" (Format_Object.Changes, ARM_Format.Old_Only)) 
then
+               -- This is an added item, and we're generating a version
+               -- that does not include it. Skip it completely.
+               return;
+           end if;
+           if ARM_Contents."=" (Level, ARM_Contents.Clause) then
+               ARM_Output.Line_Break (Output_Object);
+               ARM_Output.Ordinary_Text (Output_Object, "    ");
+               ARM_Output.Ordinary_Text (Output_Object, Clause_Text);
+               ARM_Output.Hard_Space (Output_Object);
+           elsif ARM_Contents."=" (Level, ARM_Contents.Subclause) then
+               ARM_Output.Line_Break (Output_Object);
+               ARM_Output.Ordinary_Text (Output_Object, "        ");
+               ARM_Output.Ordinary_Text (Output_Object, Clause_Text);
+               ARM_Output.Hard_Space (Output_Object);
+           elsif ARM_Contents."=" (Level, ARM_Contents.Subsubclause) then
+               ARM_Output.Line_Break (Output_Object);
+               ARM_Output.Ordinary_Text (Output_Object, "            ");
+               ARM_Output.Ordinary_Text (Output_Object, Clause_Text);
+               ARM_Output.Hard_Space (Output_Object);
+           elsif ARM_Contents."=" (Level, ARM_Contents.Unnumbered_Section) then
+               if In_Paragraph then
+                   ARM_Output.End_Paragraph (Output_Object);
+               end if;
+               ARM_Output.Start_Paragraph (Output_Object,
+                                           ARM_Output.Normal,
+                                           Indent => 0, Number => "",
+                                           Justification => ARM_Output.Left);
+               In_Paragraph := True;
+           else
+               if In_Paragraph then
+                   ARM_Output.End_Paragraph (Output_Object);
+               end if;
+               ARM_Output.Start_Paragraph (Output_Object,
+                                           ARM_Output.Normal,
+                                           Indent => 0, Number => "",
+                                           Justification => ARM_Output.Left);
+               In_Paragraph := True;
+               if ARM_Contents."=" (Level, ARM_Contents.Section) then
+                   ARM_Output.Ordinary_Text (Output_Object, Clause_Text);
+                   ARM_Output.Ordinary_Text (Output_Object, ". ");
+               else -- Annexes.
+                   ARM_Output.Ordinary_Character (Output_Object, 
Clause_Text(Clause_Text'Last)); -- We don't want the "Annex" part.
+                   ARM_Output.Ordinary_Text (Output_Object, ". ");
+               end if;
+           end if;
+           if Format_Object.Change_Version < Version then
+               -- Ignore the change:
+               ARM_Output.Clause_Reference (Output_Object,
+                   Ada.Strings.Fixed.Trim (
+                       ARM_Contents.Lookup_Old_Title (
+                           Level, Clause_Number), Ada.Strings.Right),
+                   Clause_Text);
+           else
+               case Format_Object.Changes is
+                   when ARM_Format.Old_Only =>
+                       ARM_Output.Clause_Reference (Output_Object,
+                           Ada.Strings.Fixed.Trim (
+                               ARM_Contents.Lookup_Old_Title (
+                                   Level, Clause_Number), Ada.Strings.Right),
+                           Clause_Text);
+                   when ARM_Format.New_Only |
+                        ARM_Format.Show_Changes |
+                        ARM_Format.New_Changes =>
+                       ARM_Output.Clause_Reference (Output_Object,
+                           Ada.Strings.Fixed.Trim (Title, Ada.Strings.Right),
+                           Clause_Text);
+               end case;
+           end if;
+       end Write_It;
+
+       procedure Write_Contents is new ARM_Contents.For_Each (Write_It);
+
+    begin
+       -- Note: For .RTF version, the result of this call will not be used,
+       -- preferring to let Word make the TOC (it can include page numbers).
+       if Format_Object.Use_ISO_2004_Contents_Format then
+            ARM_Output.Section (Output_Object,
+                               Section_Title => "Contents",
+                               Section_Name => "TOC");
+
+           ARM_Output.Clause_Header (Output_Object,
+                                     Header_Text => "Contents",
+                                     Level => ARM_Contents.Section,
+                                     Clause_Number => "",
+                                     Top_Level_Subdivision_Name => 
Format_Object.Top_Level_Subdivision_Name);
+       else
+            ARM_Output.Section (Output_Object,
+                               Section_Title => "Table of Contents",
+                               Section_Name => "TOC");
+
+           ARM_Output.Clause_Header (Output_Object,
+                                     Header_Text => "Table of Contents",
+                                     Level => ARM_Contents.Section,
+                                     Clause_Number => "",
+                                     Top_Level_Subdivision_Name => 
Format_Object.Top_Level_Subdivision_Name);
+       end if;
+
+       ARM_Output.TOC_Marker (Output_Object, For_Start => True);
+
+       Write_Contents;
+
+       if In_Paragraph then
+           ARM_Output.End_Paragraph (Output_Object);
+       end if;
+
+       ARM_Output.TOC_Marker (Output_Object, For_Start => False);
+
+    end Write_Table_of_Contents;
+
+
+    procedure Make_References (List : in out Reference_Ptr;
+                              Format_Object : in out Format_Type;
+                              Output_Object : in out 
ARM_Output.Output_Type'Class) is
+       -- Write the references to the Output_Object, using the format
+       -- of Format_Object.
+       -- Deallocate the references on List; List will be null afterwards.
+       Temp : Reference_Ptr;
+       Our_Text_Format : ARM_Output.Format_Type;
+    begin
+       -- We assume these are only stored here if we want to see them
+       -- on *this* paragraph. Thus, we just output them if they exist
+       -- here.
+       Our_Text_Format := Format_Object.Text_Format;
+       Our_Text_Format.Change := ARM_Output.None; -- No changes should be 
reflected in references.
+
+       while List /= null loop
+           -- Output a reference. These are *never* marked as
+           -- inserted or deleted, so set the style properly.
+           ARM_Output.Text_Format (Output_Object,
+                                   Format => Our_Text_Format);
+           ARM_Output.Ordinary_Character (Output_Object, '{');
+           Our_Text_Format.Italic := True;
+           ARM_Output.Text_Format (Output_Object,
+                                   Format => Our_Text_Format);
+           if List.Is_DR_Ref then
+               -- Output a DR reference.
+               ARM_Output.DR_Reference (Output_Object,
+                                        Text => List.Ref_Name(1..List.Ref_Len),
+                                        DR_Number => 
List.Ref_Name(1..List.Ref_Len));
+           else
+               -- Output an AI reference.
+               ARM_Output.AI_Reference (Output_Object,
+                                        Text => List.Ref_Name(1..List.Ref_Len),
+                                        AI_Number => 
List.Ref_Name(1..List.Ref_Len));
+           end if;
+           Our_Text_Format.Italic := Format_Object.Text_Format.Italic;
+           ARM_Output.Text_Format (Output_Object,
+                                   Format => Our_Text_Format);
+           ARM_Output.Ordinary_Character (Output_Object, '}');
+           ARM_Output.Ordinary_Character (Output_Object, ' ');
+           -- Reset to the current format.
+           ARM_Output.Text_Format (Output_Object,
+                                   Format => Format_Object.Text_Format);
+           Format_Object.Last_Non_Space := False;
+
+           Temp := List;
+           List := List.Next;
+           Free_Reference (Temp);
+       end loop;
+    end Make_References;
+
+
+    procedure Dump_References (List : in out Reference_Ptr) is
+       -- Destroy any references in List; List will be null afterwards.
+       Temp : Reference_Ptr;
+    begin
+       while List /= null loop
+           Temp := List;
+           List := List.Next;
+           Free_Reference (Temp);
+       end loop;
+    end Dump_References;
+
+
+    type Items is record
+        Kind : Command_Kind_Type;
+        Name : ARM_Input.Command_Name_Type;
+        Command : Data.Command_Type;
+        Close_Char : Character; -- Ought to be }, ], >, or ).
+       Text_Format : ARM_Output.Format_Type;
+           -- Format at the start of the command.
+
+        -- The next four are only used if Kind=Begin_Word, or for
+        -- Command=Implementation_Defined, Glossary_Text_Param, or
+       --    Syntax_Rule_RHS.
+        Old_Last_Subhead_Paragraph : Paragraph_Type;
+        Old_Next_Subhead_Paragraph : Paragraph_Type;
+        Old_Next_Paragraph_Format : Paragraph_Type;
+       Old_Tab_Stops : ARM_Output.Tab_Info;
+       Old_Next_Enum_Num : Positive;
+       Is_Formatting : Boolean; -- Only used if Kind=Begin_Word.
+                                -- The command changes the PARAGRAPH format.
+                                -- Otherwise, it should be ignored when
+                                -- when determining the format.
+       -- The following is only used if Command = Change, Change_Added,
+       -- Change_Deleted, Added_Subheading,
+       -- Added_Pragma_Syntax, Deleted_Pragma_Syntax,
+       -- Added_Syntax, Deleted_Syntax,
+       -- New_Page_for_Version, New_Column_for_Version,
+       -- RM_New_Page_for_Version, Not_ISO_RM_New_Page_for_Version, and
+       -- ISO_Only_RM_New_Page_for_Version.
+       Change_Version : ARM_Contents.Change_Version_Type;
+       -- The following are only used if Command = Change,
+       -- Added_Pragma_Syntax, and Deleted_Pragma_Syntax.
+       Prev_Change_Version : ARM_Contents.Change_Version_Type;
+       -- The following are only used if Command = Change.
+       Was_Text : Boolean; -- Did the current subcommand have text?
+       Prev_Change : ARM_Output.Change_Type;
+       Prev_Added_Change_Version : ARM_Contents.Change_Version_Type;
+    end record;
+    type Nesting_Stack_Type is array (1 .. 40) of Items;
+    type Format_State_Type is record
+       Nesting_Stack : Nesting_Stack_Type;
+       Nesting_Stack_Ptr : Natural := 0;
+    end record;
+
+
+    procedure Real_Process (Format_Object : in out Format_Type;
+                           Format_State : in out Format_State_Type;
+                           Input_Object : in out ARM_Input.Input_Type'Class;
+                           Output_Object : in out 
ARM_Output.Output_Type'Class) is
+       -- Process the contents of Input_Object, writing the results to
+       -- Output_Object. (Output_Object uses dispatching calls to provide
+       -- the correct formatting). Format_Object holds information about
+       -- the state of the formatting.
+
+       procedure Set_Nesting_for_Command (Name : in 
ARM_Input.Command_Name_Type;
+                                          Kind : in Command_Kind_Type;
+                                          Param_Ch : in Character) is
+           -- Push the command onto the nesting stack.
+       begin
+           Format_State.Nesting_Stack_Ptr := Format_State.Nesting_Stack_Ptr + 
1;
+           Format_State.Nesting_Stack (Format_State.Nesting_Stack_Ptr) :=
+               (Name => Name,
+                Kind => Kind,
+                Command => Data.Command (Name),
+                Close_Char => ' ', -- Set below.
+                Text_Format => Format_Object.Text_Format, -- Save the current 
format.
+                -- Other things next necessarily used:
+                Old_Last_Subhead_Paragraph => Plain, -- Not used.
+                Old_Next_Subhead_Paragraph => Plain, -- Not used.
+                Old_Next_Paragraph_Format => Plain, -- Not used.
+                Old_Tab_Stops => ARM_Output.NO_TABS, -- Not used.
+                Old_Next_Enum_Num => 1, -- Not used.
+                Is_Formatting => False, -- Not used.
+                Change_Version => '0', -- Not used.
+                Was_Text => False, -- Not used.
+                Prev_Change => ARM_Output.None, -- Not used.
+                Prev_Change_Version => '0', -- Not used.
+                Prev_Added_Change_Version => '0'); -- Not used.
+           Format_State.Nesting_Stack 
(Format_State.Nesting_Stack_Ptr).Close_Char := ARM_Input.Get_Close_Char 
(Param_Ch);
+--Ada.Text_IO.Put_Line (" &Stack (" & Name & "); Close-Char=" &
+--  Format_State.Nesting_Stack (Format_State.Nesting_Stack_Ptr).Close_Char);
+       end Set_Nesting_for_Command;
+
+
+       procedure Set_Nesting_for_Parameter (Command  : in Data.Command_Type;
+                                            Close_Ch : in Character) is
+           -- Push the parameter onto the nesting stack.
+       begin
+           Format_State.Nesting_Stack_Ptr := Format_State.Nesting_Stack_Ptr + 
1;
+           Format_State.Nesting_Stack (Format_State.Nesting_Stack_Ptr) :=
+               (Name => (others => ' '),
+                Kind => Parameter,
+                Command => Command,
+                Close_Char => Close_Ch,
+                Text_Format => Format_Object.Text_Format, -- Save the current
+                       -- format (not really used here).
+                Old_Last_Subhead_Paragraph => Plain, -- Not used.
+                Old_Next_Subhead_Paragraph => Plain, -- Not used.
+                Old_Next_Paragraph_Format => Plain, -- Not used.
+                Old_Tab_Stops => ARM_Output.NO_TABS, -- Not used.
+                Old_Next_Enum_Num => 1, -- Not used.
+                Is_Formatting => False, -- Not used.
+                Change_Version => '0', -- Not used.
+                Was_Text => False, -- Not used.
+                Prev_Change => ARM_Output.None, -- Not used.
+                Prev_Change_Version => '0', -- Not used.
+                Prev_Added_Change_Version => '0'); -- Not used.
+--Ada.Text_IO.Put_Line (" &Stack (Parameter)");
+       end Set_Nesting_for_Parameter;
+
+
+        function Is_AARM_Paragraph (Kind : in Paragraph_Type) return Boolean is
+        begin
+           case Kind is
+               when Plain | Introduction | Syntax | Resolution | Legality |
+                    Static_Semantics | Link_Time |
+                    Run_Time | Bounded_Errors |
+                    Erroneous | Requirements | Documentation |
+                    Metrics | Permissions | Advice | Notes | Single_Note |
+                    Examples =>
+                   return False;
+               when Language_Design | Ada83_Inconsistencies |
+                    Ada83_Incompatibilities | Ada83_Extensions |
+                    Ada83_Wording | Ada95_Inconsistencies |
+                    Ada95_Incompatibilities | Ada95_Extensions |
+                    Ada95_Wording | Ada2005_Inconsistencies |
+                    Ada2005_Incompatibilities | Ada2005_Extensions |
+                    Ada2005_Wording | Ada2012_Inconsistencies |
+                    Ada2012_Incompatibilities | Ada2012_Extensions |
+                    Ada2012_Wording | Reason | Ramification | Proof |
+                    Imp_Note | Corr_Change | Discussion |
+                    Honest | Glossary_Marker | Bare_Annotation |
+                    Element_Ref | Child_Ref | Usage_Note =>
+                   return True;
+               when In_Table =>
+                   return False; -- Tables are never considered part of the
+                           -- AARM for formatting purposes, even when they are.
+               when Wide_Above | Example_Text | Indented_Example_Text |
+                    Child_Example_Text | Code_Indented | Indent |
+                    Bulleted |
+                    Nested_Bulleted | Nested_X2_Bulleted |
+                    Display | Syntax_Display |
+                    Syntax_Indented | Syntax_Production |
+                    Enumerated | Nested_Enumerated |
+                    Hanging_Indented_1 | Hanging_Indented_2 |
+                    Hanging_Indented_3 | Hanging_Indented_4 |
+                    Small | Title =>
+                   -- This depends on the containing paragraph kind;
+                   -- Last_Paragraph_Subhead_Type should contain that.
+                   if Format_Object.Last_Paragraph_Subhead_Type = Wide_Above 
or else
+                      Format_Object.Last_Paragraph_Subhead_Type = Example_Text 
or else
+                      Format_Object.Last_Paragraph_Subhead_Type = 
Child_Example_Text or else
+                      Format_Object.Last_Paragraph_Subhead_Type = 
Indented_Example_Text or else
+                      Format_Object.Last_Paragraph_Subhead_Type = Bulleted or 
else
+                      Format_Object.Last_Paragraph_Subhead_Type = 
Code_Indented or else
+                      Format_Object.Last_Paragraph_Subhead_Type = Indent or 
else
+                      Format_Object.Last_Paragraph_Subhead_Type = 
Nested_Bulleted or else
+                      Format_Object.Last_Paragraph_Subhead_Type = 
Nested_X2_Bulleted or else
+                      Format_Object.Last_Paragraph_Subhead_Type = Display or 
else
+                      Format_Object.Last_Paragraph_Subhead_Type = 
Syntax_Display or else
+                      Format_Object.Last_Paragraph_Subhead_Type = 
Syntax_Indented or else
+                      Format_Object.Last_Paragraph_Subhead_Type = 
Syntax_Production or else
+                      Format_Object.Last_Paragraph_Subhead_Type = Enumerated 
or else
+                      Format_Object.Last_Paragraph_Subhead_Type = 
Nested_Enumerated or else
+                      Format_Object.Last_Paragraph_Subhead_Type = 
Hanging_Indented_1 or else
+                      Format_Object.Last_Paragraph_Subhead_Type = 
Hanging_Indented_2 or else
+                      Format_Object.Last_Paragraph_Subhead_Type = 
Hanging_Indented_3 or else
+                      Format_Object.Last_Paragraph_Subhead_Type = 
Hanging_Indented_4 or else
+                      Format_Object.Last_Paragraph_Subhead_Type = Title or else
+                      Format_Object.Last_Paragraph_Subhead_Type = In_Table then
+Ada.Text_IO.Put_Line ("%% Oops, can't find out if AARM paragraph, line " & 
ARM_Input.Line_String (Input_Object));
+                       return False; -- Oops, can't tell (double nesting).
+                           -- We make this check to avoid infinite recursion.
+                   else
+                       return Is_AARM_Paragraph 
(Format_Object.Last_Paragraph_Subhead_Type);
+                   end if;
+           end case;
+        end Is_AARM_Paragraph;
+
+
+       procedure Paragraph_Number_String (Update_Numbers : in Boolean) is
+           -- Generate the current (next) paragraph number string into
+           -- Format_Object.Current_Paragraph_String. Update the paragraph
+           -- numbers if Update_Numbers is True.
+            PNum : constant String := 
Integer'Image(Format_Object.Next_Paragraph);
+            PNum_Pred : constant String := 
Integer'Image(Format_Object.Next_Paragraph-1);
+           use type Arm_Database.Paragraph_Change_Kind_Type;
+
+           procedure AARM_Sub_Num (Sub_Letter : in Character) is
+               -- Adds a properly formatted AARM sub letter, with leading '.'.
+               -- Sets the length appropriately.
+           begin
+               Format_Object.Current_Paragraph_String(PNum_Pred'Last) :=
+                   '.';
+               if Sub_Letter <= 'z' then
+                   Format_Object.Current_Paragraph_String(PNum_Pred'Last+1) :=
+                       Sub_Letter;
+                   Format_Object.Current_Paragraph_Len :=
+                           PNum_Pred'Last + 1;
+               elsif Character'Val(Character'Pos(Sub_Letter) - 26) <= 'z' then
+                   -- Double letter.
+                   Format_Object.Current_Paragraph_String(PNum_Pred'Last+1) :=
+                       Character'Val(Character'Pos(Sub_Letter) - 26);
+                   Format_Object.Current_Paragraph_String(PNum_Pred'Last+2) :=
+                       Character'Val(Character'Pos(Sub_Letter) - 26);
+                   Format_Object.Current_Paragraph_Len :=
+                           PNum_Pred'Last + 2;
+               elsif Character'Val(Character'Pos(Sub_Letter) - 52) <= 'z' then
+                   -- Triple letter.
+                   Format_Object.Current_Paragraph_String(PNum_Pred'Last+1) :=
+                       Character'Val(Character'Pos(Sub_Letter) - 52);
+                   Format_Object.Current_Paragraph_String(PNum_Pred'Last+2) :=
+                       Character'Val(Character'Pos(Sub_Letter) - 52);
+                   Format_Object.Current_Paragraph_String(PNum_Pred'Last+3) :=
+                       Character'Val(Character'Pos(Sub_Letter) - 52);
+                   Format_Object.Current_Paragraph_Len :=
+                           PNum_Pred'Last + 3;
+               else -- Doesn't fit!
+                   Ada.Text_IO.Put_Line ("** AARM paragraph number out of 
range, line " & ARM_Input.Line_String (Input_Object));
+                   Format_Object.Current_Paragraph_String(PNum_Pred'Last+1) := 
'$';
+                   Format_Object.Current_Paragraph_String(PNum_Pred'Last+2) := 
'$';
+                   Format_Object.Current_Paragraph_String(PNum_Pred'Last+3) := 
'$';
+                   Format_Object.Current_Paragraph_Len :=
+                           PNum_Pred'Last + 3;
+               end if;
+            end AARM_Sub_Num;
+
+       begin
+           -- The full paragraph number is:
+           -- Num.AARM.Ins/Vers
+           -- where Num is a paragraph number in the RM; AARM is the
+           -- paragraph subletter for AARM text; Ins is the number of
+           -- inserted paragraph; and Vers is the version number ('1'
+           -- for Technical Corrigendum 1; '0' for original RM.;
+           -- '2' for Amendment 1). Note that we don't include change
+           -- versions greater than the one we're currently processing.
+           -- Unused parts are omitted.
+
+           -- %%%% Buglet: If a paragraph was changed by multiple versions,
+           -- we only know the last one. So we guess. If there was a change
+           -- visible here, there must be a revision number, so we use the
+           -- one we're generating. That could be wrong if we have three
+           -- or more versions. I hope we don't need to regenerate old
+           -- versions that far back.
+
+           if Format_Object.Next_Paragraph_Change_Kind = ARM_Database.None or 
else
+              Format_Object.Changes = Old_Only then
+               -- Either there is no change, or we are only producing
+               -- the original document (which means we ignore all
+               -- marked changes).
+               if Is_AARM_Paragraph 
(Format_Object.Next_Paragraph_Subhead_Type) then
+                   Format_Object.Current_Paragraph_String(1 .. 
PNum_Pred'Last-1) :=
+                       PNum_Pred(2..PNum_Pred'Last);
+                   AARM_Sub_Num (Format_Object.Next_AARM_Sub);
+                   if Update_Numbers then
+                       Format_Object.Next_AARM_Sub := 
Character'Succ(Format_Object.Next_AARM_Sub);
+                       Format_Object.Next_AARM_Insert_Para := 1;
+                   end if;
+               else
+                   Format_Object.Current_Paragraph_String(1 .. PNum'Last-1) :=
+                       PNum(2..PNum'Last);
+                   Format_Object.Current_Paragraph_Len := PNum'Last - 1;
+                   if Update_Numbers then
+                       Format_Object.Next_Paragraph := 
Format_Object.Next_Paragraph + 1;
+                       Format_Object.Next_Insert_Para := 1;
+                       Format_Object.Next_AARM_Sub := 'a';
+                       Format_Object.Next_AARM_Insert_Para := 1;
+                   end if;
+               end if;
+           elsif Format_Object.Next_Paragraph_Change_Kind = 
ARM_Database.Inserted or else
+                 Format_Object.Next_Paragraph_Change_Kind = 
ARM_Database.Revised_Inserted_Number or else
+                 Format_Object.Next_Paragraph_Change_Kind = 
ARM_Database.Deleted_Inserted_Number or else
+                 Format_Object.Next_Paragraph_Change_Kind = 
ARM_Database.Deleted_Inserted_Number_No_Delete_Message then
+               -- We'll assume that there are no more than 99 inserted
+               -- paragraphs in a row.
+               Format_Object.Current_Paragraph_String(1 .. PNum_Pred'Last-1) :=
+                   PNum_Pred(2..PNum_Pred'Last);
+               if Is_AARM_Paragraph 
(Format_Object.Next_Paragraph_Subhead_Type) then
+                   if Format_Object.Next_AARM_Sub = 'a' then
+                       AARM_Sub_Num ('a'); -- No paras before the insertion.
+                   else
+                       AARM_Sub_Num 
(Character'Pred(Format_Object.Next_AARM_Sub));
+                           -- Insertions use the preceeding paragraph letter.
+                   end if;
+                   
Format_Object.Current_Paragraph_String(Format_Object.Current_Paragraph_Len + 1) 
:=
+                       '.';
+                   if Format_Object.Next_AARM_Insert_Para >= 10 then
+                       
Format_Object.Current_Paragraph_String(Format_Object.Current_Paragraph_Len + 2) 
:=
+                           
Character'Val((Format_Object.Next_AARM_Insert_Para/10) + Character'Pos('0'));
+                       
Format_Object.Current_Paragraph_String(Format_Object.Current_Paragraph_Len + 3) 
:=
+                           Character'Val((Format_Object.Next_AARM_Insert_Para 
mod 10) + Character'Pos('0'));
+                       Format_Object.Current_Paragraph_Len := 
Format_Object.Current_Paragraph_Len + 1;
+                           -- Make this consistent with the other cases.
+                   else
+                       
Format_Object.Current_Paragraph_String(Format_Object.Current_Paragraph_Len + 2) 
:=
+                           Character'Val(Format_Object.Next_AARM_Insert_Para + 
Character'Pos('0'));
+                   end if;
+                   if Update_Numbers then
+                       Format_Object.Next_AARM_Insert_Para :=
+                           Format_Object.Next_AARM_Insert_Para + 1;
+                   end if;
+               else -- None inserted paragraphs.
+                   Format_Object.Current_Paragraph_Len := PNum_Pred'Last - 1;
+                   
Format_Object.Current_Paragraph_String(Format_Object.Current_Paragraph_Len + 1) 
:=
+                       '.';
+                   if Format_Object.Next_Insert_Para >= 10 then
+                       
Format_Object.Current_Paragraph_String(Format_Object.Current_Paragraph_Len + 2) 
:=
+                           Character'Val((Format_Object.Next_Insert_Para/10) + 
Character'Pos('0'));
+                       
Format_Object.Current_Paragraph_String(Format_Object.Current_Paragraph_Len + 3) 
:=
+                           Character'Val((Format_Object.Next_Insert_Para mod 
10) + Character'Pos('0'));
+                       Format_Object.Current_Paragraph_Len := 
Format_Object.Current_Paragraph_Len + 1;
+                           -- Make this consistent with the other cases.
+                   else
+                       
Format_Object.Current_Paragraph_String(Format_Object.Current_Paragraph_Len + 2) 
:=
+                           Character'Val(Format_Object.Next_Insert_Para + 
Character'Pos('0'));
+                   end if;
+                   if Update_Numbers then
+                       Format_Object.Next_Insert_Para := 
Format_Object.Next_Insert_Para + 1;
+                       -- Note: We don't update the AARM numbers for
+                       -- inserted paragraphs, as the insertion number is
+                       -- not included in them.
+                   end if;
+               end if;
+               if Format_Object.Next_Paragraph_Version /= '0' then
+                   
Format_Object.Current_Paragraph_String(Format_Object.Current_Paragraph_Len + 3) 
:=
+                       '/';
+                   if Format_Object.Next_Paragraph_Version <= 
Format_Object.Change_Version then
+                       
Format_Object.Current_Paragraph_String(Format_Object.Current_Paragraph_Len + 4) 
:=
+                           Format_Object.Next_Paragraph_Version;
+                   else -- Use the number we're generating.
+                       
Format_Object.Current_Paragraph_String(Format_Object.Current_Paragraph_Len + 4) 
:=
+                           Format_Object.Change_Version;
+                   end if;
+                   Format_Object.Current_Paragraph_Len := 
Format_Object.Current_Paragraph_Len + 4;
+               else
+                   Format_Object.Current_Paragraph_Len := 
Format_Object.Current_Paragraph_Len + 2;
+                end if;
+           else --if Format_Object.Next_Paragraph_Change_Kind = 
ARM_Database.Revised or else
+                --   Format_Object.Next_Paragraph_Change_Kind = 
ARM_Database.Deleted or else
+                --   Format_Object.Next_Paragraph_Change_Kind = 
ARM_Database.Inserted_Normal_Number then
+               if Is_AARM_Paragraph 
(Format_Object.Next_Paragraph_Subhead_Type) then
+                   Format_Object.Current_Paragraph_String(1 .. 
PNum_Pred'Last-1) :=
+                       PNum_Pred(2..PNum_Pred'Last);
+                   AARM_Sub_Num (Format_Object.Next_AARM_Sub);
+                   -- Format_Object.Current_Paragraph_Len := 
Format_Object.Current_Paragraph_Len; -- useless assign
+                   if Update_Numbers then
+                       Format_Object.Next_AARM_Sub := 
Character'Succ(Format_Object.Next_AARM_Sub);
+                       Format_Object.Next_AARM_Insert_Para := 1;
+                   end if;
+               else
+                   Format_Object.Current_Paragraph_String(1 .. PNum'Last-1) :=
+                       PNum(2..PNum'Last);
+                   Format_Object.Current_Paragraph_Len := PNum'Last - 1;
+                   if Update_Numbers then
+                       Format_Object.Next_Paragraph := 
Format_Object.Next_Paragraph + 1;
+                       Format_Object.Next_Insert_Para := 1;
+                       Format_Object.Next_AARM_Sub := 'a';
+                       Format_Object.Next_AARM_Insert_Para := 1;
+                   end if;
+               end if;
+               if Format_Object.Next_Paragraph_Version /= '0' then
+                   
Format_Object.Current_Paragraph_String(Format_Object.Current_Paragraph_Len + 1) 
:=
+                       '/';
+                   if Format_Object.Next_Paragraph_Version <= 
Format_Object.Change_Version then
+                       
Format_Object.Current_Paragraph_String(Format_Object.Current_Paragraph_Len + 2) 
:=
+                           Format_Object.Next_Paragraph_Version;
+                   else -- Use the number we're generating.
+                       
Format_Object.Current_Paragraph_String(Format_Object.Current_Paragraph_Len + 2) 
:=
+                           Format_Object.Change_Version;
+                   end if;
+                   Format_Object.Current_Paragraph_Len := 
Format_Object.Current_Paragraph_Len + 2;
+               -- else no version to display.
+               end if;
+           end if;
+       end Paragraph_Number_String;
+
+
+        function Paragraph_String return String is
+           -- Returns a string for a paragraph reference, for use in an
+           -- index entry.
+        begin
+           if Format_Object.In_Paragraph then
+               null; -- It is already is stored.
+           else -- Generate the next paragraph number.
+               Paragraph_Number_String (Update_Numbers => False);
+           end if;
+           return Format_Object.Current_Paragraph_String (
+                       1 .. Format_Object.Current_Paragraph_Len);
+       end Paragraph_String;
+
+
+       procedure Check_Paragraph is
+           -- Open a paragraph if needed before outputting any text that needs
+           -- one.
+
+           procedure Set_Format (For_Type : Paragraph_Type) is
+
+               use type ARM_Output.Paragraph_Indent_Type;
+
+               function Enclosing_Format return Paragraph_Type is
+               begin
+                   for I in reverse 1 .. Format_State.Nesting_Stack_Ptr loop
+                       if Format_State.Nesting_Stack(I).Command = Text_Begin 
and then
+                          (Format_State.Nesting_Stack(I).Is_Formatting) then
+                           return 
Format_State.Nesting_Stack(I).Old_Next_Paragraph_Format;
+                       end if;
+                   end loop;
+                   return Plain; -- The default format.
+               end Enclosing_Format;
+
+               function Enclosing_Indent return 
ARM_Output.Paragraph_Indent_Type is
+                   function Nested_Indent (Start_Nesting : in Natural) return 
ARM_Output.Paragraph_Indent_Type is
+                   begin
+                       for I in reverse 1 .. Start_Nesting loop
+                           if Format_State.Nesting_Stack(I).Command = 
Text_Begin and then
+                              (Format_State.Nesting_Stack(I).Is_Formatting) 
then
+                               case 
Format_State.Nesting_Stack(I).Old_Next_Paragraph_Format is
+                                   when Plain | Introduction |
+                                        Resolution |
+                                        Legality |
+                                        Static_Semantics |
+                                        Link_Time |
+                                        Run_Time |
+                                        Bounded_Errors |
+                                        Erroneous |
+                                        Requirements | -- ImplReq
+                                        Documentation | -- DocReq
+                                        Metrics |
+                                        Permissions | -- ImplPerm
+                                        Advice | -- ImplAdvice
+                                        Examples =>
+                                       return 0; -- No indent.
+                                   when Wide_Above =>
+                                       if Is_AARM_Paragraph 
(Format_Object.Last_Paragraph_Subhead_Type) then
+                                           return 2; -- Normal indent for 
annotations.
+                                       else
+                                           return 0; -- No indent.
+                                       end if;
+                                   when Syntax =>
+                                       return 1; -- One unit.
+                                   when Notes | Single_Note => -- Notes (only 
the numbering varies)
+                                       return 1; -- One unit.
+                                   when Element_Ref | Child_Ref | Usage_Note 
=> -- Similar to an AARM note.
+                                       return 2; -- Normal indent for 
annotations.
+                                   when Language_Design | -- "MetaRules"
+                                        Ada83_Inconsistencies | -- 
Inconsistent83
+                                        Ada83_Incompatibilities | -- 
Incompatible83
+                                        Ada83_Extensions | -- Extend83
+                                        Ada83_Wording | -- DiffWord83
+                                        Ada95_Inconsistencies | -- 
Inconsistent95
+                                        Ada95_Incompatibilities | -- 
Incompatible95
+                                        Ada95_Extensions | -- Extend95
+                                        Ada95_Wording | -- DiffWord95
+                                        Ada2005_Inconsistencies | -- 
Inconsistent2005
+                                        Ada2005_Incompatibilities | -- 
Incompatible2005
+                                        Ada2005_Extensions | -- Extend2005
+                                        Ada2005_Wording | -- DiffWord2005
+                                        Ada2012_Inconsistencies | -- 
Inconsistent2012
+                                        Ada2012_Incompatibilities | -- 
Incompatible2012
+                                        Ada2012_Extensions | -- Extend2012
+                                        Ada2012_Wording => -- DiffWord2012
+                                       return 2; -- Normal indent for 
annotations.
+                                   when Reason | Ramification | Proof |
+                                        Imp_Note | Corr_Change | Discussion |
+                                        Honest | Glossary_Marker | 
Bare_Annotation =>
+                                       return 2; -- Normal indent for 
annotations.
+                                   when Example_Text =>
+                                       if Is_AARM_Paragraph 
(Format_Object.Last_Paragraph_Subhead_Type) then
+                                           return 3; -- Three units.
+                                       else
+                                           return 1; -- One unit.
+                                       end if;
+                                   when Child_Example_Text =>
+                                       return 1 + Nested_Indent(I-1); -- 
Depends on enclosing.
+                                   when Indented_Example_Text =>
+                                       if Is_AARM_Paragraph 
(Format_Object.Last_Paragraph_Subhead_Type) then
+                                           return 6; -- Six units.
+                                       else
+                                           return 4; -- Four units.
+                                       end if;
+                                   when Code_Indented =>
+                                       if Is_AARM_Paragraph 
(Format_Object.Last_Paragraph_Subhead_Type) then
+                                           return 4; -- Four units.
+                                       else
+                                           return 2; -- Two units.
+                                       end if;
+                                   when Indent =>
+                                       return 1 + Nested_Indent(I-1); -- 
Depends on enclosing.
+                                   when Bulleted | Nested_Bulleted | 
Nested_X2_Bulleted =>
+                                       return 1 + Nested_Indent(I-1); -- 
Depends on enclosing.
+                                   when Display =>
+                                       return 1 + Nested_Indent(I-1); -- 
Depends on enclosing.
+                                   when Syntax_Display =>
+                                       return 1; -- One unit.
+                                   when Enumerated | Nested_Enumerated =>
+                                       return 1 + Nested_Indent(I-1); -- 
Depends on enclosing.
+                                   when Syntax_Indented =>
+                                       return 1; -- One unit.
+                                   when Syntax_Production =>
+                                       return Nested_Indent(I-1); -- Depends 
on enclosing.
+                                   when Hanging_Indented_1 =>
+                                       return Nested_Indent(I-1) + 1; -- 
Depends on enclosing, at least 1.
+                                   when Hanging_Indented_2 =>
+                                       return Nested_Indent(I-1) + 2; -- 
Depends on enclosing, at least 2.
+                                   when Hanging_Indented_3 =>
+                                       return Nested_Indent(I-1) + 3; -- 
Depends on enclosing, at least 3.
+                                   when Hanging_Indented_4 =>
+                                       return Nested_Indent(I-1) + 4; -- 
Depends on enclosing, at least 4.
+                                   when Small =>
+                                       return Nested_Indent(I-1); -- Depends 
on enclosing, does not change.
+                                   when Title =>
+                                       return 0; -- No indent.
+                                   when In_Table =>
+                                       -- Shouldn't get here.
+                                       return 0; -- No indent.
+                               end case;
+                           end if;
+                       end loop;
+                       return 0; -- No indent.
+                   end Nested_Indent;
+
+               begin
+                   return Nested_Indent (Format_State.Nesting_Stack_Ptr);
+               end Enclosing_Indent;
+
+               function Is_Small_Format_Paragraph (Subhead_Kind : in 
Paragraph_Type) return Boolean is
+                   -- AARM annotations are in the small font, as are user 
notes.
+               begin
+                   if Is_AARM_Paragraph (Subhead_Kind) then
+                       return True; -- AARM paragraphs are always small.
+                   else -- Check the enclosing formatting for "small" or
+                        -- other styles that imply that.
+                       for I in reverse 1 .. Format_State.Nesting_Stack_Ptr 
loop
+                           if Format_State.Nesting_Stack(I).Command = 
Text_Begin and then
+                              (Format_State.Nesting_Stack(I).Is_Formatting) 
then
+                               case 
Format_State.Nesting_Stack(I).Old_Next_Paragraph_Format is
+                                   when Introduction | Syntax | Resolution | 
Legality |
+                                        Static_Semantics | Link_Time |
+                                        Run_Time | Bounded_Errors |
+                                        Erroneous | Requirements | 
Documentation |
+                                        Metrics | Permissions | Advice | 
Examples =>
+                                       return False;
+                                   when Language_Design | 
Ada83_Inconsistencies |
+                                        Ada83_Incompatibilities | 
Ada83_Extensions |
+                                        Ada83_Wording | Ada95_Inconsistencies |
+                                        Ada95_Incompatibilities | 
Ada95_Extensions |
+                                        Ada95_Wording | 
Ada2005_Inconsistencies |
+                                        Ada2005_Incompatibilities | 
Ada2005_Extensions |
+                                        Ada2005_Wording | 
Ada2012_Inconsistencies |
+                                        Ada2012_Incompatibilities | 
Ada2012_Extensions |
+                                        Ada2012_Wording | Reason | 
Ramification | Proof |
+                                        Imp_Note | Corr_Change | Discussion |
+                                        Honest | Glossary_Marker | 
Bare_Annotation |
+                                        Element_Ref | Child_Ref | Usage_Note |
+                                        Notes | Single_Note | Small =>
+                                       return True;
+                                   when Plain | Wide_Above | In_Table | 
Example_Text | Indented_Example_Text |
+                                        Child_Example_Text | Code_Indented | 
Indent |
+                                        Bulleted |
+                                        Nested_Bulleted | Nested_X2_Bulleted |
+                                        Display | Syntax_Display |
+                                        Syntax_Indented | Syntax_Production |
+                                        Enumerated | Nested_Enumerated |
+                                        Hanging_Indented_1 | 
Hanging_Indented_2 |
+                                        Hanging_Indented_3 | 
Hanging_Indented_4 |
+                                        Title =>
+                                       -- This depends on the containing 
paragraph kind,
+                                       -- keep looking.
+                                       null;
+                               end case;
+                           end if;
+                       end loop;
+                       return False; -- Don't know.
+                   end if;
+               end Is_Small_Format_Paragraph;
+
+           begin
+               case For_Type is
+                   when Plain | Introduction |
+                        Resolution |
+                        Legality |
+                        Static_Semantics |
+                        Link_Time |
+                        Run_Time |
+                        Bounded_Errors |
+                        Erroneous |
+                        Requirements | -- ImplReq
+                        Documentation | -- DocReq
+                        Metrics |
+                        Permissions | -- ImplPerm
+                        Advice | -- ImplAdvice
+                        Examples =>
+                       Format_Object.Style := ARM_Output.Normal;
+                       Format_Object.Indent := 0; -- No indent.
+                       Format_Object.No_Breaks := False;
+                   when Wide_Above =>
+                       if Is_AARM_Paragraph 
(Format_Object.Last_Paragraph_Subhead_Type) then
+                           Format_Object.Style  := ARM_Output.Small_Wide_Above;
+                           Format_Object.Indent := 2; -- Two units.
+                       elsif Format_Object.Last_Paragraph_Subhead_Type = Notes 
or else
+                             Format_Object.Last_Paragraph_Subhead_Type = 
Single_Note then
+                           Format_Object.Style  := ARM_Output.Small_Wide_Above;
+                           Format_Object.Indent := 1; -- One unit.
+                       else
+                           Format_Object.Style  := ARM_Output.Wide_Above;
+                           Format_Object.Indent := 0; -- No indent.
+                       end if;
+                       Format_Object.No_Breaks := False;
+                   when Syntax =>
+                       Format_Object.Style  := ARM_Output.Normal;
+                       Format_Object.Indent := 1; -- One unit.
+                       Format_Object.No_Breaks := True;
+                   when Notes | Single_Note | Small => -- Notes (only the 
numbering varies)
+                       Format_Object.Style  := ARM_Output.Small;
+                       Format_Object.Indent := 1; -- One unit.
+                       Format_Object.No_Breaks := False;
+                   when Element_Ref | Child_Ref | Usage_Note => -- Similar to 
an AARM note.
+                       Format_Object.Style  := ARM_Output.Small;
+                       Format_Object.Indent := 2; -- Two units.
+                       Format_Object.No_Breaks := False;
+                   when Language_Design | -- "MetaRules"
+                        Ada83_Inconsistencies | -- Inconsistent83
+                        Ada83_Incompatibilities | -- Incompatible83
+                        Ada83_Extensions | -- Extend83
+                        Ada83_Wording | -- DiffWord83
+                        Ada95_Inconsistencies | -- Inconsistent95
+                        Ada95_Incompatibilities | -- Incompatible95
+                        Ada95_Extensions | -- Extend95
+                        Ada95_Wording | -- DiffWord95
+                        Ada2005_Inconsistencies | -- Inconsistent2005
+                        Ada2005_Incompatibilities | -- Incompatible2005
+                        Ada2005_Extensions | -- Extend2005
+                        Ada2005_Wording | -- DiffWord2005
+                        Ada2012_Inconsistencies | -- Inconsistent2012
+                        Ada2012_Incompatibilities | -- Incompatible2012
+                        Ada2012_Extensions | -- Extend2012
+                        Ada2012_Wording => -- DiffWord2012
+                       Format_Object.Style  := ARM_Output.Small;
+                       Format_Object.Indent := 2; -- Two units.
+                       Format_Object.No_Breaks := False;
+                   when Reason | Ramification | Proof |
+                        Imp_Note | Corr_Change | Discussion |
+                        Honest | Glossary_Marker | Bare_Annotation =>
+                       Format_Object.Style  := ARM_Output.Small;
+                       Format_Object.Indent := 2; -- Two units.
+                       Format_Object.No_Breaks := False;
+
+                   when Example_Text | Child_Example_Text |
+                       Indented_Example_Text =>
+                       case Format_Object.Examples_Font is
+                           when ARM_Output.Fixed | ARM_Output.Default =>
+                               if Is_Small_Format_Paragraph 
(Format_Object.Last_Paragraph_Subhead_Type) then
+--if not Is_AARM_Paragraph (Format_Object.Last_Paragraph_Subhead_Type) and then
+--   Format_Object.Last_Paragraph_Subhead_Type /= Small then
+--   Ada.Text_IO.Put_Line ("$$ Example in notes: size change, line " & 
ARM_Input.Line_String (Input_Object));
+--end if;
+                                  Format_Object.Style := 
ARM_Output.Small_Examples;
+                               else
+                                  Format_Object.Style := ARM_Output.Examples;
+                               end if;
+                           when ARM_Output.Roman =>
+                               if Is_Small_Format_Paragraph 
(Format_Object.Last_Paragraph_Subhead_Type) then
+                                  Format_Object.Style := ARM_Output.Small;
+                               else
+                                  Format_Object.Style := ARM_Output.Normal;
+                               end if;
+                           when ARM_Output.Swiss =>
+                               if Is_Small_Format_Paragraph 
(Format_Object.Last_Paragraph_Subhead_Type) then
+                                  Format_Object.Style := 
ARM_Output.Small_Swiss_Examples;
+                               else
+                                  Format_Object.Style := 
ARM_Output.Swiss_Examples;
+                               end if;
+                       end case;
+                       Format_Object.No_Breaks := True;
+                       if For_Type = Child_Example_Text then
+                           Format_Object.Indent := 1 + Enclosing_Indent;
+--Ada.Text_IO.Put_Line ("&& Child example paragraph, line " & 
ARM_Input.Line_String (Input_Object) & " EF=" & 
Paragraph_Type'Image(Enclosing_Format) & " Indent=" &
+--   ARM_Output.Paragraph_Indent_Type'Image(Format_Object.Indent));
+                       elsif For_Type = Indented_Example_Text then
+                           if Is_AARM_Paragraph 
(Format_Object.Last_Paragraph_Subhead_Type) then
+                               Format_Object.Indent := 6; -- Fixed indent.
+                           elsif Format_Object.Last_Paragraph_Subhead_Type = 
Notes or else
+                                 Format_Object.Last_Paragraph_Subhead_Type = 
Single_Note then
+                               Format_Object.Indent := 5; -- Fixed indent.
+                           else
+                               Format_Object.Indent := 4; -- Fixed indent.
+                           end if;
+                       else
+                           if Is_AARM_Paragraph 
(Format_Object.Last_Paragraph_Subhead_Type) then
+                               Format_Object.Indent := 3; -- Fixed indent.
+                           elsif Format_Object.Last_Paragraph_Subhead_Type = 
Notes or else
+                                 Format_Object.Last_Paragraph_Subhead_Type = 
Single_Note then
+                               Format_Object.Indent := 2; -- Fixed indent.
+                           else
+                               Format_Object.Indent := 1; -- Fixed indent.
+                           end if;
+                       end if;
+
+                   when Code_Indented =>
+                       if Is_AARM_Paragraph 
(Format_Object.Last_Paragraph_Subhead_Type) then
+                           Format_Object.Style  := ARM_Output.Small;
+                           Format_Object.Indent := 4; -- Four units.
+                       elsif Format_Object.Last_Paragraph_Subhead_Type = Notes 
or else
+                             Format_Object.Last_Paragraph_Subhead_Type = 
Single_Note then
+                           Format_Object.Style  := ARM_Output.Small;
+                           Format_Object.Indent := 3; -- Three units.
+                       elsif Format_Object.Last_Paragraph_Subhead_Type = Small 
then
+                           Format_Object.Style  := ARM_Output.Small;
+                           Format_Object.Indent := 2; -- Two units.
+                       else
+                           Format_Object.Style  := ARM_Output.Normal;
+                           Format_Object.Indent := 2; -- Two indent.
+                       end if;
+                       Format_Object.No_Breaks := False;
+
+                   when Indent =>
+                       if Is_Small_Format_Paragraph 
(Format_Object.Last_Paragraph_Subhead_Type) then
+                           Format_Object.Style  := ARM_Output.Small;
+                       else
+                           Format_Object.Style  := ARM_Output.Normal;
+                       end if;
+                       if Enclosing_Indent = 
Arm_Output.Paragraph_Indent_Type'Last then
+                            raise Program_Error with
+                               "Overindented (indent) text on line " & 
ARM_Input.Line_String (Input_Object);
+                        else
+                           Format_Object.Indent := 1 + Enclosing_Indent;
+                        end if;
+--Ada.Text_IO.Put_Line ("&& Child Indented paragraph, line " & 
ARM_Input.Line_String (Input_Object) & " EF=" & 
Paragraph_Type'Image(Enclosing_Format) & " Indent=" &
+--   ARM_Output.Paragraph_Indent_Type'Image(Format_Object.Indent));
+                       Format_Object.No_Breaks := False;
+
+                   when Bulleted =>
+                       if Is_Small_Format_Paragraph 
(Format_Object.Last_Paragraph_Subhead_Type) then
+                           Format_Object.Style  := ARM_Output.Small_Bulleted;
+                       else
+                           Format_Object.Style  := ARM_Output.Bulleted;
+                       end if;
+                       if Enclosing_Indent = 
Arm_Output.Paragraph_Indent_Type'Last then
+                            raise Program_Error with
+                               "Overindented (bullet) text on line " & 
ARM_Input.Line_String (Input_Object);
+                        else
+                           Format_Object.Indent := 1 + Enclosing_Indent;
+                        end if;
+--Ada.Text_IO.Put_Line ("&& Regular bulleted paragraph, line " & 
ARM_Input.Line_String (Input_Object) & " EF=" & 
Paragraph_Type'Image(Enclosing_Format) & " Indent=" &
+--   ARM_Output.Paragraph_Indent_Type'Image(Format_Object.Indent));
+                       Format_Object.Paragraph_Tab_Stops := ARM_Output.NO_TABS;
+                       Format_Object.No_Breaks := False;
+
+                   when Nested_Bulleted =>
+                       if Is_Small_Format_Paragraph 
(Format_Object.Last_Paragraph_Subhead_Type) then
+                           Format_Object.Style  := 
ARM_Output.Small_Nested_Bulleted;
+                       else
+                           Format_Object.Style  := ARM_Output.Nested_Bulleted;
+                       end if;
+                       if Enclosing_Indent = 
Arm_Output.Paragraph_Indent_Type'Last then
+                            raise Program_Error with
+                               "Overindented (nestbullet) text on line " & 
ARM_Input.Line_String (Input_Object);
+                        else
+                           Format_Object.Indent := 1 + Enclosing_Indent;
+                        end if;
+--Ada.Text_IO.Put_Line ("&& Nested bulleted paragraph, line " & 
ARM_Input.Line_String (Input_Object) & " EF=" & 
Paragraph_Type'Image(Enclosing_Format) & " Indent=" &
+--   ARM_Output.Paragraph_Indent_Type'Image(Format_Object.Indent));
+                       Format_Object.Paragraph_Tab_Stops := ARM_Output.NO_TABS;
+                       Format_Object.No_Breaks := False;
+
+                   when Nested_X2_Bulleted =>
+                       if Is_Small_Format_Paragraph 
(Format_Object.Last_Paragraph_Subhead_Type) then
+                           Format_Object.Style  := 
ARM_Output.Small_Nested_Bulleted;
+                       else
+                           Format_Object.Style  := ARM_Output.Nested_Bulleted;
+                       end if;
+                       Format_Object.Indent := 1 + Enclosing_Indent;
+--Ada.Text_IO.Put_Line ("&& Nested X2 bulleted paragraph, line " & 
ARM_Input.Line_String (Input_Object) & " EF=" & 
Paragraph_Type'Image(Enclosing_Format) & " Indent=" &
+--   ARM_Output.Paragraph_Indent_Type'Image(Format_Object.Indent));
+                       Format_Object.Paragraph_Tab_Stops := ARM_Output.NO_TABS;
+                       Format_Object.No_Breaks := False;
+
+                   when Display =>
+                       if Is_Small_Format_Paragraph 
(Format_Object.Last_Paragraph_Subhead_Type) then
+                           Format_Object.Style  := ARM_Output.Small;
+                       else
+                           Format_Object.Style  := ARM_Output.Normal;
+                       end if;
+                       Format_Object.Indent := 1 + Enclosing_Indent;
+--Ada.Text_IO.Put_Line ("&& Display paragraph, line " & ARM_Input.Line_String 
(Input_Object) & " EF=" & Paragraph_Type'Image(Enclosing_Format) & " Indent=" &
+--   ARM_Output.Paragraph_Indent_Type'Image(Format_Object.Indent));
+                       Format_Object.No_Breaks := True;
+
+                   when Syntax_Display =>
+                       Format_Object.Style := ARM_Output.Small;
+                       Format_Object.Indent := 1;
+                       Format_Object.No_Breaks := True;
+
+                   when Enumerated =>
+                       if Is_Small_Format_Paragraph 
(Format_Object.Last_Paragraph_Subhead_Type) then
+                           Format_Object.Style  := ARM_Output.Small_Enumerated;
+                       else
+                           Format_Object.Style  := ARM_Output.Enumerated;
+                       end if;
+                       Format_Object.Indent := 1 + Enclosing_Indent;
+--Ada.Text_IO.Put_Line ("&& Regular enumerated paragraph, line " & 
ARM_Input.Line_String (Input_Object) & " EF=" & 
Paragraph_Type'Image(Enclosing_Format) & " Indent=" &
+--   ARM_Output.Paragraph_Indent_Type'Image(Format_Object.Indent));
+                       Format_Object.Paragraph_Tab_Stops := ARM_Output.NO_TABS;
+                       Format_Object.No_Breaks := False;
+
+                   when Nested_Enumerated =>
+                       if Is_Small_Format_Paragraph 
(Format_Object.Last_Paragraph_Subhead_Type) then
+                           Format_Object.Style  := ARM_Output.Small_Enumerated;
+                       else
+                           Format_Object.Style  := ARM_Output.Enumerated;
+                       end if;
+                       Format_Object.Indent := 1 + Enclosing_Indent;
+--Ada.Text_IO.Put_Line ("&& Nested enumerated paragraph, line " & 
ARM_Input.Line_String (Input_Object) & " EF=" & 
Paragraph_Type'Image(Enclosing_Format) & " Indent=" &
+--   ARM_Output.Paragraph_Indent_Type'Image(Format_Object.Indent));
+                       -- Note: The difference here is the numbering, not the
+                       -- layout.
+                       Format_Object.Paragraph_Tab_Stops := ARM_Output.NO_TABS;
+                       Format_Object.No_Breaks := False;
+
+                   when Syntax_Indented =>
+                       Format_Object.Style := ARM_Output.Normal;
+                       Format_Object.Indent := 1; -- One unit.
+                       Format_Object.No_Breaks := False;
+                   when Syntax_Production =>
+                       null; -- Leave format alone (but line-breaks are 
preserved).
+                       Format_Object.No_Breaks := True;
+
+                   when Hanging_Indented_1 =>
+                       if Is_Small_Format_Paragraph 
(Format_Object.Last_Paragraph_Subhead_Type) then
+                           Format_Object.Style  := 
ARM_Output.Small_Narrow_Hanging;
+                       else -- Normal:
+                           Format_Object.Style  := ARM_Output.Narrow_Hanging;
+                       end if;
+                       Format_Object.Indent := 1 + Enclosing_Indent;
+                       Format_Object.Paragraph_Tab_Stops := ARM_Output.NO_TABS;
+                       Format_Object.No_Breaks := False;
+
+                   when Hanging_Indented_2 =>
+                       if Is_Small_Format_Paragraph 
(Format_Object.Last_Paragraph_Subhead_Type) then
+                           if Enclosing_Format = Bulleted or else
+                              Enclosing_Format = Enumerated then
+                               Format_Object.Style  := 
ARM_Output.Small_Hanging_in_Bulleted;
+                               -- The right margin is also adjusted in this 
case.
+                               -- This is a weird special case, used only in
+                               -- RM 11.5.
+                           else
+                               Format_Object.Style  := 
ARM_Output.Small_Medium_Hanging;
+                           end if;
+                       else -- Normal:
+                           if Enclosing_Format = Bulleted or else
+                              Enclosing_Format = Enumerated then
+                               Format_Object.Style  := 
ARM_Output.Hanging_in_Bulleted;
+                               -- The right margin is also adjusted in this 
case.
+                           else
+                               Format_Object.Style  := 
ARM_Output.Medium_Hanging;
+                           end if;
+                       end if;
+                       Format_Object.Indent := 2 + Enclosing_Indent;
+                       Format_Object.Paragraph_Tab_Stops := ARM_Output.NO_TABS;
+                       Format_Object.No_Breaks := False;
+
+                   when Hanging_Indented_3 =>
+                       if Is_Small_Format_Paragraph 
(Format_Object.Last_Paragraph_Subhead_Type) then
+                           Format_Object.Style  := 
ARM_Output.Small_Wide_Hanging;
+                       else -- Normal:
+                           Format_Object.Style  := ARM_Output.Wide_Hanging;
+                       end if;
+                       Format_Object.Indent := 3 + Enclosing_Indent;
+                       Format_Object.Paragraph_Tab_Stops := ARM_Output.NO_TABS;
+                       Format_Object.No_Breaks := False;
+
+                   when Hanging_Indented_4 =>
+                       if Is_Small_Format_Paragraph 
(Format_Object.Last_Paragraph_Subhead_Type) then
+                           Format_Object.Style  := 
ARM_Output.Small_Giant_Hanging;
+                       else -- Normal:
+                           Format_Object.Style  := ARM_Output.Giant_Hanging;
+                       end if;
+                       Format_Object.Indent := 4 + Enclosing_Indent;
+                       Format_Object.Paragraph_Tab_Stops := ARM_Output.NO_TABS;
+                       Format_Object.No_Breaks := False;
+
+                   when Title =>
+                       Format_Object.Style := ARM_Output.Title;
+                       Format_Object.Indent := 0; -- No indent.
+                       Format_Object.No_Breaks := False;
+                   when In_Table =>
+                        -- Shouldn't get here.
+                       if Is_Small_Format_Paragraph 
(Format_Object.Last_Paragraph_Subhead_Type) then
+                           Format_Object.Style := ARM_Output.Small;
+                       else
+                           Format_Object.Style := ARM_Output.Normal;
+                       end if;
+                       Format_Object.Indent := 0; -- No indent.
+                       Format_Object.No_Breaks := False;
+               end case;
+           end Set_Format;
+
+
+           procedure Make_Subhead (For_Type : Paragraph_Type) is
+           begin
+               case For_Type is
+                   when Syntax |
+                        Resolution |
+                        Legality |
+                        Static_Semantics |
+                        Link_Time |
+                        Run_Time |
+                        Bounded_Errors |
+                        Erroneous |
+                        Requirements | -- ImplReq
+                        Documentation | -- DocReq
+                        Metrics |
+                        Permissions | -- ImplPerm
+                        Advice | -- ImplAdvice
+                        Examples =>
+                       ARM_Output.Category_Header (Output_Object, 
Data.Paragraph_Kind_Title(For_Type).Str(1..Data.Paragraph_Kind_Title(For_Type).Length));
+                       Format_Object.Last_Paragraph_Subhead_Type := For_Type;
+                   when Notes | Single_Note => -- Notes
+                       if not Format_Object.Use_ISO_2004_Note_Format then
+                           -- The Notes header looks different from the others.
+                           ARM_Output.Start_Paragraph (Output_Object,
+                                                       Style  => 
ARM_Output.Small_Header,
+                                                       Indent => 1,
+                                                       Number => "",
+                                                       No_Breaks => True,
+                                                       Keep_with_Next => True);
+                           ARM_Output.Ordinary_Text (Output_Object, 
Data.Paragraph_Kind_Title(For_Type).Str(1..Data.Paragraph_Kind_Title(For_Type).Length));
+                           ARM_Output.End_Paragraph (Output_Object);
+                           Format_Object.Last_Paragraph_Subhead_Type := 
For_Type;
+--!!Debug:
+--Ada.Text_IO.Put_Line ("Write notes header");
+                       else
+                           null; -- No subheader. We don't change the last
+                               -- subheader generated, either.
+                       end if;
+                   when Language_Design | -- "MetaRules"
+                        Ada83_Inconsistencies | -- Inconsistent83
+                        Ada83_Incompatibilities | -- Incompatible83
+                        Ada83_Extensions | -- Extend83
+                        Ada83_Wording | -- DiffWord83
+                        Ada95_Inconsistencies | -- Inconsistent95
+                        Ada95_Incompatibilities | -- Incompatible95
+                        Ada95_Extensions | -- Extend95
+                        Ada95_Wording | -- DiffWord95
+                        Ada2005_Inconsistencies | -- Inconsistent2005
+                        Ada2005_Incompatibilities | -- Incompatible2005
+                        Ada2005_Extensions | -- Extend2005
+                        Ada2005_Wording | -- DiffWord2005
+                        Ada2012_Inconsistencies | -- Inconsistent2012
+                        Ada2012_Incompatibilities | -- Incompatible2012
+                        Ada2012_Extensions | -- Extend2012
+                        Ada2012_Wording => -- DiffWord2012
+                       ARM_Output.Category_Header (Output_Object, 
Paragraph_Kind_Title(For_Type).Str(1..Paragraph_Kind_Title(For_Type).Length));
+                       Format_Object.Last_Paragraph_Subhead_Type := For_Type;
+                   when Plain | Introduction | Element_Ref | Child_Ref | 
Usage_Note =>
+                       null; -- No subheader. We don't change the last
+                           -- subheader generated, either.
+                   when Reason | Ramification | Proof |
+                        Imp_Note | Corr_Change | Discussion |
+                        Honest | Glossary_Marker | Bare_Annotation |
+                        Wide_Above | Example_Text | Child_Example_Text |
+                        Indented_Example_Text | Code_Indented | Indent |
+                        Bulleted | Nested_Bulleted | Nested_X2_Bulleted |
+                        Display |
+                        Syntax_Display | Syntax_Indented | Syntax_Production |
+                        Hanging_Indented_1 | Hanging_Indented_2 |
+                        Hanging_Indented_3 | Hanging_Indented_4 | Title |
+                        Enumerated | Nested_Enumerated | Small |
+                        In_Table =>
+                       null; -- No subheader. We don't change the last
+                           -- subheader generated, either.
+               end case;
+           end Make_Subhead;
+
+
+           procedure Make_Annotation_Preface (For_Type : Paragraph_Type) is
+           begin
+               case For_Type is
+                   when Plain | Introduction |
+                        Syntax |
+                        Resolution |
+                        Legality |
+                        Static_Semantics |
+                        Link_Time |
+                        Run_Time |
+                        Bounded_Errors |
+                        Erroneous |
+                        Requirements | -- ImplReq
+                        Documentation | -- DocReq
+                        Metrics |
+                        Permissions | -- ImplPerm
+                        Advice | -- ImplAdvice
+                        Examples |
+                        Notes | Single_Note |
+                        Language_Design | -- "MetaRules"
+                        Ada83_Inconsistencies | -- Inconsistent83
+                        Ada83_Incompatibilities | -- Incompatible83
+                        Ada83_Extensions | -- Extend83
+                        Ada83_Wording | -- DiffWord83
+                        Ada95_Inconsistencies | -- Inconsistent95
+                        Ada95_Incompatibilities | -- Incompatible95
+                        Ada95_Extensions | -- Extend95
+                        Ada95_Wording | -- DiffWord95
+                        Ada2005_Inconsistencies | -- Inconsistent2005
+                        Ada2005_Incompatibilities | -- Incompatible2005
+                        Ada2005_Extensions | -- Extend2005
+                        Ada2005_Wording | -- DiffWord2005
+                        Ada2012_Inconsistencies | -- Inconsistent2012
+                        Ada2012_Incompatibilities | -- Incompatible2012
+                        Ada2012_Extensions | -- Extend2012
+                        Ada2012_Wording => -- DiffWord2012
+                       null; -- Not an annotation.
+                   when Reason | Ramification | Proof |
+                        Imp_Note | Corr_Change | Discussion |
+                        Honest | Glossary_Marker |
+                        Element_Ref | Child_Ref | Usage_Note =>
+                       declare
+                           Format_Bold : ARM_Output.Format_Type :=
+                               Format_Object.Text_Format;
+                       begin
+                           Format_Bold.Bold := True;
+                           ARM_Output.Text_Format (Output_Object,
+                                                   Format => Format_Bold);
+                       end;
+                       ARM_Output.Ordinary_Text (Output_Object,
+                            Text => Paragraph_Kind_Title(For_Type).Str(
+                                       
1..Paragraph_Kind_Title(For_Type).Length));
+                       ARM_Output.Text_Format (Output_Object,
+                                               Format => 
Format_Object.Text_Format);
+                       Format_Object.Last_Paragraph_Subhead_Type := For_Type;
+                   when Bare_Annotation =>
+                       null; -- Header (if any) is generated elsewhere.
+                   when Wide_Above |
+                        Example_Text | Child_Example_Text | 
Indented_Example_Text |
+                        Code_Indented | Indent |
+                        Bulleted | Nested_Bulleted | Nested_X2_Bulleted |
+                        Display | Syntax_Display |
+                        Syntax_Indented | Syntax_Production |
+                        Hanging_Indented_1 | Hanging_Indented_2 |
+                        Hanging_Indented_3 | Hanging_Indented_4 | Title |
+                        Enumerated | Nested_Enumerated | Small |
+                        In_Table =>
+                       null; -- Just a format.
+               end case;
+           end Make_Annotation_Preface;
+
+
+           function Show_Leading_Text_for_Paragraph return Boolean is
+               -- Returns True if the leading text (note number,
+               -- annotation preface, etc.) should be shown for this paragraph.
+               -- We assume that the current paragraph has a version less than
+               -- or equal to the one that we're displaying.
+               -- ** Note: This is not quite right. If this
+               -- paragraph is deleted, but a following one needs the
+               -- leading item, this will still lead the item out.
+               -- We *do* have enough information for that, at least in the
+               -- case of annotations: they can be marked as deleted, in
+               -- which case we don't need them here. *But* that information
+               -- doesn't get here in the case that we're not showing 
deletions.
+               -- I can't think of a fix right now, and the note numbers need
+               -- fixing ASAP.
+           begin
+--Ada.Text_IO.Put_Line ("Show_Leading_Text, para kind: " &
+--ARM_Database.Paragraph_Change_Kind_Type'Image(Format_Object.Next_Paragraph_Change_Kind)
 &
+--"; version=" & Format_Object.Next_Paragraph_Version & "; on line " & 
Arm_Input.Line_String(Input_Object));
+               if (ARM_Database."/=" 
(Format_Object.Next_Paragraph_Change_Kind, ARM_Database.Deleted) and then
+                   ARM_Database."/=" 
(Format_Object.Next_Paragraph_Change_Kind, 
ARM_Database.Deleted_Inserted_Number) and then
+                   ARM_Database."/=" 
(Format_Object.Next_Paragraph_Change_Kind, 
ARM_Database.Deleted_No_Delete_Message) and then
+                   ARM_Database."/=" 
(Format_Object.Next_Paragraph_Change_Kind, 
ARM_Database.Deleted_Inserted_Number_No_Delete_Message)) then
+                   -- Not a deleted paragraph.
+--Ada.Text_IO.Put_Line ("%% True - Not deleted");
+                   return True;
+               end if;
+               case Format_Object.Changes is
+                   when ARM_Format.Old_Only =>
+                       -- Display only the original version ('0').
+                       if ARM_Database."=" 
(Format_Object.Next_Paragraph_Change_Kind, 
ARM_Database.Deleted_Inserted_Number) or else
+                          ARM_Database."=" 
(Format_Object.Next_Paragraph_Change_Kind, 
ARM_Database.Deleted_Inserted_Number_No_Delete_Message) then
+--Ada.Text_IO.Put_Line ("%% True - Not original");
+                           return False; -- Not in the original document.
+                       else
+--Ada.Text_IO.Put_Line ("%% True - Original");
+                           return True; -- Probably in the original document.
+                               -- (If the paragraph numbers were "new" in a
+                               -- later version, we couldn't tell.)
+                       end if;
+                   when ARM_Format.New_Only =>
+                       -- Display only the version
+                       -- Format_Object.Change_Version, no insertions or 
deletions.
+--Ada.Text_IO.Put_Line ("%% False - New only");
+                       return False; -- This is always deleted.
+                   when ARM_Format.Show_Changes |
+                        ARM_Format.New_Changes =>
+                       -- Display only the the changes for versions
+                       -- Format_Object.Base_Change_Version ..
+                       -- Format_Object.Change_Version, older changes
+                       -- are applied and newer changes are ignored.
+                       -- (New_Changes shows deletions as a single
+                       -- character for older versions of Word, but otherwise
+                       -- is the same.)
+                       if Format_Object.Next_Paragraph_Version <
+                          Format_Object.Base_Change_Version then
+                           -- Change version is older than we're displaying;
+                           -- no text will be shown.
+--Ada.Text_IO.Put_Line ("%% False - show changes, old version");
+                           return False; -- This is always deleted.
+                       else
+                           -- The correct version.
+--Ada.Text_IO.Put_Line ("%% True - show changes, new enough version");
+                           return True; -- Show the item, as the old text
+                                        -- will be shown as deleted.
+                       end if;
+               end case;
+           end Show_Leading_Text_for_Paragraph;
+
+       begin
+           if not Format_Object.In_Paragraph then
+               -- Output subheader, if needed.
+               if Format_Object.Next_Paragraph_Subhead_Type /=
+                  Format_Object.Last_Paragraph_Subhead_Type then
+                   if (ARM_Database."=" 
(Format_Object.Next_Paragraph_Change_Kind, 
ARM_Database.Deleted_No_Delete_Message) or else
+                       ARM_Database."=" 
(Format_Object.Next_Paragraph_Change_Kind, 
ARM_Database.Deleted_Inserted_Number_No_Delete_Message)) and then
+                      ARM_Format."=" (Format_Object.Changes, 
ARM_Format.New_Only) then
+                       -- Nothing at all should be showm.
+                       null;
+if Format_Object.Next_Paragraph_Subhead_Type /= Plain or else
+   Format_Object.Next_Paragraph_Subhead_Type /= Introduction then
+   Ada.Text_IO.Put_Line("    -- No subhead (DelNoMsg); on line " & 
Arm_Input.Line_String(Input_Object));
+end if;
+                   elsif ((not Format_Object.Number_Paragraphs) or else
+                         Format_Object.No_Para_Num) and then
+                      (ARM_Database."=" 
(Format_Object.Next_Paragraph_Change_Kind, ARM_Database.Deleted) or else
+                       ARM_Database."=" 
(Format_Object.Next_Paragraph_Change_Kind, 
ARM_Database.Deleted_Inserted_Number)) and then
+                      ARM_Format."=" (Format_Object.Changes, 
ARM_Format.New_Only) then
+                       -- Nothing at all should be showm.
+                       null;
+if Format_Object.Next_Paragraph_Subhead_Type /= Plain or else
+   Format_Object.Next_Paragraph_Subhead_Type /= Introduction then
+   Ada.Text_IO.Put_Line("    -- No subhead (Del-no paranum); on line " & 
Arm_Input.Line_String(Input_Object));
+end if;
+                   else
+                       Make_Subhead 
(Format_Object.Next_Paragraph_Subhead_Type);
+                   end if;
+               end if;
+
+               -- Set the paragraph format:
+               Set_Format (Format_Object.Next_Paragraph_Format_Type);
+
+               if Format_Object.Number_Paragraphs and then
+                  not Format_Object.No_Para_Num then
+
+                   -- Format the paragraph number:
+                   Paragraph_Number_String (Update_Numbers => True);
+
+--Ada.Text_IO.Put_Line ("Check_Paragraph, make number " &
+--Format_Object.Current_Paragraph_String (1 .. 
Format_Object.Current_Paragraph_Len) &
+--": format= " & 
Paragraph_Type'Image(Format_Object.Next_Paragraph_Format_Type));
+                   -- ...and start the paragraph:
+                   if (ARM_Database."=" 
(Format_Object.Next_Paragraph_Change_Kind, 
ARM_Database.Deleted_No_Delete_Message) or else
+                       ARM_Database."=" 
(Format_Object.Next_Paragraph_Change_Kind, 
ARM_Database.Deleted_Inserted_Number_No_Delete_Message)) and then
+                      ARM_Format."=" (Format_Object.Changes, 
ARM_Format.New_Only) then
+                       -- Nothing at all should be showm.
+                       -- ** Warning ** If we lie here, the program will crash!
+                       Format_Object.No_Start_Paragraph := True;
+Ada.Text_IO.Put_Line("    -- No Start Paragraph (DelNoMsg)");
+                   else
+                       ARM_Output.Start_Paragraph (Output_Object,
+                                                   Style     => 
Format_Object.Style,
+                                                   Indent    => 
Format_Object.Indent,
+                                                   Number    => 
Format_Object.Current_Paragraph_String (1 .. 
Format_Object.Current_Paragraph_Len),
+                                                   No_Prefix => 
Format_Object.No_Prefix,
+                                                   Tab_Stops => 
Format_Object.Paragraph_Tab_Stops,
+                                                   No_Breaks => 
Format_Object.No_Breaks or Format_Object.In_Bundle,
+                                                   Keep_with_Next => 
Format_Object.Keep_with_Next or Format_Object.In_Bundle,
+                                                   Space_After => 
Format_Object.Space_After);
+                       Format_Object.No_Start_Paragraph := False;
+                   end if;
+                   if ARM_Database."=" 
(Format_Object.Next_Paragraph_Change_Kind, ARM_Database.Deleted) or else
+                      ARM_Database."=" 
(Format_Object.Next_Paragraph_Change_Kind, 
ARM_Database.Deleted_Inserted_Number) then
+                       -- If needed, make the "deleted text" message.
+                       -- We trust that Next_Paragraph_Change_Kind is not
+                       -- set to Deleted if the version number of the change
+                       -- is beyond the document generation version.
+                       -- (Note that Current_Change_Version may not be set,
+                       -- so it is not safe to test here.)
+                       case Format_Object.Changes is
+                           when ARM_Format.New_Only |
+                                ARM_Format.Show_Changes |
+                                ARM_Format.New_Changes =>
+                               -- Note that we include this in the
+                               -- "Show_Changes" version, even when the item
+                               -- is older than the base change version,
+                               -- so that complete paragraph deletions are 
obvious,
+                               -- and also so that we can use revision bars 
rather than
+                               -- displaying the changes in the RM version.
+                               if ARM_Format."=" (Format_Object.Changes, 
ARM_Format.New_Only) and then
+                                   (Format_Object.Next_Paragraph_Format_Type = 
Enumerated or else
+                                    Format_Object.Next_Paragraph_Format_Type = 
Nested_Enumerated or else
+                                    Format_Object.Next_Paragraph_Format_Type = 
Hanging_Indented_1 or else
+                                    Format_Object.Next_Paragraph_Format_Type = 
Hanging_Indented_2 or else
+                                    Format_Object.Next_Paragraph_Format_Type = 
Hanging_Indented_3 or else
+                                    Format_Object.Next_Paragraph_Format_Type = 
Hanging_Indented_4) then
+                                   -- We're in a hanging style, we need to end 
hanging first.
+                                   -- Nothing else will be displayed; if we 
didn't end the hang this
+                                   -- would end up on the same line as the 
next paragraph.
+                                   -- It's possible that we could have a 
problem with
+                                   -- hanging in one of the other cases if no 
text will be
+                                   -- displayed, but there is no way to know 
that here.
+                                   ARM_Output.End_Hang_Item (Output_Object);
+                               end if;
+                               ARM_Output.Text_Format (Output_Object,
+                                   Format => (Bold => 
Format_Object.Text_Format.Bold,
+                                              Italic => True,
+                                              Font => 
Format_Object.Text_Format.Font,
+                                              Color => 
Format_Object.Text_Format.Color,
+                                              Change => ARM_Output.None, -- 
Never mark this as changed!!
+                                              Version => '0', Added_Version => 
'0', -- Not used.
+                                              Size => 
ARM_Output."-"(Format_Object.Text_Format.Size, 1),
+                                              Location => 
Format_Object.Text_Format.Location));
+                               ARM_Output.Ordinary_Text (Output_Object,
+                                    Text => "This paragraph was deleted.");
+                               ARM_Output.Text_Format (Output_Object, -- 
Restore the format.
+                                           Format => 
Format_Object.Text_Format);
+                           when ARM_Format.Old_Only => null; -- Not deleted.
+                       end case;
+                   end if;
+                   Format_Object.In_Paragraph := True;
+                   Format_Object.Last_Non_Space := False;
+
+               else -- No paragraph numbers (or if the paragraph
+                    -- number has been suppressed with @NoParaNum):
+
+--Ada.Text_IO.Put_Line ("Check_Paragraph, no number: format= " & 
Paragraph_Type'Image(Format_Object.Next_Paragraph_Format_Type) &
+--   " output style= " & 
ARM_Output.Paragraph_Style_Type'Image(Format_Object.Style));
+                   -- Start the paragraph:
+                   if (ARM_Database."=" 
(Format_Object.Next_Paragraph_Change_Kind, 
ARM_Database.Deleted_No_Delete_Message) or else
+                       ARM_Database."=" 
(Format_Object.Next_Paragraph_Change_Kind, 
ARM_Database.Deleted_Inserted_Number_No_Delete_Message) or else
+                       ARM_Database."=" 
(Format_Object.Next_Paragraph_Change_Kind, ARM_Database.Deleted) or else
+                       ARM_Database."=" 
(Format_Object.Next_Paragraph_Change_Kind, 
ARM_Database.Deleted_Inserted_Number)) and then
+                      ARM_Format."=" (Format_Object.Changes, 
ARM_Format.New_Only) then
+                       -- Nothing at all should be showm.
+                       -- ** Warning ** If we lie here, the program will crash!
+                       Format_Object.No_Start_Paragraph := True;
+Ada.Text_IO.Put_Line("    -- No Start Paragraph (Del-NewOnly)");
+                   else
+                       ARM_Output.Start_Paragraph (Output_Object,
+                                                   Style     => 
Format_Object.Style,
+                                                   Indent    => 
Format_Object.Indent,
+                                                   Number    => "",
+                                                   No_Prefix => 
Format_Object.No_Prefix,
+                                                   Tab_Stops => 
Format_Object.Paragraph_Tab_Stops,
+                                                   No_Breaks => 
Format_Object.No_Breaks or Format_Object.In_Bundle,
+                                                   Keep_with_Next => 
Format_Object.Keep_with_Next or Format_Object.In_Bundle,
+                                                   Space_After => 
Format_Object.Space_After);
+                       Format_Object.In_Paragraph := True;
+                       Format_Object.No_Start_Paragraph := False;
+                       Format_Object.Current_Paragraph_Len := 0; -- Empty 
paragraph number.
+                       Format_Object.No_Para_Num := False;
+                   end if;
+               end if;
+
+               if not Format_Object.No_Prefix then
+                   if Format_Object.Next_Paragraph_Format_Type = Notes and then
+                      Show_Leading_Text_for_Paragraph then
+                       if not Format_Object.Use_ISO_2004_Note_Format then
+                           -- Output the note number (Ada95 format).
+                           declare
+                               NNum : constant String := 
Integer'Image(Format_Object.Next_Note);
+                           begin
+                               ARM_Output.Ordinary_Text (Output_Object,
+                                                         NNum(2..NNum'Last));
+                               ARM_Output.Hard_Space (Output_Object);
+                               ARM_Output.Hard_Space (Output_Object);
+                               Format_Object.Next_Note := 
Format_Object.Next_Note + 1;
+                           end;
+                       else
+                           -- Output the note header (ISO 2004 format).
+                           declare
+                               NNum : constant String := 
Integer'Image(Format_Object.Next_Note);
+                           begin
+                               ARM_Output.Ordinary_Text (Output_Object,
+                                                         "NOTE " & 
NNum(2..NNum'Last));
+                               ARM_Output.Hard_Space (Output_Object);
+                               ARM_Output.Hard_Space (Output_Object);
+                               ARM_Output.Hard_Space (Output_Object);
+                               Format_Object.Next_Note := 
Format_Object.Next_Note + 1;
+                           end;
+                       end if;
+                   elsif Format_Object.Next_Paragraph_Format_Type = 
Single_Note and then
+                      Show_Leading_Text_for_Paragraph then
+                       if not Format_Object.Use_ISO_2004_Note_Format then
+                           -- No note number, and nothing else needed.
+                           null;
+                       else
+                           -- Output the note header (ISO 2004 format)
+                           -- without a number.
+                           ARM_Output.Ordinary_Text (Output_Object,
+                                                     "NOTE");
+                           ARM_Output.Hard_Space (Output_Object);
+                           ARM_Output.Hard_Space (Output_Object);
+                           ARM_Output.Hard_Space (Output_Object);
+                       end if;
+                   elsif (Format_Object.Next_Paragraph_Format_Type = 
Enumerated or else
+                       Format_Object.Next_Paragraph_Format_Type = 
Nested_Enumerated) and then
+                      Show_Leading_Text_for_Paragraph then
+                       -- Output the item number.
+                       if Format_Object.Use_ISO_2004_Note_Format then
+                           if Format_Object.Enumerated_Level <= 1 then -- 
Outer list.
+                               -- Lower case letters for list:
+                               ARM_Output.Ordinary_Text (Output_Object,
+                                  Character'Val 
((Format_Object.Next_Enumerated_Num - 1) +
+                                       Character'Pos ('a'))
+                                                          & ')');
+                               ARM_Output.End_Hang_Item (Output_Object);
+                               Format_Object.Next_Enumerated_Num := 
Format_Object.Next_Enumerated_Num + 1;
+                           else -- numbered.
+                               declare
+                                   NNum : constant String := 
Integer'Image(Format_Object.Next_Enumerated_Num);
+                               begin
+                                   ARM_Output.Ordinary_Text (Output_Object,
+                                                             
NNum(2..NNum'Last) & ')');
+                                   ARM_Output.End_Hang_Item (Output_Object);
+                                   Format_Object.Next_Enumerated_Num := 
Format_Object.Next_Enumerated_Num + 1;
+                               end;
+                           end if;
+                       else -- Ada 95 lists.
+                           declare
+                               NNum : constant String := 
Integer'Image(Format_Object.Next_Enumerated_Num);
+                           begin
+                               ARM_Output.Ordinary_Text (Output_Object,
+                                                         NNum(2..NNum'Last) & 
'.');
+                               ARM_Output.End_Hang_Item (Output_Object);
+                               Format_Object.Next_Enumerated_Num := 
Format_Object.Next_Enumerated_Num + 1;
+                           end;
+                       end if;
+                   end if;
+               else -- No prefix marked, meaning no number.
+                   Format_Object.No_Prefix := False; -- Reset.
+               end if;
+               Format_Object.Last_Non_Space := False;
+
+               Format_Object.Keep_with_Next := False; -- Reset for next 
paragraph.
+
+               Format_Object.Space_After := ARM_Output.Normal; -- Reset for 
next paragraph.
+
+               -- Output the annotation preface, if needed.
+               if Format_Object.Next_Paragraph_Subhead_Type /=
+                  Format_Object.Last_Paragraph_Subhead_Type then
+                   if Show_Leading_Text_for_Paragraph then
+                       Make_Annotation_Preface 
(Format_Object.Next_Paragraph_Subhead_Type);
+                   end if;
+               end if;
+
+               if Format_Object.References /= null then
+                   -- We assume these are only stored here if we want to see
+                   -- them on *this* paragraph. Thus, we just output them if
+                   -- they exist here. Note: This deallocates the references
+                   -- after writing them.
+                   if Format_Object.No_Start_Paragraph then
+                       -- Oh-oh! Can't generate references; there aren't
+                       -- supposed to be any at this point.
+                       Ada.Text_IO.Put_Line ("** References generated for no 
display paragraph; line " & ARM_Input.Line_String (Input_Object));
+                   else
+                       Make_References (Format_Object.References, 
Format_Object, Output_Object);
+                   end if;
+               end if;
+
+               -- Reset the "next" paragraph kind and version (we have to
+               -- wait, so that we can use this to determine whether
+               -- note numbers and things are output):
+               Format_Object.Next_Paragraph_Change_Kind := ARM_Database.None;
+               Format_Object.Next_Paragraph_Version := '0';
+           -- else already in a paragraph.
+           end if;
+       end Check_Paragraph;
+
+
+       procedure Check_End_Paragraph is
+           -- Check for the end of a paragraph; closing it if necessary.
+           -- We will never be in a paragraph after this routine.
+       begin
+           if Format_Object.In_Paragraph then
+               if not Format_Object.No_Start_Paragraph then
+                   ARM_Output.End_Paragraph (Output_Object);
+--else Ada.Text_IO.Put_Line("No Start Paragraph, so no End Paragraph");
+               end if;
+               Format_Object.In_Paragraph := False;
+               Format_Object.No_Start_Paragraph := False;
+               Format_Object.No_Para_Num := False;
+                       -- Make sure any "leftover"
+                       -- NoParaNums are cleared; we don't want this lasting 
into
+                       -- the next paragraph.
+               if Format_Object.In_Change then
+                   Ada.Text_IO.Put_Line ("** Paragraph end while in change; 
line " & ARM_Input.Line_String (Input_Object));
+                   Format_Object.In_Change := False;
+               end if;
+               -- Check command stack for any open formatting commands,
+               -- and complain (these won't be closed properly and chaos
+               -- may result):
+               for I in reverse 1 .. Format_State.Nesting_Stack_Ptr loop
+                   if Format_State.Nesting_Stack (I).Command in Bold .. 
Tab_Set then
+                       -- There is a formatting command active.
+                       -- (Note: not all of these can be on the stack.)
+                       Ada.Text_IO.Put_Line ("** Paragraph end while in 
formatting command " &
+                           Data.Command_Type'Image(Format_State.Nesting_Stack 
(I).Command) &
+                           "; line " & ARM_Input.Line_String (Input_Object));
+                       exit;
+                   end if;
+               end loop;
+           end if;
+       end Check_End_Paragraph;
+
+
+       type DIE_Kind is (None, Is_Root, Is_Partial);
+
+       procedure Display_Index_Entry (Term_Text : in String;
+                                      Special : in DIE_Kind := None) is
+           -- If necessary, display the index entry for Term_Text.
+           Is_AARM : constant Boolean := Is_AARM_Paragraph 
(Format_Object.Next_Paragraph_Subhead_Type);
+            use type ARM_Output.Size_Type;
+       begin
+           if Format_Object.Display_Index_Entries then
+               Check_Paragraph;
+               if not Is_AARM then
+                   ARM_Output.Text_Format (Output_Object,
+                      Format => (Bold => False, Italic => False,
+                                 Font => ARM_Output.Default,
+                                 Color => ARM_Output.Default,
+                                 Size => -1,
+                                 Change => Format_Object.Text_Format.Change,
+                                 Version => Format_Object.Text_Format.Version,
+                                 Added_Version => 
Format_Object.Text_Format.Added_Version,
+                                 Location => ARM_Output.Normal));
+               end if;
+               ARM_Output.Ordinary_Character (Output_Object, '{');
+               if not Is_AARM then
+                   ARM_Output.Text_Format (Output_Object,
+                      Format => (Bold => False, Italic => True,
+                                 Font => ARM_Output.Default,
+                                 Color => ARM_Output.Default,
+                                 Size => -1,
+                                 Change => Format_Object.Text_Format.Change,
+                                 Version => Format_Object.Text_Format.Version,
+                                 Added_Version => 
Format_Object.Text_Format.Added_Version,
+                                 Location => ARM_Output.Normal));
+               else
+                   ARM_Output.Text_Format (Output_Object,
+                      Format => (Bold => False, Italic => True,
+                                 Font => ARM_Output.Default,
+                                 Color => ARM_Output.Default,
+                                 Size => 0,
+                                 Change => Format_Object.Text_Format.Change,
+                                 Version => Format_Object.Text_Format.Version,
+                                 Added_Version => 
Format_Object.Text_Format.Added_Version,
+                                 Location => ARM_Output.Normal));
+               end if;
+               ARM_Output.Ordinary_Text (Output_Object, 
ARM_Index.Clean(Term_Text, Remove_Soft_Hyphens => True));
+               if not Is_AARM then
+                   ARM_Output.Text_Format (Output_Object,
+                      Format => (Bold => False, Italic => False,
+                                 Font => ARM_Output.Default,
+                                 Color => ARM_Output.Default,
+                                 Size => -1,
+                                 Change => Format_Object.Text_Format.Change,
+                                 Version => Format_Object.Text_Format.Version,
+                                 Added_Version => 
Format_Object.Text_Format.Added_Version,
+                                 Location => ARM_Output.Normal));
+               else
+                   ARM_Output.Text_Format (Output_Object,
+                      Format => (Bold => False, Italic => False,
+                                 Font => ARM_Output.Default,
+                                 Color => ARM_Output.Default,
+                                 Size => 0,
+                                 Change => Format_Object.Text_Format.Change,
+                                 Version => Format_Object.Text_Format.Version,
+                                 Added_Version => 
Format_Object.Text_Format.Added_Version,
+                                 Location => ARM_Output.Normal));
+               end if;
+               case Special is
+                   when None => null;
+                   when Is_Root => ARM_Output.Ordinary_Text (Output_Object, " 
[distributed]");
+                   when Is_Partial => ARM_Output.Ordinary_Text (Output_Object, 
" [partial]");
+               end case;
+               ARM_Output.Ordinary_Character (Output_Object, '}');
+               if not Is_AARM then
+                   ARM_Output.Text_Format (Output_Object,
+                      Format => (Bold => False, Italic => False,
+                                 Font => ARM_Output.Default,
+                                 Color => ARM_Output.Default,
+                                 Size => 0,
+                                 Change => Format_Object.Text_Format.Change,
+                                 Version => Format_Object.Text_Format.Version,
+                                 Added_Version => 
Format_Object.Text_Format.Added_Version,
+                                 Location => ARM_Output.Normal));
+               end if;
+               ARM_Output.Ordinary_Character (Output_Object, ' ');
+               Format_Object.Last_Non_Space := False;
+           -- else not displayed.
+           end if;
+       end Display_Index_Entry;
+
+
+       procedure Parse_Tab_Stops (Stops : in String;
+                                  Tabs : in out ARM_Output.Tab_Info) is
+           -- Parse "Stops" as a tab string; store the result in Tabs.
+           Loc : Natural := Stops'First;
+       begin
+           -- Parse tab stops:
+           -- <tab_stop> ::= <modifier><pica_count_literal>
+           -- <modifier> ::= L | P
+           -- <tab_stops> ::= <tab_stop> {, <tab_stop>}
+           while Loc <= Stops'Length loop
+               Tabs.Number := Tabs.Number + 1;
+               if Stops(Loc) = 'l' or Stops(Loc) = 'L' then
+                   Tabs.Stops(Tabs.Number).Kind :=
+                       ARM_Output.Left_Fixed;
+                   Loc := Loc + 1;
+               elsif Stops(Loc) = 'p' or Stops(Loc) = 'P' then
+                   Tabs.Stops(Tabs.Number).Kind :=
+                       ARM_Output.Left_Proportional;
+                   Loc := Loc + 1;
+               else -- Default:
+                   Tabs.Stops(Tabs.Number).Kind :=
+                       ARM_Output.Left_Fixed;
+               end if;
+               while Loc <= Stops'Length loop
+                   if Stops(Loc) in '0' .. '9' then
+                       Tabs.Stops(Tabs.Number).Stop :=
+                           Tabs.Stops(Tabs.Number).Stop * 10 +
+                           Character'Pos(Stops(Loc)) - Character'Pos('0');
+                       Loc := Loc + 1;
+                   else
+                       exit; -- Number ended.
+                   end if;
+               end loop;
+               if Tabs.Stops(Tabs.Number).Stop = 0 then
+                   Tabs.Number := Tabs.Number - 1;
+                   Ada.Text_IO.Put_Line ("  ** Bad tab stop format, position" 
& Natural'Image(Loc) &
+                       " in [" & Stops & "] from line " &
+                       ARM_Input.Line_String (Input_Object));
+                   exit; -- Give up on this tabset.
+               elsif Tabs.Number < 1 and then
+                       Tabs.Stops(Tabs.Number-1).Stop >=
+                       Tabs.Stops(Tabs.Number).Stop then
+                   Tabs.Number := Tabs.Number - 1;
+                   Ada.Text_IO.Put_Line ("  ** Bad tab stop, less than 
previous, at position" & Natural'Image(Loc) &
+                       " in [" & Stops & "] from line " &
+                       ARM_Input.Line_String (Input_Object));
+                   exit; -- Give up on this tabset.
+               end if;
+               if Loc > Stops'Length then
+                   exit; -- Finished.
+               elsif Stops(Loc) = ',' then
+                   Loc := Loc + 1;
+                   if Loc > Stops'Length then
+                       Ada.Text_IO.Put_Line ("  ** Bad tab stop set format, 
ends with comma in [" &
+                           Stops & "] from line " &
+                           ARM_Input.Line_String (Input_Object));
+                       exit; -- Give up on this tabset.
+                   end if;
+               end if;
+               -- Skip any blanks in between.
+               while Loc <= Stops'Length and then Stops(Loc) = ' ' loop
+                   Loc := Loc + 1;
+               end loop;
+           end loop;
+       end Parse_Tab_Stops;
+
+
+        procedure Write_Subindex (
+                           Subindex_Object : in out ARM_Subindex.Subindex_Type;
+                           Format_Object : in out Format_Type;
+                           Output_Object : in out ARM_Output.Output_Type'Class;
+                           Minimize_Lines : in Boolean) is
+           -- Writes a subindex for the document.
+        begin
+           Check_End_Paragraph;
+
+           -- Insert a blank paragraph:
+            ARM_Output.Start_Paragraph (Output_Object, ARM_Output.Normal,
+                                       Indent => 0, Number => "");
+           ARM_Output.Hard_Space (Output_Object);
+            ARM_Output.End_Paragraph (Output_Object);
+
+           ARM_Output.Set_Columns (Output_Object, Number_of_Columns => 2);
+
+           ARM_Subindex.Write_Subindex (
+                   Subindex_Object,
+                   Output_Object,
+                   Use_Paragraphs => Format_Object.Number_Paragraphs,
+                   Minimize_Lines => Minimize_Lines);
+
+           ARM_Output.Set_Columns (Output_Object, Number_of_Columns => 1);
+
+           -- Not in a paragraph here, either.
+        end Write_Subindex;
+
+
+        procedure Simple_Subindex_Item (
+                   Subindex_Object : in out ARM_Subindex.Subindex_Type;
+                   Format_Object : in out Format_Type;
+                   Output_Object : in out ARM_Output.Output_Type'Class;
+                   Entity_Kind_Name : in String) is
+           -- Create a simple subindex item; the command has a single
+           -- parameter <defn>.
+           -- Create an "In_Unit" entry for the item;
+           -- Also create two regular index entries:
+           --    One for <defn> with a secondary entry of "@i{in} <Unit>"
+           --    (where Unit is the unit saved by a previous RootLibUnit or
+           --    ChildUnit.),
+           -- and a Second (only for version < 2 and if the entity name is
+           --    non-null) for
+           --    "Language-Defined <Entity>" with a
+           --     secondary entry of "<defn> @i{in} <Unit>".
+           -- Also outputs the <defn> parameter to the output file.
+           Entity : String(1..80);
+           Len : Natural := 0;
+           Key : ARM_Index.Index_Key := ARM_Index.Get_Key;
+           Disposition : ARM_Output.Change_Type;
+           use type ARM_Output.Change_Type;
+        begin
+           ARM_Input.Copy_to_String_until_Close_Char (
+               Input_Object,
+               
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Close_Char,
+               Entity,
+               Len);
+
+           -- Determine what to do with the "Language-Defined" entry:
+           Calc_Change_Disposition (
+               Format_Object => Format_Object,
+               Version => '2',
+               Operation => ARM_Output.Deletion,
+               Text_Kind => Disposition);
+           if Entity_Kind_Name'Length = 0 or else
+               Disposition = Do_Not_Display_Text then
+               null; -- Ignore this.
+           elsif Disposition = ARM_Output.None then
+               -- Normal reference:
+               ARM_Index.Add_Reusing_Key (
+                   Term => "Language-Defined " & Entity_Kind_Name,
+                   Subterm => Entity(1..Len) & " in " &
+                             Format_Object.Unit(1..Format_Object.Unit_Len),
+                   Kind => ARM_Index.SubDeclaration_in_Package,
+                   Clause => Clause_String (Format_Object),
+                   Paragraph => Paragraph_String,
+                   Key => Key);
+                   -- Note that the Subdeclaration type changes the
+                   -- "in" into italics.
+           elsif Disposition = ARM_Output.Deletion then
+               null; -- Ignore this (no change info in the index).
+           else -- Insertion.
+               raise Program_Error; -- An insertion inside of a deletion 
command!
+           end if;
+
+           Check_Paragraph;
+           ARM_Output.Index_Target (Output_Object, Key);
+
+           if Format_Object.Unit_Len = 0 then
+               Ada.Text_IO.Put_Line ("** No unit defined for index entry 
expecting one on line " & ARM_Input.Line_String (Input_Object));
+
+               ARM_Index.Add_Reusing_Key (
+                   Term => Entity(1..Len),
+                   Subterm => "*unknown*",
+                   Kind => ARM_Index.Declaration_in_Package,
+                   Clause => Clause_String (Format_Object),
+                   Paragraph => Paragraph_String,
+                   Key => Key);
+
+               ARM_Subindex.Insert (
+                   Subindex_Object => Subindex_Object,
+                   Entity => Entity(1..Len),
+                   From_Unit => "*unknown*",
+                   Kind => ARM_Subindex.In_Unit,
+                   Clause => Clause_String (Format_Object),
+                   Paragraph => Paragraph_String,
+                   Key => Key);
+           else
+               ARM_Index.Add_Reusing_Key (
+                   Term => Entity(1..Len),
+                   Subterm => Format_Object.Unit(1..Format_Object.Unit_Len),
+                   Kind => ARM_Index.Declaration_in_Package,
+                   Clause => Clause_String (Format_Object),
+                   Paragraph => Paragraph_String,
+                   Key => Key);
+
+               ARM_Subindex.Insert (
+                   Subindex_Object => Subindex_Object,
+                   Entity => Entity(1..Len),
+                   From_Unit => Format_Object.Unit(1..Format_Object.Unit_Len),
+                   Kind => ARM_Subindex.In_Unit,
+                   Clause => Clause_String (Format_Object),
+                   Paragraph => Paragraph_String,
+                   Key => Key);
+           end if;
+
+           ARM_Output.Ordinary_Text (Output_Object, Entity(1..Len));
+           Format_Object.Last_Non_Space := True;
+       end Simple_Subindex_Item;
+
+
+        procedure Child_Unit (
+                   Subindex_Object : in out ARM_Subindex.Subindex_Type;
+                   Format_Object : in out Format_Type;
+                   Output_Object : in out ARM_Output.Output_Type'Class) is
+           -- Generates three index entries: An index entry for <child>, with
+           -- a secondary of "@i{child of} <parent>", an index entry for
+           -- "Language-Defined Library Units" with a secondary entry of
+           -- <parent>.<child>, and an index entry for <parent>.<child>. The
+           -- Unit is set to <parent>.<child>. (For version 2 or later, the
+           -- Language-Defined entry is not generated.) The first entry is
+           -- added to the subindex list as well.
+           Close_Ch : Character;
+           Parent, Child : String(1..80);
+           PLen, CLen : Natural := 0;
+           Key : ARM_Index.Index_Key := ARM_Index.Get_Key;
+            Disposition : ARM_Output.Change_Type;
+            use type ARM_Output.Change_Type;
+        begin
+           ARM_Input.Check_Parameter_Name (Input_Object,
+               Param_Name => "Parent" & (7..ARM_Input.Command_Name_Type'Last 
=> ' '),
+               Is_First => True,
+               Param_Close_Bracket => Close_Ch);
+           if Close_Ch /= ' ' then
+               -- Copy over the term:
+               ARM_Input.Copy_to_String_until_Close_Char (
+                   Input_Object,
+                   Close_Ch,
+                   Parent,
+                   PLen);
+           -- else no parameter. Weird.
+           end if;
+
+           ARM_Input.Check_Parameter_Name (Input_Object,
+               Param_Name => "Child" & (6..ARM_Input.Command_Name_Type'Last => 
' '),
+               Is_First => False,
+               Param_Close_Bracket => Close_Ch);
+           if Close_Ch /= ' ' then
+               -- Copy over the term:
+               ARM_Input.Copy_to_String_until_Close_Char (
+                   Input_Object,
+                   Close_Ch,
+                   Child,
+                   CLen);
+           -- else no parameter. Weird.
+           end if;
+
+           -- Set the current unit for future use:
+           Format_Object.Unit_Len := PLen + CLen + 1;
+           Format_Object.Unit (1..Format_Object.Unit_Len) :=
+               Parent(1..PLen) & '.' & Child(1..CLen);
+
+           ARM_Index.Add_Reusing_Key (
+                   Term => Child(1..CLen),
+                   Subterm => Parent(1..PLen),
+                   Kind => ARM_Index.Child_Unit_Parent,
+                   Clause => Clause_String (Format_Object),
+                   Paragraph => Paragraph_String,
+                   Key => Key);
+
+           Check_Paragraph;
+           ARM_Output.Index_Target (Output_Object, Key);
+
+           -- Determine what to do with the "Language-Defined" entry:
+           Calc_Change_Disposition (
+               Format_Object => Format_Object,
+               Version => '2',
+               Operation => ARM_Output.Deletion,
+               Text_Kind => Disposition);
+           if Disposition = Do_Not_Display_Text then
+               null; -- Ignore this.
+           elsif Disposition = ARM_Output.None then
+               -- Make reference:
+               ARM_Index.Add_Reusing_Key (
+                   Term => "Language-Defined Library Units",
+                   Subterm => Parent(1..PLen) & '.' & Child(1..CLen),
+                   Kind => ARM_Index.Primary_Term_and_Subterm,
+                   Clause => Clause_String (Format_Object),
+                   Paragraph => Paragraph_String,
+                   Key => Key);
+           elsif Disposition = ARM_Output.Deletion then
+               null; -- Ignore this (no change info in the index).
+           else -- Insertion.
+               raise Program_Error; -- An insertion inside of a deletion 
command!
+           end if;
+
+           ARM_Index.Add_Reusing_Key (
+                   Term => Parent(1..PLen) & '.' & Child(1..CLen),
+                   Kind => ARM_Index.Primary_Term,
+                   Clause => Clause_String (Format_Object),
+                   Paragraph => Paragraph_String,
+                   Key => Key);
+
+           ARM_Subindex.Insert (
+                   Subindex_Object => Subindex_Object,
+                   Entity => Child(1..CLen),
+                   From_Unit => Parent(1..PLen),
+                   Kind => ARM_Subindex.Child_of_Parent,
+                   Clause => Clause_String (Format_Object),
+                   Paragraph => Paragraph_String,
+                   Key => Key);
+
+           -- Leave the command end marker, let normal processing
+           -- get rid of it.
+        end Child_Unit;
+
+
+       procedure Process_Begin is
+           -- Process a "begin". The "begin" has been stacked.
+
+           procedure Toss_for_RM (Paragraph_Kind_Name : in String) is
+               -- Call this for AARM-only sections.
+               -- It skips *everything* until the matching end. This includes
+               -- index references, section references, and the like. Anything
+               -- that ought to be in the RM should be moved outside of the
+               -- AARM specific code. Thus, we can use a fairly simple text
+               -- skip.
+               Ch : Character;
+               Close_Ch : Character;
+               Command_Name : ARM_Input.Command_Name_Type;
+           begin
+               -- Skip everything up to the next @end{<Paragraph_Kind_Name...
+               -- then pop the stack and return.
+               loop
+                   ARM_Input.Get_Char (Input_Object, Ch);
+                   while Ch /= '@' loop
+                       ARM_Input.Get_Char (Input_Object, Ch);
+                   end loop;
+                   Arm_Input.Get_Name (Input_Object, Command_Name, 
Null_Name_Allowed => True);
+                       -- Get the command name.
+                   if Ada.Characters.Handling.To_Lower (Ada.Strings.Fixed.Trim 
(
+                       Command_Name, Ada.Strings.Right)) /= "end" then
+                       -- Not an "end" command, keep going.
+                       null;
+                   else -- An End command, check if this is the one we want:
+                       ARM_Input.Get_Char (Input_Object, Ch);
+                       if ARM_Input.Is_Open_Char (Ch) then -- Start parameter:
+                           Close_Ch := ARM_Input.Get_Close_Char (Ch);
+                           Arm_Input.Get_Name (Input_Object, Command_Name); -- 
Get the end "type".
+                           if Ada.Characters.Handling.To_Lower 
(Ada.Strings.Fixed.Trim (
+                               Command_Name, Ada.Strings.Right)) /= 
Paragraph_Kind_Name then
+                               null; -- Wrong end, keep going.
+                           else -- Right end!
+                               -- Skip to the close character:
+                               while Ch /= Close_Ch loop
+                                   ARM_Input.Get_Char (Input_Object, Ch);
+                               end loop;
+                               -- Unstack the "begin".
+                               Format_State.Nesting_Stack_Ptr := 
Format_State.Nesting_Stack_Ptr - 1;
+--Ada.Text_IO.Put_Line (" &Unstack (End AARM-Only)");
+                               -- And we're done with this "begin".
+                               return;
+                           end if;
+                       else -- No parameter, forget it.
+                           null;
+                       end if;
+                   end if;
+               end loop;
+           end Toss_for_RM;
+
+       begin
+           Check_End_Paragraph; -- End any paragraph that we're in.
+           if Ada.Characters.Handling.To_Lower (Ada.Strings.Fixed.Trim (
+               
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Name, 
Ada.Strings.Right))
+               = "comment" then
+               Toss_for_RM ("comment");
+           -- Format only:
+           elsif Ada.Characters.Handling.To_Lower (Ada.Strings.Fixed.Trim (
+               
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Name, 
Ada.Strings.Right))
+               = "wideabove" then
+               Format_Object.Next_Paragraph_Format_Type := Wide_Above;
+           elsif Ada.Characters.Handling.To_Lower (Ada.Strings.Fixed.Trim (
+               
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Name, 
Ada.Strings.Right))
+               = "example" then
+               Format_Object.Next_Paragraph_Format_Type := Example_Text;
+           elsif Ada.Characters.Handling.To_Lower (Ada.Strings.Fixed.Trim (
+               
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Name, 
Ada.Strings.Right))
+               = "childexample" then
+               Format_Object.Next_Paragraph_Format_Type := Child_Example_Text;
+           elsif Ada.Characters.Handling.To_Lower (Ada.Strings.Fixed.Trim (
+               
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Name, 
Ada.Strings.Right))
+               = "descexample" then
+               Format_Object.Next_Paragraph_Format_Type := 
Indented_Example_Text;
+           elsif Ada.Characters.Handling.To_Lower (Ada.Strings.Fixed.Trim (
+               
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Name, 
Ada.Strings.Right))
+               = "describecode" then
+               Format_Object.Next_Paragraph_Format_Type := Code_Indented;
+           elsif Ada.Characters.Handling.To_Lower (Ada.Strings.Fixed.Trim (
+               
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Name, 
Ada.Strings.Right))
+               = "indent" then
+               Format_Object.Next_Paragraph_Format_Type := Indent;
+           elsif Ada.Characters.Handling.To_Lower (Ada.Strings.Fixed.Trim (
+               
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Name, 
Ada.Strings.Right))
+               = "itemize" then
+               Format_Object.Next_Paragraph_Format_Type := Bulleted;
+           elsif Ada.Characters.Handling.To_Lower (Ada.Strings.Fixed.Trim (
+               
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Name, 
Ada.Strings.Right))
+               = "inneritemize" then
+               Format_Object.Next_Paragraph_Format_Type := Nested_Bulleted;
+           elsif Ada.Characters.Handling.To_Lower (Ada.Strings.Fixed.Trim (
+               
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Name, 
Ada.Strings.Right))
+               = "innerinneritemize" then
+               Format_Object.Next_Paragraph_Format_Type := Nested_X2_Bulleted;
+           elsif Ada.Characters.Handling.To_Lower (Ada.Strings.Fixed.Trim (
+               
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Name, 
Ada.Strings.Right))
+               = "display" then
+               Format_Object.Next_Paragraph_Format_Type := Display;
+           elsif Ada.Characters.Handling.To_Lower (Ada.Strings.Fixed.Trim (
+               
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Name, 
Ada.Strings.Right))
+               = "syntaxdisplay" then
+               Format_Object.Next_Paragraph_Format_Type := Syntax_Display;
+           elsif Ada.Characters.Handling.To_Lower (Ada.Strings.Fixed.Trim (
+               
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Name, 
Ada.Strings.Right))
+               = "syntaxtext" then
+               Format_Object.Next_Paragraph_Format_Type := Syntax_Indented;
+           elsif Ada.Characters.Handling.To_Lower (Ada.Strings.Fixed.Trim (
+               
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Name, 
Ada.Strings.Right))
+               = "description" then
+               Format_Object.Next_Paragraph_Format_Type := Hanging_Indented_3;
+           elsif Ada.Characters.Handling.To_Lower (Ada.Strings.Fixed.Trim (
+               
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Name, 
Ada.Strings.Right))
+               = "small" then
+               Format_Object.Next_Paragraph_Format_Type := Small;
+           elsif Ada.Characters.Handling.To_Lower (Ada.Strings.Fixed.Trim (
+               
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Name, 
Ada.Strings.Right))
+               = "enumerate" then
+               Format_Object.Next_Paragraph_Format_Type := Enumerated;
+               Format_Object.Next_Enumerated_Num := 1;
+               Format_Object.Enumerated_Level := 
Format_Object.Enumerated_Level + 1;
+           elsif Ada.Characters.Handling.To_Lower (Ada.Strings.Fixed.Trim (
+               
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Name, 
Ada.Strings.Right))
+               = "innerenumerate" then
+               Format_Object.Next_Paragraph_Format_Type := Nested_Enumerated;
+               Format_Object.Next_Enumerated_Num := 1;
+               Format_Object.Enumerated_Level := 
Format_Object.Enumerated_Level + 1;
+           elsif Ada.Characters.Handling.To_Lower (Ada.Strings.Fixed.Trim (
+               
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Name, 
Ada.Strings.Right))
+               = "hang1list" then
+               Format_Object.Next_Paragraph_Format_Type := Hanging_Indented_1;
+           elsif Ada.Characters.Handling.To_Lower (Ada.Strings.Fixed.Trim (
+               
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Name, 
Ada.Strings.Right))
+               = "hang2list" then
+               Format_Object.Next_Paragraph_Format_Type := Hanging_Indented_2;
+           elsif Ada.Characters.Handling.To_Lower (Ada.Strings.Fixed.Trim (
+               
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Name, 
Ada.Strings.Right))
+               = "hang3list" then
+               Format_Object.Next_Paragraph_Format_Type := Hanging_Indented_3;
+           elsif Ada.Characters.Handling.To_Lower (Ada.Strings.Fixed.Trim (
+               
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Name, 
Ada.Strings.Right))
+               = "hang4list" then
+               Format_Object.Next_Paragraph_Format_Type := Hanging_Indented_4;
+           elsif Ada.Characters.Handling.To_Lower (Ada.Strings.Fixed.Trim (
+               
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Name, 
Ada.Strings.Right))
+               = "title" then
+               Format_Object.Next_Paragraph_Format_Type := Title;
+           elsif Ada.Characters.Handling.To_Lower (Ada.Strings.Fixed.Trim (
+               
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Name, 
Ada.Strings.Right))
+               = "bundle" then
+               -- Should prevent any page breaks until the "end". Not
+               -- implemented currently.
+               
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Is_Formatting
+                   := False; -- Leave the format alone.
+               Format_Object.In_Bundle := True; -- We don't need to stack this,
+                   -- because once we're in it, we can't leave it until the 
@End.
+           elsif Ada.Characters.Handling.To_Lower (Ada.Strings.Fixed.Trim (
+               
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Name, 
Ada.Strings.Right))
+               = "twocol" then
+               -- Two column; no affect on format.
+               ARM_Output.Set_Columns (Output_Object, Number_of_Columns => 2);
+               
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Is_Formatting
+                   := False;
+           elsif Ada.Characters.Handling.To_Lower (Ada.Strings.Fixed.Trim (
+               
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Name, 
Ada.Strings.Right))
+               = "fourcol" then
+               -- Four column; no affect on format.
+               ARM_Output.Set_Columns (Output_Object, Number_of_Columns => 4);
+               
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Is_Formatting
+                   := False;
+           -- RM groupings:
+           elsif Ada.Characters.Handling.To_Lower (Ada.Strings.Fixed.Trim (
+               
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Name, 
Ada.Strings.Right))
+               = "intro" then
+               Format_Object.Next_Paragraph_Format_Type := Introduction;
+               Format_Object.Next_Paragraph_Subhead_Type := Introduction;
+           elsif Ada.Characters.Handling.To_Lower (Ada.Strings.Fixed.Trim (
+               
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Name, 
Ada.Strings.Right))
+               = "syntax" then
+               Format_Object.Next_Paragraph_Format_Type := Syntax;
+               Format_Object.Next_Paragraph_Subhead_Type := Syntax;
+           elsif Ada.Characters.Handling.To_Lower (Ada.Strings.Fixed.Trim (
+               
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Name, 
Ada.Strings.Right))
+               = "resolution" then
+               Format_Object.Next_Paragraph_Format_Type := Resolution;
+               Format_Object.Next_Paragraph_Subhead_Type := Resolution;
+           elsif Ada.Characters.Handling.To_Lower (Ada.Strings.Fixed.Trim (
+               
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Name, 
Ada.Strings.Right))
+               = "legality" then
+               Format_Object.Next_Paragraph_Format_Type := Legality;
+               Format_Object.Next_Paragraph_Subhead_Type := Legality;
+           elsif Ada.Characters.Handling.To_Lower (Ada.Strings.Fixed.Trim (
+               
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Name, 
Ada.Strings.Right))
+               = "staticsem" then
+               Format_Object.Next_Paragraph_Format_Type := Static_Semantics;
+               Format_Object.Next_Paragraph_Subhead_Type := Static_Semantics;
+           elsif Ada.Characters.Handling.To_Lower (Ada.Strings.Fixed.Trim (
+               
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Name, 
Ada.Strings.Right))
+               = "linktime" then
+               Format_Object.Next_Paragraph_Format_Type := Link_Time;
+               Format_Object.Next_Paragraph_Subhead_Type := Link_Time;
+           elsif Ada.Characters.Handling.To_Lower (Ada.Strings.Fixed.Trim (
+               
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Name, 
Ada.Strings.Right))
+               = "runtime" then
+               Format_Object.Next_Paragraph_Format_Type := Run_Time;
+               Format_Object.Next_Paragraph_Subhead_Type := Run_Time;
+           elsif Ada.Characters.Handling.To_Lower (Ada.Strings.Fixed.Trim (
+               
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Name, 
Ada.Strings.Right))
+               = "bounded" then
+               Format_Object.Next_Paragraph_Format_Type := Bounded_Errors;
+               Format_Object.Next_Paragraph_Subhead_Type := Bounded_Errors;
+           elsif Ada.Characters.Handling.To_Lower (Ada.Strings.Fixed.Trim (
+               
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Name, 
Ada.Strings.Right))
+               = "erron" then
+               Format_Object.Next_Paragraph_Format_Type := Erroneous;
+               Format_Object.Next_Paragraph_Subhead_Type := Erroneous;
+           elsif Ada.Characters.Handling.To_Lower (Ada.Strings.Fixed.Trim (
+               
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Name, 
Ada.Strings.Right))
+               = "implreq" then
+               Format_Object.Next_Paragraph_Format_Type := Requirements;
+               Format_Object.Next_Paragraph_Subhead_Type := Requirements;
+           elsif Ada.Characters.Handling.To_Lower (Ada.Strings.Fixed.Trim (
+               
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Name, 
Ada.Strings.Right))
+               = "docreq" then
+               Format_Object.Next_Paragraph_Format_Type := Documentation;
+               Format_Object.Next_Paragraph_Subhead_Type := Documentation;
+           elsif Ada.Characters.Handling.To_Lower (Ada.Strings.Fixed.Trim (
+               
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Name, 
Ada.Strings.Right))
+               = "metrics" then
+               Format_Object.Next_Paragraph_Format_Type := Metrics;
+               Format_Object.Next_Paragraph_Subhead_Type := Metrics;
+           elsif Ada.Characters.Handling.To_Lower (Ada.Strings.Fixed.Trim (
+               
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Name, 
Ada.Strings.Right))
+               = "implperm" then
+               Format_Object.Next_Paragraph_Format_Type := Permissions;
+               Format_Object.Next_Paragraph_Subhead_Type := Permissions;
+           elsif Ada.Characters.Handling.To_Lower (Ada.Strings.Fixed.Trim (
+               
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Name, 
Ada.Strings.Right))
+               = "impladvice" then
+               Format_Object.Next_Paragraph_Format_Type := Advice;
+               Format_Object.Next_Paragraph_Subhead_Type := Advice;
+           elsif Ada.Characters.Handling.To_Lower (Ada.Strings.Fixed.Trim (
+               
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Name, 
Ada.Strings.Right))
+               = "examples" then
+               Format_Object.Next_Paragraph_Format_Type := Examples;
+               Format_Object.Next_Paragraph_Subhead_Type := Examples;
+           elsif Ada.Characters.Handling.To_Lower (Ada.Strings.Fixed.Trim (
+               
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Name, 
Ada.Strings.Right))
+               = "notes" then
+               Format_Object.Next_Paragraph_Format_Type := Notes;
+               Format_Object.Next_Paragraph_Subhead_Type := Notes;
+           elsif Ada.Characters.Handling.To_Lower (Ada.Strings.Fixed.Trim (
+               
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Name, 
Ada.Strings.Right))
+               = "singlenote" then
+               Format_Object.Next_Paragraph_Format_Type := Single_Note;
+               Format_Object.Next_Paragraph_Subhead_Type := Single_Note;
+           elsif Ada.Characters.Handling.To_Lower (Ada.Strings.Fixed.Trim (
+               
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Name, 
Ada.Strings.Right))
+               = "rmonly" then
+               if Format_Object.Include_Annotations then -- AARM, but this is 
RM-only.
+                   Toss_for_RM ("rmonly");
+               else
+                   
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Is_Formatting
+                       := False; -- Leave the format alone.
+               end if;
+           -- NotISO text:
+           elsif Ada.Characters.Handling.To_Lower (Ada.Strings.Fixed.Trim (
+               
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Name, 
Ada.Strings.Right))
+               = "notiso" then
+               if Format_Object.Include_ISO then
+                   Toss_for_RM ("notiso"); -- This text does not appear in ISO 
documents.
+               else -- not ISO
+                   
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Is_Formatting
+                       := False; -- Leave the format alone.
+               end if;
+--!!Debug:
+---Ada.Text_IO.Put_Line ("Next=" & 
Paragraph_Type'Image(Format_Object.Next_Paragraph_Subhead_Type));
+
+           -- ISOOnly text:
+           elsif Ada.Characters.Handling.To_Lower (Ada.Strings.Fixed.Trim (
+               
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Name, 
Ada.Strings.Right))
+               = "isoonly" then
+               if Format_Object.Include_ISO then
+                   
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Is_Formatting
+                       := False; -- Leave the format alone.
+               else -- Not ISO
+                   Toss_for_RM ("isoonly"); -- This text does not appear in 
non-ISO documents.
+               end if;
+           -- AARM groupings:
+           elsif Ada.Characters.Handling.To_Lower (Ada.Strings.Fixed.Trim (
+               
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Name, 
Ada.Strings.Right))
+               = "metarules" then
+               if Format_Object.Include_Annotations then
+                   Format_Object.Next_Paragraph_Format_Type := Language_Design;
+                   Format_Object.Next_Paragraph_Subhead_Type := 
Language_Design;
+               else -- Don't show annotations.
+                   Toss_for_RM ("metarules");
+               end if;
+           elsif Ada.Characters.Handling.To_Lower (Ada.Strings.Fixed.Trim (
+               
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Name, 
Ada.Strings.Right))
+               = "inconsistent83" then
+               if Format_Object.Include_Annotations then
+                   Format_Object.Next_Paragraph_Format_Type := 
Ada83_Inconsistencies;
+                   Format_Object.Next_Paragraph_Subhead_Type := 
Ada83_Inconsistencies;
+               else -- Don't show annotations.
+                   Toss_for_RM ("inconsistent83");
+               end if;
+           elsif Ada.Characters.Handling.To_Lower (Ada.Strings.Fixed.Trim (
+               
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Name, 
Ada.Strings.Right))
+               = "incompatible83" then
+               if Format_Object.Include_Annotations then
+                   Format_Object.Next_Paragraph_Format_Type := 
Ada83_Incompatibilities;
+                   Format_Object.Next_Paragraph_Subhead_Type := 
Ada83_Incompatibilities;
+               else -- Don't show annotations.
+                   Toss_for_RM ("incompatible83");
+               end if;
+           elsif Ada.Characters.Handling.To_Lower (Ada.Strings.Fixed.Trim (
+               
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Name, 
Ada.Strings.Right))
+               = "extend83" then
+               if Format_Object.Include_Annotations then
+                   Format_Object.Next_Paragraph_Format_Type := 
Ada83_Extensions;
+                   Format_Object.Next_Paragraph_Subhead_Type := 
Ada83_Extensions;
+               else -- Don't show annotations.
+                   Toss_for_RM ("extend83");
+               end if;
+           elsif Ada.Characters.Handling.To_Lower (Ada.Strings.Fixed.Trim (
+               
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Name, 
Ada.Strings.Right))
+               = "diffword83" then
+               if Format_Object.Include_Annotations then
+                   Format_Object.Next_Paragraph_Format_Type := Ada83_Wording;
+                   Format_Object.Next_Paragraph_Subhead_Type := Ada83_Wording;
+               else -- Don't show annotations.
+                   Toss_for_RM ("diffword83");
+               end if;
+           elsif Ada.Characters.Handling.To_Lower (Ada.Strings.Fixed.Trim (
+               
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Name, 
Ada.Strings.Right))
+               = "inconsistent95" then
+               if Format_Object.Include_Annotations then
+                   Format_Object.Next_Paragraph_Format_Type := 
Ada95_Inconsistencies;
+                   Format_Object.Next_Paragraph_Subhead_Type := 
Ada95_Inconsistencies;
+               else -- Don't show annotations.
+                   Toss_for_RM ("inconsistent95");
+               end if;
+           elsif Ada.Characters.Handling.To_Lower (Ada.Strings.Fixed.Trim (
+               
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Name, 
Ada.Strings.Right))
+               = "incompatible95" then
+               if Format_Object.Include_Annotations then
+                   Format_Object.Next_Paragraph_Format_Type := 
Ada95_Incompatibilities;
+                   Format_Object.Next_Paragraph_Subhead_Type := 
Ada95_Incompatibilities;
+               else -- Don't show annotations.
+                   Toss_for_RM ("incompatible95");
+               end if;
+           elsif Ada.Characters.Handling.To_Lower (Ada.Strings.Fixed.Trim (
+               
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Name, 
Ada.Strings.Right))
+               = "extend95" then
+               if Format_Object.Include_Annotations then
+                   Format_Object.Next_Paragraph_Format_Type := 
Ada95_Extensions;
+                   Format_Object.Next_Paragraph_Subhead_Type := 
Ada95_Extensions;
+               else -- Don't show annotations.
+                   Toss_for_RM ("extend95");
+               end if;
+           elsif Ada.Characters.Handling.To_Lower (Ada.Strings.Fixed.Trim (
+               
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Name, 
Ada.Strings.Right))
+               = "diffword95" then
+               if Format_Object.Include_Annotations then
+                   Format_Object.Next_Paragraph_Format_Type := Ada95_Wording;
+                   Format_Object.Next_Paragraph_Subhead_Type := Ada95_Wording;
+               else -- Don't show annotations.
+                   Toss_for_RM ("diffword95");
+               end if;
+           elsif Ada.Characters.Handling.To_Lower (Ada.Strings.Fixed.Trim (
+               
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Name, 
Ada.Strings.Right))
+               = "inconsistent2005" then
+               if Format_Object.Include_Annotations then
+                   Format_Object.Next_Paragraph_Format_Type := 
Ada2005_Inconsistencies;
+                   Format_Object.Next_Paragraph_Subhead_Type := 
Ada2005_Inconsistencies;
+               else -- Don't show annotations.
+                   Toss_for_RM ("inconsistent2005");
+               end if;
+           elsif Ada.Characters.Handling.To_Lower (Ada.Strings.Fixed.Trim (
+               
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Name, 
Ada.Strings.Right))
+               = "incompatible2005" then
+               if Format_Object.Include_Annotations then
+                   Format_Object.Next_Paragraph_Format_Type := 
Ada2005_Incompatibilities;
+                   Format_Object.Next_Paragraph_Subhead_Type := 
Ada2005_Incompatibilities;
+               else -- Don't show annotations.
+                   Toss_for_RM ("incompatible2005");
+               end if;
+           elsif Ada.Characters.Handling.To_Lower (Ada.Strings.Fixed.Trim (
+               
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Name, 
Ada.Strings.Right))
+               = "extend2005" then
+               if Format_Object.Include_Annotations then
+                   Format_Object.Next_Paragraph_Format_Type := 
Ada2005_Extensions;
+                   Format_Object.Next_Paragraph_Subhead_Type := 
Ada2005_Extensions;
+               else -- Don't show annotations.
+                   Toss_for_RM ("extend2005");
+               end if;
+           elsif Ada.Characters.Handling.To_Lower (Ada.Strings.Fixed.Trim (
+               
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Name, 
Ada.Strings.Right))
+               = "diffword2005" then
+               if Format_Object.Include_Annotations then
+                   Format_Object.Next_Paragraph_Format_Type := Ada2005_Wording;
+                   Format_Object.Next_Paragraph_Subhead_Type := 
Ada2005_Wording;
+               else -- Don't show annotations.
+                   Toss_for_RM ("diffword2005");
+               end if;
+           elsif Ada.Characters.Handling.To_Lower (Ada.Strings.Fixed.Trim (
+               
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Name, 
Ada.Strings.Right))
+               = "inconsistent2012" then
+               if Format_Object.Include_Annotations then
+                   Format_Object.Next_Paragraph_Format_Type := 
Ada2012_Inconsistencies;
+                   Format_Object.Next_Paragraph_Subhead_Type := 
Ada2012_Inconsistencies;
+               else -- Don't show annotations.
+                   Toss_for_RM ("inconsistent2012");
+               end if;
+           elsif Ada.Characters.Handling.To_Lower (Ada.Strings.Fixed.Trim (
+               
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Name, 
Ada.Strings.Right))
+               = "incompatible2012" then
+               if Format_Object.Include_Annotations then
+                   Format_Object.Next_Paragraph_Format_Type := 
Ada2012_Incompatibilities;
+                   Format_Object.Next_Paragraph_Subhead_Type := 
Ada2012_Incompatibilities;
+               else -- Don't show annotations.
+                   Toss_for_RM ("incompatible2012");
+               end if;
+           elsif Ada.Characters.Handling.To_Lower (Ada.Strings.Fixed.Trim (
+               
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Name, 
Ada.Strings.Right))
+               = "extend2012" then
+               if Format_Object.Include_Annotations then
+                   Format_Object.Next_Paragraph_Format_Type := 
Ada2012_Extensions;
+                   Format_Object.Next_Paragraph_Subhead_Type := 
Ada2012_Extensions;
+               else -- Don't show annotations.
+                   Toss_for_RM ("extend2012");
+               end if;
+           elsif Ada.Characters.Handling.To_Lower (Ada.Strings.Fixed.Trim (
+               
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Name, 
Ada.Strings.Right))
+               = "diffword2012" then
+               if Format_Object.Include_Annotations then
+                   Format_Object.Next_Paragraph_Format_Type := Ada2012_Wording;
+                   Format_Object.Next_Paragraph_Subhead_Type := 
Ada2012_Wording;
+               else -- Don't show annotations.
+                   Toss_for_RM ("diffword2012");
+               end if;
+           -- ASIS groupings:
+           elsif Ada.Characters.Handling.To_Lower (Ada.Strings.Fixed.Trim (
+               
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Name, 
Ada.Strings.Right))
+               = "elementref" then
+               if Format_Object.Include_Annotations then
+                   Format_Object.Next_Paragraph_Format_Type := Element_Ref;
+                   Format_Object.Next_Paragraph_Subhead_Type := Element_Ref;
+               else -- Don't show annotations.
+                   Toss_for_RM ("elementref");
+               end if;
+           elsif Ada.Characters.Handling.To_Lower (Ada.Strings.Fixed.Trim (
+               
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Name, 
Ada.Strings.Right))
+               = "childref" then
+               if Format_Object.Include_Annotations then
+                   Format_Object.Next_Paragraph_Format_Type := Child_Ref;
+                   Format_Object.Next_Paragraph_Subhead_Type := Child_Ref;
+               else -- Don't show annotations.
+                   Toss_for_RM ("childref");
+               end if;
+           elsif Ada.Characters.Handling.To_Lower (Ada.Strings.Fixed.Trim (
+               
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Name, 
Ada.Strings.Right))
+               = "usagenote" then
+               if Format_Object.Include_Annotations then
+                   Format_Object.Next_Paragraph_Format_Type := Usage_Note;
+                   Format_Object.Next_Paragraph_Subhead_Type := Usage_Note;
+               else -- Don't show annotations.
+                   Toss_for_RM ("usagenote");
+               end if;
+           -- AARM annotations:
+           elsif Ada.Characters.Handling.To_Lower (Ada.Strings.Fixed.Trim (
+               
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Name, 
Ada.Strings.Right))
+               = "discussion" then
+               if Format_Object.Include_Annotations then
+                   Format_Object.Next_Paragraph_Format_Type := Discussion;
+                   Format_Object.Next_Paragraph_Subhead_Type := Discussion;
+               else -- Don't show annotations.
+                   Toss_for_RM ("discussion");
+               end if;
+           elsif Ada.Characters.Handling.To_Lower (Ada.Strings.Fixed.Trim (
+               
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Name, 
Ada.Strings.Right))
+               = "reason" then
+               if Format_Object.Include_Annotations then
+                   Format_Object.Next_Paragraph_Format_Type := Reason;
+                   Format_Object.Next_Paragraph_Subhead_Type := Reason;
+               else -- Don't show annotations.
+                   Toss_for_RM ("reason");
+               end if;
+           elsif Ada.Characters.Handling.To_Lower (Ada.Strings.Fixed.Trim (
+               
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Name, 
Ada.Strings.Right))
+               = "ramification" then
+               if Format_Object.Include_Annotations then
+                   Format_Object.Next_Paragraph_Format_Type := Ramification;
+                   Format_Object.Next_Paragraph_Subhead_Type := Ramification;
+               else -- Don't show annotations.
+                   Toss_for_RM ("ramification");
+               end if;
+           elsif Ada.Characters.Handling.To_Lower (Ada.Strings.Fixed.Trim (
+               
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Name, 
Ada.Strings.Right))
+               = "theproof" then
+               if Format_Object.Include_Annotations then
+                   Format_Object.Next_Paragraph_Format_Type := Proof;
+                   Format_Object.Next_Paragraph_Subhead_Type := Proof;
+               else -- Don't show annotations.
+                   Toss_for_RM ("theproof");
+               end if;
+           elsif Ada.Characters.Handling.To_Lower (Ada.Strings.Fixed.Trim (
+               
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Name, 
Ada.Strings.Right))
+               = "implnote" then
+               if Format_Object.Include_Annotations then
+                   Format_Object.Next_Paragraph_Format_Type := Imp_Note;
+                   Format_Object.Next_Paragraph_Subhead_Type := Imp_Note;
+               else -- Don't show annotations.
+                   Toss_for_RM ("implnote");
+               end if;
+           elsif Ada.Characters.Handling.To_Lower (Ada.Strings.Fixed.Trim (
+               
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Name, 
Ada.Strings.Right))
+               = "honest" then
+               if Format_Object.Include_Annotations then
+                   Format_Object.Next_Paragraph_Format_Type := Honest;
+                   Format_Object.Next_Paragraph_Subhead_Type := Honest;
+               else -- Don't show annotations.
+                   Toss_for_RM ("honest");
+               end if;
+           elsif Ada.Characters.Handling.To_Lower (Ada.Strings.Fixed.Trim (
+               
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Name, 
Ada.Strings.Right))
+               = "glossarymarker" then
+               if Format_Object.Include_Annotations then
+                   Format_Object.Next_Paragraph_Format_Type := Glossary_Marker;
+                   Format_Object.Next_Paragraph_Subhead_Type := 
Glossary_Marker;
+               else -- Don't show annotations.
+                   Toss_for_RM ("glossarymarker");
+               end if;
+           elsif Ada.Characters.Handling.To_Lower (Ada.Strings.Fixed.Trim (
+               
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Name, 
Ada.Strings.Right))
+               = "aarmonly" then
+               if Format_Object.Include_Annotations then
+                   null; -- Leave the format alone.
+               else -- Don't show annotations.
+                   Toss_for_RM ("aarmonly");
+               end if;
+           else
+               Ada.Text_IO.Put_Line ("  -- Unknown 'begin' type - " &
+                   Ada.Strings.Fixed.Trim 
(Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Name, 
Ada.Strings.Right) &
+                   " on line " & ARM_Input.Line_String (Input_Object));
+           end if;
+       end Process_Begin;
+
+
+       procedure Process_Command_with_Parameter is
+           -- Process the start of a command with a parameter.
+           -- The parameter character has been processed, and
+           -- a stack item pushed.
+
+           function Get_NT return String is
+               -- Local routine:
+               -- Return the "current" non-terminal from
+               -- the Syntax_NT string. Handles @Chg.
+           begin
+               return Get_Current_Item (Format_Object, Input_Object,
+                   Format_Object.Syntax_NT (1 .. Format_Object.Syntax_NT_Len));
+           end Get_NT;
+
+
+           function Get_Old_NT return String is
+               -- Local routine:
+               -- Return the "current" non-terminal from
+               -- the Syntax_NT string. Handles @Chg.
+           begin
+               return Get_Old_Item (Format_Object, Input_Object,
+                   Format_Object.Syntax_NT (1 .. Format_Object.Syntax_NT_Len));
+           end Get_Old_NT;
+
+
+           procedure Get_Change_Version (Is_First : in Boolean;
+                                         Version : out Character) is
+               -- Get a parameter named "Version",
+               -- containing a character representing the version number.
+               Ch, Close_Ch : Character;
+           begin
+               ARM_Input.Check_Parameter_Name (Input_Object,
+                   Param_Name => "Version" & 
(8..ARM_Input.Command_Name_Type'Last => ' '),
+                   Is_First => Is_First,
+                   Param_Close_Bracket => Close_Ch);
+               if Close_Ch /= ' ' then
+                   -- Get the version character:
+                   ARM_Input.Get_Char (Input_Object, Version);
+                   ARM_Input.Get_Char (Input_Object, Ch);
+                   if Ch /= Close_Ch then
+                       Ada.Text_IO.Put_Line ("  ** Bad close for change 
version on line " & ARM_Input.Line_String (Input_Object));
+                       ARM_Input.Replace_Char (Input_Object);
+                   end if;
+               -- else no parameter. Weird.
+               end if;
+           end Get_Change_Version;
+
+
+           procedure Get_Change_Kind (Kind : out 
ARM_Database.Paragraph_Change_Kind_Type) is
+               -- Get a parameter named "Kind", containing a word representing
+               -- a change kind.
+               Kind_Name : ARM_Input.Command_Name_Type;
+               Ch, Close_Ch : Character;
+           begin
+               ARM_Input.Check_Parameter_Name (Input_Object,
+                   Param_Name => "Kind" & (5..ARM_Input.Command_Name_Type'Last 
=> ' '),
+                   Is_First => False,
+                   Param_Close_Bracket => Close_Ch);
+               if Close_Ch /= ' ' then
+                   -- Get the kind word:
+                   Arm_Input.Get_Name (Input_Object, Kind_Name);
+                   ARM_Input.Get_Char (Input_Object, Ch);
+                   if Ch /= Close_Ch then
+                       Ada.Text_IO.Put_Line ("  ** Bad close for change kind 
on line " & ARM_Input.Line_String (Input_Object));
+                       ARM_Input.Replace_Char (Input_Object);
+                   end if;
+                   if Ada.Characters.Handling.To_Lower (Ada.Strings.Fixed.Trim 
(Kind_Name, Ada.Strings.Right)) =
+                       "revised" then
+                       Kind := ARM_Database.Revised;
+                   elsif Ada.Characters.Handling.To_Lower 
(Ada.Strings.Fixed.Trim (Kind_Name, Ada.Strings.Right)) =
+                       "revisedadded" then
+                       Kind := ARM_Database.Revised_Inserted_Number;
+                   elsif Ada.Characters.Handling.To_Lower 
(Ada.Strings.Fixed.Trim (Kind_Name, Ada.Strings.Right)) =
+                       "added" then
+                       Kind := ARM_Database.Inserted;
+                   elsif Ada.Characters.Handling.To_Lower 
(Ada.Strings.Fixed.Trim (Kind_Name, Ada.Strings.Right)) =
+                       "addednormal" then
+                       Kind := ARM_Database.Inserted_Normal_Number;
+                   elsif Ada.Characters.Handling.To_Lower 
(Ada.Strings.Fixed.Trim (Kind_Name, Ada.Strings.Right)) =
+                       "deleted" then
+                       Kind := ARM_Database.Deleted;
+                   elsif Ada.Characters.Handling.To_Lower 
(Ada.Strings.Fixed.Trim (Kind_Name, Ada.Strings.Right)) =
+                       "deletedadded" then
+                       Kind := ARM_Database.Deleted_Inserted_Number;
+                   elsif Ada.Characters.Handling.To_Lower 
(Ada.Strings.Fixed.Trim (Kind_Name, Ada.Strings.Right)) =
+                       "deletednodelmsg" then
+                       Kind := ARM_Database.Deleted_No_Delete_Message;
+                   elsif Ada.Characters.Handling.To_Lower 
(Ada.Strings.Fixed.Trim (Kind_Name, Ada.Strings.Right)) =
+                       "deletedaddednodelmsg" then
+                       Kind := 
ARM_Database.Deleted_Inserted_Number_No_Delete_Message;
+                   else
+                       Ada.Text_IO.Put_Line ("  ** Bad kind for change kind: " 
&
+                               Ada.Strings.Fixed.Trim (Kind_Name, 
Ada.Strings.Right) &
+                               " on line " & ARM_Input.Line_String 
(Input_Object));
+                   end if;
+               -- else no parameter. Weird.
+               end if;
+           end Get_Change_Kind;
+
+
+           procedure Get_Boolean (Param_Name : in ARM_Input.Command_Name_Type;
+                                  Result : out Boolean) is
+               -- Get a boolean value from a parameter named Param_Name.
+               Ch, Close_Ch : Character;
+           begin
+               ARM_Input.Check_Parameter_Name (Input_Object,
+                   Param_Name => Param_Name,
+                   Is_First => False,
+                   Param_Close_Bracket => Close_Ch);
+               if Close_Ch /= ' ' then
+                   -- Get the Boolean character:
+                   ARM_Input.Get_Char (Input_Object, Ch);
+                   case Ch is
+                       when 'F' | 'f' | 'N' | 'n' =>
+                           Result := False;
+                       when 'T' | 't' | 'Y' | 'y' =>
+                           Result := True;
+                       when others =>
+                           Ada.Text_IO.Put_Line ("  ** Bad value for boolean 
parameter " &
+                               Ada.Strings.Fixed.Trim (Param_Name, 
Ada.Strings.Right) &
+                               " on line " & ARM_Input.Line_String 
(Input_Object));
+                   end case;
+                   ARM_Input.Get_Char (Input_Object, Ch);
+                   if Ch /= Close_Ch then
+                       Ada.Text_IO.Put_Line ("  ** Bad close for boolean 
parameter " &
+                           Ada.Strings.Fixed.Trim (Param_Name, 
Ada.Strings.Right) &
+                           " on line " & ARM_Input.Line_String (Input_Object));
+                       ARM_Input.Replace_Char (Input_Object);
+                   end if;
+               -- else no parameter. Weird.
+               end if;
+           end Get_Boolean;
+
+
+           procedure Gen_Ref_or_ARef_Parameter (Display_It : Boolean) is
+               -- Generate (and read) a "Ref" or "ARef" parameter, containing
+               -- a DR or AI reference. Generate it into the document only
+               -- if Display_It is True.
+               Ch, Close_Ch : Character;
+               Ref_Name : ARM_Input.Command_Name_Type;
+               Len : Natural;
+               Which_Param : ARM_Input.Param_Num;
+               New_Ref, Cursor : Reference_Ptr;
+           begin
+               ARM_Input.Check_One_of_Parameter_Names (Input_Object,
+                   Param_Name_1 => "Ref" & 
(4..ARM_Input.Command_Name_Type'Last => ' '),
+                   Param_Name_2 => "ARef" & 
(5..ARM_Input.Command_Name_Type'Last => ' '),
+                   Is_First => False,
+                   Param_Found => Which_Param,
+                   Param_Close_Bracket => Close_Ch);
+               if Close_Ch /= ' ' then
+                   -- Get the reference:
+                   Len := 0;
+                   loop
+                       ARM_Input.Get_Char (Input_Object, Ch);
+                       if Ch /= Close_Ch then
+                           Len := Len + 1;
+                           if Len > Ref_Name'Last then
+                               Ada.Text_IO.Put_Line ("  ** Reference too long 
on line " & ARM_Input.Line_String (Input_Object));
+                           else
+                               Ref_Name(Len) := Ch;
+                           end if;
+                       else -- End of the reference.
+                           if Len = 0 then
+                               Ada.Text_IO.Put_Line ("  ** Failed to find 
reference on line " & ARM_Input.Line_String (Input_Object));
+                           end if;
+                           exit;
+                       end if;
+                   end loop;
+
+                   if Display_It then
+                       -- Save a reference for outputting on the next
+                       -- paragraph start.
+                       New_Ref := Allocate_Reference;
+                       New_Ref.all := (Ref_Name => Ref_Name,
+                                       Ref_Len => Len,
+                                       Is_DR_Ref => (Which_Param = 1),
+                                          -- DR reference if Param = 1;
+                                          -- AI reference otherwise.
+                                       Next => null);
+                       -- Attach this to the *end* of the list.
+                       if Format_Object.References = null then
+                           Format_Object.References := New_Ref;
+                       else
+                           Cursor := Format_Object.References;
+                           while Cursor.Next /= null loop
+                               Cursor := Cursor.next;
+                           end loop;
+                           Cursor.Next := New_Ref;
+                       end if;
+                   -- else don't display it.
+                   end if;
+               -- else no parameter. Weird.
+               end if;
+           end Gen_Ref_or_ARef_Parameter;
+
+
+           procedure Gen_Chg_xxxx (Param_Cmd   : in Data.Command_Type;
+                                   AARM_Prefix : in String) is
+               -- Implement chgimpdef, chgimpladv, chgdocreq, and
+               -- chgaspectdesc commands.
+               -- The AARM prefix (if needed) is AARM_Prefix, and
+               -- the parameter command is Param_Cmd.
+
+               -- This command is of the form:
+               -- @chgxxxxx{Version=[<version>], Kind=(<kind>),
+               --   Text=(<text>)}}
+               -- where <version> is a single character, <Kind> is one
+               -- of Revised, Added, or Deleted, and this is followed
+               -- by the text. As usual, any of the
+               -- allowed bracketing characters can be used.
+               Close_Ch     : Character;
+               Kind         : ARM_Database.Paragraph_Change_Kind_Type;
+               Version      : ARM_Contents.Change_Version_Type;
+               Display_It   : Boolean;
+               use type ARM_Database.Paragraph_Change_Kind_Type;
+               Local_Change : ARM_Output.Change_Type;
+               Skip_Header  : Boolean := False;
+           begin
+               Get_Change_Version (Is_First => True,
+                   Version => Version);
+                   -- Read a parameter named "Version".
+
+               Get_Change_Kind (Kind);
+                   -- Read a parameter named "Kind".
+
+               if Format_Object.Impdef_Info.Command /= None then
+                   Ada.Text_IO.Put_Line ("  ** Nested impdef entry on line " & 
ARM_Input.Line_String (Input_Object));
+               -- else OK.
+               end if;
+               -- Setup impdef information for this command:
+               case Param_Cmd is
+                   when Change_Impdef_Text_Param =>
+                       Format_Object.Impdef_Info :=
+                           (Command     => Impdef,
+                            Change_Kind => <>,      -- Set below.
+                            Version     => <>,      -- Set below.
+                            Initial_Version =>
+                                         Version,   -- Until we decide 
differently.
+                            Add_to_DB   => True,    -- Until we decide 
differently.
+                            Paragraph_String => <>, -- Set below.
+                            Paragraph_Len    => <>);-- Set below.
+                   when Change_Docreq_Text_Param =>
+                       Format_Object.Impdef_Info :=
+                           (Command     => Docreq,
+                            Change_Kind => <>,      -- Set below.
+                            Version     => <>,      -- Set below.
+                            Initial_Version =>
+                                         Version,   -- Until we decide 
differently.
+                            Add_to_DB   => True,    -- Until we decide 
differently.
+                            Paragraph_String => <>, -- Set below.
+                            Paragraph_Len    => <>);-- Set below.
+                   when Change_Impladv_Text_Param =>
+                       Format_Object.Impdef_Info :=
+                           (Command     => Impladv,
+                            Change_Kind => <>,      -- Set below.
+                            Version     => <>,      -- Set below.
+                            Initial_Version =>
+                                         Version,   -- Until we decide 
differently.
+                            Add_to_DB   => True,    -- Until we decide 
differently.
+                            Paragraph_String => <>, -- Set below.
+                            Paragraph_Len    => <>);-- Set below.
+                   when Change_AspectDesc_Text_Param =>
+                       Format_Object.Impdef_Info :=
+                           (Command     => Aspect,
+                            Change_Kind => <>,      -- Set below.
+                            Version     => <>,      -- Set below.
+                            Initial_Version =>
+                                         Version,   -- Until we decide 
differently.
+                            Add_to_DB   => True,    -- Until we decide 
differently.
+                            Aspect_Name => <>,      -- Set below.
+                            Aspect_Name_Len  => <>, -- Set below.
+                            Paragraph_String => <>, -- Set below.
+                            Paragraph_Len    => <>);-- Set below.
+                   when others =>
+                       raise Program_Error; -- Wrong kind of command passed in.
+               end case;
+               -- Check for the optional "InitialVersion" parameter,
+               -- and the not optional, but only used for some commands
+               -- "Aspect" parameter, stopping when we reach Text:
+
+               -- Note: If there is no InitialVersion command, use the same
+               -- version of the rest of the command (which was set when the
+               -- Info was created).
+               declare
+                   Which_Param : ARM_Input.Param_Num;
+                   Ch          : Character;
+                   Saw_Aspect  : Boolean := False;
+               begin
+                   loop
+                       ARM_Input.Check_One_of_Parameter_Names (Input_Object,
+                           Param_Name_1 => "InitialVersion" & 
(15..ARM_Input.Command_Name_Type'Last => ' '),
+                           Param_Name_2 => "Aspect" & 
(7..ARM_Input.Command_Name_Type'Last => ' '),
+                           Param_Name_3 => "Text" & 
(5..ARM_Input.Command_Name_Type'Last => ' '),
+                           Is_First => False,
+                           Param_Found => Which_Param,
+                           Param_Close_Bracket => Close_Ch);
+
+                       if Which_Param = 1 and then Close_Ch /= ' ' then
+                           -- Found InitialVersion
+                           ARM_Input.Get_Char (Input_Object, Ch);
+                           Format_Object.Impdef_Info.Initial_Version := Ch;
+                           ARM_Input.Get_Char (Input_Object, Ch);
+                           if Ch /= Close_Ch then
+                               Ada.Text_IO.Put_Line ("  ** Bad close for 
InitialVersion parameter on line " &
+                                   ARM_Input.Line_String (Input_Object));
+                               ARM_Input.Replace_Char (Input_Object);
+                           end if;
+                       elsif Which_Param = 2 and then Close_Ch /= ' ' then
+                           -- Found Aspect parameter.
+                           Saw_Aspect := True;
+
+                           -- Save name:
+                           ARM_Input.Copy_to_String_until_Close_Char (
+                               Input_Object,
+                               Close_Ch,
+                               Format_Object.Impdef_Info.Aspect_Name,
+                               Format_Object.Impdef_Info.Aspect_Name_Len);
+
+                       else -- We found "Text" (or an error)
+                           exit; -- Handling of Text is below.
+                       end if;
+                   end loop;
+                   if Format_Object.Impdef_Info.Command = Aspect then
+                       if not Saw_Aspect then
+                           Ada.Text_IO.Put_Line ("  ** Missing Aspect 
parameter on line " &
+                               ARM_Input.Line_String (Input_Object));
+                       -- else OK.
+                       end if;
+                   else -- Not aspect.
+                       if Saw_Aspect then
+                           Ada.Text_IO.Put_Line ("  ** Aspect parameter on 
non-aspect command on line " &
+                               ARM_Input.Line_String (Input_Object));
+                       -- else OK.
+                       end if;
+                   end if;
+               end;
+
+--Ada.Text_IO.Put_Line ("Gen_Chg_xxxx, Kind=" &
+--ARM_Database.Paragraph_Change_Kind_Type'Image(Kind) &
+--"; version=" & Version & "; InitVer=" & 
Format_Object.Impdef_Initial_Version);
+
+               if (Kind = ARM_Database.Inserted or else
+                   Kind = ARM_Database.Inserted_Normal_Number) then
+                   Calc_Change_Disposition
+                       (Format_Object => Format_Object,
+                        Version => Version,
+                        Operation => ARM_Output.Insertion,
+                        Text_Kind => Local_Change);
+--Ada.Text_IO.Put_Line ("  Insert, Local_Change=" &
+--ARM_Output.Change_Type'Image(Local_Change));
+                   case Local_Change is
+                       when Do_Not_Display_Text =>
+                           Display_It := False;
+                           Local_Change := ARM_Output.None;
+                           Format_Object.Impdef_Info.Add_to_DB := False;
+                               -- Do not add to the database, or display 
anything.
+                       when ARM_Output.None|ARM_Output.Insertion =>
+                           Format_Object.Impdef_Info.Version := Version;
+                           Format_Object.Impdef_Info.Change_Kind := Kind;
+                           Display_It := Format_Object.Include_Annotations;
+                               -- Show impdef notes only if we're showing 
annotations.
+                       when ARM_Output.Deletion =>
+                           raise Program_Error;
+                   end case;
+               elsif Kind = ARM_Database.Deleted or else
+                     Kind = ARM_Database.Deleted_Inserted_Number or else
+                     Kind = ARM_Database.Deleted_No_Delete_Message or else
+                     Kind = 
ARM_Database.Deleted_Inserted_Number_No_Delete_Message then
+                   Calc_Change_Disposition
+                       (Format_Object => Format_Object,
+                        Version => Version,
+                        Operation => ARM_Output.Deletion,
+                        Text_Kind => Local_Change);
+--Ada.Text_IO.Put_Line ("  Delete, Local_Change=" &
+--ARM_Output.Change_Type'Image(Local_Change));
+                   case Local_Change is
+                       when Do_Not_Display_Text =>
+                           --Display_It := False;
+                           -- We need to show the paragraph, without its 
header,
+                           -- so that we get a proper "this paragraph is 
deleted"
+                           -- message (if one is needed). Nothing will actually
+                           -- be output in this case.
+                           Local_Change := ARM_Output.None;
+                           Skip_Header := True;
+                           Format_Object.Impdef_Info.Version := Version;
+                           Format_Object.Impdef_Info.Change_Kind := Kind;
+                           Display_It := Format_Object.Include_Annotations;
+                               -- Show impdef notes only if we're showing 
annotations.
+                           Format_Object.Impdef_Info.Add_to_DB := True;
+                               -- This will add deleted text to the database,
+                               -- but there isn't a sensible alternative 
option,
+                               -- as we need to have the deleted paragraph 
numbers.
+                       when ARM_Output.None | ARM_Output.Deletion =>
+                           Format_Object.Impdef_Info.Version := Version;
+                           Format_Object.Impdef_Info.Change_Kind := Kind;
+                           Display_It := Format_Object.Include_Annotations;
+                               -- Show impdef notes only if we're showing 
annotations.
+                           Skip_Header := False;
+                       when ARM_Output.Insertion =>
+                           raise Program_Error;
+                   end case;
+               else -- we always display it.
+--Ada.Text_IO.Put_Line ("  Other");
+                   Format_Object.Impdef_Info.Version := Version;
+                   Format_Object.Impdef_Info.Change_Kind := Kind;
+                   Display_It := Format_Object.Include_Annotations;
+                       -- Show impdef notes only if we're showing annotations.
+                   Local_Change := ARM_Output.None;
+               end if;
+--Ada.Text_IO.Put_Line ("  Display_It=" & Boolean'Image(Display_It));
+
+               -- "Text" parameter name consumed above.
+               if Close_Ch /= ' ' then
+                   -- Stack it so we can process the end:
+                   Set_Nesting_for_Parameter
+                       (Command => Param_Cmd,
+                        Close_Ch => Close_Ch);
+
+                   ARM_Input.Start_Recording (Input_Object);
+
+                   if Format_Object.In_Paragraph then
+                       -- Do this to preserve any inserted paragraph info.
+                       Format_Object.Impdef_Info.Paragraph_String :=
+                           Format_Object.Current_Paragraph_String;
+                       Format_Object.Impdef_Info.Paragraph_Len :=
+                           Format_Object.Current_Paragraph_Len;
+                   else
+                       declare
+                           PNum : constant String := Positive'Image (
+                               Format_Object.Next_Paragraph - 1);
+                       begin
+                           Format_Object.Impdef_Info.Paragraph_Len := 
PNum'Length - 1;
+                           Format_Object.Impdef_Info.Paragraph_String (1 .. 
PNum'Last-1) :=
+                               PNum (2 .. PNum'Last);
+                       end;
+                   end if;
+
+                   if Display_It then
+                       Check_End_Paragraph; -- End any paragraph that we're in.
+                       
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Old_Last_Subhead_Paragraph
 := Format_Object.Last_Paragraph_Subhead_Type;
+                       
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Old_Next_Subhead_Paragraph
 := Format_Object.Next_Paragraph_Subhead_Type;
+                       
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Old_Next_Paragraph_Format
 := Format_Object.Next_Paragraph_Format_Type;
+                       
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Old_Tab_Stops := 
Format_Object.Paragraph_Tab_Stops;
+                       Format_Object.Next_Paragraph_Format_Type := 
Bare_Annotation;
+                       Format_Object.Next_Paragraph_Subhead_Type := 
Bare_Annotation;
+                       Format_Object.Next_Paragraph_Version := 
Format_Object.Impdef_Info.Version;
+                       Format_Object.Next_Paragraph_Change_Kind := 
Format_Object.Impdef_Info.Change_Kind;
+                       Format_Object.Paragraph_Tab_Stops := ARM_Output.NO_TABS;
+                       Check_Paragraph;
+
+                       if not Skip_Header then
+                           declare
+                               Local_Format : ARM_Output.Format_Type :=
+                                   Format_Object.Text_Format;
+                           begin
+                               Local_Format.Bold := True;
+                               Local_Format.Version := 
Format_Object.Impdef_Info.Version;
+                               if ARM_Output."/=" (Local_Change, 
ARM_Output.None) then
+                                   Local_Format.Change := Local_Change;
+                                   ARM_Output.Text_Format (Output_Object,
+                                                           Local_Format);
+                               else -- No change from us:
+                                   ARM_Output.Text_Format (Output_Object,
+                                                           Local_Format);
+                               end if;
+                               ARM_Output.Ordinary_Text (Output_Object,
+                                    Text => AARM_Prefix);
+                               Local_Format.Bold := 
Format_Object.Text_Format.Bold;
+                               Local_Format.Change := 
Format_Object.Text_Format.Change;
+                               ARM_Output.Text_Format (Output_Object,
+                                                       Local_Format);
+                           end;
+                       -- else skip the header, do nothing.
+                       end if;
+                       Format_Object.Last_Paragraph_Subhead_Type := 
Bare_Annotation;
+                       Format_Object.Last_Non_Space := False;
+
+                       if Format_Object.Impdef_Info.Command = Aspect then
+                           -- Output the aspect name:
+                           declare
+                               Local_Format : ARM_Output.Format_Type :=
+                                   Format_Object.Text_Format;
+                           begin
+                               Local_Format.Bold := True;
+                               Local_Format.Version := 
Format_Object.Impdef_Info.Version;
+                               if ARM_Output."/=" (Local_Change, 
ARM_Output.None) then
+                                   Local_Format.Change := Local_Change;
+                                   ARM_Output.Text_Format (Output_Object,
+                                                           Local_Format);
+                               else -- No change from us:
+                                   ARM_Output.Text_Format (Output_Object,
+                                                           Local_Format);
+                               end if;
+                               ARM_Output.Ordinary_Text (Output_Object,
+                                    Text => 
Format_Object.Impdef_Info.Aspect_Name(1..Format_Object.Impdef_Info.Aspect_Name_Len));
+                               ARM_Output.Ordinary_Text (Output_Object,
+                                    Text => ": ");
+                               Local_Format.Bold := 
Format_Object.Text_Format.Bold;
+                               Local_Format.Change := 
Format_Object.Text_Format.Change;
+                               ARM_Output.Text_Format (Output_Object,
+                                                       Local_Format);
+                           end;
+                       -- else no additional text.
+                       end if;
+                   else -- Don't display, skip the text:
+                       ARM_Input.Skip_until_Close_Char (Input_Object,
+                           Close_Ch);
+                       ARM_Input.Replace_Char (Input_Object); -- Let the 
normal termination clean this up.
+                   end if;
+
+               -- else no parameter. Weird.
+               end if;
+           end Gen_Chg_xxxx;
+
+
+           procedure Get_Syntax_Parameters (Has_Version : in Boolean;
+                                            RHS_Close_Ch : out Character) is
+               -- Get the parameters for a Syn, AddedSyn, or DeletedSyn
+               -- command. The command has a version parameter (it's not @Syn)
+               -- if Has_Version is True. The results are put into the usual
+               -- places. The RHS parameter's name is evaluated, and its
+               -- closing character is RHS_Close_Ch.
+               -- @Syn{[Tabs=<Tabset>, ]LHS=<Non-terminal>, RHS=<Production>}
+               -- @AddedSyn{Version=[Version],[Tabs=<Tabset>, 
]LHS=<Non-terminal>, RHS=<Production>}
+               -- @DeletedSyn{Version=[Version],[Tabs=<Tabset>, 
]LHS=<Non-terminal>, RHS=<Production>}
+               Close_Ch, Ch : Character;
+               Was_Tabs : Boolean := False;
+           begin
+               if Has_Version then
+                   Get_Change_Version (Is_First => True,
+                                       Version =>
+                                          
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Change_Version);
+               end if;
+
+               -- Peek to see if Tabs parmeter is present:
+               ARM_Input.Get_Char (Input_Object, Ch);
+               ARM_Input.Replace_Char (Input_Object);
+               if Ch = 'T' or else Ch = 't' then
+                   Was_Tabs := True;
+                   ARM_Input.Check_Parameter_Name (Input_Object,
+                       Param_Name => "Tabs" & 
(5..ARM_Input.Command_Name_Type'Last => ' '),
+                       Is_First => (not Has_Version),
+                       Param_Close_Bracket => Close_Ch);
+                   if Close_Ch /= ' ' then
+                       -- Grab the tab string:
+                       ARM_Input.Copy_to_String_until_Close_Char (
+                           Input_Object,
+                           Close_Ch,
+                           Format_Object.Syntax_Tab,
+                           Format_Object.Syntax_Tab_Len);
+                   -- else no parameter. Weird.
+                   end if;
+               else
+                   Format_Object.Syntax_Tab_Len := 0;
+               end if;
+
+               ARM_Input.Check_Parameter_Name (Input_Object,
+                   Param_Name => "LHS" & (4..ARM_Input.Command_Name_Type'Last 
=> ' '),
+                   Is_First => (not Was_Tabs) and (not Has_Version),
+                   Param_Close_Bracket => Close_Ch);
+               if Close_Ch /= ' ' then
+                   -- Copy over the non-terminal:
+                   ARM_Input.Copy_to_String_until_Close_Char (
+                       Input_Object,
+                       Close_Ch,
+                       Format_Object.Syntax_NT,
+                       Format_Object.Syntax_NT_Len);
+               -- else no parameter. Weird.
+               end if;
+
+               ARM_Input.Check_Parameter_Name (Input_Object,
+                   Param_Name => "RHS" & (4..ARM_Input.Command_Name_Type'Last 
=> ' '),
+                   Is_First => False,
+                   Param_Close_Bracket => RHS_Close_Ch);
+           end Get_Syntax_Parameters;
+
+
+           procedure Gen_Syntax_Rule (Disposition : in ARM_Output.Change_Type;
+                                      RHS_Close_Ch : in Character) is
+               -- Generate a syntax rule with the specified disposition
+               -- for explicitly generated text. All of the parameters have 
been
+               -- read in; the close character for the RHS parameter is
+               -- RHS_Close_Ch.
+               use type ARM_Output.Change_Type;
+               Org_Tabs : ARM_Output.Tab_Info;
+               Key : ARM_Index.Index_Key;
+           begin
+               if Disposition = Do_Not_Display_Text then
+                   if RHS_Close_Ch /= ' ' then
+                       -- Skip the RHS and put nothing in the DB.
+                       ARM_Input.Skip_until_Close_Char (Input_Object, 
RHS_Close_Ch);
+                       ARM_Input.Replace_Char (Input_Object); -- Let the 
normal termination clean this up.
+                       if ARM_Database."=" 
(Format_Object.Next_Paragraph_Change_Kind,
+                          ARM_Database.Deleted) or else
+                          ARM_Database."=" 
(Format_Object.Next_Paragraph_Change_Kind,
+                          ARM_Database.Deleted_Inserted_Number) or else
+                          ARM_Database."=" 
(Format_Object.Next_Paragraph_Change_Kind,
+                          ARM_Database.Deleted_No_Delete_Message) or else
+                          ARM_Database."=" 
(Format_Object.Next_Paragraph_Change_Kind,
+                          
ARM_Database.Deleted_Inserted_Number_No_Delete_Message) then
+                           -- In a deleted paragraph, call Check_Paragraph
+                           -- to trigger the "deleted paragraph" message.
+                           -- (Otherwise, this may never happen.)
+                           Check_Paragraph;
+                       -- else null; -- Nothing special to do.
+                       end if;
+                   end if;
+                   -- Stack it so we can process the end:
+                   Set_Nesting_for_Parameter
+                       (Command => Syntax_Rule_RHS,
+                        Close_Ch => RHS_Close_Ch);
+                   -- (We probably don't need to do the above, but consistency
+                   -- is preferred.)
+               else
+                   -- Set up the tabs:
+                   Org_Tabs := Format_Object.Paragraph_Tab_Stops;
+                   Format_Object.Paragraph_Tab_Stops := ARM_Output.NO_TABS;
+                   if Format_Object.Syntax_Tab_Len /= 0 then
+                       Parse_Tab_Stops 
(Format_Object.Syntax_Tab(1..Format_Object.Syntax_Tab_Len),
+                           Format_Object.Paragraph_Tab_Stops);
+                   end if;
+
+                   Check_Paragraph;
+                   ARM_Format.Format (Format_Object,
+                                      "@s{" & 
Format_Object.Syntax_NT(1..Format_Object.Syntax_NT_Len) & "}",
+                                      Output_Object,
+                                      Text_Name => "@Syn(LHS=",
+                                      No_Annotations => False);
+                       -- We use Format here so we can support changes in
+                       -- the non-terminal.
+
+                   -- Index the non-terminal:
+                   ARM_Index.Add (Term => Get_NT,
+                                  Kind => ARM_Index.Primary_Term,
+                                  Clause => Clause_String (Format_Object),
+                                  Paragraph => Paragraph_String,
+                                  Key => Key);
+                   ARM_Output.Index_Target (Output_Object, Key);
+
+                   -- Make an anchor for the non-terminal:
+                   if Format_Object.Link_Non_Terminals then
+                       declare
+                           Lower_NT : constant String :=
+                               Ada.Characters.Handling.To_Lower (Get_NT);
+                           Link_Target : ARM_Syntax.Target_Type :=
+                               ARM_Syntax.Non_Terminal_Link_Target (Lower_NT);
+                           Lower_Old_NT : constant String :=
+                               Ada.Characters.Handling.To_Lower (Get_Old_NT);
+                           Old_Link_Target : ARM_Syntax.Target_Type :=
+                               ARM_Syntax.Non_Terminal_Link_Target 
(Lower_Old_NT);
+                       begin
+                           if Lower_NT /= "" then
+                               if Clause_String (Format_Object) /=
+                                   ARM_Syntax.Non_Terminal_Clause (Lower_NT) 
then
+                                   Ada.Text_IO.Put_Line ("  ** Clause mismatch 
for non-terminal: Is=" &
+                                       Clause_String (Format_Object) & "; 
Was=" & ARM_Syntax.Non_Terminal_Clause (Lower_NT) &
+                                       "; NT=" & Lower_NT & "; on line " & 
ARM_Input.Line_String (Input_Object));
+                               end if;
+                               ARM_Output.Local_Target (Output_Object,
+                                   Text => "",
+                                   Target => Link_Target);
+                           -- else the Non-Terminal was deleted, no
+                           -- anchor is needed.
+                           end if;
+                           if Lower_Old_NT /= "" then
+                               if Clause_String (Format_Object) /=
+                                   ARM_Syntax.Non_Terminal_Clause 
(Lower_Old_NT) then
+                                   -- This can happen if an item is inserted
+                                   -- on one place and deleted in another.
+                                   -- We'll assume this isn't an error and just
+                                   -- do nothing here.
+                                   --Ada.Text_IO.Put_Line ("  %% Clause 
mismatch for old non-terminal: Is=" &
+                                   --    Clause_String (Format_Object) & "; 
Was=" & ARM_Syntax.Non_Terminal_Clause (Lower_Old_NT) &
+                                   --    "; NT=" & Lower_Old_NT & "; on line " 
& ARM_Input.Line_String (Input_Object));
+                                   null;
+                               else
+                                   ARM_Output.Local_Target (Output_Object,
+                                       Text => "",
+                                       Target => Old_Link_Target);
+                               end if;
+                           -- else there was no old Non-Terminal.
+                           end if;
+                       end;
+                   end if;
+
+                   -- Set the font for the "::=". Note that we use @s{}
+                   -- above, so that any font changes in the Non-Terminal
+                   -- (as in a @Chg command) are respected.
+                   -- This command includes any needed insertion or deletion.
+
+                   declare
+                       Swiss_Format : ARM_Output.Format_Type :=
+                           Format_Object.Text_Format;
+                   begin
+                       Swiss_Format.Font := ARM_Output.Swiss;
+                       if Disposition = ARM_Output.None then
+                           null;
+                       else
+                           Swiss_Format.Change := Disposition;
+                           Swiss_Format.Version := 
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Change_Version;
+                       end if;
+                       ARM_Output.Text_Format (Output_Object,
+                                               Swiss_Format);
+                   end;
+                   ARM_Output.Ordinary_Text (Output_Object, " ::= ");
+                   ARM_Output.Text_Format (Output_Object,
+                                           Format_Object.Text_Format); -- 
Reset format.
+                   Format_Object.Last_Non_Space := False;
+
+                   if RHS_Close_Ch /= ' ' then
+                       -- Now, handle the parameter:
+                       -- Stack it so we can process the end:
+                       Set_Nesting_for_Parameter
+                           (Command => Syntax_Rule_RHS,
+                            Close_Ch => RHS_Close_Ch);
+
+                       ARM_Input.Start_Recording (Input_Object);
+
+                       -- Set the format to preserve line breaks.
+                       
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Old_Last_Subhead_Paragraph
 := Format_Object.Last_Paragraph_Subhead_Type;
+                       
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Old_Next_Subhead_Paragraph
 := Format_Object.Next_Paragraph_Subhead_Type;
+                       
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Old_Next_Paragraph_Format
 := Format_Object.Next_Paragraph_Format_Type;
+                       
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Old_Tab_Stops := 
Org_Tabs;
+                       Format_Object.Next_Paragraph_Format_Type := 
Syntax_Production;
+                       -- Tab stops are already set.
+                   -- else no parameter, weird.
+                   end if;
+               end if;
+           end Gen_Syntax_Rule;
+
+
+           procedure Format_Text (Text : in String;
+                                  Text_Name : in String) is
+               -- Note: We use the state of the surrounding call.
+               Input_Object : Arm_String.String_Input_Type;
+               Real_Include_Annotations : Boolean := 
Format_Object.Include_Annotations;
+           begin
+               -- Don't show annotations here:
+                Format_Object.Include_Annotations := False;
+               Arm_String.Open (Input_Object, Text, Text_Name);
+                    -- Open the input object using a string for input.
+               Real_Process (Format_Object, Format_State, Input_Object, 
Output_Object);
+               Arm_String.Close (Input_Object);
+               Format_Object.Include_Annotations := Real_Include_Annotations;
+           end Format_Text;
+
+           procedure DB_Report is new ARM_Database.Report (Format_Text);
+
+       begin
+           case 
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Command is
+
+               -- Basic text commands:
+
+               when Redundant =>
+                   if Format_Object.Include_Annotations then
+                       Check_Paragraph;
+                       ARM_Output.Ordinary_Character (Output_Object, '[');
+                       Format_Object.Last_Non_Space := True;
+                   -- else ignored.
+                   end if;
+
+               when Comment | Part =>
+                   -- Skip the contents of this command.
+                   -- For Part, we don't use the information contained,
+                   -- but it would help a human reader.
+                   ARM_Input.Skip_until_Close_Char (Input_Object,
+                       
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Close_Char);
+                   Format_State.Nesting_Stack_Ptr := 
Format_State.Nesting_Stack_Ptr - 1;
+                       -- Remove the "comment" or "part" record.
+
+               when Bold =>
+                   Check_Paragraph;
+                   Format_Object.Text_Format.Bold := True;
+                   ARM_Output.Text_Format (Output_Object,
+                                           Format => 
Format_Object.Text_Format);
+
+               when Italic =>
+                   Check_Paragraph;
+                   Format_Object.Text_Format.Italic := True;
+                   ARM_Output.Text_Format (Output_Object,
+                                           Format => 
Format_Object.Text_Format);
+
+               when Roman =>
+                   Check_Paragraph;
+                   Format_Object.Text_Format.Font := ARM_Output.Roman;
+                   ARM_Output.Text_Format (Output_Object,
+                                           Format => 
Format_Object.Text_Format);
+
+               when Swiss =>
+                   Check_Paragraph;
+                   Format_Object.Text_Format.Font := ARM_Output.Swiss;
+                   ARM_Output.Text_Format (Output_Object,
+                                           Format => 
Format_Object.Text_Format);
+
+               when Fixed =>
+                   Check_Paragraph;
+                   Format_Object.Text_Format.Font := ARM_Output.Fixed;
+                   ARM_Output.Text_Format (Output_Object,
+                                           Format => 
Format_Object.Text_Format);
+
+               when Roman_Italic =>
+                   Check_Paragraph;
+                   Format_Object.Text_Format.Italic := True;
+                   Format_Object.Text_Format.Font := ARM_Output.Roman;
+                   ARM_Output.Text_Format (Output_Object,
+                                           Format => 
Format_Object.Text_Format);
+               when Shrink =>
+                   declare
+                       use type ARM_Output.Size_Type;
+                   begin
+                       Check_Paragraph;
+                       Format_Object.Text_Format.Size :=
+                           Format_Object.Text_Format.Size - 1;
+                       ARM_Output.Text_Format (Output_Object,
+                                               Format => 
Format_Object.Text_Format);
+                   end;
+
+               when Grow =>
+                   declare
+                       use type ARM_Output.Size_Type;
+                   begin
+                       Check_Paragraph;
+                       Format_Object.Text_Format.Size :=
+                           Format_Object.Text_Format.Size + 1;
+                       ARM_Output.Text_Format (Output_Object,
+                                               Format => 
Format_Object.Text_Format);
+                   end;
+
+               when Black =>
+                   Check_Paragraph;
+                   Format_Object.Text_Format.Color := ARM_Output.Black;
+                   ARM_Output.Text_Format (Output_Object,
+                                           Format => 
Format_Object.Text_Format);
+
+               when Red =>
+                   Check_Paragraph;
+                   Format_Object.Text_Format.Color := ARM_Output.Red;
+                   ARM_Output.Text_Format (Output_Object,
+                                           Format => 
Format_Object.Text_Format);
+
+               when Green =>
+                   Check_Paragraph;
+                   Format_Object.Text_Format.Color := ARM_Output.Green;
+                   ARM_Output.Text_Format (Output_Object,
+                                           Format => 
Format_Object.Text_Format);
+
+               when Blue =>
+                   Check_Paragraph;
+                   Format_Object.Text_Format.Color := ARM_Output.Blue;
+                   ARM_Output.Text_Format (Output_Object,
+                                           Format => 
Format_Object.Text_Format);
+
+               when Keyword =>
+                   Check_Paragraph;
+                   Format_Object.Text_Format.Bold := True;
+                   ARM_Output.Text_Format (Output_Object,
+                                           Format => 
Format_Object.Text_Format);
+
+               when Non_Terminal_Format =>
+                   -- No linking here.
+                   Check_Paragraph;
+                   Format_Object.Text_Format.Font := ARM_Output.Swiss;
+                   ARM_Output.Text_Format (Output_Object,
+                                           Format => 
Format_Object.Text_Format);
+
+               when Example_Text =>
+                   Check_Paragraph;
+                   Format_Object.Text_Format.Font := 
Format_Object.Examples_Font;
+                   ARM_Output.Text_Format (Output_Object,
+                                           Format => 
Format_Object.Text_Format);
+
+               when Example_Comment =>
+                   Check_Paragraph;
+                   Format_Object.Text_Format.Font := ARM_Output.Roman;
+                   Format_Object.Text_Format.Italic := True;
+                   ARM_Output.Text_Format (Output_Object,
+                                           Format => 
Format_Object.Text_Format);
+
+               when Tab_Clear =>
+                   Format_Object.Paragraph_Tab_Stops := ARM_Output.NO_TABS;
+
+               when Tab_Set =>
+                   if Format_Object.Next_Paragraph_Format_Type = Bulleted or 
else
+                      Format_Object.Next_Paragraph_Format_Type = 
Nested_Bulleted or else
+                      Format_Object.Next_Paragraph_Format_Type = 
Nested_X2_Bulleted or else
+                      Format_Object.Next_Paragraph_Format_Type = Enumerated or 
else
+                      Format_Object.Next_Paragraph_Format_Type = 
Nested_Enumerated or else
+                      Format_Object.Next_Paragraph_Format_Type = 
Hanging_Indented_1 or else
+                      Format_Object.Next_Paragraph_Format_Type = 
Hanging_Indented_2 or else
+                      Format_Object.Next_Paragraph_Format_Type = 
Hanging_Indented_3 or else
+                      Format_Object.Next_Paragraph_Format_Type = 
Hanging_Indented_4 then
+                       Ada.Text_IO.Put_Line ("  ** Tab set in hang or bulleted 
format: " &
+                           
Paragraph_Type'Image(Format_Object.Next_Paragraph_Format_Type) &
+                           ", line " & ARM_Input.Line_String (Input_Object));
+                   elsif ARM_Output."/=" (Format_Object.Paragraph_Tab_Stops, 
ARM_Output.NO_TABS) then
+                       Ada.Text_IO.Put_Line ("  ** Setting tabs when they are 
not clear on line "
+                               & ARM_Input.Line_String (Input_Object));
+                   else
+                       declare
+                           My_Tabs : ARM_Output.Tab_Info := ARM_Output.NO_TABS;
+                           Stops : String(1..80);
+                           Len : Natural;
+                       begin
+                           ARM_Input.Copy_to_String_until_Close_Char (
+                               Input_Object,
+                               
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Close_Char,
+                               Stops, Len);
+                           Parse_Tab_Stops (Stops(1..Len), My_Tabs);
+
+                           Format_Object.Paragraph_Tab_Stops := My_Tabs;
+                           Format_State.Nesting_Stack_Ptr := 
Format_State.Nesting_Stack_Ptr - 1;
+--Ada.Text_IO.Put_Line (" &Unstack (Tabstop)");
+                       end;
+                   end if;
+
+               when Non_Terminal =>
+                   -- @nt{text}
+                   -- This *was* simple, until we added linking.
+                   declare
+                       Name : String(1..120);
+                       Len : Natural;
+                       Swiss_Format : ARM_Output.Format_Type :=
+                           Format_Object.Text_Format;
+                   begin
+                       ARM_Input.Copy_to_String_until_Close_Char (
+                           Input_Object,
+                           
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Close_Char,
+                           Name, Len);
+
+                       -- Set the appropriate style:
+                       Check_Paragraph;
+
+                       Swiss_Format.Font := ARM_Output.Swiss;
+                       ARM_Output.Text_Format (Output_Object,
+                                               Format => Swiss_Format);
+                       if Format_Object.Link_Non_Terminals then
+                           if Ada.Strings.Fixed.Index (Name(1..Len), "@") /= 0 
then
+                               -- Embedded commands. We have to clean the
+                               -- string of the commands (if we can) before
+                               -- making a link.
+                               declare
+                                   Lower_NT : String :=
+                                       Ada.Characters.Handling.To_Lower 
(Name(1..Len));
+                                   Lower_NT_Len : Natural := Lower_NT'Length;
+                                   Loc : Natural := Lower_NT'First;
+                               begin
+                                   while Loc <= Lower_NT_Len loop
+                                       -- Check for simple commands and remove 
them:
+                                       if Lower_NT(Loc) = '@' then -- Start of 
a command.
+                                           if Loc < Lower_NT_Len and then
+                                               (Lower_NT(Loc+1) = '!' or else
+                                                Lower_NT(Loc+1) = ';') then
+                                               -- Soft hyphen or no-op, remove.
+                                               Lower_NT(Loc .. Lower_NT_Len-2) 
:=
+                                                   Lower_NT(Loc+2 .. 
Lower_NT_Len);
+                                               Lower_NT_Len := Lower_NT_Len - 
2;
+                                           else -- Unknown.
+                                               exit;
+                                           end if;
+                                       else -- nothing to do, move to next 
character
+                                           Loc := Loc + 1;
+                                       end if;
+                                   end loop;
+
+                                   declare
+                                       Clause : constant String :=
+                                           ARM_Syntax.Non_Terminal_Clause 
(Lower_NT(1..Lower_NT_Len));
+                                       Target : constant 
ARM_Syntax.Target_Type :=
+                                           ARM_Syntax.Non_Terminal_Link_Target 
(Lower_NT(1..Lower_NT_Len));
+                                       Org_Font : ARM_Output.Font_Family_Type 
:=
+                                           Format_Object.Text_Format.Font;
+                                   begin
+                                       Format_Object.Text_Format.Font := 
ARM_Output.Swiss;
+                                       if Clause = "" then -- Not found. No 
link, but error message:
+                                           if Ada.Strings.Fixed.Index 
(Lower_NT(1..Lower_NT_Len), "@") /= 0 then
+                                               Ada.Text_IO.Put_Line ("  %% 
Non-terminal with complex embedded commands " &
+                                                   Lower_NT(1..Lower_NT_Len) & 
" on line " & ARM_Input.Line_String (Input_Object));
+                                           else
+                                               Ada.Text_IO.Put_Line ("  ?? 
Unknown non-terminal " &
+                                                   Lower_NT(1..Lower_NT_Len) & 
" on line " & ARM_Input.Line_String (Input_Object));
+                                           end if;
+                                           ARM_Format.Format (Format_Object,
+                                                              Name(1..Len),
+                                                              Output_Object,
+                                                              Text_Name => 
"@nt{}",
+                                                              No_Annotations 
=> False);
+                                       else
+                                           ARM_Output.Local_Link_Start 
(Output_Object,
+                                               Target => Target, Clause_Number 
=> Clause);
+                                           ARM_Format.Format (Format_Object,
+                                                              Name(1..Len),
+                                                              Output_Object,
+                                                              Text_Name => 
"@nt{}",
+                                                              No_Annotations 
=> False);
+                                           ARM_Output.Local_Link_End 
(Output_Object,
+                                               Target => Target, Clause_Number 
=> Clause);
+                                       end if;
+                                       Format_Object.Text_Format.Font := 
Org_Font;
+                                   end;
+                               end;
+                           else -- Ordinary link.
+                               declare
+                                   Lower_NT : constant String :=
+                                       Ada.Characters.Handling.To_Lower 
(Name(1..Len));
+                                   Clause : constant String :=
+                                       ARM_Syntax.Non_Terminal_Clause 
(Lower_NT);
+                                   Target : constant ARM_Syntax.Target_Type :=
+                                       ARM_Syntax.Non_Terminal_Link_Target 
(Lower_NT);
+                               begin
+                                   if Clause = "" then -- Not found. No link, 
but error message:
+                                       Ada.Text_IO.Put_Line ("  ?? Unknown 
non-terminal " &
+                                           Name(1..Len) & " on line " & 
ARM_Input.Line_String (Input_Object));
+                                       ARM_Output.Ordinary_Text 
(Output_Object, Name(1..Len));
+                                   else
+                                       ARM_Output.Local_Link (Output_Object, 
Text => Name(1..Len),
+                                           Target => Target, Clause_Number => 
Clause);
+                                   end if;
+                               end;
+                           end if;
+                       else
+                           if Ada.Strings.Fixed.Index (Name(1..Len), "@") /= 0 
then
+                               -- Embedded commands, better execute them.
+                               declare
+                                   Org_Font : ARM_Output.Font_Family_Type :=
+                                       Format_Object.Text_Format.Font;
+                               begin
+                                   Format_Object.Text_Format.Font := 
ARM_Output.Swiss;
+                                   ARM_Format.Format (Format_Object,
+                                                      Name(1..Len),
+                                                      Output_Object,
+                                                      Text_Name => "@nt{}",
+                                                      No_Annotations => False);
+                                   Format_Object.Text_Format.Font := Org_Font;
+                               end;
+                           else
+                               ARM_Output.Ordinary_Text (Output_Object, 
Name(1..Len));
+                           end if;
+                       end if;
+                       ARM_Output.Text_Format (Output_Object,
+                                               Format => 
Format_Object.Text_Format);
+                       Format_Object.Last_Non_Space := True;
+                   end;
+                   Format_State.Nesting_Stack_Ptr := 
Format_State.Nesting_Stack_Ptr - 1;
+--Ada.Text_IO.Put_Line (" &Unstack (Nonterminal)");
+
+               -- Versioned breaking:
+               when New_Page_for_Version | RM_New_Page_for_Version |
+                    New_Column_for_Version |
+                    Not_ISO_RM_New_Page_for_Version |
+                    ISO_Only_RM_New_Page_for_Version =>
+                   declare
+                       Version : ARM_Contents.Change_Version_Type;
+                   begin
+                       Get_Change_Version (Is_First => True,
+                           Version => Version);
+                           -- Read a parameter named "Version".
+                       
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Change_Version := 
Version;
+                   end;
+
+               -- Tables:
+               when Table =>
+                       -- @table(Columns=<number>,
+                       --       
Alignment=<AllLeft|AllCenter|CenterExceptFirst>,
+                       --       FirstColWidth=<number>,
+                       --       LastColWidth=<number>,
+                       --       NoBreak=<T|F>,
+                       --       Border=<T|F>,
+                       --       SmallSize=<T|F>,
+                       --       Caption=<text>,
+                       --       Headers=<text>,
+                       --       Body=<row_text>)
+                       -- Columns must be a single digit (2-9).
+                       -- Caption defines the table caption.
+                       -- Headers defines the table headers.
+                       -- Body defines the table body.
+
+                   Check_End_Paragraph; -- End any paragraph we're in.
+                   declare
+                       Close_Ch, Ch : Character;
+                       Align_Name : ARM_Input.Command_Name_Type;
+                       Cols, FirstWidth, LastWidth : Character;
+                       No_Page_Break : Boolean;
+                       Has_Border : Boolean;
+                       Small_Text : Boolean;
+                       Alignment : ARM_Output.Column_Text_Alignment;
+                   begin
+                       ARM_Input.Check_Parameter_Name (Input_Object,
+                           Param_Name => "Columns" & 
(8..ARM_Input.Command_Name_Type'Last => ' '),
+                           Is_First => True,
+                           Param_Close_Bracket => Close_Ch);
+                       if Close_Ch /= ' ' then
+                           ARM_Input.Get_Char (Input_Object, Cols);
+                           ARM_Input.Get_Char (Input_Object, Ch);
+                           if Ch /= Close_Ch then
+                               Ada.Text_IO.Put_Line ("  ** Bad close for Table 
Columns on line " & ARM_Input.Line_String (Input_Object));
+                               ARM_Input.Replace_Char (Input_Object);
+                           end if;
+                           if Cols not in '2'..'9' then
+                               Ada.Text_IO.Put_Line ("  ** Bad table column 
count on line " & ARM_Input.Line_String (Input_Object));
+                           end if;
+                       end if;
+
+                       ARM_Input.Check_Parameter_Name (Input_Object,
+                           Param_Name => "Alignment" & 
(10..ARM_Input.Command_Name_Type'Last => ' '),
+                           Is_First => False,
+                           Param_Close_Bracket => Close_Ch);
+                       if Close_Ch /= ' ' then
+                           -- Get the alignment word:
+                           Arm_Input.Get_Name (Input_Object, Align_Name);
+                           ARM_Input.Get_Char (Input_Object, Ch);
+                           if Ch /= Close_Ch then
+                               Ada.Text_IO.Put_Line ("  ** Bad close for Table 
Alignment on line " & ARM_Input.Line_String (Input_Object));
+                               ARM_Input.Replace_Char (Input_Object);
+                           end if;
+
+                           if Ada.Characters.Handling.To_Lower 
(Ada.Strings.Fixed.Trim (Align_Name, Ada.Strings.Right)) =
+                               "allleft" then
+                               Alignment := ARM_Output.Left_All;
+                           elsif Ada.Characters.Handling.To_Lower 
(Ada.Strings.Fixed.Trim (Align_Name, Ada.Strings.Right)) =
+                               "allcenter" then
+                               Alignment := ARM_Output.Center_All;
+                           elsif Ada.Characters.Handling.To_Lower 
(Ada.Strings.Fixed.Trim (Align_Name, Ada.Strings.Right)) =
+                               "centerexceptfirst" then
+                               Alignment := ARM_Output.Center_Except_First;
+                           else
+                               Ada.Text_IO.Put_Line ("  ** Bad column 
alignment: " &
+                                       Ada.Strings.Fixed.Trim (Align_Name, 
Ada.Strings.Right) &
+                                       " on line " & ARM_Input.Line_String 
(Input_Object));
+                           end if;
+                       -- else no parameter. Weird.
+                       end if;
+
+                       ARM_Input.Check_Parameter_Name (Input_Object,
+                           Param_Name => "FirstColWidth" & 
(14..ARM_Input.Command_Name_Type'Last => ' '),
+                           Is_First => False,
+                           Param_Close_Bracket => Close_Ch);
+                       if Close_Ch /= ' ' then
+                           ARM_Input.Get_Char (Input_Object, FirstWidth);
+                           ARM_Input.Get_Char (Input_Object, Ch);
+                           if Ch /= Close_Ch then
+                               Ada.Text_IO.Put_Line ("  ** Bad close for Table 
FirstColWidth on line " & ARM_Input.Line_String (Input_Object));
+                               ARM_Input.Replace_Char (Input_Object);
+                           end if;
+                           if FirstWidth not in '1'..'9' then
+                               Ada.Text_IO.Put_Line ("  ** Bad table 1st 
column width on line " & ARM_Input.Line_String (Input_Object));
+                           end if;
+                       end if;
+
+                       ARM_Input.Check_Parameter_Name (Input_Object,
+                           Param_Name => "LastColWidth" & 
(13..ARM_Input.Command_Name_Type'Last => ' '),
+                           Is_First => False,
+                           Param_Close_Bracket => Close_Ch);
+                       if Close_Ch /= ' ' then
+                           ARM_Input.Get_Char (Input_Object, LastWidth);
+                           ARM_Input.Get_Char (Input_Object, Ch);
+                           if Ch /= Close_Ch then
+                               Ada.Text_IO.Put_Line ("  ** Bad close for Table 
FirstColWidth on line " & ARM_Input.Line_String (Input_Object));
+                               ARM_Input.Replace_Char (Input_Object);
+                           end if;
+                           if FirstWidth not in '1'..'9' then
+                               Ada.Text_IO.Put_Line ("  ** Bad table last 
column width on line " & ARM_Input.Line_String (Input_Object));
+                           end if;
+                       end if;
+
+                       Get_Boolean ("NoBreak" & 
(8..ARM_Input.Command_Name_Type'Last => ' '), No_Page_Break);
+                       Get_Boolean ("Border" & 
(7..ARM_Input.Command_Name_Type'Last => ' '), Has_Border);
+                       Get_Boolean ("SmallSize" & 
(10..ARM_Input.Command_Name_Type'Last => ' '), Small_Text);
+
+                       -- Set to the table format:
+                       
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Old_Last_Subhead_Paragraph
 := Format_Object.Last_Paragraph_Subhead_Type;
+                       
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Old_Next_Subhead_Paragraph
 := Format_Object.Next_Paragraph_Subhead_Type;
+                       
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Old_Next_Paragraph_Format
 := Format_Object.Next_Paragraph_Format_Type;
+                       
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Old_Tab_Stops := 
Format_Object.Paragraph_Tab_Stops;
+                       Format_Object.Next_Paragraph_Format_Type := In_Table;
+                       Format_Object.In_Paragraph := True; -- A fake, but we 
cannot have any format.
+                       Format_Object.No_Start_Paragraph := False; -- For most 
purposes, being in a table is like being in a paragraph.
+
+                       -- OK, we've started the table. Now, get the caption:
+                       ARM_Input.Check_Parameter_Name (Input_Object,
+                           Param_Name => "Caption" & 
(8..ARM_Input.Command_Name_Type'Last => ' '),
+                           Is_First => False,
+                           Param_Close_Bracket => Close_Ch);
+                       if Close_Ch /= ' ' then
+                           -- Check if the parameter is empty:
+                           ARM_Input.Get_Char (Input_Object, Ch);
+                           if Ch /= Close_Ch then
+                               -- There is a caption:
+                               ARM_Input.Replace_Char (Input_Object);
+
+                               -- Create the table.
+                               Arm_Output.Start_Table (
+                                       Output_Object,
+                                       Columns => Character'Pos(Cols) - 
Character'Pos('0'),
+                                       First_Column_Width => 
Character'Pos(FirstWidth) - Character'Pos('0'),
+                                       Last_Column_Width => 
Character'Pos(LastWidth) - Character'Pos('0'),
+                                       Alignment => Alignment,
+                                       No_Page_Break => No_Page_Break,
+                                       Has_Border => Has_Border,
+                                       Small_Text_Size => Small_Text,
+                                       Header_Kind => 
ARM_Output.Both_Caption_and_Header);
+
+                               -- Now, handle the parameter:
+                               -- Stack it so we can process the end:
+                               Set_Nesting_for_Parameter
+                                   (Command => Table_Param_Caption,
+                                    Close_Ch => Close_Ch);
+
+                           else -- Empty Caption. Move on to the Headers
+                                -- command.
+                               ARM_Input.Check_Parameter_Name (Input_Object,
+                                   Param_Name => "Headers" & 
(8..ARM_Input.Command_Name_Type'Last => ' '),
+                                   Is_First => False,
+                                   Param_Close_Bracket => Close_Ch);
+
+                               if Close_Ch /= ' ' then
+                                   -- Check if the parameter is empty:
+                                   ARM_Input.Get_Char (Input_Object, Ch);
+                                   if Ch /= Close_Ch then
+                                       -- There is a header:
+                                       ARM_Input.Replace_Char (Input_Object);
+
+                                       -- Create the table.
+                                       Arm_Output.Start_Table (
+                                               Output_Object,
+                                               Columns => Character'Pos(Cols) 
- Character'Pos('0'),
+                                               First_Column_Width => 
Character'Pos(FirstWidth) - Character'Pos('0'),
+                                               Last_Column_Width => 
Character'Pos(LastWidth) - Character'Pos('0'),
+                                               Alignment => Alignment,
+                                               No_Page_Break => No_Page_Break,
+                                               Has_Border => Has_Border,
+                                               Small_Text_Size => Small_Text,
+                                               Header_Kind => 
ARM_Output.Header_Only);
+
+                                       -- Now, handle the parameter:
+                                       -- Stack it so we can process the end:
+                                       Set_Nesting_for_Parameter
+                                           (Command => Table_Param_Header,
+                                            Close_Ch => Close_Ch);
+
+                                   else -- Empty Headers, too. Move on to the
+                                        -- Body command.
+                                       ARM_Input.Check_Parameter_Name 
(Input_Object,
+                                           Param_Name => "Body" & 
(5..ARM_Input.Command_Name_Type'Last => ' '),
+                                           Is_First => False,
+                                           Param_Close_Bracket => Close_Ch);
+
+                                       if Close_Ch /= ' ' then
+                                           -- Create the table.
+                                           Arm_Output.Start_Table (
+                                                   Output_Object,
+                                                   Columns => 
Character'Pos(Cols) - Character'Pos('0'),
+                                                   First_Column_Width => 
Character'Pos(FirstWidth) - Character'Pos('0'),
+                                                   Last_Column_Width => 
Character'Pos(LastWidth) - Character'Pos('0'),
+                                                   Alignment => Alignment,
+                                                   No_Page_Break => 
No_Page_Break,
+                                                   Has_Border => Has_Border,
+                                                   Small_Text_Size => 
Small_Text,
+                                                   Header_Kind => 
ARM_Output.No_Headers);
+
+                                           -- Now, handle the parameter:
+                                           -- Stack it so we can process the 
end:
+                                           Set_Nesting_for_Parameter
+                                               (Command => Table_Param_Body,
+                                                Close_Ch => Close_Ch);
+
+                                       -- else no parameter, weird.
+                                       end if;
+
+                                   end if;
+
+                               -- else no parameter, weird.
+                               end if;
+
+                            end if;
+
+                       -- else no parameter, weird.
+                       end if;
+                   end;
+
+               -- Pictures:
+               when Picture_Alone | Picture_Inline =>
+                   -- @PictureInline(Alignment=<Inline|FloatLeft|FloatRight>,
+                   --               Border=<None|Thin|Thick>,
+                   --               Height=<nnn>,
+                   --               Width=<nnn>,
+                   --               Name=<name>,
+                   --               Descr=<descr>)
+                   -- @PictureAlone(Alignment=<Left|Right|Center>,
+                   --               Border=<None|Thin|Thick>,
+                   --               Height=<nnn>,
+                   --               Width=<nnn>,
+                   --               Name=<name>,
+                   --               Descr=<descr>)
+                   declare
+                       Close_Ch, Ch : Character;
+                       Align_Name : ARM_Input.Command_Name_Type;
+                       Alignment : ARM_Output.Picture_Alignment;
+                       Border : ARM_Output.Border_Kind;
+                       Height : Natural := 0;
+                       Width : Natural := 0;
+                       Name, Descr : String(1..120);
+                       NLen, DLen : Natural := 0;
+                   begin
+                       if 
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Command =
+                           Picture_Alone then
+                           Check_End_Paragraph; -- End any paragraph that 
we're in.
+
+                           ARM_Input.Check_Parameter_Name (Input_Object,
+                               Param_Name => "Alignment" & 
(10..ARM_Input.Command_Name_Type'Last => ' '),
+                               Is_First => True,
+                               Param_Close_Bracket => Close_Ch);
+                           if Close_Ch /= ' ' then
+                               -- Get the alignment word:
+                               Arm_Input.Get_Name (Input_Object, Align_Name);
+                               ARM_Input.Get_Char (Input_Object, Ch);
+                               if Ch /= Close_Ch then
+                                   Ada.Text_IO.Put_Line ("  ** Bad close for 
Picture Alignment on line " & ARM_Input.Line_String (Input_Object));
+                                   ARM_Input.Replace_Char (Input_Object);
+                               end if;
+
+                               if Ada.Characters.Handling.To_Lower 
(Ada.Strings.Fixed.Trim (Align_Name, Ada.Strings.Right)) =
+                                   "left" then
+                                   Alignment := ARM_Output.Alone_Left;
+                               elsif Ada.Characters.Handling.To_Lower 
(Ada.Strings.Fixed.Trim (Align_Name, Ada.Strings.Right)) =
+                                   "right" then
+                                   Alignment := ARM_Output.Alone_Right;
+                               elsif Ada.Characters.Handling.To_Lower 
(Ada.Strings.Fixed.Trim (Align_Name, Ada.Strings.Right)) =
+                                   "center" then
+                                   Alignment := ARM_Output.Alone_Center;
+                               else
+                                   Ada.Text_IO.Put_Line ("  ** Bad stand-alone 
picture alignment: " &
+                                           Ada.Strings.Fixed.Trim (Align_Name, 
Ada.Strings.Right) &
+                                           " on line " & ARM_Input.Line_String 
(Input_Object));
+                               end if;
+                           -- else no parameter. Weird.
+                           end if;
+
+                       else -- Picture_Inline.
+                           Check_Paragraph; -- Make sure we're in a paragraph.
+
+                           ARM_Input.Check_Parameter_Name (Input_Object,
+                               Param_Name => "Alignment" & 
(10..ARM_Input.Command_Name_Type'Last => ' '),
+                               Is_First => True,
+                               Param_Close_Bracket => Close_Ch);
+                           if Close_Ch /= ' ' then
+                               -- Get the alignment word:
+                               Arm_Input.Get_Name (Input_Object, Align_Name);
+                               ARM_Input.Get_Char (Input_Object, Ch);
+                               if Ch /= Close_Ch then
+                                   Ada.Text_IO.Put_Line ("  ** Bad close for 
Picture Alignment on line " & ARM_Input.Line_String (Input_Object));
+                                   ARM_Input.Replace_Char (Input_Object);
+                               end if;
+
+                               if Ada.Characters.Handling.To_Lower 
(Ada.Strings.Fixed.Trim (Align_Name, Ada.Strings.Right)) =
+                                   "inline" then
+                                   Alignment := ARM_Output.Inline;
+                               elsif Ada.Characters.Handling.To_Lower 
(Ada.Strings.Fixed.Trim (Align_Name, Ada.Strings.Right)) =
+                                   "floatleft" then
+                                   Alignment := ARM_Output.Float_Left;
+                               elsif Ada.Characters.Handling.To_Lower 
(Ada.Strings.Fixed.Trim (Align_Name, Ada.Strings.Right)) =
+                                   "floatright" then
+                                   Alignment := ARM_Output.Float_Right;
+                               else
+                                   Ada.Text_IO.Put_Line ("  ** Bad inline 
picture alignment: " &
+                                           Ada.Strings.Fixed.Trim (Align_Name, 
Ada.Strings.Right) &
+                                           " on line " & ARM_Input.Line_String 
(Input_Object));
+                               end if;
+                           -- else no parameter. Weird.
+                           end if;
+
+                       end if;
+
+                       ARM_Input.Check_Parameter_Name (Input_Object,
+                           Param_Name => "Border" & 
(7..ARM_Input.Command_Name_Type'Last => ' '),
+                           Is_First => False,
+                           Param_Close_Bracket => Close_Ch);
+                       if Close_Ch /= ' ' then
+                           -- Get the alignment word:
+                           Arm_Input.Get_Name (Input_Object, Align_Name);
+                           ARM_Input.Get_Char (Input_Object, Ch);
+                           if Ch /= Close_Ch then
+                               Ada.Text_IO.Put_Line ("  ** Bad close for 
Picture Border on line " & ARM_Input.Line_String (Input_Object));
+                               ARM_Input.Replace_Char (Input_Object);
+                           end if;
+
+                           if Ada.Characters.Handling.To_Lower 
(Ada.Strings.Fixed.Trim (Align_Name, Ada.Strings.Right)) =
+                               "none" then
+                               Border := ARM_Output.None;
+                           elsif Ada.Characters.Handling.To_Lower 
(Ada.Strings.Fixed.Trim (Align_Name, Ada.Strings.Right)) =
+                               "thin" then
+                               Border := ARM_Output.Thin;
+                           elsif Ada.Characters.Handling.To_Lower 
(Ada.Strings.Fixed.Trim (Align_Name, Ada.Strings.Right)) =
+                               "thick" then
+                               Border := ARM_Output.Thick;
+                           else
+                               Ada.Text_IO.Put_Line ("  ** Bad picture border: 
" &
+                                       Ada.Strings.Fixed.Trim (Align_Name, 
Ada.Strings.Right) &
+                                       " on line " & ARM_Input.Line_String 
(Input_Object));
+                           end if;
+                       -- else no parameter. Weird.
+                       end if;
+
+                       ARM_Input.Check_Parameter_Name (Input_Object,
+                                   Param_Name => "Height" & 
(7..ARM_Input.Command_Name_Type'Last => ' '),
+                                   Is_First => False,
+                                   Param_Close_Bracket => Close_Ch);
+                       if Close_Ch /= ' ' then
+                           -- Copy over the term:
+                           ARM_Input.Copy_to_String_until_Close_Char (
+                               Input_Object,
+                               Close_Ch,
+                               Name,
+                               NLen);
+                           begin
+                               Height := Natural'Value(Name(1..NLen));
+                           exception
+                               when Constraint_Error =>
+                                   Ada.Text_IO.Put_Line ("  ** Bad picture 
height: " &
+                                           Name(1..NLen) & " on line " & 
ARM_Input.Line_String (Input_Object));
+                           end;
+                       -- else no parameter. Weird.
+                       end if;
+
+                       ARM_Input.Check_Parameter_Name (Input_Object,
+                                   Param_Name => "Width" & 
(6..ARM_Input.Command_Name_Type'Last => ' '),
+                                   Is_First => False,
+                                   Param_Close_Bracket => Close_Ch);
+                       if Close_Ch /= ' ' then
+                           -- Copy over the term:
+                           ARM_Input.Copy_to_String_until_Close_Char (
+                               Input_Object,
+                               Close_Ch,
+                               Name,
+                               NLen);
+                           begin
+                               Width := Natural'Value(Name(1..NLen));
+                           exception
+                               when Constraint_Error =>
+                                   Ada.Text_IO.Put_Line ("  ** Bad picture 
width: " &
+                                           Name(1..NLen) & " on line " & 
ARM_Input.Line_String (Input_Object));
+                           end;
+                       -- else no parameter. Weird.
+                       end if;
+
+                       ARM_Input.Check_Parameter_Name (Input_Object,
+                                   Param_Name => "Name" & 
(5..ARM_Input.Command_Name_Type'Last => ' '),
+                                   Is_First => False,
+                                   Param_Close_Bracket => Close_Ch);
+                       if Close_Ch /= ' ' then
+                           -- Copy over the term:
+                           ARM_Input.Copy_to_String_until_Close_Char (
+                               Input_Object,
+                               Close_Ch,
+                               Name,
+                               NLen);
+                       -- else no parameter. Weird.
+                       end if;
+
+                       ARM_Input.Check_Parameter_Name (Input_Object,
+                           Param_Name => "Descr" & 
(6..ARM_Input.Command_Name_Type'Last => ' '),
+                           Is_First => False,
+                           Param_Close_Bracket => Close_Ch);
+                       if Close_Ch /= ' ' then
+                           -- Copy over the term:
+                           ARM_Input.Copy_to_String_until_Close_Char (
+                               Input_Object,
+                               Close_Ch,
+                               Descr,
+                               DLen);
+                       -- else no parameter. Weird.
+                       end if;
+
+                       ARM_Output.Picture (
+                           Output_Object,
+                           Alignment => Alignment,
+                           Border => Border,
+                           Height => Height,
+                           Width => Width,
+                           Name => Name(1..NLen),
+                           Descr => Descr(1..DLen));
+                   end;
+                   -- Normal processing should remove the command end marker.
+
+               -- Paragraph kind commands:
+
+               when Text_Begin =>
+                   declare
+                       Type_Name : ARM_Input.Command_Name_Type;
+                       Ch : Character;
+                   begin
+                       -- OK, now read the begin "type":
+                       Arm_Input.Get_Name (Input_Object, Type_Name);
+                       ARM_Input.Get_Char (Input_Object, Ch);
+                       if Ch = ',' then
+                           -- Multiple parameters. The remaining
+                           -- parameters appear to be format instructions,
+                           -- which we ought to replace or remove.
+                           Ada.Text_IO.Put_Line ("  -- Multi-parameter begin, 
line " & ARM_Input.Line_String (Input_Object));
+
+                           -- We ignore everything until the end of the
+                           -- parameter.
+                           while Ch /= 
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Close_Char loop
+                               -- Ignore everything until the end character
+                               -- turns up.
+                               ARM_Input.Get_Char (Input_Object, Ch);
+                           end loop;
+                        end if;
+
+                       if Format_State.Nesting_Stack 
(Format_State.Nesting_Stack_Ptr).Close_Char = Ch then
+                           -- Found the end of the parameter.
+                           -- Replace the top of stack with the appropriate 
begin record:
+                           Format_State.Nesting_Stack 
(Format_State.Nesting_Stack_Ptr) :=
+                               (Name => Ada.Characters.Handling.To_Lower 
(Type_Name),
+                                Kind => Begin_Word,
+                                Command => Text_Begin,
+                                Close_Char => ' ',-- No close character.
+                                Text_Format => Format_Object.Text_Format,
+                                       -- Save the current format.
+                                Old_Last_Subhead_Paragraph => 
Format_Object.Last_Paragraph_Subhead_Type,
+                                Old_Next_Subhead_Paragraph => 
Format_Object.Next_Paragraph_Subhead_Type,
+                                Old_Next_Paragraph_Format => 
Format_Object.Next_Paragraph_Format_Type,
+                                Old_Tab_Stops => 
Format_Object.Paragraph_Tab_Stops,
+                                Old_Next_Enum_Num => 
Format_Object.Next_Enumerated_Num,
+                                Is_Formatting => True, -- Reset if needed 
later.
+                                Change_Version => '0', -- Not used.
+                                Was_Text => False, -- Not used.
+                                Prev_Change => ARM_Output.None, -- Not used.
+                                Prev_Change_Version => '0', -- Not used.
+                                Prev_Added_Change_Version => '0'); -- Not used.
+
+                           Process_Begin;
+
+                       else
+                           ARM_Input.Replace_Char (Input_Object);
+                           Ada.Text_IO.Put_Line ("  ** Failed to find close 
for parameter to begin, line " & ARM_Input.Line_String (Input_Object));
+                           --Bracket_Check := 
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Old_Bracket_State;
+                           Format_State.Nesting_Stack_Ptr := 
Format_State.Nesting_Stack_Ptr - 1;
+--Ada.Text_IO.Put_Line (" &Unstack (Bad Begin)");
+                       end if;
+                   end;
+
+               when Text_End =>
+                   declare
+                       Type_Name : ARM_Input.Command_Name_Type;
+                       Ch : Character;
+                   begin
+                       Arm_Input.Get_Name (Input_Object, Type_Name); -- Get 
the end "type".
+                       ARM_Input.Get_Char (Input_Object, Ch);
+                       if Format_State.Nesting_Stack 
(Format_State.Nesting_Stack_Ptr).Close_Char = Ch then
+                           -- Found end of parameter:
+                           Format_State.Nesting_Stack_Ptr := 
Format_State.Nesting_Stack_Ptr - 1;
+                               -- Remove the "End" record.
+                           -- Check for the matching begin, and remove it.
+                           if Format_State.Nesting_Stack_Ptr = 0 then
+                               Ada.Text_IO.Put_Line ("  ** No begin for end, 
line " & ARM_Input.Line_String (Input_Object));
+                           elsif 
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Name /=
+                               Ada.Characters.Handling.To_Lower (Type_Name) 
then
+                               Ada.Text_IO.Put_Line ("  ** Names of begin and 
end mismatch, line " & ARM_Input.Line_String (Input_Object));
+                               Ada.Text_IO.Put_Line ("     Begin name: " & 
Ada.Strings.Fixed.Trim(Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Name,
 Ada.Strings.Right) &
+                                                     "  End name: " & 
Ada.Strings.Fixed.Trim(Type_Name, Ada.Strings.Right));
+--Ada.Text_IO.Put_Line (" &Stack name is " & 
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Name);
+                           else
+                               if Format_Object.Next_Paragraph_Subhead_Type /= 
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Old_Next_Subhead_Paragraph
 then
+                                   Format_Object.Last_Paragraph_Subhead_Type 
:= 
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Old_Last_Subhead_Paragraph;
+                               -- else still in same subhead, leave alone. (If
+                               -- we didn't do this, we'd output the subhead
+                               -- multiple times).
+                               end if;
+                               Format_Object.Next_Paragraph_Subhead_Type := 
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Old_Next_Subhead_Paragraph;
+                               Format_Object.Next_Paragraph_Format_Type := 
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Old_Next_Paragraph_Format;
+                               Format_Object.Paragraph_Tab_Stops := 
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Old_Tab_Stops;
+                               Format_Object.Next_Enumerated_Num := 
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Old_Next_Enum_Num;
+                               Format_State.Nesting_Stack_Ptr := 
Format_State.Nesting_Stack_Ptr - 1;
+--Ada.Text_IO.Put_Line (" &Unstack (End)");
+--!!Debug:
+--Ada.Text_IO.Put_Line ("(End) Next=" & 
Paragraph_Type'Image(Format_Object.Next_Paragraph_Subhead_Type));
+                           end if;
+
+                           Check_End_Paragraph; -- End any paragraph that 
we're in.
+
+                           declare
+                               Lower_Type_Name : constant String :=
+                                   Ada.Characters.Handling.To_Lower 
(Ada.Strings.Fixed.Trim (
+                                       Type_Name, Ada.Strings.Right));
+                           begin
+                               -- Check if number of columns is changing:
+                               if Lower_Type_Name = "twocol" then
+                                   -- Leaving two column region, reset to one:
+                                   ARM_Output.Set_Columns (Output_Object, 
Number_of_Columns => 1);
+                               elsif Lower_Type_Name = "fourcol" then
+                                   -- Leaving four column region, reset to one:
+                                   ARM_Output.Set_Columns (Output_Object, 
Number_of_Columns => 1);
+                               end if;
+                               -- Check if we're leaving a bundle:
+                               if Lower_Type_Name = "bundle" then
+                                   Format_Object.In_Bundle := False;
+                               end if;
+                               -- Check if we're leaving an enumerated list:
+                               if Lower_Type_Name = "enumerate" or else
+                                  Lower_Type_Name = "innerenumerate" then
+                                   Format_Object.Enumerated_Level :=
+                                       Format_Object.Enumerated_Level - 1;
+                               end if;
+                           end;
+                       else
+                           ARM_Input.Replace_Char (Input_Object);
+                           Ada.Text_IO.Put_Line ("  ** Failed to find close 
for parameter to end, line " & ARM_Input.Line_String (Input_Object));
+                           Format_State.Nesting_Stack_Ptr := 
Format_State.Nesting_Stack_Ptr - 1;
+--Ada.Text_IO.Put_Line (" &Unstack (Bad End)");
+                       end if;
+                   end;
+
+               -- Indexing commands:
+
+               when Defn | RootDefn =>
+                   -- @Defn{term} or @RootDefn{term}. Index the term.
+                   -- Note that there is no difference between these in terms
+                   -- of the index, so we do them together.
+                   declare
+                       Term : String(1..80);
+                       Len : Natural := 0;
+                       Key : ARM_Index.Index_Key;
+                   begin
+                       ARM_Input.Copy_to_String_until_Close_Char (
+                           Input_Object,
+                           
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Close_Char,
+                           Term,
+                           Len);
+                       ARM_Index.Add (Term => Term(1..Len),
+                                      Kind => ARM_Index.Primary_Term,
+                                      Clause => Clause_String (Format_Object),
+                                      Paragraph => Paragraph_String,
+                                      Key => Key);
+
+                       Check_Paragraph;
+                       if Format_Object.Display_Index_Entries then
+                           if 
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Command = Defn then
+                               Display_Index_Entry (Term(1..Len));
+                           else -- RootDefn
+                               Display_Index_Entry (Term(1..Len), Special => 
Is_Root);
+                           end if;
+                       end if;
+                       ARM_Output.Index_Target (Output_Object, Key);
+                       Format_State.Nesting_Stack_Ptr := 
Format_State.Nesting_Stack_Ptr - 1;
+                           -- Remove the "(Root)Defn" record.
+                   end;
+
+               when PDefn =>
+                   -- @PDefn{term} ot @RootDefn{term}. Index the term as a 
partial
+                   -- definition.
+                   declare
+                       Term : String(1..80);
+                       Len : Natural := 0;
+                       Key : ARM_Index.Index_Key;
+                   begin
+                       ARM_Input.Copy_to_String_until_Close_Char (
+                           Input_Object,
+                           
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Close_Char,
+                           Term,
+                           Len);
+                       ARM_Index.Add (Term => Term(1..Len),
+                                      Kind => ARM_Index.Partial_Term,
+                                      Clause => Clause_String (Format_Object),
+                                      Paragraph => Paragraph_String,
+                                      Key => Key);
+
+                       Check_Paragraph;
+                       if Format_Object.Display_Index_Entries then
+                           Display_Index_Entry (Term(1..Len), Special => 
Is_Partial);
+                       end if;
+                       ARM_Output.Index_Target (Output_Object, Key);
+                       Format_State.Nesting_Stack_Ptr := 
Format_State.Nesting_Stack_Ptr - 1;
+                           -- Remove the "PDefn" record.
+                   end;
+
+               when Defn2 | RootDefn2 =>
+                   -- @Defn2[Term={term}, Sec={sec}]
+                   -- @RootDefn[Term={term}, Sec={sec}]. Index the term and 
subterm.
+                   -- Note that there is no difference between these in terms
+                   -- of the index, so we do them together.
+                   declare
+                       Close_Ch : Character;
+                       Term, Subterm : String(1..90);
+                       TLen, SLen : Natural := 0;
+                       Key : ARM_Index.Index_Key;
+                   begin
+                       ARM_Input.Check_Parameter_Name (Input_Object,
+                           Param_Name => "Term" & 
(5..ARM_Input.Command_Name_Type'Last => ' '),
+                           Is_First => True,
+                           Param_Close_Bracket => Close_Ch);
+                       if Close_Ch /= ' ' then
+                           -- Copy over the term:
+                           ARM_Input.Copy_to_String_until_Close_Char (
+                               Input_Object,
+                               Close_Ch,
+                               Term,
+                               TLen);
+                       -- else no parameter. Weird.
+                       end if;
+
+                       ARM_Input.Check_Parameter_Name (Input_Object,
+                           Param_Name => "Sec" & 
(4..ARM_Input.Command_Name_Type'Last => ' '),
+                           Is_First => False,
+                           Param_Close_Bracket => Close_Ch);
+                       if Close_Ch /= ' ' then
+                           -- Copy over the term:
+                           ARM_Input.Copy_to_String_until_Close_Char (
+                               Input_Object,
+                               Close_Ch,
+                               Subterm,
+                               SLen);
+                       -- else no parameter. Weird.
+                       end if;
+
+                       ARM_Index.Add (Term => Term(1..TLen),
+                                      Subterm => Subterm(1..SLen),
+                                      Kind => 
ARM_Index.Primary_Term_and_Subterm,
+                                      Clause => Clause_String (Format_Object),
+                                      Paragraph => Paragraph_String,
+                                      Key => Key);
+
+                       Check_Paragraph;
+                       if Format_Object.Display_Index_Entries then
+                           if 
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Command = Defn2 then
+                               Display_Index_Entry (Term(1..TLen) & " (" & 
Subterm(1..SLen) & ')');
+                           else -- RootDefn
+                               Display_Index_Entry (Term(1..TLen) & " (" & 
Subterm(1..SLen) & ')', Special => Is_Root);
+                           end if;
+                       end if;
+                       ARM_Output.Index_Target (Output_Object, Key);
+
+                       -- Leave the command end marker, let normal processing
+                       -- get rid of it.
+                   end;
+
+               when PDefn2 =>
+                   -- @PDefn2[Term={term}, Sec={sec}]. Index the term and 
subterm.
+                   -- Note that there is no difference between these in terms
+                   -- of the index, so we do them together.
+                   declare
+                       Close_Ch : Character;
+                       Term, Subterm : String(1..90);
+                       TLen, SLen : Natural := 0;
+                       Key : ARM_Index.Index_Key;
+                   begin
+                       ARM_Input.Check_Parameter_Name (Input_Object,
+                           Param_Name => "Term" & 
(5..ARM_Input.Command_Name_Type'Last => ' '),
+                           Is_First => True,
+                           Param_Close_Bracket => Close_Ch);
+                       if Close_Ch /= ' ' then
+                           -- Copy over the term:
+                           ARM_Input.Copy_to_String_until_Close_Char (
+                               Input_Object,
+                               Close_Ch,
+                               Term,
+                               TLen);
+                       -- else no parameter. Weird.
+                       end if;
+
+                       ARM_Input.Check_Parameter_Name (Input_Object,
+                           Param_Name => "Sec" & 
(4..ARM_Input.Command_Name_Type'Last => ' '),
+                           Is_First => False,
+                           Param_Close_Bracket => Close_Ch);
+                       if Close_Ch /= ' ' then
+                           -- Copy over the term:
+                           ARM_Input.Copy_to_String_until_Close_Char (
+                               Input_Object,
+                               Close_Ch,
+                               Subterm,
+                               SLen);
+                       -- else no parameter. Weird.
+                       end if;
+
+                       ARM_Index.Add (Term => Term(1..TLen),
+                                      Subterm => Subterm(1..SLen),
+                                      Kind => 
ARM_Index.Partial_Term_with_Subterm,
+                                      Clause => Clause_String (Format_Object),
+                                      Paragraph => Paragraph_String,
+                                      Key => Key);
+
+                       Check_Paragraph;
+                       if Format_Object.Display_Index_Entries then
+                           Display_Index_Entry (Term(1..TLen) & " (" & 
Subterm(1..SLen) & ')',
+                               Special => Is_Partial);
+                       end if;
+                       ARM_Output.Index_Target (Output_Object, Key);
+
+                       -- Leave the command end marker, let normal processing
+                       -- get rid of it.
+                   end;
+
+               when Index_See =>
+                   -- @IndexSee[Term={term}, See={see}]. Index a See item.
+                   declare
+                       Close_Ch : Character;
+                       Term, See : String(1..80);
+                       TLen, SLen : Natural := 0;
+                       Key : ARM_Index.Index_Key;
+                   begin
+                       ARM_Input.Check_Parameter_Name (Input_Object,
+                           Param_Name => "Term" & 
(5..ARM_Input.Command_Name_Type'Last => ' '),
+                           Is_First => True,
+                           Param_Close_Bracket => Close_Ch);
+                       if Close_Ch /= ' ' then
+                           -- Copy over the term:
+                           ARM_Input.Copy_to_String_until_Close_Char (
+                               Input_Object,
+                               Close_Ch,
+                               Term,
+                               TLen);
+                       -- else no parameter. Weird.
+                       end if;
+
+                       ARM_Input.Check_Parameter_Name (Input_Object,
+                           Param_Name => "See" & 
(4..ARM_Input.Command_Name_Type'Last => ' '),
+                           Is_First => False,
+                           Param_Close_Bracket => Close_Ch);
+                       if Close_Ch /= ' ' then
+                           -- Copy over the term:
+                           ARM_Input.Copy_to_String_until_Close_Char (
+                               Input_Object,
+                               Close_Ch,
+                               See,
+                               SLen);
+                       -- else no parameter. Weird.
+                       end if;
+
+                       ARM_Index.Add (Term => Term(1..TLen),
+                                      Subterm => See(1..SLen),
+                                      Kind => ARM_Index.See_Term,
+                                      Clause => Clause_String (Format_Object),
+                                      Paragraph => Paragraph_String,
+                                      Key => Key);
+
+                       Check_Paragraph;
+                       if Format_Object.Display_Index_Entries then
+                           Display_Index_Entry (Term(1..TLen) & ": See " & 
See(1..SLen));
+                       end if;
+                       ARM_Output.Index_Target (Output_Object, Key);
+
+                       -- Leave the command end marker, let normal processing
+                       -- get rid of it.
+                   end;
+
+               when Index_See_Also =>
+                   -- @IndexSeeAlso[Term={term}, See={see}]. Index a See Also 
item.
+                   declare
+                       Close_Ch : Character;
+                       Term, See : String(1..80);
+                       TLen, SLen : Natural := 0;
+                       Key : ARM_Index.Index_Key;
+                   begin
+                       ARM_Input.Check_Parameter_Name (Input_Object,
+                           Param_Name => "Term" & 
(5..ARM_Input.Command_Name_Type'Last => ' '),
+                           Is_First => True,
+                           Param_Close_Bracket => Close_Ch);
+                       if Close_Ch /= ' ' then
+                           -- Copy over the term:
+                           ARM_Input.Copy_to_String_until_Close_Char (
+                               Input_Object,
+                               Close_Ch,
+                               Term,
+                               TLen);
+                       -- else no parameter. Weird.
+                       end if;
+
+                       ARM_Input.Check_Parameter_Name (Input_Object,
+                           Param_Name => "See" & 
(4..ARM_Input.Command_Name_Type'Last => ' '),
+                           Is_First => False,
+                           Param_Close_Bracket => Close_Ch);
+                       if Close_Ch /= ' ' then
+                           -- Copy over the term:
+                           ARM_Input.Copy_to_String_until_Close_Char (
+                               Input_Object,
+                               Close_Ch,
+                               See,
+                               SLen);
+                       -- else no parameter. Weird.
+                       end if;
+
+                       ARM_Index.Add (Term => Term(1..TLen),
+                                      Subterm => See(1..SLen),
+                                      Kind => ARM_Index.See_Also_Term,
+                                      Clause => Clause_String (Format_Object),
+                                      Paragraph => Paragraph_String,
+                                      Key => Key);
+
+                       Check_Paragraph;
+                       if Format_Object.Display_Index_Entries then
+                           Display_Index_Entry (Term(1..TLen) & ": See also " 
& See(1..SLen));
+                       end if;
+                       ARM_Output.Index_Target (Output_Object, Key);
+
+                       -- Leave the command end marker, let normal processing
+                       -- get rid of it.
+                   end;
+
+               when See_Other =>
+                   -- @SeeOther[Primary={term}, Other={see}]. Generate a
+                   -- See {see} in the index, but no reference.
+                   declare
+                       Close_Ch : Character;
+                       Term, See : String(1..80);
+                       TLen, SLen : Natural := 0;
+                       Key : ARM_Index.Index_Key;
+                   begin
+                       ARM_Input.Check_Parameter_Name (Input_Object,
+                           Param_Name => "Primary" & 
(8..ARM_Input.Command_Name_Type'Last => ' '),
+                           Is_First => True,
+                           Param_Close_Bracket => Close_Ch);
+                       if Close_Ch /= ' ' then
+                           -- Copy over the term:
+                           ARM_Input.Copy_to_String_until_Close_Char (
+                               Input_Object,
+                               Close_Ch,
+                               Term,
+                               TLen);
+                       -- else no parameter. Weird.
+                       end if;
+
+                       ARM_Input.Check_Parameter_Name (Input_Object,
+                           Param_Name => "Other" & 
(6..ARM_Input.Command_Name_Type'Last => ' '),
+                           Is_First => False,
+                           Param_Close_Bracket => Close_Ch);
+                       if Close_Ch /= ' ' then
+                           -- Copy over the term:
+                           ARM_Input.Copy_to_String_until_Close_Char (
+                               Input_Object,
+                               Close_Ch,
+                               See,
+                               SLen);
+                       -- else no parameter. Weird.
+                       end if;
+
+                       ARM_Index.Add (Term => Term(1..TLen),
+                                      Subterm => See(1..SLen),
+                                      Kind => ARM_Index.See_Other_Term,
+                                      Clause => "",
+                                      Paragraph => "",
+                                      Key => Key);
+
+                       Check_Paragraph;
+                       ARM_Output.Index_Target (Output_Object, Key);
+
+                       -- Leave the command end marker, let normal processing
+                       -- get rid of it.
+                   end;
+
+               when See_Also =>
+                   -- @SeeAlso[Primary={term}, Other={see}]. Generate a
+                   -- See also {see} in the index, but no reference.
+                   declare
+                       Close_Ch : Character;
+                       Term, See : String(1..80);
+                       TLen, SLen : Natural := 0;
+                       Key : ARM_Index.Index_Key;
+                   begin
+                       ARM_Input.Check_Parameter_Name (Input_Object,
+                           Param_Name => "Primary" & 
(8..ARM_Input.Command_Name_Type'Last => ' '),
+                           Is_First => True,
+                           Param_Close_Bracket => Close_Ch);
+                       if Close_Ch /= ' ' then
+                           -- Copy over the term:
+                           ARM_Input.Copy_to_String_until_Close_Char (
+                               Input_Object,
+                               Close_Ch,
+                               Term,
+                               TLen);
+                       -- else no parameter. Weird.
+                       end if;
+
+                       ARM_Input.Check_Parameter_Name (Input_Object,
+                           Param_Name => "Other" & 
(6..ARM_Input.Command_Name_Type'Last => ' '),
+                           Is_First => False,
+                           Param_Close_Bracket => Close_Ch);
+                       if Close_Ch /= ' ' then
+                           -- Copy over the term:
+                           ARM_Input.Copy_to_String_until_Close_Char (
+                               Input_Object,
+                               Close_Ch,
+                               See,
+                               SLen);
+                       -- else no parameter. Weird.
+                       end if;
+
+                       ARM_Index.Add (Term => Term(1..TLen),
+                                      Subterm => See(1..SLen),
+                                      Kind => ARM_Index.See_Also_Other_Term,
+                                      Clause => "",
+                                      Paragraph => "",
+                                      Key => Key);
+
+                       Check_Paragraph;
+                       ARM_Output.Index_Target (Output_Object, Key);
+
+                       -- Leave the command end marker, let normal processing
+                       -- get rid of it.
+                   end;
+
+               when Index_Root_Unit =>
+                   -- @RootLibUnit{<unit>}
+                   -- Generates two index entries: An index entry for
+                   -- "Language-Defined Library Units" with a secondary
+                   -- entry of <unit>, and an index entry for <unit>.
+                   declare
+                       Term : String(1..80);
+                       Len : Natural := 0;
+                       Key : ARM_Index.Index_Key := ARM_Index.Get_Key;
+                       Disposition : ARM_Output.Change_Type;
+                       use type ARM_Output.Change_Type;
+                   begin
+                       ARM_Input.Copy_to_String_until_Close_Char (
+                           Input_Object,
+                           
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Close_Char,
+                           Term,
+                           Len);
+
+                       -- Set the current unit for future use:
+                       Format_Object.Unit (1..Len) := Term(1..Len);
+                       Format_Object.Unit_Len := Len;
+
+                       -- Determine what to do with the "Language-Defined" 
entry:
+                       Calc_Change_Disposition (
+                           Format_Object => Format_Object,
+                           Version => '2',
+                           Operation => ARM_Output.Deletion,
+                           Text_Kind => Disposition);
+                       if Disposition = Do_Not_Display_Text then
+                           null; -- Ignore this.
+                       elsif Disposition = ARM_Output.None then
+                           -- Make reference:
+                           ARM_Index.Add_Reusing_Key (
+                               Term => "Language-Defined Library Units",
+                               Subterm => Term(1..Len),
+                               Kind => ARM_Index.Primary_Term_and_Subterm,
+                               Clause => Clause_String (Format_Object),
+                               Paragraph => Paragraph_String,
+                               Key => Key);
+                       elsif Disposition = ARM_Output.Deletion then
+                           null; -- Ignore this (no change info in the index).
+                       else -- Insertion.
+                           raise Program_Error; -- An insertion inside of a 
deletion command!
+                       end if;
+
+                       Check_Paragraph;
+                       ARM_Output.Index_Target (Output_Object, Key);
+
+                       ARM_Index.Add_Reusing_Key (
+                               Term => Term(1..Len),
+                               Kind => ARM_Index.Primary_Term,
+                               Clause => Clause_String (Format_Object),
+                               Paragraph => Paragraph_String,
+                               Key => Key);
+
+                       ARM_Subindex.Insert (
+                               Subindex_Object => Format_Object.Package_Index,
+                               Entity => Term(1..Len),
+                               Kind => ARM_Subindex.Top_Level,
+                               Clause => Clause_String (Format_Object),
+                               Paragraph => Paragraph_String,
+                               Key => Key);
+
+                       Format_State.Nesting_Stack_Ptr := 
Format_State.Nesting_Stack_Ptr - 1;
+                           -- Remove the "RootLibUnit" record.
+                   end;
+
+               when Index_Child_Unit =>
+                   -- @ChildUnit{Parent=[<parent>],Child=[<child>]}
+                   -- Generates three index entries: An index entry for 
<child>, with a secondary
+                   -- of "@i{child of} <parent>", an index entry for 
"Language-Defined
+                   -- Library Units" with a secondary entry of 
<parent>.<child>,
+                   -- and an index entry for <parent>.<child>.
+                   Child_Unit (Format_Object.Package_Index,
+                       Format_Object,
+                       Output_Object);
+
+
+               when Index_Subprogram_Child_Unit =>
+                   -- @ChildUnit{Parent=[<parent>],Child=[<child>]}
+                   -- Generates three index entries: An index entry for 
<child>, with a secondary
+                   -- of "@i{child of} <parent>", an index entry for 
"Language-Defined
+                   -- Library Units" with a secondary entry of 
<parent>.<child>,
+                   -- and an index entry for <parent>.<child>.
+                   Child_Unit (Format_Object.Subprogram_Index,
+                       Format_Object,
+                       Output_Object);
+
+               when Index_Type =>
+                   -- @AdaTypeDefn{<defn>}
+                   -- Generates two index entries: one for <defn> with a
+                   -- secondary entry of "@i{in} <Unit>" (where Unit is
+                   -- the unit saved by a previous RootLibUnit or ChildUnit.),
+                   -- adds a similar entry to the exception list,
+                   -- and second for "Language-Defined Type" with a
+                   -- secondary entry of "<defn> @i{in} <Unit>".
+                   -- Also outputs the <defn> to the output file.
+
+                   Simple_Subindex_Item (
+                       Format_Object.Type_Index,
+                       Format_Object,
+                       Output_Object,
+                       Entity_Kind_Name => "Type");
+                   Format_State.Nesting_Stack_Ptr := 
Format_State.Nesting_Stack_Ptr - 1;
+                       -- Remove the "AdaTypeDefn" record.
+
+               when Index_Subtype =>
+                   -- @AdaSubTypeDefn{Name=<defn>,Of=<type>}
+                   -- Generates an index entry of "<defn> @i{subtype of}
+                   -- <type>" with a secondary entry of "@i{in} <Unit>" (where
+                   -- Unit is the unit saved by a previous RootLibUnit or
+                   -- ChildUnit.) The entry is added to the type list as well.
+                   -- Also outputs the <defn> to the output file.
+                   declare
+                       Subtype_Name, Type_Name : String(1..80);
+                       SLen, TLen : Natural := 0;
+                       Key : ARM_Index.Index_Key := ARM_Index.Get_Key;
+                       Close_Ch : Character;
+                   begin
+                       ARM_Input.Check_Parameter_Name (Input_Object,
+                                   Param_Name => "Name" & 
(5..ARM_Input.Command_Name_Type'Last => ' '),
+                                   Is_First => True,
+                                   Param_Close_Bracket => Close_Ch);
+                       if Close_Ch /= ' ' then
+                           -- Copy over the term:
+                           ARM_Input.Copy_to_String_until_Close_Char (
+                               Input_Object,
+                               Close_Ch,
+                               Subtype_Name,
+                               SLen);
+                       -- else no parameter. Weird.
+                       end if;
+
+                       ARM_Input.Check_Parameter_Name (Input_Object,
+                           Param_Name => "Of" & 
(3..ARM_Input.Command_Name_Type'Last => ' '),
+                           Is_First => False,
+                           Param_Close_Bracket => Close_Ch);
+                       if Close_Ch /= ' ' then
+                           -- Copy over the term:
+                           ARM_Input.Copy_to_String_until_Close_Char (
+                               Input_Object,
+                               Close_Ch,
+                               Type_Name,
+                               TLen);
+                       -- else no parameter. Weird.
+                       end if;
+
+                       Check_Paragraph;
+                       ARM_Output.Index_Target (Output_Object, Key);
+
+                       if Format_Object.Unit_Len = 0 then
+                           Ada.Text_IO.Put_Line ("** No unit defined for index 
entry expecting one on line " & ARM_Input.Line_String (Input_Object));
+
+                           ARM_Index.Add_Reusing_Key (
+                               Term => Subtype_Name(1..SLen) & " subtype of " &
+                                   Type_Name(1..TLen),
+                               Subterm => "*unknown*",
+                               Kind => 
ARM_Index.Subtype_Declaration_in_Package,
+                               Clause => Clause_String (Format_Object),
+                               Paragraph => Paragraph_String,
+                               Key => Key);
+
+                           ARM_Subindex.Insert (
+                               Subindex_Object => Format_Object.Type_Index,
+                               Entity => Subtype_Name(1..SLen) & " subtype of 
" &
+                                   Type_Name(1..TLen),
+                               From_Unit => "*unknown*",
+                               Kind => ARM_Subindex.Subtype_In_Unit,
+                               Clause => Clause_String (Format_Object),
+                               Paragraph => Paragraph_String,
+                               Key => Key);
+                       else
+                           ARM_Index.Add_Reusing_Key (
+                               Term => Subtype_Name(1..SLen) & " subtype of " &
+                                   Type_Name(1..TLen),
+                               Subterm => 
Format_Object.Unit(1..Format_Object.Unit_Len),
+                               Kind => 
ARM_Index.Subtype_Declaration_in_Package,
+                               Clause => Clause_String (Format_Object),
+                               Paragraph => Paragraph_String,
+                               Key => Key);
+
+                           ARM_Subindex.Insert (
+                               Subindex_Object => Format_Object.Type_Index,
+                               Entity => Subtype_Name(1..SLen) & " subtype of 
" &
+                                   Type_Name(1..TLen),
+                               From_Unit => 
Format_Object.Unit(1..Format_Object.Unit_Len),
+                               Kind => ARM_Subindex.Subtype_In_Unit,
+                               Clause => Clause_String (Format_Object),
+                               Paragraph => Paragraph_String,
+                               Key => Key);
+                       end if;
+                       ARM_Output.Ordinary_Text (Output_Object, 
Subtype_Name(1..SLen));
+                       Format_Object.Last_Non_Space := True;
+                       -- Leave the command end marker, let normal processing
+                       -- get rid of it.
+                   end;
+
+               when Index_Subprogram =>
+                   -- @AdaSubDefn{<defn>}
+                   -- Generates two index entries: one for <defn> with a
+                   -- secondary entry of "@i{in} <Unit>" (where Unit is
+                   -- the unit saved by a previous RootLibUnit or ChildUnit.),
+                   -- adds a similar entry to the exception list,
+                   -- and second for "Language-Defined Subprogram" with a
+                   -- secondary entry of "<defn> @i{in} <Unit>".
+                   -- Also outputs the <defn> to the output file.
+                   Simple_Subindex_Item (
+                       Format_Object.Subprogram_Index,
+                       Format_Object,
+                       Output_Object,
+                       Entity_Kind_Name => "Subprogram");
+                   Format_State.Nesting_Stack_Ptr := 
Format_State.Nesting_Stack_Ptr - 1;
+                       -- Remove the "AdaSubDefn" record.
+
+               when Index_Exception =>
+                   -- @AdaExcDefn{<defn>}
+                   -- Generates and index entries for <defn> with a
+                   -- secondary entry of "@i{in} <Unit>" (where Unit is
+                   -- the unit saved by a previous RootLibUnit or ChildUnit.),
+                   -- and adds a similar entry to the exception list.
+                   -- Also outputs the <defn> to the output file.
+                   Simple_Subindex_Item (
+                       Format_Object.Exception_Index,
+                       Format_Object,
+                       Output_Object,
+                       Entity_Kind_Name => "");
+                   Format_State.Nesting_Stack_Ptr := 
Format_State.Nesting_Stack_Ptr - 1;
+                       -- Remove the "AdaExcDefn" record.
+
+               when Index_Object =>
+                   -- @AdaObjDefn{<defn>}
+                   -- Generates and index entries for <defn> with a
+                   -- secondary entry of "@i{in} <Unit>" (where Unit is
+                   -- the unit saved by a previous RootLibUnit or ChildUnit.),
+                   -- and adds a similar entry to the exception list.
+                   -- Also outputs the <defn> to the output file.
+                   Simple_Subindex_Item (
+                       Format_Object.Object_Index,
+                       Format_Object,
+                       Output_Object,
+                       Entity_Kind_Name => "");
+                   Format_State.Nesting_Stack_Ptr := 
Format_State.Nesting_Stack_Ptr - 1;
+                       -- Remove the "AdaObjDefn" record.
+
+               when Index_Package =>
+                   -- @AdaObjDefn{<defn>}
+                   -- Generates and index entries for <defn> with a
+                   -- secondary entry of "@i{in} <Unit>" (where Unit is
+                   -- the unit saved by a previous RootLibUnit or ChildUnit.),
+                   -- and adds a similar entry to the package list.
+                   -- Also outputs the <defn> to the output file.
+                   Simple_Subindex_Item (
+                       Format_Object.Package_Index,
+                       Format_Object,
+                       Output_Object,
+                       Entity_Kind_Name => "");
+                   Format_State.Nesting_Stack_Ptr := 
Format_State.Nesting_Stack_Ptr - 1;
+                       -- Remove the "AdaPackDefn" record.
+
+               when Index_Other =>
+                   -- @AdaDefn{<defn>}
+                   -- Generate an index entries for <defn> with a
+                   -- secondary entry of "@i{in} <Unit>" (where Unit is
+                   -- the unit saved by a previous RootLibUnit or ChildUnit.).
+                   -- Also outputs the <defn> to the output file.
+                   declare
+                       Item : String(1..80);
+                       Len : Natural := 0;
+                       Key : ARM_Index.Index_Key;
+                   begin
+                       ARM_Input.Copy_to_String_until_Close_Char (
+                           Input_Object,
+                           
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Close_Char,
+                           Item,
+                           Len);
+
+                       ARM_Index.Add (Term => Item(1..Len),
+                                      Subterm => 
Format_Object.Unit(1..Format_Object.Unit_Len),
+                                      Kind => ARM_Index.Declaration_in_Package,
+                                      Clause => Clause_String (Format_Object),
+                                      Paragraph => Paragraph_String,
+                                      Key => Key);
+                       Check_Paragraph;
+                       ARM_Output.Index_Target (Output_Object, Key);
+
+                       ARM_Output.Ordinary_Text (Output_Object, Item(1..Len));
+                       Format_Object.Last_Non_Space := True;
+
+                       Format_State.Nesting_Stack_Ptr := 
Format_State.Nesting_Stack_Ptr - 1;
+                           -- Remove the "AdaDefn" record.
+                   end;
+
+               when Index_Check =>
+                   -- @Indexcheck{<check>}
+                   -- Generates index items for
+                   -- "check, language-defined", <check>,
+                   -- and <check> [partial].
+                   declare
+                       Term : String(1..80);
+                       Len : Natural := 0;
+                       Key : ARM_Index.Index_Key;
+                   begin
+                       ARM_Input.Copy_to_String_until_Close_Char (
+                           Input_Object,
+                           
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Close_Char,
+                           Term,
+                           Len);
+
+                       ARM_Index.Add (Term => Term(1..Len),
+                                      Kind => ARM_Index.Partial_Term,
+                                      Clause => Clause_String (Format_Object),
+                                      Paragraph => Paragraph_String,
+                                      Key => Key);
+                       Check_Paragraph;
+                       if Format_Object.Display_Index_Entries then
+                           Display_Index_Entry (Term(1..Len), Special => 
Is_Partial);
+                       end if;
+                       ARM_Output.Index_Target (Output_Object, Key);
+
+                       ARM_Index.Add (Term => "check, language-defined",
+                                      Subterm => Term(1..Len),
+                                      Kind => 
ARM_Index.Primary_Term_and_Subterm,
+                                      Clause => Clause_String (Format_Object),
+                                      Paragraph => Paragraph_String,
+                                      Key => Key);
+                       if Format_Object.Display_Index_Entries then
+                           Display_Index_Entry ("check, language-defined (" & 
Term(1..Len) & ")");
+                       end if;
+                       ARM_Output.Index_Target (Output_Object, Key);
+
+                       Format_State.Nesting_Stack_Ptr := 
Format_State.Nesting_Stack_Ptr - 1;
+                           -- Remove the "Indexcheck" record.
+                   end;
+
+               when Index_Attr =>
+                   -- This command indexes an attribute name.
+                   -- This calls Defn2("attributes", <param>), and
+                   -- also writes <param> to output.
+                   declare
+                       Param : String(1..20);
+                       Len : Natural := 0;
+                       Key : ARM_Index.Index_Key;
+                   begin
+                       ARM_Input.Copy_to_String_until_Close_Char (
+                           Input_Object,
+                           
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Close_Char,
+                           Param,
+                           Len);
+
+                       Check_Paragraph;
+
+                       ARM_Index.Add (Term => "attributes",
+                                      Subterm => Param(1..Len),
+                                      Kind => 
ARM_Index.Primary_Term_and_Subterm,
+                                      Clause => Clause_String (Format_Object),
+                                      Paragraph => Paragraph_String,
+                                      Key => Key);
+                       ARM_Output.Index_Target (Output_Object, Key);
+
+                       ARM_Index.Add (Term => Param(1..Len) & " attribute",
+                                      Kind => ARM_Index.Primary_Term,
+                                      Clause => Clause_String (Format_Object),
+                                      Paragraph => Paragraph_String,
+                                      Key => Key);
+                       ARM_Output.Index_Target (Output_Object, Key);
+
+                       ARM_Output.Ordinary_Text (Output_Object,
+                           Param(1..Len));
+                       Format_State.Nesting_Stack_Ptr := 
Format_State.Nesting_Stack_Ptr - 1;
+                           -- Remove the "Index_Attr" record.
+                   end;
+
+               when Index_Pragma =>
+                   -- This command indexes a pragma name.
+                   -- This calls Defn2("pragmas", <param>), and
+                   -- also writes <param> to output.
+                   declare
+                       Param : String(1..30);
+                       Len : Natural := 0;
+                       Key : ARM_Index.Index_Key;
+                   begin
+                       ARM_Input.Copy_to_String_until_Close_Char (
+                           Input_Object,
+                           
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Close_Char,
+                           Param,
+                           Len);
+                       Check_Paragraph;
+                       ARM_Index.Add (Term => "pragmas",
+                                      Subterm => Param(1..Len),
+                                      Kind => 
ARM_Index.Primary_Term_and_Subterm,
+                                      Clause => Clause_String (Format_Object),
+                                      Paragraph => Paragraph_String,
+                                      Key => Key);
+                       ARM_Output.Index_Target (Output_Object, Key);
+
+                       ARM_Index.Add (Term => Param(1..Len) & " pragma",
+                                      Kind => ARM_Index.Primary_Term,
+                                      Clause => Clause_String (Format_Object),
+                                      Paragraph => Paragraph_String,
+                                      Key => Key);
+                       ARM_Output.Index_Target (Output_Object, Key);
+
+                       ARM_Output.Ordinary_Text (Output_Object,
+                           Param(1..Len));
+                       Format_State.Nesting_Stack_Ptr := 
Format_State.Nesting_Stack_Ptr - 1;
+                           -- Remove the "Index_Pragma" record.
+                   end;
+
+               when Index_Aspect =>
+                   -- This command indexes an aspect name.
+                   -- This calls Defn2("aspects", <param>), and
+                   -- Defn(<param> "aspect")
+                   declare
+                       Param : String(1..30);
+                       Len : Natural := 0;
+                       Key : ARM_Index.Index_Key;
+                   begin
+                       ARM_Input.Copy_to_String_until_Close_Char (
+                           Input_Object,
+                           
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Close_Char,
+                           Param,
+                           Len);
+                       Check_Paragraph;
+                       ARM_Index.Add (Term => "aspects",
+                                      Subterm => Param(1..Len),
+                                      Kind => 
ARM_Index.Primary_Term_and_Subterm,
+                                      Clause => Clause_String (Format_Object),
+                                      Paragraph => Paragraph_String,
+                                      Key => Key);
+                       ARM_Output.Index_Target (Output_Object, Key);
+
+                       ARM_Index.Add (Term => Param(1..Len) & " aspect",
+                                      Kind => ARM_Index.Primary_Term,
+                                      Clause => Clause_String (Format_Object),
+                                      Paragraph => Paragraph_String,
+                                      Key => Key);
+                       ARM_Output.Index_Target (Output_Object, Key);
+
+                       Format_State.Nesting_Stack_Ptr := 
Format_State.Nesting_Stack_Ptr - 1;
+                           -- Remove the "Index_Aspect" record.
+                   end;
+
+               when Syntax_Rule =>
+                   -- @syn{[Tabs=<Tabset>, ]LHS=<Non-terminal>, 
RHS=<Production>}
+                   -- Marks a syntax production of the form:
+                   --    @nt<Non-Terminal> ::= <Production>
+                   -- <Tabset> defines any tabs needed by the syntax 
production.
+                   --
+                   -- Also, the <Non-terminal> is indexed. The <Non-Terminal>
+                   -- and <Production> (and the clause number) are sent to the
+                   -- syntax manager. Also, saves <Non-terminal> for any
+                   -- following Syntax_Term (@Syn2) to use.
+
+                   declare
+                       RHS_Close_Ch : Character;
+                   begin
+                       Get_Syntax_Parameters (Has_Version => False,
+                                              RHS_Close_Ch => RHS_Close_Ch);
+
+                       Gen_Syntax_Rule (ARM_Output.None, RHS_Close_Ch);
+                   end;
+
+               when Added_Syntax_Rule =>
+                   -- @AddedSyn{Version=[Version],[Tabs=<Tabset>, 
]LHS=<Non-terminal>, RHS=<Production>}
+                   -- Marks an added syntax production of the form:
+                   --    @nt<Non-Terminal> ::= <Production>
+                   -- See Syntax_Rule for the details.
+                   declare
+                       RHS_Close_Ch : Character;
+                       Disposition : ARM_Output.Change_Type;
+                   begin
+                       Get_Syntax_Parameters (Has_Version => True,
+                                              RHS_Close_Ch => RHS_Close_Ch);
+                       if Format_Object.In_Change then
+                           Ada.Text_IO.Put_Line ("  ** In change for AddedSyn 
on line " & ARM_Input.Line_String (Input_Object));
+                           raise Program_Error;
+                       end if;
+
+                       Calc_Change_Disposition (
+                           Format_Object => Format_Object,
+                           Version => 
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Change_Version,
+                           Operation => ARM_Output.Insertion,
+                           Text_Kind => Disposition);
+
+                       Gen_Syntax_Rule (Disposition, RHS_Close_Ch);
+                   end;
+
+               when Deleted_Syntax_Rule =>
+                   -- @DeletedSyn{Version=[Version],[Tabs=<Tabset>, 
]LHS=<Non-terminal>, RHS=<Production>}
+                   -- Marks a deleted syntax production of the form:
+                   --    @nt<Non-Terminal> ::= <Production>
+                   -- See Syntax_Rule for the details.
+                   declare
+                       RHS_Close_Ch : Character;
+                       Disposition : ARM_Output.Change_Type;
+                   begin
+                       Get_Syntax_Parameters (Has_Version => True,
+                                              RHS_Close_Ch => RHS_Close_Ch);
+                       if Format_Object.In_Change then
+                           Ada.Text_IO.Put_Line ("  ** In change for 
DeletedSyn on line " & ARM_Input.Line_String (Input_Object));
+                           raise Program_Error;
+                       end if;
+
+                       Calc_Change_Disposition (
+                           Format_Object => Format_Object,
+                           Version => 
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Change_Version,
+                           Operation => ARM_Output.Deletion,
+                           Text_Kind => Disposition);
+
+                       Gen_Syntax_Rule (Disposition, RHS_Close_Ch);
+                   end;
+
+               when Syntax_Term | Syntax_Term_Undefined =>
+                   -- Marks a non-terminal name in the production of a syntax
+                   -- rule. Generates the term in the same style as
+                   -- @nt (Non_Terminal). "Undefined" means the term is
+                   -- not formally defined (like the character class names in
+                   -- the Ada standard).
+                   -- If the current LHS non-terminal is not null, generates
+                   -- a syntax cross reference entry:
+                   -- <Name> in <Non-Terminal> at <ClauseNum>. Also,
+                   -- generate an index entry for the item:
+                   -- @Defn2(Term=<Name>,Sec=@i{used}.
+                   -- Note: We assume no internal formatting in <Name>.
+                   declare
+                       Name : String(1..40);
+                       Len : Natural;
+                       Key : ARM_Index.Index_Key;
+                       Defined : constant Boolean :=
+                          
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Command =
+                              Syntax_Term;
+                   begin
+                       ARM_Input.Copy_to_String_until_Close_Char (
+                           Input_Object,
+                           
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Close_Char,
+                           Name, Len);
+                       if Format_Object.Syntax_NT_Len /= 0 then
+                           -- Generate a syntax cross-reference entry.
+                           declare
+                               NT : constant String := Get_NT;
+                           begin
+                               if NT /= "" then
+                                   ARM_Syntax.Add_Xref (
+                                        Name => Name(1..Len),
+                                        Used_In => Get_NT,
+                                        Clause => Clause_String 
(Format_Object),
+                                        Defined => Defined);
+                               -- else this is a deleted production that is
+                               -- still displayed; forget the XRef.
+                               end if;
+                           end;
+                       end if;
+
+                       -- Index the non-terminal:
+                       ARM_Index.Add (Term => Name(1..Len),
+                                      Kind => ARM_Index.Syntax_NT_Used,
+                                      Clause => Clause_String (Format_Object),
+                                      Paragraph => Paragraph_String,
+                                      Key => Key);
+                       ARM_Output.Index_Target (Output_Object, Key);
+
+                       -- Set the appropriate style:
+                       Check_Paragraph;
+                       declare
+                           Swiss_Format : ARM_Output.Format_Type :=
+                               Format_Object.Text_Format;
+                       begin
+                           Swiss_Format.Font := ARM_Output.Swiss;
+                           ARM_Output.Text_Format (Output_Object,
+                                                   Swiss_Format);
+                       end;
+                       if not Defined then
+                           -- No linking to do.
+                           ARM_Output.Ordinary_Text (Output_Object, 
Name(1..Len));
+                       elsif Format_Object.Link_Non_Terminals then
+                           declare
+                               Lower_NT : constant String :=
+                                   Ada.Characters.Handling.To_Lower 
(Name(1..Len));
+                               Clause : constant String :=
+                                   ARM_Syntax.Non_Terminal_Clause (Lower_NT);
+                               Target : constant ARM_Syntax.Target_Type :=
+                                   ARM_Syntax.Non_Terminal_Link_Target 
(Lower_NT);
+                           begin
+                               if Clause = "" then -- Not found. No link, but 
error message:
+                                   Ada.Text_IO.Put_Line ("  ** Unknown 
non-terminal in syntax production " &
+                                       Name(1..Len) & " on line " & 
ARM_Input.Line_String (Input_Object));
+                                   ARM_Output.Ordinary_Text (Output_Object, 
Name(1..Len));
+                               else
+                                   ARM_Output.Local_Link (Output_Object, Text 
=> Name(1..Len),
+                                       Target => Target, Clause_Number => 
Clause);
+                               end if;
+                           end;
+                       else
+                           ARM_Output.Ordinary_Text (Output_Object, 
Name(1..Len));
+                       end if;
+                       ARM_Output.Text_Format (Output_Object,
+                                               Format_Object.Text_Format); -- 
Reset the format.
+                       Format_Object.Last_Non_Space := True;
+                   end;
+                   Format_State.Nesting_Stack_Ptr := 
Format_State.Nesting_Stack_Ptr - 1;
+--Ada.Text_IO.Put_Line (" &Unstack (Syntax Term)");
+
+               when Syntax_Prefix =>
+                   -- Marks the prefix of a non-terminal. Writes italized
+                   -- text in the current font.
+                   -- Set the appropriate style:
+                   Check_Paragraph;
+                   Format_Object.Text_Format.Italic := True;
+                   ARM_Output.Text_Format (Output_Object,
+                                           Format_Object.Text_Format);
+
+               when To_Glossary | To_Glossary_Also =>
+                   -- This is a glossary command.
+                   -- It is of the form @ToGlossary(Term=[<term>], 
Text=[<text>])
+                   -- We will store the term and definition in the glossary
+                   -- database. We also have to pass through the Text
+                   -- parameter, either to the regular text (for
+                   -- ToGlossaryAlso) or the AARM (for ToGlossary).
+
+                   declare
+                       Close_Ch : Character;
+                       Key : ARM_Index.Index_Key;
+                   begin
+                       if Format_Object.Glossary_Info.Active then
+                           Ada.Text_IO.Put_Line ("  ** Nested glossary entry 
on line " & ARM_Input.Line_String (Input_Object));
+                       -- else OK.
+                       end if;
+                       -- Setup glossary information for this command:
+                       Format_Object.Glossary_Info :=
+                           (Active      => True,
+                            Change_Kind => ARM_Database.None,
+                               -- No change for this command.
+                            Term        => <>, -- Set below.
+                            Term_Len    => <>, -- Set below.
+                            Add_to_Glossary => True, -- Always add it.
+                            Displayed   => False); -- Until we decide 
differently.
+
+                       ARM_Input.Check_Parameter_Name (Input_Object,
+                           Param_Name => "Term" & 
(5..ARM_Input.Command_Name_Type'Last => ' '),
+                           Is_First => True,
+                           Param_Close_Bracket => Close_Ch);
+                       if Close_Ch /= ' ' then
+                           -- Copy the term:
+                           ARM_Input.Copy_to_String_until_Close_Char (
+                               Input_Object,
+                               Close_Ch,
+                               Format_Object.Glossary_Info.Term,
+                               Format_Object.Glossary_Info.Term_Len);
+                       -- else no parameter. Weird.
+                       end if;
+
+                       ARM_Input.Check_Parameter_Name (Input_Object,
+                           Param_Name => "Text" & 
(5..ARM_Input.Command_Name_Type'Last => ' '),
+                           Is_First => False,
+                           Param_Close_Bracket => Close_Ch);
+                       if Close_Ch /= ' ' then
+                           -- Now, handle the parameter:
+                           -- Stack it so we can process the end:
+                           Set_Nesting_for_Parameter
+                               (Command => Glossary_Text_Param,
+                                Close_Ch => Close_Ch);
+
+                           ARM_Input.Start_Recording (Input_Object);
+
+                           if 
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr-1).Command = 
To_Glossary_Also then
+                               -- The text just goes straight to the file.
+                               if Format_Object.Display_Index_Entries then
+                                   Display_Index_Entry 
(Format_Object.Glossary_Info.Term (1..Format_Object.Glossary_Info.Term_Len)); 
-- Includes Check_Paragraph.
+                                   ARM_Output.Ordinary_Text (Output_Object,
+                                       "[Glossary Entry]");
+                                   Format_Object.Last_Non_Space := True;
+                               -- else no marker.
+                               end if;
+
+                               -- Index the term (because it does appear here):
+                               Check_Paragraph; -- We've got to be in a 
paragraph to write this.
+                               ARM_Index.Add (Term => 
Format_Object.Glossary_Info.Term (1..Format_Object.Glossary_Info.Term_Len),
+                                              Kind => ARM_Index.Primary_Term,
+                                              Clause => Clause_String 
(Format_Object),
+                                              Paragraph => Paragraph_String,
+                                              Key => Key);
+                               ARM_Output.Index_Target (Output_Object, Key);
+                               Format_Object.Glossary_Info.Displayed := True;
+                           elsif Format_Object.Include_Annotations then
+                               Check_End_Paragraph; -- End any paragraph that 
we're in.
+                               
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Old_Last_Subhead_Paragraph
 := Format_Object.Last_Paragraph_Subhead_Type;
+                               
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Old_Next_Subhead_Paragraph
 := Format_Object.Next_Paragraph_Subhead_Type;
+                               
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Old_Next_Paragraph_Format
 := Format_Object.Next_Paragraph_Format_Type;
+                               
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Old_Tab_Stops := 
Format_Object.Paragraph_Tab_Stops;
+                               Format_Object.Next_Paragraph_Format_Type := 
Glossary_Marker;
+                               Format_Object.Next_Paragraph_Subhead_Type := 
Glossary_Marker;
+                               Format_Object.Paragraph_Tab_Stops := 
ARM_Output.NO_TABS;
+                               Display_Index_Entry 
(Format_Object.Glossary_Info.Term (1..Format_Object.Glossary_Info.Term_Len)); 
-- Includes Check_Paragraph.
+                               Format_Object.Glossary_Info.Displayed := True;
+                               -- Note: The term is indexed in the glossary,
+                               -- but not here.
+                           else -- No annotations, "To_Glossary"
+                               if Format_Object.Display_Index_Entries then
+                                   Display_Index_Entry 
(Format_Object.Glossary_Info.Term (1..Format_Object.Glossary_Info.Term_Len)); 
-- Includes Check_Paragraph.
+                                   ARM_Output.Ordinary_Text (Output_Object,
+                                       "[Glossary Entry]");
+                                   Format_Object.Last_Non_Space := True;
+                               -- else no marker.
+                               end if;
+                               -- Skip the text:
+                               ARM_Input.Skip_until_Close_Char (Input_Object,
+                                   
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Close_Char);
+                               ARM_Input.Replace_Char (Input_Object); -- Let 
the normal termination clean this up.
+                               Format_Object.Glossary_Info.Displayed := False;
+                               -- Note: The term is indexed in the glossary,
+                               -- but not here.
+                           end if;
+                       end if;
+                   end;
+
+               when Change_To_Glossary | Change_To_Glossary_Also =>
+                   -- This is a change glossary command.
+                   -- It is of the form
+                   -- 
@ChgToGlossary(Version=[<version>],Kind=(<kind>),Term=[<term>], Text=[<text>])
+                   -- We will store the term and definition in the glossary
+                   -- database. We also have to pass through the Text
+                   -- parameter, either to the regular text (for
+                   -- ChgToGlossaryAlso) or the AARM (for ChgToGlossary).
+
+                   declare
+                       Close_Ch : Character;
+                       Key : ARM_Index.Index_Key;
+                       Kind : ARM_Database.Paragraph_Change_Kind_Type;
+                       Our_Version : ARM_Contents.Change_Version_Type;
+                       use type ARM_Database.Paragraph_Change_Kind_Type;
+                       Local_Change  : ARM_Output.Change_Type;
+                   begin
+                       if Format_Object.Glossary_Info.Active then
+                           Ada.Text_IO.Put_Line ("  ** Nested glossary entry 
on line " & ARM_Input.Line_String (Input_Object));
+                       -- else OK.
+                       end if;
+
+                       Get_Change_Version (Is_First => True,
+                           Version => Our_Version);
+                           -- Read a parameter named "Version".
+
+                       Get_Change_Kind (Kind);
+                           -- Read a parameter named "Kind".
+
+                       -- Setup glossary information for this command (now
+                       -- that we know the above):
+                       -- Note: Discriminants need to be static, so we have
+                       -- to use the following brain-damaged initialization.
+                       -- At least this lets us strip the number and message
+                       -- information from Inserted and Deleted (which we
+                       -- would have to do anyway).
+                       case Kind is
+                           when ARM_Database.Inserted |
+                                ARM_Database.Inserted_Normal_Number =>
+                               Format_Object.Glossary_Info :=
+                                   (Active      => True,
+                                    Change_Kind => ARM_Database.Inserted,
+                                    Version     => Our_Version,
+                                    Term        => <>, -- Set below.
+                                    Term_Len    => <>, -- Set below.
+                                    Add_to_Glossary => <>, -- Set below.
+                                    Displayed   => <>); -- Set below.
+                           when ARM_Database.Deleted |
+                                ARM_Database.Deleted_Inserted_Number |
+                                ARM_Database.Deleted_No_Delete_Message |
+                                
ARM_Database.Deleted_Inserted_Number_No_Delete_Message =>
+                               Format_Object.Glossary_Info :=
+                                   (Active      => True,
+                                    Change_Kind => ARM_Database.Deleted,
+                                    Version     => Our_Version,
+                                    Term        => <>, -- Set below.
+                                    Term_Len    => <>, -- Set below.
+                                    Add_to_Glossary => <>, -- Set below.
+                                    Displayed   => <>); -- Set below.
+                           when ARM_Database.Revised =>
+                               Format_Object.Glossary_Info :=
+                                   (Active      => True,
+                                    Change_Kind => ARM_Database.Revised,
+                                    Version     => Our_Version,
+                                    Term        => <>, -- Set below.
+                                    Term_Len    => <>, -- Set below.
+                                    Add_to_Glossary => <>, -- Set below.
+                                    Displayed   => <>); -- Set below.
+                           when ARM_Database.Revised_Inserted_Number =>
+                               Format_Object.Glossary_Info :=
+                                   (Active      => True,
+                                    Change_Kind => 
ARM_Database.Revised_Inserted_Number,
+                                    Version     => Our_Version,
+                                    Term        => <>, -- Set below.
+                                    Term_Len    => <>, -- Set below.
+                                    Add_to_Glossary => <>, -- Set below.
+                                    Displayed   => <>); -- Set below.
+                           when ARM_Database.None =>
+                               raise Program_Error; -- Can't happen.
+                       end case;
+
+                       if 
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Command = 
Change_To_Glossary_Also then
+                           -- The text just goes straight to the file. It will
+                           -- get formatted appropriately. So we only need to
+                           -- figure out whether it will get indexed and 
displayed
+                           -- in the Glossary.
+                           Format_Object.Glossary_Info.Displayed := True;
+                           Local_Change := ARM_Output.None;
+                           if Format_Object.Changes = ARM_Format.Old_Only and 
then
+                               Format_Object.Glossary_Info.Version > '0' then
+                               -- Old only, don't display it (and it won't be
+                               -- inserted, either).
+                               Format_Object.Glossary_Info.Add_to_Glossary := 
False;
+                           elsif Format_Object.Glossary_Info.Change_Kind = 
ARM_Database.Inserted then
+                               if Format_Object.Glossary_Info.Version <= 
Format_Object.Change_Version then
+                                   Format_Object.Glossary_Info.Add_to_Glossary 
:= True;
+                               else --This reference is too new, ignore it.
+                                   Format_Object.Glossary_Info.Displayed := 
False;
+                                   Format_Object.Glossary_Info.Add_to_Glossary 
:= False;
+                               end if;
+                           elsif Format_Object.Glossary_Info.Change_Kind = 
ARM_Database.Deleted then
+                               Format_Object.Glossary_Info.Add_to_Glossary := 
True;
+                           else -- we always display it.
+                               Format_Object.Glossary_Info.Add_to_Glossary := 
True;
+                           end if;
+                       else
+                           if Format_Object.Glossary_Info.Change_Kind = 
ARM_Database.Inserted then
+                               Calc_Change_Disposition
+                                   (Format_Object => Format_Object,
+                                    Version => 
Format_Object.Glossary_Info.Version,
+                                    Operation => ARM_Output.Insertion,
+                                    Text_Kind => Local_Change);
+                               case Local_Change is
+                                   when Do_Not_Display_Text =>
+                                       Format_Object.Glossary_Info.Displayed 
:= False;
+                                       
Format_Object.Glossary_Info.Add_to_Glossary := False;
+                                       Local_Change := ARM_Output.None;
+                                   when ARM_Output.None|ARM_Output.Insertion =>
+                                       Format_Object.Glossary_Info.Displayed :=
+                                           Format_Object.Include_Annotations;
+                                       
Format_Object.Glossary_Info.Add_to_Glossary := True;
+                                   when ARM_Output.Deletion =>
+                                       raise Program_Error;
+                               end case;
+                           elsif Format_Object.Glossary_Info.Change_Kind = 
ARM_Database.Deleted then
+                               -- Note: other forms of delete removed 
previously.
+                               Calc_Change_Disposition
+                                   (Format_Object => Format_Object,
+                                    Version => 
Format_Object.Glossary_Info.Version,
+                                    Operation => ARM_Output.Deletion,
+                                    Text_Kind => Local_Change);
+                               case Local_Change is
+                                   when Do_Not_Display_Text =>
+                                       Format_Object.Glossary_Info.Displayed 
:= False;
+                                       
Format_Object.Glossary_Info.Add_to_Glossary := True;
+                                       -- We still add this to the glossary so 
that
+                                       -- the deleted paragraph message can be 
displayed for it.
+                                       Local_Change := ARM_Output.None;
+                                   when ARM_Output.None|ARM_Output.Deletion =>
+                                       Format_Object.Glossary_Info.Displayed :=
+                                           Format_Object.Include_Annotations;
+                                       
Format_Object.Glossary_Info.Add_to_Glossary := True;
+                                   when ARM_Output.Insertion =>
+                                       raise Program_Error;
+                               end case;
+                           else -- we always display it.
+                               Format_Object.Glossary_Info.Displayed :=
+                                   Format_Object.Include_Annotations;
+                               Format_Object.Glossary_Info.Add_to_Glossary := 
True;
+                               Local_Change := ARM_Output.None;
+                           end if;
+                       end if;
+
+                       ARM_Input.Check_Parameter_Name (Input_Object,
+                           Param_Name => "Term" & 
(5..ARM_Input.Command_Name_Type'Last => ' '),
+                           Is_First => False,
+                           Param_Close_Bracket => Close_Ch);
+                       if Close_Ch /= ' ' then
+                           -- Copy the term:
+                           ARM_Input.Copy_to_String_until_Close_Char (
+                               Input_Object,
+                               Close_Ch,
+                               Format_Object.Glossary_Info.Term,
+                               Format_Object.Glossary_Info.Term_Len);
+                       -- else no parameter. Weird.
+                       end if;
+
+                       ARM_Input.Check_Parameter_Name (Input_Object,
+                           Param_Name => "Text" & 
(5..ARM_Input.Command_Name_Type'Last => ' '),
+                           Is_First => False,
+                           Param_Close_Bracket => Close_Ch);
+                       if Close_Ch /= ' ' then
+                           -- Now, handle the parameter:
+                           -- Stack it so we can process the end:
+                           Set_Nesting_for_Parameter
+                               (Command => Glossary_Text_Param,
+                                Close_Ch => Close_Ch);
+
+                           ARM_Input.Start_Recording (Input_Object);
+
+                           if 
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr-1).Command = 
Change_To_Glossary_Also then
+                               -- The text just goes straight to the file.
+                               if Format_Object.Glossary_Info.Add_to_Glossary 
then
+                                   if Format_Object.Display_Index_Entries then
+                                       Display_Index_Entry 
(Format_Object.Glossary_Info.Term (1..Format_Object.Glossary_Info.Term_Len)); 
-- Includes Check_Paragraph.
+                                       ARM_Output.Ordinary_Text (Output_Object,
+                                           "[Glossary Entry]");
+                                       Format_Object.Last_Non_Space := True;
+                                   -- else no marker.
+                                   end if;
+
+                                   -- Index the term (because it does appear 
here):
+                                   Check_Paragraph; -- We've got to be in a 
paragraph to write this.
+                                   ARM_Index.Add (Term => 
Format_Object.Glossary_Info.Term (1..Format_Object.Glossary_Info.Term_Len),
+                                                  Kind => 
ARM_Index.Primary_Term,
+                                                  Clause => Clause_String 
(Format_Object),
+                                                  Paragraph => 
Paragraph_String,
+                                                  Key => Key);
+                                   ARM_Output.Index_Target (Output_Object, 
Key);
+                               -- else no indexing.
+                               end if;
+                           elsif Format_Object.Glossary_Info.Displayed then -- 
Change_To_Glossary
+                               -- Create the AARM annotation:
+                               Check_End_Paragraph; -- End any paragraph that 
we're in.
+                               
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Old_Last_Subhead_Paragraph
 := Format_Object.Last_Paragraph_Subhead_Type;
+                               
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Old_Next_Subhead_Paragraph
 := Format_Object.Next_Paragraph_Subhead_Type;
+                               
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Old_Next_Paragraph_Format
 := Format_Object.Next_Paragraph_Format_Type;
+                               
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Old_Tab_Stops := 
Format_Object.Paragraph_Tab_Stops;
+                               Format_Object.Next_Paragraph_Format_Type := 
Glossary_Marker;
+                               Format_Object.Next_Paragraph_Subhead_Type := 
Glossary_Marker;
+                               Format_Object.Paragraph_Tab_Stops := 
ARM_Output.NO_TABS;
+                               Format_Object.Next_Paragraph_Version := 
Format_Object.Glossary_Info.Version;
+                               Format_Object.Next_Paragraph_Change_Kind := 
Kind;
+
+                                -- We assume no outer changes;
+                               -- set new change state:
+                               Format_Object.Text_Format.Change := 
Local_Change;
+                               Format_Object.Text_Format.Version :=
+                                  Format_Object.Glossary_Info.Version;
+                               Format_Object.Text_Format.Added_Version := '0';
+                                   -- Change the state *before* outputting the
+                                   -- paragraph header, so the AARM prefix is 
included.
+                               Display_Index_Entry 
(Format_Object.Glossary_Info.Term (1..Format_Object.Glossary_Info.Term_Len)); 
-- Includes Check_Paragraph.
+
+                               Format_Object.Text_Format.Change := 
ARM_Output.None; -- Undo (header) change.
+                               Format_Object.Text_Format.Version := '0';
+
+                           elsif Format_Object.Glossary_Info.Add_to_Glossary 
then -- Change_To_Glossary
+                               -- No AARM annotation:
+                               if Format_Object.Display_Index_Entries then
+                                   Display_Index_Entry 
(Format_Object.Glossary_Info.Term (1..Format_Object.Glossary_Info.Term_Len)); 
-- Includes Check_Paragraph.
+                                   ARM_Output.Ordinary_Text (Output_Object,
+                                       "[Glossary Entry]");
+                                   Format_Object.Last_Non_Space := True;
+                               -- else no marker.
+                               end if;
+                               -- Skip the text:
+                               ARM_Input.Skip_until_Close_Char (Input_Object,
+                                   
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Close_Char);
+                               ARM_Input.Replace_Char (Input_Object); -- Let 
the normal termination clean this up.
+
+                               -- Note: The term is indexed in the glossary,
+                               -- but not here.
+                           else
+                               -- Skip the text (it won't be used at all):
+                               ARM_Input.Skip_until_Close_Char (Input_Object,
+                                   
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Close_Char);
+                               ARM_Input.Replace_Char (Input_Object); -- Let 
the normal termination clean this up.
+                           end if;
+                       end if;
+                   end;
+
+               when Implementation_Defined =>
+                   -- Store an "implementation-defined" entry for the 
parameter;
+                   -- also save the clause and paragraph reference.
+
+                   ARM_Input.Start_Recording (Input_Object);
+
+                   if Format_Object.Impdef_Info.Command /= None then
+                       Ada.Text_IO.Put_Line ("  ** Nested impdef entry on line 
" & ARM_Input.Line_String (Input_Object));
+                   -- else OK.
+                   end if;
+                   -- Setup impdef information for this command:
+                   Format_Object.Impdef_Info :=
+                       (Command     => Impdef,
+                        Change_Kind => ARM_Database.None,
+                        Version     => '0',
+                        Initial_Version => '0',
+                        Add_to_DB   => True,    -- Until we decide differently.
+                        Paragraph_String => <>, -- Set below.
+                        Paragraph_Len    => <>);-- Set below.
+
+                   if Format_Object.In_Paragraph then
+                       -- Do this to preserve any inserted paragraph info.
+                       Format_Object.Impdef_Info.Paragraph_String :=
+                           Format_Object.Current_Paragraph_String;
+                       Format_Object.Impdef_Info.Paragraph_Len :=
+                           Format_Object.Current_Paragraph_Len;
+                   else
+                       declare
+                           PNum : constant String := Positive'Image (
+                               Format_Object.Next_Paragraph - 1);
+                       begin
+                           Format_Object.Impdef_Info.Paragraph_Len := 
PNum'Length - 1;
+                           Format_Object.Impdef_Info.Paragraph_String (1 .. 
PNum'Last-1) :=
+                               PNum (2 .. PNum'Last);
+                       end;
+                   end if;
+
+                   if Format_Object.Include_Annotations then
+                       Check_End_Paragraph; -- End any paragraph that we're in.
+                       
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Old_Last_Subhead_Paragraph
 := Format_Object.Last_Paragraph_Subhead_Type;
+                       
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Old_Next_Subhead_Paragraph
 := Format_Object.Next_Paragraph_Subhead_Type;
+                       
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Old_Next_Paragraph_Format
 := Format_Object.Next_Paragraph_Format_Type;
+                       
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Old_Tab_Stops := 
Format_Object.Paragraph_Tab_Stops;
+                       Format_Object.Next_Paragraph_Format_Type := 
Bare_Annotation;
+                       Format_Object.Next_Paragraph_Subhead_Type := 
Bare_Annotation;
+                       Format_Object.Paragraph_Tab_Stops := ARM_Output.NO_TABS;
+                       Check_Paragraph;
+                       declare
+                           Bold_Format : ARM_Output.Format_Type :=
+                               Format_Object.Text_Format;
+                       begin
+                           Bold_Format.Bold := True; -- Change only the 
boldface.
+                           ARM_Output.Text_Format (Output_Object,
+                                                   Bold_Format);
+                       end;
+                       ARM_Output.Ordinary_Text (Output_Object,
+                            Text => "Implementation defined: ");
+                       ARM_Output.Text_Format (Output_Object,
+                                               Format_Object.Text_Format); -- 
Reset style.
+                       Format_Object.Last_Paragraph_Subhead_Type := 
Bare_Annotation;
+                       Format_Object.Last_Non_Space := False;
+                   else -- No annotations
+                       -- Skip the text:
+                       ARM_Input.Skip_until_Close_Char (Input_Object,
+                           
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Close_Char);
+                       ARM_Input.Replace_Char (Input_Object); -- Let the 
normal termination clean this up.
+                   end if;
+
+               when Prefix_Type =>
+                   -- Copy the text into the Format_Object.Prefix_Text string.
+                   Check_Paragraph;
+                   ARM_Input.Start_Recording (Input_Object);
+                   -- No changes in this version (use ChgAttribute if you need 
that).
+                   Format_Object.Attr_Prefix_Change_Kind := ARM_Database.None;
+                   Format_Object.Attr_Prefix_Version := '0';
+
+               when Reset_Prefix_Type =>
+                   -- Set Format_Object.Prefix_Text string to the default.
+                   Format_Object.Prefix_Text := "@b{NONE!}" & (10..200 => ' ');
+                   Format_Object.Prefix_Text_Len := 9;
+
+               when Attribute | Attribute_Leading =>
+                    -- @Attribute{Prefix=<Prefix>,AttrName=<Name>,Text=<Text>}
+                    -- Defines an attribute. Creates a hanging text item 
<Prefix>'<Name>,
+                    -- with the specified text. The text can contain arbitrary 
commands;
+                    -- it will be run through the full evaluation code.
+                    -- The attribute and text is also sent to a database used 
to later create
+                    -- Annex K. (This uses the current value of PrefixType.) 
Finally, the
+                    -- attribute <Name> is indexed as by calling 
@Defn2{Term=[Attribute],
+                    -- Sec=<Name>}, and as by calling @Defn{<Name> attribute}.
+                   declare
+                       Close_Ch : Character;
+                       Key : ARM_Index.Index_Key;
+                   begin
+                       Check_End_Paragraph; -- This is always a paragraph end.
+
+                       -- No changes in this version (use ChgAttribute if you 
need that).
+                       Format_Object.Attr_Change_Kind := ARM_Database.None;
+                       Format_Object.Attr_Version := '0';
+                       Format_Object.Attr_Initial_Version := '0';
+
+                       ARM_Input.Check_Parameter_Name (Input_Object,
+                           Param_Name => "Prefix" & 
(7..ARM_Input.Command_Name_Type'Last => ' '),
+                           Is_First => True,
+                           Param_Close_Bracket => Close_Ch);
+                       if Close_Ch /= ' ' then
+                           -- Save prefix:
+                           ARM_Input.Copy_to_String_until_Close_Char (
+                               Input_Object,
+                               Close_Ch,
+                               Format_Object.Attr_Prefix,
+                               Format_Object.Attr_Prefix_Len);
+                       -- else no parameter. Weird.
+                       end if;
+
+                       ARM_Input.Check_Parameter_Name (Input_Object,
+                           Param_Name => "AttrName" & 
(9..ARM_Input.Command_Name_Type'Last => ' '),
+                           Is_First => False,
+                           Param_Close_Bracket => Close_Ch);
+                       if Close_Ch /= ' ' then
+                           -- Save name:
+                           ARM_Input.Copy_to_String_until_Close_Char (
+                               Input_Object,
+                               Close_Ch,
+                               Format_Object.Attr_Name,
+                               Format_Object.Attr_Name_Len);
+                       -- else no parameter. Weird.
+                       end if;
+
+                       -- Output <Prefix>'<Name> as the hanging text.
+                       if 
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Command = 
Attribute_Leading then
+                           Format_Object.Space_After := ARM_Output.Narrow;
+                           Format_Object.Attr_Leading := True;
+                       else
+                           Format_Object.Space_After := ARM_Output.Normal;
+                           Format_Object.Attr_Leading := False;
+                       end if;
+                       Check_Paragraph;
+                       ARM_Output.Ordinary_Text (Output_Object,
+                               Format_Object.Attr_Prefix (1 .. 
Format_Object.Attr_Prefix_Len));
+                       ARM_Output.Ordinary_Character (Output_Object, ''');
+                       ARM_Output.Ordinary_Text (Output_Object,
+                               Format_Object.Attr_Name (1 .. 
Format_Object.Attr_Name_Len));
+                       ARM_Output.End_Hang_Item (Output_Object);
+                       Format_Object.Last_Non_Space := False; -- Treat like 
start of a line.
+
+                       ARM_Index.Add (Term => "attributes",
+                                      Subterm => Format_Object.Attr_Name (1 .. 
Format_Object.Attr_Name_Len),
+                                      Kind => 
ARM_Index.Primary_Term_and_Subterm,
+                                      Clause => Clause_String (Format_Object),
+                                      Paragraph => Paragraph_String,
+                                      Key => Key);
+                       ARM_Output.Index_Target (Output_Object, Key);
+
+                       ARM_Index.Add (Term => Format_Object.Attr_Name (1 .. 
Format_Object.Attr_Name_Len) & " attribute",
+                                      Kind => ARM_Index.Primary_Term,
+                                      Clause => Clause_String (Format_Object),
+                                      Paragraph => Paragraph_String,
+                                      Key => Key);
+                       ARM_Output.Index_Target (Output_Object, Key);
+
+                       ARM_Input.Check_Parameter_Name (Input_Object,
+                           Param_Name => "Text" & 
(5..ARM_Input.Command_Name_Type'Last => ' '),
+                           Is_First => False,
+                           Param_Close_Bracket => Close_Ch);
+                       if Close_Ch /= ' ' then
+                           -- Now, handle the parameter:
+                           -- The text goes to the file *and* is recorded.
+                           Arm_Input.Start_Recording (Input_Object);
+                           -- Stack the parameter so we can process the end:
+                           Set_Nesting_for_Parameter
+                               (Command => Attribute_Text_Param,
+                                Close_Ch => Close_Ch);
+                       end if;
+                   end;
+
+               when Pragma_Syntax =>
+                    -- @PragmaSyntax{<Text>}
+                    -- Defines a pragma. The text can contain arbitrary 
commands;
+                    -- it will be run through the full evaluation code.
+                    -- The text is also sent to a database used to later create
+                    -- Annex L.
+                    -- Note that these are indented slightly more than regular
+                    -- syntax text. We handle that by adding a couple of
+                    -- spaces before the text.
+
+--Ada.Text_IO.Put_Line ("%% Pragma - normal initialization.");
+                    -- All we have to do here is output a couple of
+                    -- hard spaces and then start recording.
+                    Check_Paragraph;
+                    ARM_Output.Hard_Space (Output_Object);
+                    ARM_Output.Hard_Space (Output_Object);
+                    ARM_Input.Start_Recording (Input_Object);
+                    -- Just handle the text normally.
+
+               when Added_Pragma_Syntax =>
+                    -- @AddedPragmaSyntax{Version=[<Version>],<Text>}
+                    -- Defines a pragma. The text can contain arbitrary 
commands;
+                    -- it will be run through the full evaluation code.
+                    -- The text is also sent to a database used to later create
+                    -- Annex L.
+                    -- Note that these are indented slightly more than regular
+                    -- syntax text. We handle that by adding a couple of
+                    -- spaces before the text.
+
+                    declare
+                       Ch : Character;
+                       Version : ARM_Contents.Change_Version_Type := '0';
+
+                       Disposition : ARM_Output.Change_Type;
+                       use type ARM_Output.Change_Type;
+                    begin
+                       Get_Change_Version (Is_First => True,
+                                           Version => Version);
+                       ARM_Input.Get_Char (Input_Object, Ch);
+                       if Ch /= ',' then
+                           Ada.Text_IO.Put_Line ("  ** Missing comma for 
AddedPragmaSyn on line " & ARM_Input.Line_String (Input_Object));
+                           ARM_Input.Replace_Char (Input_Object);
+                       end if;
+                       
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Change_Version := 
Version;
+                       
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Prev_Change_Version 
:= Version; -- Don't have or need an InitialVersion parameter.
+
+                       Calc_Change_Disposition (
+                           Format_Object => Format_Object,
+                           Version => Version,
+                           Operation => ARM_Output.Insertion,
+                           Text_Kind => Disposition);
+
+                       -- All we have to do here is output a couple of
+                       -- hard spaces (if anything will be displayed) and then
+                       -- start recording. The inner @Chg will handle the
+                       -- formatting for this.
+--Ada.Text_IO.Put_Line ("%% Added pragma.");
+                       Check_Paragraph;
+                       if Disposition /= Do_Not_Display_Text then
+                           ARM_Output.Hard_Space (Output_Object);
+                           ARM_Output.Hard_Space (Output_Object);
+                       -- else nothing to display.
+                       end if;
+                       ARM_Input.Start_Recording (Input_Object);
+                       -- Just handle the text normally.
+                   end;
+
+               when Deleted_Pragma_Syntax =>
+                    -- 
@DeletedPragmaSyntax{Version=[<Version>],InitialVersion=[<InitialVersion>],<Text>}
+                    -- Defines a pragma. The text can contain arbitrary 
commands;
+                    -- it will be run through the full evaluation code.
+                    -- The text is also sent to a database used to later create
+                    -- Annex L.
+                    -- Note that these are indented slightly more than regular
+                    -- syntax text. We handle that by adding a couple of
+                    -- spaces before the text.
+
+                    declare
+                       Close_Ch, Ch : Character;
+                       Version : ARM_Contents.Change_Version_Type := '0';
+                       Initial_Version : ARM_Contents.Change_Version_Type := 
'0';
+
+                       Disposition : ARM_Output.Change_Type;
+                       use type ARM_Output.Change_Type;
+                    begin
+                       Get_Change_Version (Is_First => True,
+                                           Version => Version);
+
+                       -- Now, get InitialVersion.
+                       ARM_Input.Check_Parameter_Name (Input_Object,
+                           Param_Name => "InitialVersion" & 
(15..ARM_Input.Command_Name_Type'Last => ' '),
+                           Is_First => False,
+                           Param_Close_Bracket => Close_Ch);
+
+                       ARM_Input.Get_Char (Input_Object, Initial_Version);
+                       ARM_Input.Get_Char (Input_Object, Ch);
+                       if Ch /= Close_Ch then
+                           Ada.Text_IO.Put_Line ("  ** Bad close for 
InitialVersion parameter on line " &
+                               ARM_Input.Line_String (Input_Object));
+                           ARM_Input.Replace_Char (Input_Object);
+                       end if;
+
+                       ARM_Input.Get_Char (Input_Object, Ch);
+                       if Ch /= ',' then
+                           Ada.Text_IO.Put_Line ("  ** Missing comma for 
AddedPragmaSyn on line " & ARM_Input.Line_String (Input_Object));
+                           ARM_Input.Replace_Char (Input_Object);
+                       end if;
+                       
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Change_Version := 
Version;
+                       
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Prev_Change_Version 
:= Initial_Version;
+
+                       Calc_Change_Disposition (
+                           Format_Object => Format_Object,
+                           Version => Version,
+                           Operation => ARM_Output.Deletion,
+                           Text_Kind => Disposition);
+
+--Ada.Text_IO.Put_Line ("%% Deleted pragma.");
+                       -- All we have to do here is output a couple of
+                       -- hard spaces (if anything will be displayed) and then
+                       -- start recording. The inner @Chg will handle the
+                       -- formatting for this.
+                       Check_Paragraph;
+                       if Disposition /= Do_Not_Display_Text then
+                           ARM_Output.Hard_Space (Output_Object);
+                           ARM_Output.Hard_Space (Output_Object);
+                       -- else nothing to display.
+                       end if;
+                       ARM_Input.Start_Recording (Input_Object);
+                       -- Just handle the text normally.
+                   end;
+
+               -- Clause title and reference commands:
+
+               when Labeled_Section | Labeled_Section_No_Break |
+                    Labeled_Annex | Labeled_Informative_Annex |
+                    Labeled_Normative_Annex | Labeled_Clause |
+                    Labeled_Subclause | Labeled_Subsubclause |
+                    Unnumbered_Section =>
+                   -- Load the title into the Title string:
+                   declare
+                       Title : ARM_Contents.Title_Type;
+                       Title_Length : Natural;
+                       Level : ARM_Contents.Level_Type;
+                   begin
+                       ARM_Input.Copy_to_String_until_Close_Char (
+                           Input_Object,
+                           
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Close_Char,
+                           Title, Title_Length);
+                       if 
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Command = 
Labeled_Subclause then
+                           Format_Object.Clause_Number :=
+                               (Section   => 
Format_Object.Clause_Number.Section,
+                                Clause    => 
Format_Object.Clause_Number.Clause,
+                                Subclause => 
Format_Object.Clause_Number.Subclause + 1,
+                                Subsubclause => 0);
+                           Level := ARM_Contents.Subclause;
+                       elsif 
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Command = 
Labeled_Subsubclause then
+                           Format_Object.Clause_Number.Subsubclause :=
+                               Format_Object.Clause_Number.Subsubclause + 1;
+                           Level := ARM_Contents.Subsubclause;
+                       elsif 
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Command = 
Labeled_Clause then
+                           Format_Object.Clause_Number :=
+                               (Section   => 
Format_Object.Clause_Number.Section,
+                                Clause    => 
Format_Object.Clause_Number.Clause + 1,
+                                Subclause => 0, Subsubclause => 0);
+                           Level := ARM_Contents.Clause;
+                       elsif 
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Command = 
Unnumbered_Section then
+                           Format_Object.Unnumbered_Section :=
+                               Format_Object.Unnumbered_Section + 1;
+                           Format_Object.Clause_Number :=
+                               (Section   => 0,
+                                Clause    => Format_Object.Unnumbered_Section,
+                                Subclause => 0, Subsubclause => 0);
+                           Level := ARM_Contents.Unnumbered_Section;
+                       elsif 
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Command = 
Labeled_Section or else
+                             
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Command = 
Labeled_Section_No_Break then
+                           Format_Object.Clause_Number :=
+                               (Section   => 
Format_Object.Clause_Number.Section, -- Will be set elsewhere.
+                                Clause    => 0,
+                                Subclause => 0, Subsubclause => 0);
+                           Level := ARM_Contents.Section;
+                       elsif 
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Command = 
Labeled_Annex then
+                           Format_Object.Clause_Number :=
+                               (Section   => 
Format_Object.Clause_Number.Section, -- Will be set elsewhere.
+                                Clause    => 0,
+                                Subclause => 0, Subsubclause => 0);
+                           Level := ARM_Contents.Plain_Annex;
+                       elsif 
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Command = 
Labeled_Normative_Annex then
+                           Format_Object.Clause_Number :=
+                               (Section   => 
Format_Object.Clause_Number.Section, -- Will be set elsewhere.
+                                Clause    => 0,
+                                Subclause => 0, Subsubclause => 0);
+                           Level := ARM_Contents.Normative_Annex;
+                       else -- 
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Command = 
Labeled_Informative_Annex then
+                           Format_Object.Clause_Number :=
+                               (Section   => 
Format_Object.Clause_Number.Section, -- Will be set elsewhere.
+                                Clause    => 0,
+                                Subclause => 0, Subsubclause => 0);
+                           Level := ARM_Contents.Informative_Annex;
+                       end if;
+                       Title(Title_Length+1 .. Title'Last) :=
+                           (others => ' ');
+
+                       begin
+                           declare
+                               Clause_Number : constant String :=
+                                   ARM_Contents.Lookup_Clause_Number (Title);
+                           begin
+                               Check_End_Paragraph; -- End any paragraph that 
we're in.
+                               if 
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Command = 
Labeled_Section_No_Break then
+                                   ARM_Output.Clause_Header (Output_Object,
+                                       Title(1..Title_Length),
+                                       Level => ARM_Contents.Section,
+                                       Clause_Number => Clause_Number,
+                                       No_Page_Break => True,
+                                       Top_Level_Subdivision_Name => 
Format_Object.Top_Level_Subdivision_Name);
+
+                               else -- Other cases:
+                                   ARM_Output.Clause_Header (Output_Object,
+                                       Title(1..Title_Length),
+                                       Level => Level,
+                                       Clause_Number => Clause_Number,
+                                       Top_Level_Subdivision_Name => 
Format_Object.Top_Level_Subdivision_Name);
+                               end if;
+                               -- Check that the section numbers match the 
title:
+                               if Ada.Characters.Handling.To_Lower (Title) /=
+                                  Ada.Characters.Handling.To_Lower 
(ARM_Contents.Lookup_Title (
+                                     Level, Format_Object.Clause_Number)) then
+                                   Ada.Text_IO.Put_Line ("** Unable to match 
title with section numbers, line " & ARM_Input.Line_String (Input_Object));
+                               end if;
+--!!Debug:
+--Ada.Text_IO.Put_Line ("Start clause " & Clause_Number & " -- " & 
Title(1..Title_Length));
+
+                           end;
+                       exception
+                           when ARM_Contents.Not_Found_Error =>
+                               Ada.Text_IO.Put_Line ("** Unable to find header 
reference, line " & ARM_Input.Line_String (Input_Object));
+                               Ada.Text_IO.Put_Line ("   Looking for " & 
Title(1..Title_Length));
+                       end;
+                   end;
+                   -- Reset the paragraph numbers:
+                   Format_Object.Next_Paragraph := 1;
+                   Format_Object.Next_Insert_Para := 1;
+                   Format_Object.Next_AARM_Sub := 'a';
+                   if Format_Object.Use_ISO_2004_Note_Format then
+                       -- Reset the note number:
+                       Format_Object.Next_Note := 1;
+                   elsif 
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Command = 
Labeled_Section or else
+                         
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Command = 
Labeled_Section_No_Break or else
+                         
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Command = 
Labeled_Annex or else
+                         
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Command = 
Labeled_Informative_Annex or else
+                         
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Command = 
Labeled_Normative_Annex then
+                       -- Reset the note number, only for sections:
+                       Format_Object.Next_Note := 1;
+                   end if;
+                   -- Reset the subhead:
+                   Format_Object.Last_Paragraph_Subhead_Type := Plain;
+                   Format_Object.Next_Paragraph_Format_Type := Plain;
+
+                   Format_State.Nesting_Stack_Ptr := 
Format_State.Nesting_Stack_Ptr - 1;
+--Ada.Text_IO.Put_Line (" &Unstack (Header)");
+
+               when Labeled_Revised_Annex |
+                    Labeled_Revised_Informative_Annex |
+                    Labeled_Revised_Normative_Annex |
+                    Labeled_Revised_Section |
+                    Labeled_Revised_Clause |
+                    Labeled_Revised_Subclause |
+                    Labeled_Revised_Subsubclause =>
+                   -- Load the title into the Title string:
+                   declare
+                       New_Title : ARM_Contents.Title_Type;
+                       New_Title_Length : Natural;
+                       Old_Title : ARM_Contents.Title_Type;
+                       Old_Title_Length : Natural;
+                       Close_Ch  : Character;
+                       Version   : ARM_Contents.Change_Version_Type := '0';
+                       Initial_Version : ARM_Contents.Change_Version_Type := 
'0';
+                       Level     : ARM_Contents.Level_Type;
+                   begin
+                       Get_Change_Version (Is_First => True,
+                                           Version => Version);
+
+                       -- Check for the optional "InitialVersion" parameter,
+                       -- stopping when we reach "New":
+                       declare
+                           Which_Param : ARM_Input.Param_Num;
+                           Ch          : Character;
+                       begin
+                           -- If there is no InitialVersion command, use the 
same
+                           -- version of the rest of the command.
+                           loop
+                               ARM_Input.Check_One_of_Parameter_Names 
(Input_Object,
+                                   Param_Name_1 => "InitialVersion" & 
(15..ARM_Input.Command_Name_Type'Last => ' '),
+                                   Param_Name_2 => "New" & 
(4..ARM_Input.Command_Name_Type'Last => ' '),
+                                   Is_First => False,
+                                   Param_Found => Which_Param,
+                                   Param_Close_Bracket => Close_Ch);
+
+                               if Which_Param = 1 and then Close_Ch /= ' ' then
+                                   -- Found InitialVersion
+                                   ARM_Input.Get_Char (Input_Object, Ch);
+                                   Initial_Version := Ch;
+                                   ARM_Input.Get_Char (Input_Object, Ch);
+                                   if Ch /= Close_Ch then
+                                       Ada.Text_IO.Put_Line ("  ** Bad close 
for InitialVersion parameter on line " &
+                                           ARM_Input.Line_String 
(Input_Object));
+                                       ARM_Input.Replace_Char (Input_Object);
+                                   end if;
+                               else -- We found "New" (or an error)
+                                   exit; -- Handling of New is below.
+                               end if;
+                           end loop;
+                       end;
+
+                       if Close_Ch /= ' ' then
+                           -- There is a parameter:
+                           -- Load the new title into the Title string:
+                           ARM_Input.Copy_to_String_until_Close_Char (
+                               Input_Object,
+                               Close_Ch,
+                               New_Title, New_Title_Length);
+                           New_Title(New_Title_Length+1 .. New_Title'Last) :=
+                               (others => ' ');
+                           ARM_Input.Check_Parameter_Name (Input_Object,
+                               Param_Name => "Old" & 
(4..ARM_Input.Command_Name_Type'Last => ' '),
+                               Is_First => False,
+                               Param_Close_Bracket => Close_Ch);
+                           if Close_Ch /= ' ' then
+                               -- There is a parameter:
+                               -- Load the new title into the Title string:
+                               ARM_Input.Copy_to_String_until_Close_Char (
+                                   Input_Object,
+                                   Close_Ch,
+                                   Old_Title, Old_Title_Length);
+                               Old_Title(Old_Title_Length+1 .. Old_Title'Last) 
:=
+                                   (others => ' ');
+                           end if;
+                       end if;
+                       ARM_Input.Get_Char (Input_Object, Close_Ch);
+                       if Close_Ch /= 
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Close_Char then
+                           Ada.Text_IO.Put_Line ("  ** Bad close for 
Labeled_Revised_(SubClause|Annex) on line " & ARM_Input.Line_String 
(Input_Object));
+                           ARM_Input.Replace_Char (Input_Object);
+                       end if;
+
+                       if 
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Command = 
Labeled_Revised_Subclause then
+                           Format_Object.Clause_Number :=
+                               (Section   => 
Format_Object.Clause_Number.Section,
+                                Clause    => 
Format_Object.Clause_Number.Clause,
+                                Subclause => 
Format_Object.Clause_Number.Subclause + 1,
+                                Subsubclause => 0);
+                           Level := ARM_Contents.Subclause;
+                       elsif 
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Command = 
Labeled_Revised_Subsubclause then
+                           Format_Object.Clause_Number.Subsubclause :=
+                               Format_Object.Clause_Number.Subsubclause + 1;
+                           Level := ARM_Contents.Subsubclause;
+                       elsif 
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Command = 
Labeled_Revised_Clause then
+                           Format_Object.Clause_Number :=
+                               (Section   => 
Format_Object.Clause_Number.Section,
+                                Clause    => 
Format_Object.Clause_Number.Clause + 1,
+                                Subclause => 0, Subsubclause => 0);
+                           Level := ARM_Contents.Clause;
+                       elsif 
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Command = 
Labeled_Revised_Section then
+                           Format_Object.Clause_Number :=
+                               (Section   => 
Format_Object.Clause_Number.Section, -- Will be set elsewhere.
+                                Clause    => 0,
+                                Subclause => 0, Subsubclause => 0);
+                           Level := ARM_Contents.Section;
+                       elsif 
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Command = 
Labeled_Revised_Annex then
+                           Format_Object.Clause_Number :=
+                               (Section   => 
Format_Object.Clause_Number.Section, -- Will be set elsewhere.
+                                Clause    => 0,
+                                Subclause => 0, Subsubclause => 0);
+                           Level := ARM_Contents.Plain_Annex;
+                       elsif 
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Command = 
Labeled_Revised_Normative_Annex then
+                           Format_Object.Clause_Number :=
+                               (Section   => 
Format_Object.Clause_Number.Section, -- Will be set elsewhere.
+                                Clause    => 0,
+                                Subclause => 0, Subsubclause => 0);
+                           Level := ARM_Contents.Normative_Annex;
+                       else -- 
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Command = 
Labeled_Revised_Informative_Annex then
+                           Format_Object.Clause_Number :=
+                               (Section   => 
Format_Object.Clause_Number.Section, -- Will be set elsewhere.
+                                Clause    => 0,
+                                Subclause => 0, Subsubclause => 0);
+                           Level := ARM_Contents.Informative_Annex;
+                       end if;
+
+                       begin
+                           declare
+                               Clause_Number : constant String :=
+                                   ARM_Contents.Lookup_Clause_Number 
(New_Title);
+
+                               New_Disposition : ARM_Output.Change_Type;
+                               Old_Disposition : ARM_Output.Change_Type;
+                               use type ARM_Output.Change_Type;
+                           begin
+                               Check_End_Paragraph; -- End any paragraph that 
we're in.
+                               -- Check that the section numbers match the 
title:
+                               if Ada.Characters.Handling.To_Lower (New_Title) 
/=
+                                  Ada.Characters.Handling.To_Lower 
(ARM_Contents.Lookup_Title (
+                                     Level, Format_Object.Clause_Number)) then
+                                   Ada.Text_IO.Put_Line ("** Unable to match 
title with section numbers, line " & ARM_Input.Line_String (Input_Object));
+                               end if;
+
+                               Calc_Change_Disposition (
+                                   Format_Object => Format_Object,
+                                   Version => Version,
+                                   Operation => ARM_Output.Insertion,
+                                   Text_Kind => New_Disposition);
+                                   -- Note: We use insertion here because
+                                   -- we want to decide what to do with
+                                   -- the New part.
+                               Calc_Change_Disposition (
+                                   Format_Object => Format_Object,
+                                   Version => Initial_Version,
+                                   Operation => ARM_Output.Insertion,
+                                   Text_Kind => Old_Disposition);
+
+                               if New_Disposition = Do_Not_Display_Text then
+                                   if Old_Disposition = Do_Not_Display_Text 
then
+                                       null; -- Show nothing.
+                                   elsif Old_Disposition = ARM_Output.None then
+                                       -- Use the old only:
+                                       ARM_Output.Clause_Header (Output_Object,
+                                           Old_Title(1..Old_Title_Length),
+                                           Level => Level,
+                                           Clause_Number => Clause_Number,
+                                           Top_Level_Subdivision_Name => 
Format_Object.Top_Level_Subdivision_Name);
+                                   elsif Old_Disposition = ARM_Output.Deletion 
then
+                                       raise Program_Error; -- A deletion 
inside of an insertion command!
+                                   else -- an insertion of the Old. Show this 
like an added item:
+                                       ARM_Output.Revised_Clause_Header 
(Output_Object,
+                                           New_Header_Text => 
Old_Title(1..Old_Title_Length),
+                                           Old_Header_Text => "",
+                                           Level => Level,
+                                           Version => Initial_Version,
+                                           Old_Version => '0',
+                                           Clause_Number => Clause_Number,
+                                           Top_Level_Subdivision_Name => 
Format_Object.Top_Level_Subdivision_Name);
+                                   end if;
+                               elsif New_Disposition = ARM_Output.None then
+                                   -- Use the new only:
+                                   ARM_Output.Clause_Header (Output_Object,
+                                       New_Title(1..New_Title_Length),
+                                       Level => Level,
+                                       Clause_Number => Clause_Number,
+                                       Top_Level_Subdivision_Name => 
Format_Object.Top_Level_Subdivision_Name);
+                                       -- In this case, we have no sane
+                                       -- way to show the old, so we hope that
+                                       -- isn't expected.
+--!!Debug:
+--Ada.Text_IO.Put_Line ("Start clause " & Clause_Number & " -- " & 
New_Title(1..New_Title_Length));
+                               elsif New_Disposition = ARM_Output.Deletion then
+                                   raise Program_Error; -- A deletion inside 
of an insertion command!
+                               else -- Insertion.
+                                   if Format_Object.Changes = 
ARM_Format.New_Changes or else
+                                       Old_Disposition = Do_Not_Display_Text 
then
+                                       ARM_Output.Revised_Clause_Header 
(Output_Object,
+                                           New_Header_Text => 
New_Title(1..New_Title_Length),
+                                           Old_Header_Text => " ",
+                                           Level => Level,
+                                           Version => Version,
+                                           Old_Version => '0',
+                                           Clause_Number => Clause_Number,
+                                           Top_Level_Subdivision_Name => 
Format_Object.Top_Level_Subdivision_Name);
+                                   elsif Old_Disposition = ARM_Output.None then
+                                       -- Show old without any insertion marks:
+                                       ARM_Output.Revised_Clause_Header 
(Output_Object,
+                                           New_Header_Text => 
New_Title(1..New_Title_Length),
+                                           Old_Header_Text => 
Old_Title(1..Old_Title_Length),
+                                           Level => Level,
+                                           Version => Version,
+                                           Old_Version => '0',
+                                           Clause_Number => Clause_Number,
+                                           Top_Level_Subdivision_Name => 
Format_Object.Top_Level_Subdivision_Name);
+                                   elsif Old_Disposition = ARM_Output.Deletion 
then
+                                       raise Program_Error; -- A deletion 
inside of an insertion command!
+                                   else -- An insertion of the Old item:
+                                       ARM_Output.Revised_Clause_Header 
(Output_Object,
+                                           New_Header_Text => 
New_Title(1..New_Title_Length),
+                                           Old_Header_Text => 
Old_Title(1..Old_Title_Length),
+                                           Level => Level,
+                                           Version => Version,
+                                           Old_Version => Initial_Version,
+                                           Clause_Number => Clause_Number,
+                                           Top_Level_Subdivision_Name => 
Format_Object.Top_Level_Subdivision_Name);
+                                   end if;
+--!!Debug:
+--Ada.Text_IO.Put_Line ("Start clause " & Clause_Number & " -- " & 
New_Title(1..New_Title_Length));
+                               end if;
+                           end;
+                       exception
+                           when ARM_Contents.Not_Found_Error =>
+                               Ada.Text_IO.Put_Line ("** Unable to find header 
reference, line " & ARM_Input.Line_String (Input_Object));
+                               Ada.Text_IO.Put_Line ("   Looking for " & 
New_Title(1..New_Title_Length));
+                       end;
+                       -- Reset the paragraph numbers:
+                       Format_Object.Next_Paragraph := 1;
+                       Format_Object.Next_Insert_Para := 1;
+                       Format_Object.Next_AARM_Sub := 'a';
+                       if Format_Object.Use_ISO_2004_Note_Format then
+                           -- Reset the note number:
+                           Format_Object.Next_Note := 1;
+                       elsif 
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Command = 
Labeled_Revised_Section or else
+                             
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Command = 
Labeled_Revised_Annex or else
+                             
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Command = 
Labeled_Revised_Informative_Annex or else
+                             
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Command = 
Labeled_Revised_Normative_Annex then
+                           -- Reset the note number, only for sections:
+                           Format_Object.Next_Note := 1;
+                       end if;
+                       -- Reset the subhead:
+                       Format_Object.Last_Paragraph_Subhead_Type := Plain;
+                       Format_Object.Next_Paragraph_Format_Type := Plain;
+
+                       Format_State.Nesting_Stack_Ptr := 
Format_State.Nesting_Stack_Ptr - 1;
+--Ada.Text_IO.Put_Line (" &Unstack (Header)");
+                   end;
+
+               when Labeled_Added_Annex |
+                    Labeled_Added_Informative_Annex |
+                    Labeled_Added_Normative_Annex |
+                    Labeled_Added_Section |
+                    Labeled_Added_Clause |
+                    Labeled_Added_Subclause |
+                    Labeled_Added_Subsubclause =>
+                   -- Load the title into the Title string:
+                   declare
+                       New_Title : ARM_Contents.Title_Type;
+                       New_Title_Length : Natural;
+                       Ch : Character;
+                       Version : ARM_Contents.Change_Version_Type := '0';
+                       Level : ARM_Contents.Level_Type;
+                       Disposition : ARM_Output.Change_Type;
+                       use type ARM_Output.Change_Type;
+                   begin
+                       Get_Change_Version (Is_First => True,
+                                           Version => Version);
+                       ARM_Input.Check_Parameter_Name (Input_Object,
+                           Param_Name => "Name" & 
(5..ARM_Input.Command_Name_Type'Last => ' '),
+                           Is_First => False,
+                           Param_Close_Bracket => Ch);
+                       if Ch /= ' ' then
+                           -- There is a parameter:
+                           -- Load the new title into the Title string:
+                           ARM_Input.Copy_to_String_until_Close_Char (
+                               Input_Object,
+                               Ch,
+                               New_Title, New_Title_Length);
+                           New_Title(New_Title_Length+1 .. New_Title'Last) :=
+                               (others => ' ');
+                       end if;
+                       ARM_Input.Get_Char (Input_Object, Ch);
+                       if Ch /= 
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Close_Char then
+                           Ada.Text_IO.Put_Line ("  ** Bad close for 
Labeled_Added_(Sub)Clause on line " & ARM_Input.Line_String (Input_Object));
+                           ARM_Input.Replace_Char (Input_Object);
+                       end if;
+
+                       Calc_Change_Disposition (
+                           Format_Object => Format_Object,
+                           Version => Version,
+                           Operation => ARM_Output.Insertion,
+                           Text_Kind => Disposition);
+
+                       if Disposition = Do_Not_Display_Text then
+                           null; -- Ignore this; it isn't numbered or anything.
+                       elsif Disposition = ARM_Output.Deletion then
+                           raise Program_Error; -- A deletion inside of an 
insertion command!
+                       else
+                           if 
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Command = 
Labeled_Added_Subclause then
+                               Format_Object.Clause_Number :=
+                                   (Section   => 
Format_Object.Clause_Number.Section,
+                                    Clause    => 
Format_Object.Clause_Number.Clause,
+                                    Subclause => 
Format_Object.Clause_Number.Subclause + 1,
+                                    Subsubclause => 0);
+                               Level := ARM_Contents.Subclause;
+                           elsif 
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Command = 
Labeled_Added_Subsubclause then
+                               Format_Object.Clause_Number.Subsubclause :=
+                                   Format_Object.Clause_Number.Subsubclause + 
1;
+                               Level := ARM_Contents.Subsubclause;
+                           elsif 
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Command = 
Labeled_Added_Clause then
+                               Format_Object.Clause_Number :=
+                                   (Section   => 
Format_Object.Clause_Number.Section,
+                                    Clause    => 
Format_Object.Clause_Number.Clause + 1,
+                                    Subclause => 0, Subsubclause => 0);
+                               Level := ARM_Contents.Clause;
+                           elsif 
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Command = 
Labeled_Added_Section then
+                               Format_Object.Clause_Number :=
+                                   (Section   => 
Format_Object.Clause_Number.Section, -- Will be set elsewhere.
+                                    Clause    => 0,
+                                    Subclause => 0, Subsubclause => 0);
+                               Level := ARM_Contents.Section;
+                           elsif 
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Command = 
Labeled_Added_Annex then
+                               Format_Object.Clause_Number :=
+                                   (Section   => 
Format_Object.Clause_Number.Section, -- Will be set elsewhere.
+                                    Clause    => 0,
+                                    Subclause => 0, Subsubclause => 0);
+                               Level := ARM_Contents.Plain_Annex;
+                           elsif 
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Command = 
Labeled_Added_Normative_Annex then
+                               Format_Object.Clause_Number :=
+                                   (Section   => 
Format_Object.Clause_Number.Section, -- Will be set elsewhere.
+                                    Clause    => 0,
+                                    Subclause => 0, Subsubclause => 0);
+                               Level := ARM_Contents.Normative_Annex;
+                           else -- 
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Command = 
Labeled_Added_Informative_Annex then
+                               Format_Object.Clause_Number :=
+                                   (Section   => 
Format_Object.Clause_Number.Section, -- Will be set elsewhere.
+                                    Clause    => 0,
+                                    Subclause => 0, Subsubclause => 0);
+                               Level := ARM_Contents.Informative_Annex;
+                           end if;
+
+                           begin
+                               declare
+                                   Clause_Number : constant String :=
+                                       ARM_Contents.Lookup_Clause_Number 
(New_Title);
+
+                               begin
+                                   if Disposition = ARM_Output.None then
+                                       -- Normal reference:
+                                       Check_End_Paragraph; -- End any 
paragraph that we're in.
+                                       ARM_Output.Clause_Header (Output_Object,
+                                           New_Title(1..New_Title_Length),
+                                           Level => Level,
+                                           Clause_Number => Clause_Number,
+                                           Top_Level_Subdivision_Name => 
Format_Object.Top_Level_Subdivision_Name);
+                                   else -- Insertion.
+                                       Check_End_Paragraph; -- End any 
paragraph that we're in.
+                                       ARM_Output.Revised_Clause_Header 
(Output_Object,
+                                           New_Header_Text => 
New_Title(1..New_Title_Length),
+                                           Old_Header_Text => "",
+                                           Level => Level,
+                                           Version => Version,
+                                           Old_Version => '0',
+                                           Clause_Number => Clause_Number,
+                                           Top_Level_Subdivision_Name => 
Format_Object.Top_Level_Subdivision_Name);
+                                   end if;
+
+                                   -- Check that the section numbers match the 
title:
+                                   if Ada.Characters.Handling.To_Lower 
(New_Title) /=
+                                      Ada.Characters.Handling.To_Lower 
(ARM_Contents.Lookup_Title (
+                                         Level, Format_Object.Clause_Number)) 
then
+                                       Ada.Text_IO.Put_Line ("** Unable to 
match title with section numbers, line " & ARM_Input.Line_String 
(Input_Object));
+                                   end if;
+--!!Debug:
+--Ada.Text_IO.Put_Line ("Start clause " & Clause_Number & " -- " & 
New_Title(1..New_Title_Length));
+                               end;
+                           exception
+                               when ARM_Contents.Not_Found_Error =>
+                                   Ada.Text_IO.Put_Line ("** Unable to find 
header reference, line " & ARM_Input.Line_String (Input_Object));
+                                   Ada.Text_IO.Put_Line ("   Looking for " & 
New_Title(1..New_Title_Length));
+                           end;
+                           -- Reset the paragraph numbers:
+                           Format_Object.Next_Paragraph := 1;
+                           Format_Object.Next_Insert_Para := 1;
+                           Format_Object.Next_AARM_Sub := 'a';
+                           if Format_Object.Use_ISO_2004_Note_Format then
+                               -- Reset the note number:
+                               Format_Object.Next_Note := 1;
+                           elsif 
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Command = 
Labeled_Added_Section or else
+                                 
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Command = 
Labeled_Added_Annex or else
+                                 
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Command = 
Labeled_Added_Informative_Annex or else
+                                 
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Command = 
Labeled_Added_Normative_Annex then
+                               -- Reset the note number, only for sections:
+                               Format_Object.Next_Note := 1;
+                           end if;
+                           -- Reset the subhead:
+                           Format_Object.Last_Paragraph_Subhead_Type := Plain;
+                           Format_Object.Next_Paragraph_Format_Type := Plain;
+                       end if;
+
+                       Format_State.Nesting_Stack_Ptr := 
Format_State.Nesting_Stack_Ptr - 1;
+--Ada.Text_IO.Put_Line (" &Unstack (Header)");
+                   end;
+
+               when Labeled_Deleted_Clause |
+                    Labeled_Deleted_Subclause |
+                    Labeled_Deleted_Subsubclause =>
+                   -- Load the title into the Title string:
+                   declare
+                       Old_Title : ARM_Contents.Title_Type;
+                       Old_Title_Length : Natural;
+                       Ch : Character;
+                       Version : ARM_Contents.Change_Version_Type := '0';
+                       Level : ARM_Contents.Level_Type;
+                       Disposition : ARM_Output.Change_Type;
+                       use type ARM_Output.Change_Type;
+                   begin
+                       Get_Change_Version (Is_First => True,
+                                           Version => Version);
+                       ARM_Input.Check_Parameter_Name (Input_Object,
+                           Param_Name => "Name" & 
(5..ARM_Input.Command_Name_Type'Last => ' '),
+                           Is_First => False,
+                           Param_Close_Bracket => Ch);
+                       if Ch /= ' ' then
+                           -- There is a parameter:
+                           -- Load the new title into the Title string:
+                           ARM_Input.Copy_to_String_until_Close_Char (
+                               Input_Object,
+                               Ch,
+                               Old_Title, Old_Title_Length);
+                           Old_Title(Old_Title_Length+1 .. Old_Title'Last) :=
+                               (others => ' ');
+                       end if;
+                       ARM_Input.Get_Char (Input_Object, Ch);
+                       if Ch /= 
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Close_Char then
+                           Ada.Text_IO.Put_Line ("  ** Bad close for 
Labeled_Deleted_(Sub)Clause on line " & ARM_Input.Line_String (Input_Object));
+                           ARM_Input.Replace_Char (Input_Object);
+                       end if;
+
+                       Calc_Change_Disposition (
+                           Format_Object => Format_Object,
+                           Version => Version,
+                           Operation => ARM_Output.Deletion,
+                           Text_Kind => Disposition);
+
+--Ada.Text_IO.Put_Line ("Labeled_Deleted disp: " & 
ARM_Output.Change_Type'Image(Disposition));
+--Ada.Text_IO.Put_Line ("  Version:" & Version);
+                       if Disposition = Do_Not_Display_Text then
+                           null; -- Ignore this; it isn't numbered or anything.
+                       elsif Disposition = ARM_Output.Insertion then
+                           raise Program_Error; -- An insertion inside of a 
deletion command!
+                       elsif Disposition = ARM_Output.Deletion then
+                           -- Format the text as a deletion, but not as a 
header.
+                           Check_End_Paragraph; -- End any paragraph that 
we're in.
+
+                           ARM_Output.Start_Paragraph (Output_Object,
+                               Style => ARM_Output.Title,
+                               Indent => 0,
+                               Number => "");
+                           ARM_Output.Text_Format (Output_Object,
+                               Format => (Bold => True,
+                                          Italic => False,
+                                          Font => ARM_Output.Default,
+                                          Size => ARM_Output.Size_Type(-2),
+                                          Color => ARM_Output.Default,
+                                          Change => ARM_Output.Deletion,
+                                          Version => Version,
+                                          Added_Version => '0',
+                                          Location => ARM_Output.Normal));
+                           ARM_Output.Ordinary_Text (Output_Object,
+                               Old_Title(1..Old_Title_Length));
+                           ARM_Output.Text_Format (Output_Object,
+                               ARM_Output.NORMAL_FORMAT);
+                           ARM_Output.End_Paragraph (Output_Object);
+
+                           -- Reset the paragraph numbers: (for the following 
deleted text, presumably also shown).
+                           Format_Object.Next_Paragraph := 1;
+                           Format_Object.Next_Insert_Para := 1;
+                           Format_Object.Next_AARM_Sub := 'a';
+                           if Format_Object.Use_ISO_2004_Note_Format then
+                               -- Reset the note number:
+                               Format_Object.Next_Note := 1;
+                           --elsif 
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Command = 
Labeled_Deleted_Section or else
+                           --      
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Command = 
Labeled_Deleted_Annex or else
+                           --      
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Command = 
Labeled_Deleted_Informative_Annex or else
+                           --      
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Command = 
Labeled_Deleted_Normative_Annex then
+                           --    -- Reset the note number, only for sections: 
(no sections yet)
+                           --    Format_Object.Next_Note := 1;
+                           end if;
+                           -- Reset the subhead:
+                           Format_Object.Last_Paragraph_Subhead_Type := Plain;
+                           Format_Object.Next_Paragraph_Format_Type := Plain;
+                       else -- Disposition = ARM_Output.None then
+                           if 
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Command = 
Labeled_Deleted_Subclause then
+                               Format_Object.Clause_Number :=
+                                   (Section   => 
Format_Object.Clause_Number.Section,
+                                    Clause    => 
Format_Object.Clause_Number.Clause,
+                                    Subclause => 
Format_Object.Clause_Number.Subclause + 1,
+                                    Subsubclause => 0);
+                               Level := ARM_Contents.Subclause;
+                           elsif 
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Command = 
Labeled_Deleted_Subsubclause then
+                               Format_Object.Clause_Number.Subsubclause :=
+                                   Format_Object.Clause_Number.Subsubclause + 
1;
+                               Level := ARM_Contents.Subsubclause;
+                           else 
--Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Command = 
Labeled_Deleted_Clause then
+                               Format_Object.Clause_Number :=
+                                   (Section   => 
Format_Object.Clause_Number.Section,
+                                    Clause    => 
Format_Object.Clause_Number.Clause + 1,
+                                    Subclause => 0, Subsubclause => 0);
+                               Level := ARM_Contents.Clause;
+                           end if;
+
+                           begin
+                               declare
+                                   Clause_Number : constant String :=
+                                       ARM_Contents.Lookup_Clause_Number 
(Old_Title);
+                               begin
+                                   -- Normal reference:
+                                   Check_End_Paragraph; -- End any paragraph 
that we're in.
+                                   ARM_Output.Clause_Header (Output_Object,
+                                       Old_Title(1..Old_Title_Length),
+                                       Level => Level,
+                                       Clause_Number => Clause_Number,
+                                       Top_Level_Subdivision_Name => 
Format_Object.Top_Level_Subdivision_Name);
+                               end;
+
+                               -- Check that the section numbers match the 
title:
+                               if Ada.Characters.Handling.To_Lower (Old_Title) 
/=
+                                  Ada.Characters.Handling.To_Lower 
(ARM_Contents.Lookup_Title (
+                                     Level, Format_Object.Clause_Number)) then
+                                   Ada.Text_IO.Put_Line ("** Unable to match 
title with section numbers, line " & ARM_Input.Line_String (Input_Object));
+                               end if;
+                           exception
+                               when ARM_Contents.Not_Found_Error =>
+                                   Ada.Text_IO.Put_Line ("** Unable to find 
header reference, line " & ARM_Input.Line_String (Input_Object));
+                                   Ada.Text_IO.Put_Line ("   Looking for " & 
Old_Title(1..Old_Title_Length));
+                           end;
+                           -- Reset the paragraph numbers:
+                           Format_Object.Next_Paragraph := 1;
+                           Format_Object.Next_Insert_Para := 1;
+                           Format_Object.Next_AARM_Sub := 'a';
+                           -- Reset the subhead:
+                           Format_Object.Last_Paragraph_Subhead_Type := Plain;
+                           Format_Object.Next_Paragraph_Format_Type := Plain;
+                       end if;
+
+                       Format_State.Nesting_Stack_Ptr := 
Format_State.Nesting_Stack_Ptr - 1;
+--Ada.Text_IO.Put_Line (" &Unstack (Header)");
+                   end;
+
+               when Preface_Section =>
+                   Check_End_Paragraph; -- End any paragraph that we're in.
+                   --ARM_Output.New_Page (Output_Object, 
ARM_Output.Odd_Page_Only);
+                   ARM_Output.Clause_Header (Output_Object,
+                                             Header_Text => "",
+                                             Level => 
ARM_Contents.Unnumbered_Section,
+                                             Clause_Number => "0.99",
+                                             Top_Level_Subdivision_Name => 
Format_Object.Top_Level_Subdivision_Name);
+
+               when Subheading =>
+                   -- This is used in preface sections where no numbers or
+                   -- contents are desired.
+                   Check_End_Paragraph; -- End any paragraph that we're in.
+                   ARM_Output.Start_Paragraph (Output_Object,
+                            Style     => ARM_Output.Wide_Above,
+                            Indent    => 0,
+                            Number    => "",
+                            No_Breaks => True, Keep_with_Next => True);
+                   Format_Object.In_Paragraph := True;
+                   Format_Object.No_Start_Paragraph := False;
+
+                   Format_Object.Text_Format := ARM_Output.NORMAL_FORMAT;
+                   Format_Object.Text_Format.Bold := True;
+                   Format_Object.Text_Format.Font := ARM_Output.Swiss;
+                   Format_Object.Text_Format.Size := 2;
+                   ARM_Output.Text_Format (Output_Object,
+                                           Format_Object.Text_Format);
+
+               when Added_Subheading =>
+                   -- This is used in preface sections where no numbers or
+                   -- contents are desired.
+                   declare
+                       Ch : Character;
+                       Version : ARM_Contents.Change_Version_Type := '0';
+
+                       Disposition : ARM_Output.Change_Type;
+                       use type ARM_Output.Change_Type;
+                   begin
+                       Get_Change_Version (Is_First => True,
+                                           Version => Version);
+                       ARM_Input.Get_Char (Input_Object, Ch);
+                       if Ch /= ',' then
+                           Ada.Text_IO.Put_Line ("  ** Missing comma for 
AddedSubheading on line " & ARM_Input.Line_String (Input_Object));
+                           ARM_Input.Replace_Char (Input_Object);
+                       end if;
+                       
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Change_Version := 
Version;
+
+                       Calc_Change_Disposition (
+                           Format_Object => Format_Object,
+                           Version => Version,
+                           Operation => ARM_Output.Insertion,
+                           Text_Kind => Disposition);
+
+                       if Disposition = Do_Not_Display_Text then
+                           -- Skip the text:
+                           ARM_Input.Skip_until_Close_Char (Input_Object,
+                               
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Close_Char);
+                           ARM_Input.Replace_Char (Input_Object); -- Let the 
normal termination clean this up.
+                       elsif Disposition = ARM_Output.None then
+                           -- Normal text:
+                           ARM_Output.Start_Paragraph (Output_Object,
+                                Style  => ARM_Output.Wide_Above,
+                                Indent => 0,
+                                Number => "",
+                                No_Breaks => True, Keep_with_Next => True);
+                           Format_Object.In_Paragraph := True;
+                           Format_Object.No_Start_Paragraph := False;
+
+                           Format_Object.Text_Format := 
ARM_Output.NORMAL_FORMAT;
+                           Format_Object.Text_Format.Bold := True;
+                           Format_Object.Text_Format.Font := ARM_Output.Swiss;
+                           Format_Object.Text_Format.Size := 2;
+                           ARM_Output.Text_Format (Output_Object,
+                                                   Format_Object.Text_Format);
+                       elsif Disposition = ARM_Output.Deletion then
+                           raise Program_Error; -- A deletion inside of an 
insertion command!
+                       else -- Insertion.
+                           ARM_Output.Start_Paragraph (Output_Object,
+                                Style  => ARM_Output.Wide_Above,
+                                Indent => 0,
+                                Number => "",
+                                No_Breaks => True, Keep_with_Next => True);
+                           Format_Object.In_Paragraph := True;
+                           Format_Object.No_Start_Paragraph := False;
+
+                           Format_Object.Text_Format := 
ARM_Output.NORMAL_FORMAT;
+                           Format_Object.Text_Format.Bold := True;
+                           Format_Object.Text_Format.Font := ARM_Output.Swiss;
+                           Format_Object.Text_Format.Size := 2;
+                           Format_Object.Text_Format.Change := 
ARM_Output.Insertion;
+                           Format_Object.Text_Format.Version := Version;
+                           ARM_Output.Text_Format (Output_Object,
+                                           Format_Object.Text_Format);
+                       end if;
+                   end;
+
+               when Heading =>
+                   -- This is used in preface sections where no numbers or
+                   -- contents are desired.
+                   Check_End_Paragraph; -- End any paragraph that we're in.
+                   ARM_Output.Start_Paragraph (Output_Object,
+                            Style  => ARM_Output.Title,
+                            Indent => 0,
+                            Number => "",
+                            No_Breaks => True, Keep_with_Next => True,
+                            Justification => ARM_Output.Center);
+                   Format_Object.In_Paragraph := True;
+                   Format_Object.No_Start_Paragraph := False;
+
+                   Format_Object.Text_Format := ARM_Output.NORMAL_FORMAT;
+                   Format_Object.Text_Format.Bold := True;
+                   Format_Object.Text_Format.Font := ARM_Output.Swiss;
+                   Format_Object.Text_Format.Size := 0;
+                       -- Note that the size is +3 from the Title format.
+                   ARM_Output.Text_Format (Output_Object,
+                                           Format_Object.Text_Format);
+
+               when Center =>
+                   Check_End_Paragraph; -- End any paragraph that we're in.
+                   ARM_Output.Start_Paragraph (Output_Object,
+                            Style  => ARM_Output.Normal,
+                            Indent => 0,
+                            Number => "",
+                            No_Breaks => True, Keep_with_Next => False,
+                            Justification => ARM_Output.Center);
+                   Format_Object.In_Paragraph := True;
+                   Format_Object.No_Start_Paragraph := False;
+
+               when Right =>
+                   Check_End_Paragraph; -- End any paragraph that we're in.
+                   ARM_Output.Start_Paragraph (Output_Object,
+                            Style  => ARM_Output.Normal,
+                            Indent => 0,
+                            Number => "",
+                            No_Breaks => True, Keep_with_Next => False,
+                            Justification => ARM_Output.Right);
+                   Format_Object.In_Paragraph := True;
+                   Format_Object.No_Start_Paragraph := False;
+
+               when Ref_Section | Ref_Section_Number =>
+                   -- Load the title into the Title string:
+                   declare
+                       Ch : Character;
+                       Title : ARM_Contents.Title_Type;
+                       Title_Length : Natural;
+                   begin
+                       ARM_Input.Get_Char (Input_Object, Ch);
+                       Title_Length := 0;
+                       while Ch /= 
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Close_Char loop
+                           Title_Length := Title_Length + 1;
+                           Title(Title_Length) := Ch;
+                           ARM_Input.Get_Char (Input_Object, Ch);
+                       end loop;
+                       Title(Title_Length+1 .. Title'Last) :=
+                           (others => ' ');
+
+                       begin
+                           declare
+                               Clause_Number_Text : constant String :=
+                                   ARM_Contents.Lookup_Clause_Number (Title);
+                           begin
+                               if 
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Command = 
Ref_Section then
+                                   Check_Paragraph;
+                                   ARM_Output.Clause_Reference (Output_Object,
+                                       Text => Clause_Number_Text,
+                                       Clause_Number => Clause_Number_Text);
+                                   ARM_Output.Ordinary_Text (Output_Object, ", 
");
+                                   -- Was: (To match the Ada 95 Standard)
+                                   --ARM_Output.Special_Character 
(Output_Object, ARM_Output.Left_Quote);
+                                   --ARM_Output.Special_Character 
(Output_Object, ARM_Output.Left_Quote);
+                                   ARM_Output.Special_Character 
(Output_Object, ARM_Output.Left_Double_Quote);
+                                   if Format_Object.Change_Version < '1' or 
else
+                                      Format_Object.Changes = 
ARM_Format.Old_Only then
+                                       -- Use original version:
+                                       declare
+                                           Clause_Number : 
ARM_Contents.Clause_Number_Type;
+                                       begin
+                                           ARM_Contents.Make_Clause 
(Clause_Number_Text,
+                                               Clause_Number);
+                                           ARM_Output.Clause_Reference 
(Output_Object,
+                                               Text => Ada.Strings.Fixed.Trim (
+                                                   
ARM_Contents.Lookup_Old_Title (
+                                                           
ARM_Contents.Lookup_Level (Title),
+                                                           Clause_Number),
+                                                           Ada.Strings.Right),
+                                               Clause_Number => 
Clause_Number_Text);
+                                       end;
+                                   else
+                                       -- Use new version. We don't have 
version numbers for these yet.
+                                       ARM_Output.Clause_Reference 
(Output_Object,
+                                           Text => Title(1..Title_Length),
+                                           Clause_Number => 
Clause_Number_Text);
+                                   end if;
+                                   -- Was: (To match the Ada 95 Standard)
+                                   --ARM_Output.Special_Character 
(Output_Object, ARM_Output.Right_Quote);
+                                   --ARM_Output.Special_Character 
(Output_Object, ARM_Output.Right_Quote);
+                                   ARM_Output.Special_Character 
(Output_Object, ARM_Output.Right_Double_Quote);
+                               else -- 
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Command = 
Ref_Section_Number then
+                                   Check_Paragraph;
+                                   ARM_Output.Clause_Reference (Output_Object,
+                                       Text => Clause_Number_Text,
+                                       Clause_Number => Clause_Number_Text);
+                               end if;
+                               Format_Object.Last_Non_Space := True;
+                           end;
+                       exception
+                           when ARM_Contents.Not_Found_Error =>
+                               Ada.Text_IO.Put_Line ("** Unable to find 
section reference, line " & ARM_Input.Line_String (Input_Object));
+                               Ada.Text_IO.Put_Line ("   Looking for " & 
Title(1..Title_Length));
+                       end;
+                   end;
+
+                   Format_State.Nesting_Stack_Ptr := 
Format_State.Nesting_Stack_Ptr - 1;
+--Ada.Text_IO.Put_Line (" &Unstack (Section Reference)");
+
+               when Ref_Section_by_Number =>
+                   -- Load the number into the Number string:
+                   declare
+                       Ch : Character;
+                       Number : String(1..20);
+                       Number_Length : Natural;
+                   begin
+                       ARM_Input.Get_Char (Input_Object, Ch);
+                       Number_Length := 0;
+                       while Ch /= 
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Close_Char loop
+                           Number_Length := Number_Length + 1;
+                           Number(Number_Length) := Ch;
+                           ARM_Input.Get_Char (Input_Object, Ch);
+                       end loop;
+                       Number(Number_Length+1 .. Number'Last) :=
+                           (others => ' ');
+
+                       Check_Paragraph;
+                       ARM_Output.Clause_Reference (Output_Object,
+                           Text => Number(1..Number_Length),
+                           Clause_Number => Number(1..Number_Length));
+                       Format_Object.Last_Non_Space := True;
+                       -- No checking here.
+                   end;
+
+                   Format_State.Nesting_Stack_Ptr := 
Format_State.Nesting_Stack_Ptr - 1;
+--Ada.Text_IO.Put_Line (" &Unstack (Section Num Reference)");
+
+               -- Link commands:
+               when Local_Target =>
+                   -- @LocalTarget{Target=[<target-text>],Text=[<text>]}
+                   declare
+                       Close_Ch : Character;
+                       Target : String(1..40);
+                       Target_Len : Natural;
+                       Text : String(1..100);
+                       Text_Len : Natural;
+                   begin
+                       ARM_Input.Check_Parameter_Name (Input_Object,
+                           Param_Name => "Target" & 
(7..ARM_Input.Command_Name_Type'Last => ' '),
+                           Is_First => True,
+                           Param_Close_Bracket => Close_Ch);
+                       if Close_Ch /= ' ' then
+                           -- Save URL:
+                           ARM_Input.Copy_to_String_until_Close_Char (
+                               Input_Object,
+                               Close_Ch,
+                               Target,
+                               Target_Len);
+                       -- else no parameter. Weird.
+                       end if;
+
+                       ARM_Input.Check_Parameter_Name (Input_Object,
+                           Param_Name => "Text" & 
(5..ARM_Input.Command_Name_Type'Last => ' '),
+                           Is_First => False,
+                           Param_Close_Bracket => Close_Ch);
+                       if Close_Ch /= ' ' then
+                           -- Save name:
+                           ARM_Input.Copy_to_String_until_Close_Char (
+                               Input_Object,
+                               Close_Ch,
+                               Text,
+                               Text_Len);
+                       -- else no parameter. Weird.
+                       end if;
+
+                       Check_Paragraph;
+                       ARM_Output.Local_Target (Output_Object,
+                           Text => Text(1..Text_Len),
+                           Target => Target(1..Target_Len));
+                       if Text_Len /= 0 and then Text(Text_Len) /= ' ' then
+                           Format_Object.Last_Non_Space := True;
+                       end if;
+                   end;
+                   -- Leave the command end marker, let normal processing
+                   -- get rid of it.
+
+               when Local_Link =>
+                   -- 
@LocalLink{Target=[<target-text>],Sec=[<title>],Text=[<text>]}
+                   declare
+                       Close_Ch : Character;
+                       Target : String(1..40);
+                       Target_Len : Natural;
+                       Text : String(1..100);
+                       Text_Len : Natural;
+                       Title : ARM_Contents.Title_Type;
+                       Title_Length : Natural;
+                   begin
+                       ARM_Input.Check_Parameter_Name (Input_Object,
+                           Param_Name => "Target" & 
(7..ARM_Input.Command_Name_Type'Last => ' '),
+                           Is_First => True,
+                           Param_Close_Bracket => Close_Ch);
+                       if Close_Ch /= ' ' then
+                           -- Save URL:
+                           ARM_Input.Copy_to_String_until_Close_Char (
+                               Input_Object,
+                               Close_Ch,
+                               Target,
+                               Target_Len);
+                       -- else no parameter. Weird.
+                       end if;
+
+                       ARM_Input.Check_Parameter_Name (Input_Object,
+                           Param_Name => "Sec" & 
(4..ARM_Input.Command_Name_Type'Last => ' '),
+                           Is_First => False,
+                           Param_Close_Bracket => Close_Ch);
+                       if Close_Ch /= ' ' then
+                           -- Save URL:
+                           ARM_Input.Copy_to_String_until_Close_Char (
+                               Input_Object,
+                               Close_Ch,
+                               Title,
+                               Title_Length);
+                           Title(Title_Length+1 .. Title'Last) :=
+                               (others => ' ');
+                       -- else no parameter. Weird.
+                       end if;
+
+                       ARM_Input.Check_Parameter_Name (Input_Object,
+                           Param_Name => "Text" & 
(5..ARM_Input.Command_Name_Type'Last => ' '),
+                           Is_First => False,
+                           Param_Close_Bracket => Close_Ch);
+                       if Close_Ch /= ' ' then
+                           -- Save name:
+                           ARM_Input.Copy_to_String_until_Close_Char (
+                               Input_Object,
+                               Close_Ch,
+                               Text,
+                               Text_Len);
+                       -- else no parameter. Weird.
+                       end if;
+
+                       begin
+                           declare
+                               Clause_Number_Text : constant String :=
+                                   ARM_Contents.Lookup_Clause_Number (Title);
+                           begin
+                               Check_Paragraph;
+                               ARM_Output.Local_Link (Output_Object,
+                                   Text => Text(1..Text_Len),
+                                   Target => Target(1..Target_Len),
+                                   Clause_Number => Clause_Number_Text);
+                               if Text_Len /= 0 and then Text(Text_Len) /= ' ' 
then
+                                   Format_Object.Last_Non_Space := True;
+                               end if;
+                           end;
+                       exception
+                           when ARM_Contents.Not_Found_Error =>
+                               Ada.Text_IO.Put_Line ("** Unable to find 
section in local link, line " & ARM_Input.Line_String (Input_Object));
+                               Ada.Text_IO.Put_Line ("   Looking for " & 
Title(1..Title_Length));
+                       end;
+                   end;
+                   -- Leave the command end marker, let normal processing
+                   -- get rid of it.
+
+               when URL_Link =>
+                   -- @URLLink{URL=[<URL>],Text=[<text>]}
+                   declare
+                       Close_Ch : Character;
+                       URL : String(1..80);
+                       URL_Len : Natural;
+                       Text : String(1..100);
+                       Text_Len : Natural;
+                   begin
+                       ARM_Input.Check_Parameter_Name (Input_Object,
+                           Param_Name => "URL" & 
(4..ARM_Input.Command_Name_Type'Last => ' '),
+                           Is_First => True,
+                           Param_Close_Bracket => Close_Ch);
+                       if Close_Ch /= ' ' then
+                           -- Save URL:
+                           ARM_Input.Copy_to_String_until_Close_Char (
+                               Input_Object,
+                               Close_Ch,
+                               URL,
+                               URL_Len);
+                       -- else no parameter. Weird.
+                       end if;
+
+                       ARM_Input.Check_Parameter_Name (Input_Object,
+                           Param_Name => "Text" & 
(5..ARM_Input.Command_Name_Type'Last => ' '),
+                           Is_First => False,
+                           Param_Close_Bracket => Close_Ch);
+                       if Close_Ch /= ' ' then
+                           -- Save name:
+                           ARM_Input.Copy_to_String_until_Close_Char (
+                               Input_Object,
+                               Close_Ch,
+                               Text,
+                               Text_Len);
+                       -- else no parameter. Weird.
+                       end if;
+
+                       Check_Paragraph;
+                       ARM_Output.URL_Link (Output_Object,
+                           Text => Text(1..Text_Len),
+                           URL => URL(1..URL_Len));
+                       if Text_Len /= 0 and then Text(Text_Len) /= ' ' then
+                           Format_Object.Last_Non_Space := True;
+                       end if;
+                   end;
+                   -- Leave the command end marker, let normal processing
+                   -- get rid of it.
+
+               when AI_Link =>
+                   -- @AILink{AI=[<AI>],Text=[<text>]}
+                   declare
+                       Close_Ch : Character;
+                       AI : String(1..30);
+                       AI_Len : Natural;
+                       Text : String(1..100);
+                       Text_Len : Natural;
+                   begin
+                       ARM_Input.Check_Parameter_Name (Input_Object,
+                           Param_Name => "AI" & 
(3..ARM_Input.Command_Name_Type'Last => ' '),
+                           Is_First => True,
+                           Param_Close_Bracket => Close_Ch);
+                       if Close_Ch /= ' ' then
+                           -- Save AI:
+                           ARM_Input.Copy_to_String_until_Close_Char (
+                               Input_Object,
+                               Close_Ch,
+                               AI,
+                               AI_Len);
+                       -- else no parameter. Weird.
+                       end if;
+
+                       ARM_Input.Check_Parameter_Name (Input_Object,
+                           Param_Name => "Text" & 
(5..ARM_Input.Command_Name_Type'Last => ' '),
+                           Is_First => False,
+                           Param_Close_Bracket => Close_Ch);
+                       if Close_Ch /= ' ' then
+                           -- Save name:
+                           ARM_Input.Copy_to_String_until_Close_Char (
+                               Input_Object,
+                               Close_Ch,
+                               Text,
+                               Text_Len);
+                       -- else no parameter. Weird.
+                       end if;
+
+                       Check_Paragraph;
+                       ARM_Output.AI_Reference (Output_Object,
+                           Text => Text(1..Text_Len),
+                           AI_Number => AI(1..AI_Len));
+                       if Text_Len /= 0 and then Text(Text_Len) /= ' ' then
+                           Format_Object.Last_Non_Space := True;
+                       end if;
+                   end;
+                   -- Leave the command end marker, let normal processing
+                   -- get rid of it.
+
+               -- Change commands:
+
+               when Change =>
+                   -- This command is of the form:
+                   -- @chg{[version=<Version>],new=[<new text>],old=[<old 
text>]}.
+                   -- where the parameter names (other than version) are
+                   -- optional (but highly recommended), and the curly and
+                   -- square brackets can be any of the allowed bracketing 
characters.
+                   -- We have to process this in parts, in order that the
+                   -- text can be handled normally.
+
+                   declare
+                       Ch : Character;
+                       Saw_Version : Boolean;
+                   begin
+                       -- Check for the optional "Version" parameter:
+                       ARM_Input.Get_Char (Input_Object, Ch);
+                       ARM_Input.Replace_Char (Input_Object);
+                       if Ch = 'V' or else Ch = 'v' then
+                           -- There is a Version parameter, grab it.
+                           Get_Change_Version (Is_First => True,
+                               Version => 
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Change_Version);
+                               -- Read a parameter named "Version".
+                           Saw_Version := True;
+                       else
+                           
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Change_Version := 
'1';
+                           Saw_Version := False;
+                       end if;
+
+                       -- Save the current state:
+                       
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Prev_Change :=
+                           Format_Object.Text_Format.Change;
+                       
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Prev_Change_Version 
:=
+                           Format_Object.Text_Format.Version;
+                       
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Prev_Added_Change_Version
 :=
+                           Format_Object.Text_Format.Added_Version;
+
+                       -- Check and handle the "New" parameter:
+                       ARM_Input.Check_Parameter_Name (Input_Object,
+                           Param_Name => "New" & 
(4..ARM_Input.Command_Name_Type'Last => ' '),
+                           Is_First => not Saw_Version,
+                           Param_Close_Bracket => Ch);
+                       if Ch /= ' ' then
+                           -- There is a parameter:
+
+                           -- Stack the parameter so we can process the end:
+                           Set_Nesting_for_Parameter
+                               (Command => Change_Param_New,
+                                Close_Ch => Ch);
+
+                           Format_Object.In_Change := True;
+
+                           -- Note: We can't use Calc_Change_Disposition here,
+                           -- because it isn't intended to work on possibly
+                           -- nested calls like these.
+
+                           -- Now, handle the parameter:
+                           if 
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr-1).Change_Version >
+                              Format_Object.Change_Version then
+                               -- Ignore any changes with version numbers 
higher than
+                               -- the current maximum.
+                               -- Skip the text:
+                               ARM_Input.Skip_until_Close_Char (Input_Object,
+                                   
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Close_Char);
+                               ARM_Input.Replace_Char (Input_Object); -- Let 
the normal termination clean this up.
+                           else
+                               case Format_Object.Changes is
+                                   when ARM_Format.Old_Only =>
+                                       -- Skip the text:
+                                       ARM_Input.Skip_until_Close_Char 
(Input_Object,
+                                           
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Close_Char);
+                                       ARM_Input.Replace_Char (Input_Object); 
-- Let the normal termination clean this up.
+                                   when ARM_Format.New_Only =>
+                                       if ARM_Database."=" 
(Format_Object.Next_Paragraph_Change_Kind,
+                                          ARM_Database.Deleted) or else
+                                          ARM_Database."=" 
(Format_Object.Next_Paragraph_Change_Kind,
+                                          
ARM_Database.Deleted_Inserted_Number) or else
+                                          ARM_Database."=" 
(Format_Object.Next_Paragraph_Change_Kind,
+                                          
ARM_Database.Deleted_No_Delete_Message) or else
+                                          ARM_Database."=" 
(Format_Object.Next_Paragraph_Change_Kind,
+                                          
ARM_Database.Deleted_Inserted_Number_No_Delete_Message) then
+                                           -- In a deleted paragraph, call 
Check_Paragraph
+                                           -- to trigger the "deleted 
paragraph" message.
+                                           -- (Otherwise, this never happens.)
+                                           Check_Paragraph;
+                                       -- else null; -- Nothing special to do.
+                                       end if;
+                                   when ARM_Format.Show_Changes |
+                                        ARM_Format.New_Changes =>
+                                       if 
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr-1).Change_Version <
+                                           Format_Object.Base_Change_Version 
then
+                                           -- Just normal output text.
+                                           if ARM_Database."=" 
(Format_Object.Next_Paragraph_Change_Kind,
+                                              ARM_Database.Deleted) or else
+                                              ARM_Database."=" 
(Format_Object.Next_Paragraph_Change_Kind,
+                                              
ARM_Database.Deleted_Inserted_Number) or else
+                                              ARM_Database."=" 
(Format_Object.Next_Paragraph_Change_Kind,
+                                              
ARM_Database.Deleted_No_Delete_Message) or else
+                                              ARM_Database."=" 
(Format_Object.Next_Paragraph_Change_Kind,
+                                              
ARM_Database.Deleted_Inserted_Number_No_Delete_Message) then
+                                               -- In a deleted paragraph, call 
Check_Paragraph
+                                               -- to trigger the "deleted 
paragraph" message.
+                                               -- (Otherwise, this never 
happens.)
+                                               Check_Paragraph;
+                                           -- else null; -- Nothing special to 
do.
+                                           end if;
+                                       else
+                                           ARM_Input.Get_Char (Input_Object, 
Ch);
+                                           ARM_Input.Replace_Char 
(Input_Object);
+                                           
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr-1).Was_Text :=
+                                               Ch /= 
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Close_Char;
+                                           if 
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr-1).Was_Text then
+                                               -- Non-empty text; Calculate 
new change state (current is insertion):
+                                               Check_Paragraph; -- Change the 
state *after* outputting the paragraph header.
+                                               case 
Format_Object.Text_Format.Change is
+                                                   when ARM_Output.Insertion | 
ARM_Output.None =>
+                                                       
Format_Object.Text_Format.Change := ARM_Output.Insertion;
+                                                       
Format_Object.Text_Format.Version :=
+                                                          
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr-1).Change_Version;
+                                                       
Format_Object.Text_Format.Added_Version := '0';
+                                                   when ARM_Output.Deletion =>
+                                                       
Format_Object.Text_Format.Change := ARM_Output.Both;
+                                                       
Format_Object.Text_Format.Added_Version := -- The insertion should be older.
+                                                          
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr-1).Change_Version;
+                                                       -- .Text_Format.Version 
is unchanged.
+                                                   when ARM_Output.Both =>
+                                                       
Format_Object.Text_Format.Change := ARM_Output.Both;
+                                                       
Format_Object.Text_Format.Added_Version := -- The insertion should be older.
+                                                          
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr-1).Change_Version;
+                                                       -- .Text_Format.Version 
is unchanged.
+                                               end case;
+                                               ARM_Output.Text_Format 
(Output_Object,
+                                                                       
Format_Object.Text_Format); -- Set style.
+                                           -- else no text, so don't bother.
+                                           end if;
+                                       end if;
+                               end case;
+                           end if;
+                       -- else no parameter. Weird.
+                       end if;
+                   end;
+
+               when Change_Param_Old | Change_Param_New =>
+                   -- These can't get here; they represent the parameters of
+                   -- "Change" and can't be generated explicitly.
+                   Ada.Text_IO.Put_Line ("  ** Change parameter command?? on 
line " & ARM_Input.Line_String (Input_Object));
+
+               when Change_Added | Change_Deleted =>
+                   -- 
@ChgAdded{Version=[<Version>],[NoPrefix=[T|F],][NoParanum=[T|F],]
+                   --     
[Type=[Leading|Trailing|Normal],][Keepnext=[T|F],]Text=[text]}
+                   -- 
@ChgDeleted{Version=[<Version>],[NoPrefix=[T|F],][NoParanum=[T|F],]
+                   --     
[Type=[Leading|Trailing|Normal],][Keepnext=[T|F],]Text=[text]}
+                   -- Whole paragraph change. These let us modify the AARM 
prefix
+                   -- (like "Reason:" or "Discussion:", and also let us
+                   -- conditionally handle paragraph formatting (which
+                   -- otherwise would come too late).
+                   declare
+                       Which_Param : ARM_Input.Param_Num;
+                       Close_Ch : Character;
+
+                       NoPrefix, Noparanum, Keepnext : Boolean := False;
+                       Space_After : ARM_Output.Space_After_Type := 
ARM_Output.Normal;
+
+                       Disposition : ARM_Output.Change_Type;
+                       use type ARM_Output.Change_Type;
+
+                       function Read_Boolean (Close_Ch : in Character;
+                                              Name : in String) return Boolean 
is
+                           -- Read a Boolean parameter for a parameter already
+                           -- opened and ending with Close_Ch.
+                           -- Name is the name of the parameter; for error 
messages only.
+                           Ch : Character;
+                           Result : Boolean;
+                       begin
+                           ARM_Input.Get_Char (Input_Object, Ch);
+                           case Ch is
+                               when 'F' | 'f' | 'N' | 'n' =>
+                                   Result := False;
+                               when 'T' | 't' | 'Y' | 'y' =>
+                                   Result := True;
+                               when others =>
+                                   Ada.Text_IO.Put_Line ("  ** Bad value for 
boolean parameter " &
+                                       Name & " on line " & 
ARM_Input.Line_String (Input_Object));
+                           end case;
+                           ARM_Input.Get_Char (Input_Object, Ch);
+                           if Ch /= Close_Ch then
+                               Ada.Text_IO.Put_Line ("  ** Bad close for 
boolean parameter " &
+                                   Name & " on line " & ARM_Input.Line_String 
(Input_Object));
+                               ARM_Input.Replace_Char (Input_Object);
+                           end if;
+                           return Result;
+                       end Read_Boolean;
+
+                       function Read_Type (Close_Ch : in Character) return 
ARM_Output.Space_After_Type is
+                           -- Read the Type parameter.
+                           Type_Name : ARM_Input.Command_Name_Type;
+                           Ch : Character;
+                           Result : ARM_Output.Space_After_Type := 
ARM_Output.Normal;
+                       begin
+                           -- Get the type word:
+                           Arm_Input.Get_Name (Input_Object, Type_Name);
+                           ARM_Input.Get_Char (Input_Object, Ch);
+                           if Ch /= Close_Ch then
+                               Ada.Text_IO.Put_Line ("  ** Bad close for Type 
on line " & ARM_Input.Line_String (Input_Object));
+                               ARM_Input.Replace_Char (Input_Object);
+                           end if;
+                           if Ada.Characters.Handling.To_Lower 
(Ada.Strings.Fixed.Trim (Type_Name, Ada.Strings.Right)) =
+                               "leading" then
+                               Result := ARM_Output.Narrow;
+                           elsif Ada.Characters.Handling.To_Lower 
(Ada.Strings.Fixed.Trim (Type_Name, Ada.Strings.Right)) =
+                               "trailing" then
+                               Result := ARM_Output.Wide;
+                           elsif Ada.Characters.Handling.To_Lower 
(Ada.Strings.Fixed.Trim (Type_Name, Ada.Strings.Right)) =
+                               "normal" then
+                               Result := ARM_Output.Normal;
+                           else
+                               Ada.Text_IO.Put_Line ("  ** Bad type for 
paragraph type: " &
+                                   Ada.Strings.Fixed.Trim (Type_Name, 
Ada.Strings.Right) &
+                                   " on line " & ARM_Input.Line_String 
(Input_Object));
+                           end if;
+                           return Result;
+                       end Read_Type;
+
+                   begin
+                       -- These are not allowed in other @Chg commands.
+                       if Format_Object.In_Change then
+                           Ada.Text_IO.Put_Line ("** ChgAdded/ChgDeleted 
nested in other Chg, line " & ARM_Input.Line_String (Input_Object));
+                       end if;
+
+                       Get_Change_Version (Is_First => True,
+                           Version => 
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Change_Version);
+                           -- Read a parameter named "Version".
+
+                       loop
+                           -- Handle the optional parameters; stop on Text.
+                           ARM_Input.Check_One_of_Parameter_Names 
(Input_Object,
+                               Param_Name_1 => "NoPrefix" & 
(9..ARM_Input.Command_Name_Type'Last => ' '),
+                               Param_Name_2 => "NoParanum" & 
(10..ARM_Input.Command_Name_Type'Last => ' '),
+                               Param_Name_3 => "Type" & 
(5..ARM_Input.Command_Name_Type'Last => ' '),
+                               Param_Name_4 => "Keepnext" & 
(9..ARM_Input.Command_Name_Type'Last => ' '),
+                               Param_Name_5 => "Text" & 
(5..ARM_Input.Command_Name_Type'Last => ' '),
+                               Is_First => False,
+                               Param_Found => Which_Param,
+                               Param_Close_Bracket => Close_Ch);
+
+                           if Which_Param = 1 and then Close_Ch /= ' ' then
+                               NoPrefix := Read_Boolean (Close_Ch, "NoPrefix");
+                           elsif Which_Param = 2 and then Close_Ch /= ' ' then
+                               NoParanum := Read_Boolean (Close_Ch, 
"NoParanum");
+                           elsif Which_Param = 3 and then Close_Ch /= ' ' then
+                               Space_After := Read_Type (Close_Ch);
+                           elsif Which_Param = 4 and then Close_Ch /= ' ' then
+                               Keepnext := Read_Boolean (Close_Ch, "KeepNext");
+                           else
+                               exit; -- We found "Text" (or an error)
+                           end if;
+                       end loop;
+
+                       if 
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Command = 
Change_Added and then
+                          Close_Ch /= ' ' then
+                           -- Generate an insertion, there is a Text parameter.
+
+                           Calc_Change_Disposition (
+                               Format_Object => Format_Object,
+                               Version => 
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Change_Version,
+                               Operation => ARM_Output.Insertion,
+                               Text_Kind => Disposition);
+
+                           -- Stack the parameter so we can process the end:
+                           Set_Nesting_for_Parameter
+                               (Command => Change_Added_Param,
+                                Close_Ch => Close_Ch);
+
+                           Format_Object.In_Change := True;
+
+                           if Disposition = Do_Not_Display_Text then
+                               -- Skip the text:
+                               ARM_Input.Skip_until_Close_Char (Input_Object,
+                                   
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Close_Char);
+                               ARM_Input.Replace_Char (Input_Object); -- Let 
the normal termination clean this up.
+                           elsif Disposition = ARM_Output.None then
+                               -- Display the text normally.
+                               Format_Object.No_Prefix := NoPrefix;
+                               Format_Object.No_Para_Num := NoParanum;
+                               Format_Object.Keep_with_Next := KeepNext;
+                               Format_Object.Space_After := Space_After;
+                           elsif Disposition = ARM_Output.Deletion then
+                               raise Program_Error; -- A deletion inside of an 
insertion command!
+                           else -- Insertion.
+                               Format_Object.No_Prefix := NoPrefix;
+                               Format_Object.No_Para_Num := NoParanum;
+                               Format_Object.Keep_with_Next := KeepNext;
+                               Format_Object.Space_After := Space_After;
+                               -- We assume non-empty text and no outer 
changes;
+                               -- set new change state:
+                               Format_Object.Text_Format.Change := 
ARM_Output.Insertion;
+                               Format_Object.Text_Format.Version :=
+                                  
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr-1).Change_Version;
+                               Format_Object.Text_Format.Added_Version := '0';
+                               Check_Paragraph; -- Change the state *before* 
outputting the
+                                                -- paragraph header, so the 
AARM prefix is included.
+                               ARM_Output.Text_Format (Output_Object,
+                                                       
Format_Object.Text_Format); -- Reset style.
+                           end if;
+
+                       elsif 
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Command = 
Change_Deleted and then
+                          Close_Ch /= ' ' then
+                           -- Generate a deletion.
+
+                           Calc_Change_Disposition (
+                               Format_Object => Format_Object,
+                               Version => 
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Change_Version,
+                               Operation => ARM_Output.Deletion,
+                               Text_Kind => Disposition);
+
+                           -- Stack the parameter so we can process the end:
+                           Set_Nesting_for_Parameter
+                               (Command => Change_Deleted_Param,
+                                Close_Ch => Close_Ch);
+
+                           Format_Object.In_Change := True;
+
+                           if Disposition = Do_Not_Display_Text then
+                               -- Skip the text:
+                               ARM_Input.Skip_until_Close_Char (Input_Object,
+                                   
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Close_Char);
+                               ARM_Input.Replace_Char (Input_Object); -- Let 
the normal termination clean this up.
+                               if ARM_Database."=" 
(Format_Object.Next_Paragraph_Change_Kind,
+                                  ARM_Database.Deleted) or else
+                                  ARM_Database."=" 
(Format_Object.Next_Paragraph_Change_Kind,
+                                  ARM_Database.Deleted_Inserted_Number) or else
+                                  ARM_Database."=" 
(Format_Object.Next_Paragraph_Change_Kind,
+                                  ARM_Database.Deleted_No_Delete_Message) or 
else
+                                  ARM_Database."=" 
(Format_Object.Next_Paragraph_Change_Kind,
+                                  
ARM_Database.Deleted_Inserted_Number_No_Delete_Message) then
+                                   -- In a deleted paragraph, call 
Check_Paragraph
+                                   -- to trigger the "deleted paragraph" 
message and
+                                   -- increment the paragraph number.
+                                   -- (Otherwise, this may never happen.)
+                                   Format_Object.No_Para_Num := NoParanum;
+                                   Check_Paragraph;
+                               -- else null; -- Nothing special to do.
+                               end if;
+                           elsif Disposition = ARM_Output.None then
+                               -- Display the text normally.
+                               Format_Object.No_Prefix := NoPrefix;
+                               Format_Object.No_Para_Num := NoParanum;
+                               Format_Object.Keep_with_Next := KeepNext;
+                               Format_Object.Space_After := Space_After;
+                           elsif Disposition = ARM_Output.Insertion then
+                               raise Program_Error; -- An insertion inside of 
a deletion command!
+                           else -- Deletion.
+                               if Format_Object.Changes = 
ARM_Format.New_Changes then
+                                   -- Special case: we ignore the deleted 
text, but mark its presence.
+                                   -- We assume that the text is non-empty;
+                                   -- set the new change state.
+                                   -- Note: We ignore the formatting here!
+                                   Format_Object.No_Prefix := True;
+                                   Format_Object.No_Para_Num := NoParanum;
+                                   Format_Object.Text_Format.Change := 
ARM_Output.Deletion;
+                                   Format_Object.Text_Format.Version :=
+                                      
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr-1).Change_Version;
+                                   Format_Object.Text_Format.Added_Version := 
'0';
+                                   Check_Paragraph; -- Output the paragraph 
headers *after* changing the state,
+                                       -- so that AARM headers are marked.
+                                   ARM_Output.Text_Format (Output_Object,
+                                                           
Format_Object.Text_Format); -- Reset style.
+
+                                   ARM_Output.Ordinary_Character 
(Output_Object, ' ');
+                                   -- Skip the text (we're not going to output 
it):
+                                   ARM_Input.Skip_until_Close_Char 
(Input_Object, Close_Ch);
+                                   ARM_Input.Replace_Char (Input_Object); -- 
Let the normal termination clean this up.
+
+                               else -- Normal.
+                                   -- We assume that the text is non-empty;
+                                   -- set the new change state and formatting.
+                                   Format_Object.No_Prefix := NoPrefix;
+                                   Format_Object.No_Para_Num := NoParanum;
+                                   Format_Object.Keep_with_Next := KeepNext;
+                                   Format_Object.Space_After := Space_After;
+
+                                   Format_Object.Text_Format.Change := 
ARM_Output.Deletion;
+                                   Format_Object.Text_Format.Version :=
+                                      
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr-1).Change_Version;
+                                   Format_Object.Text_Format.Added_Version := 
'0';
+                                   Check_Paragraph; -- Output the paragraph 
headers *after* changing the state,
+                                       -- so that AARM headers are marked.
+                                   ARM_Output.Text_Format (Output_Object,
+                                                           
Format_Object.Text_Format); -- Reset style.
+                               end if;
+                           end if;
+                       -- else no parameter; previous error.
+                       end if;
+                   end;
+
+               when Change_Added_Param | Change_Deleted_Param =>
+                   -- These can't get here; they represent the parameter of
+                   -- "Change_Added" and "Change_Deleted" and can't be 
generated explicitly.
+                   Ada.Text_IO.Put_Line ("  ** Change_xxx parameter command?? 
on line " & ARM_Input.Line_String (Input_Object));
+
+               when Table_Param_Caption | Table_Param_Header | 
Table_Param_Body =>
+                   -- These can't get here; they represent the parameters of
+                   -- "Table" and can't be generated explicitly.
+                   Ada.Text_IO.Put_Line ("  ** Table parameter command?? on 
line " & ARM_Input.Line_String (Input_Object));
+
+               when Syntax_Rule_RHS =>
+                   -- This can't get here; it represents the second parameter 
of
+                   -- "Syn" and can't be generated explicitly.
+                   Ada.Text_IO.Put_Line ("  ** Syntax parameter command?? on 
line " & ARM_Input.Line_String (Input_Object));
+
+               when Glossary_Text_Param =>
+                   -- This can't get here; it represents the second parameter 
of
+                   -- "ToGlossary" and can't be generated explicitly.
+                   Ada.Text_IO.Put_Line ("  ** Glossary parameter command?? on 
line " & ARM_Input.Line_String (Input_Object));
+
+               when Attribute_Text_Param =>
+                   -- This can't get here; it represents the third parameter of
+                   -- "Attribute" and can't be generated explicitly.
+                   Ada.Text_IO.Put_Line ("  ** Attribute parameter command?? 
on line " & ARM_Input.Line_String (Input_Object));
+
+               when Change_Impdef_Text_Param =>
+                   -- This can't get here; it represents the third parameter of
+                   -- "ChgImpldef" and can't be generated explicitly.
+                   Ada.Text_IO.Put_Line ("  ** Impdef parameter command?? on 
line " & ARM_Input.Line_String (Input_Object));
+
+               when Change_Impladv_Text_Param =>
+                   -- This can't get here; it represents the third parameter of
+                   -- "ChgImpladvice" and can't be generated explicitly.
+                   Ada.Text_IO.Put_Line ("  ** Impladv parameter command?? on 
line " & ARM_Input.Line_String (Input_Object));
+
+               when Change_Docreq_Text_Param =>
+                   -- This can't get here; it represents the third parameter of
+                   -- "ChgDocReq" and can't be generated explicitly.
+                   Ada.Text_IO.Put_Line ("  ** Docreq parameter command?? on 
line " & ARM_Input.Line_String (Input_Object));
+
+               when Change_AspectDesc_Text_Param =>
+                   -- This can't get here; it represents the fourth parameter 
of
+                   -- "ChgAspectDesc" and can't be generated explicitly.
+                   Ada.Text_IO.Put_Line ("  ** AspectDesc parameter command?? 
on line " & ARM_Input.Line_String (Input_Object));
+
+               when Change_Prefix_Text_Param =>
+                   -- This can't get here; it represents the second parameter 
of
+                   -- "ChgPrefixType" and can't be generated explicitly.
+                   Ada.Text_IO.Put_Line ("  ** ChgPrefix parameter command?? 
on line " & ARM_Input.Line_String (Input_Object));
+
+               when Change_Reference =>
+                   -- This command is of the form:
+                   -- @chgref{Version=[<version>], Kind=(<kind>)
+                   --   {,Ref=(<DR_Number>)}{,ARef=(<AI_Number>)}}
+                   -- where <version> is a single character, <Kind> is one
+                   -- of Revised, Added, or Deleted, followed by zero or more
+                   -- DR references, and finally zero or more AI references.
+                   -- As usual, any of the allowed bracketing characters can
+                   -- be used.
+
+                   declare
+                       Ch : Character;
+                       Kind : ARM_Database.Paragraph_Change_Kind_Type;
+                       Version : ARM_Contents.Change_Version_Type;
+                       Display_It : Boolean;
+                   begin
+                       Get_Change_Version (Is_First => True,
+                           Version => Version);
+                           -- Read a parameter named "Version".
+
+                       Get_Change_Kind (Kind);
+                           -- Read a parameter named "Kind".
+
+                       if Version <= Format_Object.Change_Version then
+                           Format_Object.Next_Paragraph_Version := Version;
+                           Format_Object.Next_Paragraph_Change_Kind := Kind;
+                           if (ARM_Database."=" (Kind, 
ARM_Database.Deleted_No_Delete_Message) or else
+                               ARM_Database."=" (Kind, 
ARM_Database.Deleted_Inserted_Number_No_Delete_Message)) and then
+                              ARM_Format."=" (Format_Object.Changes, 
ARM_Format.New_Only) then
+                               -- In this case, display nothing, period.
+                               Display_It := False;
+                               -- Check if any Ref's already exist; remove them
+                               -- if they do. %% Ugly: This is needed if
+                               -- a paragraph is first revised, then deleted,
+                               -- as in 4.6. There ought to be a better way
+                               -- of handling this, not sure what it is.
+                               Dump_References (Format_Object.References);
+                           elsif (ARM_Database."=" (Kind, 
ARM_Database.Deleted) or else
+                               ARM_Database."=" (Kind, 
ARM_Database.Deleted_Inserted_Number)) and then
+                              ARM_Format."=" (Format_Object.Changes, 
ARM_Format.New_Only) and then
+                               (not Format_Object.Number_Paragraphs) then
+                               -- No delete messages ever in this case, so
+                               -- display nothing, period.
+                               Display_It := False;
+                               -- Check if any Ref's already exist; see above.
+                               Dump_References (Format_Object.References);
+                           else
+                               Display_It := Format_Object.Include_Annotations;
+                           end if;
+                       else --This reference is too new, ignore it.
+                           Display_It := False;
+                       end if;
+
+                       -- Handle zero or more "Ref" parameters.
+                       loop
+                           ARM_Input.Get_Char (Input_Object, Ch);
+                           if Ch /= ',' then
+                               exit; -- No more commands.
+                           else
+                               ARM_Input.Replace_Char (Input_Object);
+                           end if;
+                           Gen_Ref_or_ARef_Parameter (Display_It);
+                               -- Read (and possibly generate) a "Ref" or 
"ARef" parameter.
+                       end loop;
+
+                       -- Now, close the command.
+                       -- Ch was read when checking for commas, above.
+                       if Ch /= 
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Close_Char then
+                           Ada.Text_IO.Put_Line ("  ** Bad close for Chgref on 
line " & ARM_Input.Line_String (Input_Object));
+                           ARM_Input.Replace_Char (Input_Object);
+                       end if;
+                       Format_State.Nesting_Stack_Ptr := 
Format_State.Nesting_Stack_Ptr - 1;
+                           -- Remove the "Change_Reference" record.
+                   end;
+
+               when Change_Note =>
+                   -- Skip the contents of this command.
+                   ARM_Input.Skip_until_Close_Char (Input_Object,
+                       
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Close_Char);
+                   Format_State.Nesting_Stack_Ptr := 
Format_State.Nesting_Stack_Ptr - 1;
+                       -- Remove the "Change_Note" record.
+
+               when Change_Implementation_Defined =>
+                   -- This command is of the form:
+                   -- @chgimpldef{Version=[<version>], Kind=(<kind>),
+                   --   Text=(<text>)}}
+                   -- where <version> is a single character, <Kind> is one
+                   -- of Revised, Added, or Deleted, and this is followed
+                   -- by the text. As usual, any of the
+                   -- allowed bracketing characters can be used.
+                   Gen_Chg_xxxx (Param_Cmd => Change_Impdef_Text_Param,
+                                 AARM_Prefix => "Implementation defined: ");
+
+               when Change_Implementation_Advice =>
+                   -- This command is of the form:
+                   -- @chgimpladvice{Version=[<version>], Kind=(<kind>),
+                   --   Text=(<text>)}}
+                   -- where <version> is a single character, <Kind> is one
+                   -- of Revised, Added, or Deleted, and this is followed
+                   -- by the text. As usual, any of the
+                   -- allowed bracketing characters can be used.
+                   Gen_Chg_xxxx (Param_Cmd => Change_Impladv_Text_Param,
+                                 AARM_Prefix => "Implementation Advice: ");
+
+               when Change_Documentation_Requirement =>
+                   -- This command is of the form:
+                   -- @chgdocreq{Version=[<version>], Kind=(<kind>),
+                   --   Text=(<text>)}}
+                   -- where <version> is a single character, <Kind> is one
+                   -- of Revised, Added, or Deleted, and this is followed
+                   -- by the text. As usual, any of the
+                   -- allowed bracketing characters can be used.
+                   Gen_Chg_xxxx (Param_Cmd => Change_Docreq_Text_Param,
+                                 AARM_Prefix => "Documentation Requirement: ");
+
+               when Change_Aspect_Description =>
+                   -- This command is of the form:
+                   -- @chgaspectdesc{Version=[<version>], Kind=(<kind>),
+                   --   Aspect=[<name>],Text=(<text>)}}
+                   -- where <version> is a single character, <Kind> is one
+                   -- of Revised, Added, or Deleted, <Name> is the aspect
+                   -- name, and this is followed
+                   -- by the text. As usual, any of the
+                   -- allowed bracketing characters can be used.
+                   Gen_Chg_xxxx (Param_Cmd => Change_AspectDesc_Text_Param,
+                                 AARM_Prefix => "Aspect Description for ");
+
+               when Change_Attribute =>
+                    -- @ChgAttribute{Version=[<version>], Kind=(<kind>),
+                    --    Chginannex=[T|F],Leading=[T|F],
+                    --    Prefix=<Prefix>,AttrName=<Name>,
+                    --    {[A]Ref=[<DR_Number>]},Text=<Text>}
+                    -- Defines a changed attribute.
+                   declare
+                       Close_Ch : Character;
+                       Key : ARM_Index.Index_Key;
+                       Chg_in_Annex : Boolean;
+                       Is_Leading : Boolean;
+                       Kind : ARM_Database.Paragraph_Change_Kind_Type;
+                       Version : ARM_Contents.Change_Version_Type;
+                       InitialVersion : ARM_Contents.Change_Version_Type;
+                       Display_Ref : Boolean;
+                       References : Reference_Ptr := null;
+
+
+                       procedure Make_Attribute_Text is
+                           -- Generate the attribute text.
+                           -- Output <Prefix>'<Name> as the hanging text.
+                           -- Generate the needed index entries.
+                       begin
+                           Check_Paragraph;
+                           ARM_Output.Ordinary_Text (Output_Object,
+                                   Format_Object.Attr_Prefix (1 .. 
Format_Object.Attr_Prefix_Len));
+                           ARM_Output.Ordinary_Character (Output_Object, ''');
+                           ARM_Output.Ordinary_Text (Output_Object,
+                                   Format_Object.Attr_Name (1 .. 
Format_Object.Attr_Name_Len));
+                           ARM_Output.End_Hang_Item (Output_Object);
+                           Format_Object.Last_Non_Space := False; -- Treat 
like start of a line.
+
+                           ARM_Index.Add (Term => "attributes",
+                                          Subterm => Format_Object.Attr_Name 
(1 .. Format_Object.Attr_Name_Len),
+                                          Kind => 
ARM_Index.Primary_Term_and_Subterm,
+                                          Clause => Clause_String 
(Format_Object),
+                                          Paragraph => Paragraph_String,
+                                          Key => Key);
+                           ARM_Output.Index_Target (Output_Object, Key);
+
+                           ARM_Index.Add (Term => Format_Object.Attr_Name (1 
.. Format_Object.Attr_Name_Len) & " attribute",
+                                          Kind => ARM_Index.Primary_Term,
+                                          Clause => Clause_String 
(Format_Object),
+                                          Paragraph => Paragraph_String,
+                                          Key => Key);
+                           ARM_Output.Index_Target (Output_Object, Key);
+
+                           Make_References (References, Format_Object, 
Output_Object);
+
+                       end Make_Attribute_Text;
+
+                   begin
+                       Check_End_Paragraph; -- This is always a paragraph end.
+
+                       Get_Change_Version (Is_First => True,
+                           Version => Version);
+                           -- Read a parameter named "Version".
+
+                       Get_Change_Kind (Kind);
+                           -- Read a parameter named "Kind".
+
+                       if Version <= Format_Object.Change_Version then
+                           Format_Object.Next_Paragraph_Version := Version;
+                           Format_Object.Next_Paragraph_Change_Kind := Kind;
+                           if (ARM_Database."=" (Kind, 
ARM_Database.Deleted_No_Delete_Message) or else
+                               ARM_Database."=" (Kind, 
ARM_Database.Deleted_Inserted_Number_No_Delete_Message)) and then
+                              ARM_Format."=" (Format_Object.Changes, 
ARM_Format.New_Only) then
+                               -- In this case, display nothing, period.
+                               Display_Ref := False;
+                           else
+                               Display_Ref := 
Format_Object.Include_Annotations;
+                           end if;
+                       else --This reference is too new, ignore it.
+                           Display_Ref := False;
+                       end if;
+
+                       Get_Boolean ("ChginAnnex" & 
(11..ARM_Input.Command_Name_Type'Last => ' '),
+                                    Chg_in_Annex);
+                           -- Read a boolean parameter.
+
+                       if Chg_in_Annex then
+                           Format_Object.Attr_Change_Kind := Kind;
+                           Format_Object.Attr_Version := Version;
+                       else -- don't save the change info.; it only applies 
here.
+                           Format_Object.Attr_Change_Kind := ARM_Database.None;
+                           Format_Object.Attr_Version := '0';
+                           Format_Object.Attr_Initial_Version := '0';
+                       end if;
+
+                       Get_Boolean ("Leading" & 
(8..ARM_Input.Command_Name_Type'Last => ' '),
+                                    Is_Leading);
+                           -- Read a boolean parameter.
+
+                       if Is_Leading then
+                           Format_Object.Space_After := ARM_Output.Narrow;
+                           Format_Object.Attr_Leading := True;
+                       else
+                           Format_Object.Space_After := ARM_Output.Normal;
+                           Format_Object.Attr_Leading := False;
+                       end if;
+
+                       ARM_Input.Check_Parameter_Name (Input_Object,
+                           Param_Name => "Prefix" & 
(7..ARM_Input.Command_Name_Type'Last => ' '),
+                           Is_First => False,
+                           Param_Close_Bracket => Close_Ch);
+                       if Close_Ch /= ' ' then
+                           -- Save prefix:
+                           ARM_Input.Copy_to_String_until_Close_Char (
+                               Input_Object,
+                               Close_Ch,
+                               Format_Object.Attr_Prefix,
+                               Format_Object.Attr_Prefix_Len);
+                       -- else no parameter. Weird.
+                       end if;
+
+                       ARM_Input.Check_Parameter_Name (Input_Object,
+                           Param_Name => "AttrName" & 
(9..ARM_Input.Command_Name_Type'Last => ' '),
+                           Is_First => False,
+                           Param_Close_Bracket => Close_Ch);
+                       if Close_Ch /= ' ' then
+                           -- Save name:
+                           ARM_Input.Copy_to_String_until_Close_Char (
+                               Input_Object,
+                               Close_Ch,
+                               Format_Object.Attr_Name,
+                               Format_Object.Attr_Name_Len);
+                       -- else no parameter. Weird.
+                       end if;
+
+                       -- Handle the Ref, ARef, and InitialVersion parameters,
+                       -- until the Text parameter shows up.
+
+                       -- Note: If there is no InitialVersion command, use the
+                       -- value of Version.
+                       InitialVersion := Version;
+                       declare
+                           Which_Param : ARM_Input.Param_Num;
+                           Ch          : Character;
+                       begin
+                           loop
+                               ARM_Input.Check_One_of_Parameter_Names 
(Input_Object,
+                                   Param_Name_1 => "Ref" & 
(4..ARM_Input.Command_Name_Type'Last => ' '),
+                                   Param_Name_2 => "ARef" & 
(5..ARM_Input.Command_Name_Type'Last => ' '),
+                                   Param_Name_3 => "InitialVersion" & 
(15..ARM_Input.Command_Name_Type'Last => ' '),
+                                   Param_Name_4 => "Text" & 
(5..ARM_Input.Command_Name_Type'Last => ' '),
+                                   Is_First => False,
+                                   Param_Found => Which_Param,
+                                   Param_Close_Bracket => Close_Ch);
+                               if (Which_Param = 1 or else Which_Param = 2) 
and then
+                                   Close_Ch /= ' ' then
+                                   declare
+                                       Ref_Name : ARM_Input.Command_Name_Type;
+                                       Len : Natural := 0;
+                                       New_Ref, Cursor : Reference_Ptr;
+                                       Ch : Character;
+                                   begin
+                                       -- Get the reference:
+                                       loop
+                                           ARM_Input.Get_Char (Input_Object, 
Ch);
+                                           if Ch /= Close_Ch then
+                                               Len := Len + 1;
+                                               if Len > Ref_Name'Last then
+                                                   Ada.Text_IO.Put_Line ("  ** 
Reference too long on line " & ARM_Input.Line_String (Input_Object));
+                                               else
+                                                   Ref_Name(Len) := Ch;
+                                               end if;
+                                           else -- End of the reference.
+                                               if Len = 0 then
+                                                   Ada.Text_IO.Put_Line ("  ** 
Failed to find reference on line " & ARM_Input.Line_String (Input_Object));
+                                               end if;
+                                               exit;
+                                           end if;
+                                       end loop;
+
+                                       if Display_Ref then
+                                           -- Save a reference for outputting
+                                           -- later.
+                                           New_Ref := Allocate_Reference;
+                                           New_Ref.all := (Ref_Name => 
Ref_Name,
+                                                           Ref_Len => Len,
+                                                           Is_DR_Ref => 
(Which_Param = 1),
+                                                              -- DR reference 
if Param = 1;
+                                                              -- AI reference 
otherwise.
+                                                           Next => null);
+                                           -- Attach this to the *end* of the 
list.
+                                           if References = null then
+                                               References := New_Ref;
+                                           else
+                                               Cursor := References;
+                                               while Cursor.Next /= null loop
+                                                   Cursor := Cursor.next;
+                                               end loop;
+                                               Cursor.Next := New_Ref;
+                                           end if;
+                                       -- else don't display it.
+                                       end if;
+                                   end;
+                               elsif Which_Param = 3 and then Close_Ch /= ' ' 
then
+                                   -- Found InitialVersion
+                                   ARM_Input.Get_Char (Input_Object, Ch);
+                                   InitialVersion := Ch;
+                                   ARM_Input.Get_Char (Input_Object, Ch);
+                                   if Ch /= Close_Ch then
+                                       Ada.Text_IO.Put_Line ("  ** Bad close 
for InitialVersion parameter on line " &
+                                           ARM_Input.Line_String 
(Input_Object));
+                                       ARM_Input.Replace_Char (Input_Object);
+                                   end if;
+                               else
+                                   exit; -- We found "Text" (or an error)
+                               end if;
+                           end loop;
+                       end;
+
+--**Debug:
+--Ada.Text_IO.Put_Line ("ChgAttr on line " & ARM_Input.Line_String 
(Input_Object) &
+--   "; Vers=" & Version & "; InitVer=" & InitialVersion & "; Kind=" & 
ARM_Database.Paragraph_Change_Kind_Type'Image(Format_Object.Attr_Change_Kind));
+                       if ARM_Database."/=" (Format_Object.Attr_Change_Kind, 
ARM_Database.None) then
+                           Format_Object.Attr_Initial_Version := 
InitialVersion;
+                       -- else ChginAnnex is False, don't care about this.
+                       end if;
+
+                       -- How the prefix (attribute name) is handled depends
+                       -- only on the InitialVersion and its relationship
+                       -- to the version we're generating. It does *not*
+                       -- depend on the (current) change kind.
+
+                       if InitialVersion = '0' then
+                           -- Original version, never an insertion.
+                           Make_Attribute_Text;
+                           if Close_Ch /= ' ' then
+                               -- Now, handle the parameter:
+                               -- The text goes to the file *and* is recorded.
+                               Arm_Input.Start_Recording (Input_Object);
+                               -- Stack the parameter so we can process the 
end:
+                               Set_Nesting_for_Parameter
+                                   (Command => Attribute_Text_Param,
+                                    Close_Ch => Close_Ch);
+                           end if;
+
+                       elsif Close_Ch /= ' ' then -- All other cases.
+
+                           -- Stack the parameter so we can process the end:
+                           Set_Nesting_for_Parameter
+                               (Command => Attribute_Text_Param,
+                                Close_Ch => Close_Ch);
+
+                           declare
+                               Disposition : ARM_Output.Change_Type;
+                               use type ARM_Output.Change_Type;
+                           begin
+
+                               Calc_Change_Disposition (
+                                   Format_Object => Format_Object,
+                                   Version   => InitialVersion,
+                                   Operation => ARM_Output.Insertion,
+                                   Text_Kind => Disposition);
+
+                               if Disposition = Do_Not_Display_Text then
+                                   -- Skip the text:
+                                   ARM_Input.Skip_until_Close_Char 
(Input_Object, Close_Ch);
+                                   ARM_Input.Replace_Char (Input_Object); -- 
Let the normal termination clean this up.
+--Ada.Text_IO.Put_Line("--Skip text");
+
+                               elsif Disposition = ARM_Output.None then
+                                   -- Display the text normally.
+                                   Make_Attribute_Text;
+                                   -- Nothing special to do (normal text).
+--Ada.Text_IO.Put_Line("--Normal text");
+
+                               elsif Disposition = ARM_Output.Deletion then
+                                   raise Program_Error; -- A deletion inside 
of an insertion command!
+
+                               else -- Insertion.
+--Ada.Text_IO.Put_Line("--Insertion");
+                                   -- We assume non-empty text and no outer 
changes;
+                                   -- set new change state:
+                                   Format_Object.Text_Format.Change := 
ARM_Output.Insertion;
+                                   Format_Object.Text_Format.Version := 
InitialVersion;
+                                   Format_Object.Text_Format.Added_Version := 
'0';
+                                   Check_Paragraph; -- Change the state 
*before* outputting the
+                                                    -- paragraph header, so 
the AARM prefix is included.
+                                   ARM_Output.Text_Format (Output_Object,
+                                                           
Format_Object.Text_Format);
+                                   Make_Attribute_Text;
+
+                                   -- Reset the state to normal:
+                                   Format_Object.Text_Format.Change := 
ARM_Output.None;
+                                   Format_Object.Text_Format.Version := '0';
+                                   Format_Object.Text_Format.Added_Version := 
'0';
+                                   ARM_Output.Text_Format (Output_Object,
+                                                           
Format_Object.Text_Format);
+                               end if;
+                           end;
+
+                           -- The text goes to the file *and* is recorded.
+                           Arm_Input.Start_Recording (Input_Object);
+
+                       -- else no parameter. Do nothing.
+                       end if;
+                   end;
+
+               when Change_Prefix_Type =>
+                   -- This command is of the form:
+                   -- @chgprefixtype{Version=[<version>], Kind=(<kind>),
+                   --   Text=(<text>)}}
+                   -- where <version> is a single character, <Kind> is one
+                   -- of Revised, Added, or Deleted, and this is followed
+                   -- by the text. As usual, any of the
+                   -- allowed bracketing characters can be used.
+                   declare
+                       Close_Ch : Character;
+                   begin
+                       Get_Change_Version (Is_First => True,
+                                           Version => 
Format_Object.Attr_Prefix_Version);
+                           -- Read a parameter named "Version".
+
+                       Get_Change_Kind (Format_Object.Attr_Prefix_Change_Kind);
+                           -- Read a parameter named "Kind".
+
+                       ARM_Input.Check_Parameter_Name (Input_Object,
+                           Param_Name => "Text" & 
(5..ARM_Input.Command_Name_Type'Last => ' '),
+                           Is_First => False,
+                           Param_Close_Bracket => Close_Ch);
+                       if Close_Ch /= ' ' then
+                           -- Stack it so we can process the end:
+                           Set_Nesting_for_Parameter
+                               (Command => Change_Prefix_Text_Param,
+                                Close_Ch => Close_Ch);
+
+                           ARM_Input.Start_Recording (Input_Object);
+                       -- else no parameter. Weird.
+                       end if;
+                   end;
+
+               when Added_Implementation_Advice_List =>
+                   -- This command is of the form:
+                   -- @AddedImplAdvice{Version=[v]}
+                   declare
+                       Version : ARM_Contents.Change_Version_Type;
+                   begin
+                       Get_Change_Version (Is_First => True,
+                           Version => Version);
+                           -- Read a parameter named "Version".
+                       DB_Report  (Format_Object.ImplAdv_DB,
+                                   ARM_Database.Bullet_List,
+                                   Sorted => True,
+                                   Added_Version => Version);
+                   end;
+
+               when Added_Documentation_Requirements_List =>
+                   -- This command is of the form:
+                   -- @AddedDocReq{Version=[v]}
+                   declare
+                       Version : ARM_Contents.Change_Version_Type;
+                   begin
+                       Get_Change_Version (Is_First => True,
+                           Version => Version);
+                           -- Read a parameter named "Version".
+                       DB_Report  (Format_Object.Docreq_DB,
+                                   ARM_Database.Bullet_List,
+                                   Sorted => True,
+                                   Added_Version => Version);
+                   end;
+
+               when Added_Aspect_Description_List =>
+                   -- This command is of the form:
+                   -- @AddedAspectList{Version=[v]}
+                   declare
+                       Version : ARM_Contents.Change_Version_Type;
+                   begin
+                       Get_Change_Version (Is_First => True,
+                           Version => Version);
+                           -- Read a parameter named "Version".
+                       DB_Report  (Format_Object.Aspect_DB,
+                                   ARM_Database.Hanging_List,
+                                   Sorted => True,
+                                   Added_Version => Version);
+                   end;
+
+               when Latin_1 =>
+                   -- The parameter is the decimal code for the Latin-1
+                   -- character to generate.
+                   declare
+                       Value : String (1..5);
+                       Len : Natural := 0;
+                       Ch : Character;
+                   begin
+                       ARM_Input.Get_Char (Input_Object, Ch);
+                       while Ch /= 
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Close_Char loop
+                           Len := Len + 1;
+                           if Len > Value'Last then
+                               Ada.Text_IO.Put_Line ("  ** Latin-1 value too 
long on line " &
+                                                           
ARM_Input.Line_String (Input_Object));
+                               exit;
+                           end if;
+                           Value(Len) := Ch;
+                           ARM_Input.Get_Char (Input_Object, Ch);
+                       end loop;
+                       Format_State.Nesting_Stack_Ptr := 
Format_State.Nesting_Stack_Ptr - 1;
+                           -- Remove the "Latin-1" record.
+                       Check_Paragraph;
+                       ARM_Output.Ordinary_Character (Output_Object,
+                           Character'Val(Natural'Value(Value(1..Len))));
+                       Format_Object.Last_Non_Space := True;
+                   exception
+                       when Constraint_Error =>
+                           Ada.Text_IO.Put_Line ("  ** Bad Latin-1 value [" &
+                                                 Value(1..Len) & "] on line " &
+                                                       ARM_Input.Line_String 
(Input_Object));
+                   end;
+
+               when Unicode =>
+                   -- The parameter is the decimal code for the Uncode
+                   -- character to generate.
+                   declare
+                       Value : String (1..11);
+                       Len : Natural := 0;
+                       Ch : Character;
+                   begin
+                       ARM_Input.Get_Char (Input_Object, Ch);
+                       while Ch /= 
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Close_Char loop
+                           Len := Len + 1;
+                           if Len > Value'Last then
+                               Ada.Text_IO.Put_Line ("  ** Unicode value too 
long on line " &
+                                                           
ARM_Input.Line_String (Input_Object));
+                               exit;
+                           end if;
+                           Value(Len) := Ch;
+                           ARM_Input.Get_Char (Input_Object, Ch);
+                       end loop;
+                       Format_State.Nesting_Stack_Ptr := 
Format_State.Nesting_Stack_Ptr - 1;
+                           -- Remove the "Unicode" record.
+                       Check_Paragraph;
+                       ARM_Output.Unicode_Character (Output_Object,
+                           ARM_Output.Unicode_Type'Value(Value(1..Len)));
+                       Format_Object.Last_Non_Space := True;
+                   exception
+                       when Constraint_Error =>
+                           Ada.Text_IO.Put_Line ("  ** Bad Unicode value [" &
+                                                 Value(1..Len) & "] on line " &
+                                                       ARM_Input.Line_String 
(Input_Object));
+                   end;
+
+               when Ceiling =>
+                    Check_Paragraph;
+                    ARM_Output.Special_Character (Output_Object, 
ARM_Output.Left_Ceiling);
+                    Format_Object.Last_Non_Space := True;
+
+               when Floor =>
+                    Check_Paragraph;
+                    ARM_Output.Special_Character (Output_Object, 
ARM_Output.Left_Floor);
+                    Format_Object.Last_Non_Space := True;
+
+               when Absolute =>
+                    Check_Paragraph;
+                    ARM_Output.Ordinary_Character (Output_Object, '|');
+                    Format_Object.Last_Non_Space := True;
+
+               when Log =>
+                    Check_Paragraph;
+                    ARM_Output.Ordinary_Text (Output_Object, "log(");
+                    Format_Object.Last_Non_Space := True;
+
+               when Down | Up =>
+                   Ada.Text_IO.Put_Line ("  ** Su(b|per)script can't occur 
directly, line " &
+                       ARM_Input.Line_String (Input_Object));
+
+               when New_Column | New_Page | RM_New_Page | Soft_Page |
+                    No_Prefix | No_Para_Num | Keep_with_Next | Leading | 
Trailing |
+                    Thin_Line | Thick_Line | Table_Last |
+                    Index_List |
+                    Syntax_Summary | Syntax_XRef | Glossary_List |
+                    Attribute_List | Pragma_List | Implementation_Defined_List 
|
+                    Package_List | Type_List | Subprogram_List |
+                    Exception_List | Object_List |
+                    Intro_Name | Syntax_Name | Resolution_Name |
+                    Legality_Name | Static_Name | Link_Name | Run_Name |
+                    Bounded_Name | Erroneous_Name | Req_Name |
+                    Doc_Name | Metrics_Name | Permission_Name | Advice_Name |
+                    Notes_Name | Single_Note_Name | Examples_Name |
+                    Meta_Name | Inconsistent83_Name |
+                    Incompatible83_Name | Extend83_Name | Wording83_Name |
+                    Inconsistent95_Name |
+                    Incompatible95_Name | Extend95_Name | Wording95_Name |
+                    Inconsistent2005_Name |
+                    Incompatible2005_Name | Extend2005_Name | Wording2005_Name 
|
+                    Inconsistent2012_Name |
+                    Incompatible2012_Name | Extend2012_Name | Wording2012_Name 
|
+                    Syntax_Title | Resolution_Title | Legality_Title |
+                    Static_Title | Link_Title | Run_Title | Bounded_Title |
+                    Erroneous_Title | Req_Title | Doc_Title | Metrics_Title |
+                    Permission_Title | Advice_Title | Notes_Title |
+                    Single_Note_Title |
+                    Examples_Title | Meta_Title | Inconsistent83_Title |
+                    Incompatible83_Title | Extend83_Title | Wording83_Title |
+                    Inconsistent95_Title |
+                    Incompatible95_Title | Extend95_Title | Wording95_Title |
+                    Inconsistent2005_Title |
+                    Incompatible2005_Title | Extend2005_Title | 
Wording2005_Title |
+                    Inconsistent2012_Title |
+                    Incompatible2012_Title | Extend2012_Title | 
Wording2012_Title |
+                    EM_Dash | EN_Dash | LT | LE | GT | GE | NE | PI |
+                    Times | PorM | Single_Quote | Thin_Space | Left_Quote |
+                    Right_Quote | Left_Double_Quote | Right_Double_Quote |
+                    Left_Quote_Pair | Right_Quote_Pair | Small_Dotless_I |
+                    Capital_Dotted_I =>
+
+                   -- These commands must not have a parameter.
+                   Ada.Text_IO.Put_Line ("  ** Parameter for " &
+                       Ada.Strings.Fixed.Trim 
(Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Name, 
Ada.Strings.Right) &
+                       ", line " & ARM_Input.Line_String (Input_Object));
+
+               when Unknown =>
+                   Ada.Text_IO.Put_Line ("  ?? Unknown command (skipped) - " &
+                       Ada.Strings.Fixed.Trim 
(Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Name, 
Ada.Strings.Right) &
+                       " on line " & ARM_Input.Line_String (Input_Object));
+           end case;
+       end Process_Command_with_Parameter;
+
+
+       procedure Process_Command_without_Parameter (Name : in 
ARM_Input.Command_Name_Type) is
+           -- Process the start of a command without a parameter. The name
+           -- of the command is Name.
+           procedure Put_Name (Kind : Paragraph_Type) is
+           begin
+               Check_Paragraph;
+               ARM_Output.Ordinary_Text (Output_Object,
+                   
Data.Paragraph_Kind_Name(Kind).Str(1..Data.Paragraph_Kind_Name(Kind).Length));
+               Format_Object.Last_Non_Space := True;
+           end Put_Name;
+
+           procedure Put_Title (Kind : Paragraph_Type) is
+           begin
+               Check_Paragraph;
+               ARM_Output.Ordinary_Text (Output_Object,
+                   
Paragraph_Kind_Title(Kind).Str(1..Paragraph_Kind_Title(Kind).Length));
+               Format_Object.Last_Non_Space := True;
+           end Put_Title;
+
+           procedure Format_Text (Text : in String;
+                                  Text_Name : in String) is
+               -- Note: We use the state of the surrounding call.
+               Input_Object : Arm_String.String_Input_Type;
+               Real_Include_Annotations : Boolean := 
Format_Object.Include_Annotations;
+           begin
+               -- Don't show annotations here:
+                Format_Object.Include_Annotations := False;
+               Arm_String.Open (Input_Object, Text, Text_Name);
+                    -- Open the input object using a string for input.
+               Real_Process (Format_Object, Format_State, Input_Object, 
Output_Object);
+               Arm_String.Close (Input_Object);
+               Format_Object.Include_Annotations := Real_Include_Annotations;
+           end Format_Text;
+
+           procedure DB_Report is new ARM_Database.Report (Format_Text);
+
+           procedure Syn_Report is new ARM_Syntax.Report (Format_Text);
+
+           procedure Syn_XRef is new ARM_Syntax.XRef (Format_Text);
+
+       begin
+           case Command (Name) is
+               when Comment =>
+                   null; -- Harmless, but still junk.
+
+               when No_Prefix =>
+                   Format_Object.No_Prefix := True;
+
+               when No_Para_Num =>
+                   Format_Object.No_Para_Num := True;
+
+               when Keep_with_Next =>
+                   Format_Object.Keep_with_Next := True;
+
+               when Leading =>
+                   Format_Object.Space_After := ARM_Output.Narrow;
+
+               when Trailing =>
+                   Format_Object.Space_After := ARM_Output.Wide;
+
+               when New_Page =>
+                   Check_End_Paragraph; -- End any paragraph that we're in.
+                   ARM_Output.New_Page (Output_Object, ARM_Output.Any_Page);
+
+               when RM_New_Page =>
+                   if not Format_Object.Include_Annotations then
+                       Check_End_Paragraph; -- End any paragraph that we're in.
+                       ARM_Output.New_Page (Output_Object, 
ARM_Output.Any_Page);
+                   -- else do nothing.
+                   end if;
+
+               when Soft_Page =>
+                   Check_Paragraph;
+                   ARM_Output.New_Page (Output_Object, ARM_Output.Soft_Page);
+
+               when New_Column =>
+                   Check_End_Paragraph; -- End any paragraph that we're in.
+                   ARM_Output.New_Column (Output_Object);
+
+               when Thin_Line =>
+                   Check_End_Paragraph;
+                   ARM_Output.Separator_Line (Output_Object, Is_Thin => True);
+
+               when Thick_Line =>
+                   Check_End_Paragraph;
+                   ARM_Output.Separator_Line (Output_Object, Is_Thin => False);
+
+               when Table_Last =>
+                   if Format_Object.Next_Paragraph_Format_Type = In_Table then
+                       -- If in a table, ends the second last row.
+                       ARM_Output.Table_Marker (Output_Object, 
ARM_Output.End_Row_Next_is_Last);
+                       -- Eat the following LF, if any, to avoid confusing
+                       -- row ends:
+                       declare
+                           Ch : Character;
+                       begin
+                           ARM_Input.Get_Char (Input_Object, Ch);
+                           if Ch /= Ascii.LF then
+                               ARM_Input.Replace_Char (Input_Object);
+                           end if;
+                       end;
+                   else
+                       Ada.Text_IO.Put_Line ("  ** @Last command not in table, 
line " & ARM_Input.Line_String (Input_Object));
+                   end if;
+
+               when Index_List =>
+                   -- Generate the index body.
+                   Check_End_Paragraph;
+
+                   ARM_Output.Set_Columns (Output_Object, Number_of_Columns => 
3);
+
+                   ARM_Index.Generate_Index_Body (Output_Object,
+                       Use_Paragraphs => Format_Object.Number_Paragraphs);
+
+                   ARM_Output.Set_Columns (Output_Object, Number_of_Columns => 
1);
+
+               when Syntax_Summary =>
+--Ada.Text_IO.Put_Line ("%% Generate Syntax summary");
+                   Syn_Report;
+
+               when Syntax_XRef =>
+--Ada.Text_IO.Put_Line ("%% Generate Syntax xref");
+                   Syn_XRef;
+
+               when Glossary_List =>
+                   DB_Report  (Format_Object.Glossary_DB,
+                               ARM_Database.Normal_Indexed_List,
+                               Sorted => True);
+
+               when Attribute_List =>
+                   DB_Report  (Format_Object.Attr_DB,
+                               ARM_Database.Hanging_List,
+                               Sorted => True,
+                               No_Deleted_Paragraph_Messages => True);
+
+               when Pragma_List =>
+                   DB_Report  (Format_Object.Pragma_DB,
+                               ARM_Database.Normal_List,
+                               Sorted => True);
+
+               when Implementation_Defined_List =>
+                   DB_Report  (Format_Object.Impdef_DB,
+                               ARM_Database.Bullet_List,
+                               Sorted => True);
+
+               when Package_List =>
+                   Write_Subindex (Format_Object.Package_Index,
+                                   Format_Object,
+                                   Output_Object,
+                                   Minimize_Lines => False);
+
+               when Type_List =>
+                   Write_Subindex (Format_Object.Type_Index,
+                                   Format_Object,
+                                   Output_Object,
+                                   Minimize_Lines => False);
+
+               when Subprogram_List =>
+                   Write_Subindex (Format_Object.Subprogram_Index,
+                                   Format_Object,
+                                   Output_Object,
+                                   Minimize_Lines => True);
+
+               when Exception_List =>
+                   Write_Subindex (Format_Object.Exception_Index,
+                                   Format_Object,
+                                   Output_Object,
+                                   Minimize_Lines => False);
+
+               when Object_List =>
+                   Write_Subindex (Format_Object.Object_Index,
+                                   Format_Object,
+                                   Output_Object,
+                                   Minimize_Lines => True);
+
+               when Text_Begin | Text_End | Redundant | Part | Bold | Italic |
+                    Roman | Swiss | Fixed | Roman_Italic | Shrink | Grow |
+                    Black | Red | Green | Blue |
+                    Keyword | Non_Terminal | Non_Terminal_Format |
+                    Example_Text | Example_Comment |
+                    Up | Down | Tab_Clear | Tab_Set |
+                    New_Page_for_Version | RM_New_Page_for_Version |
+                    Not_ISO_RM_New_Page_for_Version |
+                    ISO_Only_RM_New_Page_for_Version |
+                    New_Column_for_Version |
+                    Table | Picture_Alone | Picture_Inline |
+                    Defn | RootDefn | PDefn | Defn2 | RootDefn2 | PDefn2 |
+                    Index_See | Index_See_Also | See_Other | See_Also |
+                    Index_Root_Unit | Index_Child_Unit | 
Index_Subprogram_Child_Unit |
+                    Index_Type | Index_Subtype |
+                    Index_Subprogram | Index_Exception | Index_Object |
+                    Index_Package | Index_Other | Index_Check |
+                    Index_Attr | Index_Pragma | Index_Aspect |
+                    Syntax_Rule | Syntax_Term | Syntax_Term_Undefined | 
Syntax_Prefix |
+                    Added_Syntax_Rule | Deleted_Syntax_Rule |
+                    To_Glossary | To_Glossary_Also |
+                    Change_To_Glossary | Change_To_Glossary_Also |
+                    Implementation_Defined |
+                    Prefix_Type | Reset_Prefix_Type | Attribute | 
Attribute_Leading |
+                    Pragma_Syntax | Added_Pragma_Syntax | 
Deleted_Pragma_Syntax |
+                    Labeled_Section | Labeled_Section_No_Break |
+                    Labeled_Clause | Labeled_Subclause | Labeled_Subsubclause |
+                    Labeled_Revised_Section | Labeled_Revised_Clause |
+                    Labeled_Revised_Subclause | Labeled_Revised_Subsubclause |
+                    Labeled_Added_Section | Labeled_Added_Clause |
+                    Labeled_Added_Subclause | Labeled_Added_Subsubclause |
+                    Labeled_Deleted_Clause |
+                    Labeled_Deleted_Subclause | Labeled_Deleted_Subsubclause |
+                    Labeled_Annex | Labeled_Revised_Annex | 
Labeled_Added_Annex |
+                    Labeled_Informative_Annex | 
Labeled_Revised_Informative_Annex |
+                    Labeled_Added_Informative_Annex |
+                    Labeled_Normative_Annex | Labeled_Revised_Normative_Annex |
+                    Labeled_Added_Normative_Annex |
+                    Unnumbered_Section | Subheading | Added_Subheading | 
Heading |
+                    Center | Right |
+                    Preface_Section | Ref_Section | Ref_Section_Number | 
Ref_Section_by_Number |
+                    Local_Target | Local_Link | URL_Link | AI_Link |
+                    Change | Change_Reference | Change_Note |
+                    Change_Added | Change_Deleted |
+                    Change_Implementation_Defined |
+                    Change_Implementation_Advice |
+                    Change_Documentation_Requirement |
+                    Change_Aspect_Description |
+                    Added_Implementation_Advice_List |
+                    Added_Documentation_Requirements_List |
+                    Added_Aspect_Description_List |
+                    Change_Attribute |
+                    Change_Prefix_Type |
+                    Latin_1 | Unicode | Ceiling | Floor | Absolute | Log =>
+                   -- These commands must have a parameter.
+                   Ada.Text_IO.Put_Line ("  ** Failed to find parameter for " &
+                       Ada.Strings.Fixed.Trim (Name, Ada.Strings.Right) &
+                       ", line " & ARM_Input.Line_String (Input_Object));
+
+               when Change_Param_Old | Change_Param_New | Change_Added_Param | 
Change_Deleted_Param =>
+                   -- These can't get here; they represent the parameters of
+                   -- "Change" and can't be generated explicitly.
+                   Ada.Text_IO.Put_Line ("  ** Change parameter command?? on 
line " & ARM_Input.Line_String (Input_Object));
+
+               when Table_Param_Caption | Table_Param_Header | 
Table_Param_Body =>
+                   -- These can't get here; they represent the parameters of
+                   -- "Table" and can't be generated explicitly.
+                   Ada.Text_IO.Put_Line ("  ** Table parameter command?? on 
line " & ARM_Input.Line_String (Input_Object));
+
+               when Syntax_Rule_RHS =>
+                   -- This can't get here; it represents the second parameter 
of
+                   -- "Syn" and can't be generated explicitly.
+                   Ada.Text_IO.Put_Line ("  ** Syntax parameter command?? on 
line " & ARM_Input.Line_String (Input_Object));
+
+               when Glossary_Text_Param =>
+                   -- This can't get here; it represents a parameter of
+                   -- "ToGlossary" and can't be generated explicitly.
+                   Ada.Text_IO.Put_Line ("  ** Glossary parameter command?? on 
line " & ARM_Input.Line_String (Input_Object));
+
+               when Attribute_Text_Param =>
+                   -- This can't get here; it represents a parameter of
+                   -- "Attribute" and can't be generated explicitly.
+                   Ada.Text_IO.Put_Line ("  ** Attribute parameter command?? 
on line " & ARM_Input.Line_String (Input_Object));
+
+               when Change_Impdef_Text_Param =>
+                   -- This can't get here; it represents a parameter of
+                   -- "ChgImpldef" and can't be generated explicitly.
+                   Ada.Text_IO.Put_Line ("  ** Impdef parameter command?? on 
line " & ARM_Input.Line_String (Input_Object));
+
+               when Change_Impladv_Text_Param =>
+                   -- This can't get here; it represents a parameter of
+                   -- "ChgImpladv" and can't be generated explicitly.
+                   Ada.Text_IO.Put_Line ("  ** Impladv parameter command?? on 
line " & ARM_Input.Line_String (Input_Object));
+
+               when Change_Docreq_Text_Param =>
+                   -- This can't get here; it represents a parameter of
+                   -- "ChgDocreq" and can't be generated explicitly.
+                   Ada.Text_IO.Put_Line ("  ** DocReq parameter command?? on 
line " & ARM_Input.Line_String (Input_Object));
+
+               when Change_AspectDesc_Text_Param =>
+                   -- This can't get here; it represents a parameter of
+                   -- "ChgAspectDesc" and can't be generated explicitly.
+                   Ada.Text_IO.Put_Line ("  ** AspectDesc parameter command?? 
on line " & ARM_Input.Line_String (Input_Object));
+
+               when Change_Prefix_Text_Param =>
+                   -- This can't get here; it represents a parameter of
+                   -- "ChgPrefixType" and can't be generated explicitly.
+                   Ada.Text_IO.Put_Line ("  ** ChgPrefix parameter command?? 
on line " & ARM_Input.Line_String (Input_Object));
+
+               when Intro_Name =>
+                   Put_Name(Introduction);
+               when Syntax_Name =>
+                   Put_Name(Syntax);
+               when Resolution_Name =>
+                   Put_Name(Resolution);
+               when Legality_Name =>
+                   Put_Name(Legality);
+               when Static_Name =>
+                   Put_Name(Static_Semantics);
+               when Link_Name =>
+                   Put_Name(Link_Time);
+               when Run_Name =>
+                   Put_Name(Run_Time);
+               when Bounded_Name =>
+                   Put_Name(Bounded_Errors);
+               when Erroneous_Name =>
+                   Put_Name(Erroneous);
+               when Req_Name =>
+                   Put_Name(Requirements);
+               when Doc_Name =>
+                   Put_Name(Documentation);
+               when Metrics_Name =>
+                   Put_Name(Metrics);
+               when Permission_Name =>
+                   Put_Name(Permissions);
+               when Advice_Name =>
+                   Put_Name(Advice);
+               when Notes_Name =>
+                   Put_Name(Notes);
+               when Single_Note_Name =>
+                   Put_Name(Single_Note);
+               when Examples_Name =>
+                   Put_Name(Examples);
+               when Meta_Name =>
+                   Put_Name(Language_Design);
+               when Inconsistent83_Name =>
+                   Put_Name(Ada83_Inconsistencies);
+               when Incompatible83_Name =>
+                   Put_Name(Ada83_Incompatibilities);
+               when Extend83_Name =>
+                   Put_Name(Ada83_Extensions);
+               when Wording83_Name =>
+                   Put_Name(Ada83_Wording);
+               when Inconsistent95_Name =>
+                   Put_Name(Ada95_Inconsistencies);
+               when Incompatible95_Name =>
+                   Put_Name(Ada95_Incompatibilities);
+               when Extend95_Name =>
+                   Put_Name(Ada95_Extensions);
+               when Wording95_Name =>
+                   Put_Name(Ada95_Wording);
+               when Inconsistent2005_Name =>
+                   Put_Name(Ada2005_Inconsistencies);
+               when Incompatible2005_Name =>
+                   Put_Name(Ada2005_Incompatibilities);
+               when Extend2005_Name =>
+                   Put_Name(Ada2005_Extensions);
+               when Wording2005_Name =>
+                   Put_Name(Ada2005_Wording);
+               when Inconsistent2012_Name =>
+                   Put_Name(Ada2012_Inconsistencies);
+               when Incompatible2012_Name =>
+                   Put_Name(Ada2012_Incompatibilities);
+               when Extend2012_Name =>
+                   Put_Name(Ada2012_Extensions);
+               when Wording2012_Name =>
+                   Put_Name(Ada2012_Wording);
+
+               when Syntax_Title =>
+                   Put_Title(Syntax);
+               when Resolution_Title =>
+                   Put_Title(Resolution);
+               when Legality_Title =>
+                   Put_Title(Legality);
+               when Static_Title =>
+                   Put_Title(Static_Semantics);
+               when Link_Title =>
+                   Put_Title(Link_Time);
+               when Run_Title =>
+                   Put_Title(Run_Time);
+               when Bounded_Title =>
+                   Put_Title(Bounded_Errors);
+               when Erroneous_Title =>
+                   Put_Title(Erroneous);
+               when Req_Title =>
+                   Put_Title(Requirements);
+               when Doc_Title =>
+                   Put_Title(Documentation);
+               when Metrics_Title =>
+                   Put_Title(Metrics);
+               when Permission_Title =>
+                   Put_Title(Permissions);
+               when Advice_Title =>
+                   Put_Title(Advice);
+               when Notes_Title =>
+                   Put_Title(Notes);
+               when Single_Note_Title =>
+                   Put_Title(Single_Note);
+               when Examples_Title =>
+                   Put_Title(Examples);
+               when Meta_Title =>
+                   Put_Title(Language_Design);
+               when Inconsistent83_Title =>
+                   Put_Title(Ada83_Inconsistencies);
+               when Incompatible83_Title =>
+                   Put_Title(Ada83_Incompatibilities);
+               when Extend83_Title =>
+                   Put_Title(Ada83_Extensions);
+               when Wording83_Title =>
+                   Put_Title(Ada83_Wording);
+               when Inconsistent95_Title =>
+                   Put_Title(Ada95_Inconsistencies);
+               when Incompatible95_Title =>
+                   Put_Title(Ada95_Incompatibilities);
+               when Extend95_Title =>
+                   Put_Title(Ada95_Extensions);
+               when Wording95_Title =>
+                   Put_Title(Ada95_Wording);
+               when Inconsistent2005_Title =>
+                   Put_Title(Ada2005_Inconsistencies);
+               when Incompatible2005_Title =>
+                   Put_Title(Ada2005_Incompatibilities);
+               when Extend2005_Title =>
+                   Put_Title(Ada2005_Extensions);
+               when Wording2005_Title =>
+                   Put_Title(Ada2005_Wording);
+               when Inconsistent2012_Title =>
+                   Put_Title(Ada2012_Inconsistencies);
+               when Incompatible2012_Title =>
+                   Put_Title(Ada2012_Incompatibilities);
+               when Extend2012_Title =>
+                   Put_Title(Ada2012_Extensions);
+               when Wording2012_Title =>
+                   Put_Title(Ada2012_Wording);
+
+               when EM_Dash =>
+                   Check_Paragraph;
+                   ARM_Output.Special_Character (Output_Object, 
ARM_Output.EM_Dash);
+                   Format_Object.Last_Non_Space := True;
+               when EN_Dash =>
+                   Check_Paragraph;
+                   ARM_Output.Special_Character (Output_Object, 
ARM_Output.EN_Dash);
+                   Format_Object.Last_Non_Space := True;
+               when LE =>
+                   Check_Paragraph;
+                   ARM_Output.Special_Character (Output_Object, 
ARM_Output.LEQ);
+                   Format_Object.Last_Non_Space := True;
+               when LT =>
+                   Check_Paragraph;
+                   ARM_Output.Ordinary_Character (Output_Object, '<');
+                   Format_Object.Last_Non_Space := True;
+               when GE =>
+                   Check_Paragraph;
+                   ARM_Output.Special_Character (Output_Object, 
ARM_Output.GEQ);
+                   Format_Object.Last_Non_Space := True;
+               when GT =>
+                   Check_Paragraph;
+                   ARM_Output.Ordinary_Character (Output_Object, '>');
+                   Format_Object.Last_Non_Space := True;
+               when NE =>
+                   Check_Paragraph;
+                   ARM_Output.Special_Character (Output_Object, 
ARM_Output.NEQ);
+                   Format_Object.Last_Non_Space := True;
+               when PI =>
+                   Check_Paragraph;
+                   ARM_Output.Special_Character (Output_Object, ARM_Output.PI);
+                   Format_Object.Last_Non_Space := True;
+               when Times =>
+                   Check_Paragraph;
+                   ARM_Output.Ordinary_Character (Output_Object, 
Character'Val(183)); -- Middle Dot.
+                   Format_Object.Last_Non_Space := True;
+               when PorM =>
+                   Check_Paragraph;
+                   ARM_Output.Ordinary_Character (Output_Object, 
Character'Val(177)); -- Plus or Minus character.
+                   Format_Object.Last_Non_Space := True;
+               when Single_Quote =>
+                   Check_Paragraph;
+                   ARM_Output.Ordinary_Character (Output_Object, '''); -- 
Single quote.
+                   Format_Object.Last_Non_Space := True;
+               when Thin_Space =>
+                   Check_Paragraph;
+                   ARM_Output.Special_Character (Output_Object, 
ARM_Output.Thin_Space);
+                   Format_Object.Last_Non_Space := True;
+               when Small_Dotless_I =>
+                   Check_Paragraph;
+                   ARM_Output.Special_Character (Output_Object, 
ARM_Output.Small_Dotless_I);
+                   Format_Object.Last_Non_Space := True;
+               when Capital_Dotted_I =>
+                   Check_Paragraph;
+                   ARM_Output.Special_Character (Output_Object, 
ARM_Output.Capital_Dotted_I);
+                   Format_Object.Last_Non_Space := True;
+               when Left_Quote =>
+                   Check_Paragraph;
+                   ARM_Output.Special_Character (Output_Object, 
ARM_Output.Left_Quote);
+                   Format_Object.Last_Non_Space := True;
+               when Right_Quote =>
+                   Check_Paragraph;
+                   ARM_Output.Special_Character (Output_Object, 
ARM_Output.Right_Quote);
+                   Format_Object.Last_Non_Space := True;
+               when Left_Double_Quote =>
+                   Check_Paragraph;
+                   ARM_Output.Special_Character (Output_Object, 
ARM_Output.Left_Double_Quote);
+                   Format_Object.Last_Non_Space := True;
+               when Right_Double_Quote =>
+                   Check_Paragraph;
+                   ARM_Output.Special_Character (Output_Object, 
ARM_Output.Right_Double_Quote);
+                   Format_Object.Last_Non_Space := True;
+               when Left_Quote_Pair =>
+                   Check_Paragraph;
+                   -- Was: To match the Ada 95 standard:
+                   --ARM_Output.Special_Character (Output_Object, 
ARM_Output.Left_Quote);
+                   --ARM_Output.Special_Character (Output_Object, 
ARM_Output.Left_Quote);
+                   ARM_Output.Special_Character (Output_Object, 
ARM_Output.Left_Double_Quote);
+                   Format_Object.Last_Non_Space := True;
+               when Right_Quote_Pair =>
+                   Check_Paragraph;
+                   -- Was: To match the Ada 95 standard:
+                   --ARM_Output.Special_Character (Output_Object, 
ARM_Output.Right_Quote);
+                   --ARM_Output.Special_Character (Output_Object, 
ARM_Output.Right_Quote);
+                   ARM_Output.Special_Character (Output_Object, 
ARM_Output.Right_Double_Quote);
+                   Format_Object.Last_Non_Space := True;
+
+               when Unknown =>
+                   Ada.Text_IO.Put_Line ("  ?? Unknown command (skipped) - " &
+                       Ada.Strings.Fixed.Trim (Name, Ada.Strings.Right) &
+                       " on line " & ARM_Input.Line_String (Input_Object));
+           end case;
+       end Process_Command_without_Parameter;
+
+
+       procedure Handle_End_of_Command is
+           -- Unstack and handle the end of Commands.
+
+           procedure Finish_and_DB_Entry (DB : in out 
ARM_Database.Database_Type) is
+               -- Close the text parameter for a number of commands
+               -- (impdef, chgimpdef, chgimpladv, chgdocreg)
+               -- and insert the resulting string into the appropriate DB.
+               Text_Buffer : String (1..ARM_Input.MAX_RECORDING_SIZE);
+               Text_Buffer_Len : Natural;
+
+               function DB_Clause_String return String is
+                   use type ARM_Contents.Section_Number_Type;
+               begin
+                   if Format_Object.Clause_Number.Clause = 0 then
+                       if Format_Object.Clause_Number.Section in 0 .. 9 then
+                           return
+                               Character'Val(Character'Pos('0') +
+                                  Format_Object.Clause_Number.Section) & "";
+                       elsif Format_Object.Clause_Number.Section in 10 .. 19 
then
+                           return "1" &
+                               Character'Val(Character'Pos('0') +
+                                  Format_Object.Clause_Number.Section - 10);
+                       elsif Format_Object.Clause_Number.Section in 20 .. 29 
then
+                           return "2" &
+                               Character'Val(Character'Pos('0') +
+                                  Format_Object.Clause_Number.Section - 20);
+                       elsif Format_Object.Clause_Number.Section = 30 then
+                           return "30";
+                       else --if Format_Object.Clause_Number.Section >= 
ARM_Contents.ANNEX_START then
+                           return Character'Val (Character'Pos('A') +
+                                (Format_Object.Clause_Number.Section -
+                                   ARM_Contents.ANNEX_START)) & "";
+                       end if;
+                   elsif Format_Object.Clause_Number.Subclause = 0 then
+                       return ARM_Contents.Make_Clause_Number (
+                               ARM_Contents.Clause,
+                               Format_Object.Clause_Number);
+                   elsif Format_Object.Clause_Number.Subsubclause = 0 then
+                       return ARM_Contents.Make_Clause_Number (
+                               ARM_Contents.SubClause,
+                               Format_Object.Clause_Number);
+                   else
+                       return ARM_Contents.Make_Clause_Number (
+                               ARM_Contents.SubsubClause,
+                               Format_Object.Clause_Number);
+                   end if;
+               end DB_Clause_String;
+
+               function Sort_Clause_String return String is
+                   Res : String(1..13);
+                   -- Always use the paragraph for sorting:
+               begin
+                   -- The funny encoding to insure proper sorting.
+                   -- (Otherwise "10" sorts before "2".
+                   Res(1) := Character'Val 
(Natural(Format_Object.Clause_Number.Section) + 16#30#);
+                   Res(2) := '.';
+                   Res(3) := Character'Val (Format_Object.Clause_Number.Clause 
+ 16#30#);
+                   Res(4) := '.';
+                   Res(5) := Character'Val 
(Format_Object.Clause_Number.Subclause + 16#30#);
+                   Res(6) := '.';
+                   Res(7) := Character'Val 
(Format_Object.Clause_Number.Subsubclause + 16#30#);
+                   Res(8) := '(';
+                   Res(9) := Character'Val ((Format_Object.Next_Paragraph / 
10) + 16#30#);
+                   Res(10) := Character'Val ((Format_Object.Next_Paragraph mod 
10) + 16#30#);
+                   Res(11) := '.';
+                   Res(12) := Character'Val ((Format_Object.Next_Insert_Para 
mod 10) + 16#30#);
+                   Res(13) := ')';
+                   return Res;
+               end Sort_Clause_String;
+
+               function See_String return String is
+               begin
+                   case Format_Object.Impdef_Info.Change_Kind is
+                       when ARM_Database.None | ARM_Database.Revised |
+                            ARM_Database.Revised_Inserted_Number =>
+                           if Format_Object.Number_Paragraphs and then
+                                Format_Object.Impdef_Info.Command /= Aspect 
then
+                               return " See @RefSecbyNum{" & DB_Clause_String 
& "}(" &
+                                   Format_Object.Impdef_Info.Paragraph_String 
(1..Format_Object.Impdef_Info.Paragraph_Len) &
+                                   ").";
+                           else -- No paragraph numbers.
+                               return " See @RefSecbyNum{" & DB_Clause_String 
& "}.";
+                           end if;
+                       when ARM_Database.Inserted | 
ARM_Database.Inserted_Normal_Number =>
+                           if Format_Object.Number_Paragraphs and then
+                                Format_Object.Impdef_Info.Command /= Aspect 
then
+                               return "@Chg{Version=[" & 
Format_Object.Impdef_Info.Version &
+                                   "], New=[ See @RefSecbyNum{" & 
DB_Clause_String & "}(" &
+                                   Format_Object.Impdef_Info.Paragraph_String 
(1..Format_Object.Impdef_Info.Paragraph_Len) &
+                                   ").],Old=[]}";
+                           else -- No paragraph numbers.
+                               return "@Chg{Version=[" & 
Format_Object.Impdef_Info.Version &
+                                   "], New=[ See @RefSecbyNum{" & 
DB_Clause_String & "}.],Old=[]}";
+                           end if;
+                       when ARM_Database.Deleted |
+                            ARM_Database.Deleted_Inserted_Number |
+                            ARM_Database.Deleted_No_Delete_Message |
+                            
ARM_Database.Deleted_Inserted_Number_No_Delete_Message =>
+                           if Format_Object.Number_Paragraphs and then
+                                Format_Object.Impdef_Info.Command /= Aspect 
then
+                               return "@Chg{Version=[" & 
Format_Object.Impdef_Info.Version &
+                                   "], New=[],Old=[ See @RefSecbyNum{" & 
DB_Clause_String & "}(" &
+                                   Format_Object.Impdef_Info.Paragraph_String 
(1..Format_Object.Impdef_Info.Paragraph_Len) &
+                                   ").]}";
+                           else -- No paragraph numbers.
+                               return "@Chg{Version=[" & 
Format_Object.Impdef_Info.Version &
+                                   "], New=[],Old=[ See @RefSecbyNum{" & 
DB_Clause_String & "}.]}";
+                           end if;
+                   end case;
+               end See_String;
+
+           begin
+               Arm_Input.Stop_Recording_and_Read_Result
+                   (Input_Object, Text_Buffer, Text_Buffer_Len);
+               Text_Buffer_Len := Text_Buffer_Len - 1; -- Remove command close 
character.
+               if not Format_Object.Impdef_Info.Add_to_DB then
+                   null; -- Don't add to the DB
+               elsif Format_Object.Impdef_Info.Command = Aspect then
+                   if Format_Object.Impdef_Info.Initial_Version >= '4' then
+                       -- ** Horrible hack: We treat the aspect as inserted
+                       -- if the initial version is greater than 4 (this is
+                       -- what we need in the RM and AARM). This
+                       -- should depend on other parameters, and ideally
+                       -- be determined inside of the DB_Report code.
+                       ARM_Database.Insert (DB,
+                           Sort_Key => 
Format_Object.Impdef_Info.Aspect_Name(1..Format_Object.Impdef_Info.Aspect_Name_Len),
+                           Hang_Item => "@Chg{Version=[" & 
Format_Object.Impdef_Info.Initial_Version &
+                               "],New=[" & 
Format_Object.Impdef_Info.Aspect_Name(1..Format_Object.Impdef_Info.Aspect_Name_Len)
 &
+                               "],Old=[]}",
+                           Text => Text_Buffer(1..Text_Buffer_Len) &
+                              See_String,
+                           Change_Kind => 
Format_Object.Impdef_Info.Change_Kind,
+                           Version => Format_Object.Impdef_Info.Version,
+                           Initial_Version => 
Format_Object.Impdef_Info.Initial_Version);
+                   else -- Normal
+                       ARM_Database.Insert (DB,
+                           Sort_Key => 
Format_Object.Impdef_Info.Aspect_Name(1..Format_Object.Impdef_Info.Aspect_Name_Len),
+                           Hang_Item => 
Format_Object.Impdef_Info.Aspect_Name(1..Format_Object.Impdef_Info.Aspect_Name_Len),
+                           Text => Text_Buffer(1..Text_Buffer_Len) &
+                              See_String,
+                           Change_Kind => 
Format_Object.Impdef_Info.Change_Kind,
+                           Version => Format_Object.Impdef_Info.Version,
+                           Initial_Version => 
Format_Object.Impdef_Info.Initial_Version);
+                   end if;
+               else
+                   ARM_Database.Insert (DB,
+                       Sort_Key => Sort_Clause_String,
+                       Hang_Item => "",
+                       Text => Text_Buffer(1..Text_Buffer_Len) &
+                          See_String,
+                       Change_Kind => Format_Object.Impdef_Info.Change_Kind,
+                       Version => Format_Object.Impdef_Info.Version,
+                       Initial_Version => 
Format_Object.Impdef_Info.Initial_Version);
+               end if;
+               -- Finish the text processing:
+               if Format_Object.Impdef_Info.Add_to_DB and
+                  Format_Object.Include_Annotations then
+                   -- End the annotation:
+                   Check_End_Paragraph;
+                   if Format_Object.Next_Paragraph_Subhead_Type /=
+                           
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Old_Next_Subhead_Paragraph
 then
+                       Format_Object.Last_Paragraph_Subhead_Type :=
+                           
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Old_Last_Subhead_Paragraph;
+                   -- else still in same subhead, leave alone. (If
+                   -- we didn't do this, we'd output the subhead
+                   -- multiple times).
+                   end if;
+                   Format_Object.Next_Paragraph_Subhead_Type :=
+                       
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Old_Next_Subhead_Paragraph;
+                   Format_Object.Next_Paragraph_Format_Type :=
+                       
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Old_Next_Paragraph_Format;
+                   Format_Object.Paragraph_Tab_Stops :=
+                       
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Old_Tab_Stops;
+               -- else nothing started, nothing to finish.
+               end if;
+               -- Clear the Impdef information:
+               Format_Object.Impdef_Info := (Command => None);
+           end Finish_and_DB_Entry;
+
+       begin
+           case 
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Command is
+               when Redundant =>
+                   if Format_Object.Include_Annotations then
+                       Check_Paragraph;
+                       ARM_Output.Ordinary_Character (Output_Object, ']');
+                   -- else ignored.
+                   end if;
+
+               when Bold | Italic | Roman | Swiss | Fixed | Roman_Italic |
+                    Shrink | Grow | Up | Down |
+                    Black | Red | Green | Blue |
+                    Keyword | Non_Terminal | Non_Terminal_Format |
+                    Example_Text | Example_Comment =>
+                   -- Formatting commands; revert to the previous (saved)
+                   -- version:
+                   Check_Paragraph;
+                   Format_Object.Text_Format :=
+                       
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Text_Format;
+                   ARM_Output.Text_Format (Output_Object,
+                                           Format => 
Format_Object.Text_Format);
+
+               when Subheading | Heading =>
+                   -- Restore the format.
+                   Check_Paragraph;
+                   ARM_Output.Text_Format (Output_Object,
+                                           Format => ARM_Output.NORMAL_FORMAT);
+                   Format_Object.Text_Format := ARM_Output.NORMAL_FORMAT;
+                   Check_End_Paragraph;
+
+               when Added_Subheading =>
+                   -- Restore the format.
+                   declare
+                       Disposition : ARM_Output.Change_Type;
+                       use type ARM_Output.Change_Type;
+                   begin
+                       Calc_Change_Disposition (
+                           Format_Object => Format_Object,
+                           Version => 
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Change_Version,
+                           Operation => ARM_Output.Insertion,
+                           Text_Kind => Disposition);
+
+                       if Disposition = Do_Not_Display_Text then
+                           -- The new text was ignored.
+                           null; -- Nothing to do (we nulled out the text 
before we got here).
+                       elsif Disposition = ARM_Output.None then
+                           -- Display the text normally.
+                           Check_Paragraph;
+                           ARM_Output.Text_Format (Output_Object,
+                                                   Format => 
ARM_Output.NORMAL_FORMAT);
+                           Format_Object.Text_Format := 
ARM_Output.NORMAL_FORMAT;
+                           Check_End_Paragraph;
+                       elsif Disposition = ARM_Output.Deletion then
+                           raise Program_Error; -- A deletion inside of an 
insertion command!
+                       else -- Insertion.
+                           Check_Paragraph;
+                           ARM_Output.Text_Format (Output_Object,
+                                                   Format => 
ARM_Output.NORMAL_FORMAT);
+                           Format_Object.Text_Format := 
ARM_Output.NORMAL_FORMAT;
+                           Check_End_Paragraph;
+                       end if;
+                   end;
+
+               when Center | Right =>
+                   -- Close the paragraph.
+                   Check_End_Paragraph;
+
+               when New_Page_for_Version =>
+                   -- The version parameter is stored in Change_Version on
+                   -- the stack.
+                   if 
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Change_Version
+                       = Format_Object.Change_Version then
+                       Check_End_Paragraph; -- End any paragraph that we're in.
+                       ARM_Output.New_Page (Output_Object, 
ARM_Output.Any_Page);
+                   -- else do nothing.
+                   end if;
+
+               when RM_New_Page_for_Version =>
+                   -- The version parameter is stored in Change_Version on
+                   -- the stack.
+                   if not Format_Object.Include_Annotations and then
+                      
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Change_Version
+                       = Format_Object.Change_Version then
+                       Check_End_Paragraph; -- End any paragraph that we're in.
+                       ARM_Output.New_Page (Output_Object, 
ARM_Output.Any_Page);
+                   -- else do nothing.
+                   end if;
+
+               when Not_ISO_RM_New_Page_for_Version =>
+                   -- The version parameter is stored in Change_Version on
+                   -- the stack.
+                   if not Format_Object.Include_Annotations and then
+                      not Format_Object.Include_ISO and then
+                      
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Change_Version
+                       = Format_Object.Change_Version then
+                       Check_End_Paragraph; -- End any paragraph that we're in.
+                       ARM_Output.New_Page (Output_Object, 
ARM_Output.Any_Page);
+                   -- else do nothing.
+                   end if;
+
+               when ISO_Only_RM_New_Page_for_Version =>
+                   -- The version parameter is stored in Change_Version on
+                   -- the stack.
+                   if not Format_Object.Include_Annotations and then
+                      Format_Object.Include_ISO and then
+                      
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Change_Version
+                       = Format_Object.Change_Version then
+                       Check_End_Paragraph; -- End any paragraph that we're in.
+                       ARM_Output.New_Page (Output_Object, 
ARM_Output.Any_Page);
+                   -- else do nothing.
+                   end if;
+
+               when New_Column_for_Version =>
+                   -- The version parameter is stored in Change_Version on
+                   -- the stack.
+                   if 
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Change_Version
+                       = Format_Object.Change_Version then
+                       Check_End_Paragraph; -- End any paragraph that we're in.
+                       ARM_Output.New_Column (Output_Object);
+                   -- else do nothing.
+                   end if;
+
+               when Table_Param_Caption =>
+                   ARM_Output.Table_Marker (Output_Object,
+                                            ARM_Output.End_Caption);
+                   Format_Object.Last_Non_Space := False;
+
+                   Format_State.Nesting_Stack_Ptr := 
Format_State.Nesting_Stack_Ptr - 1;
+                       -- Unstack the "Caption" parameter.
+--Ada.Text_IO.Put_Line (" &Unstack (Tab Cap)");
+
+                   -- Check and handle the following "Headers" parameter:
+                   declare
+                       Ch : Character;
+                   begin
+                       ARM_Input.Check_Parameter_Name (Input_Object,
+                           Param_Name => "Headers" & 
(8..ARM_Input.Command_Name_Type'Last => ' '),
+                           Is_First => False,
+                           Param_Close_Bracket => Ch);
+                       if Ch /= ' ' then -- There is a parameter.
+                           -- Stack the parameter so we can process the end:
+                           Set_Nesting_for_Parameter
+                               (Command => Table_Param_Header,
+                                Close_Ch => Ch);
+
+                           -- No processing needed here.
+
+                       -- else no parameter. Weird.
+                       end if;
+                       return; -- We've already done the unstacking.
+                   end;
+
+               when Table_Param_Header =>
+                   ARM_Output.Table_Marker (Output_Object,
+                                            ARM_Output.End_Header);
+                   Format_Object.Last_Non_Space := False;
+
+                   Format_State.Nesting_Stack_Ptr := 
Format_State.Nesting_Stack_Ptr - 1;
+                       -- Unstack the "Header" parameter.
+--Ada.Text_IO.Put_Line (" &Unstack (Tab Head)");
+
+                   -- Check and handle the following "Body" parameter:
+                   declare
+                       Ch : Character;
+                   begin
+                       ARM_Input.Check_Parameter_Name (Input_Object,
+                           Param_Name => "Body" & 
(5..ARM_Input.Command_Name_Type'Last => ' '),
+                           Is_First => False,
+                           Param_Close_Bracket => Ch);
+                       if Ch /= ' ' then -- There is a parameter.
+                           -- Stack the parameter so we can process the end:
+                           Set_Nesting_for_Parameter
+                               (Command => Table_Param_Body,
+                                Close_Ch => Ch);
+
+                           -- No processing needed here.
+
+                       -- else no parameter. Weird.
+                       end if;
+                       return; -- We've already done the unstacking.
+                   end;
+
+               when Table_Param_Body =>
+                   -- Close the table:
+                   ARM_Output.Table_Marker (Output_Object,
+                                            ARM_Output.End_Table);
+                   Format_Object.Last_Non_Space := False;
+
+                   -- Reset the paragraph format (and skip over the parameter 
records):
+                   Format_Object.Last_Paragraph_Subhead_Type :=
+                       
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr-1).Old_Last_Subhead_Paragraph;
+                   Format_Object.Next_Paragraph_Subhead_Type :=
+                       
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr-1).Old_Next_Subhead_Paragraph;
+                   Format_Object.Next_Paragraph_Format_Type :=
+                       
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr-1).Old_Next_Paragraph_Format;
+                   Format_Object.Paragraph_Tab_Stops :=
+                       
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr-1).Old_Tab_Stops;
+                   Format_Object.In_Paragraph := False; -- End fake paragraph.
+                   Format_Object.No_Start_Paragraph := False;
+
+               when Syntax_Rule_RHS =>
+                   -- Send the production to the syntax manager.
+                   -- Other processing has already been handled.
+                   declare
+                       Text_Buffer : String (1..ARM_Input.MAX_RECORDING_SIZE);
+                       Text_Buffer_Len : Natural;
+                       Disposition : ARM_Output.Change_Type;
+                       use type ARM_Output.Change_Type;
+                   begin
+                       -- Calculate Disposition:
+                       if 
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr-1).Command = 
Syntax_Rule then
+                           Disposition := ARM_Output.None; -- Normal text.
+                       elsif 
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr-1).Command = 
Added_Syntax_Rule then
+                           Calc_Change_Disposition (
+                               Format_Object => Format_Object,
+                               Version => 
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr-1).Change_Version,
+                               Operation => ARM_Output.Insertion,
+                               Text_Kind => Disposition);
+                       else -- Deleted_Syntax_Rule
+                           Calc_Change_Disposition (
+                               Format_Object => Format_Object,
+                               Version => 
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr-1).Change_Version,
+                               Operation => ARM_Output.Deletion,
+                               Text_Kind => Disposition);
+                       end if;
+
+                       if Disposition = Do_Not_Display_Text then
+                           -- The text was ignored and skipped.
+                           -- Set the Non-terminal to empty:
+                           Format_Object.Syntax_NT_Len := 0;
+                           Format_Object.Syntax_Tab_Len := 0;
+                       else
+                           Arm_Input.Stop_Recording_and_Read_Result
+                               (Input_Object, Text_Buffer, Text_Buffer_Len);
+                           Text_Buffer_Len := Text_Buffer_Len - 1; -- Remove 
command close character.
+                           if Disposition = ARM_Output.None then
+                               -- Display the text normally.
+                               ARM_Syntax.Insert_Rule (For_Clause => 
Clause_String (Format_Object),
+                                   Rule => "@ntf{" & 
Format_Object.Syntax_NT(1..Format_Object.Syntax_NT_Len) &
+                                       " ::=} " & 
Text_Buffer(1..Text_Buffer_Len),
+                                   Tabset => 
Format_Object.Syntax_Tab(1..Format_Object.Syntax_Tab_Len));
+                           elsif Disposition = ARM_Output.Deletion then
+                               ARM_Syntax.Insert_Rule (For_Clause => 
Clause_String (Format_Object),
+                                   Rule => "@ntf{" & 
Format_Object.Syntax_NT(1..Format_Object.Syntax_NT_Len) &
+                                       "@Chg{Version=[" & 
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr-1).Change_Version &
+                                       "],New=[],Old=[ ::=]}} " & 
Text_Buffer(1..Text_Buffer_Len),
+                                   Tabset => 
Format_Object.Syntax_Tab(1..Format_Object.Syntax_Tab_Len));
+                           else -- Insertion.
+                               ARM_Syntax.Insert_Rule (For_Clause => 
Clause_String (Format_Object),
+                                   Rule => "@ntf{" & 
Format_Object.Syntax_NT(1..Format_Object.Syntax_NT_Len) &
+                                       "@Chg{Version=[" & 
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr-1).Change_Version &
+                                       "],New=[ ::=],Old=[]}} " & 
Text_Buffer(1..Text_Buffer_Len),
+                                   Tabset => 
Format_Object.Syntax_Tab(1..Format_Object.Syntax_Tab_Len));
+                           end if;
+                           -- Note: The LHS non-terminals aren't linked as 
usual.
+
+                           Check_End_Paragraph; -- End the paragraph, so the
+                                                -- next rule gets its own.
+
+                           -- Reset the paragraph format:
+                           Format_Object.Last_Paragraph_Subhead_Type :=
+                               
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Old_Last_Subhead_Paragraph;
+                           Format_Object.Next_Paragraph_Subhead_Type :=
+                               
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Old_Next_Subhead_Paragraph;
+                           Format_Object.Next_Paragraph_Format_Type :=
+                               
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Old_Next_Paragraph_Format;
+                           Format_Object.Paragraph_Tab_Stops :=
+                               
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Old_Tab_Stops;
+
+                           -- Set the Non-terminal to empty:
+                           Format_Object.Syntax_NT_Len := 0;
+                           Format_Object.Syntax_Tab_Len := 0;
+                       end if;
+                   end;
+
+               when Syntax_Prefix =>
+                   -- Reset the style:
+                   Check_Paragraph;
+                   Format_Object.Text_Format.Italic := False;
+                   ARM_Output.Text_Format (Output_Object,
+                                           Format_Object.Text_Format);
+
+               when Glossary_Text_Param =>
+                   -- Save the glossary entry in the Glossary database.
+                   if not Format_Object.Glossary_Info.Active then
+                       Ada.Text_IO.Put_Line ("  ** Not in glossary command at 
end of glossary command!? on line " & ARM_Input.Line_String (Input_Object));
+                   -- else OK.
+                   end if;
+                   declare
+                       use type ARM_Database.Paragraph_Change_Kind_Type;
+                       Text_Buffer : String (1..ARM_Input.MAX_RECORDING_SIZE);
+                       Text_Buffer_Len : Natural;
+                   begin
+                       Arm_Input.Stop_Recording_and_Read_Result
+                           (Input_Object, Text_Buffer, Text_Buffer_Len);
+                       Text_Buffer_Len := Text_Buffer_Len - 1; -- Remove 
command close character.
+                       if Format_Object.Glossary_Info.Add_to_Glossary then
+                           if Format_Object.Glossary_Info.Change_Kind = 
ARM_Database.Inserted then
+                               ARM_Database.Insert (Format_Object.Glossary_DB,
+                                   Sort_Key => 
Format_Object.Glossary_Info.Term(1..Format_Object.Glossary_Info.Term_Len),
+                                   Hang_Item => "",
+                                   Text => "@chg{Version=[" & 
Format_Object.Glossary_Info.Version & "],New=[@b{" &
+                                       
Format_Object.Glossary_Info.Term(1..Format_Object.Glossary_Info.Term_Len) &
+                                       ".}],Old=[]} " & 
Text_Buffer(1..Text_Buffer_Len),
+                                   Change_Kind => 
Format_Object.Glossary_Info.Change_Kind,
+                                   Version => 
Format_Object.Glossary_Info.Version,
+                                   Initial_Version => 
Format_Object.Glossary_Info.Version);
+
+                           elsif Format_Object.Glossary_Info.Change_Kind = 
ARM_Database.Deleted then
+                               ARM_Database.Insert (Format_Object.Glossary_DB,
+                                   Sort_Key => 
Format_Object.Glossary_Info.Term(1..Format_Object.Glossary_Info.Term_Len),
+                                   Hang_Item => "",
+                                   Text => "@chg{Version=[" & 
Format_Object.Glossary_Info.Version & "],New=[],Old=[@b{" &
+                                       
Format_Object.Glossary_Info.Term(1..Format_Object.Glossary_Info.Term_Len) &
+                                       ".}]} " & 
Text_Buffer(1..Text_Buffer_Len),
+                                   Change_Kind => 
Format_Object.Glossary_Info.Change_Kind,
+                                   Version => 
Format_Object.Glossary_Info.Version);
+
+                           elsif Format_Object.Glossary_Info.Change_Kind = 
ARM_Database.None then
+                               ARM_Database.Insert (Format_Object.Glossary_DB,
+                                   Sort_Key => 
Format_Object.Glossary_Info.Term(1..Format_Object.Glossary_Info.Term_Len),
+                                   Hang_Item => "",
+                                   Text => "@b{" & 
Format_Object.Glossary_Info.Term(1..Format_Object.Glossary_Info.Term_Len) &
+                                       ".} " & Text_Buffer(1..Text_Buffer_Len),
+                                   Change_Kind => ARM_Database.None);
+
+                           else
+                               ARM_Database.Insert (Format_Object.Glossary_DB,
+                                   Sort_Key => 
Format_Object.Glossary_Info.Term(1..Format_Object.Glossary_Info.Term_Len),
+                                   Hang_Item => "",
+                                   Text => "@b{" & 
Format_Object.Glossary_Info.Term(1..Format_Object.Glossary_Info.Term_Len) &
+                                       ".} " & Text_Buffer(1..Text_Buffer_Len),
+                                   Change_Kind => 
Format_Object.Glossary_Info.Change_Kind,
+                                   Version => 
Format_Object.Glossary_Info.Version);
+                           end if;
+                       end if;
+                   end;
+
+                   -- Finish the text processing:
+                   if 
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr-1).Command = 
To_Glossary_Also or else
+                      
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr-1).Command = 
Change_To_Glossary_Also then
+                       null; -- Normal text, no special handling needed.
+                   else
+                       if Format_Object.Glossary_Info.Displayed then
+                           -- End the annotation.
+                           Check_End_Paragraph;
+                           Format_Object.Last_Paragraph_Subhead_Type :=
+                               
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Old_Last_Subhead_Paragraph;
+                           Format_Object.Next_Paragraph_Subhead_Type :=
+                               
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Old_Next_Subhead_Paragraph;
+                           Format_Object.Next_Paragraph_Format_Type :=
+                               
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Old_Next_Paragraph_Format;
+                           Format_Object.Paragraph_Tab_Stops :=
+                               
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Old_Tab_Stops;
+                       else
+                           null; -- No text, no special handling needed.
+                       end if;
+                   end if;
+                   -- Remove glossary information as the command is finished:
+                   Format_Object.Glossary_Info :=
+                       (Active => False,
+                        Change_Kind => ARM_Database.None);
+
+               when Attribute_Text_Param =>
+                   declare
+                       Text_Buffer : String (1..ARM_Input.MAX_RECORDING_SIZE);
+                       Text_Buffer_Len : Natural;
+
+                       function Sort_Key return String is
+                           -- Generate a Sort Key so that these sort
+                           -- as they did in Ada 95.
+                       begin
+                           if Format_Object.Attr_Prefix_Len > 2 and then
+                                   Format_Object.Attr_Prefix(2) = ''' then
+                               -- Class-wide prefix. For some reason, this
+                               -- sorts before the main item in the Ada 95 RM.
+                               -- (And this continues in later RMs.)
+                               return 
Format_Object.Attr_Name(1..Format_Object.Attr_Name_Len) &
+                                   ''' & 
Character'Pred(Format_Object.Attr_Prefix(1)) &
+                                   "'Class";
+                                       -- Sort by name, then by prefix.
+                           else
+                               return 
Format_Object.Attr_Name(1..Format_Object.Attr_Name_Len) &
+                                   ''' & 
Format_Object.Attr_Prefix(1..Format_Object.Attr_Prefix_Len);
+                                       -- Sort by name, then by prefix.
+                           end if;
+                           -- Note: Ada 2005 sorted E'Identity and T'Identity
+                           -- backwards from Ada 95. This will fix that.
+                       end Sort_Key;
+
+                       function ChgRef_Command (Kind : in 
ARM_Database.Paragraph_Change_Kind_Type;
+                                                Version : in Character;
+                                                Initial_Version : in 
Character) return String is
+                           -- Careful: This assumes this is being used for
+                           -- the attribute index, which has always existed.
+                           -- Use the annex initial version rather than '0'
+                           -- to determine whether it is inserted or not for
+                           -- other listings.
+                       begin
+                           case Kind is
+                               when ARM_Database.None =>
+                                   return "";
+                               when ARM_Database.Inserted | 
ARM_Database.Inserted_Normal_Number =>
+                                   if Initial_Version > '0' then -- Not 
original.
+                                       return "@Chgref{Version=[" & Version &
+                                           "],Kind=[Added]}";
+                                   else
+                                       return "@Chgref{Version=[" & Version &
+                                           "],Kind=[AddedNormal]}";
+                                   end if;
+                               when ARM_Database.Deleted |
+                                    ARM_Database.Deleted_Inserted_Number |
+                                    ARM_Database.Deleted_No_Delete_Message |
+                                    
ARM_Database.Deleted_Inserted_Number_No_Delete_Message =>
+                                   if Initial_Version > '0' then -- Not 
original.
+                                       return "@Chgref{Version=[" & Version &
+                                           "],Kind=[DeletedAdded]}";
+                                   else
+                                       return "@Chgref{Version=[" & Version &
+                                           "],Kind=[Deleted]}";
+                                   end if;
+                               when ARM_Database.Revised | 
ARM_Database.Revised_Inserted_Number =>
+                                   if Initial_Version > '0' then -- Not 
original.
+                                       return "@Chgref{Version=[" & Version &
+                                           "],Kind=[RevisedAdded]}";
+                                   else
+                                       return "@Chgref{Version=[" & Version &
+                                           "],Kind=[Revised]}";
+                                   end if;
+                           end case;
+                       end ChgRef_Command;
+
+                       procedure Write_to_DB (Prefix_Kind, Text_Kind :
+                               in ARM_Database.Paragraph_Change_Kind_Type;
+                               Prefix_Version, Text_Version,
+                               Initial_Version : in Character) is
+                           -- Write the item to the DB; use Prefix_Kind and
+                           -- Text_Kind for the change kind.
+                       begin
+                           if Format_Object.Attr_Leading then
+                               ARM_Database.Insert (Format_Object.Attr_DB,
+                                   Sort_Key => Sort_Key,
+                                   Hang_Item =>
+                                       
Format_Object.Attr_Prefix(1..Format_Object.Attr_Prefix_Len) &
+                                          ''' & 
Format_Object.Attr_Name(1..Format_Object.Attr_Name_Len),
+                                   Text => "For " & 
Format_Object.Prefix_Text(1..Format_Object.Prefix_Text_Len) &
+                                       ":" & Ascii.LF & Ascii.LF &
+                                       ChgRef_Command (Text_Kind, 
Text_Version, Initial_Version) &
+                                       "@leading@noprefix@;" & 
Text_Buffer(1..Text_Buffer_Len) &
+                                       " See @RefSecbyNum{" & 
Clause_String(Format_Object) & "}.",
+                                   Change_Kind => Prefix_Kind,
+                                   Version => Prefix_Version,
+                                   Initial_Version => Initial_Version);
+                           else -- not leading:
+                               ARM_Database.Insert (Format_Object.Attr_DB,
+                                   Sort_Key => Sort_Key,
+                                   Hang_Item =>
+                                       
Format_Object.Attr_Prefix(1..Format_Object.Attr_Prefix_Len) &
+                                          ''' & 
Format_Object.Attr_Name(1..Format_Object.Attr_Name_Len),
+                                   Text => "For " & 
Format_Object.Prefix_Text(1..Format_Object.Prefix_Text_Len) &
+                                       ":" & Ascii.LF & Ascii.LF &
+                                       ChgRef_Command (Text_Kind, 
Text_Version, Initial_Version) &
+                                       "@noprefix@;" & 
Text_Buffer(1..Text_Buffer_Len) &
+                                       " See @RefSecbyNum{" & 
Clause_String(Format_Object) & "}.",
+                                   Change_Kind => Prefix_Kind,
+                                   Version => Prefix_Version,
+                                   Initial_Version => Initial_Version);
+                           end if;
+                       end Write_to_DB;
+
+                       use type ARM_Database.Paragraph_Change_Kind_Type;
+
+                   begin
+                       Arm_Input.Stop_Recording_and_Read_Result
+                           (Input_Object, Text_Buffer, Text_Buffer_Len);
+                       Text_Buffer_Len := Text_Buffer_Len - 1; -- Remove 
command close character.
+--Ada.Text_IO.Put_Line ("&& Attr: " & 
Format_Object.Attr_Name(1..Format_Object.Attr_Name_Len) &
+--   "; Prefix kind=" & 
ARM_Database.Paragraph_Change_Kind_Type'Image(Format_Object.Attr_Prefix_Change_Kind)
 &
+--   "; Attr chg kind=" & 
ARM_Database.Paragraph_Change_Kind_Type'Image(Format_Object.Attr_Change_Kind) &
+--   "; Attr Prefix Vers=" & Format_Object.Attr_Prefix_Version & "; Attr Text 
Vers=" & Format_Object.Attr_Version &
+--   "; Attr Init Vers=" & Format_Object.Attr_Initial_Version);
+
+                       -- How the prefix text is handled depends only on
+                       -- the Initial_Version and what version we're 
generating.
+                       -- The Kind and Version of the prefix or item is
+                       -- irrelevant (it's needed mainly for the paragraph
+                       -- revision number). We assume that all attributes
+                       -- are inserted for their Initial_Version (since it's
+                       -- unlikely that we'd delete an attribute).
+
+                       if Format_Object.Attr_Initial_Version = '0' then
+                           -- Initial version, not inserted.
+--Ada.Text_IO.Put_Line ("   Attr: Normal initial version");
+                               -- Normal reference:
+                           Write_to_DB (Prefix_Kind     => 
Format_Object.Attr_Prefix_Change_Kind,
+                                        Text_Kind       => 
Format_Object.Attr_Change_Kind,
+                                        Prefix_Version  => 
Format_Object.Attr_Prefix_Version,
+                                        Text_Version    => 
Format_Object.Attr_Version,
+                                        Initial_Version => '0');
+                       else
+                           declare
+                               Disposition : ARM_Output.Change_Type;
+                               use type ARM_Output.Change_Type;
+                               PVersion : Character := 
Format_Object.Attr_Prefix_Version;
+                               PKind    : 
ARM_Database.Paragraph_Change_Kind_Type :=
+                                               
Format_Object.Attr_Prefix_Change_Kind;
+                           begin
+                               if PVersion < 
Format_Object.Attr_Initial_Version then
+                                   -- This usually happens when the prefix used
+                                   -- @PrefixType; in that case, the
+                                   -- Initial_Version is really want we want.
+                                   -- And in that case, the prefix paragraph 
number
+                                   -- is always inserted (since we can't get 
here
+                                   -- if the Initial_Version is '0').
+                                   PVersion := 
Format_Object.Attr_Initial_Version;
+                                   PKind    := ARM_Database.Inserted;
+                               end if;
+
+                               Calc_Change_Disposition (
+                                   Format_Object => Format_Object,
+                                   Version => 
Format_Object.Attr_Initial_Version,
+                                   Operation => ARM_Output.Insertion,
+                                   Text_Kind => Disposition);
+
+                               if Disposition = Do_Not_Display_Text then
+                                   null; -- Do *not* put this into the DB.
+--Ada.Text_IO.Put_Line ("   Attr: Ignore");
+                               elsif Disposition = ARM_Output.None then
+--Ada.Text_IO.Put_Line ("   Attr: Normal");
+                                   -- Normal reference:
+                                   Write_to_DB (Prefix_Kind     => PKind,
+                                                Text_Kind       => 
Format_Object.Attr_Change_Kind,
+                                                Prefix_Version  => PVersion,
+                                                Text_Version    => 
Format_Object.Attr_Version,
+                                                Initial_Version => 
Format_Object.Attr_Initial_Version);
+                               elsif Disposition = ARM_Output.Deletion then
+                                   raise Program_Error; -- A deletion inside 
of an insertion command!
+                               else -- Insertion.
+                                   -- Write inserted text:
+                                   -- We need to mark everything with
+                                   -- the kind and version of the *entire* 
insertion,
+                                   -- because the entire thing is an
+                                   -- insertion. (So we ignore the prefix kind 
and version).
+--Ada.Text_IO.Put_Line ("   Attr: Inserted version:" & 
Format_Object.Attr_Initial_Version);
+                                   if Format_Object.Attr_Leading then
+                                       ARM_Database.Insert 
(Format_Object.Attr_DB,
+                                           Sort_Key => Sort_Key,
+                                           Hang_Item =>
+                                               "@ChgAdded{Version=[" & 
Format_Object.Attr_Initial_Version & "],Text=[" &
+                                               
Format_Object.Attr_Prefix(1..Format_Object.Attr_Prefix_Len) &
+                                                  ''' & 
Format_Object.Attr_Name(1..Format_Object.Attr_Name_Len) & "]}",
+                                           Text =>
+                                               "@ChgAdded{Version=[" & 
Format_Object.Attr_Initial_Version & "],Text=[" &
+                                               "For " & 
Format_Object.Prefix_Text(1..Format_Object.Prefix_Text_Len) &
+                                               ":]}" & Ascii.LF & Ascii.LF &
+                                               ChgRef_Command 
(Format_Object.Attr_Change_Kind, Format_Object.Attr_Version, 
Format_Object.Attr_Initial_Version) &
+                                               "@leading@noprefix@;" & 
Text_Buffer(1..Text_Buffer_Len) &
+                                               " See @RefSecbyNum{" & 
Clause_String(Format_Object) & "}.",
+                                           Change_Kind => PKind,
+                                           Version => PVersion,
+                                           Initial_Version => 
Format_Object.Attr_Initial_Version);
+                                   else -- not leading:
+                                       ARM_Database.Insert 
(Format_Object.Attr_DB,
+                                           Sort_Key => Sort_Key,
+                                           Hang_Item =>
+                                               "@ChgAdded{Version=[" & 
Format_Object.Attr_Initial_Version & "],Text=[" &
+                                               
Format_Object.Attr_Prefix(1..Format_Object.Attr_Prefix_Len) &
+                                                  ''' & 
Format_Object.Attr_Name(1..Format_Object.Attr_Name_Len) & "]}",
+                                           Text =>
+                                               "@ChgAdded{Version=[" & 
Format_Object.Attr_Initial_Version & "],Text=[" &
+                                               "For " & 
Format_Object.Prefix_Text(1..Format_Object.Prefix_Text_Len) &
+                                               ":]}" & Ascii.LF & Ascii.LF &
+                                               ChgRef_Command 
(Format_Object.Attr_Change_Kind, Format_Object.Attr_Version, 
Format_Object.Attr_Initial_Version) &
+                                               "@noprefix@;" & 
Text_Buffer(1..Text_Buffer_Len) &
+                                               " See @RefSecbyNum{" & 
Clause_String(Format_Object) & "}.",
+                                           Change_Kind => PKind,
+                                           Version => PVersion,
+                                           Initial_Version => 
Format_Object.Attr_Initial_Version);
+                                   end if;
+                               end if;
+                           end;
+                       end if;
+                   end;
+
+               when Pragma_Syntax | Added_Pragma_Syntax | 
Deleted_Pragma_Syntax =>
+                   -- Note: Pragma_Syntax is not recorded in the syntax 
summary.
+                   declare
+                       Text_Buffer : String (1..ARM_Input.MAX_RECORDING_SIZE);
+                       Text_Buffer_Len : Natural;
+
+                       function My_Sort return String is
+                           -- Find and return the @prag argument.
+                       begin
+                           for I in 1 .. Text_Buffer_Len - 7 loop
+                               if Text_Buffer(I) = '@' and then
+                               (Text_Buffer(I+1) = 'p' or else 
Text_Buffer(I+1) = 'P') and then
+                               (Text_Buffer(I+2) = 'r' or else 
Text_Buffer(I+2) = 'R') and then
+                               (Text_Buffer(I+3) = 'a' or else 
Text_Buffer(I+3) = 'A') and then
+                               (Text_Buffer(I+4) = 'g' or else 
Text_Buffer(I+4) = 'G') and then
+                               ARM_Input.Is_Open_Char (Text_Buffer(I+5)) then
+                                   -- Found @prag.
+                                   for J in I+6 .. Text_Buffer_Len loop
+                                       if Text_Buffer(J) = 
ARM_Input.Get_Close_Char (Text_Buffer(I+5)) then
+                                           return Text_Buffer(I+6 .. J-1);
+                                       end if;
+                                   end loop;
+                                   Ada.Text_IO.Put_Line ("** Can't find 
argument for @prag: " & Text_Buffer(1..Text_Buffer_Len) &
+                                       " on line " & ARM_Input.Line_String 
(Input_Object));
+                                   return ""; -- Never found the end of the 
argument.
+                               -- else not @prag, keep looking.
+                               end if;
+                           end loop;
+                           -- If we get here, we never found "@prag"
+                           Ada.Text_IO.Put_Line ("** Funny pragma format: " & 
Text_Buffer(1..Text_Buffer_Len) &
+                               " on line " & ARM_Input.Line_String 
(Input_Object));
+                           return ""; -- Gotta return something.
+                       end My_Sort;
+
+                   begin
+                       Arm_Input.Stop_Recording_and_Read_Result
+                           (Input_Object, Text_Buffer, Text_Buffer_Len);
+                       Text_Buffer_Len := Text_Buffer_Len - 1; -- Remove 
command close character.
+                       -- Ordinary text processing is fine for the local text.
+                       if 
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Command = 
Pragma_Syntax then
+                           ARM_Database.Insert (Format_Object.Pragma_DB,
+                               Sort_Key => My_Sort,
+                               Hang_Item => "",
+                               Text => Text_Buffer(1..Text_Buffer_Len) &
+                                   " @em See @RefSecbyNum{" & 
Clause_String(Format_Object) & "}.");
+                       elsif 
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Command = 
Added_Pragma_Syntax then
+                           declare
+                               Disposition : ARM_Output.Change_Type;
+                               use type ARM_Output.Change_Type;
+                           begin
+                               Calc_Change_Disposition (
+                                   Format_Object => Format_Object,
+                                   Version => 
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Change_Version,
+                                   Operation => ARM_Output.Insertion,
+                                   Text_Kind => Disposition);
+
+                               if Disposition = Do_Not_Display_Text then
+                                   null; -- Not in old versions, omit from 
Annex.
+                               elsif Disposition = ARM_Output.None then
+                                   -- Normal reference:
+                                   ARM_Database.Insert 
(Format_Object.Pragma_DB,
+                                       Sort_Key => My_Sort,
+                                       Hang_Item => "",
+                                       Text => "@ChgRef{Version=[" & 
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Change_Version &
+                                           "],Kind=[Added]}" &
+                                           Text_Buffer(1..Text_Buffer_Len) &
+                                           " @em See @RefSecbyNum{" & 
Clause_String(Format_Object) & "}.");
+                                   -- Note: We still need the @ChgRef in order
+                                   -- to get the paragraph numbers right.
+                               elsif Disposition = ARM_Output.Deletion then
+                                   raise Program_Error; -- A deletion inside 
of an insertion command!
+                               else -- Insertion.
+                                   ARM_Database.Insert 
(Format_Object.Pragma_DB,
+                                       Sort_Key => My_Sort,
+                                       Hang_Item => "",
+                                       Text => "@ChgRef{Version=[" & 
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Change_Version &
+                                           "],Kind=[Added]}" &
+                                           Text_Buffer(1..Text_Buffer_Len) &
+                                           "@Chg{Version=[" & 
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Change_Version &
+                                           "],New=[" &
+                                           " @em See @RefSecbyNum<" & 
Clause_String(Format_Object) & ">.],Old=[]}");
+                                   -- Note: Text includes any needed @Chg 
commands.
+                               end if;
+                           end;
+                       else --if 
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Command = 
Deleted_Pragma_Syntax then
+                           declare
+                               Add_Disposition : ARM_Output.Change_Type;
+                               Del_Disposition : ARM_Output.Change_Type;
+                               use type ARM_Output.Change_Type;
+
+                               function Para_Kind return String is
+                               begin
+                                   if 
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Prev_Change_Version 
= '0' and then
+                                       Add_Disposition /= ARM_Output.Insertion 
then
+                                       return "Deleted";
+                                   else
+                                       return "DeletedAdded";
+                                   end if;
+                               end Para_Kind;
+
+                           begin
+                               Calc_Change_Disposition (
+                                   Format_Object => Format_Object,
+                                   Version => 
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Change_Version,
+                                   Operation => ARM_Output.Deletion,
+                                   Text_Kind => Del_Disposition);
+                               if 
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Prev_Change_Version 
= '0' then
+                                   Add_Disposition := ARM_Output.None;
+                               else
+                                   Calc_Change_Disposition (
+                                       Format_Object => Format_Object,
+                                       Version => 
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Prev_Change_Version,
+                                       Operation => ARM_Output.Insertion,
+                                       Text_Kind => Add_Disposition);
+                               end if;
+
+                               if Del_Disposition = Do_Not_Display_Text then
+--Ada.Text_IO.Put_Line ("%% Deleted pragma completely omitted");
+                                   if Add_Disposition /= Do_Not_Display_Text
+                                       and then 
Format_Object.Number_Paragraphs then
+                                       -- If this was in older editions, then
+                                       -- we need a deletion message (and also
+                                       -- to get the paragraph numbers right).
+                                       -- But don't need this if there are no
+                                       -- paragraph numbers (then there is no
+                                       -- deleted message).
+--Ada.Text_IO.Put_Line ("   ... but need a deletion message");
+                                       ARM_Database.Insert 
(Format_Object.Pragma_DB,
+                                           Sort_Key => My_Sort,
+                                           Hang_Item => "",
+                                           Text => "@ChgRef{Version=[" & 
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Change_Version &
+                                               "],Kind=[" & Para_Kind & "]}@ 
");
+                                    else
+                                       null; -- Not at all in this version, 
omit from Annex.
+                                   end if;
+                               elsif Del_Disposition = ARM_Output.None then
+--Ada.Text_IO.Put_Line ("%% Deleted pragma normal format");
+                                   -- Is the initial item inserted or normal?
+                                   if Add_Disposition = ARM_Output.Insertion 
then
+--Ada.Text_IO.Put_Line ("... but inserted");
+                                       -- Inserted reference:
+                                       ARM_Database.Insert 
(Format_Object.Pragma_DB,
+                                           Sort_Key => My_Sort,
+                                           Hang_Item => "",
+                                           Text => "@ChgRef{Version=[" & 
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Prev_Change_Version &
+                                               "],Kind=[Added]}" &
+                                               Text_Buffer(1..Text_Buffer_Len) 
&
+                                               "@Chg{Version=[" & 
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Prev_Change_Version &
+                                               "],New=[" &
+                                               " @em See @RefSecbyNum<" & 
Clause_String(Format_Object) & ">.],Old=[]}");
+                                   else -- Anything else.
+                                       -- Normal reference:
+                                       if 
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Prev_Change_Version 
= '0' then
+                                           ARM_Database.Insert 
(Format_Object.Pragma_DB,
+                                               Sort_Key => My_Sort,
+                                               Hang_Item => "",
+                                               Text => 
Text_Buffer(1..Text_Buffer_Len) &
+                                                   " @em See @RefSecbyNum{" & 
Clause_String(Format_Object) & "}.");
+                                       else
+                                           ARM_Database.Insert 
(Format_Object.Pragma_DB,
+                                               Sort_Key => My_Sort,
+                                               Hang_Item => "",
+                                               Text => "@ChgRef{Version=[" & 
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Prev_Change_Version &
+                                                   "],Kind=[Added]}" &
+                                                   
Text_Buffer(1..Text_Buffer_Len) &
+                                                   " @em See @RefSecbyNum{" & 
Clause_String(Format_Object) & "}.");
+                                           -- Note: We still need the @ChgRef 
in order
+                                           -- to get the paragraph numbers 
right.
+                                       end if;
+                                   end if;
+                               elsif Del_Disposition = ARM_Output.Insertion 
then
+                                   raise Program_Error; -- An insertion inside 
of a deletion command!
+                               else -- Deletion.
+--Ada.Text_IO.Put_Line ("%% Deleted pragma deleted text");
+                                   -- Is the initial item inserted or normal?
+                                   if Add_Disposition = ARM_Output.Insertion 
then
+                                       ARM_Database.Insert 
(Format_Object.Pragma_DB,
+                                           Sort_Key => My_Sort,
+                                           Hang_Item => "",
+                                           Text => "@ChgRef{Version=[" & 
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Change_Version &
+                                               "],Kind=[DeletedAdded]}" &
+                                               Text_Buffer(1..Text_Buffer_Len) 
&
+                                               "@Chg{Version=[" & 
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Prev_Change_Version &
+                                               "],New=[" &
+                                               "@Chg{Version=[" & 
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Change_Version &
+                                               "],New=[],Old=[" &
+                                               " @em See @RefSecbyNum<" & 
Clause_String(Format_Object) & ">.]}],Old=[]}");
+                                   else -- Anything else.
+                                       -- Just a deleted reference:
+                                       ARM_Database.Insert 
(Format_Object.Pragma_DB,
+                                           Sort_Key => My_Sort,
+                                           Hang_Item => "",
+                                           Text => "@ChgRef{Version=[" & 
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Change_Version &
+                                               "],Kind=[" & Para_Kind & "]}" &
+                                               Text_Buffer(1..Text_Buffer_Len) 
&
+                                               "@Chg{Version=[" & 
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr).Change_Version &
+                                               "],New=[],Old=[" &
+                                               " @em See @RefSecbyNum<" & 
Clause_String(Format_Object) & ">.]}");
+                                       -- Note: We still need the @ChgRef in 
order
+                                       -- to get the paragraph numbers right 
and for the deleted paragraph message.
+                                   end if;
+                               end if;
+                           end;
+
+                       end if;
+                   end;
+
+               when Implementation_Defined | Change_Impdef_Text_Param =>
+                   -- Save the implementation-defined entry in the database.
+                   Finish_and_DB_Entry (Format_Object.Impdef_DB);
+
+               when Change_Impladv_Text_Param =>
+                   -- Save the implementation advice entry in the database.
+                   Finish_and_DB_Entry (Format_Object.Impladv_DB);
+
+               when Change_Docreq_Text_Param =>
+                   -- Save the documentation requirement entry in the database.
+                   Finish_and_DB_Entry (Format_Object.Docreq_DB);
+
+               when Change_AspectDesc_Text_Param =>
+                   -- Save the documentation requirement entry in the database.
+                   Finish_and_DB_Entry (Format_Object.Aspect_DB);
+
+               when Prefix_Type | Change_Prefix_Text_Param =>
+                   -- Copy the text into the Format_Object.Prefix_Text string.
+                   ARM_Input.Stop_Recording_and_Read_Result (
+                       Input_Object,
+                       Format_Object.Prefix_Text,
+                       Format_Object.Prefix_Text_Len);
+                   Format_Object.Prefix_Text_Len :=
+                       Format_Object.Prefix_Text_Len - 1; -- Remove command 
close character.
+
+               when Change_Param_Old =>
+                   if 
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr-1).Change_Version >
+                       Format_Object.Change_Version then
+                       -- The new text was ignored, use the old only.
+                       null; -- Nothing special to do.
+                   else
+                       case Format_Object.Changes is
+                           when ARM_Format.Old_Only =>
+                               null; -- Nothing special to do.
+                           when ARM_Format.New_Only =>
+                               null; -- Nothing to do (we nulled out the text 
before we got here).
+                           when ARM_Format.Show_Changes |
+                                ARM_Format.New_Changes =>
+                               if 
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr-1).Change_Version <
+                                   Format_Object.Base_Change_Version then
+                                   -- Old enough that only the new text is 
shown.
+                                   null; -- Nothing to do (we nulled out the 
text before we got here).
+                               else
+                                   if 
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr-1).Was_Text then
+                                       -- Non-empty text. Restore the previous
+                                       -- insertion state.
+                                       Format_Object.Text_Format.Change :=
+                                           
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr-1).Prev_Change;
+                                       Format_Object.Text_Format.Version :=
+                                           
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr-1).Prev_Change_Version;
+                                       Format_Object.Text_Format.Added_Version 
:=
+                                           
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr-1).Prev_Added_Change_Version;
+
+                                       Check_Paragraph; -- We have to be in a 
paragraph
+                                           -- in correct code, but this could 
happen
+                                           -- if the user ended the paragraph 
by mistake
+                                           -- (we've already generated an 
error in that case).
+                                       ARM_Output.Text_Format (Output_Object,
+                                                               
Format_Object.Text_Format);
+                                   -- else no text.
+                                   end if;
+                               end if;
+                       end case;
+                   end if;
+                   Format_Object.In_Change :=
+                       Arm_Output."/=" (Format_Object.Text_Format.Change, 
ARM_Output.None);
+
+               when Change_Param_New =>
+                   if 
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr-1).Change_Version >
+                      Format_Object.Change_Version then
+                       -- The new text was ignored.
+                       null; -- Nothing to do (we nulled out the text before 
we got here).
+                   else
+                       case Format_Object.Changes is
+                           when ARM_Format.Old_Only =>
+                               null; -- Nothing to do (we nulled out the text 
before we got here).
+                           when ARM_Format.New_Only =>
+                               null; -- Nothing special to do.
+                           when ARM_Format.Show_Changes |
+                                ARM_Format.New_Changes =>
+                               if 
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr-1).Change_Version <
+                                   Format_Object.Base_Change_Version then
+                                   -- Old enough that only the new text is 
shown.
+                                   null; -- Nothing special to do.
+                               else
+                                   if 
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr-1).Was_Text then
+                                       -- Non-empty text. Restore the previous
+                                       -- insertion state.
+                                       Format_Object.Text_Format.Change :=
+                                           
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr-1).Prev_Change;
+                                       Format_Object.Text_Format.Version :=
+                                           
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr-1).Prev_Change_Version;
+                                       Format_Object.Text_Format.Added_Version 
:=
+                                           
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr-1).Prev_Added_Change_Version;
+
+                                       Check_Paragraph; -- We have to be in a 
paragraph
+                                           -- in correct code, but this could 
happen
+                                           -- if the user ended the paragraph 
by mistake
+                                           -- (we've already generated an 
error in that case).
+                                       ARM_Output.Text_Format (Output_Object,
+                                                               
Format_Object.Text_Format);
+                                   -- else no text.
+                                   end if;
+                               end if;
+                       end case;
+                   end if;
+
+                   Format_State.Nesting_Stack_Ptr := 
Format_State.Nesting_Stack_Ptr - 1;
+                   -- Unstack the "New" parameter.
+--Ada.Text_IO.Put_Line (" &Unstack (Chg New)");
+
+                   -- Check and handle the following "Old" parameter:
+                   declare
+                       Ch, Ch2 : Character;
+                   begin
+                       ARM_Input.Check_Parameter_Name (Input_Object,
+                           Param_Name => "Old" & 
(4..ARM_Input.Command_Name_Type'Last => ' '),
+                           Is_First => False,
+                           Param_Close_Bracket => Ch);
+                       if Ch /= ' ' then -- There is a parameter.
+                           -- Stack the parameter so we can process the end:
+                           Set_Nesting_for_Parameter
+                               (Command => Change_Param_Old,
+                                Close_Ch => Ch);
+
+                           -- Now, handle the parameter:
+                           if 
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr-1).Change_Version >
+                               Format_Object.Change_Version then
+                               -- The new text was ignored, show the old only.
+                               null; -- Nothing special to do.
+                           else
+                               case Format_Object.Changes is
+                                   when ARM_Format.Old_Only =>
+                                       null; -- Nothing special to do.
+                                   when ARM_Format.New_Only =>
+                                       -- Skip the text:
+                                       ARM_Input.Skip_until_Close_Char 
(Input_Object, Ch);
+                                       ARM_Input.Replace_Char (Input_Object); 
-- Let the normal termination clean this up.
+                                   when ARM_Format.Show_Changes |
+                                        ARM_Format.New_Changes =>
+                                       if 
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr-1).Change_Version <
+                                           Format_Object.Base_Change_Version 
then
+                                           -- Old enough that only the new 
text is shown.
+                                           -- Skip the text:
+                                           ARM_Input.Skip_until_Close_Char 
(Input_Object, Ch);
+                                           ARM_Input.Replace_Char 
(Input_Object); -- Let the normal termination clean this up.
+                                       else
+                                           ARM_Input.Get_Char (Input_Object, 
Ch2);
+                                           ARM_Input.Replace_Char 
(Input_Object);
+                                           
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr-1).Was_Text :=
+                                               Ch /= Ch2;
+                                           if 
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr-1).Was_Text then
+                                               -- Non-empty text; calculate 
new change state: (current is deletion)
+                                               Check_Paragraph; -- Output the 
paragraph headers before changing the state.
+                                                   -- This can only matter for 
a deletion without
+                                                   -- an insertion; otherwise, 
we're already in a paragraph.
+                                               case 
Format_Object.Text_Format.Change is
+                                                   when ARM_Output.Deletion | 
ARM_Output.None =>
+                                                       
Format_Object.Text_Format.Change := ARM_Output.Deletion;
+                                                       
Format_Object.Text_Format.Version :=
+                                                           
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr-1).Change_Version;
+                                                       
Format_Object.Text_Format.Added_Version := '0';
+                                                   when ARM_Output.Insertion =>
+                                                       
Format_Object.Text_Format.Change := ARM_Output.Both;
+                                                       
Format_Object.Text_Format.Added_Version :=
+                                                           
Format_Object.Text_Format.Version;
+                                                       
Format_Object.Text_Format.Version :=
+                                                          
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr-1).Change_Version;
+                                                   when ARM_Output.Both =>
+                                                       
Format_Object.Text_Format.Change := ARM_Output.Both;
+                                                       -- Added_Version is 
unchanged.
+                                                       
Format_Object.Text_Format.Version :=
+                                                          
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr-1).Change_Version;
+                                               end case;
+                                               ARM_Output.Text_Format 
(Output_Object,
+                                                                       
Format_Object.Text_Format);
+                                               if Format_Object.Changes = 
ARM_Format.New_Changes then
+                                                   
ARM_Output.Ordinary_Character (Output_Object, ' ');
+                                                   -- Skip the text (we're not 
going to output it):
+                                                   
ARM_Input.Skip_until_Close_Char (Input_Object, Ch);
+                                                   ARM_Input.Replace_Char 
(Input_Object); -- Let the normal termination clean this up.
+                                               -- else if 
Format_Object.Changes = ARM_Format.Show_Changes then
+                                               --    Nothing else needed.
+                                               end if;
+                                           -- else no text, so don't emit a 
change area.
+                                           end if;
+                                       end if;
+                               end case;
+                           end if;
+                           Format_Object.In_Change := True;
+
+                       -- else no parameter. Weird.
+                       end if;
+                       return; -- We've already done the unstacking.
+                   end;
+
+               when Change_Added_Param =>
+                   declare
+                       Disposition : ARM_Output.Change_Type;
+                       use type ARM_Output.Change_Type;
+                   begin
+                       Format_Object.In_Change := False;
+
+                       Calc_Change_Disposition (
+                           Format_Object => Format_Object,
+                           Version => 
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr-1).Change_Version,
+                           Operation => ARM_Output.Insertion,
+                           Text_Kind => Disposition);
+
+                       if Disposition = Do_Not_Display_Text then
+                           -- The new text was ignored.
+                           null; -- Nothing to do (we nulled out the text 
before we got here).
+                       elsif Disposition = ARM_Output.None then
+                           -- Display the text normally.
+                           null; -- Nothing special to do.
+                       elsif Disposition = ARM_Output.Deletion then
+                           raise Program_Error; -- A deletion inside of an 
insertion command!
+                       else -- Insertion.
+                           -- Reset the state to normal:
+                           Format_Object.Text_Format.Change := ARM_Output.None;
+                           Format_Object.Text_Format.Version := '0';
+                           Format_Object.Text_Format.Added_Version := '0';
+
+                           Check_Paragraph; -- We have to be in a paragraph
+                               -- in correct code, but this could happen
+                               -- if the user ended the paragraph by mistake
+                               -- (we've already generated an error in that 
case).
+                           ARM_Output.Text_Format (Output_Object,
+                                                   Format_Object.Text_Format);
+                       end if;
+                   end;
+
+               when Change_Deleted_Param =>
+                   declare
+                       Disposition : ARM_Output.Change_Type;
+                       use type ARM_Output.Change_Type;
+                   begin
+                       Format_Object.In_Change := False;
+
+                       Calc_Change_Disposition (
+                           Format_Object => Format_Object,
+                           Version => 
Format_State.Nesting_Stack(Format_State.Nesting_Stack_Ptr-1).Change_Version,
+                           Operation => ARM_Output.Deletion,
+                           Text_Kind => Disposition);
+
+                       if Disposition = Do_Not_Display_Text then
+                           -- The old text was ignored.
+                           null; -- Nothing to do (we nulled out the text 
before we got here).
+                       elsif Disposition = ARM_Output.None then
+                           -- Display the text normally.
+                           null; -- Nothing special to do.
+                       elsif Disposition = ARM_Output.Insertion then
+                           raise Program_Error; -- An insertion inside of a 
deletion command!
+                       else -- Insertion.
+                           -- Reset the state to normal:
+                           Format_Object.Text_Format.Change := ARM_Output.None;
+                           Format_Object.Text_Format.Version := '0';
+                           Format_Object.Text_Format.Added_Version := '0';
+
+                           Check_Paragraph; -- We have to be in a paragraph
+                               -- in correct code, but this could happen
+                               -- if the user ended the paragraph by mistake
+                               -- (we've already generated an error in that 
case).
+                           ARM_Output.Text_Format (Output_Object,
+                                                   Format_Object.Text_Format);
+                       end if;
+                   end;
+
+               when Ceiling =>
+                    Check_Paragraph;
+                    ARM_Output.Special_Character (Output_Object, 
ARM_Output.Right_Ceiling);
+                    Format_Object.Last_Non_Space := True;
+
+               when Floor =>
+                    Check_Paragraph;
+                    ARM_Output.Special_Character (Output_Object, 
ARM_Output.Right_Floor);
+                    Format_Object.Last_Non_Space := True;
+
+               when Absolute =>
+                    Check_Paragraph;
+                    ARM_Output.Ordinary_Character (Output_Object, '|');
+                    Format_Object.Last_Non_Space := True;
+
+               when Log =>
+                    Check_Paragraph;
+                    ARM_Output.Ordinary_Character (Output_Object, ')');
+                    Format_Object.Last_Non_Space := True;
+
+               when others =>
+                   -- No special handling needed.
+                   null;
+           end case;
+--Ada.Text_IO.Put_Line (" &Unstack (Normal)");
+           Format_State.Nesting_Stack_Ptr := Format_State.Nesting_Stack_Ptr - 
1;
+       end Handle_End_of_Command;
+
+
+       procedure Process_Special is
+           -- Process a special command/macro/tab.
+           -- These all start with '@'.
+           -- @xxxx is a command. It may have parameters delimited by
+           -- (), {}, [], or <>. There does not appear to be an escape, so
+           -- we don't have to worry about '}' being used in {} brackets,
+           -- for example. (Must be a pain to write, though.)
+           Command_Name : ARM_Input.Command_Name_Type;
+           Ch : Character;
+           use type ARM_Output.Size_Type;
+       begin
+           ARM_Input.Get_Char (Input_Object, Ch);
+           if Ch = '\' then
+               -- This represents a tab, or the end of centered text.
+               -- (According to Bob Duff, from the Scribe manual).
+               if Format_Object.Next_Paragraph_Format_Type = 
Hanging_Indented_1 or else
+                  Format_Object.Next_Paragraph_Format_Type = 
Hanging_Indented_2 or else
+                  Format_Object.Next_Paragraph_Format_Type = 
Hanging_Indented_3 or else
+                  Format_Object.Next_Paragraph_Format_Type = 
Hanging_Indented_4 then
+                   -- Instead of a tab, just use this to mark the end
+                   -- of the hanging portion:
+                   Check_Paragraph;
+                   if Format_Object.In_Change then
+                       -- Close all formatting:
+                       declare
+                           Closed_Formatting : ARM_Output.Format_Type :=
+                               ARM_Output.NORMAL_FORMAT;
+                       begin
+                           Closed_Formatting.Font := 
Format_Object.Text_Format.Font; -- No clear default for these.
+                           Closed_Formatting.Size := 
Format_Object.Text_Format.Size;
+
+                           ARM_Output.Text_Format (Output_Object,
+                                                   Closed_Formatting);
+                       end;
+                   end if;
+                   ARM_Output.End_Hang_Item (Output_Object);
+                   if Format_Object.In_Change then
+                       -- Reset to the normal case:
+                       ARM_Output.Text_Format (Output_Object,
+                                               Format_Object.Text_Format);
+                   end if;
+               elsif Format_Object.Next_Paragraph_Format_Type = In_Table then
+                   -- If in a table, ends a item.
+                   ARM_Output.Table_Marker (Output_Object, 
ARM_Output.End_Item);
+               -- elsif centered text: TBD.
+               elsif ARM_Output."="(Format_Object.Paragraph_Tab_Stops, 
ARM_Output.NO_TABS) then
+                   Ada.Text_IO.Put_Line ("  ** Tab, but no tab stops set on 
line " &
+                        ARM_Input.Line_String (Input_Object));
+               else
+                   Check_Paragraph;
+                   ARM_Output.Tab (Output_Object);
+               end if;
+               return; -- We're done here.
+           elsif Ch = '=' then
+               -- This marks the start of centered text.
+               -- (According to Bob Duff, from the Scribe manual).
+               -- We're not implementing this; we're just going to replace
+               -- the handful of uses.
+               -- We're done here.
+               Ada.Text_IO.Put_Line ("  ** Centered text unimplemented 
(skipped) on line " &
+                    ARM_Input.Line_String (Input_Object));
+               return;
+           elsif Ch = '^' then
+               -- This represents setting at tab stop at the current location.
+               -- Neither HTML nor RTF supports such a thing, so these should
+               -- all have been replaced by conventional tab stops.
+               Ada.Text_IO.Put_Line ("  && Cursor tab stop unimplemented 
(skipped) on line " &
+                    ARM_Input.Line_String (Input_Object));
+               return;
+           elsif Ch = '@' then
+               -- This represents @ in the text. We're done here.
+               Check_Paragraph;
+               ARM_Output.Ordinary_Character (Output_Object, '@');
+               return;
+           elsif Ch = ' ' then
+               -- This represents a hard space in the text. We're done here.
+               Check_Paragraph;
+               ARM_Output.Hard_Space (Output_Object);
+               return;
+           elsif Ch = ';' then
+               -- This seems to be an end of command (or substitution) marker.
+               -- For instance, it is used in Section 1:
+               -- .. the distinction between @ResolutionName@;s and ...
+               -- This converts to:
+               -- .. the distinction between Name Resolution Rules and ...
+               -- Without it, the 's' would append to the command name, and
+               -- we would get the wrong command. Thus, it itself does nothing
+               -- at all, so we're done here.
+               return;
+           elsif Ch = '-' then
+               -- This represents a subscript. It has an argument.
+               ARM_Input.Get_Char (Input_Object, Ch);
+               if ARM_Input.Is_Open_Char (Ch) then -- Start parameter:
+                   Set_Nesting_for_Command
+                       (Name => '-' & (2..ARM_Input.Command_Name_Type'Last => 
' '),
+                        Kind => Normal,
+                        Param_Ch => Ch);
+                   Check_Paragraph;
+                   Format_Object.Text_Format.Size :=
+                       Format_Object.Text_Format.Size - 2;
+                   Format_Object.Text_Format.Location := ARM_Output.Subscript;
+                   ARM_Output.Text_Format (Output_Object,
+                                           Format_Object.Text_Format);
+               else -- No parameter. Weird.
+                   ARM_Input.Replace_Char (Input_Object);
+                   Ada.Text_IO.Put_Line ("  ** Failed to find parameter for 
subscript, line " & ARM_Input.Line_String (Input_Object));
+               end if;
+               return;
+           elsif Ch = '+' then
+               -- This represents a superscript. It has an argument.
+               ARM_Input.Get_Char (Input_Object, Ch);
+               if ARM_Input.Is_Open_Char (Ch) then -- Start parameter:
+                   Set_Nesting_for_Command
+                       (Name => '+' & (2..ARM_Input.Command_Name_Type'Last => 
' '),
+                        Kind => Normal,
+                        Param_Ch => Ch);
+                   Check_Paragraph;
+                   Format_Object.Text_Format.Size :=
+                       Format_Object.Text_Format.Size - 2;
+                   Format_Object.Text_Format.Location := 
ARM_Output.Superscript;
+                   ARM_Output.Text_Format (Output_Object,
+                                           Format_Object.Text_Format);
+               else -- No parameter. Weird.
+                   ARM_Input.Replace_Char (Input_Object);
+                   Ada.Text_IO.Put_Line ("  ** Failed to find parameter for 
superscript, line " & ARM_Input.Line_String (Input_Object));
+               end if;
+               return;
+           elsif Ch = ':' then
+               -- According to Tucker, the Scribe manual says:
+               -- @:  After a ".", it forces the "." to be interpreted as a
+               --     sentence-ending period rather than as an initial-ending
+               --     period.  E.g.: You are better than I.@:  F. Stone is
+               --     even better. Without the @:, the period after "I"
+               --     would be interpreted as the period signifying an
+               --     initial.
+               --
+               -- Besides not making much sense, this certainly does nothing
+               -- for us.
+               return;
+           elsif Ch = '*' then
+               -- According to Tucker, the Scribe manual says:
+               -- @*  This forces a line break, without starting a new
+               --     paragraph.
+               -- Tucker thinks this is "<BR>" in HTML.
+               if Format_Object.In_Paragraph then
+                   ARM_Output.Line_Break (Output_Object);
+                   Format_Object.Last_Non_Space := False;
+               -- else why start a paragraph with a line break??
+               end if;
+               return;
+           elsif Ch = '|' then
+               -- According to Tucker, the Scribe manual says:
+               -- @|  This marks a place within a word where a line break
+               --     may be inserted, *without* inserting a hyphen.  It is
+               --     effectively a zero-length "word".  You can use it to add
+               --     spaces between words that disappear if the line gets
+               --     broken there.  For example:
+               --        This is @| a sentence with two spaces between "is" 
and "a".
+               --     The extra space will disappear if the line is broken
+               --     between "is" and "a".
+               --
+               -- However, this appears to be used mainly to insert potential
+               -- line breaks into large words, and we use and implement it
+               -- that way.
+               if Format_Object.In_Paragraph then
+                   ARM_Output.Soft_Line_Break (Output_Object);
+                   Format_Object.Last_Non_Space := False;
+               -- else don't care about non-required breaks between paragraphs.
+               end if;
+               return;
+           elsif Ch = '!' then
+               -- This marks a place within a word where a line break
+               -- may be inserted, inserting a hyphen.
+               if Format_Object.In_Paragraph then
+                   ARM_Output.Soft_Hyphen_Break (Output_Object);
+                   Format_Object.Last_Non_Space := False;
+               -- else don't care about non-required breaks between paragraphs.
+               end if;
+               return;
+           elsif Ch = Ascii.LF then
+               -- Stand alone '@'.
+               -- I now believe this is an error, perhaps a hard space where
+               -- the trailing blank was dropped. It originally appeared in
+               -- Infosys.MSS.
+               Ada.Text_IO.Put_Line("** Stand-alone '@' on line " & 
ARM_Input.Line_String (Input_Object));
+               return;
+           end if;
+           ARM_Input.Replace_Char (Input_Object);
+           ARM_Input.Get_Name (Input_Object, Command_Name);
+--Ada.Text_IO.Put_Line("!!Command=" & Ada.Strings.Fixed.Trim(Command_Name, 
Ada.Strings.Both));
+
+           ARM_Input.Get_Char (Input_Object, Ch);
+           if ARM_Input.Is_Open_Char (Ch) then -- Start parameter:
+               Set_Nesting_for_Command
+                   (Name => Ada.Characters.Handling.To_Lower (Command_Name),
+                    Kind => Normal,
+                    Param_Ch => Ch);
+               Process_Command_with_Parameter;
+           else
+               ARM_Input.Replace_Char (Input_Object);
+               Process_Command_without_Parameter (Command_Name);
+           end if;
+       end Process_Special;
+
+
+       procedure Lookahead_for_End_of_Paragraph is
+           -- Look at the command following to see if it would
+           -- end the paragraph. If not, generate a Line_Break.
+           -- In any case, process the command (we don't allow more than
+           -- one call to Replace_Char).
+           -- We can assume that we are in a paragraph.
+           Command_Name : ARM_Input.Command_Name_Type;
+           Ch : Character;
+       begin
+           ARM_Input.Get_Char (Input_Object, Ch);
+           if Ch not in 'A' .. 'Z' and then Ch not in 'a' .. 'z' then
+               -- Not a named command, these never end a paragraph:
+               ARM_Input.Replace_Char (Input_Object);
+               ARM_Output.Line_Break (Output_Object);
+               Format_Object.Last_Non_Space := False;
+               Process_Special;
+           else -- Named command.
+               ARM_Input.Replace_Char (Input_Object);
+               ARM_Input.Get_Name (Input_Object, Command_Name);
+
+               case Command (Command_Name) is
+                   when Text_Begin | Text_End | New_Page | New_Column | 
RM_New_Page |
+                       Thin_Line | Thick_Line | Table | Picture_Alone |
+                       To_Glossary | Change_To_Glossary |
+                       Implementation_Defined |
+                       Change_Implementation_Defined |
+                       Change_Implementation_Advice |
+                       Change_Documentation_Requirement |
+                       Labeled_Section |
+                       Labeled_Section_No_Break |
+                       Labeled_Clause | Labeled_Subclause | 
Labeled_Subsubclause |
+                       Labeled_Revised_Section | Labeled_Revised_Clause |
+                       Labeled_Revised_Subclause | 
Labeled_Revised_Subsubclause |
+                       Labeled_Added_Section | Labeled_Added_Clause |
+                       Labeled_Added_Subclause | Labeled_Added_Subsubclause |
+                       Labeled_Deleted_Clause |
+                       Labeled_Deleted_Subclause | 
Labeled_Deleted_Subsubclause |
+                       Preface_Section |
+                       Labeled_Annex | Labeled_Revised_Annex | 
Labeled_Added_Annex |
+                       Labeled_Informative_Annex |
+                       Labeled_Revised_Informative_Annex | 
Labeled_Added_Informative_Annex |
+                       Labeled_Normative_Annex |
+                       Labeled_Revised_Normative_Annex | 
Labeled_Added_Normative_Annex |
+                       Unnumbered_Section | Subheading | Heading | Center | 
Right =>
+                       -- Ends a paragraph. No line break needed here (or
+                       -- we'd end up with two).
+                       null;
+                   when others =>
+                       -- Does not end a paragraph. Put in the soft break.
+                       ARM_Output.Line_Break (Output_Object);
+                       Format_Object.Last_Non_Space := False;
+               end case;
+
+               -- Now, process the command:
+               ARM_Input.Get_Char (Input_Object, Ch);
+               if ARM_Input.Is_Open_Char (Ch) then -- Start parameter:
+                   Set_Nesting_for_Command
+                       (Name => Ada.Characters.Handling.To_Lower 
(Command_Name),
+                        Kind => Normal,
+                        Param_Ch => Ch);
+                   Process_Command_with_Parameter;
+               else
+                   ARM_Input.Replace_Char (Input_Object);
+                   Process_Command_without_Parameter (Command_Name);
+               end if;
+           end if;
+       end Lookahead_for_End_of_Paragraph;
+
+    begin
+        Reading_Loop: loop
+           declare
+               Char : Character;
+           begin
+               ARM_Input.Get_Char (Input_Object, Char);
+--Ada.Text_IO.Put_Line("!!Char=" & Char & " Nesting=" & 
Natural'Image(Format_State.Nesting_Stack_Ptr));
+               case Char is
+                   when '@' =>
+                       Process_Special;
+                   when Ascii.LF =>
+                       ARM_Input.Get_Char (Input_Object, Char);
+                       if Char /= Ascii.LF then
+                           -- Soft line break.
+                           if Format_Object.Next_Paragraph_Format_Type = 
Example_Text or else
+                              Format_Object.Next_Paragraph_Format_Type = 
Child_Example_Text or else
+                              Format_Object.Next_Paragraph_Format_Type = 
Indented_Example_Text or else
+                              Format_Object.Next_Paragraph_Format_Type = 
Display or else
+                              Format_Object.Next_Paragraph_Format_Type = 
Syntax_Display or else
+                              Format_Object.Next_Paragraph_Format_Type = 
Syntax_Production then
+                               -- These formats preserves all line breaks, but 
a
+                               -- "soft" break does not end a paragraph.
+                               if Char /= '@' or else (not 
Format_Object.In_Paragraph) then
+                                   -- Not a paragraph end coming up:
+                                   if Format_Object.In_Paragraph then
+                                       ARM_Output.Line_Break (Output_Object);
+                                       Format_Object.Last_Non_Space := False;
+                                   -- else not in paragraph, we don't need to 
preserve
+                                   -- the break.
+                                   end if;
+                                   ARM_Input.Replace_Char (Input_Object);
+                               else
+                                   -- A command following, and we're in a 
paragraph.
+                                   -- If that command ends the paragraph, then
+                                   -- we don't want a soft break here (else 
we'd
+                                   -- end up with an extra blank line at the 
end).
+                                   -- Otherwise, we do.
+                                   Lookahead_for_End_of_Paragraph;
+                               end if;
+                           elsif Format_Object.Next_Paragraph_Format_Type = 
In_Table then
+                               -- If in a table, ends a row.
+                               ARM_Output.Table_Marker (Output_Object, 
ARM_Output.End_Row);
+                               ARM_Input.Replace_Char (Input_Object);
+                               Format_Object.Last_Non_Space := False;
+                               -- There should be nothing above the table at
+                               -- this point. Complain about other commands
+                               -- (this is a signficant aid to building 
tables):
+                               declare
+                                   Start_Depth : Natural := 1;
+                               begin
+                                   --Find the table:
+                                   for I in reverse 1 .. 
Format_State.Nesting_Stack_Ptr loop
+                                       if 
Format_State.Nesting_Stack(I).Command = Table then
+                                           Start_Depth := I;
+                                           exit;
+                                       end if;
+                                   end loop;
+                                   if 
Format_State.Nesting_Stack(Start_Depth+1).Command /= Table_Param_Body then
+                                       Ada.Text_IO.Put_Line ("   ** Wrong 
command on top of table, line " & ARM_Input.Line_String (Input_Object));
+                                       Ada.Text_IO.Put_Line ("      Command=" 
& Format_State.Nesting_Stack(Start_Depth+1).Name & " Class=" &
+                                           
Data.Command_Type'Image(Format_State.Nesting_Stack(Start_Depth+1).Command));
+                                   elsif Format_State.Nesting_Stack_Ptr /= 
Start_Depth+1 then
+                                       Ada.Text_IO.Put_Line ("   ** Unfinished 
commands detected at end of row, line " & ARM_Input.Line_String (Input_Object));
+                                   end if;
+                                   for I in reverse Start_Depth+2 .. 
Format_State.Nesting_Stack_Ptr loop
+                                       Ada.Text_IO.Put_Line ("      Open 
command=" &
+                                           Format_State.Nesting_Stack(I).Name 
& " Class=" &
+                                           
Data.Command_Type'Image(Format_State.Nesting_Stack(I).Command));
+                                   end loop;
+                               end;
+
+                           else -- Normal paragraph:
+                               -- Output a space if the last character was
+                               -- not a space and the next character is
+                               -- not a space. Eliminate any leading blanks
+                               -- added for formatting:
+                               if Format_Object.In_Paragraph and then
+                                  Format_Object.Last_Non_Space then
+                                   ARM_Output.Ordinary_Character 
(Output_Object, ' ');
+                                   Format_Object.Last_Non_Space := False;
+                               end if;
+                               -- Skip any leading spaces for the next 
paragraph:
+                               while Char = ' ' loop
+                                   ARM_Input.Get_Char (Input_Object, Char);
+                               end loop;
+                               ARM_Input.Replace_Char (Input_Object);
+                           end if;
+                       else -- Hard paragraph break. Only one, no matter
+                           -- how many blank lines there are:
+                           while Char = Ascii.LF loop
+                               ARM_Input.Get_Char (Input_Object, Char);
+                           end loop;
+                           if Format_Object.Next_Paragraph_Format_Type = 
Example_Text or else
+                              Format_Object.Next_Paragraph_Format_Type = 
Child_Example_Text or else
+                              Format_Object.Next_Paragraph_Format_Type = 
Indented_Example_Text or else
+                              Format_Object.Next_Paragraph_Format_Type = 
Display or else
+                              Format_Object.Next_Paragraph_Format_Type = 
Syntax_Display or else
+                              Format_Object.Next_Paragraph_Format_Type = 
Syntax_Production then
+                               null; -- In these formats, blanks remain.
+                           else
+                               -- Also remove any leading blanks from the next
+                               -- paragraph:
+                               while Char = ' ' loop
+                                   ARM_Input.Get_Char (Input_Object, Char);
+                               end loop;
+                           end if;
+                           ARM_Input.Replace_Char (Input_Object);
+                           Check_End_Paragraph; -- End the paragraph.
+                       end if;
+                   when ' ' =>
+                       if Format_Object.Next_Paragraph_Format_Type = 
Example_Text or else
+                          Format_Object.Next_Paragraph_Format_Type = 
Child_Example_Text or else
+                          Format_Object.Next_Paragraph_Format_Type = 
Indented_Example_Text or else
+                          Format_Object.Next_Paragraph_Format_Type = Display 
or else
+                          Format_Object.Next_Paragraph_Format_Type = 
Syntax_Display or else
+                          Format_Object.Next_Paragraph_Format_Type = 
Syntax_Production then
+                           -- Spaces are significant these formats.
+                           Check_Paragraph;
+                           ARM_Output.Hard_Space (Output_Object);
+                       else
+                           if Format_Object.In_Paragraph then
+                               if Format_Object.No_Start_Paragraph then
+                                   -- Not really in a paragraph.
+Ada.Text_IO.Put_Line ("Attempt to write into a deleted paragraph, on line " & 
ARM_Input.Line_String (Input_Object));
+                                   -- We'll probably crash soon.
+                                   null;
+                               else
+                                   ARM_Output.Ordinary_Character 
(Output_Object, ' ');
+                               end if;
+                           -- else we never want to start a paragraph with a 
space.
+                           end if;
+                       end if;
+                       Format_Object.Last_Non_Space := False;
+                   when Ascii.SUB =>
+                       -- End of file.
+                       exit Reading_Loop;
+                   when others =>
+                       if Format_State.Nesting_Stack_Ptr /= 0 and then
+                          Format_State.Nesting_Stack 
(Format_State.Nesting_Stack_Ptr).Close_Char /= ' ' and then
+                          Format_State.Nesting_Stack 
(Format_State.Nesting_Stack_Ptr).Close_Char = Char then
+                           -- Closing a command, remove it from the stack.
+                           Handle_End_of_Command;
+                       else
+                           Check_Paragraph;
+                           ARM_Output.Ordinary_Character (Output_Object, Char);
+                           null; -- Ordinary characters, output them.
+                           Format_Object.Last_Non_Space := True;
+                       end if;
+               end case;
+           end;
+        end loop Reading_Loop;
+    exception
+       when ARM_Output.Not_Valid_Error =>
+           Ada.Text_IO.Put_Line ("** Output validity error processing line " & 
ARM_Input.Line_String (Input_Object));
+           raise;
+    end Real_Process;
+
+
+    procedure Process (Format_Object : in out Format_Type;
+                      File_Name : in String;
+                      Output_Object : in out ARM_Output.Output_Type'Class;
+                      Section_Name : in String;
+                      Section_Number : in ARM_Contents.Section_Number_Type;
+                      Starts_New_Section : in Boolean) is
+       -- Process the contents for File_Name, writing the results to
+       -- Output_Object. (Output_Object uses dispatching calls to provide
+       -- the correct formatting). Section_Name is the name of the section
+       -- for this file. Starts_New_Section is True if the file starts
+       -- a new section. Section_Number is the number (or letter) of the
+       -- section. Values > 20 represent annex letters (21 => A, 22 => B, etc.)
+       Input_Object : Arm_File.File_Input_Type;
+       Format_State : Format_State_Type;
+    begin
+       Ada.Text_IO.Put_Line ("-- Processing " & File_Name);
+       begin
+           Arm_File.Open (Input_Object, File_Name);
+       exception
+           when others =>
+               Ada.Text_IO.Put_Line ("** Unable to open file " & File_Name);
+               raise;
+       end;
+       if Starts_New_Section then
+           Format_Object.Clause_Number := (Section => Section_Number,
+               Clause => 0, Subclause => 0, Subsubclause => 0);
+           declare
+               use type ARM_Contents.Section_Number_Type;
+           begin
+               if Section_Number = 0 then -- No title at all.
+                   ARM_Output.Section (Output_Object,
+                                       Section_Title => "",
+                                       Section_Name => Section_Name);
+               elsif Section_Number < ARM_Contents.ANNEX_START then
+                   ARM_Output.Section (Output_Object,
+                                       Section_Title => Ada.Strings.Fixed.Trim 
(
+                                                        
ARM_Contents.Lookup_Title (ARM_Contents.Section,
+                                                               (Section => 
Section_Number, others => 0)), Ada.Strings.Right),
+                                       Section_Name => Section_Name);
+               else
+                   -- We don't have a way to tell between the three kinds of 
annexes, so we try them all:
+                   begin
+                       ARM_Output.Section (Output_Object,
+                                           Section_Title => 
Ada.Strings.Fixed.Trim (
+                                                            
ARM_Contents.Lookup_Title (ARM_Contents.Normative_Annex,
+                                                                   (Section => 
Section_Number, others => 0)), Ada.Strings.Right),
+                                           Section_Name => Section_Name);
+                   exception
+                       when ARM_Contents.Not_Found_Error =>
+                           begin
+                                ARM_Output.Section (Output_Object,
+                                                   Section_Title => 
Ada.Strings.Fixed.Trim (
+                                                                    
ARM_Contents.Lookup_Title (ARM_Contents.Informative_Annex,
+                                                                           
(Section => Section_Number, others => 0)), Ada.Strings.Right),
+                                                   Section_Name => 
Section_Name);
+                           exception
+                               when ARM_Contents.Not_Found_Error =>
+                                   ARM_Output.Section (Output_Object,
+                                                       Section_Title => 
Ada.Strings.Fixed.Trim (
+                                                                        
ARM_Contents.Lookup_Title (ARM_Contents.Plain_Annex,
+                                                                               
(Section => Section_Number, others => 0)), Ada.Strings.Right),
+                                                       Section_Name => 
Section_Name);
+                                   -- If this fails, too, we just propagate to 
the outer handler.
+                           end;
+                   end;
+               end if;
+           exception
+               when ARM_Contents.Not_Found_Error =>
+                   Ada.Text_IO.Put_Line ("** Unable to find section title, 
line " & ARM_File.Line_String (Input_Object));
+           end;
+           Format_Object.Next_Note := 1;
+           Format_Object.Next_Paragraph := 1;
+           Format_Object.Next_Insert_Para := 1;
+           Format_Object.Next_AARM_Sub := 'a';
+           Format_Object.Next_Enumerated_Num := 1;
+           Format_Object.Enumerated_Level := 0;
+
+           Format_Object.Text_Format := ARM_Output.NORMAL_FORMAT;
+
+           Format_Object.No_Prefix := False;
+           Format_Object.No_Para_Num := False;
+           Format_Object.Keep_with_Next := False;
+           Format_Object.Space_After := ARM_Output.Normal;
+           Format_Object.No_Breaks := False;
+           Format_Object.In_Change := False;
+           Format_Object.Last_Non_Space := False;
+
+           Format_Object.Next_Paragraph_Change_Kind := ARM_Database.None;
+
+           Format_Object.Style := ARM_Output.Normal; -- The default.
+           Format_Object.Indent := 0; -- No indent to start.
+           Format_Object.In_Paragraph := False;
+           Format_Object.No_Start_Paragraph := False;
+       end if;
+
+       Real_Process (Format_Object, Format_State, Input_Object, Output_Object);
+
+       -- Reached end of the file/input object.
+       -- Kill any open paragraph:
+       if Format_Object.In_Paragraph and then (not 
Format_Object.No_Start_Paragraph) then
+           ARM_Output.End_Paragraph (Output_Object);
+           Format_Object.In_Paragraph := False;
+           Format_Object.No_Start_Paragraph := False;
+        end if;
+       Ada.Text_IO.Put_Line ("  Lines processed: " &
+               ARM_File.Line_String (Input_Object));
+       Arm_File.Close (Input_Object);
+       if Format_State.Nesting_Stack_Ptr /= 0 then
+           Ada.Text_IO.Put_Line ("   ** Unfinished commands detected.");
+           for I in reverse 1 .. Format_State.Nesting_Stack_Ptr loop
+               Ada.Text_IO.Put_Line ("      Open command=" &
+                   Format_State.Nesting_Stack(I).Name);
+           end loop;
+       end if;
+    end Process;
+
+
+    procedure Format (Format_Object : in out Format_Type;
+                     Text : in String;
+                     Output_Object : in out ARM_Output.Output_Type'Class;
+                     Text_Name : in String;
+                     No_Annotations : in Boolean) is
+       -- Format the contents of Text, writing the results to
+       -- Output_Object. (Output_Object uses dispatching calls to provide
+       -- the correct formatting). Text is assumed to be a component of
+       -- a larger section. Text_Name is an identifying name for error 
messages.
+       -- If No_Annotations is true, we don't want any annotations even if we
+       -- are generating a document with annotations.
+       Input_Object : Arm_String.String_Input_Type;
+       Format_State : Format_State_Type;
+       Real_Include_Annotations : Boolean := Format_Object.Include_Annotations;
+    begin
+       if No_Annotations then
+            Format_Object.Include_Annotations := False;
+       end if;
+       Arm_String.Open (Input_Object, Text, Text_Name);
+            -- Open the input object using a string for input.
+       Real_Process (Format_Object, Format_State, Input_Object, Output_Object);
+       Arm_String.Close (Input_Object);
+       Format_Object.Include_Annotations := Real_Include_Annotations;
+       if Format_State.Nesting_Stack_Ptr /= 0 then
+           Ada.Text_IO.Put_Line ("   ** Unfinished commands detected.");
+       end if;
+    end Format;
+
+end ARM_Format;
diff --git a/progs/arm_frm.ads b/progs/arm_frm.ads
new file mode 100755
index 0000000..ebf1485
--- /dev/null
+++ b/progs/arm_frm.ads
@@ -0,0 +1,476 @@
+with ARM_Output,
+     ARM_Contents;
+--private -- Ada 2005
+with ARM_Input,
+     ARM_Database,
+     ARM_Subindex;
+package ARM_Format is
+
+    --
+    -- Ada reference manual formatter (ARM_Form).
+    --
+    -- This package contains the routines to parse the input files, and
+    -- determine what to output.
+    --
+    -- ---------------------------------------
+    -- Copyright 2000, 2002, 2004, 2005, 2006, 2007, 2010, 2011, 2012, 2016
+    --   AXE Consultants. All rights reserved.
+    -- P.O. Box 1512, Madison WI  53701
+    -- E-Mail: randy@rrsoftware.com
+    --
+    -- ARM_Form is free software: you can redistribute it and/or modify
+    -- it under the terms of the GNU General Public License version 3
+    -- as published by the Free Software Foundation.
+    --
+    -- AXE CONSULTANTS MAKES THIS TOOL AND SOURCE CODE AVAILABLE ON AN "AS IS"
+    -- BASIS AND MAKES NO WARRANTY, EXPRESS OR IMPLIED, AS TO THE ACCURACY,
+    -- CAPABILITY, EFFICIENCY, MERCHANTABILITY, OR FUNCTIONING OF THIS TOOL.
+    -- IN NO EVENT WILL AXE CONSULTANTS BE LIABLE FOR ANY GENERAL,
+    -- CONSEQUENTIAL, INDIRECT, INCIDENTAL, EXEMPLARY, OR SPECIAL DAMAGES,
+    -- EVEN IF AXE CONSULTANTS HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
+    -- DAMAGES.
+    --
+    -- A copy of the GNU General Public License is available in the file
+    -- gpl-3-0.txt in the standard distribution of the ARM_Form tool.
+    -- Otherwise, see <http://www.gnu.org/licenses/>.
+    --
+    -- If the GPLv3 license is not satisfactory for your needs, a commercial
+    -- use license is available for this tool. Contact Randy at AXE Consultants
+    -- for more information.
+    --
+    -- ---------------------------------------
+    --
+    -- Edit History:
+    --
+    --  4/14/00 - RLB - Created base package.
+    --  4/18/00 - RLB - Added additional information to Object;
+    --                  added Scan.
+    --  4/24/00 - RLB - Added Change_Kind and Display_Index_Entries.
+    --          - RLB - Added Change format.
+    --  4/25/00 - RLB - Added Size.
+    --  4/26/00 - RLB - Added paragraph formats.
+    --  5/10/00 - RLB - Added additional paragraph kinds.
+    --  5/11/00 - RLB - Added numbers for enumerated paragraphs.
+    --  5/12/00 - RLB - Added attribute prefix text.
+    --  5/15/00 - RLB - Split input from parsing/formatting.
+    --  5/16/00 - RLB - Added database objects and Destroy.
+    --  5/23/00 - RLB - Added tab stops.
+    --  5/24/00 - RLB - Implemented subscript/superscript commands.
+    --  5/28/00 - RLB - Implemented index operations.
+    --  6/ 2/00 - RLB - Added Unit.
+    --  8/ 2/00 - RLB - Added Leading and Syntax_Leading styles.
+    --  8/ 4/00 - RLB - Added more new styles.
+    --  8/ 7/00 - RLB - Added Leading flag, removed Leading styles.
+    --  8/ 8/00 - RLB - Added Attr_Leading flag.
+    --  8/16/00 - RLB - Added No_Para_Num flag, removed No_Pnum formats.
+    --  8/17/00 - RLB - Changed Leading flag to Space_After.
+    --  8/28/00 - RLB - Added flags for ChgAttribute and ChgImpldef commands.
+    --  8/31/00 - RLB - Added the New_Changes change kind.
+    --  9/26/00 - RLB - Added Syntax_Display format.
+    --  6/17/02 - RLB - Added Ada95 changes sections.
+    --  7/18/02 - RLB - Moved document type here.
+    --          - RLB - Added Changes_Only and versioning for individual 
changes.
+    --  9/10/04 - RLB - Added support for nested changes.
+    --  9/14/04 - RLB - Moved Change_Version_Type to ARM_Contents.
+    -- 11/03/04 - RLB - Added Nested_X2_Bulleted.
+    -- 11/16/04 - RLB - Added Attr_Prefix_Text_Change_Kind.
+    -- 12/06/04 - RLB - Added reference chain for Format_Type.
+    -- 12/11/04 - RLB - Increased Syntax_NT length.
+    -- 10/17/05 - RLB - Added Glossary change items.
+    -- 10/28/05 - RLB - Added Language-Define subindexes.
+    --  1/12/06 - RLB - Replaced "Document" with a number of new more general
+    --                  properties.
+    --  1/16/06 - RLB - Added "Unnumbered_Section" counter, so we can assign
+    --                  names without special cases.
+    --  1/18/06 - RLB - Added "Example_Font".
+    --  9/22/06 - RLB - Added "Use_ISO_2004_Note_Format".
+    --          - RLB - Revised to use Clause_Number_Type.
+    --  9/25/06 - RLB - Added "Use_ISO_2004_Contents_Format".
+    -- 10/04/06 - RLB - Added "Use_ISO_2004_List_Format".
+    --  2/ 5/07 - RLB - Added Usage_Note for ASIS, and renamed Wide paragraph
+    --                  kinds.
+    --  2/13/07 - RLB - Redid output formating to use an explict indent;
+    --                  added ChildExample.
+    --  2/16/07 - RLB - Added Indent.
+    --  2/19/07 - RLB - Added Title format.
+    --  4/23/10 - RLB - Added Ada 2005 header.
+    --  8/ 8/11 - RLB - Added Aspect DB.
+    -- 10/18/11 - RLB - Changed to GPLv3 license.
+    --  3/12/12 - RLB - Lengthened unit name so
+    --                  
"Ada.Strings.Wide_Wide_Unbounded.Wide_Wide_Equal_Case_Insensitive"
+    --                  would fit (have we lost our minds??).
+    --  8/31/12 - RLB - Put glossary components into a subrecord to prevent
+    --                  inappropriate usage.
+    -- 10/18/12 - RLB - Put impdef components into a subrecord to prevent
+    --                  inappropriate usage.
+    --          - RLB - Added more specific hanging_indent formats, along with
+    --                  small.
+    -- 11/26/12 - RLB - Added subdivision names.
+    -- 12/17/12 - RLB - Added Ada 2012 AARM sections.
+    --  3/17/16 - RLB - Removed Changes_Only, added Base_Change_Version.
+
+    type Format_Type is tagged limited private;
+
+    type Change_Kind is (Old_Only, New_Only, Show_Changes, New_Changes);
+        -- Which changes to show?
+        -- If Old_Only, we will get the original Ada Reference Manual or AARM.
+        -- If New_Only, we will get the reference documents with the updates
+        -- up to the Change_Version specified included.
+        -- If Show_Changes, we will get the reference documents with the
+        -- updates up to the Base_Change_Version specified included; and
+        -- insertions and deletions will be shown for versions
+        -- Base_Change_Version .. Change_Version.
+        -- If New_Changes, original RM text removed, but new RM text will be
+        -- shown as inserted, up to and including the Change_Version specified.
+        -- In all cases, changes with versions newer than Change_Version are
+        -- ignored. Thus Change_Version = '0' is the same as Old_Only no
+        -- matter what command is given.
+        --
+        -- Note: Previous versions of this tool had Changes_Only as well;
+        -- that is the same as Show_Changes with Base_Change_Version =
+        -- Change_Version. (The previous version's Show_Changes is
+        -- equivalent to this version's Show_Changes with
+        -- Base_Change_Version = 1.)
+
+    procedure Create (Format_Object : in out Format_Type;
+                      Changes : in ARM_Format.Change_Kind;
+                      Change_Version : in ARM_Contents.Change_Version_Type;
+                      Base_Change_Version : in 
ARM_Contents.Change_Version_Type;
+                      Display_Index_Entries : in Boolean;
+                      Include_Annotations : in Boolean;
+                      Include_ISO : in Boolean;
+                      Link_Non_Terminals : in Boolean;
+                      Number_Paragraphs : in Boolean;
+                      Examples_Font : in ARM_Output.Font_Family_Type;
+                      Use_ISO_2004_Note_Format : in Boolean;
+                      Use_ISO_2004_Contents_Format : in Boolean;
+                      Use_ISO_2004_List_Format : in Boolean;
+                      Top_Level_Subdivision_Name : in 
ARM_Output.Top_Level_Subdivision_Name_Kind);
+        -- Initialize an input object. Changes, Change_Version, and
+        -- Base_Change_Version determine
+        -- which changes should be displayed. If Display_Index_Entries is True,
+        -- index entries will be printed in the document; otherwise, they
+        -- will not generate any visible text (although they might generate
+        -- a link anchor). If Include_Annotations is True, annotations (AARM
+        -- text) will be included in the output; otherwise it will not be.
+        -- If Include_ISO is True, ISOOnly text will be included in the output
+        -- (and NotISO text will not); otherwise the reverse is true.
+        -- If Link_Non_Terminals is True, links will be generated for
+        -- each Non_Terminal, linking it to its definition.
+        -- If Number_Paragraphs is true, paragraphs will be numbered (per
+        -- subclause); otherwise they will not be.
+        -- Example_Font specifies the font that examples will be set in.
+        -- If Use_ISO_2004_Note_Format is true, that format will be used;
+        -- else the Ada95 standard's format will be used for notes.
+        -- If Use_ISO_2004_Contents_Format is true, that format will be used;
+        -- else the Ada95 standard's format will be used for the table of 
contents.
+        -- If Use_ISO_2004_List_Format is true, then lists will be lettered;
+        -- else the Ada95 standard's numbering format will be used for
+        -- enumerated lists.
+        -- The top-level (and other) subdivision names are as specified
+        -- in Top_Level_Subdivision_Name.
+
+    procedure Destroy (Format_Object : in out Format_Type);
+        -- Destroy a format object, releasing any resources.
+
+    procedure Scan (Format_Object : in out Format_Type;
+                    File_Name : in String;
+                    Section_Number : in ARM_Contents.Section_Number_Type;
+                    Starts_New_Section : in Boolean);
+        -- Scans the contents for File_Name, determining the table of contents
+        -- for the section. The results are written to the contents package.
+        -- Starts_New_Section is True if the file starts a new section.
+        -- Section_Number is the number (or letter) of the section.
+        -- Note: We need this scanning pass so we can process @SeeSec,
+        -- @SeeSecNum, and similar commands. For that, we need the full names
+        -- of the sections and clauses.
+
+    procedure Write_Table_of_Contents (
+                        Format_Object : in out Format_Type;
+                       Output_Object : in out ARM_Output.Output_Type'Class);
+        -- Writes the table of contents for the document. (It will have
+        -- a section name of "TOC").
+
+    procedure Process (Format_Object : in out Format_Type;
+                       File_Name : in String;
+                       Output_Object : in out ARM_Output.Output_Type'Class;
+                       Section_Name : in String;
+                       Section_Number : in ARM_Contents.Section_Number_Type;
+                       Starts_New_Section : in Boolean);
+        -- Process the contents for File_Name, writing the results to
+        -- Output_Object. (Output_Object uses dispatching calls to provide
+        -- the correct formatting). Section_Name is the name of the section
+        -- for this file. Starts_New_Section is True if the file starts
+        -- a new section. Section_Number is the number (or letter) of the
+        -- section. Values > 20 represent annex letters (21 => A, 22 => B, 
etc.)
+
+    procedure Format (Format_Object : in out Format_Type;
+                      Text : in String;
+                      Output_Object : in out ARM_Output.Output_Type'Class;
+                      Text_Name : in String;
+                      No_Annotations : in Boolean);
+        -- Format the contents of Text, writing the results to
+        -- Output_Object. (Output_Object uses dispatching calls to provide
+        -- the correct formatting). Text is assumed to be a component of
+        -- a larger section. Text_Name is an identifying name for error 
messages.
+        -- If No_Annotations is true, we don't want any annotations even if we
+        -- are generating a document with annotations.
+
+private
+    type Paragraph_Type is (Plain, Introduction,
+        Language_Design, -- AARM-only.
+        Syntax, Resolution, Legality,
+        Static_Semantics, Link_Time, Run_Time, Bounded_Errors,
+        Erroneous, Requirements, Documentation, Metrics, Permissions, Advice,
+        Notes, Single_Note, Examples,
+        Ada83_Inconsistencies, Ada83_Incompatibilities, -- AARM-only.
+        Ada83_Extensions, Ada83_Wording, -- AARM-only.
+        Ada95_Inconsistencies, Ada95_Incompatibilities, -- AARM-only.
+        Ada95_Extensions, Ada95_Wording, -- AARM-only.
+        Ada2005_Inconsistencies, Ada2005_Incompatibilities, -- AARM-only.
+        Ada2005_Extensions, Ada2005_Wording, -- AARM-only.
+        Ada2012_Inconsistencies, Ada2012_Incompatibilities, -- AARM-only.
+        Ada2012_Extensions, Ada2012_Wording, -- AARM-only.
+        Element_Ref, Child_Ref, Usage_Note, -- For ASIS (AASIS-only).
+        -- AARM annotations (no headers)
+        Reason, Ramification, Proof, Imp_Note, Corr_Change, Discussion,
+        Honest, Glossary_Marker, Bare_Annotation,
+        -- Format only:
+        Wide_Above, Example_Text, Child_Example_Text,
+        Indented_Example_Text, Code_Indented, Indent, Bulleted, 
Nested_Bulleted,
+        Nested_X2_Bulleted,
+        Display, Syntax_Display, Syntax_Indented, Syntax_Production,
+        Enumerated, Nested_Enumerated,
+        Hanging_Indented_1, Hanging_Indented_2, Hanging_Indented_3,
+        Hanging_Indented_4, Small, Title, In_Table);
+
+    type Reference;
+    type Reference_Ptr is access Reference;
+    type Reference is record
+        Ref_Name : ARM_Input.Command_Name_Type;
+        Ref_Len  : Natural; -- Length of the reference.
+        Is_DR_Ref : Boolean; -- True for a DR reference; False for an AI 
reference.
+        Next : Reference_Ptr;
+    end record;
+
+    type Glossary_Info_Type (Active : Boolean := False;
+                             Change_Kind : 
ARM_Database.Paragraph_Change_Kind_Type := ARM_Database.None) is record
+                                -- The Change_Kind of ToGlossary.
+        case Active is
+            when False => null; -- No glossary entry in use.
+            when True =>
+                -- Glossary actively being processed; used only when
+                -- processing [Chg]ToGlossary[Also] commands.
+                Term : String (1..50); -- Glossary term.
+                Term_Len : Natural := 0;
+                Add_to_Glossary : Boolean;
+                        -- Add this item to the Glossary. (Not the same
+                        -- as "Active"; when generating older versions
+                        -- of a document, this would be False for a
+                        -- new glossary entry.)
+                Displayed : Boolean;
+                        -- The text was displayed in the document.
+                case Change_Kind is
+                    when ARM_Database.None => null;
+                    when others =>
+                        Version : ARM_Contents.Change_Version_Type;
+                            -- The version number of the changed paragraph.
+                end case;
+        end case;
+    end record;
+
+    type Impdef_Command_Type is (None, Aspect, Impdef, Docreq, ImplAdv);
+
+    type Impdef_Info_Type (Command : Impdef_Command_Type := None) is record
+        case Command is
+            when None => null; -- No impdef, docreq, impladv, aspectdesc in 
use.
+            when others =>
+                -- Impdef, Docreq, Impladv, Aspectdesc actively being 
processed;
+                -- used only when processing ImplDef, ChgImplDef,
+                --    ChgDocReq, ChgImplAdv, and ChgAspectDesc.
+                Change_Kind : ARM_Database.Paragraph_Change_Kind_Type := 
ARM_Database.None;
+                        -- The Change_Kind of the command.
+                Version : ARM_Contents.Change_Version_Type;
+                        -- If the kind is not "None", this is the version
+                        -- number of the changed paragraph.
+                Initial_Version : ARM_Contents.Change_Version_Type;
+                        -- This is the version number of the original 
paragraph.
+                Paragraph_String : String (1 .. 10); -- Paragraph number.
+                Paragraph_Len : Natural;
+                Add_to_DB : Boolean;
+                        -- Add this item to the appropriate DB. (Not the same
+                        -- as "Active"; when generating older versions
+                        -- of a document, this would be False for a
+                        -- new impdef, docreq, etc. entry.)
+                case Command is
+                    when Aspect =>
+                        Aspect_Name : String (1..30); -- Aspect name text
+                        Aspect_Name_Len : Natural := 0;
+                    when others => null;
+                end case;
+        end case;
+    end record;
+
+    type Format_Type is tagged limited record
+        -- Document information:
+        Changes : ARM_Format.Change_Kind; -- No Both here.
+        Change_Version : ARM_Contents.Change_Version_Type;
+        Base_Change_Version : ARM_Contents.Change_Version_Type;
+        Display_Index_Entries : Boolean;
+        Include_Annotations : Boolean;
+        Include_ISO : Boolean;
+        Link_Non_Terminals : Boolean;
+        Number_Paragraphs : Boolean;
+        Examples_Font : ARM_Output.Font_Family_Type;
+        Use_ISO_2004_Note_Format : Boolean;
+        Use_ISO_2004_Contents_Format : Boolean;
+        Use_ISO_2004_List_Format : Boolean;
+        Top_Level_Subdivision_Name : 
ARM_Output.Top_Level_Subdivision_Name_Kind;
+
+        -- Clause numbers:
+        Clause_Number : ARM_Contents.Clause_Number_Type;
+             -- The current clause number (Section, clause, subclause, 
subsubclause).
+        Unnumbered_Section : Natural; -- The current (if any) clause number
+                -- for unnumbered sections.
+
+        -- Paragraph format info:
+        Next_Paragraph_Change_Kind : ARM_Database.Paragraph_Change_Kind_Type;
+                             -- The change kind of the next paragraph. This is
+                             -- reset to none after each paragraph.
+        Next_Paragraph_Version : ARM_Contents.Change_Version_Type;
+                             -- If the kind is not "None", this is the version
+                             -- number of the changed paragraph.
+        Last_Paragraph_Subhead_Type : Paragraph_Type;
+                             -- The last paragraph subhead generated.
+        Next_Paragraph_Subhead_Type : Paragraph_Type;
+                             -- The next paragraph subhead to generate (not
+                             -- necessarily the same as 
Next_Paragraph_Format_Type).
+                             -- This indicates the current paragraph type.
+        Next_Paragraph_Format_Type : Paragraph_Type;
+                             -- The format type of the next paragraph to
+                             -- generate. We keep this separately so that the
+                             -- first paragraph of a grouping can be in a
+                             -- different format than the standard one, and
+                             -- still generate a subheading.
+        Paragraph_Tab_Stops : ARM_Output.Tab_Info := ARM_Output.NO_TABS;
+                             -- The tab stops for the next paragraph.
+        In_Bundle : Boolean := False;
+                             -- Are we in a bundle?
+        References : Reference_Ptr := null;
+                             -- Any references to generate at the start of the
+                             -- next paragraph.
+
+        -- Paragraph numbering info:
+        Next_Note : Natural; -- The number of the next note. These are
+                             -- per-section, not per-clause (unless ISO 2004 
is set).
+        Next_Paragraph : Positive; -- The number of the next paragraph. These
+                             -- are per-(sub)clause.
+        Next_Insert_Para : Positive; -- The subnumber of the next inserted
+                             -- paragraph.
+        Next_AARM_Sub : Character; -- The letter of the next AARM subclause.
+                             -- These are reset when the paragraph number
+                             -- changes.
+        Next_AARM_Insert_Para : Positive; -- The subnumber of the next inserted
+                             -- AARM paragraph.
+        Next_Enumerated_Num : Positive;
+                             -- If the format is enumerated, this is the
+                             -- number of the next paragraph.
+        Enumerated_Level : Natural;
+                             -- Number of enumerated formats that we're in.
+        Current_Paragraph_String : String (1 .. 10);
+                             -- The current paragraph number string (only
+                             -- valid if In_Paragraph is True).
+        Current_Paragraph_Len : Natural;
+
+        -- Text format info:
+        Text_Format : ARM_Output.Format_Type; -- Holds the current text format.
+
+        Style : ARM_Output.Paragraph_Style_Type; -- What is the current 
paragraph style?
+        Indent : ARM_Output.Paragraph_Indent_Type; -- What is the current 
paragraph indent?
+        In_Paragraph : Boolean; -- Are we currently in a paragraph?
+        No_Start_Paragraph : Boolean; -- Did we suppress "Start_Paragraph"?
+        No_Prefix : Boolean; -- Should we suppress any prefix on the next 
paragraph?
+        No_Para_Num : Boolean; -- Should we suppress the paragraph number on 
the next paragraph?
+        Keep_with_Next : Boolean; -- Should we force this paragraph to bind to 
the next
+                                  -- (disallowing a page break between)?
+        Space_After : ARM_Output.Space_After_Type; -- Space following this
+                             -- paragraph.
+        No_Breaks : Boolean; -- Should we allow page breaks in this paragraph?
+        In_Change : Boolean; -- Are we in a change region?
+        Last_Non_Space : Boolean; -- Is the last character written into the
+                        -- paragraph a non-space? (If nothing has been
+                        -- written into the paragraph, then this is False).
+
+        -- Indexing:
+        Unit : String (1..72);  -- Unit for predefined definitions. Used only
+                                -- by a handful of indexing commands.
+        Unit_Len : Natural := 0;
+
+        -- Syntax:
+        Syntax_NT : String (1..80); -- Syntax non-terminal; used only during 
the
+                                    -- processing of the Syn command.
+        Syntax_NT_Len : Natural := 0;
+        Syntax_Tab : String (1..40); -- Syntax tab string; used only during the
+                                    -- processing of the Syn command.
+        Syntax_Tab_Len : Natural := 0;
+
+        -- Attributes:
+        Prefix_Text : String (1..200) := "@b{NONE!}" & (10..200 => ' ');
+            -- This text is used as part of the attribute list text.
+            -- It is shared between multiple attributes, which is why it is
+            -- handled this way.
+        Prefix_Text_Len : Natural := 9;
+
+        Attr_Prefix : String (1..10); -- Attribute prefix text
+        Attr_Prefix_Len : Natural := 0;
+        Attr_Prefix_Change_Kind : ARM_Database.Paragraph_Change_Kind_Type;
+        Attr_Prefix_Version : ARM_Contents.Change_Version_Type;
+        Attr_Name : String (1..30); -- Attribute name text
+        Attr_Name_Len : Natural := 0;
+        Attr_Leading : Boolean := False; -- Attribute leading flag
+        Attr_Change_Kind : ARM_Database.Paragraph_Change_Kind_Type;
+        Attr_Prefix_Text_Change_Kind : ARM_Database.Paragraph_Change_Kind_Type;
+        Attr_Version : ARM_Contents.Change_Version_Type;
+        Attr_Initial_Version : ARM_Contents.Change_Version_Type;
+            -- The above ten items are used only when processing Attribute
+            -- and Attribute_Leading commands.
+
+        Attr_DB : ARM_Database.Database_Type;
+
+        -- Pragmas:
+        Pragma_DB : ARM_Database.Database_Type;
+
+        -- Glossary:
+        Glossary_Info : Glossary_Info_Type;
+        Glossary_DB : ARM_Database.Database_Type;
+
+        -- Aspects:
+        Aspect_DB : ARM_Database.Database_Type;
+            -- Also see Impdef_Info, below.
+
+        -- Implementation advice:
+        Impladv_DB : ARM_Database.Database_Type;
+            -- Also see Impdef_Info, below.
+
+        -- Documentation requirements:
+        Docreq_DB : ARM_Database.Database_Type;
+            -- Also see Impdef_Info, below.
+
+        -- Implementation-defined:
+        Impdef_DB : ARM_Database.Database_Type;
+            -- Also see Impdef_Info, below.
+
+        -- For all of the above four:
+        Impdef_Info : Impdef_Info_Type;
+            -- Used only during processing of ImplDef, ChgImplDef,
+            --    ChgDocReq, ChgImplAdv, and ChgAspectDesc.
+
+        -- Language-Defined entity subindexes:
+        Package_Index : ARM_Subindex.Subindex_Type;
+        Type_Index : ARM_Subindex.Subindex_Type;
+        Subprogram_Index : ARM_Subindex.Subindex_Type;
+        Exception_Index : ARM_Subindex.Subindex_Type;
+        Object_Index : ARM_Subindex.Subindex_Type;
+
+    end record;
+end ARM_Format;
diff --git a/progs/arm_frmd.adb b/progs/arm_frmd.adb
new file mode 100755
index 0000000..e9cdc2c
--- /dev/null
+++ b/progs/arm_frmd.adb
@@ -0,0 +1,552 @@
+with Ada.Characters.Handling,
+     Ada.Strings.Fixed;
+package body ARM_Format.Data is
+
+    --
+    -- Ada reference manual formatter (ARM_Form).
+    --
+    -- This package contains various data used by the input file parser.
+    --
+    -- ---------------------------------------
+    -- Copyright 2011, 2012  AXE Consultants. All rights reserved.
+    -- P.O. Box 1512, Madison WI  53701
+    -- E-Mail: randy@rrsoftware.com
+    --
+    -- ARM_Form is free software: you can redistribute it and/or modify
+    -- it under the terms of the GNU General Public License version 3
+    -- as published by the Free Software Foundation.
+    --
+    -- AXE CONSULTANTS MAKES THIS TOOL AND SOURCE CODE AVAILABLE ON AN "AS IS"
+    -- BASIS AND MAKES NO WARRANTY, EXPRESS OR IMPLIED, AS TO THE ACCURACY,
+    -- CAPABILITY, EFFICIENCY, MERCHANTABILITY, OR FUNCTIONING OF THIS TOOL.
+    -- IN NO EVENT WILL AXE CONSULTANTS BE LIABLE FOR ANY GENERAL,
+    -- CONSEQUENTIAL, INDIRECT, INCIDENTAL, EXEMPLARY, OR SPECIAL DAMAGES,
+    -- EVEN IF AXE CONSULTANTS HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
+    -- DAMAGES.
+    --
+    -- A copy of the GNU General Public License is available in the file
+    -- gpl-3-0.txt in the standard distribution of the ARM_Form tool.
+    -- Otherwise, see <http://www.gnu.org/licenses/>.
+    --
+    -- If the GPLv3 license is not satisfactory for your needs, a commercial
+    -- use license is available for this tool. Contact Randy at AXE Consultants
+    -- for more information.
+    --
+    -- ---------------------------------------
+    --
+    -- Edit History:
+    --
+    --  8/ 8/11 - RLB - Split from base package, mainly to reduce the
+    --                 size of that package.
+    --         - RLB - Added aspect index commands.
+    -- 10/18/11 - RLB - Changed to GPLv3 license.
+    -- 10/19/11 - RLB - Added AspectDefn command.
+    -- 10/20/11 - RLB - Added DeletedPragmaSyn command.
+    -- 10/26/11 - RLB - Added versioned break commands.
+    --  3/27/12 - RLB - Added more versioned break commands.
+    -- 12/17/12 - RLB - Added Ada 2012 AARM headings.
+
+
+    function Command (Name : in ARM_Input.Command_Name_Type) return 
Command_Type is
+       -- Return the command value for a particular command name:
+       Canonical_Name : constant String :=
+           Ada.Characters.Handling.To_Lower (Ada.Strings.Fixed.Trim (Name, 
Ada.Strings.Right));
+    begin
+       if Canonical_Name = "begin" then
+           return Text_Begin;
+       elsif Canonical_Name = "end" then
+           return Text_End;
+       elsif Canonical_Name = "redundant" then
+           return Redundant;
+       elsif Canonical_Name = "comment" then
+           return Comment;
+       elsif Canonical_Name = "noprefix" then
+           return No_Prefix;
+       elsif Canonical_Name = "noparanum" then
+           return No_Para_Num;
+       elsif Canonical_Name = "keepnext" then
+           return Keep_with_Next;
+       elsif Canonical_Name = "leading" then
+           return Leading;
+       elsif Canonical_Name = "trailing" then
+           return Trailing;
+       elsif Canonical_Name = "+" then -- Can't happen directly, but can 
happen through stacking.
+           return Up;
+       elsif Canonical_Name = "-" then -- Can't happen directly, but can 
happen through stacking.
+           return Down;
+       elsif Canonical_Name = "thinline" then
+           return Thin_Line;
+       elsif Canonical_Name = "thickline" then
+           return Thick_Line;
+       elsif Canonical_Name = "tabclear" then
+           return Tab_Clear;
+       elsif Canonical_Name = "tabset" then
+           return Tab_Set;
+       elsif Canonical_Name = "table" then
+           return Table;
+       elsif Canonical_Name = "picturealone" then
+           return Picture_Alone;
+       elsif Canonical_Name = "pictureinline" then
+           return Picture_Inline;
+       elsif Canonical_Name = "last" then
+           return Table_Last;
+       elsif Canonical_Name = "part" then
+           return Part;
+       elsif Canonical_Name = "newpage" then
+           return New_Page;
+       elsif Canonical_Name = "rmnewpage" then
+           return RM_New_Page;
+       elsif Canonical_Name = "softpage" then
+           return Soft_Page;
+       elsif Canonical_Name = "newcolumn" then
+           return New_Column;
+       elsif Canonical_Name = "newpagever" then
+           return New_Page_for_Version;
+       elsif Canonical_Name = "rmnewpagever" then
+           return RM_New_Page_for_Version;
+       elsif Canonical_Name = "notisormnewpagever" then
+           return Not_Iso_RM_New_Page_for_Version;
+       elsif Canonical_Name = "isoonlyrmnewpagever" then
+           return Iso_Only_RM_New_Page_for_Version;
+       elsif Canonical_Name = "newcolumnver" then
+           return New_Column_for_Version;
+       elsif Canonical_Name = "b" or else Canonical_Name = "bold" then
+           return Bold;
+       elsif Canonical_Name = "i" or else Canonical_Name = "italics" then
+           return Italic;
+       elsif Canonical_Name = "r" or else Canonical_Name = "roman" then
+           return Roman;
+       elsif Canonical_Name = "s" or else Canonical_Name = "swiss" then
+           return Swiss;
+       elsif Canonical_Name = "f" or else Canonical_Name = "fixed" then
+           return Fixed;
+       elsif Canonical_Name = "ri" then
+           return Roman_Italic;
+       elsif Canonical_Name = "shrink" then
+           return Shrink;
+       elsif Canonical_Name = "grow" then
+           return Grow;
+       elsif Canonical_Name = "black" then
+           return Black;
+       elsif Canonical_Name = "red" then
+           return Red;
+       elsif Canonical_Name = "green" then
+           return Green;
+       elsif Canonical_Name = "blue" then
+           return Blue;
+       elsif Canonical_Name = "key" then
+           return Keyword;
+       elsif Canonical_Name = "nt" then
+           return Non_Terminal;
+       elsif Canonical_Name = "ntf" then
+           return Non_Terminal_Format;
+       elsif Canonical_Name = "exam" then
+           return Example_Text;
+       elsif Canonical_Name = "examcom" then
+           return Example_Comment;
+       elsif Canonical_Name = "indexlist" then
+           return Index_List;
+       elsif Canonical_Name = "defn" then
+           return Defn;
+       elsif Canonical_Name = "defn2" then
+           return Defn2;
+       elsif Canonical_Name = "rootdefn" then
+           return RootDefn;
+       elsif Canonical_Name = "rootdefn2" then
+           return RootDefn2;
+       elsif Canonical_Name = "pdefn" then
+           return PDefn;
+       elsif Canonical_Name = "pdefn2" then
+           return PDefn2;
+       elsif Canonical_Name = "indexsee" then
+           return Index_See;
+       elsif Canonical_Name = "indexseealso" then
+           return Index_See_Also;
+       elsif Canonical_Name = "seeother" then
+           return See_Other;
+       elsif Canonical_Name = "seealso" then
+           return See_Also;
+       elsif Canonical_Name = "rootlibunit" then
+           return Index_Root_Unit;
+       elsif Canonical_Name = "childunit" then
+           return Index_Child_Unit;
+       elsif Canonical_Name = "subchildunit" then
+           return Index_Subprogram_Child_Unit;
+       elsif Canonical_Name = "adatypedefn" then
+           return Index_Type;
+       elsif Canonical_Name = "adasubtypedefn" then
+           return Index_Subtype;
+       elsif Canonical_Name = "adasubdefn" then
+           return Index_Subprogram;
+       elsif Canonical_Name = "adaexcdefn" then
+           return Index_Exception;
+       elsif Canonical_Name = "adaobjdefn" then
+           return Index_Object;
+       elsif Canonical_Name = "adapackdefn" then
+           return Index_Package;
+       elsif Canonical_Name = "adadefn" then
+           return Index_Other;
+       elsif Canonical_Name = "indexcheck" then
+           return Index_Check;
+       elsif Canonical_Name = "attr" then
+           return Index_Attr;
+       elsif Canonical_Name = "prag" then
+           return Index_Pragma;
+       elsif Canonical_Name = "aspectdefn" then
+           return Index_Aspect;
+       elsif Canonical_Name = "syn" then
+           return Syntax_Rule;
+       elsif Canonical_Name = "syn2" then
+           return Syntax_Term;
+       elsif Canonical_Name = "synf" then
+           return Syntax_Term_Undefined;
+       elsif Canonical_Name = "syni" then
+           return Syntax_Prefix;
+       elsif Canonical_Name = "syntaxsummary" then
+           return Syntax_Summary;
+       elsif Canonical_Name = "syntaxxref" then
+           return Syntax_Xref;
+       elsif Canonical_Name = "addedsyn" then
+           return Added_Syntax_Rule;
+       elsif Canonical_Name = "deletedsyn" then
+           return Deleted_Syntax_Rule;
+       elsif Canonical_Name = "toglossary" then
+           return To_Glossary;
+       elsif Canonical_Name = "toglossaryalso" then
+           return To_Glossary_Also;
+       elsif Canonical_Name = "chgtoglossary" then
+           return Change_To_Glossary;
+       elsif Canonical_Name = "chgtoglossaryalso" then
+           return Change_To_Glossary_Also;
+       elsif Canonical_Name = "glossarylist" then
+           return Glossary_List;
+       elsif Canonical_Name = "prefixtype" then
+           return Prefix_Type;
+       elsif Canonical_Name = "chgprefixtype" then
+           return Change_Prefix_Type;
+       elsif Canonical_Name = "endprefixtype" then
+           return Reset_Prefix_Type;
+       elsif Canonical_Name = "attribute" then
+           return Attribute;
+       elsif Canonical_Name = "attributeleading" then
+           return Attribute_Leading;
+       elsif Canonical_Name = "chgattribute" then
+           return Change_Attribute;
+       elsif Canonical_Name = "attributelist" then
+           return Attribute_List;
+       elsif Canonical_Name = "pragmasyn" then
+           return Pragma_Syntax;
+       elsif Canonical_Name = "pragmalist" then
+           return Pragma_List;
+       elsif Canonical_Name = "addedpragmasyn" then
+           return Added_Pragma_Syntax;
+       elsif Canonical_Name = "deletedpragmasyn" then
+           return Deleted_Pragma_Syntax;
+       elsif Canonical_Name = "impldef" then
+           return Implementation_Defined;
+       elsif Canonical_Name = "chgimpldef" then
+           return Change_Implementation_Defined;
+       elsif Canonical_Name = "impldeflist" then
+           return Implementation_Defined_List;
+       elsif Canonical_Name = "chgimpladvice" then
+           return Change_Implementation_Advice;
+       elsif Canonical_Name = "addedimpladvicelist" then
+           return Added_Implementation_Advice_List;
+       elsif Canonical_Name = "chgdocreq" then
+           return Change_Documentation_Requirement;
+       elsif Canonical_Name = "addeddocreqlist" then
+           return Added_Documentation_Requirements_List;
+       elsif Canonical_Name = "chgaspectdesc" then
+           return Change_Aspect_Description;
+       elsif Canonical_Name = "addedaspectlist" then
+           return Added_Aspect_Description_List;
+       elsif Canonical_Name = "packagelist" then
+           return Package_List;
+       elsif Canonical_Name = "typelist" then
+           return Type_List;
+       elsif Canonical_Name = "subprogramlist" then
+           return Subprogram_List;
+       elsif Canonical_Name = "exceptionlist" then
+           return Exception_List;
+       elsif Canonical_Name = "objectlist" then
+           return Object_List;
+       elsif Canonical_Name = "labeledsection" then
+           return Labeled_Section;
+       elsif Canonical_Name = "labeledsectionnobreak" then
+           return Labeled_Section_No_Break;
+       elsif Canonical_Name = "labeledclause" then
+           return Labeled_Clause;
+       elsif Canonical_Name = "labeledsubclause" then
+           return Labeled_Subclause;
+       elsif Canonical_Name = "labeledsubsubclause" then
+           return Labeled_Subsubclause;
+       elsif Canonical_Name = "labeledannex" then
+           return Labeled_Annex;
+       elsif Canonical_Name = "labeledinformativeannex" then
+           return Labeled_Informative_Annex;
+       elsif Canonical_Name = "labelednormativeannex" then
+           return Labeled_Normative_Annex;
+       elsif Canonical_Name = "unnumberedsection" then
+           return Unnumbered_Section;
+       elsif Canonical_Name = "labeledrevisedannex" then
+           return Labeled_Revised_Annex;
+       elsif Canonical_Name = "labeledrevisedinformativeannex" then
+           return Labeled_Revised_Informative_Annex;
+       elsif Canonical_Name = "labeledrevisednormativeannex" then
+           return Labeled_Revised_Normative_Annex;
+       elsif Canonical_Name = "labeledaddedannex" then
+           return Labeled_Added_Annex;
+       elsif Canonical_Name = "labeledaddedinformativeannex" then
+           return Labeled_Added_Informative_Annex;
+       elsif Canonical_Name = "labeledaddednormativeannex" then
+           return Labeled_Added_Normative_Annex;
+       elsif Canonical_Name = "labeledrevisedsection" then
+           return Labeled_Revised_Section;
+       elsif Canonical_Name = "labeledrevisedclause" then
+           return Labeled_Revised_Clause;
+       elsif Canonical_Name = "labeledrevisedsubclause" then
+           return Labeled_Revised_Subclause;
+       elsif Canonical_Name = "labeledrevisedsubsubclause" then
+           return Labeled_Revised_Subsubclause;
+       elsif Canonical_Name = "labeledaddedsection" then
+           return Labeled_Added_Section;
+       elsif Canonical_Name = "labeledaddedclause" then
+           return Labeled_Added_Clause;
+       elsif Canonical_Name = "labeledaddedsubclause" then
+           return Labeled_Added_Subclause;
+       elsif Canonical_Name = "labeledaddedsubsubclause" then
+           return Labeled_Added_Subsubclause;
+       elsif Canonical_Name = "labeleddeletedclause" then
+           return Labeled_Deleted_Clause;
+       elsif Canonical_Name = "labeleddeletedsubclause" then
+           return Labeled_Deleted_Subclause;
+       elsif Canonical_Name = "labeleddeletedsubsubclause" then
+           return Labeled_Deleted_Subsubclause;
+       elsif Canonical_Name = "subheading" then
+           return Subheading;
+       elsif Canonical_Name = "addedsubheading" then
+           return Added_Subheading;
+       elsif Canonical_Name = "heading" then
+           return Heading;
+       elsif Canonical_Name = "center" then
+           return Center;
+       elsif Canonical_Name = "right" then
+           return Right;
+       elsif Canonical_Name = "prefacesection" then
+           return Preface_Section;
+       elsif Canonical_Name = "refsec" then
+           return Ref_Section;
+       elsif Canonical_Name = "refsecnum" then
+           return Ref_Section_Number;
+       elsif Canonical_Name = "refsecbynum" then
+           return Ref_Section_By_Number;
+       elsif Canonical_Name = "locallink" then
+           return Local_Link;
+       elsif Canonical_Name = "localtarget" then
+           return Local_Target;
+       elsif Canonical_Name = "urllink" then
+           return URL_Link;
+       elsif Canonical_Name = "ailink" then
+           return AI_Link;
+       elsif Canonical_Name = "chg" then
+           return Change;
+       elsif Canonical_Name = "chgadded" then
+           return Change_Added;
+       elsif Canonical_Name = "chgdeleted" then
+           return Change_Deleted;
+       elsif Canonical_Name = "chgref" then
+           return Change_Reference;
+       elsif Canonical_Name = "chgnote" then
+           return Change_Note;
+       elsif Canonical_Name = "introname" then
+           return Intro_Name;
+       elsif Canonical_Name = "syntaxname" then
+           return Syntax_Name;
+       elsif Canonical_Name = "resolutionname" then
+           return Resolution_Name;
+       elsif Canonical_Name = "legalityname" then
+           return Legality_Name;
+       elsif Canonical_Name = "staticsemname" then
+           return Static_Name;
+       elsif Canonical_Name = "linktimename" then
+           return Link_Name;
+       elsif Canonical_Name = "runtimename" then
+           return Run_Name;
+       elsif Canonical_Name = "boundedname" then
+           return Bounded_Name;
+       elsif Canonical_Name = "erronname" then
+           return Erroneous_Name;
+       elsif Canonical_Name = "implreqname" then
+           return Req_Name;
+       elsif Canonical_Name = "docreqname" then
+           return Doc_Name;
+       elsif Canonical_Name = "metricsname" then
+           return Metrics_Name;
+       elsif Canonical_Name = "implpermname" then
+           return Permission_Name;
+       elsif Canonical_Name = "impladvicename" then
+           return Advice_Name;
+       elsif Canonical_Name = "notesname" then
+           return Notes_Name;
+       elsif Canonical_Name = "singlenotename" then
+           return Single_Note_Name;
+       elsif Canonical_Name = "examplesname" then
+           return Examples_Name;
+       elsif Canonical_Name = "metarulesname" then
+           return Meta_Name;
+       elsif Canonical_Name = "inconsistent83name" then
+           return Inconsistent83_Name;
+       elsif Canonical_Name = "incompatible83name" then
+           return Incompatible83_Name;
+       elsif Canonical_Name = "extend83name" then
+           return Extend83_Name;
+       elsif Canonical_Name = "diffword83name" then
+           return Wording83_Name;
+       elsif Canonical_Name = "inconsistent95name" then
+           return Inconsistent95_Name;
+       elsif Canonical_Name = "incompatible95name" then
+           return Incompatible95_Name;
+       elsif Canonical_Name = "extend95name" then
+           return Extend95_Name;
+       elsif Canonical_Name = "diffword95name" then
+           return Wording95_Name;
+       elsif Canonical_Name = "inconsistent2005name" then
+           return Inconsistent2005_Name;
+       elsif Canonical_Name = "incompatible2005name" then
+           return Incompatible2005_Name;
+       elsif Canonical_Name = "extend2005name" then
+           return Extend2005_Name;
+       elsif Canonical_Name = "diffword2005name" then
+           return Wording2005_Name;
+       elsif Canonical_Name = "inconsistent2012name" then
+           return Inconsistent2012_Name;
+       elsif Canonical_Name = "incompatible2012name" then
+           return Incompatible2012_Name;
+       elsif Canonical_Name = "extend2012name" then
+           return Extend2012_Name;
+       elsif Canonical_Name = "diffword2012name" then
+           return Wording2012_Name;
+       elsif Canonical_Name = "syntaxtitle" then
+           return Syntax_Title;
+       elsif Canonical_Name = "resolutiontitle" then
+           return Resolution_Title;
+       elsif Canonical_Name = "legalitytitle" then
+           return Legality_Title;
+       elsif Canonical_Name = "staticsemtitle" then
+           return Static_Title;
+       elsif Canonical_Name = "linktimetitle" then
+           return Link_Title;
+       elsif Canonical_Name = "runtimetitle" then
+           return Run_Title;
+       elsif Canonical_Name = "boundedtitle" then
+           return Bounded_Title;
+       elsif Canonical_Name = "errontitle" then
+           return Erroneous_Title;
+       elsif Canonical_Name = "implreqtitle" then
+           return Req_Title;
+       elsif Canonical_Name = "docreqtitle" then
+           return Doc_Title;
+       elsif Canonical_Name = "metricstitle" then
+           return Metrics_Title;
+       elsif Canonical_Name = "implpermtitle" then
+           return Permission_Title;
+       elsif Canonical_Name = "impladvicetitle" then
+           return Advice_Title;
+       elsif Canonical_Name = "notestitle" then
+           return Notes_Title;
+       elsif Canonical_Name = "singlenotetitle" then
+           return Single_Note_Title;
+       elsif Canonical_Name = "examplestitle" then
+           return Examples_Title;
+       elsif Canonical_Name = "metarulestitle" then
+           return Meta_Title;
+       elsif Canonical_Name = "inconsistent83title" then
+           return Inconsistent83_Title;
+       elsif Canonical_Name = "incompatible83title" then
+           return Incompatible83_Title;
+       elsif Canonical_Name = "extend83title" then
+           return Extend83_Title;
+       elsif Canonical_Name = "diffword83title" then
+           return Wording83_Title;
+       elsif Canonical_Name = "inconsistent95title" then
+           return Inconsistent95_Title;
+       elsif Canonical_Name = "incompatible95title" then
+           return Incompatible95_Title;
+       elsif Canonical_Name = "extend95title" then
+           return Extend95_Title;
+       elsif Canonical_Name = "diffword95title" then
+           return Wording95_Title;
+       elsif Canonical_Name = "inconsistent2005title" then
+           return Inconsistent2005_Title;
+       elsif Canonical_Name = "incompatible2005title" then
+           return Incompatible2005_Title;
+       elsif Canonical_Name = "extend2005title" then
+           return Extend2005_Title;
+       elsif Canonical_Name = "diffword2005title" then
+           return Wording2005_Title;
+       elsif Canonical_Name = "inconsistent2012title" then
+           return Inconsistent2012_Title;
+       elsif Canonical_Name = "incompatible2012title" then
+           return Incompatible2012_Title;
+       elsif Canonical_Name = "extend2012title" then
+           return Extend2012_Title;
+       elsif Canonical_Name = "diffword2012title" then
+           return Wording2012_Title;
+       elsif Canonical_Name = "em" then
+           return EM_Dash;
+       elsif Canonical_Name = "en" then
+           return EN_Dash;
+       elsif Canonical_Name = "lt" then
+           return LT;
+       elsif Canonical_Name = "leq" then
+           return LE;
+       elsif Canonical_Name = "gt" then
+           return GT;
+       elsif Canonical_Name = "geq" then
+           return GE;
+       elsif Canonical_Name = "neq" then
+           return NE;
+       elsif Canonical_Name = "pi" then
+           return PI;
+       elsif Canonical_Name = "times" then
+           return Times;
+       elsif Canonical_Name = "porm" then
+           return PorM;
+       elsif Canonical_Name = "singlequote" then
+           return Single_Quote;
+       elsif Canonical_Name = "latin1" then
+           return LATIN_1;
+       elsif Canonical_Name = "unicode" then
+           return Unicode;
+       elsif Canonical_Name = "ceiling" then
+           return Ceiling;
+       elsif Canonical_Name = "floor" then
+           return Floor;
+       elsif Canonical_Name = "abs" then
+           return Absolute;
+       elsif Canonical_Name = "log" then
+           return Log;
+       elsif Canonical_Name = "thin" then
+           return Thin_Space;
+       elsif Canonical_Name = "lquote" then
+           return Left_Quote;
+       elsif Canonical_Name = "lquotes" then
+           return Left_Quote_Pair;
+       elsif Canonical_Name = "ldquote" then
+           return Left_Double_Quote;
+       elsif Canonical_Name = "rquote" then
+           return Right_Quote;
+       elsif Canonical_Name = "rquotes" then
+           return Right_Quote_Pair;
+       elsif Canonical_Name = "rdquote" then
+           return Right_Double_Quote;
+       elsif Canonical_Name = "smldotlessi" then
+           return Small_Dotless_I;
+       elsif Canonical_Name = "capdottedi" then
+           return Capital_Dotted_I;
+       else
+           return Unknown;
+       end if;
+    end Command;
+
+end ARM_Format.Data;
diff --git a/progs/arm_frmd.ads b/progs/arm_frmd.ads
new file mode 100755
index 0000000..7e64fff
--- /dev/null
+++ b/progs/arm_frmd.ads
@@ -0,0 +1,319 @@
+private package ARM_Format.Data is
+
+    --
+    -- Ada reference manual formatter (ARM_Form).
+    --
+    -- This package contains various data used by the input file parser.
+    --
+    -- ---------------------------------------
+    -- Copyright 2011, 2012  AXE Consultants. All rights reserved.
+    -- P.O. Box 1512, Madison WI  53701
+    -- E-Mail: randy@rrsoftware.com
+    --
+    -- ARM_Form is free software: you can redistribute it and/or modify
+    -- it under the terms of the GNU General Public License version 3
+    -- as published by the Free Software Foundation.
+    --
+    -- AXE CONSULTANTS MAKES THIS TOOL AND SOURCE CODE AVAILABLE ON AN "AS IS"
+    -- BASIS AND MAKES NO WARRANTY, EXPRESS OR IMPLIED, AS TO THE ACCURACY,
+    -- CAPABILITY, EFFICIENCY, MERCHANTABILITY, OR FUNCTIONING OF THIS TOOL.
+    -- IN NO EVENT WILL AXE CONSULTANTS BE LIABLE FOR ANY GENERAL,
+    -- CONSEQUENTIAL, INDIRECT, INCIDENTAL, EXEMPLARY, OR SPECIAL DAMAGES,
+    -- EVEN IF AXE CONSULTANTS HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
+    -- DAMAGES.
+    --
+    -- A copy of the GNU General Public License is available in the file
+    -- gpl-3-0.txt in the standard distribution of the ARM_Form tool.
+    -- Otherwise, see <http://www.gnu.org/licenses/>.
+    --
+    -- If the GPLv3 license is not satisfactory for your needs, a commercial
+    -- use license is available for this tool. Contact Randy at AXE Consultants
+    -- for more information.
+    --
+    -- ---------------------------------------
+    --
+    -- Edit History:
+    --
+    --  8/ 8/11 - RLB - Split from base package, mainly to reduce the
+    --                 size of that package.
+    --         - RLB - Added aspect index commands.
+    -- 10/18/11 - RLB - Changed to GPLv3 license.
+    -- 10/19/11 - RLB - Added AspectDefn command.
+    -- 10/20/11 - RLB - Added DeletedPragmaSyn command.
+    -- 10/26/11 - RLB - Added versioned break commands.
+    --  3/27/12 - RLB - Added more versioned break commands.
+    -- 10/18/12 - RLB - Added more specific hanging_indent commands.
+    -- 12/17/12 - RLB - Added Ada 2012 AARM headings.
+
+
+    type LString is record
+       Length : Natural;
+       Str : String(1..40);
+    end record;
+    Paragraph_Kind_Name : constant array (Paragraph_Type) of LString :=
+       (Plain           => (Length =>  0, Str => (others => ' ')), -- Not used.
+        Introduction    => (Length => 17, Str => "Introductory Text            
           "), -- IntroName
+        Language_Design => (Length => 25, Str => "Language Design Principle    
           "), -- MetaRulesName
+        Syntax          => (Length => 11, Str => "Syntax Rule                  
           "), -- SyntaxName
+        Resolution      => (Length => 20, Str => "Name Resolution Rule         
           "), -- ResolutionName
+        Legality        => (Length => 13, Str => "Legality Rule                
           "), -- LegalityName
+        Static_Semantics=> (Length => 20, Str => "Static Semantic Item         
           "), -- StaticSemName
+        Link_Time       => (Length => 21, Str => "Post-Compilation Rule        
           "), -- LinkTimeName
+        Run_Time        => (Length => 21, Str => "Dynamic Semantic Item        
           "), -- RunTimeName
+        Bounded_Errors  => (Length => 24, Str => "Bounded (Run-Time) Error     
           "), -- BoundedName
+        Erroneous       => (Length => 19, Str => "Erroneous Execution          
           "), -- ErronName
+        Requirements    => (Length => 26, Str => "Implementation Requirement   
           "), -- ImplReqName
+        Documentation   => (Length => 25, Str => "Documentation Requirement    
           "), -- DocReqName
+        Metrics         => (Length =>  6, Str => "Metric                       
           "), -- MetricsName
+        Permissions     => (Length => 25, Str => "Implementation Permission    
           "), -- ImplPermName
+        Advice          => (Length => 21, Str => "Implementation Advice        
           "), -- ImplAdviceName
+        Notes           => (Length =>  4, Str => "Note                         
           "), -- NotesName
+        Single_Note     => (Length =>  4, Str => "Note                         
           "), -- SimpleNoteName
+        Examples        => (Length =>  7, Str => "Example                      
           "), -- ExamplesName
+        Ada83_Inconsistencies
+                        => (Length => 25, Str => "Inconsistency with Ada 83    
           "), -- Inconsistent83Name
+        Ada83_Incompatibilities
+                        => (Length => 27, Str => "Incompatibility with Ada 83  
           "), -- Incompatible83Name
+        Ada83_Extensions=> (Length => 19, Str => "Extension to Ada 83          
           "), -- Extend83Name
+        Ada83_Wording   => (Length => 26, Str => "Wording Change from Ada 83   
           "), -- DiffWord83Name
+        Ada95_Inconsistencies
+                        => (Length => 25, Str => "Inconsistency with Ada 95    
           "), -- Inconsistent95Name
+        Ada95_Incompatibilities
+                        => (Length => 27, Str => "Incompatibility with Ada 95  
           "), -- Incompatible95Name
+        Ada95_Extensions=> (Length => 19, Str => "Extension to Ada 95          
           "), -- Extend95Name
+        Ada95_Wording   => (Length => 26, Str => "Wording Change from Ada 95   
           "), -- DiffWord95Name
+        Ada2005_Inconsistencies
+                        => (Length => 27, Str => "Inconsistency with Ada 2005  
           "), -- Inconsistent2005Name
+        Ada2005_Incompatibilities
+                        => (Length => 29, Str => "Incompatibility with Ada 
2005           "), -- Incompatible2005Name
+        Ada2005_Extensions
+                        => (Length => 21, Str => "Extension to Ada 2005        
           "), -- Extend2005Name
+        Ada2005_Wording => (Length => 28, Str => "Wording Change from Ada 2005 
           "), -- DiffWord2005Name
+        Ada2012_Inconsistencies
+                        => (Length => 27, Str => "Inconsistency with Ada 2012  
           "), -- Inconsistent2012Name
+        Ada2012_Incompatibilities
+                        => (Length => 29, Str => "Incompatibility with Ada 
2012           "), -- Incompatible2012Name
+        Ada2012_Extensions
+                        => (Length => 21, Str => "Extension to Ada 2012        
           "), -- Extend2012Name
+        Ada2012_Wording => (Length => 28, Str => "Wording Change from Ada 2012 
           "), -- DiffWord2012Name
+        Element_Ref     => (Length =>  0, Str => (others => ' ')), -- Not used.
+        Child_Ref       => (Length =>  0, Str => (others => ' ')), -- Not used.
+        Usage_Note      => (Length =>  0, Str => (others => ' ')), -- Not used.
+        Reason          => (Length =>  0, Str => (others => ' ')), -- Not used.
+        Ramification    => (Length =>  0, Str => (others => ' ')), -- Not used.
+        Proof           => (Length =>  0, Str => (others => ' ')), -- Not used.
+        Imp_Note        => (Length =>  0, Str => (others => ' ')), -- Not used.
+        Corr_Change     => (Length =>  0, Str => (others => ' ')), -- Not used.
+        Discussion      => (Length =>  0, Str => (others => ' ')), -- Not used.
+        Honest          => (Length =>  0, Str => (others => ' ')), -- Not used.
+        Glossary_Marker => (Length =>  0, Str => (others => ' ')), -- Not used.
+        Bare_Annotation => (Length =>  0, Str => (others => ' ')), -- Not used.
+        Wide_Above      => (Length =>  0, Str => (others => ' ')), -- Not used.
+        Example_Text    => (Length =>  0, Str => (others => ' ')), -- Not used.
+        Child_Example_Text => (Length =>  0, Str => (others => ' ')), -- Not 
used.
+        Indented_Example_Text=>(Length =>  0, Str => (others => ' ')), -- Not 
used.
+        Code_Indented   => (Length =>  0, Str => (others => ' ')), -- Not used.
+        Indent          => (Length =>  0, Str => (others => ' ')), -- Not used.
+        Bulleted        => (Length =>  0, Str => (others => ' ')), -- Not used.
+        Nested_Bulleted => (Length =>  0, Str => (others => ' ')), -- Not used.
+        Nested_X2_Bulleted=>(Length=>  0, Str => (others => ' ')), -- Not used.
+        Display         => (Length =>  0, Str => (others => ' ')), -- Not used.
+        Syntax_Display  => (Length =>  0, Str => (others => ' ')), -- Not used.
+        Syntax_Indented => (Length =>  0, Str => (others => ' ')), -- Not used.
+        Syntax_Production=>(Length =>  0, Str => (others => ' ')), -- Not used.
+        Enumerated      => (Length =>  0, Str => (others => ' ')), -- Not used.
+        Nested_Enumerated=>(Length =>  0, Str => (others => ' ')), -- Not used.
+        Hanging_Indented_1=>(Length => 0, Str => (others => ' ')), -- Not used.
+        Hanging_Indented_2=>(Length => 0, Str => (others => ' ')), -- Not used.
+        Hanging_Indented_3=>(Length => 0, Str => (others => ' ')), -- Not used.
+        Hanging_Indented_4=>(Length => 0, Str => (others => ' ')), -- Not used.
+        Small           => (Length =>  0, Str => (others => ' ')), -- Not used.
+        Title           => (Length =>  0, Str => (others => ' ')), -- Not used.
+        In_Table        => (Length =>  0, Str => (others => ' '))); -- Not 
used.
+
+    Paragraph_Kind_Title : constant array (Paragraph_Type) of LString :=
+       (Plain           => (Length =>  0, Str => (others => ' ')),
+        Introduction    => (Length =>  0, Str => (others => ' ')), -- 
IntroTitle (deleted).
+        Language_Design => (Length => 26, Str => "Language Design Principles   
           "), -- MetaRulesTitle
+        Syntax          => (Length =>  6, Str => "Syntax                       
           "), -- SyntaxTitle
+        Resolution      => (Length => 21, Str => "Name Resolution Rules        
           "), -- ResolutionTitle
+        Legality        => (Length => 14, Str => "Legality Rules               
           "), -- LegalityTitle
+        Static_Semantics=> (Length => 16, Str => "Static Semantics             
           "), -- StaticSemTitle
+        Link_Time       => (Length => 22, Str => "Post-Compilation Rules       
           "), -- LinkTimeTitle
+        Run_Time        => (Length => 17, Str => "Dynamic Semantics            
           "), -- RunTimeTitle
+        Bounded_Errors  => (Length => 25, Str => "Bounded (Run-Time) Errors    
           "), -- BoundedTitle
+        Erroneous       => (Length => 19, Str => "Erroneous Execution          
           "), -- ErronTitle
+        Requirements    => (Length => 27, Str => "Implementation Requirements  
           "), -- ImplReqTitle
+        Documentation   => (Length => 26, Str => "Documentation Requirements   
           "), -- DocReqTitle
+        Metrics         => (Length =>  7, Str => "Metrics                      
           "), -- MetricsTitle
+        Permissions     => (Length => 26, Str => "Implementation Permissions   
           "), -- ImplPermTitle
+        Advice          => (Length => 21, Str => "Implementation Advice        
           "), -- ImplAdviceTitle
+        Notes           => (Length =>  5, Str => "NOTES                        
           "), -- NotesTitle
+        Single_Note     => (Length =>  5, Str => "NOTES                        
           "), -- SimpleNoteTitle
+        Examples        => (Length =>  8, Str => "Examples                     
           "), -- ExamplesTitle
+        Ada83_Inconsistencies
+                        => (Length => 27, Str => "Inconsistencies With Ada 83  
           "), -- Inconsistent83Title
+        Ada83_Incompatibilities
+                        => (Length => 29, Str => "Incompatibilities With Ada 
83           "), -- Incompatible83Title
+        Ada83_Extensions=> (Length => 20, Str => "Extensions to Ada 83         
           "), -- Extend83Title
+        Ada83_Wording   => (Length => 27, Str => "Wording Changes from Ada 83  
           "), -- DiffWord83Title
+        Ada95_Inconsistencies
+                        => (Length => 27, Str => "Inconsistencies With Ada 95  
           "), -- Inconsistent95Title
+        Ada95_Incompatibilities
+                        => (Length => 29, Str => "Incompatibilities With Ada 
95           "), -- Incompatible95Title
+        Ada95_Extensions=> (Length => 20, Str => "Extensions to Ada 95         
           "), -- Extend95Title
+        Ada95_Wording   => (Length => 27, Str => "Wording Changes from Ada 95  
           "), -- DiffWord95Title
+        Ada2005_Inconsistencies
+                        => (Length => 29, Str => "Inconsistencies With Ada 
2005           "), -- Inconsistent2005Title
+        Ada2005_Incompatibilities
+                        => (Length => 31, Str => "Incompatibilities With Ada 
2005         "), -- Incompatible2005Title
+        Ada2005_Extensions
+                        => (Length => 22, Str => "Extensions to Ada 2005       
           "), -- Extend2005Title
+        Ada2005_Wording => (Length => 29, Str => "Wording Changes from Ada 
2005           "), -- DiffWord2005Title
+        Ada2012_Inconsistencies
+                        => (Length => 29, Str => "Inconsistencies With Ada 
2012           "), -- Inconsistent2012Title
+        Ada2012_Incompatibilities
+                        => (Length => 31, Str => "Incompatibilities With Ada 
2012         "), -- Incompatible2012Title
+        Ada2012_Extensions
+                        => (Length => 22, Str => "Extensions to Ada 2012       
           "), -- Extend2012Title
+        Ada2012_Wording => (Length => 29, Str => "Wording Changes from Ada 
2012           "), -- DiffWord2012Title
+        Element_Ref     => (Length => 19, Str => "Element Reference:           
           "), -- Paragraph start.
+        Child_Ref       => (Length => 28, Str => "Child Elements returned by:  
           "), -- Paragraph start.
+        Usage_Note      => (Length => 12, Str => "Usage Note:                  
           "), -- Paragraph start.
+        Reason          => (Length =>  8, Str => "Reason:                      
           "), -- Paragraph start.
+        Ramification    => (Length => 14, Str => "Ramification:                
           "), -- Paragraph start.
+        Proof           => (Length =>  7, Str => "Proof:                       
           "), -- Paragraph start.
+        Imp_Note        => (Length => 21, Str => "Implementation Note:         
           "), -- Paragraph start.
+        Corr_Change     => (Length =>  8, Str => "Change:                      
           "), -- Paragraph start.
+        Discussion      => (Length => 12, Str => "Discussion:                  
           "), -- Paragraph start.
+        Honest          => (Length => 14, Str => "To be honest:                
           "), -- Paragraph start.
+        Glossary_Marker => (Length => 16, Str => "Glossary entry:              
           "), -- Paragraph start.
+        Bare_Annotation => (Length =>  0, Str => (others => ' ')), -- Not used.
+        Wide_Above      => (Length =>  0, Str => (others => ' ')), -- Not used.
+        Example_Text    => (Length =>  0, Str => (others => ' ')), -- Not used.
+        Child_Example_Text => (Length =>  0, Str => (others => ' ')), -- Not 
used.
+        Indented_Example_Text=>(Length =>  0, Str => (others => ' ')), -- Not 
used.
+        Code_Indented   => (Length =>  0, Str => (others => ' ')), -- Not used.
+        Indent          => (Length =>  0, Str => (others => ' ')), -- Not used.
+        Bulleted        => (Length =>  0, Str => (others => ' ')), -- Not used.
+        Nested_Bulleted => (Length =>  0, Str => (others => ' ')), -- Not used.
+        Nested_X2_Bulleted=>(Length=>  0, Str => (others => ' ')), -- Not used.
+        Display         => (Length =>  0, Str => (others => ' ')), -- Not used.
+        Syntax_Display  => (Length =>  0, Str => (others => ' ')), -- Not used.
+        Syntax_Indented => (Length =>  0, Str => (others => ' ')), -- Not used.
+        Syntax_Production=>(Length =>  0, Str => (others => ' ')), -- Not used.
+        Enumerated      => (Length =>  0, Str => (others => ' ')), -- Not used.
+        Nested_Enumerated=>(Length =>  0, Str => (others => ' ')), -- Not used.
+        Hanging_Indented_1=>(Length => 0, Str => (others => ' ')), -- Not used.
+        Hanging_Indented_2=>(Length => 0, Str => (others => ' ')), -- Not used.
+        Hanging_Indented_3=>(Length => 0, Str => (others => ' ')), -- Not used.
+        Hanging_Indented_4=>(Length => 0, Str => (others => ' ')), -- Not used.
+        Small           => (Length =>  0, Str => (others => ' ')), -- Not used.
+        Title           => (Length =>  0, Str => (others => ' ')), -- Not used.
+        In_Table        => (Length =>  0, Str => (others => ' '))); -- Not 
used.
+
+
+    type Command_Type is (
+       -- Paragraphs:
+       Text_Begin, Text_End, Redundant, Comment, Part, New_Page, Soft_Page,
+       New_Column, RM_New_Page, New_Page_for_Version, New_Column_for_Version,
+       RM_New_Page_for_Version, Not_Iso_RM_New_Page_for_Version,
+       Iso_Only_RM_New_Page_for_Version,
+       -- Basic text formatting:
+       Bold, Italic, Roman, Swiss, Fixed, Roman_Italic, Shrink, Grow,
+       Black, Red, Green, Blue,
+       Keyword, Non_Terminal, Non_Terminal_Format,
+       Example_Text, Example_Comment,
+       No_Prefix, No_Para_Num, Keep_with_Next,
+        Leading, Trailing, Up, Down, Thin_Line, Thick_Line, Tab_Clear, Tab_Set,
+       -- Tables:
+       Table, Table_Param_Caption, Table_Param_Header, Table_Param_Body, 
Table_Last,
+       -- Pictures:
+       Picture_Alone, Picture_Inline,
+        -- Indexing:
+       Index_List,
+       Defn, RootDefn, PDefn, Defn2, RootDefn2, PDefn2, Index_See,
+       Index_See_Also, See_Other, See_Also,
+       Index_Root_Unit, Index_Child_Unit, Index_Subprogram_Child_Unit,
+       Index_Type, Index_Subtype, Index_Subprogram,
+       Index_Exception, Index_Object, Index_Package,
+       Index_Other, Index_Check, Index_Attr, Index_Pragma, Index_Aspect,
+       -- Clause labels:
+       Labeled_Section, Labeled_Section_No_Break, Labeled_Clause,
+       Labeled_Subclause, Labeled_Subsubclause,
+       Labeled_Revised_Section, Labeled_Revised_Clause, 
Labeled_Revised_Subclause, Labeled_Revised_Subsubclause,
+        Labeled_Added_Section, Labeled_Added_Clause, Labeled_Added_Subclause, 
Labeled_Added_Subsubclause,
+        Labeled_Deleted_Clause, Labeled_Deleted_Subclause, 
Labeled_Deleted_Subsubclause,
+       Preface_Section,
+       Labeled_Annex, Labeled_Revised_Annex, Labeled_Added_Annex,
+       Labeled_Informative_Annex, Labeled_Revised_Informative_Annex,
+        Labeled_Added_Informative_Annex,
+       Labeled_Normative_Annex, Labeled_Revised_Normative_Annex,
+        Labeled_Added_Normative_Annex,
+       Unnumbered_Section, Subheading, Heading, Center, Right,
+        Added_Subheading,
+       -- Clause references:
+       Ref_Section, Ref_Section_Number, Ref_Section_by_Number,
+       -- Links:
+       Local_Target, Local_Link, URL_Link, AI_Link,
+       -- Information:
+       Syntax_Rule, Syntax_Rule_RHS, Syntax_Term, Syntax_Term_Undefined,
+       Syntax_Prefix, Syntax_Summary, Syntax_Xref,
+       Added_Syntax_Rule, Deleted_Syntax_Rule,
+       Implementation_Defined, Implementation_Defined_List,
+       To_Glossary, To_Glossary_Also,
+       Change_To_Glossary, Change_To_Glossary_Also,
+       Glossary_Text_Param, -- This is a parameter of the last four.
+       Glossary_List,
+        Prefix_Type, Reset_Prefix_Type, Attribute, Attribute_Leading, 
Attribute_Text_Param, -- The last is a parameter of Attribute.
+       Attribute_List,
+       Pragma_Syntax, Pragma_List, Added_Pragma_Syntax, Deleted_Pragma_Syntax,
+       Package_List, Type_List, Subprogram_List, Exception_List, Object_List,
+       -- Corrigendum changes:
+       Change, Change_Param_Old, Change_Param_New, -- The latter are the 
parameters of "Change".
+       Change_Reference, Change_Note,
+       Change_Added, Change_Added_Param, Change_Deleted, Change_Deleted_Param,
+       Change_Implementation_Defined,
+       Change_Impdef_Text_Param, -- This is a parameter of the previous.
+       Change_Implementation_Advice,
+       Change_Impladv_Text_Param, -- This is a parameter of the previous.
+       Added_Implementation_Advice_List,
+       Change_Documentation_Requirement,
+       Change_DocReq_Text_Param, -- This is a parameter of the previous.
+       Added_Documentation_Requirements_List,
+       Change_Aspect_Description,
+       Change_AspectDesc_Text_Param, -- This is a parameter of the previous.
+       Added_Aspect_Description_List,
+       Change_Attribute, Change_Prefix_Type,
+       Change_Prefix_Text_Param, -- This is a parameter of the previous.
+       -- Text macros:
+       Intro_Name, Syntax_Name, Resolution_Name, Legality_Name, Static_Name,
+       Link_Name, Run_Name, Bounded_Name, Erroneous_Name, Req_Name,
+       Doc_Name, Metrics_Name, Permission_Name, Advice_Name, Notes_Name,
+       Single_Note_Name, Examples_Name, Meta_Name, Inconsistent83_Name,
+       Incompatible83_Name, Extend83_Name, Wording83_Name,
+       Inconsistent95_Name, Incompatible95_Name, Extend95_Name, Wording95_Name,
+       Inconsistent2005_Name, Incompatible2005_Name, Extend2005_Name, 
Wording2005_Name,
+       Inconsistent2012_Name, Incompatible2012_Name, Extend2012_Name, 
Wording2012_Name,
+       Syntax_Title, Resolution_Title, Legality_Title, Static_Title,
+       Link_Title, Run_Title, Bounded_Title, Erroneous_Title, Req_Title,
+       Doc_Title, Metrics_Title, Permission_Title, Advice_Title, Notes_Title,
+       Single_Note_Title,
+       Examples_Title, Meta_Title, Inconsistent83_Title, Incompatible83_Title,
+       Extend83_Title, Wording83_Title, Inconsistent95_Title, 
Incompatible95_Title,
+       Extend95_Title, Wording95_Title, Inconsistent2005_Title, 
Incompatible2005_Title,
+       Extend2005_Title, Wording2005_Title, Inconsistent2012_Title, 
Incompatible2012_Title,
+       Extend2012_Title, Wording2012_Title,
+       -- Character macros:
+       EM_Dash, EN_Dash, LE, LT, GE, GT, NE, PI, Times, PorM, Single_Quote,
+       Latin_1, Unicode, Ceiling, Floor, Absolute, Log, Thin_Space,
+       Left_Quote, Right_Quote, Left_Double_Quote, Right_Double_Quote,
+       Left_Quote_Pair, Right_Quote_Pair, Small_Dotless_I, Capital_Dotted_I,
+       Unknown);
+
+
+    function Command (Name : in ARM_Input.Command_Name_Type)
+        return Command_Type;
+       -- Return the command value for a particular command name:
+
+end ARM_Format.Data;
\ No newline at end of file
diff --git a/progs/arm_frms.adb b/progs/arm_frms.adb
new file mode 100755
index 0000000..8dc3d50
--- /dev/null
+++ b/progs/arm_frms.adb
@@ -0,0 +1,1016 @@
+    --
+    -- Ada reference manual formatter (ARM_Form).
+    --
+    -- This subprogram is part of the command processor.
+    --
+    -- We use dispatching calls to call the formatter, so the details of
+    -- formatting are insulated from the code that reads the source and
+    -- determines the details of the text.
+    --
+    -- ---------------------------------------
+    -- Copyright 2000, 2002, 2004, 2005, 2006, 2007, 2009, 2011
+    --   AXE Consultants. All rights reserved.
+    -- P.O. Box 1512, Madison WI  53701
+    -- E-Mail: randy@rrsoftware.com
+    --
+    -- ARM_Form is free software: you can redistribute it and/or modify
+    -- it under the terms of the GNU General Public License version 3
+    -- as published by the Free Software Foundation.
+    --
+    -- AXE CONSULTANTS MAKES THIS TOOL AND SOURCE CODE AVAILABLE ON AN "AS IS"
+    -- BASIS AND MAKES NO WARRANTY, EXPRESS OR IMPLIED, AS TO THE ACCURACY,
+    -- CAPABILITY, EFFICIENCY, MERCHANTABILITY, OR FUNCTIONING OF THIS TOOL.
+    -- IN NO EVENT WILL AXE CONSULTANTS BE LIABLE FOR ANY GENERAL,
+    -- CONSEQUENTIAL, INDIRECT, INCIDENTAL, EXEMPLARY, OR SPECIAL DAMAGES,
+    -- EVEN IF AXE CONSULTANTS HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
+    -- DAMAGES.
+    --
+    -- A copy of the GNU General Public License is available in the file
+    -- gpl-3-0.txt in the standard distribution of the ARM_Form tool.
+    -- Otherwise, see <http://www.gnu.org/licenses/>.
+    --
+    -- If the GPLv3 license is not satisfactory for your needs, a commercial
+    -- use license is available for this tool. Contact Randy at AXE Consultants
+    -- for more information.
+    --
+    -- ---------------------------------------
+    --
+    -- Edit History:
+    --
+    --  2/10/06 - RLB - Split from base package.
+    --  9/22/06 - RLB - Revised to use Clause_Number_Type, and to support
+    --                 Subsubclauses.
+    -- 10/16/06 - RLB - Added definition of old non-terminals for NT linking.
+    --  2/16/07 - RLB - Added missing code to handle comments here.
+    --  7/31/07 - RLB - Added code to detect duplicated titles.
+    -- 12/18/07 - RLB - Added Plain_Annex and associated commands.
+    --  5/06/09 - RLB - Added Labeled_Deleted_xxx.
+    --  5/07/09 - RLB - Changed above to load dead clauses.
+    -- 10/18/11 - RLB - Changed to GPLv3 license.
+
+separate(ARM_Format)
+procedure Scan (Format_Object : in out Format_Type;
+               File_Name : in String;
+               Section_Number : in ARM_Contents.Section_Number_Type;
+               Starts_New_Section : in Boolean) is
+    -- Scans the contents for File_Name, determining the table of contents
+    -- for the section. The results are written to the contents package.
+    -- Starts_New_Section is True if the file starts a new section.
+    -- Section_Number is the number (or letter) of the section.
+
+    type Items is record
+        Command : Command_Type;
+        Close_Char : Character; -- Ought to be }, ], >, or ).
+    end record;
+    Nesting_Stack : array (1 .. 60) of Items;
+    Nesting_Stack_Ptr : Natural := 0;
+    Saw_a_Section_Header : Boolean := False;
+
+    Input_Object : ARM_File.File_Input_Type;
+
+    procedure Set_Nesting_for_Command (Command : in Command_Type;
+                                      Param_Ch : in Character) is
+        -- Push the command onto the nesting stack.
+    begin
+        if Nesting_Stack_Ptr < Nesting_Stack'Last then
+           Nesting_Stack_Ptr := Nesting_Stack_Ptr + 1;
+           Nesting_Stack (Nesting_Stack_Ptr) :=
+               (Command => Command,
+                Close_Char => ARM_Input.Get_Close_Char (Param_Ch));
+--Ada.Text_IO.Put_Line (" &Stack (" & Command_Type'Image(Command) & "); 
Close-Char=" &
+--  Nesting_Stack(Nesting_Stack_Ptr).Close_Char);
+        else
+           Ada.Text_IO.Put_Line ("** Nesting stack overflow on line" & 
ARM_File.Line_String (Input_Object));
+           for I in reverse Nesting_Stack'range loop
+               Ada.Text_IO.Put_Line ("-- Command at" & Natural'Image(I) & " 
has a close char of '" &
+                   Nesting_Stack (Nesting_Stack_Ptr).Close_Char & "' for " & 
Command_Type'Image(Nesting_Stack (Nesting_Stack_Ptr).Command));
+           end loop;
+           raise Program_Error;
+        end if;
+    end Set_Nesting_for_Command;
+
+
+    procedure Scan_Command_with_Parameter is
+        -- Scan the start of a command with a parameter.
+        -- The parameter character has been scanned, and
+        -- a stack item pushed.
+        Title : ARM_Contents.Title_Type;
+        Title_Length : Natural;
+
+        procedure Get_Change_Version (Is_First : in Boolean;
+                                     Version : out 
ARM_Contents.Change_Version_Type) is
+           -- Get a parameter named "Version", containing a character
+           -- representing the version number.
+           Ch, Close_Ch : Character;
+        begin
+           ARM_Input.Check_Parameter_Name (Input_Object,
+               Param_Name => "Version" & (8..ARM_Input.Command_Name_Type'Last 
=> ' '),
+               Is_First => Is_First,
+               Param_Close_Bracket => Close_Ch);
+           if Close_Ch /= ' ' then
+               -- Get the version character:
+               ARM_File.Get_Char (Input_Object, Ch);
+               Version := ARM_Contents.Change_Version_Type(Ch);
+               ARM_File.Get_Char (Input_Object, Ch);
+               if Ch /= Close_Ch then
+                   Ada.Text_IO.Put_Line ("  ** Bad close for change version on 
line " & ARM_File.Line_String (Input_Object));
+                   ARM_File.Replace_Char (Input_Object);
+               end if;
+           -- else no parameter. Weird.
+           end if;
+        end Get_Change_Version;
+
+    begin
+        case Nesting_Stack(Nesting_Stack_Ptr).Command is
+           when Labeled_Section | Labeled_Section_No_Break |
+                Labeled_Annex | Labeled_Informative_Annex |
+                Labeled_Normative_Annex | Labeled_Clause |
+                Labeled_Subclause | Labeled_Subsubclause =>
+               -- Load the title into the Title string:
+               ARM_Input.Copy_to_String_until_Close_Char (
+                   Input_Object,
+                   Nesting_Stack(Nesting_Stack_Ptr).Close_Char,
+                   Title, Title_Length);
+               Title(Title_Length+1 .. Title'Last) :=
+                   (others => ' ');
+               if Nesting_Stack(Nesting_Stack_Ptr).Command = Labeled_Subclause 
then
+                   Format_Object.Clause_Number :=
+                       (Section   => Format_Object.Clause_Number.Section,
+                        Clause    => Format_Object.Clause_Number.Clause,
+                        Subclause => Format_Object.Clause_Number.Subclause + 1,
+                        Subsubclause => 0);
+               elsif Nesting_Stack(Nesting_Stack_Ptr).Command = 
Labeled_Subsubclause then
+                   Format_Object.Clause_Number.Subsubclause :=
+                       Format_Object.Clause_Number.Subsubclause + 1;
+               elsif Nesting_Stack(Nesting_Stack_Ptr).Command = Labeled_Clause 
then
+                   Format_Object.Clause_Number :=
+                       (Section   => Format_Object.Clause_Number.Section,
+                        Clause    => Format_Object.Clause_Number.Clause + 1,
+                        Subclause => 0, Subsubclause => 0);
+               elsif Saw_a_Section_Header then
+                   Ada.Text_IO.Put_Line ("  ** Multiple section headers in a 
file, line " &
+                           ARM_File.Line_String (Input_Object));
+               else
+                   Saw_a_Section_Header := True;
+                   Format_Object.Clause_Number :=
+                       (Section   => Format_Object.Clause_Number.Section, -- 
Will be set elsewhere.
+                        Clause    => 0,
+                        Subclause => 0, Subsubclause => 0);
+               end if;
+
+               begin
+                   declare
+                       Ref : constant String := 
ARM_Contents.Lookup_Clause_Number (Title);
+                   begin
+                       -- If we get here, this title is already defined. Oops.
+                       Ada.Text_IO.Put_Line ("  ** Title """ &
+                           Title(1..Title_Length) & """ is multiply defined on 
line " &
+                           ARM_File.Line_String (Input_Object));
+                       Ada.Text_IO.Put_Line ("     Initial use is for clause " 
& Ref);
+                   end;
+               exception
+                   when ARM_Contents.Not_Found_Error =>
+                       -- OK, not previously defined.
+
+                       -- Load the title into the contents package:
+                       if Nesting_Stack(Nesting_Stack_Ptr).Command = 
Labeled_Subclause then
+                           ARM_Contents.Add (Title, ARM_Contents.Subclause,
+                                             Format_Object.Clause_Number);
+                       elsif Nesting_Stack(Nesting_Stack_Ptr).Command = 
Labeled_Subsubclause then
+                           ARM_Contents.Add (Title, ARM_Contents.Subsubclause,
+                                             Format_Object.Clause_Number);
+                       elsif Nesting_Stack(Nesting_Stack_Ptr).Command = 
Labeled_Clause then
+                           ARM_Contents.Add (Title, ARM_Contents.Clause,
+                                             Format_Object.Clause_Number);
+                       elsif Nesting_Stack(Nesting_Stack_Ptr).Command = 
Labeled_Section or else
+                             Nesting_Stack(Nesting_Stack_Ptr).Command = 
Labeled_Section_No_Break then
+                           ARM_Contents.Add (Title, ARM_Contents.Section,
+                                             Format_Object.Clause_Number);
+                       elsif Nesting_Stack(Nesting_Stack_Ptr).Command = 
Labeled_Annex then
+                           ARM_Contents.Add (Title, ARM_Contents.Plain_Annex,
+                                             Format_Object.Clause_Number);
+                       elsif Nesting_Stack(Nesting_Stack_Ptr).Command = 
Labeled_Normative_Annex then
+                           ARM_Contents.Add (Title, 
ARM_Contents.Normative_Annex,
+                                             Format_Object.Clause_Number);
+                       else
+                           ARM_Contents.Add (Title, 
ARM_Contents.Informative_Annex,
+                                             Format_Object.Clause_Number);
+                       end if;
+               end;
+
+               Nesting_Stack_Ptr := Nesting_Stack_Ptr - 1;
+--Ada.Text_IO.Put_Line (" &Unstack (Header)");
+
+           when Unnumbered_Section =>
+               -- Load the title into the Title string:
+               ARM_Input.Copy_to_String_until_Close_Char (
+                   Input_Object,
+                   Nesting_Stack(Nesting_Stack_Ptr).Close_Char,
+                   Title, Title_Length);
+               Title(Title_Length+1 .. Title'Last) :=
+                   (others => ' ');
+               Format_Object.Unnumbered_Section :=
+                   Format_Object.Unnumbered_Section + 1;
+               -- This section will be numbered 0.Unnumbered_Section:
+               Format_Object.Clause_Number :=
+                   (Section   => 0,
+                    Clause    => Format_Object.Unnumbered_Section,
+                    Subclause => 0, Subsubclause => 0);
+
+               begin
+                   declare
+                       Ref : constant String := 
ARM_Contents.Lookup_Clause_Number (Title);
+                   begin
+                       -- If we get here, this title is already defined. Oops.
+                       Ada.Text_IO.Put_Line ("  ** Title """ &
+                           Title(1..Title_Length) & """ is multiply defined on 
line " &
+                           ARM_File.Line_String (Input_Object));
+                       Ada.Text_IO.Put_Line ("     Initial use is for clause " 
& Ref);
+                   end;
+               exception
+                   when ARM_Contents.Not_Found_Error =>
+                       -- OK, not previously defined.
+
+                       -- Load the title into the contents package:
+                       ARM_Contents.Add (Title, 
ARM_Contents.Unnumbered_Section,
+                                         Format_Object.Clause_Number);
+               end;
+
+               Nesting_Stack_Ptr := Nesting_Stack_Ptr - 1;
+--Ada.Text_IO.Put_Line (" &Unstack (Header)");
+
+           when Labeled_Revised_Annex |
+                Labeled_Revised_Informative_Annex |
+                Labeled_Revised_Normative_Annex |
+                Labeled_Revised_Section |
+                Labeled_Revised_Clause |
+                Labeled_Revised_Subclause |
+                Labeled_Revised_Subsubclause =>
+               declare
+                   Old_Title : ARM_Contents.Title_Type;
+                   Old_Title_Length : Natural;
+                   Close_Ch : Character;
+                   Version : ARM_Contents.Change_Version_Type := '0';
+                   Initial_Version : ARM_Contents.Change_Version_Type := '0';
+               begin
+                   Get_Change_Version (Is_First => True,
+                                       Version => Version);
+
+                   -- Check for the optional "InitialVersion" parameter,
+                   -- stopping when we reach "New":
+                   declare
+                       Which_Param : ARM_Input.Param_Num;
+                       Ch              : Character;
+                   begin
+                       -- If there is no InitialVersion command, use the same
+                       -- version of the rest of the command.
+                       loop
+                           ARM_Input.Check_One_of_Parameter_Names 
(Input_Object,
+                               Param_Name_1 => "InitialVersion" & 
(15..ARM_Input.Command_Name_Type'Last => ' '),
+                               Param_Name_2 => "New" & 
(4..ARM_Input.Command_Name_Type'Last => ' '),
+                               Is_First => False,
+                               Param_Found => Which_Param,
+                               Param_Close_Bracket => Close_Ch);
+
+                           if Which_Param = 1 and then Close_Ch /= ' ' then
+                               -- Found InitialVersion
+                               ARM_File.Get_Char (Input_Object, Ch);
+                               Initial_Version := Ch;
+                               ARM_File.Get_Char (Input_Object, Ch);
+                               if Ch /= Close_Ch then
+                                   Ada.Text_IO.Put_Line ("  ** Bad close for 
InitialVersion parameter on line " &
+                                       ARM_File.Line_String (Input_Object));
+                                   ARM_File.Replace_Char (Input_Object);
+                               end if;
+                           else -- We found "New" (or an error)
+                               exit; -- Handling of New is below.
+                           end if;
+                       end loop;
+                   end;
+
+                   if Close_Ch /= ' ' then
+                       -- There is a parameter:
+                       -- Load the new title into the Title string:
+                       ARM_Input.Copy_to_String_until_Close_Char (
+                           Input_Object,
+                           Close_Ch,
+                           Title, Title_Length);
+                       Title(Title_Length+1 .. Title'Last) :=
+                           (others => ' ');
+                       ARM_Input.Check_Parameter_Name (Input_Object,
+                           Param_Name => "Old" & 
(4..ARM_Input.Command_Name_Type'Last => ' '),
+                           Is_First => False,
+                           Param_Close_Bracket => Close_Ch);
+                       if Close_Ch /= ' ' then
+                           -- There is a parameter:
+                           -- Load the new title into the Title string:
+                           ARM_Input.Copy_to_String_until_Close_Char (
+                               Input_Object,
+                               Close_Ch,
+                               Old_Title, Old_Title_Length);
+                           Old_Title(Old_Title_Length+1 .. Old_Title'Last) :=
+                               (others => ' ');
+                       end if;
+                   end if;
+                   ARM_File.Get_Char (Input_Object, Close_Ch);
+                   if Close_Ch /= Nesting_Stack(Nesting_Stack_Ptr).Close_Char 
then
+                       Ada.Text_IO.Put_Line ("  ** Bad close for 
Labeled_Revised_(SubClause|Annex) on line " & ARM_File.Line_String 
(Input_Object));
+                       ARM_File.Replace_Char (Input_Object);
+                   end if;
+
+                   if Nesting_Stack(Nesting_Stack_Ptr).Command = 
Labeled_Revised_Subclause then
+                       Format_Object.Clause_Number :=
+                           (Section   => Format_Object.Clause_Number.Section,
+                            Clause    => Format_Object.Clause_Number.Clause,
+                            Subclause => Format_Object.Clause_Number.Subclause 
+ 1,
+                            Subsubclause => 0);
+                   elsif Nesting_Stack(Nesting_Stack_Ptr).Command = 
Labeled_Revised_Subsubclause then
+                       Format_Object.Clause_Number.Subsubclause :=
+                           Format_Object.Clause_Number.Subsubclause + 1;
+                   elsif Nesting_Stack(Nesting_Stack_Ptr).Command = 
Labeled_Revised_Clause then
+                       Format_Object.Clause_Number :=
+                           (Section   => Format_Object.Clause_Number.Section,
+                            Clause    => Format_Object.Clause_Number.Clause + 
1,
+                            Subclause => 0, Subsubclause => 0);
+                   elsif Saw_a_Section_Header then
+                       Ada.Text_IO.Put_Line ("  ** Multiple section headers in 
a file, line " &
+                               ARM_File.Line_String (Input_Object));
+                   else
+                       Saw_a_Section_Header := True;
+                       Format_Object.Clause_Number :=
+                           (Section   => Format_Object.Clause_Number.Section, 
-- Will be set elsewhere.
+                            Clause    => 0,
+                            Subclause => 0, Subsubclause => 0);
+                   end if;
+
+                   begin
+                       declare
+                           Ref : constant String := 
ARM_Contents.Lookup_Clause_Number (Title);
+                       begin
+                           -- If we get here, this title is already defined. 
Oops.
+                           Ada.Text_IO.Put_Line ("  ** Title """ &
+                               Title(1..Title_Length) & """ is multiply 
defined on line " &
+                               ARM_File.Line_String (Input_Object));
+                           Ada.Text_IO.Put_Line ("     Initial use is for 
clause " & Ref);
+                       end;
+                   exception
+                       when ARM_Contents.Not_Found_Error =>
+                           -- OK, not previously defined.
+
+                           -- Load the title into the contents package:
+                           if Nesting_Stack(Nesting_Stack_Ptr).Command = 
Labeled_Revised_Subclause then
+                               ARM_Contents.Add (Title, ARM_Contents.Subclause,
+                                                 Format_Object.Clause_Number,
+                                                 Version => Version);
+                               ARM_Contents.Add_Old (Old_Title,
+                                                 ARM_Contents.Subclause,
+                                                 Format_Object.Clause_Number,
+                                                 Version => Initial_Version);
+                           elsif Nesting_Stack(Nesting_Stack_Ptr).Command = 
Labeled_Revised_Subsubclause then
+                               ARM_Contents.Add (Title, 
ARM_Contents.Subsubclause,
+                                                 Format_Object.Clause_Number,
+                                                 Version => Version);
+                               ARM_Contents.Add_Old (Old_Title,
+                                                 ARM_Contents.Subsubclause,
+                                                 Format_Object.Clause_Number,
+                                                 Version => Initial_Version);
+                           elsif Nesting_Stack(Nesting_Stack_Ptr).Command = 
Labeled_Revised_Clause then
+                               ARM_Contents.Add (Title, ARM_Contents.Clause,
+                                                 Format_Object.Clause_Number,
+                                                 Version => Version);
+                               ARM_Contents.Add_Old (Old_Title,
+                                                 ARM_Contents.Clause,
+                                                 Format_Object.Clause_Number,
+                                                 Version => Initial_Version);
+                           elsif Nesting_Stack(Nesting_Stack_Ptr).Command = 
Labeled_Revised_Section then
+                               ARM_Contents.Add (Title, ARM_Contents.Section,
+                                                 Format_Object.Clause_Number,
+                                                 Version => Version);
+                               ARM_Contents.Add_Old (Old_Title,
+                                                 ARM_Contents.Section,
+                                                 Format_Object.Clause_Number,
+                                                 Version => Initial_Version);
+                           elsif Nesting_Stack(Nesting_Stack_Ptr).Command = 
Labeled_Revised_Annex then
+                               ARM_Contents.Add (Title,
+                                                 ARM_Contents.Plain_Annex,
+                                                 Format_Object.Clause_Number,
+                                                 Version => Version);
+                               ARM_Contents.Add_Old (Old_Title,
+                                                 ARM_Contents.Plain_Annex,
+                                                 Format_Object.Clause_Number,
+                                                 Version => Initial_Version);
+                           elsif Nesting_Stack(Nesting_Stack_Ptr).Command = 
Labeled_Revised_Normative_Annex then
+                               ARM_Contents.Add (Title,
+                                                 ARM_Contents.Normative_Annex,
+                                                 Format_Object.Clause_Number,
+                                                 Version => Version);
+                               ARM_Contents.Add_Old (Old_Title,
+                                                 ARM_Contents.Normative_Annex,
+                                                 Format_Object.Clause_Number,
+                                                 Version => Initial_Version);
+                           else -- Nesting_Stack(Nesting_Stack_Ptr).Command = 
Labeled_Revised_Informative_Annex then
+                               ARM_Contents.Add (Title,
+                                                 
ARM_Contents.Informative_Annex,
+                                                 Format_Object.Clause_Number,
+                                                 Version => Version);
+                               ARM_Contents.Add_Old (Old_Title,
+                                                 
ARM_Contents.Informative_Annex,
+                                                 Format_Object.Clause_Number,
+                                                 Version => Initial_Version);
+                           end if;
+                   end;
+
+                   Nesting_Stack_Ptr := Nesting_Stack_Ptr - 1;
+--Ada.Text_IO.Put_Line (" &Unstack (Header)");
+               end;
+
+           when Labeled_Added_Annex |
+                Labeled_Added_Informative_Annex |
+                Labeled_Added_Normative_Annex |
+                Labeled_Added_Section |
+                Labeled_Added_Clause |
+                Labeled_Added_Subclause |
+                Labeled_Added_Subsubclause =>
+               declare
+                   Ch : Character;
+                   Version : ARM_Contents.Change_Version_Type := '0';
+                   How : ARM_Output.Change_Type;
+                   use type ARM_Output.Change_Type;
+               begin
+                   Get_Change_Version (Is_First => True,
+                                       Version => Version);
+                   ARM_Input.Check_Parameter_Name (Input_Object,
+                       Param_Name => "Name" & 
(5..ARM_Input.Command_Name_Type'Last => ' '),
+                       Is_First => False,
+                       Param_Close_Bracket => Ch);
+                   if Ch /= ' ' then
+                       -- There is a parameter:
+                       -- Load the new title into the Title string:
+                       ARM_Input.Copy_to_String_until_Close_Char (
+                           Input_Object,
+                           Ch,
+                           Title, Title_Length);
+                       Title(Title_Length+1 .. Title'Last) :=
+                           (others => ' ');
+                   end if;
+                   ARM_File.Get_Char (Input_Object, Ch);
+                   if Ch /= Nesting_Stack(Nesting_Stack_Ptr).Close_Char then
+                       Ada.Text_IO.Put_Line ("  ** Bad close for 
Labeled_Added_(Sub)Clause on line " & ARM_File.Line_String (Input_Object));
+                       ARM_File.Replace_Char (Input_Object);
+                   end if;
+
+                   -- Determine the insertion state for this label:
+                   Calc_Change_Disposition (Format_Object,
+                       Version => Version,
+                       Operation => ARM_Output.Insertion,
+                       Text_Kind => How);
+
+                   if How = Do_Not_Display_Text then
+                       null; -- Nothing to display, so we do *not* number it
+                             -- or insert it into the contents database.
+                   else
+                       begin
+                           declare
+                               Ref : constant String := 
ARM_Contents.Lookup_Clause_Number (Title);
+                           begin
+                               -- If we get here, this title is already 
defined. Oops.
+                               Ada.Text_IO.Put_Line ("  ** Title """ &
+                                   Title(1..Title_Length) & """ is multiply 
defined on line " &
+                                   ARM_File.Line_String (Input_Object));
+                               Ada.Text_IO.Put_Line ("     Initial use is for 
clause " & Ref);
+                           end;
+                       exception
+                           when ARM_Contents.Not_Found_Error =>
+                               -- OK, not previously defined.
+
+                               -- Load the title into the contents package:
+                               if Nesting_Stack(Nesting_Stack_Ptr).Command = 
Labeled_Added_Subclause then
+                                   Format_Object.Clause_Number :=
+                                       (Section   => 
Format_Object.Clause_Number.Section,
+                                        Clause    => 
Format_Object.Clause_Number.Clause,
+                                        Subclause => 
Format_Object.Clause_Number.Subclause + 1,
+                                        Subsubclause => 0);
+                                   ARM_Contents.Add (Title, 
ARM_Contents.Subclause,
+                                                     
Format_Object.Clause_Number,
+                                                     Version => Version);
+                                   ARM_Contents.Add_Old ((others => ' '),
+                                                     ARM_Contents.Subclause,
+                                                     
Format_Object.Clause_Number);
+                               elsif Nesting_Stack(Nesting_Stack_Ptr).Command 
= Labeled_Added_Subsubclause then
+                                   Format_Object.Clause_Number.Subsubclause :=
+                                       
Format_Object.Clause_Number.Subsubclause + 1;
+                                   ARM_Contents.Add (Title, 
ARM_Contents.Subsubclause,
+                                                     
Format_Object.Clause_Number,
+                                                     Version => Version);
+                                   ARM_Contents.Add_Old ((others => ' '),
+                                                     ARM_Contents.Subsubclause,
+                                                     
Format_Object.Clause_Number);
+                               elsif Nesting_Stack(Nesting_Stack_Ptr).Command 
= Labeled_Added_Clause then
+                                   Format_Object.Clause_Number :=
+                                       (Section   => 
Format_Object.Clause_Number.Section,
+                                        Clause    => 
Format_Object.Clause_Number.Clause + 1,
+                                        Subclause => 0, Subsubclause => 0);
+                                   ARM_Contents.Add (Title, 
ARM_Contents.Clause,
+                                                     
Format_Object.Clause_Number,
+                                                     Version => Version);
+                                   ARM_Contents.Add_Old ((others => ' '),
+                                                     ARM_Contents.Clause,
+                                                     
Format_Object.Clause_Number);
+                               elsif Nesting_Stack(Nesting_Stack_Ptr).Command 
= Labeled_Added_Section then
+                                   if Saw_a_Section_Header then
+                                       Ada.Text_IO.Put_Line ("  ** Multiple 
section headers in a file, line " &
+                                               ARM_File.Line_String 
(Input_Object));
+                                   end if;
+                                   Saw_a_Section_Header := True;
+                                   Format_Object.Clause_Number :=
+                                       (Section   => 
Format_Object.Clause_Number.Section, -- Will be set elsewhere.
+                                        Clause    => 0,
+                                        Subclause => 0, Subsubclause => 0);
+                                   ARM_Contents.Add (Title,
+                                                     ARM_Contents.Section,
+                                                     
Format_Object.Clause_Number,
+                                                     Version => Version);
+                                   ARM_Contents.Add_Old ((others => ' '),
+                                                     ARM_Contents.Section,
+                                                     
Format_Object.Clause_Number);
+                               elsif Nesting_Stack(Nesting_Stack_Ptr).Command 
= Labeled_Added_Annex then
+                                   if Saw_a_Section_Header then
+                                       Ada.Text_IO.Put_Line ("  ** Multiple 
section headers in a file, line " &
+                                               ARM_File.Line_String 
(Input_Object));
+                                   end if;
+                                   Saw_a_Section_Header := True;
+                                   Format_Object.Clause_Number :=
+                                       (Section   => 
Format_Object.Clause_Number.Section, -- Will be set elsewhere.
+                                        Clause    => 0,
+                                        Subclause => 0, Subsubclause => 0);
+                                   ARM_Contents.Add (Title,
+                                                     ARM_Contents.Plain_Annex,
+                                                     
Format_Object.Clause_Number,
+                                                     Version => Version);
+                                   ARM_Contents.Add_Old ((others => ' '),
+                                                     ARM_Contents.Plain_Annex,
+                                                     
Format_Object.Clause_Number);
+                               elsif Nesting_Stack(Nesting_Stack_Ptr).Command 
= Labeled_Added_Normative_Annex then
+                                   if Saw_a_Section_Header then
+                                       Ada.Text_IO.Put_Line ("  ** Multiple 
section headers in a file, line " &
+                                               ARM_File.Line_String 
(Input_Object));
+                                   end if;
+                                   Saw_a_Section_Header := True;
+                                   Format_Object.Clause_Number :=
+                                       (Section   => 
Format_Object.Clause_Number.Section, -- Will be set elsewhere.
+                                        Clause    => 0,
+                                        Subclause => 0, Subsubclause => 0);
+                                   ARM_Contents.Add (Title,
+                                                     
ARM_Contents.Normative_Annex,
+                                                     
Format_Object.Clause_Number,
+                                                     Version => Version);
+                                   ARM_Contents.Add_Old ((others => ' '),
+                                                     
ARM_Contents.Normative_Annex,
+                                                     
Format_Object.Clause_Number);
+                               else -- 
Nesting_Stack(Nesting_Stack_Ptr).Command = Labeled_Added_Informative_Annex then
+                                   if Saw_a_Section_Header then
+                                       Ada.Text_IO.Put_Line ("  ** Multiple 
section headers in a file, line " &
+                                               ARM_File.Line_String 
(Input_Object));
+                                   end if;
+                                   Saw_a_Section_Header := True;
+                                   Format_Object.Clause_Number :=
+                                       (Section   => 
Format_Object.Clause_Number.Section, -- Will be set elsewhere.
+                                        Clause    => 0,
+                                        Subclause => 0, Subsubclause => 0);
+                                   ARM_Contents.Add (Title,
+                                                     
ARM_Contents.Informative_Annex,
+                                                     
Format_Object.Clause_Number,
+                                                     Version => Version);
+                                   ARM_Contents.Add_Old ((others => ' '),
+                                                     
ARM_Contents.Informative_Annex,
+                                                     
Format_Object.Clause_Number);
+                               end if;
+                       end;
+                   end if;
+
+                   Nesting_Stack_Ptr := Nesting_Stack_Ptr - 1;
+--Ada.Text_IO.Put_Line (" &Unstack (Header)");
+               end;
+
+           when Labeled_Deleted_Clause |
+                Labeled_Deleted_Subclause |
+                Labeled_Deleted_Subsubclause =>
+               declare
+                   Ch : Character;
+                   Version : ARM_Contents.Change_Version_Type := '0';
+                   How : ARM_Output.Change_Type;
+                   use type ARM_Output.Change_Type;
+               begin
+                   Get_Change_Version (Is_First => True,
+                                       Version => Version);
+                   ARM_Input.Check_Parameter_Name (Input_Object,
+                       Param_Name => "Name" & 
(5..ARM_Input.Command_Name_Type'Last => ' '),
+                       Is_First => False,
+                       Param_Close_Bracket => Ch);
+                   if Ch /= ' ' then
+                       -- There is a parameter:
+                       -- Load the new title into the Title string:
+                       ARM_Input.Copy_to_String_until_Close_Char (
+                           Input_Object,
+                           Ch,
+                           Title, Title_Length);
+                       Title(Title_Length+1 .. Title'Last) :=
+                           (others => ' ');
+                   end if;
+                   ARM_File.Get_Char (Input_Object, Ch);
+                   if Ch /= Nesting_Stack(Nesting_Stack_Ptr).Close_Char then
+                       Ada.Text_IO.Put_Line ("  ** Bad close for 
Labeled_Deleted_(Sub)Clause on line " & ARM_File.Line_String (Input_Object));
+                       ARM_File.Replace_Char (Input_Object);
+                   end if;
+
+                   -- Determine the insertion state for this label:
+                   Calc_Change_Disposition (Format_Object,
+                       Version => Version,
+                       Operation => ARM_Output.Deletion,
+                       Text_Kind => How);
+
+--Ada.Text_IO.Put_Line ("Labeled_Deleted disp: " & 
ARM_Output.Change_Type'Image(How));
+                   if How = ARM_Output.None then
+                       -- Normal text, number normally.
+                       begin
+                           declare
+                               Ref : constant String := 
ARM_Contents.Lookup_Clause_Number (Title);
+                           begin
+                               -- If we get here, this title is already 
defined. Oops.
+                               Ada.Text_IO.Put_Line ("  ** Title """ &
+                                   Title(1..Title_Length) & """ is multiply 
defined on line " &
+                                   ARM_File.Line_String (Input_Object));
+                               Ada.Text_IO.Put_Line ("     Initial use is for 
clause " & Ref);
+                           end;
+                       exception
+                           when ARM_Contents.Not_Found_Error =>
+                               -- OK, not previously defined.
+
+                               -- Load the title into the contents package:
+                               if Nesting_Stack(Nesting_Stack_Ptr).Command = 
Labeled_Deleted_Subclause then
+                                   Format_Object.Clause_Number :=
+                                       (Section   => 
Format_Object.Clause_Number.Section,
+                                        Clause    => 
Format_Object.Clause_Number.Clause,
+                                        Subclause => 
Format_Object.Clause_Number.Subclause + 1,
+                                        Subsubclause => 0);
+                                   ARM_Contents.Add (Title, 
ARM_Contents.Subclause,
+                                                     
Format_Object.Clause_Number,
+                                                     Version => '0'); -- 
Version here is an insertion version, and this was available from the beginning.
+                                   ARM_Contents.Add_Old ((others => ' '),
+                                                     ARM_Contents.Subclause,
+                                                     
Format_Object.Clause_Number);
+                               elsif Nesting_Stack(Nesting_Stack_Ptr).Command 
= Labeled_Deleted_Subsubclause then
+                                   Format_Object.Clause_Number.Subsubclause :=
+                                       
Format_Object.Clause_Number.Subsubclause + 1;
+                                   ARM_Contents.Add (Title, 
ARM_Contents.Subsubclause,
+                                                     
Format_Object.Clause_Number,
+                                                     Version => '0');
+                                   ARM_Contents.Add_Old ((others => ' '),
+                                                     ARM_Contents.Subsubclause,
+                                                     
Format_Object.Clause_Number);
+                           else -- Nesting_Stack(Nesting_Stack_Ptr).Command = 
Labeled_Deleted_Clause then
+                               Format_Object.Clause_Number :=
+                                   (Section   => 
Format_Object.Clause_Number.Section,
+                                    Clause    => 
Format_Object.Clause_Number.Clause + 1,
+                                    Subclause => 0, Subsubclause => 0);
+                               ARM_Contents.Add (Title, ARM_Contents.Clause,
+                                                 Format_Object.Clause_Number,
+                                                 Version => '0');
+                               ARM_Contents.Add_Old ((others => ' '),
+                                                 ARM_Contents.Clause,
+                                                 Format_Object.Clause_Number);
+                           end if;
+                       end;
+                   elsif How = ARM_Output.Insertion then
+                       -- Huh? We're deleting here.
+                       raise Program_Error;
+                   elsif How = ARM_Output.Deletion then
+                       -- We'll just display the header without a number.
+                       -- But we need to insert it so that x-refs don't
+                       -- fail.
+                       begin
+                           declare
+                               Ref : constant String := 
ARM_Contents.Lookup_Clause_Number (Title);
+                           begin
+                               -- If we get here, this title is already 
defined. Oops.
+                               Ada.Text_IO.Put_Line ("  ** Title """ &
+                                   Title(1..Title_Length) & """ is multiply 
defined on line " &
+                                   ARM_File.Line_String (Input_Object));
+                               Ada.Text_IO.Put_Line ("     Initial use is for 
clause " & Ref);
+                           end;
+                       exception
+                           when ARM_Contents.Not_Found_Error =>
+                               -- OK, not previously defined.
+
+                               -- Load the title into the contents package as 
a dead clause:
+                               ARM_Contents.Add (Title, 
ARM_Contents.Dead_Clause,
+                                                 (Section   => 0,
+                                                  Clause    => 1,
+                                                  Subclause => 0,
+                                                  Subsubclause => 0),
+                                                 Version => '0');
+                               ARM_Contents.Add_Old ((others => ' '),
+                                                 ARM_Contents.Dead_Clause,
+                                                 (Section   => 0,
+                                                  Clause    => 1,
+                                                  Subclause => 0,
+                                                  Subsubclause => 0));
+                       end;
+
+                   elsif How = Do_Not_Display_Text then
+                       null; -- Nothing to display/number.
+                   end if;
+
+                   Nesting_Stack_Ptr := Nesting_Stack_Ptr - 1;
+--Ada.Text_IO.Put_Line (" &Unstack (Header)");
+               end;
+
+           when Syntax_Rule | Added_Syntax_Rule | Deleted_Syntax_Rule =>
+               -- @Syn{[Tabs=<Tabset>, ]LHS=<Non-terminal>, RHS=<Production>}
+               -- @AddedSyn{Version=[<Version>],[Tabs=<Tabset>, 
]LHS=<Non-terminal>, RHS=<Production>}
+               -- @DeletedSyn{Version=[<Version>],[Tabs=<Tabset>, 
]LHS=<Non-terminal>, RHS=<Production>}
+               -- We need to index the non-terminal, so we can link to it
+               -- later. (If we didn't do this here, we wouldn't be able
+               -- to handle forward references.)
+               -- We only care about the non-terminal, so we skip the other
+               -- parts.
+               declare
+                   Close_Ch, Ch : Character;
+                   Seen_First_Param : Boolean := False;
+                   Non_Terminal : String (1..120);
+                   NT_Len : Natural := 0;
+               begin
+                   if Nesting_Stack(Nesting_Stack_Ptr).Command /= Syntax_Rule 
then
+                       -- Get and skip the Version parameter.
+                       Seen_First_Param := True;
+                       Get_Change_Version (Is_First => True,
+                                           Version => Ch);
+                   end if;
+
+                   -- Peek to see if Tabs parmeter is present, and skip it if
+                   -- it is:
+                   ARM_File.Get_Char (Input_Object, Ch);
+                   ARM_File.Replace_Char (Input_Object);
+                   if Ch = 'T' or else Ch = 't' then
+                       ARM_Input.Check_Parameter_Name (Input_Object,
+                          Param_Name => "Tabs" & 
(5..ARM_Input.Command_Name_Type'Last => ' '),
+                          Is_First => (not Seen_First_Param),
+                          Param_Close_Bracket => Close_Ch);
+                       Seen_First_Param := True;
+                       if Close_Ch /= ' ' then
+                           -- Grab the tab string:
+                           ARM_Input.Skip_until_Close_Char (
+                               Input_Object,
+                               Close_Ch);
+                       -- else no parameter. Weird.
+                       end if;
+                   end if;
+
+                   -- Get the LHS parameter and save it:
+                   ARM_Input.Check_Parameter_Name (Input_Object,
+                       Param_Name => "LHS" & 
(4..ARM_Input.Command_Name_Type'Last => ' '),
+                       Is_First => (not Seen_First_Param),
+                       Param_Close_Bracket => Close_Ch);
+                   if Close_Ch /= ' ' then
+                       -- Copy over the non-terminal:
+                       ARM_Input.Copy_to_String_until_Close_Char (
+                           Input_Object,
+                           Close_Ch,
+                           Non_Terminal,
+                           NT_Len);
+                   -- else no parameter. Weird.
+                   end if;
+
+                   -- Skip the RHS parameter:
+                   ARM_Input.Check_Parameter_Name (Input_Object,
+                      Param_Name => "RHS" & 
(4..ARM_Input.Command_Name_Type'Last => ' '),
+                      Is_First => False,
+                      Param_Close_Bracket => Close_Ch);
+                   Seen_First_Param := True;
+                   if Close_Ch /= ' ' then
+                       -- Grab the tab string:
+                       ARM_Input.Skip_until_Close_Char (
+                           Input_Object,
+                           Close_Ch);
+                   -- else no parameter. Weird.
+                   end if;
+
+                   declare
+                       The_Non_Terminal : constant String :=
+                           Ada.Characters.Handling.To_Lower (
+                               Get_Current_Item (Format_Object, Input_Object,
+                                   Non_Terminal(1..NT_Len))); -- Handle 
embedded @Chg.
+                       The_Old_Non_Terminal : constant String :=
+                           Ada.Characters.Handling.To_Lower (
+                               Get_Old_Item (Format_Object, Input_Object,
+                                   Non_Terminal(1..NT_Len))); -- Handle 
embedded @Chg.
+                   begin
+                       if Ada.Strings.Fixed.Index (The_Non_Terminal, "@") /= 0 
then
+                           -- Still embedded commands, do not register.
+                           Ada.Text_IO.Put_Line ("** Saw Non-Terminal with 
embedded commands: " &
+                               Non_Terminal(1..NT_Len) & " in " & 
Clause_String (Format_Object));
+                       elsif The_Non_Terminal = "" then
+                           null; -- Deleted Non-Terminal, nothing to do.
+                       else
+                           -- Save the non-terminal:
+                           declare
+                               Link_Target : ARM_Syntax.Target_Type;
+                           begin
+                                ARM_Syntax.Add_Non_Terminal
+                                    (NT_Name => The_Non_Terminal,
+                                     For_Clause => Clause_String 
(Format_Object),
+                                     Link_Target => Link_Target);
+                           end;
+--Ada.Text_IO.Put_Line ("%% Saw simple Non-Terminal: " & The_Non_Terminal & " 
in "
+--   & Clause_String (Format_Object));
+                       end if;
+                       if The_Old_Non_Terminal = "" then
+                           null; -- No old Non-Terminal, nothing to do.
+                       elsif ARM_Syntax.Non_Terminal_Clause 
(The_Old_Non_Terminal) /= "" then
+                           null; -- This non-terminal is already defined;
+                               -- that presumably is a *new* definition,
+                               -- we'll use that instead of this one.
+                       else
+                           -- Save the non-terminal:
+                           declare
+                               Link_Target : ARM_Syntax.Target_Type;
+                           begin
+                                ARM_Syntax.Add_Non_Terminal
+                                    (NT_Name => The_Old_Non_Terminal,
+                                     For_Clause => Clause_String 
(Format_Object),
+                                     Link_Target => Link_Target);
+                           end;
+--Ada.Text_IO.Put_Line ("%% Saw simple old Non-Terminal: " & 
The_Old_Non_Terminal & " in "
+--   & Clause_String (Format_Object));
+                       end if;
+                   end;
+               end;
+
+           when Comment =>
+--Ada.Text_IO.Put_Line("Comment with Close=" & 
Nesting_Stack(Nesting_Stack_Ptr).Close_Char &
+--   " on line " & ARM_File.Line_String (Input_Object));
+               -- Skip the contents of this command.
+               ARM_Input.Skip_until_Close_Char (Input_Object,
+                   Nesting_Stack(Nesting_Stack_Ptr).Close_Char);
+               ARM_File.Replace_Char (Input_Object); -- Put the close 
character back.
+--Ada.Text_IO.Put_Line("Comment done");
+
+           when others =>
+               null; -- Not in scanner.
+        end case;
+    end Scan_Command_with_Parameter;
+
+
+    procedure Handle_End_of_Command is
+        -- Unstack and handle the end of Commands.
+    begin
+        case Nesting_Stack(Nesting_Stack_Ptr).Command is
+           when others =>
+               -- No special handling needed.
+               null;
+        end case;
+--Ada.Text_IO.Put_Line (" &Unstack (Normal-"& 
Command_Type'Image(Nesting_Stack(Nesting_Stack_Ptr).Command) & ")");
+        Nesting_Stack_Ptr := Nesting_Stack_Ptr - 1;
+    end Handle_End_of_Command;
+
+
+    procedure Scan_Special is
+        -- Scan a special command/macro/tab.
+        -- These all start with '@'.
+        -- @xxxx is a command. It may have parameters delimited by
+        -- (), {}, [], or <>. There does not appear to be an escape, so
+        -- we don't have to worry about '}' being used in {} brackets,
+        -- for example. (Must be a pain to write, though.)
+        Command_Name : ARM_Input.Command_Name_Type;
+        Ch : Character;
+    begin
+        ARM_File.Get_Char (Input_Object, Ch);
+        if Ch = '\' then
+           -- This represents a tab (or the end of centered text). We're
+           -- done here.
+           return;
+        elsif Ch = '=' then
+           -- This marks the beginning of centered text.
+           -- We're done here.
+           return;
+        elsif Ch = '^' then
+           -- This represented a tab stop (these should have been
+           -- deleted from the input). We're done here.
+           return;
+        elsif Ch = '@' then
+           -- This represents @ in the text. We're done here.
+           return;
+        elsif Ch = ' ' then
+           -- This represents a hard space in the text. We're done here.
+           return;
+        elsif Ch = ';' then
+           -- This seems to be an end of command (or substitution) marker.
+           -- For instance, it is used in Section 1:
+           -- .. the distinction between @ResolutionName@;s and ...
+           -- This converts to:
+           -- .. the distinction between Name Resolution Rules and ...
+           -- Without it, the 's' would append to the command name, and
+           -- we would get the wrong command. Thus, it itself does nothing
+           -- at all, so we're done here.
+           return;
+        elsif Ch = '-' then
+           -- This represents a subscript. It has an argument.
+           ARM_File.Get_Char (Input_Object, Ch);
+           if ARM_Input.Is_Open_Char (Ch) then -- Start parameter:
+               Set_Nesting_for_Command
+                   (Command  => Unknown,
+                    Param_Ch => Ch);
+           else -- No parameter. Weird.
+               ARM_File.Replace_Char (Input_Object);
+           end if;
+           return;
+        elsif Ch = '+' then
+           -- This represents a superscript. It has an argument.
+           ARM_File.Get_Char (Input_Object, Ch);
+           if ARM_Input.Is_Open_Char (Ch) then -- Start parameter:
+               Set_Nesting_for_Command
+                   (Command  => Unknown,
+                    Param_Ch => Ch);
+           else -- No parameter. Weird.
+               ARM_File.Replace_Char (Input_Object);
+           end if;
+           return;
+        elsif Ch = ':' then
+           -- This is a period type marker. We're done here.
+           return;
+        elsif Ch = '*' then
+           -- This is a line break. We're done here.
+           return;
+        elsif Ch = '|' then
+           -- This is a soft line break. We're done here.
+           return;
+        elsif Ch = '!' then
+           -- This is a soft hyphen break. We're done here.
+           return;
+        elsif Ch = Ascii.LF then
+           -- Stand alone '@'.
+           -- I now believe this is an error. It appears in
+           -- Infosys.MSS, and seems to have something to do with formatting.
+           return;
+        end if;
+        ARM_File.Replace_Char (Input_Object);
+        Arm_Input.Get_Name (Input_Object, Command_Name);
+--Ada.Text_IO.Put_Line("Command=" & Command_Name & " Nesting=" & 
Natural'Image(Nesting_Stack_Ptr));
+
+        ARM_File.Get_Char (Input_Object, Ch);
+        if ARM_Input.Is_Open_Char (Ch) then -- Start parameter:
+           Set_Nesting_for_Command
+               (Command  => Command (Ada.Characters.Handling.To_Lower 
(Command_Name)),
+                Param_Ch => Ch);
+           Scan_Command_with_Parameter;
+        else
+           ARM_File.Replace_Char (Input_Object);
+           -- We're not interested in commands with no parameters.
+        end if;
+    end Scan_Special;
+
+begin
+    Ada.Text_IO.Put_Line ("-- Scanning " & File_Name);
+    begin
+        Arm_File.Open (Input_Object, File_Name);
+    exception
+        when others =>
+           Ada.Text_IO.Put_Line ("** Unable to open file " & File_Name);
+           raise;
+    end;
+    if Starts_New_Section then
+        Format_Object.Clause_Number := (Section => Section_Number, others => 
0);
+    end if;
+    loop
+        declare
+           Char : Character;
+        begin
+           ARM_File.Get_Char (Input_Object, Char);
+--Ada.Text_IO.Put_Line("Char=" & Char & " Nesting=" & 
Natural'Image(Nesting_Stack_Ptr));
+           case Char is
+               when '@' =>
+                   Scan_Special;
+               when Ascii.SUB =>
+                   exit; -- End of file.
+               when others =>
+                   if Nesting_Stack_Ptr /= 0 and then
+                      Nesting_Stack (Nesting_Stack_Ptr).Close_Char /= ' ' and 
then
+                      Nesting_Stack (Nesting_Stack_Ptr).Close_Char = Char then
+                       -- Closing a command, remove it from the stack.
+                       Handle_End_of_Command;
+                   else
+                       null; -- Ordinary characters, nothing to do.
+                   end if;
+           end case;
+        end;
+    end loop;
+    -- Reached end of the file.
+    Ada.Text_IO.Put_Line ("  Lines scanned: " &
+                    ARM_File.Line_String (Input_Object));
+    ARM_File.Close (Input_Object);
+    if Nesting_Stack_Ptr /= 0 then
+        Ada.Text_IO.Put_Line ("   ** Unfinished commands detected.");
+    end if;
+end Scan;
+
+
diff --git a/progs/arm_html.adb b/progs/arm_html.adb
new file mode 100755
index 0000000..1632539
--- /dev/null
+++ b/progs/arm_html.adb
@@ -0,0 +1,5755 @@
+with -- ARM_Output,
+     -- ARM_Contents,
+     -- Ada.Text_IO,
+     Ada.Exceptions,
+     Ada.Strings.Maps.Constants,
+     Ada.Strings.Fixed,
+     Ada.Unchecked_Deallocation;
+package body ARM_HTML is
+
+    --
+    -- Ada reference manual formatter (ARM_Form).
+    --
+    -- This package defines the HTML output object.
+    -- Output objects are responsible for implementing the details of
+    -- a particular format.
+    --
+    -- ---------------------------------------
+    -- Copyright 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
+    --          2008, 2009, 2011, 2012, 2013, 2016
+    -- AXE Consultants. All rights reserved.
+    -- P.O. Box 1512, Madison WI  53701
+    -- E-Mail: randy@rrsoftware.com
+    --
+    -- ARM_Form is free software: you can redistribute it and/or modify
+    -- it under the terms of the GNU General Public License version 3
+    -- as published by the Free Software Foundation.
+    --
+    -- AXE CONSULTANTS MAKES THIS TOOL AND SOURCE CODE AVAILABLE ON AN "AS IS"
+    -- BASIS AND MAKES NO WARRANTY, EXPRESS OR IMPLIED, AS TO THE ACCURACY,
+    -- CAPABILITY, EFFICIENCY, MERCHANTABILITY, OR FUNCTIONING OF THIS TOOL.
+    -- IN NO EVENT WILL AXE CONSULTANTS BE LIABLE FOR ANY GENERAL,
+    -- CONSEQUENTIAL, INDIRECT, INCIDENTAL, EXEMPLARY, OR SPECIAL DAMAGES,
+    -- EVEN IF AXE CONSULTANTS HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
+    -- DAMAGES.
+    --
+    -- A copy of the GNU General Public License is available in the file
+    -- gpl-3-0.txt in the standard distribution of the ARM_Form tool.
+    -- Otherwise, see <http://www.gnu.org/licenses/>.
+    --
+    -- If the GPLv3 license is not satisfactory for your needs, a commercial
+    -- use license is available for this tool. Contact Randy at AXE Consultants
+    -- for more information.
+    --
+    -- ---------------------------------------
+    --
+    -- Edit History:
+    --
+    --  4/19/00 - RLB - Created base package.
+    --  4/21/00 - RLB - Added line break and hard space routines.
+    --  4/24/00 - RLB - Added DR references and Insert/Delete text formats.
+    --  4/25/00 - RLB - Added size to format.
+    --  4/26/00 - RLB - Added paragraph formats.
+    --  4/29/00 - RLB - Added more paragraph formats.
+    --  5/10/00 - RLB - Added even more formats.
+    --          - RLB - Added End_Hang_Item.
+    --  5/12/00 - RLB - Added No_Prefix to Start_Paragraph.
+    --  5/13/00 - RLB - Added Special_Character.
+    --  5/16/00 - RLB - Added additional special characters.
+    --  5/17/00 - RLB - Added New_Page.
+    --  5/22/00 - RLB - Added Includes_Changes to Create.
+    --  5/23/00 - RLB - Added multi-column formats and New_Column.
+    --               - Added Tab_Info and Tab_Stops.
+    --  5/24/00 - RLB - Added Location to Text_Format.
+    --         - RLB - Added No_Breaks and Keep_with_Next to Start_Paragraph.
+    --  5/25/00 - RLB - Added Big_Files to Create. Added Justification.
+    --         - RLB - Added Separator_Lines and TOC routines.
+    --         - RLB - Added "Legal" to the footer, pointing at the title page.
+    --  5/26/00 - RLB - Added table operations.
+    --  5/28/00 - RLB - Added index references.
+    --  6/ 2/00 - RLB - Added Soft_Line_Break.
+    --  8/ 2/00 - RLB - Added Soft_Hyphen_Break and left and right quote
+    --                 characters.
+    --         - RLB - Added additional styles.
+    --  8/ 7/00 - RLB - Added Leading flag to Start_Paragraph, removed 
"Leading"
+    --                 styles.
+    --  8/11/00 - RLB - Added Hanging_in_Bulleted styles.
+    --  8/16/00 - RLB - Added Code_Indented_Nested_Bulleted.
+    --  8/17/00 - RLB - Replaced "Leading" by "Space_After".
+    --                 - RLB - Added Nested_Enumerated.
+    --  8/22/00 - RLB - Added Revised_Clause_Header.
+    --  9/ 8/00 - RLB - Removed soft hyphen, as this does not work on either
+    --                 browser I tried.
+    --  9/26/00 - RLB - Added Syntax_Summary style.
+    --  9/27/00 - RLB - Added tab emulation when in the fixed font.
+    --  9/28/00 - RLB - Added some style sheets.
+    --         - RLB - Updated to use absolute positioning for paragraph
+    --                 numbers (this looks much better than floating).
+    --  7/18/01 - RLB - Added "Indented" style to supported styles for
+    --                 multi-column.
+    --         - RLB - Implemented single "Big-File" support.
+    --  7/18/02 - RLB - Removed Document parameter from Create, replaced by
+    --                 three strings and For_ISO boolean.
+    --         - RLB - Added AI_Reference.
+    --         - RLB - Added Change_Version_Type and uses.
+    --  1/15/03 - RLB - Removed space from DIV.paranum, as it doesn't validate
+    --                 with it.
+    --  4/10/03 - RLB - Updated to add access to search pages (not generated
+    --                 here; make them by hand, it only needs to be done once).
+    --         - RLB - Updated to insure that changes are separated by a space.
+    --  4/11/03 - RLB - Changed some formats to meet WC3 validation 
requirements.
+    --  9/09/04 - RLB - Removed unused junk noted by Stephen Leake.
+    --  9/10/04 - RLB - Added "Both" to possible changes to handle
+    --                 replacement of changed text.
+    --  9/14/04 - RLB - Moved Change_Version_Type to ARM_Contents.
+    --         - RLB - Changed to use left/right quotes whether or not Unicode
+    --                 is being used. (These work on IE, but not on old
+    --                 Netscape.)
+    --  9/16/04 - RLB - Added a charset meta in the header, so that browsers
+    --                 can't misinterpret these documents.
+    -- 11/03/04 - RLB - Added Nested_X2_Bulleted.
+    -- 11/15/04 - RLB - Added Indented_Nested_Bulleted.
+    -- 12/15/04 - RLB - Added wider columns.
+