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

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

[elpa] 02/02: publish ada-mode 5.1.6, wisi 1.0.6, new package ada-ref-ma


From: Stephen Leake
Subject: [elpa] 02/02: publish ada-mode 5.1.6, wisi 1.0.6, new package ada-ref-man
Date: Sun, 28 Sep 2014 18:11:38 +0000

stephen_leake pushed a commit to branch master
in repository elpa.

commit 06668272dced7c63995c31d12a27c196a939b863
Author: Stephen Leake <address@hidden>
Date:   Sun Sep 28 13:07:53 2014 -0500

    publish ada-mode 5.1.6, wisi 1.0.6, new package ada-ref-man
    
    * admin/archive-contents.el (archive--metadata): include 'dir' in files, 
for doc-only packages
      (archive--metadata): fix typo in error message
    
    * packages/ada-mode/ada-ref-man.el: New file.
    * packages/ada-mode/*: version 5.1.6
    
    * packages/ada-ref-man/: New directory.
    
    * packages/wisi/*: version 1.0.6
    * packages/wisi/README: New file.
---
 admin/archive-contents.el             |    4 +-
 packages/ada-mode/NEWS                |   13 +
 packages/ada-mode/README              |   36 +-
 packages/ada-mode/ada-fix-error.el    |    9 +-
 packages/ada-mode/ada-gnat-compile.el |   25 +-
 packages/ada-mode/ada-gnat-xref.el    |    2 -
 packages/ada-mode/ada-grammar-wy.el   |  978 +-
 packages/ada-mode/ada-mode.el         |  350 +-
 packages/ada-mode/ada-mode.info       |  134 +-
 packages/ada-mode/ada-mode.texi       |   54 +-
 packages/ada-mode/ada-ref-man.el      |   12 +
 packages/ada-mode/ada-skel.el         |   13 +-
 packages/ada-mode/ada-wisi.el         |  229 +-
 packages/ada-mode/gnat-core.el        |   12 +
 packages/ada-mode/gnat-inspect.el     |    2 -
 packages/ada-mode/gpr-grammar-wy.el   |  238 +-
 packages/ada-mode/gpr-mode.el         |   14 +-
 packages/ada-mode/gpr-mode.info       |  398 +-
 packages/ada-mode/gpr-mode.texi       |    2 +-
 packages/ada-mode/gpr-query.el        |   34 +-
 packages/ada-mode/gpr-skel.el         |    4 +-
 packages/ada-mode/gpr-wisi.el         |   18 +-
 packages/ada-ref-man/README           |   10 +
 packages/ada-ref-man/aarm2012.info    |147476 +++++++++++++++++++++++++++++++++
 packages/ada-ref-man/ada-ref-man.el   |   12 +
 packages/ada-ref-man/arm2012.info     |97779 ++++++++++++++++++++++
 packages/ada-ref-man/dir              |    7 +
 packages/wisi/README                  |   14 +
 packages/wisi/wisi-compile.el         |    7 +-
 packages/wisi/wisi-parse.el           |  126 +-
 packages/wisi/wisi.el                 |  383 +-
 31 files changed, 247123 insertions(+), 1272 deletions(-)

diff --git a/admin/archive-contents.el b/admin/archive-contents.el
old mode 100644
new mode 100755
index 5983646..c53f4ba
--- a/admin/archive-contents.el
+++ b/admin/archive-contents.el
@@ -167,7 +167,7 @@ EXTRAS is an alist with additional metadata.
 
 PKG is the name of the package and DIR is the directory where it is."
   (let* ((mainfile (expand-file-name (concat pkg ".el") dir))
-         (files (directory-files dir nil "\\.el\\'")))
+         (files (directory-files dir nil "\\`dir\\'\\|\\.el\\'")))
     (setq files (delete (concat pkg "-pkg.el") files))
     (setq files (delete (concat pkg "-autoloads.el") files))
     (cond
@@ -201,7 +201,7 @@ PKG is the name of the package and DIR is the directory 
where it is."
                   (list (cons :url url)
                         (cons :keywords keywords)))))))
      (t
-      (error "Can find main file %s file in %s" mainfile dir)))))
+      (error "Can't find main file %s file in %s" mainfile dir)))))
 
 (defun archive--process-simple-package (dir pkg vers desc req extras)
   "Deploy the contents of DIR into the archive as a simple package.
diff --git a/packages/ada-mode/NEWS b/packages/ada-mode/NEWS
index 22daeb3..cc457d9 100755
--- a/packages/ada-mode/NEWS
+++ b/packages/ada-mode/NEWS
@@ -7,7 +7,20 @@ Please send Emacs Ada mode bug reports to address@hidden, with
 'ada-mode' in the subject. If possible, use M-x report-emacs-bug.
 
 
+* Ada mode 5.1.6
+
+** improve syntax highlighting of names after 'of', 'new', 'renames'
+
+** fix ada-format-paramlist to handle 'aliased' keyword (new in Ada
+   2012), and 'not null' without 'access'.
+
+** fix ada-find-other-file in separate bodies; now navigates to the
+   spec.
+
+** restore ada-indent-newline-indent for [return]
+
 * Ada mode 5.1.5
+12 Jul 2014
 
 ** add C-c <, C-c >; goto-declaration-start, -end
 
diff --git a/packages/ada-mode/README b/packages/ada-mode/README
index 56bf740..66c4f34 100644
--- a/packages/ada-mode/README
+++ b/packages/ada-mode/README
@@ -1,4 +1,4 @@
-Emacs Ada mode version 5.1.5
+Emacs Ada mode version 5.1.6
 
 Ada mode requires Emacs 24.2 or greater
 
@@ -34,37 +34,7 @@ matching extension (default *.ads, *.adb).
 
 
 By default ada-mode uses gnat find for cross-reference functions.
-There is experimental support for an alternative, gnatinspect. You can
-select that by adding:
-
-(require 'gnat-inspect)
-
-in your ~/.emacs, before anything that loads ada-mode
-
-to build gnatinspect:
-    (gds-lynx-5)
-    cd ~/Projects
-    tar xf ~/Downloads/gnatcoll...
-    cd gnatcoll...
-    case:
-    when linux:
-        ./configure --prefix=/usr/gnat-7.1.2 --enable-gpl
-    when windows:
-        in cygwin bash, with gnat-7.1.2 in path:
-        ./configure --prefix=/Apps/GNAT-7.1.2 --enable-gpl
-    end case
-
-    make Gnatcoll_Build=Debug
-    sudo make Gnatcoll_Build=Debug install
-
-
-gnatinspect references:
-    gnatcoll-1.6-src/docs/xref.rst
-    gnatcoll-1.6-src/src/tools/gnatinspect.adb
-
-debugging gnatinspect:
-    verbosity in .gnatdebug:
-    -- Projects
-    -- ENTITIES.PARSING
+There is experimental support for two alternatives: gnat_inspect and
+gpr_query. See ada-mode.texi section Installation for more.
 
 (end of file)
diff --git a/packages/ada-mode/ada-fix-error.el 
b/packages/ada-mode/ada-fix-error.el
index e8115fa..33d202f 100644
--- a/packages/ada-mode/ada-fix-error.el
+++ b/packages/ada-mode/ada-fix-error.el
@@ -36,10 +36,11 @@
   :group 'ada)
 
 (defvar ada-fix-context-clause nil
-  "Function to return the region containing the context clause for the current 
buffer.
-Called with no arguments; return (BEGIN . END). BEGIN and
-END must be at beginning of line.  If there is no context
-clause, BEGIN = END, at start of compilation unit.")
+  "Function to return the region containing the context clause for the current 
buffer,
+excluding leading pragmas.  Called with no arguments;
+return (BEGIN . END). BEGIN and END must be at beginning of line.
+If there is no context clause, BEGIN = END, at start of
+compilation unit.")
 
 (defun ada-fix-context-clause ()
   (when ada-fix-context-clause
diff --git a/packages/ada-mode/ada-gnat-compile.el 
b/packages/ada-mode/ada-gnat-compile.el
index 8036f80..b17ebe9 100644
--- a/packages/ada-mode/ada-gnat-compile.el
+++ b/packages/ada-mode/ada-gnat-compile.el
@@ -330,6 +330,19 @@ Prompt user if more than one."
             (insert expected-name))
           t)
 
+         ((looking-at (concat "\"end loop " ada-name-regexp ";\" expected"))
+          (let ((expected-name (match-string 1)))
+            (pop-to-buffer source-buffer)
+            (if (looking-at (concat "end loop " ada-name-regexp ";"))
+                (progn
+                  (goto-char (match-end 1))   ; just before ';'
+                  (delete-region (match-beginning 1) (match-end 1)))
+              ;; else we have just 'end loop;'
+              (forward-word 2)
+              (insert " "))
+            (insert expected-name))
+          t)
+
          ((looking-at "expected an access type")
           (progn
             (set-buffer source-buffer)
@@ -490,7 +503,8 @@ Prompt user if more than one."
          ((looking-at (concat "warning: variable " ada-gnat-quoted-name-regexp 
" is assigned but never read"))
           (let ((param (match-string 1)))
             (pop-to-buffer source-buffer)
-            (ada-goto-end)
+            (ada-goto-end) ;; leaves point before semicolon
+            (forward-char 1)
             (newline-and-indent)
             (insert "pragma Unreferenced (" param ");"))
           t)
@@ -571,7 +585,12 @@ Prompt user if more than one."
 
 (defun ada-gnat-compile-select-prj ()
   (setq ada-fix-error-hook 'ada-gnat-fix-error-hook)
+  (setq ada-prj-show-path 'gnat-prj-show-path)
   (add-to-list 'completion-ignored-extensions ".ali") ;; gnat library files
+  (add-hook 'ada-syntax-propertize-hook 'ada-gnat-syntax-propertize)
+
+  ;; find error locations in .gpr files
+  (setq compilation-search-path (append compilation-search-path (ada-prj-get 
'prj_dir)))
 
   (add-hook 'compilation-filter-hook 'ada-gnat-compilation-filter)
 
@@ -583,6 +602,10 @@ Prompt user if more than one."
 (defun ada-gnat-compile-deselect-prj ()
   (setq ada-fix-error-hook nil)
   (setq completion-ignored-extensions (delete ".ali" 
completion-ignored-extensions))
+  (setq ada-syntax-propertize-hook (delq 'ada-gnat-syntax-propertize 
ada-syntax-propertize-hook))
+
+  ;; don't need to delete from compilation-search-path; completely rewritten 
in ada-select-prj-file
+
   (setq compilation-filter-hook (delete 'ada-gnat-compilation-filter 
compilation-filter-hook))
   (setq compilation-error-regexp-alist (delete 'gnat 
compilation-error-regexp-alist))
   )
diff --git a/packages/ada-mode/ada-gnat-xref.el 
b/packages/ada-mode/ada-gnat-xref.el
index 9accba2..0aefe1e 100644
--- a/packages/ada-mode/ada-gnat-xref.el
+++ b/packages/ada-mode/ada-gnat-xref.el
@@ -175,7 +175,6 @@
   (setq ada-make-package-body       'ada-gnat-make-package-body)
 
   (add-hook 'ada-syntax-propertize-hook 'gnatprep-syntax-propertize)
-  (add-hook 'ada-syntax-propertize-hook 'ada-gnat-syntax-propertize)
 
   ;; must be after indentation engine setup, because that resets the
   ;; indent function list.
@@ -201,7 +200,6 @@
   (setq ada-make-package-body       nil)
 
   (setq ada-syntax-propertize-hook (delq 'gnatprep-syntax-propertize 
ada-syntax-propertize-hook))
-  (setq ada-syntax-propertize-hook (delq 'ada-gnat-syntax-propertize 
ada-syntax-propertize-hook))
   (setq ada-mode-hook (delq 'ada-gnat-xref-setup ada-mode-hook))
 
   (setq ada-xref-other-function  nil)
diff --git a/packages/ada-mode/ada-grammar-wy.el 
b/packages/ada-mode/ada-grammar-wy.el
index ef0ece1..a349179 100644
--- a/packages/ada-mode/ada-grammar-wy.el
+++ b/packages/ada-mode/ada-grammar-wy.el
@@ -175,7 +175,7 @@
         (wisi-containing-action 2 3)
         (wisi-containing-action 2 4)
         (wisi-containing-action 5 6)
-        (wisi-motion-action 1 5 '(6 EXCEPTION))))
+        (wisi-motion-action 1 5 '(6 block-middle EXCEPTION block-middle 
WHEN))))
        ((ACCEPT IDENTIFIER actual_parameter_part_opt parameter_profile_opt 
SEMICOLON )
         (progn
         (wisi-statement-action 1 'statement-start 2 'name-paren 5 
'statement-end)
@@ -183,16 +183,20 @@
         (wisi-containing-action 2 4))))
       (access_definition
        ((null_exclusion_opt ACCESS general_access_modifier_opt name )
-        (wisi-statement-action 4 'type))
+        (progn
+        (wisi-statement-action 2 'keyword)
+        (wisi-face-action 2 'font-lock-keyword-face 4 'font-lock-type-face)))
        ((null_exclusion_opt ACCESS protected_opt PROCEDURE 
parameter_profile_opt )
         (progn
-        (wisi-statement-action 4 'name-paren)
-        (wisi-containing-action 4 5)))
+        (wisi-statement-action 2 'keyword 4 'name-paren)
+        (wisi-containing-action 4 5)
+        (wisi-face-action 2 'font-lock-keyword-face)))
        ((null_exclusion_opt ACCESS protected_opt FUNCTION 
parameter_and_result_profile )
         (progn
-        (wisi-statement-action 4 'name-paren)
+        (wisi-statement-action 2 'keyword 4 'name-paren)
         (wisi-containing-action 4 5)
-        (wisi-motion-action 4 '(5 RETURN)))))
+        (wisi-motion-action 4 '(5 return-1 RETURN return-2 RETURN))
+        (wisi-face-action 2 'font-lock-keyword-face))))
       (actual_parameter_part
        ((LEFT_PAREN association_list RIGHT_PAREN )
         (progn
@@ -228,14 +232,16 @@
       (array_type_definition
        ((ARRAY LEFT_PAREN index_subtype_definition_list RIGHT_PAREN OF 
component_definition )
         (progn
-        (wisi-statement-action 2 'open-paren 4 'close-paren 5 'statement-other)
+        (wisi-statement-action 1 'keyword 2 'open-paren 4 'close-paren 5 
'statement-other)
         (wisi-containing-action 2 3)
-        (wisi-containing-action 5 6)))
+        (wisi-containing-action 5 6)
+        (wisi-face-action 1 'font-lock-keyword-face)))
        ((ARRAY LEFT_PAREN discrete_subtype_definition_list RIGHT_PAREN OF 
component_definition )
         (progn
-        (wisi-statement-action 2 'open-paren 4 'close-paren 5 'statement-other)
+        (wisi-statement-action 1 'keyword 2 'open-paren 4 'close-paren 5 
'statement-other)
         (wisi-containing-action 2 3)
-        (wisi-containing-action 5 6))))
+        (wisi-containing-action 5 6)
+        (wisi-face-action 1 'font-lock-keyword-face))))
       (aspect_clause
        ((FOR attribute_reference USE expression SEMICOLON )
         (progn
@@ -303,12 +309,12 @@
         (wisi-statement-action 1 'block-start 3 'block-middle 5 'block-end 7 
'statement-end)
         (wisi-containing-action 1 2)
         (wisi-containing-action 3 4)
-        (wisi-motion-action 1 3 '(4 EXCEPTION) 5)))
+        (wisi-motion-action 1 3 '(4 block-middle EXCEPTION block-middle WHEN) 
5)))
        ((BEGIN handled_sequence_of_statements END identifier_opt SEMICOLON )
         (progn
         (wisi-statement-action 1 'block-start 3 'block-end 5 'statement-end)
         (wisi-containing-action 1 2)
-        (wisi-motion-action 1 '(2 EXCEPTION) 3))))
+        (wisi-motion-action 1 '(2 block-middle EXCEPTION block-middle WHEN) 
3))))
       (body
        ((proper_body ))
        ((body_stub )))
@@ -340,7 +346,7 @@
         (wisi-statement-action 1 'block-start 3 'block-middle 5 'block-end 7 
'statement-end)
         (wisi-containing-action 1 2)
         (wisi-containing-action 3 4)
-        (wisi-motion-action 1 '(4 WHEN) 5))))
+        (wisi-motion-action 1 '(4 block-middle WHEN) 5))))
       (case_statement_alternative
        ((WHEN discrete_choice_list EQUAL_GREATER sequence_of_statements_opt )
         (progn
@@ -438,7 +444,10 @@
         (wisi-containing-action 3 4))))
       (constant_opt
        (())
-       ((CONSTANT )))
+       ((CONSTANT )
+        (progn
+        (wisi-statement-action 1 'keyword)
+        (wisi-face-action 1 'font-lock-keyword-face))))
       (constraint
        ((RANGE range ))
        ((index_constraint )))
@@ -490,8 +499,11 @@
         (wisi-containing-action 1 2))))
       (derived_type_definition
        ((abstract_limited_opt NEW name and_interface_list_opt WITH 
record_definition )
-        (wisi-statement-action 5 'statement-other))
-       ((abstract_limited_opt NEW name constraint_opt )))
+        (progn
+        (wisi-statement-action 5 'statement-other)
+        (wisi-face-action 3 'font-lock-type-face)))
+       ((abstract_limited_opt NEW name constraint_opt )
+        (wisi-face-action 3 'font-lock-type-face)))
       (direct_name
        ((IDENTIFIER ))
        ((STRING_LITERAL )))
@@ -663,7 +675,8 @@
        ((RETURN extended_return_object_declaration_opt DO 
handled_sequence_of_statements END RETURN SEMICOLON )
         (progn
         (wisi-statement-action 1 'block-start 3 'block-middle 5 'block-end 7 
'statement-end)
-        (wisi-containing-action 3 4)))
+        (wisi-containing-action 3 4)
+        (wisi-motion-action 1 3 5)))
        ((RETURN extended_return_object_declaration SEMICOLON )
         (wisi-statement-action 1 'statement-start 3 'statement-end)))
       (factor
@@ -746,10 +759,10 @@
        ((access_definition ))
        ((interface_type_definition )))
       (formal_derived_type_definition
-       ((abstract_limited_synchronized_opt NEW name AND interface_list WITH 
PRIVATE ))
-       ((abstract_limited_synchronized_opt NEW name WITH PRIVATE ))
-       ((abstract_limited_synchronized_opt NEW name AND interface_list ))
-       ((abstract_limited_synchronized_opt NEW name )))
+       ((abstract_limited_synchronized_opt NEW name and_interface_list_opt 
WITH PRIVATE )
+        (wisi-face-action 3 'font-lock-type-face))
+       ((abstract_limited_synchronized_opt NEW name and_interface_list_opt )
+        (wisi-face-action 3 'font-lock-type-face)))
       (formal_package_declaration
        ((WITH PACKAGE name IS NEW name formal_package_actual_part 
aspect_specification_opt SEMICOLON )
         (progn
@@ -757,7 +770,8 @@
         (wisi-containing-action 1 3)
         (wisi-containing-action 5 6)
         (wisi-containing-action 6 7)
-        (wisi-containing-action 6 8))))
+        (wisi-containing-action 6 8)
+        (wisi-face-action 6 'font-lock-function-name-face))))
       (formal_package_actual_part
        ((LEFT_PAREN BOX RIGHT_PAREN ))
        (()))
@@ -776,7 +790,7 @@
         (wisi-statement-action 1 'statement-other 2 'name)
         (wisi-containing-action 1 2)
         (wisi-containing-action 1 3)
-        (wisi-motion-action 1 '(3 RETURN)))))
+        (wisi-motion-action 1 '(3 return-1 RETURN return-2 RETURN)))))
       (general_access_modifier_opt
        (())
        ((ALL ))
@@ -805,17 +819,20 @@
         (progn
         (wisi-statement-action 1 'statement-start 2 'name 4 'statement-other 7 
'statement-end)
         (wisi-containing-action 4 5)
-        (wisi-containing-action 5 6)))
+        (wisi-containing-action 5 6)
+        (wisi-face-action 5 'font-lock-function-name-face)))
        ((overriding_indicator_opt PROCEDURE name IS NEW name 
aspect_specification_opt SEMICOLON )
         (progn
         (wisi-statement-action 1 'statement-start 2 'block-middle 3 'name 5 
'statement-other 8 'statement-end)
         (wisi-containing-action 5 6)
-        (wisi-containing-action 6 7)))
+        (wisi-containing-action 6 7)
+        (wisi-face-action 6 'font-lock-function-name-face)))
        ((overriding_indicator_opt FUNCTION name IS NEW name 
aspect_specification_opt SEMICOLON )
         (progn
         (wisi-statement-action 1 'statement-start 2 'block-middle 3 'name 5 
'statement-other 8 'statement-end)
         (wisi-containing-action 5 6)
-        (wisi-containing-action 6 7))))
+        (wisi-containing-action 6 7)
+        (wisi-face-action 6 'font-lock-function-name-face))))
       (generic_package_declaration
        ((generic_formal_part package_specification SEMICOLON )
         (progn
@@ -826,17 +843,20 @@
         (progn
         (wisi-statement-action 1 'statement-start 2 'statement-other 3 'name 4 
'statement-other 7 'statement-end)
         (wisi-containing-action 2 3)
-        (wisi-containing-action 3 6)))
+        (wisi-containing-action 3 6)
+        (wisi-face-action 5 'font-lock-function-name-face)))
        ((GENERIC PROCEDURE name RENAMES name aspect_specification_opt 
SEMICOLON )
         (progn
         (wisi-statement-action 1 'statement-start 2 'statement-other 3 'name 4 
'statement-other 7 'statement-end)
         (wisi-containing-action 2 3)
-        (wisi-containing-action 3 6)))
+        (wisi-containing-action 3 6)
+        (wisi-face-action 5 'font-lock-function-name-face)))
        ((GENERIC FUNCTION name RENAMES name aspect_specification_opt SEMICOLON 
)
         (progn
         (wisi-statement-action 1 'statement-start 2 'statement-other 3 'name 4 
'statement-other 7 'statement-end)
         (wisi-containing-action 2 3)
-        (wisi-containing-action 3 6))))
+        (wisi-containing-action 3 6)
+        (wisi-face-action 5 'font-lock-function-name-face))))
       (generic_subprogram_declaration
        ((generic_formal_part subprogram_specification aspect_specification_opt 
SEMICOLON )
         (progn
@@ -847,8 +867,7 @@
        ((sequence_of_statements_opt EXCEPTION exception_handler_list_opt )
         (progn
         (wisi-statement-action 2 'block-middle)
-        (wisi-containing-action 2 3)
-        (wisi-motion-action 2 '(3 WHEN))))
+        (wisi-containing-action 2 3)))
        ((sequence_of_statements_opt )))
       (identifier_list
        ((IDENTIFIER ))
@@ -864,14 +883,14 @@
         (wisi-containing-action 3 4)
         (wisi-containing-action 3 5)
         (wisi-containing-action 6 7)
-        (wisi-motion-action 1 3 '(5 (ELSIF THEN)) 6)))
+        (wisi-motion-action 1 3 '(5 statement-other ELSIF block-middle THEN) 
6)))
        ((IF expression THEN expression elsif_expression_list )
         (progn
         (wisi-statement-action 1 'statement-start 3 'block-middle)
         (wisi-containing-action 1 2)
         (wisi-containing-action 3 4)
         (wisi-containing-action 3 5)
-        (wisi-motion-action 1 3 '(5 (ELSIF THEN)))))
+        (wisi-motion-action 1 3 '(5 statement-other ELSIF block-middle THEN))))
        ((IF expression THEN expression ELSE expression )
         (progn
         (wisi-statement-action 1 'statement-start 3 'block-middle 5 
'block-middle)
@@ -893,14 +912,14 @@
         (wisi-containing-action 3 4)
         (wisi-containing-action 3 5)
         (wisi-containing-action 6 7)
-        (wisi-motion-action 1 3 '(5 (ELSIF THEN)) 6 8)))
+        (wisi-motion-action 1 3 '(5 statement-other ELSIF block-middle THEN) 6 
8)))
        ((IF expression_opt THEN sequence_of_statements_opt 
elsif_statement_list END IF SEMICOLON )
         (progn
         (wisi-statement-action 1 'statement-start 3 'block-middle 6 'block-end 
9 'statement-end)
         (wisi-containing-action 1 2)
         (wisi-containing-action 3 4)
         (wisi-containing-action 3 5)
-        (wisi-motion-action 1 3 '(5 (ELSIF THEN)) 6)))
+        (wisi-motion-action 1 3 '(5 statement-other ELSIF block-middle THEN) 
6)))
        ((IF expression_opt THEN sequence_of_statements_opt ELSE 
sequence_of_statements_opt END IF SEMICOLON )
         (progn
         (wisi-statement-action 1 'statement-start 3 'block-middle 5 
'block-middle 7 'block-end 9 'statement-end)
@@ -935,8 +954,10 @@
         (wisi-statement-action 2 'list-break)
         (wisi-containing-action 2 3))))
       (interface_list
-       ((name ))
-       ((interface_list AND name )))
+       ((name )
+        (wisi-face-action 1 'font-lock-type-face))
+       ((interface_list AND name )
+        (wisi-face-action 3 'font-lock-type-face)))
       (interface_type_definition
        ((LIMITED INTERFACE AND interface_list ))
        ((TASK INTERFACE AND interface_list ))
@@ -1007,9 +1028,18 @@
        ((AT MOD expression SEMICOLON )))
       (mode_opt
        (())
-       ((IN ))
-       ((IN OUT ))
-       ((OUT )))
+       ((IN )
+        (progn
+        (wisi-statement-action 1 'keyword)
+        (wisi-face-action 1 'font-lock-keyword-face)))
+       ((IN OUT )
+        (progn
+        (wisi-statement-action 1 'keyword)
+        (wisi-face-action 1 'font-lock-keyword-face)))
+       ((OUT )
+        (progn
+        (wisi-statement-action 1 'keyword)
+        (wisi-face-action 1 'font-lock-keyword-face))))
       (multiplying_operator
        ((STAR ))
        ((SLASH ))
@@ -1022,14 +1052,16 @@
         (wisi-statement-action 2 'statement-other)
         (wisi-containing-action 2 3))))
       (name
-       ((IDENTIFIER ))
+       ((IDENTIFIER )
+        (wisi-statement-action 1 'name))
        ((CHARACTER_LITERAL ))
        ((name LEFT_PAREN range RIGHT_PAREN )
         (progn
         (wisi-statement-action 1 'name-paren 2 'open-paren 4 'close-paren)
         (wisi-containing-action 1 2)
         (wisi-containing-action 2 3)))
-       ((selected_component ))
+       ((selected_component )
+        (wisi-extend-action 1))
        ((attribute_reference ))
        ((name actual_parameter_part )
         (progn
@@ -1042,7 +1074,10 @@
        ((name )))
       (null_exclusion_opt
        (())
-       ((NOT NULL )))
+       ((NOT NULL )
+        (progn
+        (wisi-statement-action 1 'keyword)
+        (wisi-face-action 1 'font-lock-keyword-face))))
       (null_exclusion_opt_name
        ((IDENTIFIER ))
        ((selected_component ))
@@ -1122,7 +1157,7 @@
         (wisi-containing-action 3 4)
         (wisi-containing-action 5 6)
         (wisi-containing-action 7 8)
-        (wisi-motion-action 1 5 7 '(8 EXCEPTION) 9)))
+        (wisi-motion-action 1 5 7 '(8 block-middle EXCEPTION block-middle 
WHEN) 9)))
        ((PACKAGE BODY name aspect_specification_opt IS declarative_part_opt 
END name_opt SEMICOLON )
         (progn
         (wisi-statement-action 1 'block-start 3 'name 5 'block-middle 7 
'block-end 9 'statement-end)
@@ -1144,7 +1179,8 @@
         (progn
         (wisi-statement-action 1 'statement-start 2 'name 3 'statement-other 6 
'statement-end)
         (wisi-containing-action 1 2)
-        (wisi-containing-action 3 5))))
+        (wisi-containing-action 3 5)
+        (wisi-face-action 4 'font-lock-function-name-face))))
       (package_specification
        ((PACKAGE name aspect_specification_opt IS declarative_part_opt PRIVATE 
declarative_part_opt END name_opt )
         (progn
@@ -1164,12 +1200,13 @@
       (parameter_and_result_profile
        ((formal_part RETURN null_exclusion_opt name_opt )
         (progn
-        (wisi-statement-action
-        2 'return-1
-        4 'type)
-        (wisi-containing-action 2 4)))
+        (wisi-statement-action 2 'return-1)
+        (wisi-containing-action 2 4)
+        (wisi-face-action 4 'font-lock-type-face)))
        ((RETURN name_opt )
-        (wisi-statement-action 1 'return-2 2 'type))
+        (progn
+        (wisi-statement-action 1 'return-2)
+        (wisi-face-action 2 'font-lock-type-face)))
        ((formal_part RETURN access_definition )
         (progn
         (wisi-statement-action 2 'return-1)
@@ -1182,10 +1219,12 @@
        (())
        ((formal_part )))
       (parameter_specification
-       ((identifier_list COLON aliased_opt mode_opt null_exclusion_opt name 
COLON_EQUAL expression ))
-       ((identifier_list COLON aliased_opt mode_opt null_exclusion_opt name ))
-       ((identifier_list COLON access_definition COLON_EQUAL expression ))
-       ((identifier_list COLON access_definition )))
+       ((identifier_list COLON aliased_opt mode_opt null_exclusion_opt name 
COLON_EQUAL expression )
+        (wisi-face-action 6 'font-lock-type-face))
+       ((identifier_list COLON aliased_opt mode_opt null_exclusion_opt name )
+        (wisi-face-action 6 'font-lock-type-face))
+       ((identifier_list COLON aliased_opt access_definition COLON_EQUAL 
expression ))
+       ((identifier_list COLON aliased_opt access_definition )))
       (parameter_specification_list
        ((parameter_specification ))
        ((parameter_specification_list SEMICOLON parameter_specification )
@@ -1223,7 +1262,8 @@
        ((NULL ))
        ((aggregate ))
        ((name ))
-       ((NEW name ))
+       ((NEW name )
+        (wisi-face-action 2 'font-lock-type-face))
        ((LEFT_PAREN if_expression RIGHT_PAREN )
         (progn
         (wisi-statement-action 1 'open-paren 3 'close-paren)
@@ -1243,7 +1283,8 @@
         (wisi-containing-action 1 3)
         (wisi-containing-action 6 7)
         (wisi-containing-action 6 8)
-        (wisi-containing-action 2 11))))
+        (wisi-containing-action 2 11)
+        (wisi-face-action 7 'font-lock-type-face))))
       (private_type_declaration
        ((TYPE IDENTIFIER discriminant_part_opt IS abstract_tagged_limited_opt 
PRIVATE aspect_specification_opt SEMICOLON )
         (progn
@@ -1416,12 +1457,12 @@
         (wisi-statement-action 1 'block-start 3 'block-middle 5 'block-end 7 
'statement-end)
         (wisi-containing-action 1 2)
         (wisi-containing-action 3 4)
-        (wisi-motion-action 1 '(2 OR) 3 5)))
+        (wisi-motion-action 1 '(2 block-middle OR) 3 5)))
        ((SELECT select_alternative_list_opt END SELECT SEMICOLON )
         (progn
         (wisi-statement-action 1 'block-start 3 'block-end 5 'statement-end)
         (wisi-containing-action 1 2)
-        (wisi-motion-action 1 '(2 OR) 3))))
+        (wisi-motion-action 1 '(2 block-middle OR) 3))))
       (select_alternative
        ((WHEN expression EQUAL_GREATER accept_statement 
sequence_of_statements_opt )
         (progn
@@ -1547,7 +1588,8 @@
        ((overriding_indicator_opt subprogram_specification RENAMES name 
aspect_specification_opt SEMICOLON )
         (progn
         (wisi-statement-action 1 'statement-start 2 'block-middle 3 
'statement-other 6 'statement-end)
-        (wisi-containing-action 2 5))))
+        (wisi-containing-action 2 5)
+        (wisi-face-action 4 'font-lock-function-name-face))))
       (subprogram_specification
        ((procedure_specification ))
        ((function_specification )))
@@ -1561,18 +1603,24 @@
       (subtype_indication
        ((NOT NULL name constraint )
         (progn
-        (wisi-statement-action 3 'name)
-        (wisi-containing-action 3 4)))
-       ((NOT NULL name ))
+        (wisi-statement-action 1 'keyword)
+        (wisi-containing-action 3 4)
+        (wisi-face-action 1 'font-lock-keyword-face 3 'font-lock-type-face)))
+       ((NOT NULL name )
+        (progn
+        (wisi-statement-action 1 'keyword)
+        (wisi-face-action 1 'font-lock-keyword-face 3 'font-lock-type-face)))
        ((name constraint )
         (progn
-        (wisi-statement-action 1 'name)
-        (wisi-containing-action 1 2)))
-       ((name )))
+        (wisi-containing-action 1 2)
+        (wisi-face-action 1 'font-lock-type-face)))
+       ((name )
+        (wisi-face-action 1 'font-lock-type-face)))
       (subunit
        ((SEPARATE LEFT_PAREN name RIGHT_PAREN proper_body )
         (progn
-        (wisi-statement-action 2 'open-paren 4 'close-paren)
+        (wisi-statement-action 1 'block-start 2 'open-paren 4 'close-paren 5 
'block-middle)
+        (wisi-containing-action 1 5)
         (wisi-containing-action 2 3))))
       (task_body
        ((TASK BODY IDENTIFIER aspect_specification_opt IS declarative_part_opt 
BEGIN handled_sequence_of_statements END identifier_opt SEMICOLON )
@@ -1918,12 +1966,12 @@
       ((default . error) (DO . (selected_component . 2)) (RIGHT_PAREN . 
(selected_component . 2)) (BAR . (selected_component . 2)) (ELSIF . 
(selected_component . 2)) (ELSE . (selected_component . 2)) (EQUAL_GREATER . 
(selected_component . 2)) (DIGITS . (selected_component . 2)) (RANGE . 
(selected_component . 2)) (THEN . (selected_component . 2)) (DOT_DOT . 
(selected_component . 2)) (IN . (selected_component . 2)) (NOT . 
(selected_component . 2)) (EQUAL . (selected_component . 2)) (GREATE [...]
       ((default . error) (DO . (selected_component . 1)) (RIGHT_PAREN . 
(selected_component . 1)) (BAR . (selected_component . 1)) (ELSIF . 
(selected_component . 1)) (ELSE . (selected_component . 1)) (EQUAL_GREATER . 
(selected_component . 1)) (DIGITS . (selected_component . 1)) (RANGE . 
(selected_component . 1)) (THEN . (selected_component . 1)) (DOT_DOT . 
(selected_component . 1)) (IN . (selected_component . 1)) (NOT . 
(selected_component . 1)) (EQUAL . (selected_component . 1)) (GREATE [...]
       ((default . error) (DO . (selected_component . 3)) (RIGHT_PAREN . 
(selected_component . 3)) (BAR . (selected_component . 3)) (ELSIF . 
(selected_component . 3)) (ELSE . (selected_component . 3)) (EQUAL_GREATER . 
(selected_component . 3)) (DIGITS . (selected_component . 3)) (RANGE . 
(selected_component . 3)) (THEN . (selected_component . 3)) (DOT_DOT . 
(selected_component . 3)) (IN . (selected_component . 3)) (NOT . 
(selected_component . 3)) (EQUAL . (selected_component . 3)) (GREATE [...]
-      ((default . error) (DOT_DOT . (primary . 0)) (RIGHT_PAREN . (primary . 
0)) (COMMA . (primary . 0)) (BAR . (primary . 0)) (EQUAL_GREATER . (primary . 
0)) (PLUS . (primary . 0)) (MINUS . (primary . 0)) (AMPERSAND . (primary . 0)) 
(IN . (primary . 0)) (NOT . (primary . 0)) (EQUAL . (primary . 0)) (GREATER . 
(primary . 0)) (GREATER_EQUAL . (primary . 0)) (LESS . (primary . 0)) 
(LESS_EQUAL . (primary . 0)) (SLASH_EQUAL . (primary . 0)) (WITH . (primary . 
0)) (SLASH . (primary . 0)) (STA [...]
-      ((default . error) (COMMA .  261) (RIGHT_PAREN .  517))
-      ((default . error) (RIGHT_PAREN . (expression_opt . 1)) (COMMA . 
(expression_opt . 1)) (WITH .  516))
+      ((default . error) (DOT_DOT . (primary . 0)) (RIGHT_PAREN . (primary . 
0)) (COMMA . (primary . 0)) (BAR . (primary . 0)) (EQUAL_GREATER . (primary . 
0)) (PLUS . (primary . 0)) (MINUS . (primary . 0)) (AMPERSAND . (primary . 0)) 
(IN . (primary . 0)) (NOT . (primary . 0)) (EQUAL . (primary . 0)) (GREATER . 
(primary . 0)) (GREATER_EQUAL . (primary . 0)) (LESS . (primary . 0)) 
(LESS_EQUAL . (primary . 0)) (SLASH_EQUAL . (primary . 0)) (WITH . (primary . 
0)) (SLASH . (primary . 0)) (STA [...]
+      ((default . error) (COMMA .  261) (RIGHT_PAREN .  516))
+      ((default . error) (RIGHT_PAREN . (expression_opt . 1)) (COMMA . 
(expression_opt . 1)) (WITH .  515))
       ((default . error) (IDENTIFIER .  72))
       ((default . error) (RIGHT_PAREN . (formal_part . 0)) (COLON_EQUAL . 
(formal_part . 0)) (DO . (formal_part . 0)) (WHEN . (formal_part . 0)) (RENAMES 
. (formal_part . 0)) (IS . (formal_part . 0)) (SEMICOLON . (formal_part . 0)) 
(WITH . (formal_part . 0)) (RETURN . (formal_part . 0)))
-      ((default . error) (IN . (aliased_opt . 0)) (OUT . (aliased_opt . 0)) 
(IDENTIFIER . (aliased_opt . 0)) (STRING_LITERAL . (aliased_opt . 0)) 
(CHARACTER_LITERAL . (aliased_opt . 0)) (ALIASED .  512) (ACCESS . 
(null_exclusion_opt . 0)) (NOT . ((aliased_opt . 0)  208)))
+      ((default . error) (ACCESS . (aliased_opt . 0)) (NOT . (aliased_opt . 
0)) (IN . (aliased_opt . 0)) (OUT . (aliased_opt . 0)) (IDENTIFIER . 
(aliased_opt . 0)) (STRING_LITERAL . (aliased_opt . 0)) (CHARACTER_LITERAL . 
(aliased_opt . 0)) (ALIASED .  512))
       ((default . error) (FUNCTION . (protected_opt . 0)) (PROCEDURE . 
(protected_opt . 0)) (PROTECTED .  509) (IDENTIFIER . 
(general_access_modifier_opt . 0)) (STRING_LITERAL . 
(general_access_modifier_opt . 0)) (CHARACTER_LITERAL . 
(general_access_modifier_opt . 0)) (ALL .  507) (CONSTANT .  508))
       ((default . error) (RIGHT_PAREN . (null_exclusion_opt . 1)) (DO . 
(null_exclusion_opt . 1)) (RENAMES . (null_exclusion_opt . 1)) (COLON_EQUAL . 
(null_exclusion_opt . 1)) (ACCESS . (null_exclusion_opt . 1)) 
(CHARACTER_LITERAL . (null_exclusion_opt . 1)) (STRING_LITERAL . 
(null_exclusion_opt . 1)) (IDENTIFIER . (null_exclusion_opt . 1)) (WITH . 
(null_exclusion_opt . 1)) (SEMICOLON . (null_exclusion_opt . 1)) (IS . 
(null_exclusion_opt . 1)))
       ((default . error) (DO . (parameter_and_result_profile . 2)) 
(RIGHT_PAREN . (parameter_and_result_profile . 2)) (COLON_EQUAL . 
(parameter_and_result_profile . 2)) (RENAMES . (parameter_and_result_profile . 
2)) (IS . (parameter_and_result_profile . 2)) (SEMICOLON . 
(parameter_and_result_profile . 2)) (WITH . (parameter_and_result_profile . 2)))
@@ -2076,21 +2124,21 @@
       ((default . error) (IDENTIFIER .  48) (CHARACTER_LITERAL .  50) 
(STRING_LITERAL .  49))
       ((default . error) (DOT .  87) (TICK .  88) (SEMICOLON . 
(aspect_specification_opt . 0)) (WITH .  108) (LEFT_PAREN .  106))
       ((default . error) (DOT .  87) (TICK .  88) (SEMICOLON . 
(aspect_specification_opt . 0)) (WITH .  108) (LEFT_PAREN .  106))
-      ((default . error) (END . (sequence_of_statements_opt . 0)) (EXCEPTION . 
(sequence_of_statements_opt . 0)) (ACCEPT . (label_opt . 0)) (BEGIN . 
(label_opt . 0)) (CASE . (label_opt . 0)) (DECLARE . (label_opt . 0)) (FOR . 
(label_opt . 0)) (IF . (label_opt . 0)) (LOOP . (label_opt . 0)) (RETURN . 
(label_opt . 0)) (SELECT . (label_opt . 0)) (WHILE . (label_opt . 0)) 
(STRING_LITERAL . (label_opt . 0)) (CHARACTER_LITERAL . (label_opt . 0)) (ABORT 
. (label_opt . 0)) (DELAY . (label_opt .  [...]
+      ((default . error) (END . (sequence_of_statements_opt . 0)) (EXCEPTION . 
(sequence_of_statements_opt . 0)) (ACCEPT . (label_opt . 0)) (BEGIN . 
(label_opt . 0)) (CASE . (label_opt . 0)) (DECLARE . (label_opt . 0)) (FOR . 
(label_opt . 0)) (IF . (label_opt . 0)) (LOOP . (label_opt . 0)) (RETURN . 
(label_opt . 0)) (SELECT . (label_opt . 0)) (WHILE . (label_opt . 0)) 
(STRING_LITERAL . (label_opt . 0)) (CHARACTER_LITERAL . (label_opt . 0)) (ABORT 
. (label_opt . 0)) (DELAY . (label_opt .  [...]
       ((default . error) (BEGIN . (subprogram_renaming_declaration . 0)) 
(IDENTIFIER . (subprogram_renaming_declaration . 0)) (ENTRY . 
(subprogram_renaming_declaration . 0)) (FOR . (subprogram_renaming_declaration 
. 0)) (PROTECTED . (subprogram_renaming_declaration . 0)) (SUBTYPE . 
(subprogram_renaming_declaration . 0)) (TASK . (subprogram_renaming_declaration 
. 0)) (TYPE . (subprogram_renaming_declaration . 0)) (END . 
(subprogram_renaming_declaration . 0)) (WITH . (subprogram_renaming_d [...]
       ((default . error) (IS . (aspect_specification_opt . 0)) (WITH .  108))
-      ((default . error) (IDENTIFIER .  609))
       ((default . error) (IDENTIFIER .  608))
-      ((default . error) (EQUAL_GREATER .  607))
+      ((default . error) (IDENTIFIER .  607))
+      ((default . error) (EQUAL_GREATER .  606))
       ((default . error) (COMMA . (pragma_argument_association . 0)) 
(RIGHT_PAREN . (pragma_argument_association . 0)))
       ((default . error) (OF . (primary . 6)) (COLON_EQUAL . (primary . 6)) 
(DO . (primary . 6)) (LOOP . (primary . 6)) (ELSIF . (primary . 6)) (ELSE . 
(primary . 6)) (DIGITS . (primary . 6)) (RIGHT_PAREN . (primary . 6)) (COMMA . 
(primary . 6)) (RANGE . (primary . 6)) (THEN . (primary . 6)) (WITH . (primary 
. 6)) (BAR . (primary . 6)) (EQUAL_GREATER . (primary . 6)) (IS . (primary . 
6)) (IN . (primary . 6)) (NOT . (primary . 6)) (EQUAL . (primary . 6)) (GREATER 
. (primary . 6)) (GREATER [...]
       ((default . error) (OF . (primary . 4)) (COLON_EQUAL . (primary . 4)) 
(DO . (primary . 4)) (LOOP . (primary . 4)) (ELSIF . (primary . 4)) (ELSE . 
(primary . 4)) (DIGITS . (primary . 4)) (RIGHT_PAREN . (primary . 4)) (COMMA . 
(primary . 4)) (RANGE . (primary . 4)) (THEN . (primary . 4)) (WITH . (primary 
. 4)) (BAR . (primary . 4)) (EQUAL_GREATER . (primary . 4)) (IS . (primary . 
4)) (IN . (primary . 4)) (NOT . (primary . 4)) (EQUAL . (primary . 4)) (GREATER 
. (primary . 4)) (GREATER [...]
       ((default . error) (OF . (primary . 5)) (COLON_EQUAL . (primary . 5)) 
(DO . (primary . 5)) (LOOP . (primary . 5)) (ELSIF . (primary . 5)) (ELSE . 
(primary . 5)) (DIGITS . (primary . 5)) (RIGHT_PAREN . (primary . 5)) (COMMA . 
(primary . 5)) (RANGE . (primary . 5)) (THEN . (primary . 5)) (WITH . (primary 
. 5)) (BAR . (primary . 5)) (EQUAL_GREATER . (primary . 5)) (IS . (primary . 
5)) (IN . (primary . 5)) (NOT . (primary . 5)) (EQUAL . (primary . 5)) (GREATER 
. (primary . 5)) (GREATER [...]
-      ((default . error) (THEN .  606))
+      ((default . error) (THEN .  605))
       ((default . error) (IDENTIFIER . (quantifier . 0)))
       ((default . error) (IDENTIFIER . (quantifier . 1)))
-      ((default . error) (IDENTIFIER .  604))
-      ((default . error) (IS .  603))
+      ((default . error) (IDENTIFIER .  603))
+      ((default . error) (IS .  602))
       ((default . error) (WHEN . (pragma . 0)) (THEN . (pragma . 0)) (OR . 
(pragma . 0)) (ELSIF . (pragma . 0)) (ELSE . (pragma . 0)) (WHILE . (pragma . 
0)) (SELECT . (pragma . 0)) (RETURN . (pragma . 0)) (REQUEUE . (pragma . 0)) 
(RAISE . (pragma . 0)) (NULL . (pragma . 0)) (LOOP . (pragma . 0)) (IF . 
(pragma . 0)) (GOTO . (pragma . 0)) (EXIT . (pragma . 0)) (DELAY . (pragma . 
0)) (DECLARE . (pragma . 0)) (CASE . (pragma . 0)) (ABORT . (pragma . 0)) 
(ACCEPT . (pragma . 0)) (CHARACTER_LIT [...]
       ((default . error) (RIGHT_PAREN . (pragma_argument_association_list . 
1)) (COMMA . (pragma_argument_association_list . 1)))
       ((default . error) (OF . (factor . 0)) (COLON_EQUAL . (factor . 0)) (DO 
. (factor . 0)) (LOOP . (factor . 0)) (ELSIF . (factor . 0)) (ELSE . (factor . 
0)) (DIGITS . (factor . 0)) (COMMA . (factor . 0)) (RIGHT_PAREN . (factor . 0)) 
(RANGE . (factor . 0)) (THEN . (factor . 0)) (WITH . (factor . 0)) (BAR . 
(factor . 0)) (EQUAL_GREATER . (factor . 0)) (IS . (factor . 0)) (SLASH_EQUAL . 
(factor . 0)) (LESS_EQUAL . (factor . 0)) (LESS . (factor . 0)) (GREATER_EQUAL 
. (factor . 0)) (GREAT [...]
@@ -2107,30 +2155,30 @@
       ((default . error) (DO . (relation . 1)) (LOOP . (relation . 1)) (COMMA 
. (relation . 1)) (ELSIF . (relation . 1)) (ELSE . (relation . 1)) 
(EQUAL_GREATER . (relation . 1)) (RIGHT_PAREN . (relation . 1)) (DIGITS . 
(relation . 1)) (RANGE . (relation . 1)) (THEN . (relation . 1)) (SEMICOLON . 
(relation . 1)) (WITH . (relation . 1)) (IS . (relation . 1)) (AND . (relation 
. 1)) (OR . (relation . 1)) (XOR . (relation . 1)))
       ((default . error) (OF . (term . 1)) (COLON_EQUAL . (term . 1)) (DO . 
(term . 1)) (LOOP . (term . 1)) (ELSIF . (term . 1)) (ELSE . (term . 1)) 
(DIGITS . (term . 1)) (RIGHT_PAREN . (term . 1)) (COMMA . (term . 1)) (RANGE . 
(term . 1)) (THEN . (term . 1)) (WITH . (term . 1)) (BAR . (term . 1)) 
(EQUAL_GREATER . (term . 1)) (IS . (term . 1)) (IN . (term . 1)) (NOT . (term . 
1)) (EQUAL . (term . 1)) (GREATER . (term . 1)) (GREATER_EQUAL . (term . 1)) 
(LESS . (term . 1)) (LESS_EQUAL . (t [...]
       ((default . error) (OF . (term_list . 1)) (COLON_EQUAL . (term_list . 
1)) (DO . (term_list . 1)) (LOOP . (term_list . 1)) (ELSIF . (term_list . 1)) 
(ELSE . (term_list . 1)) (DIGITS . (term_list . 1)) (COMMA . (term_list . 1)) 
(RIGHT_PAREN . (term_list . 1)) (RANGE . (term_list . 1)) (THEN . (term_list . 
1)) (WITH . (term_list . 1)) (BAR . (term_list . 1)) (EQUAL_GREATER . 
(term_list . 1)) (IS . (term_list . 1)) (SLASH_EQUAL . (term_list . 1)) 
(LESS_EQUAL . (term_list . 1)) (LESS .  [...]
-      ((default . error) (BEGIN .  597) (END .  598))
-      ((default . error) (IDENTIFIER .  596))
-      ((default . error) (IS . ( 595 (subprogram_specification . 1))) (WITH . 
(subprogram_specification . 1)) (SEMICOLON . (subprogram_specification . 1)) 
(RENAMES . (subprogram_specification . 1)))
-      ((default . error) (IS . ( 594 (subprogram_specification . 0))) (WITH . 
(subprogram_specification . 0)) (SEMICOLON . (subprogram_specification . 0)) 
(RENAMES . (subprogram_specification . 0)))
-      ((default . error) (RENAMES .  127) (SEMICOLON . 
(aspect_specification_opt . 0)) (IS . ( 593 (aspect_specification_opt . 0))) 
(WITH .  108))
-      ((default . error) (EXCEPTION .  591) (CONSTANT . ( 590 (aliased_opt . 
0))) (ARRAY . (aliased_opt . 0)) (ACCESS . (aliased_opt . 0)) (NOT . 
(aliased_opt . 0)) (IDENTIFIER . (aliased_opt . 0)) (STRING_LITERAL . 
(aliased_opt . 0)) (CHARACTER_LITERAL . (aliased_opt . 0)) (ALIASED .  512))
+      ((default . error) (BEGIN .  596) (END .  597))
+      ((default . error) (IDENTIFIER .  595))
+      ((default . error) (IS . ( 594 (subprogram_specification . 1))) (WITH . 
(subprogram_specification . 1)) (SEMICOLON . (subprogram_specification . 1)) 
(RENAMES . (subprogram_specification . 1)))
+      ((default . error) (IS . ( 593 (subprogram_specification . 0))) (WITH . 
(subprogram_specification . 0)) (SEMICOLON . (subprogram_specification . 0)) 
(RENAMES . (subprogram_specification . 0)))
+      ((default . error) (RENAMES .  127) (SEMICOLON . 
(aspect_specification_opt . 0)) (IS . ( 592 (aspect_specification_opt . 0))) 
(WITH .  108))
+      ((default . error) (EXCEPTION .  590) (CONSTANT . ( 589 (aliased_opt . 
0))) (ARRAY . (aliased_opt . 0)) (ACCESS . (aliased_opt . 0)) (NOT . 
(aliased_opt . 0)) (IDENTIFIER . (aliased_opt . 0)) (STRING_LITERAL . 
(aliased_opt . 0)) (CHARACTER_LITERAL . (aliased_opt . 0)) (ALIASED .  512))
       ((default . error) (IDENTIFIER .  48) (CHARACTER_LITERAL .  50) 
(STRING_LITERAL .  49))
       ((default . error) (END . (declarative_part_opt . 0)) (USE .  11) 
(SUBTYPE .  292) (PRAGMA .  7) (NOT .  4) (OVERRIDING .  5) (FUNCTION . 
(overriding_indicator_opt . 2)) (PROCEDURE . (overriding_indicator_opt . 2)) 
(ENTRY . (overriding_indicator_opt . 2)) (FOR .  289) (IDENTIFIER .  288) (TYPE 
.  294) (GENERIC .  2) (PROTECTED .  291) (TASK .  293) (PACKAGE .  290))
       ((default . error) (USE . (declarations . 1)) (TYPE . (declarations . 
1)) (TASK . (declarations . 1)) (SUBTYPE . (declarations . 1)) (PROTECTED . 
(declarations . 1)) (PROCEDURE . (declarations . 1)) (PRAGMA . (declarations . 
1)) (PACKAGE . (declarations . 1)) (OVERRIDING . (declarations . 1)) (NOT . 
(declarations . 1)) (GENERIC . (declarations . 1)) (FUNCTION . (declarations . 
1)) (FOR . (declarations . 1)) (ENTRY . (declarations . 1)) (IDENTIFIER . 
(declarations . 1)) (BEGIN . (de [...]
-      ((default . error) (SEMICOLON .  586) (IS . (discriminant_part_opt . 0)) 
(LEFT_PAREN .  198))
+      ((default . error) (SEMICOLON .  585) (IS . (discriminant_part_opt . 0)) 
(LEFT_PAREN .  198))
       ((default . error) (SEMICOLON . (aspect_specification_opt . 0)) (IS . 
(aspect_specification_opt . 0)) (WITH .  108))
-      ((default . error) (IDENTIFIER .  584))
       ((default . error) (IDENTIFIER .  583))
-      ((default . error) (IS .  582))
+      ((default . error) (IDENTIFIER .  582))
+      ((default . error) (IS .  581))
       ((default . error) (IS . (aspect_specification_opt . 0)) (WITH .  108))
-      ((default . error) (IDENTIFIER .  580))
       ((default . error) (IDENTIFIER .  579))
+      ((default . error) (IDENTIFIER .  578))
       ((default . error) (IDENTIFIER .  48) (CHARACTER_LITERAL .  50) 
(STRING_LITERAL .  49))
       ((default . error) (USE . ((direct_name . 0) (name . 0))) (LEFT_PAREN . 
(name . 0)) (DOT . (name . 0)) (TICK . (name . 0)))
       ((default . error) (USE . ((direct_name . 1) (name . 7))) (LEFT_PAREN . 
(name . 7)) (DOT . (name . 7)) (TICK . (name . 7)))
-      ((default . error) (USE . ( 577 (name . 4))) (LEFT_PAREN . (name . 4)) 
(DOT . (name . 4)) (TICK . (name . 4)))
-      ((default . error) (USE .  576))
-      ((default . error) (DOT .  87) (TICK .  88) (USE .  575) (LEFT_PAREN .  
106))
-      ((default . error) (EXCEPTION .  572) (IDENTIFIER . (null_exclusion_opt 
. 0)) (STRING_LITERAL . (null_exclusion_opt . 0)) (CHARACTER_LITERAL . 
(null_exclusion_opt . 0)) (ACCESS . (null_exclusion_opt . 0)) (NOT .  208))
+      ((default . error) (USE . ( 576 (name . 4))) (LEFT_PAREN . (name . 4)) 
(DOT . (name . 4)) (TICK . (name . 4)))
+      ((default . error) (USE .  575))
+      ((default . error) (DOT .  87) (TICK .  88) (USE .  574) (LEFT_PAREN .  
106))
+      ((default . error) (EXCEPTION .  571) (IDENTIFIER . (null_exclusion_opt 
. 0)) (STRING_LITERAL . (null_exclusion_opt . 0)) (CHARACTER_LITERAL . 
(null_exclusion_opt . 0)) (ACCESS . (null_exclusion_opt . 0)) (NOT .  208))
       ((default . error) (SEMICOLON . (association_opt . 2)) (IS . 
(association_opt . 2)) (COMMA . (association_opt . 2)) (RIGHT_PAREN . 
(association_opt . 2)))
       ((default . error) (SEMICOLON . (association_opt . 1)) (IS . 
(association_opt . 1)) (COMMA . (association_opt . 1)) (RIGHT_PAREN . 
(association_opt . 1)))
       ((default . error) (DOT .  87) (TICK .  88) (BAR . (discrete_choice . 
1)) (EQUAL_GREATER . (discrete_choice . 1)) (LEFT_PAREN .  106))
@@ -2149,175 +2197,174 @@
       ((default . error) (SEMICOLON . (association_opt . 3)) (IS . 
(association_opt . 3)) (COMMA . (association_opt . 3)) (RIGHT_PAREN . 
(association_opt . 3)))
       ((default . error) (EQUAL_GREATER . (discrete_choice_list . 2)) (BAR . 
(discrete_choice_list . 2)))
       ((default . error) (DOT_DOT .  264) (BAR . (choice_relation . 1)) 
(EQUAL_GREATER . (choice_relation . 1)) (AND . (choice_relation . 1)) (OR . 
(choice_relation . 1)) (XOR . (choice_relation . 1)) (EQUAL .  265) 
(SLASH_EQUAL .  270) (LESS .  268) (LESS_EQUAL .  269) (GREATER .  266) 
(GREATER_EQUAL .  267))
-      ((default . error) (LOOP . (range . 1)) (DO . (range . 1)) (COMMA . 
(range . 1)) (OF . (range . 1)) (COLON_EQUAL . (range . 1)) (ELSIF . (range . 
1)) (ELSE . (range . 1)) (DIGITS . (range . 1)) (RANGE . (range . 1)) (THEN . 
(range . 1)) (SEMICOLON . (range . 1)) (WITH . (range . 1)) (IS . (range . 1)) 
(AND . (range . 1)) (OR . (range . 1)) (XOR . (range . 1)) (RIGHT_PAREN . 
(range . 1)) (EQUAL_GREATER . (range . 1)) (BAR . (range . 1)) (LEFT_PAREN .  
566))
+      ((default . error) (LOOP . (range . 1)) (DO . (range . 1)) (COMMA . 
(range . 1)) (OF . (range . 1)) (COLON_EQUAL . (range . 1)) (ELSIF . (range . 
1)) (ELSE . (range . 1)) (DIGITS . (range . 1)) (RANGE . (range . 1)) (THEN . 
(range . 1)) (SEMICOLON . (range . 1)) (WITH . (range . 1)) (IS . (range . 1)) 
(AND . (range . 1)) (OR . (range . 1)) (XOR . (range . 1)) (RIGHT_PAREN . 
(range . 1)) (EQUAL_GREATER . (range . 1)) (BAR . (range . 1)) (LEFT_PAREN .  
565))
       ((default . error) (SEMICOLON . (relation . 1)) (IS . (relation . 1)) 
(WITH . (relation . 1)) (RIGHT_PAREN . (relation . 1)) (COMMA . (relation . 1)) 
(BAR . (choice_relation . 0)) (EQUAL_GREATER . (choice_relation . 0)) (AND . 
((relation . 1) (choice_relation . 0))) (OR . ((relation . 1) (choice_relation 
. 0))) (XOR . ((relation . 1) (choice_relation . 0))))
       ((default . error) (PLUS .  144) (MINUS .  143) (IDENTIFIER .  48) 
(CHARACTER_LITERAL .  50) (STRING_LITERAL .  49) (ABS .  146) (NOT .  149) 
(NULL .  150) (NEW .  148) (LEFT_PAREN .  147))
-      ((default . error) (BAR .  564) (DO . (relation . 3)) (LOOP . (relation 
. 3)) (COMMA . (relation . 3)) (ELSIF . (relation . 3)) (ELSE . (relation . 3)) 
(EQUAL_GREATER . (relation . 3)) (RIGHT_PAREN . (relation . 3)) (DIGITS . 
(relation . 3)) (RANGE . (relation . 3)) (THEN . (relation . 3)) (SEMICOLON . 
(relation . 3)) (WITH . (relation . 3)) (IS . (relation . 3)) (AND . (relation 
. 3)) (OR . (relation . 3)) (XOR . (relation . 3)))
+      ((default . error) (BAR .  563) (DO . (relation . 3)) (LOOP . (relation 
. 3)) (COMMA . (relation . 3)) (ELSIF . (relation . 3)) (ELSE . (relation . 3)) 
(EQUAL_GREATER . (relation . 3)) (RIGHT_PAREN . (relation . 3)) (DIGITS . 
(relation . 3)) (RANGE . (relation . 3)) (THEN . (relation . 3)) (SEMICOLON . 
(relation . 3)) (WITH . (relation . 3)) (IS . (relation . 3)) (AND . (relation 
. 3)) (OR . (relation . 3)) (XOR . (relation . 3)))
       ((default . error) (DO . (membership_choice_list . 0)) (LOOP . 
(membership_choice_list . 0)) (COMMA . (membership_choice_list . 0)) (ELSIF . 
(membership_choice_list . 0)) (ELSE . (membership_choice_list . 0)) 
(EQUAL_GREATER . (membership_choice_list . 0)) (RIGHT_PAREN . 
(membership_choice_list . 0)) (DIGITS . (membership_choice_list . 0)) (RANGE . 
(membership_choice_list . 0)) (THEN . (membership_choice_list . 0)) (SEMICOLON 
. (membership_choice_list . 0)) (WITH . (membership_choic [...]
       ((default . error) (DO . (membership_choice . 1)) (LOOP . 
(membership_choice . 1)) (COMMA . (membership_choice . 1)) (ELSIF . 
(membership_choice . 1)) (ELSE . (membership_choice . 1)) (EQUAL_GREATER . 
(membership_choice . 1)) (RIGHT_PAREN . (membership_choice . 1)) (DIGITS . 
(membership_choice . 1)) (RANGE . (membership_choice . 1)) (THEN . 
(membership_choice . 1)) (SEMICOLON . (membership_choice . 1)) (WITH . 
(membership_choice . 1)) (IS . (membership_choice . 1)) (AND . (membersh [...]
       ((default . error) (DOT_DOT .  264) (DO . (membership_choice . 0)) (LOOP 
. (membership_choice . 0)) (COMMA . (membership_choice . 0)) (ELSIF . 
(membership_choice . 0)) (ELSE . (membership_choice . 0)) (EQUAL_GREATER . 
(membership_choice . 0)) (RIGHT_PAREN . (membership_choice . 0)) (DIGITS . 
(membership_choice . 0)) (RANGE . (membership_choice . 0)) (THEN . 
(membership_choice . 0)) (SEMICOLON . (membership_choice . 0)) (WITH . 
(membership_choice . 0)) (IS . (membership_choice . 0)) [...]
       ((default . error) (DO . (range . 2)) (LOOP . (range . 2)) (OF . (range 
. 2)) (COLON_EQUAL . (range . 2)) (ELSIF . (range . 2)) (ELSE . (range . 2)) 
(DIGITS . (range . 2)) (RANGE . (range . 2)) (THEN . (range . 2)) (SEMICOLON . 
(range . 2)) (WITH . (range . 2)) (IS . (range . 2)) (AND . (range . 2)) (OR . 
(range . 2)) (XOR . (range . 2)) (COMMA . (range . 2)) (RIGHT_PAREN . (range . 
2)) (EQUAL_GREATER . (range . 2)) (BAR . (range . 2)))
       ((default . error) (BEGIN . (package_renaming_declaration . 0)) 
(IDENTIFIER . (package_renaming_declaration . 0)) (ENTRY . 
(package_renaming_declaration . 0)) (FOR . (package_renaming_declaration . 0)) 
(PROTECTED . (package_renaming_declaration . 0)) (SUBTYPE . 
(package_renaming_declaration . 0)) (TASK . (package_renaming_declaration . 0)) 
(TYPE . (package_renaming_declaration . 0)) (END . 
(package_renaming_declaration . 0)) (WITH . (package_renaming_declaration . 0)) 
(USE . (packa [...]
       ((default . error) (SEMICOLON . (association_list . 1)) (IS . 
(association_list . 1)) (COMMA . (association_list . 1)) (RIGHT_PAREN . 
(association_list . 1)))
-      ((default . error) (SEMICOLON .  563))
       ((default . error) (SEMICOLON .  562))
       ((default . error) (SEMICOLON .  561))
       ((default . error) (SEMICOLON .  560))
-      ((default . error) (ACCESS . (null_exclusion_opt . 0)) (NOT .  555) 
(IDENTIFIER .  554) (CHARACTER_LITERAL .  50) (STRING_LITERAL .  49))
+      ((default . error) (SEMICOLON .  559))
+      ((default . error) (ACCESS . (null_exclusion_opt . 0)) (NOT .  554) 
(IDENTIFIER .  553) (CHARACTER_LITERAL .  50) (STRING_LITERAL .  49))
       ((default . error) (RIGHT_PAREN . (discriminant_specification_opt . 0)) 
(SEMICOLON . (discriminant_specification_opt . 0)) (IDENTIFIER .  72))
       ((default . error) (IS . (discriminant_part_opt . 2)) (WITH . 
(discriminant_part_opt . 2)) (SEMICOLON . (discriminant_part_opt . 2)))
       ((default . error) (IS . (discriminant_part_opt . 1)) (WITH . 
(discriminant_part_opt . 1)) (SEMICOLON . (discriminant_part_opt . 1)))
       ((default . error) (PACKAGE . (formal_type_declaration . 2)) (PROCEDURE 
. (formal_type_declaration . 2)) (FUNCTION . (formal_type_declaration . 2)) 
(IDENTIFIER . (formal_type_declaration . 2)) (PRAGMA . (formal_type_declaration 
. 2)) (TYPE . (formal_type_declaration . 2)) (WITH . (formal_type_declaration . 
2)))
-      ((default . error) (TAGGED .  552) (NEW . 
(abstract_limited_synchronized_opt . 3)) (SYNCHRONIZED .  551) (LIMITED .  550))
-      ((default . error) (LEFT_PAREN .  549))
-      ((default . error) (BOX .  548))
+      ((default . error) (TAGGED .  551) (NEW . 
(abstract_limited_synchronized_opt . 3)) (SYNCHRONIZED .  550) (LIMITED .  549))
+      ((default . error) (LEFT_PAREN .  548))
       ((default . error) (BOX .  547))
-      ((default . error) (SEMICOLON . (interface_type_definition . 8)) (WITH . 
(interface_type_definition . 8)))
       ((default . error) (BOX .  546))
-      ((default . error) (INTERFACE .  545) (PRIVATE . 
(abstract_tagged_limited_opt . 5)) (NEW . (abstract_limited_synchronized_opt . 
4)))
-      ((default . error) (BOX .  544))
-      ((default . error) (INTERFACE .  543))
-      ((default . error) (BOX .  542))
-      ((default . error) (INTERFACE .  541) (NEW . 
(abstract_limited_synchronized_opt . 5)))
-      ((default . error) (PRIVATE . (abstract_tagged_limited_opt . 4)) 
(LIMITED .  539) (SEMICOLON . (aspect_specification_opt . 0)) (WITH .  108))
-      ((default . error) (INTERFACE .  538))
-      ((default . error) (NEW .  537))
-      ((default . error) (PRIVATE .  536))
+      ((default . error) (SEMICOLON . (interface_type_definition . 8)) (WITH . 
(interface_type_definition . 8)))
+      ((default . error) (BOX .  545))
+      ((default . error) (INTERFACE .  544) (PRIVATE . 
(abstract_tagged_limited_opt . 5)) (NEW . (abstract_limited_synchronized_opt . 
4)))
+      ((default . error) (BOX .  543))
+      ((default . error) (INTERFACE .  542))
+      ((default . error) (BOX .  541))
+      ((default . error) (INTERFACE .  540) (NEW . 
(abstract_limited_synchronized_opt . 5)))
+      ((default . error) (PRIVATE . (abstract_tagged_limited_opt . 4)) 
(LIMITED .  538) (SEMICOLON . (aspect_specification_opt . 0)) (WITH .  108))
+      ((default . error) (INTERFACE .  537))
+      ((default . error) (NEW .  536))
+      ((default . error) (PRIVATE .  535))
       ((default . error) (WITH . (formal_type_definition . 9)) (SEMICOLON . 
(formal_type_definition . 9)))
       ((default . error) (WITH . (formal_type_definition . 8)) (SEMICOLON . 
(formal_type_definition . 8)))
       ((default . error) (SEMICOLON . (aspect_specification_opt . 0)) (WITH .  
108))
       ((default . error) (WITH . (formal_type_definition . 1)) (SEMICOLON . 
(formal_type_definition . 1)))
       ((default . error) (WITH . (formal_type_definition . 10)) (SEMICOLON . 
(formal_type_definition . 10)))
-      ((default . error) (SEMICOLON .  534))
       ((default . error) (SEMICOLON .  533))
+      ((default . error) (SEMICOLON .  532))
       ((default . error) (SEMICOLON . (aspect_specification_opt . 0)) (WITH .  
108))
       ((default . error) (IDENTIFIER .  48) (CHARACTER_LITERAL .  50) 
(STRING_LITERAL .  49))
-      ((default . error) (DOT .  87) (TICK .  88) (COLON_EQUAL .  529) 
(LEFT_PAREN .  106) (SEMICOLON . (aspect_specification_opt . 0)) (WITH .  108))
+      ((default . error) (DOT .  87) (TICK .  88) (COLON_EQUAL .  528) 
(LEFT_PAREN .  106) (SEMICOLON . (aspect_specification_opt . 0)) (WITH .  108))
       ((default . error) (PLUS .  144) (MINUS .  143) (ABS .  146) (NOT .  
149) (NULL .  150) (NEW .  148) (IDENTIFIER .  48) (CHARACTER_LITERAL .  50) 
(STRING_LITERAL .  49) (LEFT_PAREN .  147))
-      ((default . error) (SEMICOLON .  527))
+      ((default . error) (SEMICOLON .  526))
       ((default . error) (RIGHT_PAREN . (parameter_and_result_profile . 0)) 
(DO . (parameter_and_result_profile . 0)) (RENAMES . 
(parameter_and_result_profile . 0)) (COLON_EQUAL . 
(parameter_and_result_profile . 0)) (WITH . (parameter_and_result_profile . 0)) 
(SEMICOLON . (parameter_and_result_profile . 0)) (IS . 
(parameter_and_result_profile . 0)))
       ((default . error) (IDENTIFIER . (general_access_modifier_opt . 1)) 
(STRING_LITERAL . (general_access_modifier_opt . 1)) (CHARACTER_LITERAL . 
(general_access_modifier_opt . 1)))
       ((default . error) (IDENTIFIER . (general_access_modifier_opt . 2)) 
(STRING_LITERAL . (general_access_modifier_opt . 2)) (CHARACTER_LITERAL . 
(general_access_modifier_opt . 2)))
       ((default . error) (FUNCTION . (protected_opt . 1)) (PROCEDURE . 
(protected_opt . 1)))
       ((default . error) (IDENTIFIER .  48) (CHARACTER_LITERAL .  50) 
(STRING_LITERAL .  49))
-      ((default . error) (FUNCTION .  524) (PROCEDURE .  525))
+      ((default . error) (FUNCTION .  523) (PROCEDURE .  524))
       ((default . error) (IN . (aliased_opt . 1)) (OUT . (aliased_opt . 1)) 
(ARRAY . (aliased_opt . 1)) (CONSTANT . (aliased_opt . 1)) (IDENTIFIER . 
(aliased_opt . 1)) (STRING_LITERAL . (aliased_opt . 1)) (CHARACTER_LITERAL . 
(aliased_opt . 1)) (ACCESS . (aliased_opt . 1)) (NOT . (aliased_opt . 1)))
-      ((default . error) (SEMICOLON . (parameter_specification . 3)) 
(RIGHT_PAREN . (parameter_specification . 3)) (COLON_EQUAL .  523))
-      ((default . error) (NOT . (mode_opt . 0)) (IDENTIFIER . (mode_opt . 0)) 
(STRING_LITERAL . (mode_opt . 0)) (CHARACTER_LITERAL . (mode_opt . 0)) (IN .  
204) (OUT .  205))
+      ((default . error) (IDENTIFIER . (mode_opt . 0)) (STRING_LITERAL . 
(mode_opt . 0)) (CHARACTER_LITERAL . (mode_opt . 0)) (IN .  204) (OUT .  205) 
(ACCESS . (null_exclusion_opt . 0)) (NOT . ((mode_opt . 0)  208)))
       ((default . error) (RIGHT_PAREN . (parameter_specification_list . 1)) 
(SEMICOLON . (parameter_specification_list . 1)))
-      ((default . error) (RIGHT_PAREN . ((association_opt . 0) (expression_opt 
. 0))) (COMMA . ((association_opt . 0) (expression_opt . 0))) (EQUAL_GREATER . 
(discrete_choice_list . 0)) (BAR . (discrete_choice_list . 0)) (OTHERS .  172) 
(IDENTIFIER .  48) (CHARACTER_LITERAL .  170) (STRING_LITERAL .  49) (PLUS .  
144) (MINUS .  143) (ABS .  146) (NOT .  171) (NULL .  520) (NEW .  148) 
(LEFT_PAREN .  147))
+      ((default . error) (RIGHT_PAREN . ((association_opt . 0) (expression_opt 
. 0))) (COMMA . ((association_opt . 0) (expression_opt . 0))) (EQUAL_GREATER . 
(discrete_choice_list . 0)) (BAR . (discrete_choice_list . 0)) (OTHERS .  172) 
(IDENTIFIER .  48) (CHARACTER_LITERAL .  170) (STRING_LITERAL .  49) (PLUS .  
144) (MINUS .  143) (ABS .  146) (NOT .  171) (NULL .  519) (NEW .  148) 
(LEFT_PAREN .  147))
       ((default . error) (DO . (aggregate . 0)) (LOOP . (aggregate . 0)) (USE 
. (aggregate . 0)) (COLON_EQUAL . (aggregate . 0)) (WHILE . (aggregate . 0)) 
(SELECT . (aggregate . 0)) (REQUEUE . (aggregate . 0)) (RAISE . (aggregate . 
0)) (PRAGMA . (aggregate . 0)) (NULL . (aggregate . 0)) (IF . (aggregate . 0)) 
(GOTO . (aggregate . 0)) (FOR . (aggregate . 0)) (EXIT . (aggregate . 0)) 
(DELAY . (aggregate . 0)) (DECLARE . (aggregate . 0)) (CASE . (aggregate . 0)) 
(BEGIN . (aggregate . 0)) (A [...]
-      ((default . error) (RIGHT_PAREN .  519))
+      ((default . error) (RIGHT_PAREN .  518))
       ((default . error) (OF . (aggregate . 3)) (LESS_LESS . (aggregate . 3)) 
(IDENTIFIER . (aggregate . 3)) (STRING_LITERAL . (aggregate . 3)) 
(CHARACTER_LITERAL . (aggregate . 3)) (ACCEPT . (aggregate . 3)) (ABORT . 
(aggregate . 3)) (BEGIN . (aggregate . 3)) (CASE . (aggregate . 3)) (DECLARE . 
(aggregate . 3)) (DELAY . (aggregate . 3)) (EXIT . (aggregate . 3)) (FOR . 
(aggregate . 3)) (GOTO . (aggregate . 3)) (IF . (aggregate . 3)) (NULL . 
(aggregate . 3)) (PRAGMA . (aggregate . 3)) (RA [...]
-      ((default . error) (PLUS . (primary . 0)) (MINUS . (primary . 0)) 
(AMPERSAND . (primary . 0)) (DOT_DOT . (primary . 0)) (IN . (primary . 0)) (NOT 
. (primary . 0)) (EQUAL . (primary . 0)) (GREATER . (primary . 0)) 
(GREATER_EQUAL . (primary . 0)) (LESS . (primary . 0)) (LESS_EQUAL . (primary . 
0)) (SLASH_EQUAL . (primary . 0)) (RIGHT_PAREN . (primary . 0)) (COMMA . 
(primary . 0)) (SLASH . (primary . 0)) (STAR . (primary . 0)) (MOD . (primary . 
0)) (REM . (primary . 0)) (STAR_STAR . ( [...]
-      ((default . error) (COMMA .  261) (RIGHT_PAREN .  787))
+      ((default . error) (PLUS . (primary . 0)) (MINUS . (primary . 0)) 
(AMPERSAND . (primary . 0)) (DOT_DOT . (primary . 0)) (IN . (primary . 0)) (NOT 
. (primary . 0)) (EQUAL . (primary . 0)) (GREATER . (primary . 0)) 
(GREATER_EQUAL . (primary . 0)) (LESS . (primary . 0)) (LESS_EQUAL . (primary . 
0)) (SLASH_EQUAL . (primary . 0)) (RIGHT_PAREN . (primary . 0)) (COMMA . 
(primary . 0)) (SLASH . (primary . 0)) (STAR . (primary . 0)) (MOD . (primary . 
0)) (REM . (primary . 0)) (STAR_STAR . ( [...]
+      ((default . error) (COMMA .  261) (RIGHT_PAREN .  786))
+      ((default . error) (COLON_EQUAL .  785) (RIGHT_PAREN . 
(parameter_specification . 3)) (SEMICOLON . (parameter_specification . 3)))
       ((default . error) (IDENTIFIER . (null_exclusion_opt . 0)) 
(STRING_LITERAL . (null_exclusion_opt . 0)) (CHARACTER_LITERAL . 
(null_exclusion_opt . 0)) (NOT .  208))
-      ((default . error) (PLUS .  144) (MINUS .  143) (ABS .  146) (NOT .  
149) (NULL .  150) (NEW .  148) (IDENTIFIER .  48) (CHARACTER_LITERAL .  50) 
(STRING_LITERAL .  49) (LEFT_PAREN .  147))
-      ((default . error) (RETURN .  90) (LEFT_PAREN .  782))
-      ((default . error) (IS . (parameter_profile_opt . 0)) (SEMICOLON . 
(parameter_profile_opt . 0)) (WITH . (parameter_profile_opt . 0)) (COLON_EQUAL 
. (parameter_profile_opt . 0)) (RENAMES . (parameter_profile_opt . 0)) (DO . 
(parameter_profile_opt . 0)) (RIGHT_PAREN . (parameter_profile_opt . 0)) 
(LEFT_PAREN .  782))
+      ((default . error) (RETURN .  90) (LEFT_PAREN .  781))
+      ((default . error) (IS . (parameter_profile_opt . 0)) (SEMICOLON . 
(parameter_profile_opt . 0)) (WITH . (parameter_profile_opt . 0)) (COLON_EQUAL 
. (parameter_profile_opt . 0)) (RENAMES . (parameter_profile_opt . 0)) (DO . 
(parameter_profile_opt . 0)) (RIGHT_PAREN . (parameter_profile_opt . 0)) 
(LEFT_PAREN .  781))
       ((default . error) (DOT .  87) (TICK .  88) (RIGHT_PAREN . 
(access_definition . 0)) (DO . (access_definition . 0)) (RENAMES . 
(access_definition . 0)) (COLON_EQUAL . (access_definition . 0)) (WITH . 
(access_definition . 0)) (SEMICOLON . (access_definition . 0)) (IS . 
(access_definition . 0)) (LEFT_PAREN .  106))
       ((default . error) (WITH . (formal_object_declaration . 3)) (TYPE . 
(formal_object_declaration . 3)) (PRAGMA . (formal_object_declaration . 3)) 
(IDENTIFIER . (formal_object_declaration . 3)) (FUNCTION . 
(formal_object_declaration . 3)) (PROCEDURE . (formal_object_declaration . 3)) 
(PACKAGE . (formal_object_declaration . 3)))
       ((default . error) (SEMICOLON . (aspect_specification_opt . 0)) (WITH .  
108))
       ((default . error) (PLUS .  144) (MINUS .  143) (ABS .  146) (NOT .  
149) (NULL .  150) (NEW .  148) (IDENTIFIER .  48) (CHARACTER_LITERAL .  50) 
(STRING_LITERAL .  49) (LEFT_PAREN .  147))
-      ((default . error) (SEMICOLON .  779))
-      ((default . error) (DOT .  87) (TICK .  88) (WITH . 
(formal_package_actual_part . 1)) (SEMICOLON . (formal_package_actual_part . 
1)) (LEFT_PAREN .  777))
-      ((default . error) (SEMICOLON .  776))
+      ((default . error) (SEMICOLON .  778))
+      ((default . error) (DOT .  87) (TICK .  88) (WITH . 
(formal_package_actual_part . 1)) (SEMICOLON . (formal_package_actual_part . 
1)) (LEFT_PAREN .  776))
+      ((default . error) (SEMICOLON .  775))
       ((default . error) (WITH . (formal_subprogram_declaration . 3)) (TYPE . 
(formal_subprogram_declaration . 3)) (PRAGMA . (formal_subprogram_declaration . 
3)) (IDENTIFIER . (formal_subprogram_declaration . 3)) (FUNCTION . 
(formal_subprogram_declaration . 3)) (PROCEDURE . 
(formal_subprogram_declaration . 3)) (PACKAGE . (formal_subprogram_declaration 
. 3)))
       ((default . error) (WITH . (formal_subprogram_declaration . 0)) (TYPE . 
(formal_subprogram_declaration . 0)) (PRAGMA . (formal_subprogram_declaration . 
0)) (IDENTIFIER . (formal_subprogram_declaration . 0)) (FUNCTION . 
(formal_subprogram_declaration . 0)) (PROCEDURE . 
(formal_subprogram_declaration . 0)) (PACKAGE . (formal_subprogram_declaration 
. 0)))
-      ((default . error) (SEMICOLON .  775))
+      ((default . error) (SEMICOLON .  774))
       ((default . error) (SEMICOLON . (formal_type_definition . 0)) (WITH . 
(formal_type_definition . 0)))
       ((default . error) (IDENTIFIER .  48) (CHARACTER_LITERAL .  50) 
(STRING_LITERAL .  49))
-      ((default . error) (AND .  773) (WITH . (interface_type_definition . 5)) 
(SEMICOLON . (interface_type_definition . 5)))
+      ((default . error) (AND .  772) (WITH . (interface_type_definition . 5)) 
(SEMICOLON . (interface_type_definition . 5)))
       ((default . error) (RECORD . (abstract_tagged_limited_opt . 3)) (NULL . 
(abstract_tagged_limited_opt . 3)) (PRIVATE . (abstract_tagged_limited_opt . 
3)))
-      ((default . error) (SEMICOLON .  772))
-      ((default . error) (AND .  771) (WITH . (interface_type_definition . 7)) 
(SEMICOLON . (interface_type_definition . 7)))
+      ((default . error) (SEMICOLON .  771))
+      ((default . error) (AND .  770) (WITH . (interface_type_definition . 7)) 
(SEMICOLON . (interface_type_definition . 7)))
       ((default . error) (SEMICOLON . (formal_type_definition . 3)) (WITH . 
(formal_type_definition . 3)))
-      ((default . error) (AND .  770) (WITH . (interface_type_definition . 6)) 
(SEMICOLON . (interface_type_definition . 6)))
+      ((default . error) (AND .  769) (WITH . (interface_type_definition . 6)) 
(SEMICOLON . (interface_type_definition . 6)))
       ((default . error) (SEMICOLON . (formal_type_definition . 4)) (WITH . 
(formal_type_definition . 4)))
-      ((default . error) (AND .  769) (WITH . (interface_type_definition . 4)) 
(SEMICOLON . (interface_type_definition . 4)))
-      ((default . error) (RIGHT_PAREN .  768))
+      ((default . error) (AND .  768) (WITH . (interface_type_definition . 4)) 
(SEMICOLON . (interface_type_definition . 4)))
+      ((default . error) (RIGHT_PAREN .  767))
       ((default . error) (SEMICOLON . (formal_type_definition . 5)) (WITH . 
(formal_type_definition . 5)))
-      ((default . error) (SEMICOLON . (formal_type_definition . 6)) (WITH . 
(formal_type_definition . 6)) (DIGITS .  767))
-      ((default . error) (IDENTIFIER .  48) (CHARACTER_LITERAL .  50) 
(STRING_LITERAL .  49) (PLUS .  144) (MINUS .  143) (ABS .  146) (NOT .  758) 
(NULL .  150) (NEW .  148) (LEFT_PAREN .  147))
+      ((default . error) (SEMICOLON . (formal_type_definition . 6)) (WITH . 
(formal_type_definition . 6)) (DIGITS .  766))
+      ((default . error) (IDENTIFIER .  48) (CHARACTER_LITERAL .  50) 
(STRING_LITERAL .  49) (PLUS .  144) (MINUS .  143) (ABS .  146) (NOT .  757) 
(NULL .  150) (NEW .  148) (LEFT_PAREN .  147))
       ((default . error) (NEW . (abstract_limited_synchronized_opt . 1)))
       ((default . error) (NEW . (abstract_limited_synchronized_opt . 2)))
-      ((default . error) (LIMITED .  757) (RECORD . 
(abstract_tagged_limited_opt . 2)) (NULL . (abstract_tagged_limited_opt . 2)) 
(PRIVATE . (abstract_tagged_limited_opt . 2)))
+      ((default . error) (LIMITED .  756) (RECORD . 
(abstract_tagged_limited_opt . 2)) (NULL . (abstract_tagged_limited_opt . 2)) 
(PRIVATE . (abstract_tagged_limited_opt . 2)))
       ((default . error) (RIGHT_PAREN . (discriminant_specification_list . 1)) 
(SEMICOLON . (discriminant_specification_list . 1)))
       ((default . error) (SEMICOLON . (null_exclusion_opt_name . 0)) 
(RIGHT_PAREN . (null_exclusion_opt_name . 0)) (COLON_EQUAL . 
(null_exclusion_opt_name . 0)) (DOT . (name . 0)) (LEFT_PAREN . (name . 0)) 
(TICK . (name . 0)))
-      ((default . error) (NULL .  756))
-      ((default . error) (SEMICOLON . (discriminant_specification_opt . 4)) 
(RIGHT_PAREN . (discriminant_specification_opt . 4)) (COLON_EQUAL .  755))
+      ((default . error) (NULL .  755))
+      ((default . error) (SEMICOLON . (discriminant_specification_opt . 4)) 
(RIGHT_PAREN . (discriminant_specification_opt . 4)) (COLON_EQUAL .  754))
       ((default . error) (DOT .  87) (TICK .  88) (LEFT_PAREN .  106))
-      ((default . error) (SEMICOLON . (discriminant_specification_opt . 2)) 
(RIGHT_PAREN . (discriminant_specification_opt . 2)) (COLON_EQUAL .  754))
+      ((default . error) (SEMICOLON . (discriminant_specification_opt . 2)) 
(RIGHT_PAREN . (discriminant_specification_opt . 2)) (COLON_EQUAL .  753))
       ((default . error) (SEMICOLON . (null_exclusion_opt_name . 1)) 
(RIGHT_PAREN . (null_exclusion_opt_name . 1)) (COLON_EQUAL . 
(null_exclusion_opt_name . 1)) (DOT . (name . 3)) (LEFT_PAREN . (name . 3)) 
(TICK . (name . 3)))
       ((default . error) ($EOI . (generic_renaming_declaration . 1)) (LIMITED 
. (generic_renaming_declaration . 1)) (SEPARATE . (generic_renaming_declaration 
. 1)) (WITH . (generic_renaming_declaration . 1)) (END . 
(generic_renaming_declaration . 1)) (PRIVATE . (generic_renaming_declaration . 
1)) (USE . (generic_renaming_declaration . 1)) (TYPE . 
(generic_renaming_declaration . 1)) (TASK . (generic_renaming_declaration . 1)) 
(SUBTYPE . (generic_renaming_declaration . 1)) (PROTECTED . (ge [...]
       ((default . error) ($EOI . (generic_renaming_declaration . 0)) (LIMITED 
. (generic_renaming_declaration . 0)) (SEPARATE . (generic_renaming_declaration 
. 0)) (WITH . (generic_renaming_declaration . 0)) (END . 
(generic_renaming_declaration . 0)) (PRIVATE . (generic_renaming_declaration . 
0)) (USE . (generic_renaming_declaration . 0)) (TYPE . 
(generic_renaming_declaration . 0)) (TASK . (generic_renaming_declaration . 0)) 
(SUBTYPE . (generic_renaming_declaration . 0)) (PROTECTED . (ge [...]
       ((default . error) ($EOI . (generic_renaming_declaration . 2)) (LIMITED 
. (generic_renaming_declaration . 2)) (SEPARATE . (generic_renaming_declaration 
. 2)) (WITH . (generic_renaming_declaration . 2)) (END . 
(generic_renaming_declaration . 2)) (PRIVATE . (generic_renaming_declaration . 
2)) (USE . (generic_renaming_declaration . 2)) (TYPE . 
(generic_renaming_declaration . 2)) (TASK . (generic_renaming_declaration . 2)) 
(SUBTYPE . (generic_renaming_declaration . 2)) (PROTECTED . (ge [...]
       ((default . error) (END . (generic_instantiation . 0)) (BEGIN . 
(generic_instantiation . 0)) (IDENTIFIER . (generic_instantiation . 0)) (ENTRY 
. (generic_instantiation . 0)) (FOR . (generic_instantiation . 0)) (PROTECTED . 
(generic_instantiation . 0)) (SUBTYPE . (generic_instantiation . 0)) (TASK . 
(generic_instantiation . 0)) (TYPE . (generic_instantiation . 0)) ($EOI . 
(generic_instantiation . 0)) (FUNCTION . (generic_instantiation . 0)) (GENERIC 
. (generic_instantiation . 0)) (L [...]
       ((default . error) (PLUS .  144) (MINUS .  143) (IDENTIFIER .  48) 
(CHARACTER_LITERAL .  50) (STRING_LITERAL .  49) (ABS .  146) (NOT .  149) 
(NULL .  150) (NEW .  148) (LEFT_PAREN .  147))
-      ((default . error) (BAR .  564) (LOOP . (relation . 2)) (DO . (relation 
. 2)) (XOR . (relation . 2)) (OR . (relation . 2)) (AND . (relation . 2)) (IS . 
(relation . 2)) (WITH . (relation . 2)) (SEMICOLON . (relation . 2)) (THEN . 
(relation . 2)) (RANGE . (relation . 2)) (DIGITS . (relation . 2)) (RIGHT_PAREN 
. (relation . 2)) (EQUAL_GREATER . (relation . 2)) (ELSE . (relation . 2)) 
(ELSIF . (relation . 2)) (COMMA . (relation . 2)))
+      ((default . error) (BAR .  563) (LOOP . (relation . 2)) (DO . (relation 
. 2)) (XOR . (relation . 2)) (OR . (relation . 2)) (AND . (relation . 2)) (IS . 
(relation . 2)) (WITH . (relation . 2)) (SEMICOLON . (relation . 2)) (THEN . 
(relation . 2)) (RANGE . (relation . 2)) (DIGITS . (relation . 2)) (RIGHT_PAREN 
. (relation . 2)) (EQUAL_GREATER . (relation . 2)) (ELSE . (relation . 2)) 
(ELSIF . (relation . 2)) (COMMA . (relation . 2)))
       ((default . error) (PLUS .  144) (MINUS .  143) (ABS .  146) (NOT .  
149) (NULL .  150) (NEW .  148) (IDENTIFIER .  48) (CHARACTER_LITERAL .  50) 
(STRING_LITERAL .  49) (LEFT_PAREN .  147))
       ((default . error) (PLUS .  144) (MINUS .  143) (ABS .  146) (NOT .  
149) (NULL .  150) (NEW .  148) (IDENTIFIER .  48) (CHARACTER_LITERAL .  50) 
(STRING_LITERAL .  49) (LEFT_PAREN .  147))
       ((default . error) (AND . (choice_relation_and_then_list . 0)) 
(EQUAL_GREATER . (choice_relation_and_then_list . 0)) (BAR . 
(choice_relation_and_then_list . 0)))
       ((default . error) (OR . (choice_relation_or_else_list . 0)) 
(EQUAL_GREATER . (choice_relation_or_else_list . 0)) (BAR . 
(choice_relation_or_else_list . 0)))
       ((default . error) (OR . (choice_relation_or_else_list . 1)) 
(EQUAL_GREATER . (choice_relation_or_else_list . 1)) (BAR . 
(choice_relation_or_else_list . 1)))
       ((default . error) (AND . (choice_relation_and_then_list . 1)) 
(EQUAL_GREATER . (choice_relation_and_then_list . 1)) (BAR . 
(choice_relation_and_then_list . 1)))
-      ((default . error) (RENAMES .  750))
       ((default . error) (RENAMES .  749))
+      ((default . error) (RENAMES .  748))
       ((default . error) (ACCESS .  235) (IDENTIFIER .  48) (CHARACTER_LITERAL 
.  50) (STRING_LITERAL .  49))
-      ((default . error) (LEFT_PAREN .  220) (RECORD .  745))
-      ((default . error) (AT .  744))
+      ((default . error) (LEFT_PAREN .  220) (RECORD .  744))
+      ((default . error) (AT .  743))
       ((default . error) (PLUS .  144) (MINUS .  143) (ABS .  146) (NOT .  
149) (NULL .  150) (NEW .  148) (IDENTIFIER .  48) (CHARACTER_LITERAL .  50) 
(STRING_LITERAL .  49) (LEFT_PAREN .  147))
-      ((default . error) (DOT .  87) (TICK .  88) (IS . ( 742 
(aspect_specification_opt . 0))) (WITH .  108) (LEFT_PAREN .  106))
+      ((default . error) (DOT .  87) (TICK .  88) (IS . ( 741 
(aspect_specification_opt . 0))) (WITH .  108) (LEFT_PAREN .  106))
       ((default . error) (WITH . (discriminant_part_opt . 0)) (IS . 
(discriminant_part_opt . 0)) (LEFT_PAREN .  198))
-      ((default . error) (IS . ( 740 (aspect_specification_opt . 0))) (WITH .  
108))
-      ((default . error) (IS .  739))
-      ((default . error) (NOT .  736) (IDENTIFIER .  48) (CHARACTER_LITERAL .  
50) (STRING_LITERAL .  49))
+      ((default . error) (IS . ( 739 (aspect_specification_opt . 0))) (WITH .  
108))
+      ((default . error) (IS .  738))
+      ((default . error) (NOT .  735) (IDENTIFIER .  48) (CHARACTER_LITERAL .  
50) (STRING_LITERAL .  49))
       ((default . error) (WITH . (discriminant_part_opt . 0)) (IS . 
(discriminant_part_opt . 0)) (SEMICOLON . (discriminant_part_opt . 0)) 
(LEFT_PAREN .  198))
-      ((default . error) (IS . ( 734 (aspect_specification_opt . 0))) (WITH .  
108))
-      ((default . error) (SEMICOLON .  732) (IS .  733))
+      ((default . error) (IS . ( 733 (aspect_specification_opt . 0))) (WITH .  
108))
+      ((default . error) (SEMICOLON .  731) (IS .  732))
       ((default . error) (END . (incomplete_type_declaration . 1)) (PRIVATE . 
(incomplete_type_declaration . 1)) (USE . (incomplete_type_declaration . 1)) 
(TYPE . (incomplete_type_declaration . 1)) (TASK . (incomplete_type_declaration 
. 1)) (SUBTYPE . (incomplete_type_declaration . 1)) (PROTECTED . 
(incomplete_type_declaration . 1)) (PROCEDURE . (incomplete_type_declaration . 
1)) (PRAGMA . (incomplete_type_declaration . 1)) (PACKAGE . 
(incomplete_type_declaration . 1)) (OVERRIDING . (inc [...]
-      ((default . error) (IS .  731))
-      ((default . error) (END .  730))
+      ((default . error) (IS .  730))
+      ((default . error) (END .  729))
       ((default . error) (DOT .  87) (TICK .  88) (SEMICOLON . 
(package_specification . 1)) (LEFT_PAREN .  106))
-      ((default . error) (COLON_EQUAL .  729))
-      ((default . error) (SEMICOLON .  728))
-      ((default . error) (IDENTIFIER . (constant_opt . 0)) (STRING_LITERAL . 
(constant_opt . 0)) (CHARACTER_LITERAL . (constant_opt . 0)) (NOT . 
(constant_opt . 0)) (ACCESS . (constant_opt . 0)) (ARRAY . (constant_opt . 0)) 
(CONSTANT .  726))
-      ((default . error) (SEPARATE .  725) (ABSTRACT .  724))
-      ((default . error) (NULL .  723))
-      ((default . error) (LEFT_PAREN .  721))
-      ((default . error) (WITH . (parameter_profile_opt . 0)) (SEMICOLON . 
(parameter_profile_opt . 0)) (LEFT_PAREN .  719))
-      ((default . error) (END . (sequence_of_statements_opt . 0)) (EXCEPTION . 
(sequence_of_statements_opt . 0)) (ACCEPT . (label_opt . 0)) (BEGIN . 
(label_opt . 0)) (CASE . (label_opt . 0)) (DECLARE . (label_opt . 0)) (FOR . 
(label_opt . 0)) (IF . (label_opt . 0)) (LOOP . (label_opt . 0)) (RETURN . 
(label_opt . 0)) (SELECT . (label_opt . 0)) (WHILE . (label_opt . 0)) 
(STRING_LITERAL . (label_opt . 0)) (CHARACTER_LITERAL . (label_opt . 0)) (ABORT 
. (label_opt . 0)) (DELAY . (label_opt .  [...]
+      ((default . error) (COLON_EQUAL .  728))
+      ((default . error) (SEMICOLON .  727))
+      ((default . error) (IDENTIFIER . (constant_opt . 0)) (STRING_LITERAL . 
(constant_opt . 0)) (CHARACTER_LITERAL . (constant_opt . 0)) (NOT . 
(constant_opt . 0)) (ACCESS . (constant_opt . 0)) (ARRAY . (constant_opt . 0)) 
(CONSTANT .  725))
+      ((default . error) (SEPARATE .  724) (ABSTRACT .  723))
+      ((default . error) (NULL .  722))
+      ((default . error) (LEFT_PAREN .  720))
+      ((default . error) (WITH . (parameter_profile_opt . 0)) (SEMICOLON . 
(parameter_profile_opt . 0)) (LEFT_PAREN .  718))
+      ((default . error) (END . (sequence_of_statements_opt . 0)) (EXCEPTION . 
(sequence_of_statements_opt . 0)) (ACCEPT . (label_opt . 0)) (BEGIN . 
(label_opt . 0)) (CASE . (label_opt . 0)) (DECLARE . (label_opt . 0)) (FOR . 
(label_opt . 0)) (IF . (label_opt . 0)) (LOOP . (label_opt . 0)) (RETURN . 
(label_opt . 0)) (SELECT . (label_opt . 0)) (WHILE . (label_opt . 0)) 
(STRING_LITERAL . (label_opt . 0)) (CHARACTER_LITERAL . (label_opt . 0)) (ABORT 
. (label_opt . 0)) (DELAY . (label_opt .  [...]
       ((default . error) (SEMICOLON . (name_opt . 0)) (IDENTIFIER .  48) 
(CHARACTER_LITERAL .  50) (STRING_LITERAL .  49))
       ((default . error) (LOOP . (relation_and_then_list . 0)) (DO . 
(relation_and_then_list . 0)) (AND . (relation_and_then_list . 0)) (IS . 
(relation_and_then_list . 0)) (WITH . (relation_and_then_list . 0)) (SEMICOLON 
. (relation_and_then_list . 0)) (THEN . (relation_and_then_list . 0)) (RANGE . 
(relation_and_then_list . 0)) (COMMA . (relation_and_then_list . 0)) 
(RIGHT_PAREN . (relation_and_then_list . 0)) (DIGITS . (relation_and_then_list 
. 0)) (EQUAL_GREATER . (relation_and_then_li [...]
       ((default . error) (LOOP . (relation_or_else_list . 0)) (DO . 
(relation_or_else_list . 0)) (OR . (relation_or_else_list . 0)) (IS . 
(relation_or_else_list . 0)) (WITH . (relation_or_else_list . 0)) (SEMICOLON . 
(relation_or_else_list . 0)) (THEN . (relation_or_else_list . 0)) (RANGE . 
(relation_or_else_list . 0)) (COMMA . (relation_or_else_list . 0)) (RIGHT_PAREN 
. (relation_or_else_list . 0)) (DIGITS . (relation_or_else_list . 0)) 
(EQUAL_GREATER . (relation_or_else_list . 0)) (ELS [...]
       ((default . error) (LOOP . (relation_or_else_list . 1)) (DO . 
(relation_or_else_list . 1)) (OR . (relation_or_else_list . 1)) (IS . 
(relation_or_else_list . 1)) (WITH . (relation_or_else_list . 1)) (SEMICOLON . 
(relation_or_else_list . 1)) (THEN . (relation_or_else_list . 1)) (RANGE . 
(relation_or_else_list . 1)) (COMMA . (relation_or_else_list . 1)) (RIGHT_PAREN 
. (relation_or_else_list . 1)) (DIGITS . (relation_or_else_list . 1)) 
(EQUAL_GREATER . (relation_or_else_list . 1)) (ELS [...]
       ((default . error) (LOOP . (relation_and_then_list . 1)) (DO . 
(relation_and_then_list . 1)) (AND . (relation_and_then_list . 1)) (IS . 
(relation_and_then_list . 1)) (WITH . (relation_and_then_list . 1)) (SEMICOLON 
. (relation_and_then_list . 1)) (THEN . (relation_and_then_list . 1)) (RANGE . 
(relation_and_then_list . 1)) (COMMA . (relation_and_then_list . 1)) 
(RIGHT_PAREN . (relation_and_then_list . 1)) (DIGITS . (relation_and_then_list 
. 1)) (EQUAL_GREATER . (relation_and_then_li [...]
-      ((default . error) (WHEN .  714))
-      ((default . error) (OF .  713) (COLON .  711) (IN .  712))
-      ((default . error) (EQUAL_GREATER .  710))
+      ((default . error) (WHEN .  713))
+      ((default . error) (OF .  712) (COLON .  710) (IN .  711))
+      ((default . error) (EQUAL_GREATER .  709))
       ((default . error) (PLUS .  144) (MINUS .  143) (ABS .  146) (NOT .  
149) (NULL .  150) (NEW .  148) (IDENTIFIER .  48) (CHARACTER_LITERAL .  50) 
(STRING_LITERAL .  49) (LEFT_PAREN .  147))
       ((default . error) (PLUS .  144) (MINUS .  143) (ABS .  146) (NOT .  
149) (NULL .  150) (NEW .  148) (IDENTIFIER .  48) (CHARACTER_LITERAL .  50) 
(STRING_LITERAL .  49) (LEFT_PAREN .  147))
       ((default . error) (IS . (aspect_specification_opt . 0)) (WITH .  108))
       ((default . error) (IS . (aspect_specification_opt . 0)) (WITH .  108))
       ((default . error) (IS .  134))
-      ((default . error) (IDENTIFIER .  705))
-      ((default . error) (COLON .  704))
-      ((default . error) (IDENTIFIER .  703))
+      ((default . error) (IDENTIFIER .  704))
+      ((default . error) (COLON .  703))
+      ((default . error) (IDENTIFIER .  702))
       ((default . error) (IDENTIFIER .  48) (CHARACTER_LITERAL .  50) 
(STRING_LITERAL .  49))
-      ((default . error) (END . (sequence_of_statements_opt . 0)) (EXCEPTION . 
(sequence_of_statements_opt . 0)) (ACCEPT . (label_opt . 0)) (BEGIN . 
(label_opt . 0)) (CASE . (label_opt . 0)) (DECLARE . (label_opt . 0)) (FOR . 
(label_opt . 0)) (IF . (label_opt . 0)) (LOOP . (label_opt . 0)) (RETURN . 
(label_opt . 0)) (SELECT . (label_opt . 0)) (WHILE . (label_opt . 0)) 
(STRING_LITERAL . (label_opt . 0)) (CHARACTER_LITERAL . (label_opt . 0)) (ABORT 
. (label_opt . 0)) (DELAY . (label_opt .  [...]
+      ((default . error) (END . (sequence_of_statements_opt . 0)) (EXCEPTION . 
(sequence_of_statements_opt . 0)) (ACCEPT . (label_opt . 0)) (BEGIN . 
(label_opt . 0)) (CASE . (label_opt . 0)) (DECLARE . (label_opt . 0)) (FOR . 
(label_opt . 0)) (IF . (label_opt . 0)) (LOOP . (label_opt . 0)) (RETURN . 
(label_opt . 0)) (SELECT . (label_opt . 0)) (WHILE . (label_opt . 0)) 
(STRING_LITERAL . (label_opt . 0)) (CHARACTER_LITERAL . (label_opt . 0)) (ABORT 
. (label_opt . 0)) (DELAY . (label_opt .  [...]
       ((default . error) (IS . (expression_opt . 0)) (PLUS .  144) (MINUS .  
143) (ABS .  146) (NOT .  149) (NULL .  150) (NEW .  148) (IDENTIFIER .  48) 
(CHARACTER_LITERAL .  50) (STRING_LITERAL .  49) (LEFT_PAREN .  147))
       ((default . error) (BEGIN . (declarative_part_opt . 0)) (USE .  11) 
(SUBTYPE .  292) (PRAGMA .  7) (NOT .  4) (OVERRIDING .  5) (FUNCTION . 
(overriding_indicator_opt . 2)) (PROCEDURE . (overriding_indicator_opt . 2)) 
(ENTRY . (overriding_indicator_opt . 2)) (FOR .  289) (IDENTIFIER .  288) (TYPE 
.  294) (GENERIC .  2) (PROTECTED .  291) (TASK .  293) (PACKAGE .  290))
-      ((default . error) (UNTIL .  697) (PLUS .  144) (MINUS .  143) (ABS .  
146) (NOT .  149) (NULL .  150) (NEW .  148) (IDENTIFIER .  48) 
(CHARACTER_LITERAL .  50) (STRING_LITERAL .  49) (LEFT_PAREN .  147))
-      ((default . error) (WHEN . (identifier_opt . 0)) (SEMICOLON . 
(identifier_opt . 0)) (IDENTIFIER .  695))
-      ((default . error) (LOOP . (iterator_specification_opt . 0)) (IDENTIFIER 
.  604))
-      ((default . error) (IDENTIFIER .  692))
+      ((default . error) (UNTIL .  696) (PLUS .  144) (MINUS .  143) (ABS .  
146) (NOT .  149) (NULL .  150) (NEW .  148) (IDENTIFIER .  48) 
(CHARACTER_LITERAL .  50) (STRING_LITERAL .  49) (LEFT_PAREN .  147))
+      ((default . error) (WHEN . (identifier_opt . 0)) (SEMICOLON . 
(identifier_opt . 0)) (IDENTIFIER .  694))
+      ((default . error) (LOOP . (iterator_specification_opt . 0)) (IDENTIFIER 
.  603))
+      ((default . error) (IDENTIFIER .  691))
       ((default . error) (THEN . (expression_opt . 0)) (PLUS .  144) (MINUS .  
143) (ABS .  146) (NOT .  149) (NULL .  150) (NEW .  148) (IDENTIFIER .  48) 
(CHARACTER_LITERAL .  50) (STRING_LITERAL .  49) (LEFT_PAREN .  147))
-      ((default . error) (END . (sequence_of_statements_opt . 0)) (ACCEPT . 
(label_opt . 0)) (BEGIN . (label_opt . 0)) (CASE . (label_opt . 0)) (DECLARE . 
(label_opt . 0)) (FOR . (label_opt . 0)) (IF . (label_opt . 0)) (LOOP . 
(label_opt . 0)) (RETURN . (label_opt . 0)) (SELECT . (label_opt . 0)) (WHILE . 
(label_opt . 0)) (STRING_LITERAL . (label_opt . 0)) (CHARACTER_LITERAL . 
(label_opt . 0)) (ABORT . (label_opt . 0)) (DELAY . (label_opt . 0)) (EXIT . 
(label_opt . 0)) (GOTO . (label_opt [...]
-      ((default . error) (SEMICOLON .  689))
-      ((default . error) (SEMICOLON .  687) (IDENTIFIER .  48) 
(CHARACTER_LITERAL .  50) (STRING_LITERAL .  49))
+      ((default . error) (END . (sequence_of_statements_opt . 0)) (ACCEPT . 
(label_opt . 0)) (BEGIN . (label_opt . 0)) (CASE . (label_opt . 0)) (DECLARE . 
(label_opt . 0)) (FOR . (label_opt . 0)) (IF . (label_opt . 0)) (LOOP . 
(label_opt . 0)) (RETURN . (label_opt . 0)) (SELECT . (label_opt . 0)) (WHILE . 
(label_opt . 0)) (STRING_LITERAL . (label_opt . 0)) (CHARACTER_LITERAL . 
(label_opt . 0)) (ABORT . (label_opt . 0)) (DELAY . (label_opt . 0)) (EXIT . 
(label_opt . 0)) (GOTO . (label_opt [...]
+      ((default . error) (SEMICOLON .  688))
+      ((default . error) (SEMICOLON .  686) (IDENTIFIER .  48) 
(CHARACTER_LITERAL .  50) (STRING_LITERAL .  49))
       ((default . error) (IDENTIFIER .  48) (CHARACTER_LITERAL .  50) 
(STRING_LITERAL .  49))
-      ((default . error) (SEMICOLON .  681) (DO . 
(extended_return_object_declaration_opt . 0)) (PLUS .  144) (MINUS .  143) (ABS 
.  146) (NOT .  149) (NULL .  150) (NEW .  148) (IDENTIFIER .  682) 
(CHARACTER_LITERAL .  50) (STRING_LITERAL .  49) (LEFT_PAREN .  147))
-      ((default . error) (ELSE . (select_alternative_list_opt . 0)) (END . 
(select_alternative_list_opt . 0)) (IDENTIFIER .  48) (CHARACTER_LITERAL .  50) 
(STRING_LITERAL .  49) (DELAY .  618) (WHEN .  670) (TERMINATE .  669) (ACCEPT 
.  613))
+      ((default . error) (SEMICOLON .  680) (DO . 
(extended_return_object_declaration_opt . 0)) (PLUS .  144) (MINUS .  143) (ABS 
.  146) (NOT .  149) (NULL .  150) (NEW .  148) (IDENTIFIER .  681) 
(CHARACTER_LITERAL .  50) (STRING_LITERAL .  49) (LEFT_PAREN .  147))
+      ((default . error) (ELSE . (select_alternative_list_opt . 0)) (END . 
(select_alternative_list_opt . 0)) (IDENTIFIER .  48) (CHARACTER_LITERAL .  50) 
(STRING_LITERAL .  49) (DELAY .  617) (WHEN .  669) (TERMINATE .  668) (ACCEPT 
.  612))
       ((default . error) (LOOP . (expression_opt . 0)) (PLUS .  144) (MINUS .  
143) (ABS .  146) (NOT .  149) (NULL .  150) (NEW .  148) (IDENTIFIER .  48) 
(CHARACTER_LITERAL .  50) (STRING_LITERAL .  49) (LEFT_PAREN .  147))
       ((default . error) (OR . (compound_statement . 5)) (THEN . 
(compound_statement . 5)) (WHEN . (compound_statement . 5)) (EXCEPTION . 
(compound_statement . 5)) (END . (compound_statement . 5)) (LESS_LESS . 
(compound_statement . 5)) (IDENTIFIER . (compound_statement . 5)) 
(STRING_LITERAL . (compound_statement . 5)) (CHARACTER_LITERAL . 
(compound_statement . 5)) (ACCEPT . (compound_statement . 5)) (ABORT . 
(compound_statement . 5)) (BEGIN . (compound_statement . 5)) (CASE . 
(compound_s [...]
       ((default . error) (OR . (simple_statement . 1)) (THEN . 
(simple_statement . 1)) (WHEN . (simple_statement . 1)) (EXCEPTION . 
(simple_statement . 1)) (END . (simple_statement . 1)) (LESS_LESS . 
(simple_statement . 1)) (IDENTIFIER . (simple_statement . 1)) (STRING_LITERAL . 
(simple_statement . 1)) (CHARACTER_LITERAL . (simple_statement . 1)) (ACCEPT . 
(simple_statement . 1)) (ABORT . (simple_statement . 1)) (BEGIN . 
(simple_statement . 1)) (CASE . (simple_statement . 1)) (DECLARE .  [...]
@@ -2328,25 +2375,25 @@
       ((default . error) (OR . (simple_statement . 7)) (THEN . 
(simple_statement . 7)) (WHEN . (simple_statement . 7)) (EXCEPTION . 
(simple_statement . 7)) (END . (simple_statement . 7)) (LESS_LESS . 
(simple_statement . 7)) (IDENTIFIER . (simple_statement . 7)) (STRING_LITERAL . 
(simple_statement . 7)) (CHARACTER_LITERAL . (simple_statement . 7)) (ACCEPT . 
(simple_statement . 7)) (ABORT . (simple_statement . 7)) (BEGIN . 
(simple_statement . 7)) (CASE . (simple_statement . 7)) (DECLARE .  [...]
       ((default . error) (OR . (simple_statement . 2)) (THEN . 
(simple_statement . 2)) (WHEN . (simple_statement . 2)) (EXCEPTION . 
(simple_statement . 2)) (END . (simple_statement . 2)) (LESS_LESS . 
(simple_statement . 2)) (IDENTIFIER . (simple_statement . 2)) (STRING_LITERAL . 
(simple_statement . 2)) (CHARACTER_LITERAL . (simple_statement . 2)) (ACCEPT . 
(simple_statement . 2)) (ABORT . (simple_statement . 2)) (BEGIN . 
(simple_statement . 2)) (CASE . (simple_statement . 2)) (DECLARE .  [...]
       ((default . error) (OR . (compound_statement . 4)) (THEN . 
(compound_statement . 4)) (WHEN . (compound_statement . 4)) (EXCEPTION . 
(compound_statement . 4)) (END . (compound_statement . 4)) (LESS_LESS . 
(compound_statement . 4)) (IDENTIFIER . (compound_statement . 4)) 
(STRING_LITERAL . (compound_statement . 4)) (CHARACTER_LITERAL . 
(compound_statement . 4)) (ACCEPT . (compound_statement . 4)) (ABORT . 
(compound_statement . 4)) (BEGIN . (compound_statement . 4)) (CASE . 
(compound_s [...]
-      ((default . error) (END .  667))
+      ((default . error) (END .  666))
       ((default . error) (OR . (compound_statement . 0)) (THEN . 
(compound_statement . 0)) (WHEN . (compound_statement . 0)) (EXCEPTION . 
(compound_statement . 0)) (END . (compound_statement . 0)) (LESS_LESS . 
(compound_statement . 0)) (IDENTIFIER . (compound_statement . 0)) 
(STRING_LITERAL . (compound_statement . 0)) (CHARACTER_LITERAL . 
(compound_statement . 0)) (ACCEPT . (compound_statement . 0)) (ABORT . 
(compound_statement . 0)) (BEGIN . (compound_statement . 0)) (CASE . 
(compound_s [...]
-      ((default . error) (LOOP .  666))
-      ((default . error) (NULL .  624) (GOTO .  621) (ABORT .  614) (ACCEPT .  
613) (DECLARE .  617) (BEGIN .  615) (LOOP .  623) (CASE .  616) (IF .  622) 
(PRAGMA .  7) (RAISE .  625) (DELAY .  618) (REQUEUE .  626) (RETURN .  627) 
(EXIT .  619) (IDENTIFIER .  48) (CHARACTER_LITERAL .  50) (STRING_LITERAL .  
49) (WHILE .  629) (FOR .  620) (SELECT .  628))
+      ((default . error) (LOOP .  665))
+      ((default . error) (NULL .  623) (GOTO .  620) (ABORT .  613) (ACCEPT .  
612) (DECLARE .  616) (BEGIN .  614) (LOOP .  622) (CASE .  615) (IF .  621) 
(PRAGMA .  7) (RAISE .  624) (DELAY .  617) (REQUEUE .  625) (RETURN .  626) 
(EXIT .  618) (IDENTIFIER .  48) (CHARACTER_LITERAL .  50) (STRING_LITERAL .  
49) (WHILE .  628) (FOR .  619) (SELECT .  627))
       ((default . error) (OR . (compound_statement . 2)) (THEN . 
(compound_statement . 2)) (WHEN . (compound_statement . 2)) (EXCEPTION . 
(compound_statement . 2)) (END . (compound_statement . 2)) (LESS_LESS . 
(compound_statement . 2)) (IDENTIFIER . (compound_statement . 2)) 
(STRING_LITERAL . (compound_statement . 2)) (CHARACTER_LITERAL . 
(compound_statement . 2)) (ACCEPT . (compound_statement . 2)) (ABORT . 
(compound_statement . 2)) (BEGIN . (compound_statement . 2)) (CASE . 
(compound_s [...]
-      ((default . error) (DOT .  87) (SEMICOLON .  663) (TICK .  88) 
(COLON_EQUAL .  662) (LEFT_PAREN .  106))
+      ((default . error) (DOT .  87) (SEMICOLON .  662) (TICK .  88) 
(COLON_EQUAL .  661) (LEFT_PAREN .  106))
       ((default . error) (OR . (simple_statement . 10)) (THEN . 
(simple_statement . 10)) (WHEN . (simple_statement . 10)) (EXCEPTION . 
(simple_statement . 10)) (END . (simple_statement . 10)) (LESS_LESS . 
(simple_statement . 10)) (IDENTIFIER . (simple_statement . 10)) (STRING_LITERAL 
. (simple_statement . 10)) (CHARACTER_LITERAL . (simple_statement . 10)) 
(ACCEPT . (simple_statement . 10)) (ABORT . (simple_statement . 10)) (BEGIN . 
(simple_statement . 10)) (CASE . (simple_statement . 10) [...]
       ((default . error) (OR . (simple_statement . 4)) (THEN . 
(simple_statement . 4)) (WHEN . (simple_statement . 4)) (EXCEPTION . 
(simple_statement . 4)) (END . (simple_statement . 4)) (LESS_LESS . 
(simple_statement . 4)) (IDENTIFIER . (simple_statement . 4)) (STRING_LITERAL . 
(simple_statement . 4)) (CHARACTER_LITERAL . (simple_statement . 4)) (ACCEPT . 
(simple_statement . 4)) (ABORT . (simple_statement . 4)) (BEGIN . 
(simple_statement . 4)) (CASE . (simple_statement . 4)) (DECLARE .  [...]
       ((default . error) (OR . (simple_statement . 9)) (THEN . 
(simple_statement . 9)) (WHEN . (simple_statement . 9)) (EXCEPTION . 
(simple_statement . 9)) (END . (simple_statement . 9)) (LESS_LESS . 
(simple_statement . 9)) (IDENTIFIER . (simple_statement . 9)) (STRING_LITERAL . 
(simple_statement . 9)) (CHARACTER_LITERAL . (simple_statement . 9)) (ACCEPT . 
(simple_statement . 9)) (ABORT . (simple_statement . 9)) (BEGIN . 
(simple_statement . 9)) (CASE . (simple_statement . 9)) (DECLARE .  [...]
       ((default . error) (OR . (simple_statement . 6)) (THEN . 
(simple_statement . 6)) (WHEN . (simple_statement . 6)) (EXCEPTION . 
(simple_statement . 6)) (END . (simple_statement . 6)) (LESS_LESS . 
(simple_statement . 6)) (IDENTIFIER . (simple_statement . 6)) (STRING_LITERAL . 
(simple_statement . 6)) (CHARACTER_LITERAL . (simple_statement . 6)) (ACCEPT . 
(simple_statement . 6)) (ABORT . (simple_statement . 6)) (BEGIN . 
(simple_statement . 6)) (CASE . (simple_statement . 6)) (DECLARE .  [...]
       ((default . error) (OR . (select_statement . 0)) (THEN . 
(select_statement . 0)) (WHEN . (select_statement . 0)) (EXCEPTION . 
(select_statement . 0)) (END . (select_statement . 0)) (LESS_LESS . 
(select_statement . 0)) (IDENTIFIER . (select_statement . 0)) (STRING_LITERAL . 
(select_statement . 0)) (CHARACTER_LITERAL . (select_statement . 0)) (ACCEPT . 
(select_statement . 0)) (ABORT . (select_statement . 0)) (BEGIN . 
(select_statement . 0)) (CASE . (select_statement . 0)) (DECLARE .  [...]
       ((default . error) (OR . (compound_statement . 6)) (THEN . 
(compound_statement . 6)) (WHEN . (compound_statement . 6)) (EXCEPTION . 
(compound_statement . 6)) (END . (compound_statement . 6)) (LESS_LESS . 
(compound_statement . 6)) (IDENTIFIER . (compound_statement . 6)) 
(STRING_LITERAL . (compound_statement . 6)) (CHARACTER_LITERAL . 
(compound_statement . 6)) (ACCEPT . (compound_statement . 6)) (ABORT . 
(compound_statement . 6)) (BEGIN . (compound_statement . 6)) (CASE . 
(compound_s [...]
-      ((default . error) (WHEN . (sequence_of_statements_opt . 1)) (THEN . 
(sequence_of_statements_opt . 1)) (OR . (sequence_of_statements_opt . 1)) 
(ELSIF . (sequence_of_statements_opt . 1)) (ELSE . (sequence_of_statements_opt 
. 1)) (END . (sequence_of_statements_opt . 1)) (EXCEPTION . 
(sequence_of_statements_opt . 1)) (ACCEPT . (label_opt . 0)) (BEGIN . 
(label_opt . 0)) (CASE . (label_opt . 0)) (DECLARE . (label_opt . 0)) (FOR . 
(label_opt . 0)) (IF . (label_opt . 0)) (LOOP . (label_op [...]
-      ((default . error) (END . (handled_sequence_of_statements . 1)) 
(EXCEPTION .  660))
+      ((default . error) (WHEN . (sequence_of_statements_opt . 1)) (THEN . 
(sequence_of_statements_opt . 1)) (OR . (sequence_of_statements_opt . 1)) 
(ELSIF . (sequence_of_statements_opt . 1)) (ELSE . (sequence_of_statements_opt 
. 1)) (END . (sequence_of_statements_opt . 1)) (EXCEPTION . 
(sequence_of_statements_opt . 1)) (ACCEPT . (label_opt . 0)) (BEGIN . 
(label_opt . 0)) (CASE . (label_opt . 0)) (DECLARE . (label_opt . 0)) (FOR . 
(label_opt . 0)) (IF . (label_opt . 0)) (LOOP . (label_op [...]
+      ((default . error) (END . (handled_sequence_of_statements . 1)) 
(EXCEPTION .  659))
       ((default . error) (OR . (simple_statement . 5)) (THEN . 
(simple_statement . 5)) (WHEN . (simple_statement . 5)) (EXCEPTION . 
(simple_statement . 5)) (END . (simple_statement . 5)) (LESS_LESS . 
(simple_statement . 5)) (IDENTIFIER . (simple_statement . 5)) (STRING_LITERAL . 
(simple_statement . 5)) (CHARACTER_LITERAL . (simple_statement . 5)) (ACCEPT . 
(simple_statement . 5)) (ABORT . (simple_statement . 5)) (BEGIN . 
(simple_statement . 5)) (CASE . (simple_statement . 5)) (DECLARE .  [...]
       ((default . error) (WHEN . (sequence_of_statements . 0)) (THEN . 
(sequence_of_statements . 0)) (OR . (sequence_of_statements . 0)) (ELSIF . 
(sequence_of_statements . 0)) (ELSE . (sequence_of_statements . 0)) (EXCEPTION 
. (sequence_of_statements . 0)) (END . (sequence_of_statements . 0)) (LESS_LESS 
. (sequence_of_statements . 0)) (IDENTIFIER . (sequence_of_statements . 0)) 
(STRING_LITERAL . (sequence_of_statements . 0)) (CHARACTER_LITERAL . 
(sequence_of_statements . 0)) (ACCEPT . (s [...]
       ((default . error) (OR . (select_statement . 1)) (THEN . 
(select_statement . 1)) (WHEN . (select_statement . 1)) (EXCEPTION . 
(select_statement . 1)) (END . (select_statement . 1)) (LESS_LESS . 
(select_statement . 1)) (IDENTIFIER . (select_statement . 1)) (STRING_LITERAL . 
(select_statement . 1)) (CHARACTER_LITERAL . (select_statement . 1)) (ACCEPT . 
(select_statement . 1)) (ABORT . (select_statement . 1)) (BEGIN . 
(select_statement . 1)) (CASE . (select_statement . 1)) (DECLARE .  [...]
-      ((default . error) (SEMICOLON .  659))
       ((default . error) (SEMICOLON .  658))
+      ((default . error) (SEMICOLON .  657))
       ((default . error) (TYPE . (generic_instantiation . 2)) (TASK . 
(generic_instantiation . 2)) (SUBTYPE . (generic_instantiation . 2)) (PROTECTED 
. (generic_instantiation . 2)) (FOR . (generic_instantiation . 2)) (ENTRY . 
(generic_instantiation . 2)) (IDENTIFIER . (generic_instantiation . 2)) (BEGIN 
. (generic_instantiation . 2)) (END . (generic_instantiation . 2)) (WITH . 
(generic_instantiation . 2)) (USE . (generic_instantiation . 2)) (SEPARATE . 
(generic_instantiation . 2)) (PROCE [...]
       ((default . error) (TYPE . (generic_instantiation . 1)) (TASK . 
(generic_instantiation . 1)) (SUBTYPE . (generic_instantiation . 1)) (PROTECTED 
. (generic_instantiation . 1)) (FOR . (generic_instantiation . 1)) (ENTRY . 
(generic_instantiation . 1)) (IDENTIFIER . (generic_instantiation . 1)) (BEGIN 
. (generic_instantiation . 1)) (END . (generic_instantiation . 1)) (WITH . 
(generic_instantiation . 1)) (USE . (generic_instantiation . 1)) (SEPARATE . 
(generic_instantiation . 1)) (PROCE [...]
       ((default . error) (END . (exception_handler_list_opt . 0)) (WHEN .  
930))
@@ -2355,17 +2402,17 @@
       ((default . error) (WHEN . (procedure_call_statement . 0)) (OR . 
(procedure_call_statement . 0)) (THEN . (procedure_call_statement . 0)) (ELSIF 
. (procedure_call_statement . 0)) (ELSE . (procedure_call_statement . 0)) 
(WHILE . (procedure_call_statement . 0)) (SELECT . (procedure_call_statement . 
0)) (RETURN . (procedure_call_statement . 0)) (REQUEUE . 
(procedure_call_statement . 0)) (RAISE . (procedure_call_statement . 0)) 
(PRAGMA . (procedure_call_statement . 0)) (NULL . (procedur [...]
       ((default . error) (OR . (statement . 1)) (THEN . (statement . 1)) (WHEN 
. (statement . 1)) (EXCEPTION . (statement . 1)) (END . (statement . 1)) 
(LESS_LESS . (statement . 1)) (IDENTIFIER . (statement . 1)) (STRING_LITERAL . 
(statement . 1)) (CHARACTER_LITERAL . (statement . 1)) (ACCEPT . (statement . 
1)) (ABORT . (statement . 1)) (BEGIN . (statement . 1)) (CASE . (statement . 
1)) (DECLARE . (statement . 1)) (DELAY . (statement . 1)) (EXIT . (statement . 
1)) (FOR . (statement . 1)) [...]
       ((default . error) (OR . (statement . 0)) (THEN . (statement . 0)) (WHEN 
. (statement . 0)) (EXCEPTION . (statement . 0)) (END . (statement . 0)) 
(LESS_LESS . (statement . 0)) (IDENTIFIER . (statement . 0)) (STRING_LITERAL . 
(statement . 0)) (CHARACTER_LITERAL . (statement . 0)) (ACCEPT . (statement . 
0)) (ABORT . (statement . 0)) (BEGIN . (statement . 0)) (CASE . (statement . 
0)) (DECLARE . (statement . 0)) (DELAY . (statement . 0)) (EXIT . (statement . 
0)) (FOR . (statement . 0)) [...]
-      ((default . error) (END . (sequence_of_statements_opt . 0)) (ACCEPT . 
(label_opt . 0)) (BEGIN . (label_opt . 0)) (CASE . (label_opt . 0)) (DECLARE . 
(label_opt . 0)) (FOR . (label_opt . 0)) (IF . (label_opt . 0)) (LOOP . 
(label_opt . 0)) (RETURN . (label_opt . 0)) (SELECT . (label_opt . 0)) (WHILE . 
(label_opt . 0)) (STRING_LITERAL . (label_opt . 0)) (CHARACTER_LITERAL . 
(label_opt . 0)) (ABORT . (label_opt . 0)) (DELAY . (label_opt . 0)) (EXIT . 
(label_opt . 0)) (GOTO . (label_opt [...]
+      ((default . error) (END . (sequence_of_statements_opt . 0)) (ACCEPT . 
(label_opt . 0)) (BEGIN . (label_opt . 0)) (CASE . (label_opt . 0)) (DECLARE . 
(label_opt . 0)) (FOR . (label_opt . 0)) (IF . (label_opt . 0)) (LOOP . 
(label_opt . 0)) (RETURN . (label_opt . 0)) (SELECT . (label_opt . 0)) (WHILE . 
(label_opt . 0)) (STRING_LITERAL . (label_opt . 0)) (CHARACTER_LITERAL . 
(label_opt . 0)) (ABORT . (label_opt . 0)) (DELAY . (label_opt . 0)) (EXIT . 
(label_opt . 0)) (GOTO . (label_opt [...]
       ((default . error) (SEMICOLON . (name_opt . 0)) (IDENTIFIER .  48) 
(CHARACTER_LITERAL .  50) (STRING_LITERAL .  49))
       ((default . error) (LOOP . (iteration_scheme . 0)))
       ((default . error) (SEMICOLON .  926))
       ((default . error) (PLUS .  144) (MINUS .  143) (ABS .  146) (NOT .  
149) (NULL .  150) (NEW .  148) (IDENTIFIER .  48) (CHARACTER_LITERAL .  50) 
(STRING_LITERAL .  49) (LEFT_PAREN .  147))
-      ((default . error) (END . (sequence_of_statements_opt . 0)) (OR . 
(sequence_of_statements_opt . 0)) (ELSE . (sequence_of_statements_opt . 0)) 
(ACCEPT . (label_opt . 0)) (BEGIN . (label_opt . 0)) (CASE . (label_opt . 0)) 
(DECLARE . (label_opt . 0)) (FOR . (label_opt . 0)) (IF . (label_opt . 0)) 
(LOOP . (label_opt . 0)) (RETURN . (label_opt . 0)) (SELECT . (label_opt . 0)) 
(WHILE . (label_opt . 0)) (STRING_LITERAL . (label_opt . 0)) (CHARACTER_LITERAL 
. (label_opt . 0)) (ABORT . (lab [...]
+      ((default . error) (END . (sequence_of_statements_opt . 0)) (OR . 
(sequence_of_statements_opt . 0)) (ELSE . (sequence_of_statements_opt . 0)) 
(ACCEPT . (label_opt . 0)) (BEGIN . (label_opt . 0)) (CASE . (label_opt . 0)) 
(DECLARE . (label_opt . 0)) (FOR . (label_opt . 0)) (IF . (label_opt . 0)) 
(LOOP . (label_opt . 0)) (RETURN . (label_opt . 0)) (SELECT . (label_opt . 0)) 
(WHILE . (label_opt . 0)) (STRING_LITERAL . (label_opt . 0)) (CHARACTER_LITERAL 
. (label_opt . 0)) (ABORT . (lab [...]
       ((default . error) (ELSE . (select_alternative . 3)) (OR . 
(select_alternative . 3)) (END . (select_alternative . 3)))
-      ((default . error) (OR . (sequence_of_statements_opt . 0)) (END . 
(sequence_of_statements_opt . 0)) (ELSE . (sequence_of_statements_opt . 0)) 
(THEN . (sequence_of_statements_opt . 0)) (ACCEPT . (label_opt . 0)) (BEGIN . 
(label_opt . 0)) (CASE . (label_opt . 0)) (DECLARE . (label_opt . 0)) (FOR . 
(label_opt . 0)) (IF . (label_opt . 0)) (LOOP . (label_opt . 0)) (RETURN . 
(label_opt . 0)) (SELECT . (label_opt . 0)) (WHILE . (label_opt . 0)) 
(STRING_LITERAL . (label_opt . 0)) (CHARACTE [...]
+      ((default . error) (OR . (sequence_of_statements_opt . 0)) (END . 
(sequence_of_statements_opt . 0)) (ELSE . (sequence_of_statements_opt . 0)) 
(THEN . (sequence_of_statements_opt . 0)) (ACCEPT . (label_opt . 0)) (BEGIN . 
(label_opt . 0)) (CASE . (label_opt . 0)) (DECLARE . (label_opt . 0)) (FOR . 
(label_opt . 0)) (IF . (label_opt . 0)) (LOOP . (label_opt . 0)) (RETURN . 
(label_opt . 0)) (SELECT . (label_opt . 0)) (WHILE . (label_opt . 0)) 
(STRING_LITERAL . (label_opt . 0)) (CHARACTE [...]
       ((default . error) (ELSE .  921) (OR .  922))
-      ((default . error) (DOT .  87) (SEMICOLON .  663) (TICK .  88) (OR . 
(sequence_of_statements_opt . 0)) (ELSE . (sequence_of_statements_opt . 0)) 
(THEN . (sequence_of_statements_opt . 0)) (LEFT_PAREN .  106) (ACCEPT . 
(label_opt . 0)) (BEGIN . (label_opt . 0)) (CASE . (label_opt . 0)) (DECLARE . 
(label_opt . 0)) (FOR . (label_opt . 0)) (IF . (label_opt . 0)) (LOOP . 
(label_opt . 0)) (RETURN . (label_opt . 0)) (SELECT . (label_opt . 0)) (WHILE . 
(label_opt . 0)) (STRING_LITERAL . (la [...]
-      ((default . error) (OR . (sequence_of_statements_opt . 0)) (ELSE . 
(sequence_of_statements_opt . 0)) (THEN . (sequence_of_statements_opt . 0)) 
(ACCEPT . (label_opt . 0)) (BEGIN . (label_opt . 0)) (CASE . (label_opt . 0)) 
(DECLARE . (label_opt . 0)) (FOR . (label_opt . 0)) (IF . (label_opt . 0)) 
(LOOP . (label_opt . 0)) (RETURN . (label_opt . 0)) (SELECT . (label_opt . 0)) 
(WHILE . (label_opt . 0)) (STRING_LITERAL . (label_opt . 0)) (CHARACTER_LITERAL 
. (label_opt . 0)) (ABORT . (la [...]
+      ((default . error) (DOT .  87) (SEMICOLON .  662) (TICK .  88) (OR . 
(sequence_of_statements_opt . 0)) (ELSE . (sequence_of_statements_opt . 0)) 
(THEN . (sequence_of_statements_opt . 0)) (LEFT_PAREN .  106) (ACCEPT . 
(label_opt . 0)) (BEGIN . (label_opt . 0)) (CASE . (label_opt . 0)) (DECLARE . 
(label_opt . 0)) (FOR . (label_opt . 0)) (IF . (label_opt . 0)) (LOOP . 
(label_opt . 0)) (RETURN . (label_opt . 0)) (SELECT . (label_opt . 0)) (WHILE . 
(label_opt . 0)) (STRING_LITERAL . (la [...]
+      ((default . error) (OR . (sequence_of_statements_opt . 0)) (ELSE . 
(sequence_of_statements_opt . 0)) (THEN . (sequence_of_statements_opt . 0)) 
(ACCEPT . (label_opt . 0)) (BEGIN . (label_opt . 0)) (CASE . (label_opt . 0)) 
(DECLARE . (label_opt . 0)) (FOR . (label_opt . 0)) (IF . (label_opt . 0)) 
(LOOP . (label_opt . 0)) (RETURN . (label_opt . 0)) (SELECT . (label_opt . 0)) 
(WHILE . (label_opt . 0)) (STRING_LITERAL . (label_opt . 0)) (CHARACTER_LITERAL 
. (label_opt . 0)) (ABORT . (la [...]
       ((default . error) (ELSE . (select_alternative_list . 0)) (END . 
(select_alternative_list . 0)) (OR . (select_alternative_list . 0)))
       ((default . error) (ELSE . (select_alternative_list_opt . 1)) (END . 
(select_alternative_list_opt . 1)) (OR .  918))
       ((default . error) (ELSE .  916) (END .  917))
@@ -2400,15 +2447,15 @@
       ((default . error) (COMMA . (pragma_argument_association . 2)) 
(RIGHT_PAREN . (pragma_argument_association . 2)))
       ((default . error) (ELSE .  886) (RIGHT_PAREN . (if_expression . 3)) 
(ELSIF .  887))
       ((default . error) (PLUS .  144) (MINUS .  143) (ABS .  146) (NOT .  
149) (NULL .  150) (NEW .  148) (IDENTIFIER .  48) (CHARACTER_LITERAL .  50) 
(STRING_LITERAL .  49) (LEFT_PAREN .  147))
-      ((default . error) (NOT .  736) (IDENTIFIER .  48) (CHARACTER_LITERAL .  
50) (STRING_LITERAL .  49))
-      ((default . error) (REVERSE .  882) (IDENTIFIER .  48) 
(CHARACTER_LITERAL .  50) (STRING_LITERAL .  49) (PLUS .  144) (MINUS .  143) 
(ABS .  146) (NOT .  758) (NULL .  150) (NEW .  148) (LEFT_PAREN .  147))
+      ((default . error) (NOT .  735) (IDENTIFIER .  48) (CHARACTER_LITERAL .  
50) (STRING_LITERAL .  49))
+      ((default . error) (REVERSE .  882) (IDENTIFIER .  48) 
(CHARACTER_LITERAL .  50) (STRING_LITERAL .  49) (PLUS .  144) (MINUS .  143) 
(ABS .  146) (NOT .  757) (NULL .  150) (NEW .  148) (LEFT_PAREN .  147))
       ((default . error) (REVERSE .  880) (IDENTIFIER .  48) 
(CHARACTER_LITERAL .  50) (STRING_LITERAL .  49))
       ((default . error) (EQUAL_GREATER . (discrete_choice_list . 0)) (BAR . 
(discrete_choice_list . 0)) (OTHERS .  172) (IDENTIFIER .  48) 
(CHARACTER_LITERAL .  50) (STRING_LITERAL .  49) (PLUS .  144) (MINUS .  143) 
(ABS .  146) (NOT .  171) (NULL .  150) (NEW .  148) (LEFT_PAREN .  147))
       ((default . error) (RIGHT_PAREN . (case_expression_alternative_list . 
0)) (COMMA . (case_expression_alternative_list . 0)))
       ((default . error) (COMMA .  878) (RIGHT_PAREN . (case_expression . 0)))
       ((default . error) (SEMICOLON .  877))
       ((default . error) (END .  876))
-      ((default . error) (IDENTIFIER .  213) (CHARACTER_LITERAL .  50) 
(STRING_LITERAL .  49) (PLUS .  144) (MINUS .  143) (ABS .  146) (NOT .  758) 
(NULL .  150) (NEW .  148) (LEFT_PAREN .  147))
+      ((default . error) (IDENTIFIER .  213) (CHARACTER_LITERAL .  50) 
(STRING_LITERAL .  49) (PLUS .  144) (MINUS .  143) (ABS .  146) (NOT .  757) 
(NULL .  150) (NEW .  148) (LEFT_PAREN .  147))
       ((default . error) (SEMICOLON . (aspect_specification_opt . 0)) (WITH .  
108))
       ((default . error) (CASE .  366) (IF .  368) (PLUS .  144) (MINUS .  
143) (ABS .  146) (NOT .  149) (NULL .  150) (NEW .  148) (IDENTIFIER .  48) 
(CHARACTER_LITERAL .  50) (STRING_LITERAL .  49) (LEFT_PAREN .  147))
       ((default . error) (SEMICOLON . (aspect_specification_opt . 0)) (WITH .  
108))
@@ -2463,7 +2510,7 @@
       ((default . error) (IDENTIFIER .  48) (CHARACTER_LITERAL .  50) 
(STRING_LITERAL .  49))
       ((default . error) (PACKAGE . (formal_type_declaration . 1)) (PROCEDURE 
. (formal_type_declaration . 1)) (FUNCTION . (formal_type_declaration . 1)) 
(IDENTIFIER . (formal_type_declaration . 1)) (PRAGMA . (formal_type_declaration 
. 1)) (TYPE . (formal_type_declaration . 1)) (WITH . (formal_type_declaration . 
1)))
       ((default . error) (IDENTIFIER .  48) (CHARACTER_LITERAL .  50) 
(STRING_LITERAL .  49))
-      ((default . error) (SEMICOLON . (formal_derived_type_definition . 3)) 
(WITH . ((formal_derived_type_definition . 3)  796)) (DOT .  87) (TICK .  88) 
(AND .  795) (LEFT_PAREN .  106))
+      ((default . error) (DOT .  87) (TICK .  88) (WITH . 
(and_interface_list_opt . 0)) (SEMICOLON . (and_interface_list_opt . 0)) (AND . 
 795) (LEFT_PAREN .  106))
       ((default . error) (PACKAGE . (formal_type_declaration . 0)) (PROCEDURE 
. (formal_type_declaration . 0)) (FUNCTION . (formal_type_declaration . 0)) 
(IDENTIFIER . (formal_type_declaration . 0)) (PRAGMA . (formal_type_declaration 
. 0)) (TYPE . (formal_type_declaration . 0)) (WITH . (formal_type_declaration . 
0)))
       ((default . error) (PACKAGE . (formal_subprogram_declaration . 2)) 
(PROCEDURE . (formal_subprogram_declaration . 2)) (FUNCTION . 
(formal_subprogram_declaration . 2)) (IDENTIFIER . 
(formal_subprogram_declaration . 2)) (PRAGMA . (formal_subprogram_declaration . 
2)) (TYPE . (formal_subprogram_declaration . 2)) (WITH . 
(formal_subprogram_declaration . 2)))
       ((default . error) (BOX .  794) (IDENTIFIER .  48) (STRING_LITERAL .  
49) (CHARACTER_LITERAL .  170) (RIGHT_PAREN . ((association_opt . 0) 
(expression_opt . 0))) (COMMA . ((association_opt . 0) (expression_opt . 0))) 
(EQUAL_GREATER . (discrete_choice_list . 0)) (BAR . (discrete_choice_list . 0)) 
(PLUS .  144) (MINUS .  143) (OTHERS .  172) (ABS .  146) (NOT .  171) (NULL .  
150) (NEW .  148) (LEFT_PAREN .  147))
@@ -2474,18 +2521,19 @@
       ((default . error) (IDENTIFIER .  72))
       ((default . error) (RENAMES . (access_definition . 1)) (DO . 
(access_definition . 1)) (RIGHT_PAREN . (access_definition . 1)) (IS . 
(access_definition . 1)) (SEMICOLON . (access_definition . 1)) (WITH . 
(access_definition . 1)) (COLON_EQUAL . (access_definition . 1)))
       ((default . error) (RENAMES . (access_definition . 2)) (DO . 
(access_definition . 2)) (RIGHT_PAREN . (access_definition . 2)) (IS . 
(access_definition . 2)) (SEMICOLON . (access_definition . 2)) (WITH . 
(access_definition . 2)) (COLON_EQUAL . (access_definition . 2)))
-      ((default . error) (SEMICOLON . (parameter_specification . 2)) 
(RIGHT_PAREN . (parameter_specification . 2)))
       ((default . error) (IDENTIFIER .  48) (CHARACTER_LITERAL .  50) 
(STRING_LITERAL .  49))
+      ((default . error) (PLUS .  144) (MINUS .  143) (ABS .  146) (NOT .  
149) (NULL .  150) (NEW .  148) (IDENTIFIER .  48) (CHARACTER_LITERAL .  50) 
(STRING_LITERAL .  49) (LEFT_PAREN .  147))
       ((default . error) (DO . (aggregate . 1)) (LOOP . (aggregate . 1)) (USE 
. (aggregate . 1)) (COLON_EQUAL . (aggregate . 1)) (WHILE . (aggregate . 1)) 
(SELECT . (aggregate . 1)) (REQUEUE . (aggregate . 1)) (RAISE . (aggregate . 
1)) (PRAGMA . (aggregate . 1)) (NULL . (aggregate . 1)) (IF . (aggregate . 1)) 
(GOTO . (aggregate . 1)) (FOR . (aggregate . 1)) (EXIT . (aggregate . 1)) 
(DELAY . (aggregate . 1)) (DECLARE . (aggregate . 1)) (CASE . (aggregate . 1)) 
(BEGIN . (aggregate . 1)) (A [...]
-      ((default . error) (RIGHT_PAREN .  789))
+      ((default . error) (RIGHT_PAREN .  788))
       ((default . error) (OF . (aggregate . 2)) (LESS_LESS . (aggregate . 2)) 
(IDENTIFIER . (aggregate . 2)) (STRING_LITERAL . (aggregate . 2)) 
(CHARACTER_LITERAL . (aggregate . 2)) (ACCEPT . (aggregate . 2)) (ABORT . 
(aggregate . 2)) (BEGIN . (aggregate . 2)) (CASE . (aggregate . 2)) (DECLARE . 
(aggregate . 2)) (DELAY . (aggregate . 2)) (EXIT . (aggregate . 2)) (FOR . 
(aggregate . 2)) (GOTO . (aggregate . 2)) (IF . (aggregate . 2)) (NULL . 
(aggregate . 2)) (PRAGMA . (aggregate . 2)) (RA [...]
+      ((default . error) (RIGHT_PAREN . (parameter_specification . 2)) 
(SEMICOLON . (parameter_specification . 2)))
       ((default . error) (COLON_EQUAL .  1067) (DOT .  87) (TICK .  88) 
(RIGHT_PAREN . (parameter_specification . 1)) (SEMICOLON . 
(parameter_specification . 1)) (LEFT_PAREN .  106))
       ((default . error) (WITH . (formal_object_declaration . 2)) (TYPE . 
(formal_object_declaration . 2)) (PRAGMA . (formal_object_declaration . 2)) 
(IDENTIFIER . (formal_object_declaration . 2)) (FUNCTION . 
(formal_object_declaration . 2)) (PROCEDURE . (formal_object_declaration . 2)) 
(PACKAGE . (formal_object_declaration . 2)))
       ((default . error) (SEMICOLON .  1066))
       ((default . error) (SEMICOLON .  1065))
       ((default . error) (RIGHT_PAREN .  1064))
       ((default . error) (IDENTIFIER .  48) (CHARACTER_LITERAL .  50) 
(STRING_LITERAL .  49))
-      ((default . error) (PRIVATE .  1062))
+      ((default . error) (WITH . ( 1062 (formal_derived_type_definition . 1))) 
(SEMICOLON . (formal_derived_type_definition . 1)))
       ((default . error) (AND .  1061) (WITH . (interface_type_definition . 
1)) (SEMICOLON . (interface_type_definition . 1)))
       ((default . error) (DOT .  87) (SEMICOLON . (interface_list . 0)) (WITH 
. (interface_list . 0)) (AND . (interface_list . 0)) (TICK .  88) (LEFT_PAREN . 
 106))
       ((default . error) (AND .  1061) (WITH . (interface_type_definition . 
3)) (SEMICOLON . (interface_type_definition . 3)))
@@ -2498,7 +2546,7 @@
       ((default . error) (LOOP . (constraint . 1)) (DO . (constraint . 1)) 
(EQUAL_GREATER . (constraint . 1)) (COMMA . (constraint . 1)) (RIGHT_PAREN . 
(constraint . 1)) (COLON_EQUAL . (constraint . 1)) (WITH . (constraint . 1)) 
(SEMICOLON . (constraint . 1)) (AND . (constraint . 1)) (OF . (constraint . 1)))
       ((default . error) (IDENTIFIER .  48) (CHARACTER_LITERAL .  50) 
(STRING_LITERAL .  49))
       ((default . error) (OF .  1054))
-      ((default . error) (IDENTIFIER .  48) (CHARACTER_LITERAL .  50) 
(STRING_LITERAL .  49) (PLUS .  144) (MINUS .  143) (ABS .  146) (NOT .  758) 
(NULL .  150) (NEW .  148) (LEFT_PAREN .  147))
+      ((default . error) (IDENTIFIER .  48) (CHARACTER_LITERAL .  50) 
(STRING_LITERAL .  49) (PLUS .  144) (MINUS .  143) (ABS .  146) (NOT .  757) 
(NULL .  150) (NEW .  148) (LEFT_PAREN .  147))
       ((default . error) (OF .  1052))
       ((default . error) (PLUS . (primary . 0)) (MINUS . (primary . 0)) 
(AMPERSAND . (primary . 0)) (DOT_DOT . (primary . 0)) (SLASH . (primary . 0)) 
(STAR . (primary . 0)) (MOD . (primary . 0)) (REM . (primary . 0)) (IDENTIFIER 
.  48) (CHARACTER_LITERAL .  50) (STRING_LITERAL .  49))
       ((default . error) (DOT . (name . 0)) (LEFT_PAREN . (name . 0)) (TICK . 
(name . 0)) (SEMICOLON . (null_exclusion_opt_name . 2)) (RIGHT_PAREN . 
(null_exclusion_opt_name . 2)) (COLON_EQUAL . (null_exclusion_opt_name . 2)))
@@ -2529,16 +2577,16 @@
       ((default . error) (IDENTIFIER .  48) (CHARACTER_LITERAL .  50) 
(STRING_LITERAL .  49))
       ((default . error) (END .  1028) (PRIVATE .  1029))
       ((default . error) (SEMICOLON .  1027))
-      ((default . error) (SYNCHRONIZED .  551) (TAGGED .  552) (NEW . 
((abstract_limited_synchronized_opt . 3) (abstract_limited_opt . 3))) (LIMITED 
.  1026))
+      ((default . error) (SYNCHRONIZED .  550) (TAGGED .  551) (NEW . 
((abstract_limited_synchronized_opt . 3) (abstract_limited_opt . 3))) (LIMITED 
.  1026))
       ((default . error) (PLUS .  144) (MINUS .  143) (ABS .  146) (NOT .  
149) (NULL .  150) (NEW .  148) (IDENTIFIER .  48) (CHARACTER_LITERAL .  50) 
(STRING_LITERAL .  49) (LEFT_PAREN .  147))
       ((default . error) (PLUS .  144) (MINUS .  143) (ABS .  146) (NOT .  
149) (NULL .  150) (NEW .  148) (IDENTIFIER .  48) (CHARACTER_LITERAL .  50) 
(STRING_LITERAL .  49) (LEFT_PAREN .  147))
       ((default . error) (IDENTIFIER .  1020) (CHARACTER_LITERAL .  1021))
-      ((default . error) (INTERFACE .  545) (PRIVATE . 
(abstract_tagged_limited_opt . 5)) (NULL . (abstract_tagged_limited_opt . 5)) 
(RECORD . (abstract_tagged_limited_opt . 5)) (NEW . 
((abstract_limited_synchronized_opt . 4) (abstract_limited_opt . 2))))
+      ((default . error) (INTERFACE .  544) (PRIVATE . 
(abstract_tagged_limited_opt . 5)) (NULL . (abstract_tagged_limited_opt . 5)) 
(RECORD . (abstract_tagged_limited_opt . 5)) (NEW . 
((abstract_limited_synchronized_opt . 4) (abstract_limited_opt . 2))))
       ((default . error) (PLUS .  144) (MINUS .  143) (ABS .  146) (NOT .  
149) (NULL .  150) (NEW .  148) (IDENTIFIER .  48) (CHARACTER_LITERAL .  50) 
(STRING_LITERAL .  49) (LEFT_PAREN .  147))
       ((default . error) (RECORD .  1018))
       ((default . error) (PLUS .  144) (MINUS .  143) (ABS .  146) (NOT .  
149) (NULL .  150) (NEW .  148) (IDENTIFIER .  48) (CHARACTER_LITERAL .  50) 
(STRING_LITERAL .  49) (LEFT_PAREN .  147))
       ((default . error) (END . (component_list_opt . 0)) (NULL .  1009) (CASE 
.  1008) (IDENTIFIER .  72) (FOR .  289))
-      ((default . error) (SEMICOLON .  1007) (PRIVATE . 
(abstract_tagged_limited_opt . 4)) (NULL . (abstract_tagged_limited_opt . 4)) 
(RECORD . (abstract_tagged_limited_opt . 4)) (LIMITED .  539))
+      ((default . error) (SEMICOLON .  1007) (PRIVATE . 
(abstract_tagged_limited_opt . 4)) (NULL . (abstract_tagged_limited_opt . 4)) 
(RECORD . (abstract_tagged_limited_opt . 4)) (LIMITED .  538))
       ((default . error) (NEW .  1006))
       ((default . error) (NEW .  1005))
       ((default . error) (PRIVATE .  1003) (RECORD .  848) (NULL .  846))
@@ -2567,11 +2615,11 @@
       ((default . error) (LOOP . (subtype_indication . 3)) (DOT .  87) (IN . 
(primary . 2)) (NOT . (primary . 2)) (EQUAL . (primary . 2)) (GREATER . 
(primary . 2)) (GREATER_EQUAL . (primary . 2)) (LESS . (primary . 2)) 
(LESS_EQUAL . (primary . 2)) (SLASH_EQUAL . (primary . 2)) (RIGHT_PAREN . 
((subtype_indication . 3) (primary . 2))) (COMMA . ((subtype_indication . 3) 
(primary . 2))) (BAR . (primary . 2)) (EQUAL_GREATER . ((subtype_indication . 
3) (primary . 2))) (AND . (primary . 2)) (OR [...]
       ((default . error) (SEMICOLON . (name_opt . 0)) (IDENTIFIER .  48) 
(CHARACTER_LITERAL .  50) (STRING_LITERAL .  49))
       ((default . error) (END . (package_body . 1)) (BEGIN . (package_body . 
1)) (IDENTIFIER . (package_body . 1)) (ENTRY . (package_body . 1)) (FOR . 
(package_body . 1)) (PROTECTED . (package_body . 1)) (SUBTYPE . (package_body . 
1)) (TASK . (package_body . 1)) (TYPE . (package_body . 1)) (WITH . 
(package_body . 1)) (USE . (package_body . 1)) (SEPARATE . (package_body . 1)) 
(PROCEDURE . (package_body . 1)) (PRIVATE . (package_body . 1)) (PRAGMA . 
(package_body . 1)) (PACKAGE . (package_ [...]
-      ((default . error) (WHEN .  714))
+      ((default . error) (WHEN .  713))
       ((default . error) (BAR .  275) (EQUAL_GREATER .  982))
       ((default . error) (IDENTIFIER .  48) (CHARACTER_LITERAL .  50) 
(STRING_LITERAL .  49))
       ((default . error) (DOT .  87) (TICK .  88) (LOOP . 
(iterator_specification . 5)) (EQUAL_GREATER . (iterator_specification . 5)) 
(LEFT_PAREN .  106))
-      ((default . error) (IDENTIFIER .  48) (CHARACTER_LITERAL .  50) 
(STRING_LITERAL .  49) (PLUS .  144) (MINUS .  143) (ABS .  146) (NOT .  758) 
(NULL .  150) (NEW .  148) (LEFT_PAREN .  147))
+      ((default . error) (IDENTIFIER .  48) (CHARACTER_LITERAL .  50) 
(STRING_LITERAL .  49) (PLUS .  144) (MINUS .  143) (ABS .  146) (NOT .  757) 
(NULL .  150) (NEW .  148) (LEFT_PAREN .  147))
       ((default . error) (LOOP . (iterator_specification . 1)) (EQUAL_GREATER 
. (iterator_specification . 1)))
       ((default . error) (OF .  979))
       ((default . error) (RIGHT_PAREN . (quantified_expression . 0)))
@@ -2584,34 +2632,34 @@
       ((default . error) (ACCEPT . (label_opt . 1)) (BEGIN . (label_opt . 1)) 
(CASE . (label_opt . 1)) (DECLARE . (label_opt . 1)) (FOR . (label_opt . 1)) 
(IF . (label_opt . 1)) (LOOP . (label_opt . 1)) (RETURN . (label_opt . 1)) 
(SELECT . (label_opt . 1)) (WHILE . (label_opt . 1)) (IDENTIFIER . (label_opt . 
1)) (STRING_LITERAL . (label_opt . 1)) (CHARACTER_LITERAL . (label_opt . 1)) 
(ABORT . (label_opt . 1)) (DELAY . (label_opt . 1)) (EXIT . (label_opt . 1)) 
(GOTO . (label_opt . 1)) (NU [...]
       ((default . error) (RIGHT_PAREN . ((association_opt . 0) (expression_opt 
. 0))) (COMMA . ((association_opt . 0) (expression_opt . 0))) (EQUAL_GREATER . 
(discrete_choice_list . 0)) (BAR . (discrete_choice_list . 0)) (OTHERS .  172) 
(IDENTIFIER .  48) (CHARACTER_LITERAL .  170) (STRING_LITERAL .  49) (PLUS .  
144) (MINUS .  143) (ABS .  146) (NOT .  171) (NULL .  150) (NEW .  148) 
(LEFT_PAREN .  147))
       ((default . error) (SEMICOLON . (actual_parameter_part_opt . 1)) 
(LEFT_PAREN . (actual_parameter_part_opt . 1)) (DO . (actual_parameter_part_opt 
. 1)))
-      ((default . error) (DO . (parameter_profile_opt . 0)) (SEMICOLON . 
(parameter_profile_opt . 0)) (LEFT_PAREN .  782))
+      ((default . error) (DO . (parameter_profile_opt . 0)) (SEMICOLON . 
(parameter_profile_opt . 0)) (LEFT_PAREN .  781))
       ((default . error) (OR . (simple_statement . 8)) (THEN . 
(simple_statement . 8)) (WHEN . (simple_statement . 8)) (EXCEPTION . 
(simple_statement . 8)) (END . (simple_statement . 8)) (LESS_LESS . 
(simple_statement . 8)) (IDENTIFIER . (simple_statement . 8)) (STRING_LITERAL . 
(simple_statement . 8)) (CHARACTER_LITERAL . (simple_statement . 8)) (ACCEPT . 
(simple_statement . 8)) (ABORT . (simple_statement . 8)) (BEGIN . 
(simple_statement . 8)) (CASE . (simple_statement . 8)) (DECLARE .  [...]
-      ((default . error) (SEMICOLON . (identifier_opt . 0)) (IDENTIFIER .  
695))
+      ((default . error) (SEMICOLON . (identifier_opt . 0)) (IDENTIFIER .  
694))
       ((default . error) (WHEN .  960))
-      ((default . error) (END . (sequence_of_statements_opt . 0)) (EXCEPTION . 
(sequence_of_statements_opt . 0)) (ACCEPT . (label_opt . 0)) (BEGIN . 
(label_opt . 0)) (CASE . (label_opt . 0)) (DECLARE . (label_opt . 0)) (FOR . 
(label_opt . 0)) (IF . (label_opt . 0)) (LOOP . (label_opt . 0)) (RETURN . 
(label_opt . 0)) (SELECT . (label_opt . 0)) (WHILE . (label_opt . 0)) 
(STRING_LITERAL . (label_opt . 0)) (CHARACTER_LITERAL . (label_opt . 0)) (ABORT 
. (label_opt . 0)) (DELAY . (label_opt .  [...]
+      ((default . error) (END . (sequence_of_statements_opt . 0)) (EXCEPTION . 
(sequence_of_statements_opt . 0)) (ACCEPT . (label_opt . 0)) (BEGIN . 
(label_opt . 0)) (CASE . (label_opt . 0)) (DECLARE . (label_opt . 0)) (FOR . 
(label_opt . 0)) (IF . (label_opt . 0)) (LOOP . (label_opt . 0)) (RETURN . 
(label_opt . 0)) (SELECT . (label_opt . 0)) (WHILE . (label_opt . 0)) 
(STRING_LITERAL . (label_opt . 0)) (CHARACTER_LITERAL . (label_opt . 0)) (ABORT 
. (label_opt . 0)) (DELAY . (label_opt .  [...]
       ((default . error) (WHEN . (delay_statement . 1)) (EXCEPTION . 
(delay_statement . 1)) (ELSIF . (delay_statement . 1)) (THEN . (delay_statement 
. 1)) (ELSE . (delay_statement . 1)) (OR . (delay_statement . 1)) (END . 
(delay_statement . 1)) (LESS_LESS . (delay_statement . 1)) (IDENTIFIER . 
(delay_statement . 1)) (STRING_LITERAL . (delay_statement . 1)) 
(CHARACTER_LITERAL . (delay_statement . 1)) (ACCEPT . (delay_statement . 1)) 
(ABORT . (delay_statement . 1)) (BEGIN . (delay_statemen [...]
       ((default . error) (SEMICOLON .  958))
       ((default . error) (OR . (exit_statement . 1)) (THEN . (exit_statement . 
1)) (WHEN . (exit_statement . 1)) (EXCEPTION . (exit_statement . 1)) (END . 
(exit_statement . 1)) (LESS_LESS . (exit_statement . 1)) (IDENTIFIER . 
(exit_statement . 1)) (STRING_LITERAL . (exit_statement . 1)) 
(CHARACTER_LITERAL . (exit_statement . 1)) (ACCEPT . (exit_statement . 1)) 
(ABORT . (exit_statement . 1)) (BEGIN . (exit_statement . 1)) (CASE . 
(exit_statement . 1)) (DECLARE . (exit_statement . 1)) (DEL [...]
       ((default . error) (SEMICOLON . (expression_opt . 0)) (PLUS .  144) 
(MINUS .  143) (ABS .  146) (NOT .  149) (NULL .  150) (NEW .  148) (IDENTIFIER 
.  48) (CHARACTER_LITERAL .  50) (STRING_LITERAL .  49) (LEFT_PAREN .  147))
       ((default . error) (OR . (simple_statement . 3)) (THEN . 
(simple_statement . 3)) (WHEN . (simple_statement . 3)) (EXCEPTION . 
(simple_statement . 3)) (END . (simple_statement . 3)) (LESS_LESS . 
(simple_statement . 3)) (IDENTIFIER . (simple_statement . 3)) (STRING_LITERAL . 
(simple_statement . 3)) (CHARACTER_LITERAL . (simple_statement . 3)) (ACCEPT . 
(simple_statement . 3)) (ABORT . (simple_statement . 3)) (BEGIN . 
(simple_statement . 3)) (CASE . (simple_statement . 3)) (DECLARE .  [...]
-      ((default . error) (ELSIF . (sequence_of_statements_opt . 0)) (ELSE . 
(sequence_of_statements_opt . 0)) (END . (sequence_of_statements_opt . 0)) 
(ACCEPT . (label_opt . 0)) (BEGIN . (label_opt . 0)) (CASE . (label_opt . 0)) 
(DECLARE . (label_opt . 0)) (FOR . (label_opt . 0)) (IF . (label_opt . 0)) 
(LOOP . (label_opt . 0)) (RETURN . (label_opt . 0)) (SELECT . (label_opt . 0)) 
(WHILE . (label_opt . 0)) (STRING_LITERAL . (label_opt . 0)) (CHARACTER_LITERAL 
. (label_opt . 0)) (ABORT . ( [...]
+      ((default . error) (ELSIF . (sequence_of_statements_opt . 0)) (ELSE . 
(sequence_of_statements_opt . 0)) (END . (sequence_of_statements_opt . 0)) 
(ACCEPT . (label_opt . 0)) (BEGIN . (label_opt . 0)) (CASE . (label_opt . 0)) 
(DECLARE . (label_opt . 0)) (FOR . (label_opt . 0)) (IF . (label_opt . 0)) 
(LOOP . (label_opt . 0)) (RETURN . (label_opt . 0)) (SELECT . (label_opt . 0)) 
(WHILE . (label_opt . 0)) (STRING_LITERAL . (label_opt . 0)) (CHARACTER_LITERAL 
. (label_opt . 0)) (ABORT . ( [...]
       ((default . error) (LOOP .  955))
       ((default . error) (OR . (raise_statement . 2)) (THEN . (raise_statement 
. 2)) (WHEN . (raise_statement . 2)) (EXCEPTION . (raise_statement . 2)) (END . 
(raise_statement . 2)) (LESS_LESS . (raise_statement . 2)) (IDENTIFIER . 
(raise_statement . 2)) (STRING_LITERAL . (raise_statement . 2)) 
(CHARACTER_LITERAL . (raise_statement . 2)) (ACCEPT . (raise_statement . 2)) 
(ABORT . (raise_statement . 2)) (BEGIN . (raise_statement . 2)) (CASE . 
(raise_statement . 2)) (DECLARE . (raise_statem [...]
       ((default . error) (PLUS .  144) (MINUS .  143) (ABS .  146) (NOT .  
149) (NULL .  150) (NEW .  148) (IDENTIFIER .  48) (CHARACTER_LITERAL .  50) 
(STRING_LITERAL .  49) (LEFT_PAREN .  147))
       ((default . error) (OR . (requeue_statement . 1)) (THEN . 
(requeue_statement . 1)) (WHEN . (requeue_statement . 1)) (EXCEPTION . 
(requeue_statement . 1)) (END . (requeue_statement . 1)) (LESS_LESS . 
(requeue_statement . 1)) (IDENTIFIER . (requeue_statement . 1)) (STRING_LITERAL 
. (requeue_statement . 1)) (CHARACTER_LITERAL . (requeue_statement . 1)) 
(ACCEPT . (requeue_statement . 1)) (ABORT . (requeue_statement . 1)) (BEGIN . 
(requeue_statement . 1)) (CASE . (requeue_statement . 1) [...]
       ((default . error) (ABORT .  953))
-      ((default . error) (END . (sequence_of_statements_opt . 0)) (EXCEPTION . 
(sequence_of_statements_opt . 0)) (ACCEPT . (label_opt . 0)) (BEGIN . 
(label_opt . 0)) (CASE . (label_opt . 0)) (DECLARE . (label_opt . 0)) (FOR . 
(label_opt . 0)) (IF . (label_opt . 0)) (LOOP . (label_opt . 0)) (RETURN . 
(label_opt . 0)) (SELECT . (label_opt . 0)) (WHILE . (label_opt . 0)) 
(STRING_LITERAL . (label_opt . 0)) (CHARACTER_LITERAL . (label_opt . 0)) (ABORT 
. (label_opt . 0)) (DELAY . (label_opt .  [...]
+      ((default . error) (END . (sequence_of_statements_opt . 0)) (EXCEPTION . 
(sequence_of_statements_opt . 0)) (ACCEPT . (label_opt . 0)) (BEGIN . 
(label_opt . 0)) (CASE . (label_opt . 0)) (DECLARE . (label_opt . 0)) (FOR . 
(label_opt . 0)) (IF . (label_opt . 0)) (LOOP . (label_opt . 0)) (RETURN . 
(label_opt . 0)) (SELECT . (label_opt . 0)) (WHILE . (label_opt . 0)) 
(STRING_LITERAL . (label_opt . 0)) (CHARACTER_LITERAL . (label_opt . 0)) (ABORT 
. (label_opt . 0)) (DELAY . (label_opt .  [...]
       ((default . error) (OR . (extended_return_statement . 1)) (THEN . 
(extended_return_statement . 1)) (WHEN . (extended_return_statement . 1)) 
(EXCEPTION . (extended_return_statement . 1)) (END . (extended_return_statement 
. 1)) (LESS_LESS . (extended_return_statement . 1)) (IDENTIFIER . 
(extended_return_statement . 1)) (STRING_LITERAL . (extended_return_statement . 
1)) (CHARACTER_LITERAL . (extended_return_statement . 1)) (ACCEPT . 
(extended_return_statement . 1)) (ABORT . (extended_ [...]
       ((default . error) (OR . (simple_return_statement . 1)) (THEN . 
(simple_return_statement . 1)) (WHEN . (simple_return_statement . 1)) 
(EXCEPTION . (simple_return_statement . 1)) (END . (simple_return_statement . 
1)) (LESS_LESS . (simple_return_statement . 1)) (IDENTIFIER . 
(simple_return_statement . 1)) (STRING_LITERAL . (simple_return_statement . 1)) 
(CHARACTER_LITERAL . (simple_return_statement . 1)) (ACCEPT . 
(simple_return_statement . 1)) (ABORT . (simple_return_statement . 1)) [...]
       ((default . error) (CONSTANT . (aliased_opt . 0)) (IDENTIFIER . 
(aliased_opt . 0)) (STRING_LITERAL . (aliased_opt . 0)) (CHARACTER_LITERAL . 
(aliased_opt . 0)) (ACCESS . (aliased_opt . 0)) (NOT . (aliased_opt . 0)) 
(ALIASED .  512))
       ((default . error) (ABORT .  950))
-      ((default . error) (END . (sequence_of_statements_opt . 0)) (ACCEPT . 
(label_opt . 0)) (BEGIN . (label_opt . 0)) (CASE . (label_opt . 0)) (DECLARE . 
(label_opt . 0)) (FOR . (label_opt . 0)) (IF . (label_opt . 0)) (LOOP . 
(label_opt . 0)) (RETURN . (label_opt . 0)) (SELECT . (label_opt . 0)) (WHILE . 
(label_opt . 0)) (STRING_LITERAL . (label_opt . 0)) (CHARACTER_LITERAL . 
(label_opt . 0)) (ABORT . (label_opt . 0)) (DELAY . (label_opt . 0)) (EXIT . 
(label_opt . 0)) (GOTO . (label_opt [...]
+      ((default . error) (END . (sequence_of_statements_opt . 0)) (ACCEPT . 
(label_opt . 0)) (BEGIN . (label_opt . 0)) (CASE . (label_opt . 0)) (DECLARE . 
(label_opt . 0)) (FOR . (label_opt . 0)) (IF . (label_opt . 0)) (LOOP . 
(label_opt . 0)) (RETURN . (label_opt . 0)) (SELECT . (label_opt . 0)) (WHILE . 
(label_opt . 0)) (STRING_LITERAL . (label_opt . 0)) (CHARACTER_LITERAL . 
(label_opt . 0)) (ABORT . (label_opt . 0)) (DELAY . (label_opt . 0)) (EXIT . 
(label_opt . 0)) (GOTO . (label_opt [...]
       ((default . error) (SELECT .  948))
-      ((default . error) (WHEN .  670) (TERMINATE .  669) (ACCEPT .  613) 
(DELAY .  618))
+      ((default . error) (WHEN .  669) (TERMINATE .  668) (ACCEPT .  612) 
(DELAY .  617))
       ((default . error) (OR . (entry_call_alternative . 0)) (ELSE . 
(entry_call_alternative . 0)) (THEN . (triggering_alternative . 0)))
       ((default . error) (OR . (entry_call_alternative . 1)) (ELSE . 
(entry_call_alternative . 1)) (THEN . (triggering_alternative . 1)))
-      ((default . error) (END . (sequence_of_statements_opt . 0)) (ACCEPT . 
(label_opt . 0)) (BEGIN . (label_opt . 0)) (CASE . (label_opt . 0)) (DECLARE . 
(label_opt . 0)) (FOR . (label_opt . 0)) (IF . (label_opt . 0)) (LOOP . 
(label_opt . 0)) (RETURN . (label_opt . 0)) (SELECT . (label_opt . 0)) (WHILE . 
(label_opt . 0)) (STRING_LITERAL . (label_opt . 0)) (CHARACTER_LITERAL . 
(label_opt . 0)) (ABORT . (label_opt . 0)) (DELAY . (label_opt . 0)) (EXIT . 
(label_opt . 0)) (GOTO . (label_opt [...]
-      ((default . error) (DELAY .  618))
+      ((default . error) (END . (sequence_of_statements_opt . 0)) (ACCEPT . 
(label_opt . 0)) (BEGIN . (label_opt . 0)) (CASE . (label_opt . 0)) (DECLARE . 
(label_opt . 0)) (FOR . (label_opt . 0)) (IF . (label_opt . 0)) (LOOP . 
(label_opt . 0)) (RETURN . (label_opt . 0)) (SELECT . (label_opt . 0)) (WHILE . 
(label_opt . 0)) (STRING_LITERAL . (label_opt . 0)) (CHARACTER_LITERAL . 
(label_opt . 0)) (ABORT . (label_opt . 0)) (DELAY . (label_opt . 0)) (EXIT . 
(label_opt . 0)) (GOTO . (label_opt [...]
+      ((default . error) (DELAY .  617))
       ((default . error) (OR . (delay_alternative . 0)) (END . 
(delay_alternative . 0)) (ELSE . (delay_alternative . 0)) (THEN . 
(triggering_alternative . 2)))
       ((default . error) (END . (select_alternative . 1)) (OR . 
(select_alternative . 1)) (ELSE . (select_alternative . 1)))
       ((default . error) (EQUAL_GREATER .  943))
@@ -2632,19 +2680,19 @@
       ((default . error) (WHEN . (assignment_statement . 0)) (THEN . 
(assignment_statement . 0)) (OR . (assignment_statement . 0)) (ELSIF . 
(assignment_statement . 0)) (ELSE . (assignment_statement . 0)) (WHILE . 
(assignment_statement . 0)) (SELECT . (assignment_statement . 0)) (RETURN . 
(assignment_statement . 0)) (REQUEUE . (assignment_statement . 0)) (RAISE . 
(assignment_statement . 0)) (PRAGMA . (assignment_statement . 0)) (NULL . 
(assignment_statement . 0)) (LOOP . (assignment_state [...]
       ((default . error) (LOOP .  1165))
       ((default . error) (TYPE . (subprogram_body . 0)) (TASK . 
(subprogram_body . 0)) (SUBTYPE . (subprogram_body . 0)) (PROTECTED . 
(subprogram_body . 0)) (FOR . (subprogram_body . 0)) (ENTRY . (subprogram_body 
. 0)) (IDENTIFIER . (subprogram_body . 0)) (BEGIN . (subprogram_body . 0)) (END 
. (subprogram_body . 0)) ($EOI . (subprogram_body . 0)) (FUNCTION . 
(subprogram_body . 0)) (GENERIC . (subprogram_body . 0)) (LIMITED . 
(subprogram_body . 0)) (NOT . (subprogram_body . 0)) (OVERRIDIN [...]
-      ((default . error) (TERMINATE .  1162) (ACCEPT .  613) (DELAY .  618))
+      ((default . error) (TERMINATE .  1162) (ACCEPT .  612) (DELAY .  617))
       ((default . error) (END .  1161))
-      ((default . error) (END . (sequence_of_statements_opt . 0)) (OR . 
(sequence_of_statements_opt . 0)) (ELSE . (sequence_of_statements_opt . 0)) 
(ACCEPT . (label_opt . 0)) (BEGIN . (label_opt . 0)) (CASE . (label_opt . 0)) 
(DECLARE . (label_opt . 0)) (FOR . (label_opt . 0)) (IF . (label_opt . 0)) 
(LOOP . (label_opt . 0)) (RETURN . (label_opt . 0)) (SELECT . (label_opt . 0)) 
(WHILE . (label_opt . 0)) (STRING_LITERAL . (label_opt . 0)) (CHARACTER_LITERAL 
. (label_opt . 0)) (ABORT . (lab [...]
+      ((default . error) (END . (sequence_of_statements_opt . 0)) (OR . 
(sequence_of_statements_opt . 0)) (ELSE . (sequence_of_statements_opt . 0)) 
(ACCEPT . (label_opt . 0)) (BEGIN . (label_opt . 0)) (CASE . (label_opt . 0)) 
(DECLARE . (label_opt . 0)) (FOR . (label_opt . 0)) (IF . (label_opt . 0)) 
(LOOP . (label_opt . 0)) (RETURN . (label_opt . 0)) (SELECT . (label_opt . 0)) 
(WHILE . (label_opt . 0)) (STRING_LITERAL . (label_opt . 0)) (CHARACTER_LITERAL 
. (label_opt . 0)) (ABORT . (lab [...]
       ((default . error) (END .  1159))
       ((default . error) (ELSE . (select_alternative_list . 1)) (END . 
(select_alternative_list . 1)) (OR . (select_alternative_list . 1)))
       ((default . error) (SEMICOLON .  1158))
       ((default . error) (END .  1157))
-      ((default . error) (END . (sequence_of_statements_opt . 0)) (ACCEPT . 
(label_opt . 0)) (BEGIN . (label_opt . 0)) (CASE . (label_opt . 0)) (DECLARE . 
(label_opt . 0)) (FOR . (label_opt . 0)) (IF . (label_opt . 0)) (LOOP . 
(label_opt . 0)) (RETURN . (label_opt . 0)) (SELECT . (label_opt . 0)) (WHILE . 
(label_opt . 0)) (STRING_LITERAL . (label_opt . 0)) (CHARACTER_LITERAL . 
(label_opt . 0)) (ABORT . (label_opt . 0)) (DELAY . (label_opt . 0)) (EXIT . 
(label_opt . 0)) (GOTO . (label_opt [...]
-      ((default . error) (IDENTIFIER . (constant_opt . 0)) (STRING_LITERAL . 
(constant_opt . 0)) (CHARACTER_LITERAL . (constant_opt . 0)) (ACCESS . 
(constant_opt . 0)) (NOT . (constant_opt . 0)) (CONSTANT .  726))
+      ((default . error) (END . (sequence_of_statements_opt . 0)) (ACCEPT . 
(label_opt . 0)) (BEGIN . (label_opt . 0)) (CASE . (label_opt . 0)) (DECLARE . 
(label_opt . 0)) (FOR . (label_opt . 0)) (IF . (label_opt . 0)) (LOOP . 
(label_opt . 0)) (RETURN . (label_opt . 0)) (SELECT . (label_opt . 0)) (WHILE . 
(label_opt . 0)) (STRING_LITERAL . (label_opt . 0)) (CHARACTER_LITERAL . 
(label_opt . 0)) (ABORT . (label_opt . 0)) (DELAY . (label_opt . 0)) (EXIT . 
(label_opt . 0)) (GOTO . (label_opt [...]
+      ((default . error) (IDENTIFIER . (constant_opt . 0)) (STRING_LITERAL . 
(constant_opt . 0)) (CHARACTER_LITERAL . (constant_opt . 0)) (ACCESS . 
(constant_opt . 0)) (NOT . (constant_opt . 0)) (CONSTANT .  725))
       ((default . error) (END .  1154))
       ((default . error) (SEMICOLON .  1153))
       ((default . error) (SEMICOLON .  1152))
-      ((default . error) (SEMICOLON . (identifier_opt . 0)) (IDENTIFIER .  
695))
+      ((default . error) (SEMICOLON . (identifier_opt . 0)) (IDENTIFIER .  
694))
       ((default . error) (ELSE .  1146) (END .  1148) (ELSIF .  1147))
       ((default . error) (SEMICOLON .  1145))
       ((default . error) (WHEN . (delay_statement . 0)) (ELSIF . 
(delay_statement . 0)) (EXCEPTION . (delay_statement . 0)) (WHILE . 
(delay_statement . 0)) (SELECT . (delay_statement . 0)) (RETURN . 
(delay_statement . 0)) (REQUEUE . (delay_statement . 0)) (RAISE . 
(delay_statement . 0)) (PRAGMA . (delay_statement . 0)) (NULL . 
(delay_statement . 0)) (LOOP . (delay_statement . 0)) (IF . (delay_statement . 
0)) (GOTO . (delay_statement . 0)) (FOR . (delay_statement . 0)) (EXIT . 
(delay_stat [...]
@@ -2674,7 +2722,7 @@
       ((default . error) (PLUS .  144) (MINUS .  143) (ABS .  146) (NOT .  
149) (NULL .  150) (NEW .  148) (IDENTIFIER .  48) (CHARACTER_LITERAL .  50) 
(STRING_LITERAL .  49) (LEFT_PAREN .  147))
       ((default . error) (RIGHT_PAREN . (case_expression_alternative_list . 
1)) (COMMA . (case_expression_alternative_list . 1)))
       ((default . error) (SEMICOLON .  1127))
-      ((default . error) (WITH . (parameter_profile_opt . 0)) (SEMICOLON . 
(parameter_profile_opt . 0)) (LEFT_PAREN .  782))
+      ((default . error) (WITH . (parameter_profile_opt . 0)) (SEMICOLON . 
(parameter_profile_opt . 0)) (LEFT_PAREN .  781))
       ((default . error) (USE . (entry_declaration . 1)) (TYPE . 
(entry_declaration . 1)) (TASK . (entry_declaration . 1)) (SUBTYPE . 
(entry_declaration . 1)) (PROTECTED . (entry_declaration . 1)) (PROCEDURE . 
(entry_declaration . 1)) (PRAGMA . (entry_declaration . 1)) (PACKAGE . 
(entry_declaration . 1)) (OVERRIDING . (entry_declaration . 1)) (NOT . 
(entry_declaration . 1)) (GENERIC . (entry_declaration . 1)) (FUNCTION . 
(entry_declaration . 1)) (FOR . (entry_declaration . 1)) (ENTRY . ( [...]
       ((default . error) (WITH . (paren_expression . 2)) (SEMICOLON . 
(paren_expression . 2)))
       ((default . error) (WITH . (paren_expression . 0)) (SEMICOLON . 
(paren_expression . 0)))
@@ -2695,7 +2743,7 @@
       ((default . error) (SEMICOLON . (aspect_specification_opt . 0)) (WITH .  
108))
       ((default . error) (WITH . (record_type_definition . 0)) (SEMICOLON . 
(record_type_definition . 0)))
       ((default . error) (IDENTIFIER .  48) (CHARACTER_LITERAL .  50) 
(STRING_LITERAL .  49))
-      ((default . error) (NOT .  736) (IDENTIFIER .  48) (CHARACTER_LITERAL .  
50) (STRING_LITERAL .  49))
+      ((default . error) (NOT .  735) (IDENTIFIER .  48) (CHARACTER_LITERAL .  
50) (STRING_LITERAL .  49))
       ((default . error) (BEGIN . (incomplete_type_declaration . 0)) 
(IDENTIFIER . (incomplete_type_declaration . 0)) (ENTRY . 
(incomplete_type_declaration . 0)) (FOR . (incomplete_type_declaration . 0)) 
(FUNCTION . (incomplete_type_declaration . 0)) (GENERIC . 
(incomplete_type_declaration . 0)) (NOT . (incomplete_type_declaration . 0)) 
(OVERRIDING . (incomplete_type_declaration . 0)) (PACKAGE . 
(incomplete_type_declaration . 0)) (PRAGMA . (incomplete_type_declaration . 0)) 
(PROCEDURE .  [...]
       ((default . error) (IS . (direct_name_opt . 0)) (IDENTIFIER .  1112) 
(STRING_LITERAL .  1113))
       ((default . error) (SEMICOLON .  1111))
@@ -2717,7 +2765,7 @@
       ((default . error) (DIGITS .  1100) (WITH . 
(real_range_specification_opt . 0)) (SEMICOLON . (real_range_specification_opt 
. 0)) (RANGE .  1101))
       ((default . error) (NEW . ((abstract_limited_opt . 1) 
(abstract_limited_synchronized_opt . 1))))
       ((default . error) (BEGIN . (single_task_declaration . 1)) (IDENTIFIER . 
(single_task_declaration . 1)) (ENTRY . (single_task_declaration . 1)) (FOR . 
(single_task_declaration . 1)) (FUNCTION . (single_task_declaration . 1)) 
(GENERIC . (single_task_declaration . 1)) (NOT . (single_task_declaration . 1)) 
(OVERRIDING . (single_task_declaration . 1)) (PACKAGE . 
(single_task_declaration . 1)) (PRAGMA . (single_task_declaration . 1)) 
(PROCEDURE . (single_task_declaration . 1)) (PROTECTE [...]
-      ((default . error) (SEMICOLON . (identifier_opt . 0)) (IDENTIFIER .  
695))
+      ((default . error) (SEMICOLON . (identifier_opt . 0)) (IDENTIFIER .  
694))
       ((default . error) (END . (declarative_part_opt . 0)) (USE .  11) 
(SUBTYPE .  292) (PRAGMA .  7) (NOT .  4) (OVERRIDING .  5) (FUNCTION . 
(overriding_indicator_opt . 2)) (PROCEDURE . (overriding_indicator_opt . 2)) 
(ENTRY . (overriding_indicator_opt . 2)) (FOR .  289) (IDENTIFIER .  288) (TYPE 
.  294) (GENERIC .  2) (PROTECTED .  291) (TASK .  293) (PACKAGE .  290))
       ((default . error) (AND .  1061) (WITH .  1097))
       ((default . error) (SEMICOLON .  1096))
@@ -2727,7 +2775,7 @@
       ((default . error) (LOOP . (constraint . 0)) (EQUAL_GREATER . 
(constraint . 0)) (DO . (constraint . 0)) (OF . (constraint . 0)) (AND . 
(constraint . 0)) (SEMICOLON . (constraint . 0)) (WITH . (constraint . 0)) 
(COLON_EQUAL . (constraint . 0)) (RIGHT_PAREN . (constraint . 0)) (COMMA . 
(constraint . 0)))
       ((default . error) (USE . (subtype_declaration . 0)) (TYPE . 
(subtype_declaration . 0)) (TASK . (subtype_declaration . 0)) (SUBTYPE . 
(subtype_declaration . 0)) (PROTECTED . (subtype_declaration . 0)) (PROCEDURE . 
(subtype_declaration . 0)) (PRAGMA . (subtype_declaration . 0)) (PACKAGE . 
(subtype_declaration . 0)) (OVERRIDING . (subtype_declaration . 0)) (NOT . 
(subtype_declaration . 0)) (GENERIC . (subtype_declaration . 0)) (FUNCTION . 
(subtype_declaration . 0)) (FOR . (subtype_de [...]
       ((default . error) (BEGIN . (single_protected_declaration . 1)) 
(IDENTIFIER . (single_protected_declaration . 1)) (ENTRY . 
(single_protected_declaration . 1)) (FOR . (single_protected_declaration . 1)) 
(FUNCTION . (single_protected_declaration . 1)) (GENERIC . 
(single_protected_declaration . 1)) (NOT . (single_protected_declaration . 1)) 
(OVERRIDING . (single_protected_declaration . 1)) (PACKAGE . 
(single_protected_declaration . 1)) (PRAGMA . (single_protected_declaration . 
1)) (PR [...]
-      ((default . error) (SEMICOLON . (identifier_opt . 0)) (IDENTIFIER .  
695))
+      ((default . error) (SEMICOLON . (identifier_opt . 0)) (IDENTIFIER .  
694))
       ((default . error) (END . (declarative_part_opt . 0)) (USE .  11) 
(SUBTYPE .  292) (PRAGMA .  7) (NOT .  4) (OVERRIDING .  5) (FUNCTION . 
(overriding_indicator_opt . 2)) (PROCEDURE . (overriding_indicator_opt . 2)) 
(ENTRY . (overriding_indicator_opt . 2)) (FOR .  289) (IDENTIFIER .  288) (TYPE 
.  294) (GENERIC .  2) (PROTECTED .  291) (TASK .  293) (PACKAGE .  290))
       ((default . error) (AND .  1061) (WITH .  1090))
       ((default . error) (SEMICOLON .  1089))
@@ -2751,14 +2799,14 @@
       ((default . error) (COMMA .  809) (RIGHT_PAREN .  1071))
       ((default . error) (COMMA . (discrete_subtype_definition . 1)) (BAR . 
(discrete_choice . 2)) (EQUAL_GREATER . (discrete_choice . 2)) (RIGHT_PAREN . 
((discrete_subtype_definition . 1)  260)))
       ((default . error) (IDENTIFIER .  48) (CHARACTER_LITERAL .  50) 
(STRING_LITERAL .  49))
-      ((default . error) (SEMICOLON . (formal_derived_type_definition . 1)) 
(WITH . (formal_derived_type_definition . 1)))
-      ((default . error) (SEMICOLON . (formal_derived_type_definition . 2)) 
(AND .  1061) (WITH . ((formal_derived_type_definition . 2)  1069)))
+      ((default . error) (PRIVATE .  1069))
+      ((default . error) (AND .  1061) (WITH . (and_interface_list_opt . 1)) 
(SEMICOLON . (and_interface_list_opt . 1)))
       ((default . error) (WITH . (formal_package_actual_part . 0)) (SEMICOLON 
. (formal_package_actual_part . 0)))
       ((default . error) (PACKAGE . (formal_package_declaration . 0)) 
(PROCEDURE . (formal_package_declaration . 0)) (FUNCTION . 
(formal_package_declaration . 0)) (IDENTIFIER . (formal_package_declaration . 
0)) (PRAGMA . (formal_package_declaration . 0)) (TYPE . 
(formal_package_declaration . 0)) (WITH . (formal_package_declaration . 0)))
       ((default . error) (PACKAGE . (formal_object_declaration . 0)) 
(PROCEDURE . (formal_object_declaration . 0)) (FUNCTION . 
(formal_object_declaration . 0)) (IDENTIFIER . (formal_object_declaration . 0)) 
(PRAGMA . (formal_object_declaration . 0)) (TYPE . (formal_object_declaration . 
0)) (WITH . (formal_object_declaration . 0)))
       ((default . error) (PLUS .  144) (MINUS .  143) (ABS .  146) (NOT .  
149) (NULL .  150) (NEW .  148) (IDENTIFIER .  48) (CHARACTER_LITERAL .  50) 
(STRING_LITERAL .  49) (LEFT_PAREN .  147))
       ((default . error) (RIGHT_PAREN . (parameter_specification . 0)) 
(SEMICOLON . (parameter_specification . 0)))
-      ((default . error) (PRIVATE .  1233))
+      ((default . error) (WITH . (formal_derived_type_definition . 0)) 
(SEMICOLON . (formal_derived_type_definition . 0)))
       ((default . error) (DOT .  87) (TICK .  88) (WITH . (interface_list . 
1)) (SEMICOLON . (interface_list . 1)) (AND . (interface_list . 1)) (LEFT_PAREN 
.  106))
       ((default . error) (LOOP . (index_constraint . 0)) (DO . 
(index_constraint . 0)) (EQUAL_GREATER . (index_constraint . 0)) (COMMA . 
(index_constraint . 0)) (RIGHT_PAREN . (index_constraint . 0)) (COLON_EQUAL . 
(index_constraint . 0)) (WITH . (index_constraint . 0)) (SEMICOLON . 
(index_constraint . 0)) (AND . (index_constraint . 0)) (OF . (index_constraint 
. 0)))
       ((default . error) (PLUS . (primary . 0)) (MINUS . (primary . 0)) 
(AMPERSAND . (primary . 0)) (DOT_DOT . (primary . 0)) (SLASH . (primary . 0)) 
(STAR . (primary . 0)) (MOD . (primary . 0)) (REM . (primary . 0)) (XOR . 
(primary . 0)) (OR . (primary . 0)) (AND . (primary . 0)) (EQUAL_GREATER . 
(primary . 0)) (BAR . (primary . 0)) (IN . (primary . 0)) (NOT . (primary . 0)) 
(EQUAL . (primary . 0)) (GREATER . (primary . 0)) (GREATER_EQUAL . (primary . 
0)) (LESS . (primary . 0)) (LESS_EQ [...]
@@ -2770,24 +2818,24 @@
       ((default . error) (WITH . (array_type_definition . 1)) (SEMICOLON . 
(array_type_definition . 1)) (COLON_EQUAL . (array_type_definition . 1)))
       ((default . error) (END . (object_renaming_declaration . 2)) (PRIVATE . 
(object_renaming_declaration . 2)) (USE . (object_renaming_declaration . 2)) 
(TYPE . (object_renaming_declaration . 2)) (TASK . (object_renaming_declaration 
. 2)) (SUBTYPE . (object_renaming_declaration . 2)) (PROTECTED . 
(object_renaming_declaration . 2)) (PROCEDURE . (object_renaming_declaration . 
2)) (PRAGMA . (object_renaming_declaration . 2)) (PACKAGE . 
(object_renaming_declaration . 2)) (OVERRIDING . (obj [...]
       ((default . error) (END . (object_renaming_declaration . 1)) (PRIVATE . 
(object_renaming_declaration . 1)) (USE . (object_renaming_declaration . 1)) 
(TYPE . (object_renaming_declaration . 1)) (TASK . (object_renaming_declaration 
. 1)) (SUBTYPE . (object_renaming_declaration . 1)) (PROTECTED . 
(object_renaming_declaration . 1)) (PROCEDURE . (object_renaming_declaration . 
1)) (PRAGMA . (object_renaming_declaration . 1)) (PACKAGE . 
(object_renaming_declaration . 1)) (OVERRIDING . (obj [...]
-      ((default . error) (SEMICOLON .  1229))
       ((default . error) (SEMICOLON .  1228))
-      ((default . error) (RECORD .  1227))
+      ((default . error) (SEMICOLON .  1227))
+      ((default . error) (RECORD .  1226))
       ((default . error) (IDENTIFIER . (component_clause_list . 1)) (END . 
(component_clause_list . 1)))
       ((default . error) (PLUS .  144) (MINUS .  143) (ABS .  146) (NOT .  
149) (NULL .  150) (NEW .  148) (IDENTIFIER .  48) (CHARACTER_LITERAL .  50) 
(STRING_LITERAL .  49) (LEFT_PAREN .  147))
       ((default . error) (PRIVATE . (package_body_stub . 0)) (END . 
(package_body_stub . 0)) (BEGIN . (package_body_stub . 0)) (IDENTIFIER . 
(package_body_stub . 0)) (ENTRY . (package_body_stub . 0)) (FOR . 
(package_body_stub . 0)) (FUNCTION . (package_body_stub . 0)) (GENERIC . 
(package_body_stub . 0)) (NOT . (package_body_stub . 0)) (OVERRIDING . 
(package_body_stub . 0)) (PACKAGE . (package_body_stub . 0)) (PRAGMA . 
(package_body_stub . 0)) (PROCEDURE . (package_body_stub . 0)) (PROTEC [...]
       ((default . error) (IDENTIFIER .  48) (CHARACTER_LITERAL .  50) 
(STRING_LITERAL .  49))
-      ((default . error) (SEMICOLON .  1224))
+      ((default . error) (SEMICOLON .  1223))
       ((default . error) (PRIVATE . (protected_body_stub . 0)) (END . 
(protected_body_stub . 0)) (BEGIN . (protected_body_stub . 0)) (IDENTIFIER . 
(protected_body_stub . 0)) (ENTRY . (protected_body_stub . 0)) (FOR . 
(protected_body_stub . 0)) (FUNCTION . (protected_body_stub . 0)) (GENERIC . 
(protected_body_stub . 0)) (NOT . (protected_body_stub . 0)) (OVERRIDING . 
(protected_body_stub . 0)) (PACKAGE . (protected_body_stub . 0)) (PRAGMA . 
(protected_body_stub . 0)) (PROCEDURE . (protect [...]
       ((default . error) (END . (declarative_part_opt . 0)) (PRIVATE . 
(declarative_part_opt . 0)) (USE .  11) (SUBTYPE .  292) (PRAGMA .  7) (NOT .  
4) (OVERRIDING .  5) (FUNCTION . (overriding_indicator_opt . 2)) (PROCEDURE . 
(overriding_indicator_opt . 2)) (ENTRY . (overriding_indicator_opt . 2)) (FOR . 
 289) (IDENTIFIER .  288) (TYPE .  294) (GENERIC .  2) (PROTECTED .  291) (TASK 
.  293) (PACKAGE .  290))
-      ((default . error) (END .  1222))
+      ((default . error) (END .  1221))
       ((default . error) (SEMICOLON . (protected_definition . 1)))
       ((default . error) (LOOP . (subtype_indication . 0)) (DO . 
(subtype_indication . 0)) (RIGHT_PAREN . (subtype_indication . 0)) (COMMA . 
(subtype_indication . 0)) (EQUAL_GREATER . (subtype_indication . 0)) (WITH . 
(subtype_indication . 0)) (AND . (subtype_indication . 0)) (OF . 
(subtype_indication . 0)) (SEMICOLON . (subtype_indication . 0)) (COLON_EQUAL . 
(subtype_indication . 0)))
       ((default . error) (IDENTIFIER .  48) (CHARACTER_LITERAL .  50) 
(STRING_LITERAL .  49))
-      ((default . error) (SEMICOLON .  1220))
+      ((default . error) (SEMICOLON .  1219))
       ((default . error) (PRIVATE . (task_body_stub . 0)) (END . 
(task_body_stub . 0)) (BEGIN . (task_body_stub . 0)) (IDENTIFIER . 
(task_body_stub . 0)) (ENTRY . (task_body_stub . 0)) (FOR . (task_body_stub . 
0)) (FUNCTION . (task_body_stub . 0)) (GENERIC . (task_body_stub . 0)) (NOT . 
(task_body_stub . 0)) (OVERRIDING . (task_body_stub . 0)) (PACKAGE . 
(task_body_stub . 0)) (PRAGMA . (task_body_stub . 0)) (PROCEDURE . 
(task_body_stub . 0)) (PROTECTED . (task_body_stub . 0)) (SUBTYPE .  [...]
       ((default . error) (END . (declarative_part_opt . 0)) (PRIVATE . 
(declarative_part_opt . 0)) (USE .  11) (SUBTYPE .  292) (PRAGMA .  7) (NOT .  
4) (OVERRIDING .  5) (FUNCTION . (overriding_indicator_opt . 2)) (PROCEDURE . 
(overriding_indicator_opt . 2)) (ENTRY . (overriding_indicator_opt . 2)) (FOR . 
 289) (IDENTIFIER .  288) (TYPE .  294) (GENERIC .  2) (PROTECTED .  291) (TASK 
.  293) (PACKAGE .  290))
-      ((default . error) (END .  1218))
+      ((default . error) (END .  1217))
       ((default . error) (SEMICOLON . (task_definition . 1)))
       ((default . error) (PLUS .  144) (MINUS .  143) (ABS .  146) (NOT .  
149) (NULL .  150) (NEW .  148) (IDENTIFIER .  48) (CHARACTER_LITERAL .  50) 
(STRING_LITERAL .  49) (LEFT_PAREN .  147))
       ((default . error) (PLUS .  144) (MINUS .  143) (ABS .  146) (NOT .  
149) (NULL .  150) (NEW .  148) (IDENTIFIER .  48) (CHARACTER_LITERAL .  50) 
(STRING_LITERAL .  49) (LEFT_PAREN .  147))
@@ -2797,16 +2845,16 @@
       ((default . error) (SEMICOLON . (enumeration_type_definition . 0)) (WITH 
. (enumeration_type_definition . 0)))
       ((default . error) (PLUS .  144) (MINUS .  143) (ABS .  146) (NOT .  
149) (NULL .  150) (NEW .  148) (IDENTIFIER .  48) (CHARACTER_LITERAL .  50) 
(STRING_LITERAL .  49) (LEFT_PAREN .  147))
       ((default . error) (ALIASED .  1074) (IDENTIFIER .  48) 
(CHARACTER_LITERAL .  50) (STRING_LITERAL .  49) (ACCESS . (null_exclusion_opt 
. 0)) (NOT .  862))
-      ((default . error) (RECORD .  1212))
+      ((default . error) (RECORD .  1211))
       ((default . error) (WHEN . (component_list . 1)) (FOR . (component_list 
. 1)) (IDENTIFIER . (component_list . 1)) (CASE . (component_list . 1)) (END . 
(component_list . 1)))
       ((default . error) (WHEN . (component_list . 2)) (FOR . (component_list 
. 2)) (IDENTIFIER . (component_list . 2)) (CASE . (component_list . 2)) (END . 
(component_list . 2)))
       ((default . error) (WHEN . (component_list . 4)) (FOR . (component_list 
. 4)) (IDENTIFIER . (component_list . 4)) (CASE . (component_list . 4)) (END . 
(component_list . 4)))
       ((default . error) (IS . (direct_name . 0)))
       ((default . error) (IS . (direct_name . 1)))
       ((default . error) (IS . (direct_name_opt . 1)))
-      ((default . error) (IS .  1211))
-      ((default . error) (WITH . (and_interface_list_opt . 0)) (AND .  1206))
-      ((default . error) (DOT .  87) (TICK .  88) (AND .  1206) (WITH . 
((and_interface_list_opt . 0) (constraint_opt . 0))) (SEMICOLON . 
(constraint_opt . 0)) (RANGE .  833) (LEFT_PAREN .  803))
+      ((default . error) (IS .  1210))
+      ((default . error) (WITH . (and_interface_list_opt . 0)) (AND .  795))
+      ((default . error) (DOT .  87) (TICK .  88) (AND .  795) (WITH . 
((and_interface_list_opt . 0) (constraint_opt . 0))) (SEMICOLON . 
(constraint_opt . 0)) (RANGE .  833) (LEFT_PAREN .  803))
       ((default . error) (SEMICOLON .  1205))
       ((default . error) (END . (full_type_declaration . 0)) (PRIVATE . 
(full_type_declaration . 0)) (USE . (full_type_declaration . 0)) (TYPE . 
(full_type_declaration . 0)) (TASK . (full_type_declaration . 0)) (SUBTYPE . 
(full_type_declaration . 0)) (PROTECTED . (full_type_declaration . 0)) 
(PROCEDURE . (full_type_declaration . 0)) (PRAGMA . (full_type_declaration . 
0)) (PACKAGE . (full_type_declaration . 0)) (OVERRIDING . 
(full_type_declaration . 0)) (NOT . (full_type_declaration . 0)) [...]
       ((default . error) (PRIVATE . (object_declaration . 3)) (END . 
(object_declaration . 3)) (BEGIN . (object_declaration . 3)) (IDENTIFIER . 
(object_declaration . 3)) (ENTRY . (object_declaration . 3)) (FOR . 
(object_declaration . 3)) (FUNCTION . (object_declaration . 3)) (GENERIC . 
(object_declaration . 3)) (NOT . (object_declaration . 3)) (OVERRIDING . 
(object_declaration . 3)) (PACKAGE . (object_declaration . 3)) (PRAGMA . 
(object_declaration . 3)) (PROCEDURE . (object_declaration  [...]
@@ -2822,20 +2870,20 @@
       ((default . error) (DOT .  87) (TICK .  88) (LOOP . 
(iterator_specification . 3)) (EQUAL_GREATER . (iterator_specification . 3)) 
(LEFT_PAREN .  106))
       ((default . error) (PLUS .  144) (MINUS .  143) (ABS .  146) (NOT .  
149) (NULL .  150) (NEW .  148) (IDENTIFIER .  48) (CHARACTER_LITERAL .  50) 
(STRING_LITERAL .  49) (LEFT_PAREN .  147))
       ((default . error) (RIGHT_PAREN . (if_expression . 0)))
-      ((default . error) (SEMICOLON . (identifier_opt . 0)) (IDENTIFIER .  
695))
+      ((default . error) (SEMICOLON . (identifier_opt . 0)) (IDENTIFIER .  
694))
       ((default . error) (PROCEDURE . (protected_operation_item_list . 1)) 
(OVERRIDING . (protected_operation_item_list . 1)) (NOT . 
(protected_operation_item_list . 1)) (FUNCTION . (protected_operation_item_list 
. 1)) (FOR . (protected_operation_item_list . 1)) (ENTRY . 
(protected_operation_item_list . 1)) (END . (protected_operation_item_list . 
1)))
       ((default . error) (SEMICOLON . (aspect_specification_opt . 0)) (IS . 
(aspect_specification_opt . 0)) (WITH .  108))
       ((default . error) (WHEN . (parameter_profile_opt . 0)) (LEFT_PAREN .  
1195))
-      ((default . error) (END . (sequence_of_statements_opt . 0)) (EXCEPTION . 
(sequence_of_statements_opt . 0)) (ACCEPT . (label_opt . 0)) (BEGIN . 
(label_opt . 0)) (CASE . (label_opt . 0)) (DECLARE . (label_opt . 0)) (FOR . 
(label_opt . 0)) (IF . (label_opt . 0)) (LOOP . (label_opt . 0)) (RETURN . 
(label_opt . 0)) (SELECT . (label_opt . 0)) (WHILE . (label_opt . 0)) 
(STRING_LITERAL . (label_opt . 0)) (CHARACTER_LITERAL . (label_opt . 0)) (ABORT 
. (label_opt . 0)) (DELAY . (label_opt .  [...]
+      ((default . error) (END . (sequence_of_statements_opt . 0)) (EXCEPTION . 
(sequence_of_statements_opt . 0)) (ACCEPT . (label_opt . 0)) (BEGIN . 
(label_opt . 0)) (CASE . (label_opt . 0)) (DECLARE . (label_opt . 0)) (FOR . 
(label_opt . 0)) (IF . (label_opt . 0)) (LOOP . (label_opt . 0)) (RETURN . 
(label_opt . 0)) (SELECT . (label_opt . 0)) (WHILE . (label_opt . 0)) 
(STRING_LITERAL . (label_opt . 0)) (CHARACTER_LITERAL . (label_opt . 0)) (ABORT 
. (label_opt . 0)) (DELAY . (label_opt .  [...]
       ((default . error) (THEN . (accept_statement . 1)) (WHEN . 
(accept_statement . 1)) (EXCEPTION . (accept_statement . 1)) (ELSIF . 
(accept_statement . 1)) (ELSE . (accept_statement . 1)) (OR . (accept_statement 
. 1)) (END . (accept_statement . 1)) (LESS_LESS . (accept_statement . 1)) 
(IDENTIFIER . (accept_statement . 1)) (STRING_LITERAL . (accept_statement . 1)) 
(CHARACTER_LITERAL . (accept_statement . 1)) (ACCEPT . (accept_statement . 1)) 
(ABORT . (accept_statement . 1)) (BEGIN . (a [...]
-      ((default . error) (END . (sequence_of_statements_opt . 0)) (EXCEPTION . 
(sequence_of_statements_opt . 0)) (ACCEPT . (label_opt . 0)) (BEGIN . 
(label_opt . 0)) (CASE . (label_opt . 0)) (DECLARE . (label_opt . 0)) (FOR . 
(label_opt . 0)) (IF . (label_opt . 0)) (LOOP . (label_opt . 0)) (RETURN . 
(label_opt . 0)) (SELECT . (label_opt . 0)) (WHILE . (label_opt . 0)) 
(STRING_LITERAL . (label_opt . 0)) (CHARACTER_LITERAL . (label_opt . 0)) (ABORT 
. (label_opt . 0)) (DELAY . (label_opt .  [...]
+      ((default . error) (END . (sequence_of_statements_opt . 0)) (EXCEPTION . 
(sequence_of_statements_opt . 0)) (ACCEPT . (label_opt . 0)) (BEGIN . 
(label_opt . 0)) (CASE . (label_opt . 0)) (DECLARE . (label_opt . 0)) (FOR . 
(label_opt . 0)) (IF . (label_opt . 0)) (LOOP . (label_opt . 0)) (RETURN . 
(label_opt . 0)) (SELECT . (label_opt . 0)) (WHILE . (label_opt . 0)) 
(STRING_LITERAL . (label_opt . 0)) (CHARACTER_LITERAL . (label_opt . 0)) (ABORT 
. (label_opt . 0)) (DELAY . (label_opt .  [...]
       ((default . error) (OR . (block_statement . 1)) (THEN . (block_statement 
. 1)) (WHEN . (block_statement . 1)) (EXCEPTION . (block_statement . 1)) (END . 
(block_statement . 1)) (LESS_LESS . (block_statement . 1)) (IDENTIFIER . 
(block_statement . 1)) (STRING_LITERAL . (block_statement . 1)) 
(CHARACTER_LITERAL . (block_statement . 1)) (ACCEPT . (block_statement . 1)) 
(ABORT . (block_statement . 1)) (BEGIN . (block_statement . 1)) (CASE . 
(block_statement . 1)) (DECLARE . (block_statem [...]
       ((default . error) (CASE .  1192))
       ((default . error) (WHEN . (case_statement_alternative_list . 1)) (END . 
(case_statement_alternative_list . 1)))
       ((default . error) (BAR .  275) (EQUAL_GREATER .  1191))
-      ((default . error) (SEMICOLON . (identifier_opt . 0)) (IDENTIFIER .  
695))
+      ((default . error) (SEMICOLON . (identifier_opt . 0)) (IDENTIFIER .  
694))
       ((default . error) (OR . (exit_statement . 0)) (THEN . (exit_statement . 
0)) (WHEN . (exit_statement . 0)) (EXCEPTION . (exit_statement . 0)) (END . 
(exit_statement . 0)) (LESS_LESS . (exit_statement . 0)) (IDENTIFIER . 
(exit_statement . 0)) (STRING_LITERAL . (exit_statement . 0)) 
(CHARACTER_LITERAL . (exit_statement . 0)) (ACCEPT . (exit_statement . 0)) 
(ABORT . (exit_statement . 0)) (BEGIN . (exit_statement . 0)) (CASE . 
(exit_statement . 0)) (DECLARE . (exit_statement . 0)) (DEL [...]
-      ((default . error) (END . (sequence_of_statements_opt . 0)) (ACCEPT . 
(label_opt . 0)) (BEGIN . (label_opt . 0)) (CASE . (label_opt . 0)) (DECLARE . 
(label_opt . 0)) (FOR . (label_opt . 0)) (IF . (label_opt . 0)) (LOOP . 
(label_opt . 0)) (RETURN . (label_opt . 0)) (SELECT . (label_opt . 0)) (WHILE . 
(label_opt . 0)) (STRING_LITERAL . (label_opt . 0)) (CHARACTER_LITERAL . 
(label_opt . 0)) (ABORT . (label_opt . 0)) (DELAY . (label_opt . 0)) (EXIT . 
(label_opt . 0)) (GOTO . (label_opt [...]
+      ((default . error) (END . (sequence_of_statements_opt . 0)) (ACCEPT . 
(label_opt . 0)) (BEGIN . (label_opt . 0)) (CASE . (label_opt . 0)) (DECLARE . 
(label_opt . 0)) (FOR . (label_opt . 0)) (IF . (label_opt . 0)) (LOOP . 
(label_opt . 0)) (RETURN . (label_opt . 0)) (SELECT . (label_opt . 0)) (WHILE . 
(label_opt . 0)) (STRING_LITERAL . (label_opt . 0)) (CHARACTER_LITERAL . 
(label_opt . 0)) (ABORT . (label_opt . 0)) (DELAY . (label_opt . 0)) (EXIT . 
(label_opt . 0)) (GOTO . (label_opt [...]
       ((default . error) (THEN . (expression_opt . 0)) (PLUS .  144) (MINUS .  
143) (ABS .  146) (NOT .  149) (NULL .  150) (NEW .  148) (IDENTIFIER .  48) 
(CHARACTER_LITERAL .  50) (STRING_LITERAL .  49) (LEFT_PAREN .  147))
       ((default . error) (IF .  1187))
       ((default . error) (END . (elsif_statement_list . 0)) (ELSE . 
(elsif_statement_list . 0)) (ELSIF . (elsif_statement_list . 0)))
@@ -2852,77 +2900,75 @@
       ((default . error) (END . (delay_alternative . 0)) (OR . 
(delay_alternative . 0)) (ELSE . (delay_alternative . 0)))
       ((default . error) (SELECT .  1175))
       ((default . error) (SEMICOLON .  1174))
-      ((default . error) (ELSE . (sequence_of_statements_opt . 0)) (OR . 
(sequence_of_statements_opt . 0)) (END . (sequence_of_statements_opt . 0)) 
(ACCEPT . (label_opt . 0)) (BEGIN . (label_opt . 0)) (CASE . (label_opt . 0)) 
(DECLARE . (label_opt . 0)) (FOR . (label_opt . 0)) (IF . (label_opt . 0)) 
(LOOP . (label_opt . 0)) (RETURN . (label_opt . 0)) (SELECT . (label_opt . 0)) 
(WHILE . (label_opt . 0)) (STRING_LITERAL . (label_opt . 0)) (CHARACTER_LITERAL 
. (label_opt . 0)) (ABORT . (lab [...]
+      ((default . error) (ELSE . (sequence_of_statements_opt . 0)) (OR . 
(sequence_of_statements_opt . 0)) (END . (sequence_of_statements_opt . 0)) 
(ACCEPT . (label_opt . 0)) (BEGIN . (label_opt . 0)) (CASE . (label_opt . 0)) 
(DECLARE . (label_opt . 0)) (FOR . (label_opt . 0)) (IF . (label_opt . 0)) 
(LOOP . (label_opt . 0)) (RETURN . (label_opt . 0)) (SELECT . (label_opt . 0)) 
(WHILE . (label_opt . 0)) (STRING_LITERAL . (label_opt . 0)) (CHARACTER_LITERAL 
. (label_opt . 0)) (ABORT . (lab [...]
       ((default . error) (END . (select_alternative . 2)) (OR . 
(select_alternative . 2)) (ELSE . (select_alternative . 2)))
-      ((default . error) (SEMICOLON . (identifier_opt . 0)) (IDENTIFIER .  
695))
+      ((default . error) (SEMICOLON . (identifier_opt . 0)) (IDENTIFIER .  
694))
       ((default . error) (OTHERS .  936) (IDENTIFIER .  48) (CHARACTER_LITERAL 
.  50) (STRING_LITERAL .  49))
-      ((default . error) (WHEN . (sequence_of_statements_opt . 0)) (END . 
(sequence_of_statements_opt . 0)) (ACCEPT . (label_opt . 0)) (BEGIN . 
(label_opt . 0)) (CASE . (label_opt . 0)) (DECLARE . (label_opt . 0)) (FOR . 
(label_opt . 0)) (IF . (label_opt . 0)) (LOOP . (label_opt . 0)) (RETURN . 
(label_opt . 0)) (SELECT . (label_opt . 0)) (WHILE . (label_opt . 0)) 
(STRING_LITERAL . (label_opt . 0)) (CHARACTER_LITERAL . (label_opt . 0)) (ABORT 
. (label_opt . 0)) (DELAY . (label_opt . 0)) ( [...]
+      ((default . error) (WHEN . (sequence_of_statements_opt . 0)) (END . 
(sequence_of_statements_opt . 0)) (ACCEPT . (label_opt . 0)) (BEGIN . 
(label_opt . 0)) (CASE . (label_opt . 0)) (DECLARE . (label_opt . 0)) (FOR . 
(label_opt . 0)) (IF . (label_opt . 0)) (LOOP . (label_opt . 0)) (RETURN . 
(label_opt . 0)) (SELECT . (label_opt . 0)) (WHILE . (label_opt . 0)) 
(STRING_LITERAL . (label_opt . 0)) (CHARACTER_LITERAL . (label_opt . 0)) (ABORT 
. (label_opt . 0)) (DELAY . (label_opt . 0)) ( [...]
       ((default . error) (OTHERS .  936) (IDENTIFIER .  48) (CHARACTER_LITERAL 
.  50) (STRING_LITERAL .  49))
-      ((default . error) (BAR .  1166) (EQUAL_GREATER .  1275))
+      ((default . error) (BAR .  1166) (EQUAL_GREATER .  1272))
       ((default . error) (WHEN . (exception_handler . 1)) (END . 
(exception_handler . 1)))
       ((default . error) (EQUAL_GREATER . (exception_choice_list . 1)) (BAR . 
(exception_choice_list . 1)))
-      ((default . error) (SEMICOLON .  1274))
+      ((default . error) (SEMICOLON .  1271))
       ((default . error) (ELSE . (select_alternative . 0)) (OR . 
(select_alternative . 0)) (END . (select_alternative . 0)))
       ((default . error) (ELSE . (select_alternative . 4)) (OR . 
(select_alternative . 4)) (END . (select_alternative . 4)))
-      ((default . error) (SEMICOLON .  1273))
-      ((default . error) (SEMICOLON .  1272))
-      ((default . error) (SEMICOLON .  1271))
-      ((default . error) (SELECT .  1270))
+      ((default . error) (SEMICOLON .  1270))
+      ((default . error) (SEMICOLON .  1269))
+      ((default . error) (SEMICOLON .  1268))
+      ((default . error) (SELECT .  1267))
       ((default . error) (DO . (return_subtype_indication . 1)) (SEMICOLON . 
(return_subtype_indication . 1)) (COLON_EQUAL . (return_subtype_indication . 
1)))
-      ((default . error) (DO . (extended_return_object_declaration . 1)) 
(SEMICOLON . (extended_return_object_declaration . 1)) (COLON_EQUAL .  1269))
+      ((default . error) (DO . (extended_return_object_declaration . 1)) 
(SEMICOLON . (extended_return_object_declaration . 1)) (COLON_EQUAL .  1266))
       ((default . error) (DO . (return_subtype_indication . 0)) (SEMICOLON . 
(return_subtype_indication . 0)) (COLON_EQUAL . (return_subtype_indication . 
0)))
-      ((default . error) (SEMICOLON .  1268))
+      ((default . error) (SEMICOLON .  1265))
       ((default . error) (WHEN . (loop_statement . 1)) (THEN . (loop_statement 
. 1)) (OR . (loop_statement . 1)) (ELSIF . (loop_statement . 1)) (ELSE . 
(loop_statement . 1)) (WHILE . (loop_statement . 1)) (SELECT . (loop_statement 
. 1)) (RETURN . (loop_statement . 1)) (REQUEUE . (loop_statement . 1)) (RAISE . 
(loop_statement . 1)) (PRAGMA . (loop_statement . 1)) (NULL . (loop_statement . 
1)) (LOOP . (loop_statement . 1)) (IF . (loop_statement . 1)) (GOTO . 
(loop_statement . 1)) (FOR . (l [...]
-      ((default . error) (END . (sequence_of_statements_opt . 0)) (ACCEPT . 
(label_opt . 0)) (BEGIN . (label_opt . 0)) (CASE . (label_opt . 0)) (DECLARE . 
(label_opt . 0)) (FOR . (label_opt . 0)) (IF . (label_opt . 0)) (LOOP . 
(label_opt . 0)) (RETURN . (label_opt . 0)) (SELECT . (label_opt . 0)) (WHILE . 
(label_opt . 0)) (STRING_LITERAL . (label_opt . 0)) (CHARACTER_LITERAL . 
(label_opt . 0)) (ABORT . (label_opt . 0)) (DELAY . (label_opt . 0)) (EXIT . 
(label_opt . 0)) (GOTO . (label_opt [...]
-      ((default . error) (IF .  1266))
+      ((default . error) (END . (sequence_of_statements_opt . 0)) (ACCEPT . 
(label_opt . 0)) (BEGIN . (label_opt . 0)) (CASE . (label_opt . 0)) (DECLARE . 
(label_opt . 0)) (FOR . (label_opt . 0)) (IF . (label_opt . 0)) (LOOP . 
(label_opt . 0)) (RETURN . (label_opt . 0)) (SELECT . (label_opt . 0)) (WHILE . 
(label_opt . 0)) (STRING_LITERAL . (label_opt . 0)) (CHARACTER_LITERAL . 
(label_opt . 0)) (ABORT . (label_opt . 0)) (DELAY . (label_opt . 0)) (EXIT . 
(label_opt . 0)) (GOTO . (label_opt [...]
+      ((default . error) (IF .  1263))
       ((default . error) (ELSIF . (elsif_statement_list . 1)) (ELSE . 
(elsif_statement_list . 1)) (END . (elsif_statement_list . 1)))
-      ((default . error) (SEMICOLON .  1265))
-      ((default . error) (THEN .  1264))
-      ((default . error) (END .  1263))
       ((default . error) (SEMICOLON .  1262))
-      ((default . error) (END . (sequence_of_statements_opt . 0)) (WHEN . 
(sequence_of_statements_opt . 0)) (ACCEPT . (label_opt . 0)) (BEGIN . 
(label_opt . 0)) (CASE . (label_opt . 0)) (DECLARE . (label_opt . 0)) (FOR . 
(label_opt . 0)) (IF . (label_opt . 0)) (LOOP . (label_opt . 0)) (RETURN . 
(label_opt . 0)) (SELECT . (label_opt . 0)) (WHILE . (label_opt . 0)) 
(STRING_LITERAL . (label_opt . 0)) (CHARACTER_LITERAL . (label_opt . 0)) (ABORT 
. (label_opt . 0)) (DELAY . (label_opt . 0)) ( [...]
-      ((default . error) (SEMICOLON .  1260))
-      ((default . error) (END .  1259))
-      ((default . error) (END .  1258))
-      ((default . error) (FOR .  1257) (IDENTIFIER .  72))
-      ((default . error) (WHEN .  1256))
+      ((default . error) (THEN .  1261))
+      ((default . error) (END .  1260))
+      ((default . error) (SEMICOLON .  1259))
+      ((default . error) (END . (sequence_of_statements_opt . 0)) (WHEN . 
(sequence_of_statements_opt . 0)) (ACCEPT . (label_opt . 0)) (BEGIN . 
(label_opt . 0)) (CASE . (label_opt . 0)) (DECLARE . (label_opt . 0)) (FOR . 
(label_opt . 0)) (IF . (label_opt . 0)) (LOOP . (label_opt . 0)) (RETURN . 
(label_opt . 0)) (SELECT . (label_opt . 0)) (WHILE . (label_opt . 0)) 
(STRING_LITERAL . (label_opt . 0)) (CHARACTER_LITERAL . (label_opt . 0)) (ABORT 
. (label_opt . 0)) (DELAY . (label_opt . 0)) ( [...]
+      ((default . error) (SEMICOLON .  1257))
+      ((default . error) (END .  1256))
+      ((default . error) (END .  1255))
+      ((default . error) (FOR .  1254) (IDENTIFIER .  72))
+      ((default . error) (WHEN .  1253))
       ((default . error) (WHEN . (entry_body_formal_part . 1)))
-      ((default . error) (SEMICOLON .  1255))
+      ((default . error) (SEMICOLON .  1252))
       ((default . error) (ELSE . (elsif_expression_item . 0)) (ELSIF . 
(elsif_expression_item . 0)) (RIGHT_PAREN . (elsif_expression_item . 0)))
       ((default . error) (DOT .  87) (TICK .  88) (LOOP . 
(iterator_specification . 2)) (EQUAL_GREATER . (iterator_specification . 2)) 
(LEFT_PAREN .  106))
-      ((default . error) (SEMICOLON .  1254))
-      ((default . error) (SEMICOLON .  1253))
-      ((default . error) (SEMICOLON .  1252))
       ((default . error) (SEMICOLON .  1251))
+      ((default . error) (SEMICOLON .  1250))
+      ((default . error) (SEMICOLON .  1249))
+      ((default . error) (SEMICOLON .  1248))
       ((default . error) (BEGIN . (private_type_declaration . 0)) (IDENTIFIER 
. (private_type_declaration . 0)) (ENTRY . (private_type_declaration . 0)) (FOR 
. (private_type_declaration . 0)) (FUNCTION . (private_type_declaration . 0)) 
(GENERIC . (private_type_declaration . 0)) (NOT . (private_type_declaration . 
0)) (OVERRIDING . (private_type_declaration . 0)) (PACKAGE . 
(private_type_declaration . 0)) (PRAGMA . (private_type_declaration . 0)) 
(PROCEDURE . (private_type_declaration . 0) [...]
-      ((default . error) (IDENTIFIER .  48) (CHARACTER_LITERAL .  50) 
(STRING_LITERAL .  49))
-      ((default . error) (WITH .  1249))
+      ((default . error) (WITH .  1247))
       ((default . error) (WITH . (constraint_opt . 1)) (SEMICOLON . 
(constraint_opt . 1)))
       ((default . error) (WITH . (derived_type_definition . 1)) (SEMICOLON . 
(derived_type_definition . 1)))
-      ((default . error) (WITH .  1248))
-      ((default . error) (WHEN .  1245))
+      ((default . error) (WITH .  1246))
+      ((default . error) (WHEN .  1243))
       ((default . error) (SEMICOLON . (record_definition . 0)) (WITH . 
(record_definition . 0)))
-      ((default . error) (COLON_EQUAL .  1243) (SEMICOLON . 
(aspect_specification_opt . 0)) (WITH .  108))
+      ((default . error) (COLON_EQUAL .  1241) (SEMICOLON . 
(aspect_specification_opt . 0)) (WITH .  108))
       ((default . error) (SEMICOLON . (type_definition . 1)) (WITH . 
(type_definition . 1)))
       ((default . error) (RIGHT_PAREN . (enumeration_literal_list . 1)) (COMMA 
. (enumeration_literal_list . 1)))
-      ((default . error) (DOT_DOT .  1242))
+      ((default . error) (DOT_DOT .  1240))
       ((default . error) (WITH . (real_range_specification_opt . 0)) 
(SEMICOLON . (real_range_specification_opt . 0)) (RANGE .  1101))
-      ((default . error) (SEMICOLON . (identifier_opt . 0)) (IDENTIFIER .  
695))
-      ((default . error) (SEMICOLON .  1239))
+      ((default . error) (SEMICOLON . (identifier_opt . 0)) (IDENTIFIER .  
694))
+      ((default . error) (SEMICOLON .  1237))
       ((default . error) (USE . (task_type_declaration . 1)) (TYPE . 
(task_type_declaration . 1)) (TASK . (task_type_declaration . 1)) (SUBTYPE . 
(task_type_declaration . 1)) (PROTECTED . (task_type_declaration . 1)) 
(PROCEDURE . (task_type_declaration . 1)) (PRAGMA . (task_type_declaration . 
1)) (PACKAGE . (task_type_declaration . 1)) (OVERRIDING . 
(task_type_declaration . 1)) (NOT . (task_type_declaration . 1)) (GENERIC . 
(task_type_declaration . 1)) (FUNCTION . (task_type_declaration  [...]
-      ((default . error) (AND .  1061) (WITH .  1238))
-      ((default . error) (SEMICOLON . (identifier_opt . 0)) (IDENTIFIER .  
695))
-      ((default . error) (SEMICOLON .  1236))
+      ((default . error) (AND .  1061) (WITH .  1236))
+      ((default . error) (SEMICOLON . (identifier_opt . 0)) (IDENTIFIER .  
694))
+      ((default . error) (SEMICOLON .  1234))
       ((default . error) (USE . (protected_type_declaration . 1)) (TYPE . 
(protected_type_declaration . 1)) (TASK . (protected_type_declaration . 1)) 
(SUBTYPE . (protected_type_declaration . 1)) (PROTECTED . 
(protected_type_declaration . 1)) (PROCEDURE . (protected_type_declaration . 
1)) (PRAGMA . (protected_type_declaration . 1)) (PACKAGE . 
(protected_type_declaration . 1)) (OVERRIDING . (protected_type_declaration . 
1)) (NOT . (protected_type_declaration . 1)) (GENERIC . (protected_typ [...]
-      ((default . error) (AND .  1061) (WITH .  1235))
-      ((default . error) (RANGE .  1234))
+      ((default . error) (AND .  1061) (WITH .  1233))
+      ((default . error) (RANGE .  1232))
       ((default . error) (SEMICOLON . (record_rep . 0)))
       ((default . error) (IDENTIFIER . (mod_clause_opt . 1)))
       ((default . error) (BEGIN . (object_renaming_declaration . 0)) 
(IDENTIFIER . (object_renaming_declaration . 0)) (ENTRY . 
(object_renaming_declaration . 0)) (FOR . (object_renaming_declaration . 0)) 
(FUNCTION . (object_renaming_declaration . 0)) (GENERIC . 
(object_renaming_declaration . 0)) (NOT . (object_renaming_declaration . 0)) 
(OVERRIDING . (object_renaming_declaration . 0)) (PACKAGE . 
(object_renaming_declaration . 0)) (PRAGMA . (object_renaming_declaration . 0)) 
(PROCEDURE .  [...]
       ((default . error) (COLON_EQUAL . (component_definition . 2)) (SEMICOLON 
. (component_definition . 2)) (WITH . (component_definition . 2)))
       ((default . error) (COLON_EQUAL . (component_definition . 0)) (SEMICOLON 
. (component_definition . 0)) (WITH . (component_definition . 0)))
       ((default . error) (RIGHT_PAREN . (subtype_indication . 1)) (COMMA . 
(subtype_indication . 1)) (DOT .  87) (TICK .  88) (BAR . (discrete_choice . 
1)) (EQUAL_GREATER . (discrete_choice . 1)) (RANGE .  833) (LEFT_PAREN .  803))
-      ((default . error) (SEMICOLON . (formal_derived_type_definition . 0)) 
(WITH . (formal_derived_type_definition . 0)))
       ((default . error) (PLUS .  144) (MINUS .  143) (ABS .  146) (NOT .  
149) (NULL .  150) (NEW .  148) (IDENTIFIER .  48) (CHARACTER_LITERAL .  50) 
(STRING_LITERAL .  49) (LEFT_PAREN .  147))
       ((default . error) (END . (declarative_part_opt . 0)) (PRIVATE . 
(declarative_part_opt . 0)) (USE .  11) (SUBTYPE .  292) (PRAGMA .  7) (NOT .  
4) (OVERRIDING .  5) (FUNCTION . (overriding_indicator_opt . 2)) (PROCEDURE . 
(overriding_indicator_opt . 2)) (ENTRY . (overriding_indicator_opt . 2)) (FOR . 
 289) (IDENTIFIER .  288) (TYPE .  294) (GENERIC .  2) (PROTECTED .  291) (TASK 
.  293) (PACKAGE .  290))
       ((default . error) (END . (single_protected_declaration . 0)) (PRIVATE . 
(single_protected_declaration . 0)) (USE . (single_protected_declaration . 0)) 
(TYPE . (single_protected_declaration . 0)) (TASK . 
(single_protected_declaration . 0)) (SUBTYPE . (single_protected_declaration . 
0)) (PROTECTED . (single_protected_declaration . 0)) (PROCEDURE . 
(single_protected_declaration . 0)) (PRAGMA . (single_protected_declaration . 
0)) (PACKAGE . (single_protected_declaration . 0)) (OVERRID [...]
@@ -2933,88 +2979,87 @@
       ((default . error) (WITH . (type_definition . 5)) (SEMICOLON . 
(type_definition . 5)))
       ((default . error) (PLUS .  144) (MINUS .  143) (ABS .  146) (NOT .  
149) (NULL .  150) (NEW .  148) (IDENTIFIER .  48) (CHARACTER_LITERAL .  50) 
(STRING_LITERAL .  49) (LEFT_PAREN .  147))
       ((default . error) (PLUS .  144) (MINUS .  143) (ABS .  146) (NOT .  
149) (NULL .  150) (NEW .  148) (IDENTIFIER .  48) (CHARACTER_LITERAL .  50) 
(STRING_LITERAL .  49) (LEFT_PAREN .  147))
-      ((default . error) (SEMICOLON .  1292))
+      ((default . error) (SEMICOLON .  1289))
       ((default . error) (EQUAL_GREATER . (discrete_choice_list . 0)) (BAR . 
(discrete_choice_list . 0)) (OTHERS .  172) (IDENTIFIER .  48) 
(CHARACTER_LITERAL .  50) (STRING_LITERAL .  49) (PLUS .  144) (MINUS .  143) 
(ABS .  146) (NOT .  171) (NULL .  150) (NEW .  148) (LEFT_PAREN .  147))
-      ((default . error) (END .  1289) (WHEN .  1245))
+      ((default . error) (END .  1286) (WHEN .  1243))
       ((default . error) (END . (variant_list . 0)) (WHEN . (variant_list . 
0)))
-      ((default . error) (PRIVATE .  1288))
+      ((default . error) (PRIVATE .  1285))
       ((default . error) (RECORD .  848) (NULL .  846))
-      ((default . error) (AND .  1061) (WITH . (and_interface_list_opt . 1)))
       ((default . error) (PRIVATE . (object_declaration . 2)) (END . 
(object_declaration . 2)) (BEGIN . (object_declaration . 2)) (IDENTIFIER . 
(object_declaration . 2)) (ENTRY . (object_declaration . 2)) (FOR . 
(object_declaration . 2)) (FUNCTION . (object_declaration . 2)) (GENERIC . 
(object_declaration . 2)) (NOT . (object_declaration . 2)) (OVERRIDING . 
(object_declaration . 2)) (PACKAGE . (object_declaration . 2)) (PRAGMA . 
(object_declaration . 2)) (PROCEDURE . (object_declaration  [...]
       ((default . error) (PRIVATE . (object_declaration . 4)) (END . 
(object_declaration . 4)) (BEGIN . (object_declaration . 4)) (IDENTIFIER . 
(object_declaration . 4)) (ENTRY . (object_declaration . 4)) (FOR . 
(object_declaration . 4)) (FUNCTION . (object_declaration . 4)) (GENERIC . 
(object_declaration . 4)) (NOT . (object_declaration . 4)) (OVERRIDING . 
(object_declaration . 4)) (PACKAGE . (object_declaration . 4)) (PRAGMA . 
(object_declaration . 4)) (PROCEDURE . (object_declaration  [...]
       ((default . error) (PRIVATE . (object_declaration . 0)) (END . 
(object_declaration . 0)) (BEGIN . (object_declaration . 0)) (IDENTIFIER . 
(object_declaration . 0)) (ENTRY . (object_declaration . 0)) (FOR . 
(object_declaration . 0)) (FUNCTION . (object_declaration . 0)) (GENERIC . 
(object_declaration . 0)) (NOT . (object_declaration . 0)) (OVERRIDING . 
(object_declaration . 0)) (PACKAGE . (object_declaration . 0)) (PRAGMA . 
(object_declaration . 0)) (PROCEDURE . (object_declaration  [...]
       ((default . error) (PRIVATE . (entry_declaration . 0)) (END . 
(entry_declaration . 0)) (BEGIN . (entry_declaration . 0)) (IDENTIFIER . 
(entry_declaration . 0)) (ENTRY . (entry_declaration . 0)) (FOR . 
(entry_declaration . 0)) (FUNCTION . (entry_declaration . 0)) (GENERIC . 
(entry_declaration . 0)) (NOT . (entry_declaration . 0)) (OVERRIDING . 
(entry_declaration . 0)) (PACKAGE . (entry_declaration . 0)) (PRAGMA . 
(entry_declaration . 0)) (PROCEDURE . (entry_declaration . 0)) (PROTEC [...]
       ((default . error) (PRIVATE . (protected_body . 0)) (END . 
(protected_body . 0)) (BEGIN . (protected_body . 0)) (IDENTIFIER . 
(protected_body . 0)) (ENTRY . (protected_body . 0)) (FOR . (protected_body . 
0)) (FUNCTION . (protected_body . 0)) (GENERIC . (protected_body . 0)) (NOT . 
(protected_body . 0)) (OVERRIDING . (protected_body . 0)) (PACKAGE . 
(protected_body . 0)) (PRAGMA . (protected_body . 0)) (PROCEDURE . 
(protected_body . 0)) (PROTECTED . (protected_body . 0)) (SUBTYPE .  [...]
       ((default . error) (IS . (expression_opt . 0)) (PLUS .  144) (MINUS .  
143) (ABS .  146) (NOT .  149) (NULL .  150) (NEW .  148) (IDENTIFIER .  48) 
(CHARACTER_LITERAL .  50) (STRING_LITERAL .  49) (LEFT_PAREN .  147))
-      ((default . error) (IDENTIFIER .  1285))
-      ((default . error) (SEMICOLON . (identifier_opt . 0)) (IDENTIFIER .  
695))
-      ((default . error) (SEMICOLON . (identifier_opt . 0)) (IDENTIFIER .  
695))
+      ((default . error) (IDENTIFIER .  1282))
+      ((default . error) (SEMICOLON . (identifier_opt . 0)) (IDENTIFIER .  
694))
+      ((default . error) (SEMICOLON . (identifier_opt . 0)) (IDENTIFIER .  
694))
       ((default . error) (OR . (case_statement . 0)) (THEN . (case_statement . 
0)) (WHEN . (case_statement . 0)) (EXCEPTION . (case_statement . 0)) (END . 
(case_statement . 0)) (LESS_LESS . (case_statement . 0)) (IDENTIFIER . 
(case_statement . 0)) (STRING_LITERAL . (case_statement . 0)) 
(CHARACTER_LITERAL . (case_statement . 0)) (ACCEPT . (case_statement . 0)) 
(ABORT . (case_statement . 0)) (BEGIN . (case_statement . 0)) (CASE . 
(case_statement . 0)) (DECLARE . (case_statement . 0)) (DEL [...]
       ((default . error) (END . (case_statement_alternative . 0)) (WHEN . 
(case_statement_alternative . 0)))
       ((default . error) (OR . (block_statement . 0)) (THEN . (block_statement 
. 0)) (WHEN . (block_statement . 0)) (EXCEPTION . (block_statement . 0)) (END . 
(block_statement . 0)) (LESS_LESS . (block_statement . 0)) (IDENTIFIER . 
(block_statement . 0)) (STRING_LITERAL . (block_statement . 0)) 
(CHARACTER_LITERAL . (block_statement . 0)) (ACCEPT . (block_statement . 0)) 
(ABORT . (block_statement . 0)) (BEGIN . (block_statement . 0)) (CASE . 
(block_statement . 0)) (DECLARE . (block_statem [...]
-      ((default . error) (IF .  1282))
-      ((default . error) (ELSE . (sequence_of_statements_opt . 0)) (ELSIF . 
(sequence_of_statements_opt . 0)) (END . (sequence_of_statements_opt . 0)) 
(ACCEPT . (label_opt . 0)) (BEGIN . (label_opt . 0)) (CASE . (label_opt . 0)) 
(DECLARE . (label_opt . 0)) (FOR . (label_opt . 0)) (IF . (label_opt . 0)) 
(LOOP . (label_opt . 0)) (RETURN . (label_opt . 0)) (SELECT . (label_opt . 0)) 
(WHILE . (label_opt . 0)) (STRING_LITERAL . (label_opt . 0)) (CHARACTER_LITERAL 
. (label_opt . 0)) (ABORT . ( [...]
+      ((default . error) (IF .  1279))
+      ((default . error) (ELSE . (sequence_of_statements_opt . 0)) (ELSIF . 
(sequence_of_statements_opt . 0)) (END . (sequence_of_statements_opt . 0)) 
(ACCEPT . (label_opt . 0)) (BEGIN . (label_opt . 0)) (CASE . (label_opt . 0)) 
(DECLARE . (label_opt . 0)) (FOR . (label_opt . 0)) (IF . (label_opt . 0)) 
(LOOP . (label_opt . 0)) (RETURN . (label_opt . 0)) (SELECT . (label_opt . 0)) 
(WHILE . (label_opt . 0)) (STRING_LITERAL . (label_opt . 0)) (CHARACTER_LITERAL 
. (label_opt . 0)) (ABORT . ( [...]
       ((default . error) (OR . (if_statement . 3)) (THEN . (if_statement . 3)) 
(WHEN . (if_statement . 3)) (EXCEPTION . (if_statement . 3)) (END . 
(if_statement . 3)) (LESS_LESS . (if_statement . 3)) (IDENTIFIER . 
(if_statement . 3)) (STRING_LITERAL . (if_statement . 3)) (CHARACTER_LITERAL . 
(if_statement . 3)) (ACCEPT . (if_statement . 3)) (ABORT . (if_statement . 3)) 
(BEGIN . (if_statement . 3)) (CASE . (if_statement . 3)) (DECLARE . 
(if_statement . 3)) (DELAY . (if_statement . 3)) (EX [...]
-      ((default . error) (SEMICOLON .  1280))
-      ((default . error) (END .  1279))
+      ((default . error) (SEMICOLON .  1277))
+      ((default . error) (END .  1276))
       ((default . error) (OR . (extended_return_statement . 0)) (THEN . 
(extended_return_statement . 0)) (WHEN . (extended_return_statement . 0)) 
(EXCEPTION . (extended_return_statement . 0)) (END . (extended_return_statement 
. 0)) (LESS_LESS . (extended_return_statement . 0)) (IDENTIFIER . 
(extended_return_statement . 0)) (STRING_LITERAL . (extended_return_statement . 
0)) (CHARACTER_LITERAL . (extended_return_statement . 0)) (ACCEPT . 
(extended_return_statement . 0)) (ABORT . (extended_ [...]
       ((default . error) (PLUS .  144) (MINUS .  143) (ABS .  146) (NOT .  
149) (NULL .  150) (NEW .  148) (IDENTIFIER .  48) (CHARACTER_LITERAL .  50) 
(STRING_LITERAL .  49) (LEFT_PAREN .  147))
-      ((default . error) (SEMICOLON .  1277))
+      ((default . error) (SEMICOLON .  1274))
       ((default . error) (OR . (selective_accept . 0)) (THEN . 
(selective_accept . 0)) (WHEN . (selective_accept . 0)) (EXCEPTION . 
(selective_accept . 0)) (END . (selective_accept . 0)) (LESS_LESS . 
(selective_accept . 0)) (IDENTIFIER . (selective_accept . 0)) (STRING_LITERAL . 
(selective_accept . 0)) (CHARACTER_LITERAL . (selective_accept . 0)) (ACCEPT . 
(selective_accept . 0)) (ABORT . (selective_accept . 0)) (BEGIN . 
(selective_accept . 0)) (CASE . (selective_accept . 0)) (DECLARE .  [...]
       ((default . error) (OR . (conditional_entry_call . 0)) (THEN . 
(conditional_entry_call . 0)) (WHEN . (conditional_entry_call . 0)) (EXCEPTION 
. (conditional_entry_call . 0)) (END . (conditional_entry_call . 0)) (LESS_LESS 
. (conditional_entry_call . 0)) (IDENTIFIER . (conditional_entry_call . 0)) 
(STRING_LITERAL . (conditional_entry_call . 0)) (CHARACTER_LITERAL . 
(conditional_entry_call . 0)) (ACCEPT . (conditional_entry_call . 0)) (ABORT . 
(conditional_entry_call . 0)) (BEGIN . ( [...]
       ((default . error) (OR . (timed_entry_call . 0)) (THEN . 
(timed_entry_call . 0)) (WHEN . (timed_entry_call . 0)) (EXCEPTION . 
(timed_entry_call . 0)) (END . (timed_entry_call . 0)) (LESS_LESS . 
(timed_entry_call . 0)) (IDENTIFIER . (timed_entry_call . 0)) (STRING_LITERAL . 
(timed_entry_call . 0)) (CHARACTER_LITERAL . (timed_entry_call . 0)) (ACCEPT . 
(timed_entry_call . 0)) (ABORT . (timed_entry_call . 0)) (BEGIN . 
(timed_entry_call . 0)) (CASE . (timed_entry_call . 0)) (DECLARE .  [...]
       ((default . error) (OR . (loop_statement . 0)) (THEN . (loop_statement . 
0)) (WHEN . (loop_statement . 0)) (EXCEPTION . (loop_statement . 0)) (END . 
(loop_statement . 0)) (LESS_LESS . (loop_statement . 0)) (IDENTIFIER . 
(loop_statement . 0)) (STRING_LITERAL . (loop_statement . 0)) 
(CHARACTER_LITERAL . (loop_statement . 0)) (ACCEPT . (loop_statement . 0)) 
(ABORT . (loop_statement . 0)) (BEGIN . (loop_statement . 0)) (CASE . 
(loop_statement . 0)) (DECLARE . (loop_statement . 0)) (DEL [...]
-      ((default . error) (WHEN . (sequence_of_statements_opt . 0)) (END . 
(sequence_of_statements_opt . 0)) (ACCEPT . (label_opt . 0)) (BEGIN . 
(label_opt . 0)) (CASE . (label_opt . 0)) (DECLARE . (label_opt . 0)) (FOR . 
(label_opt . 0)) (IF . (label_opt . 0)) (LOOP . (label_opt . 0)) (RETURN . 
(label_opt . 0)) (SELECT . (label_opt . 0)) (WHILE . (label_opt . 0)) 
(STRING_LITERAL . (label_opt . 0)) (CHARACTER_LITERAL . (label_opt . 0)) (ABORT 
. (label_opt . 0)) (DELAY . (label_opt . 0)) ( [...]
+      ((default . error) (WHEN . (sequence_of_statements_opt . 0)) (END . 
(sequence_of_statements_opt . 0)) (ACCEPT . (label_opt . 0)) (BEGIN . 
(label_opt . 0)) (CASE . (label_opt . 0)) (DECLARE . (label_opt . 0)) (FOR . 
(label_opt . 0)) (IF . (label_opt . 0)) (LOOP . (label_opt . 0)) (RETURN . 
(label_opt . 0)) (SELECT . (label_opt . 0)) (WHILE . (label_opt . 0)) 
(STRING_LITERAL . (label_opt . 0)) (CHARACTER_LITERAL . (label_opt . 0)) (ABORT 
. (label_opt . 0)) (DELAY . (label_opt . 0)) ( [...]
       ((default . error) (WHEN . (exception_handler . 0)) (END . 
(exception_handler . 0)))
       ((default . error) (WHEN . (asynchronous_select . 0)) (THEN . 
(asynchronous_select . 0)) (OR . (asynchronous_select . 0)) (ELSIF . 
(asynchronous_select . 0)) (ELSE . (asynchronous_select . 0)) (WHILE . 
(asynchronous_select . 0)) (SELECT . (asynchronous_select . 0)) (RETURN . 
(asynchronous_select . 0)) (REQUEUE . (asynchronous_select . 0)) (RAISE . 
(asynchronous_select . 0)) (PRAGMA . (asynchronous_select . 0)) (NULL . 
(asynchronous_select . 0)) (LOOP . (asynchronous_select . 0)) (I [...]
       ((default . error) (DO . (extended_return_object_declaration . 0)) 
(SEMICOLON . (extended_return_object_declaration . 0)))
-      ((default . error) (IF .  1310))
+      ((default . error) (IF .  1307))
       ((default . error) (WHEN . (if_statement . 1)) (THEN . (if_statement . 
1)) (OR . (if_statement . 1)) (ELSIF . (if_statement . 1)) (ELSE . 
(if_statement . 1)) (WHILE . (if_statement . 1)) (SELECT . (if_statement . 1)) 
(RETURN . (if_statement . 1)) (REQUEUE . (if_statement . 1)) (RAISE . 
(if_statement . 1)) (PRAGMA . (if_statement . 1)) (NULL . (if_statement . 1)) 
(LOOP . (if_statement . 1)) (IF . (if_statement . 1)) (GOTO . (if_statement . 
1)) (FOR . (if_statement . 1)) (EXIT . (if_ [...]
       ((default . error) (ELSE . (elsif_statement_item . 0)) (ELSIF . 
(elsif_statement_item . 0)) (END . (elsif_statement_item . 0)))
-      ((default . error) (SEMICOLON .  1309))
-      ((default . error) (SEMICOLON .  1308))
-      ((default . error) (SEMICOLON .  1307))
-      ((default . error) (IN .  1306))
-      ((default . error) (IS .  1305))
+      ((default . error) (SEMICOLON .  1306))
+      ((default . error) (SEMICOLON .  1305))
+      ((default . error) (SEMICOLON .  1304))
+      ((default . error) (IN .  1303))
+      ((default . error) (IS .  1302))
       ((default . error) (WITH . (derived_type_definition . 0)) (SEMICOLON . 
(derived_type_definition . 0)))
       ((default . error) (SEMICOLON . (aspect_specification_opt . 0)) (WITH .  
108))
-      ((default . error) (CASE .  1303))
+      ((default . error) (CASE .  1300))
       ((default . error) (WHEN . (variant_list . 1)) (END . (variant_list . 
1)))
-      ((default . error) (BAR .  275) (EQUAL_GREATER .  1302))
+      ((default . error) (BAR .  275) (EQUAL_GREATER .  1299))
       ((default . error) (WHEN . (component_declaration . 1)) (END . 
(component_declaration . 1)) (CASE . (component_declaration . 1)) (IDENTIFIER . 
(component_declaration . 1)) (FOR . (component_declaration . 1)))
       ((default . error) (SEMICOLON . (aspect_specification_opt . 0)) (WITH .  
108))
       ((default . error) (SEMICOLON . (real_range_specification_opt . 1)) 
(WITH . (real_range_specification_opt . 1)))
-      ((default . error) (SEMICOLON .  1300))
-      ((default . error) (SEMICOLON .  1299))
-      ((default . error) (DOT_DOT .  1298))
+      ((default . error) (SEMICOLON .  1297))
+      ((default . error) (SEMICOLON .  1296))
+      ((default . error) (DOT_DOT .  1295))
       ((default . error) (PLUS .  144) (MINUS .  143) (ABS .  146) (NOT .  
149) (NULL .  150) (NEW .  148) (IDENTIFIER .  48) (CHARACTER_LITERAL .  50) 
(STRING_LITERAL .  49) (LEFT_PAREN .  147))
       ((default . error) (PRIVATE . (protected_type_declaration . 0)) (END . 
(protected_type_declaration . 0)) (BEGIN . (protected_type_declaration . 0)) 
(IDENTIFIER . (protected_type_declaration . 0)) (ENTRY . 
(protected_type_declaration . 0)) (FOR . (protected_type_declaration . 0)) 
(FUNCTION . (protected_type_declaration . 0)) (GENERIC . 
(protected_type_declaration . 0)) (NOT . (protected_type_declaration . 0)) 
(OVERRIDING . (protected_type_declaration . 0)) (PACKAGE . (protected_type [...]
       ((default . error) (PRIVATE . (task_type_declaration . 0)) (END . 
(task_type_declaration . 0)) (BEGIN . (task_type_declaration . 0)) (IDENTIFIER 
. (task_type_declaration . 0)) (ENTRY . (task_type_declaration . 0)) (FOR . 
(task_type_declaration . 0)) (FUNCTION . (task_type_declaration . 0)) (GENERIC 
. (task_type_declaration . 0)) (NOT . (task_type_declaration . 0)) (OVERRIDING 
. (task_type_declaration . 0)) (PACKAGE . (task_type_declaration . 0)) (PRAGMA 
. (task_type_declaration . 0 [...]
-      ((default . error) (SEMICOLON .  1317))
-      ((default . error) (END . (component_list_opt . 0)) (WHEN . 
(component_list_opt . 0)) (NULL .  1009) (CASE .  1008) (IDENTIFIER .  72) (FOR 
.  289))
-      ((default . error) (SEMICOLON .  1315))
       ((default . error) (SEMICOLON .  1314))
+      ((default . error) (END . (component_list_opt . 0)) (WHEN . 
(component_list_opt . 0)) (NULL .  1009) (CASE .  1008) (IDENTIFIER .  72) (FOR 
.  289))
+      ((default . error) (SEMICOLON .  1312))
+      ((default . error) (SEMICOLON .  1311))
       ((default . error) (BEGIN . (declarative_part_opt . 0)) (USE .  11) 
(SUBTYPE .  292) (PRAGMA .  7) (NOT .  4) (OVERRIDING .  5) (FUNCTION . 
(overriding_indicator_opt . 2)) (PROCEDURE . (overriding_indicator_opt . 2)) 
(ENTRY . (overriding_indicator_opt . 2)) (FOR .  289) (IDENTIFIER .  288) (TYPE 
.  294) (GENERIC .  2) (PROTECTED .  291) (TASK .  293) (PACKAGE .  290))
-      ((default . error) (IDENTIFIER .  48) (CHARACTER_LITERAL .  50) 
(STRING_LITERAL .  49) (PLUS .  144) (MINUS .  143) (ABS .  146) (NOT .  758) 
(NULL .  150) (NEW .  148) (LEFT_PAREN .  147))
+      ((default . error) (IDENTIFIER .  48) (CHARACTER_LITERAL .  50) 
(STRING_LITERAL .  49) (PLUS .  144) (MINUS .  143) (ABS .  146) (NOT .  757) 
(NULL .  150) (NEW .  148) (LEFT_PAREN .  147))
       ((default . error) (PRIVATE . (task_body . 0)) (END . (task_body . 0)) 
(BEGIN . (task_body . 0)) (IDENTIFIER . (task_body . 0)) (ENTRY . (task_body . 
0)) (FOR . (task_body . 0)) (FUNCTION . (task_body . 0)) (GENERIC . (task_body 
. 0)) (NOT . (task_body . 0)) (OVERRIDING . (task_body . 0)) (PACKAGE . 
(task_body . 0)) (PRAGMA . (task_body . 0)) (PROCEDURE . (task_body . 0)) 
(PROTECTED . (task_body . 0)) (SUBTYPE . (task_body . 0)) (TASK . (task_body . 
0)) (TYPE . (task_body . 0)) (US [...]
       ((default . error) (THEN . (accept_statement . 0)) (WHEN . 
(accept_statement . 0)) (EXCEPTION . (accept_statement . 0)) (ELSIF . 
(accept_statement . 0)) (ELSE . (accept_statement . 0)) (OR . (accept_statement 
. 0)) (END . (accept_statement . 0)) (LESS_LESS . (accept_statement . 0)) 
(IDENTIFIER . (accept_statement . 0)) (STRING_LITERAL . (accept_statement . 0)) 
(CHARACTER_LITERAL . (accept_statement . 0)) (ACCEPT . (accept_statement . 0)) 
(ABORT . (accept_statement . 0)) (BEGIN . (a [...]
       ((default . error) (OR . (if_statement . 2)) (THEN . (if_statement . 2)) 
(WHEN . (if_statement . 2)) (EXCEPTION . (if_statement . 2)) (END . 
(if_statement . 2)) (LESS_LESS . (if_statement . 2)) (IDENTIFIER . 
(if_statement . 2)) (STRING_LITERAL . (if_statement . 2)) (CHARACTER_LITERAL . 
(if_statement . 2)) (ACCEPT . (if_statement . 2)) (ABORT . (if_statement . 2)) 
(BEGIN . (if_statement . 2)) (CASE . (if_statement . 2)) (DECLARE . 
(if_statement . 2)) (DELAY . (if_statement . 2)) (EX [...]
-      ((default . error) (SEMICOLON .  1311))
+      ((default . error) (SEMICOLON .  1308))
       ((default . error) (WHEN . (if_statement . 0)) (THEN . (if_statement . 
0)) (OR . (if_statement . 0)) (ELSIF . (if_statement . 0)) (ELSE . 
(if_statement . 0)) (WHILE . (if_statement . 0)) (SELECT . (if_statement . 0)) 
(RETURN . (if_statement . 0)) (REQUEUE . (if_statement . 0)) (RAISE . 
(if_statement . 0)) (PRAGMA . (if_statement . 0)) (NULL . (if_statement . 0)) 
(LOOP . (if_statement . 0)) (IF . (if_statement . 0)) (GOTO . (if_statement . 
0)) (FOR . (if_statement . 0)) (EXIT . (if_ [...]
-      ((default . error) (RIGHT_PAREN .  1321))
-      ((default . error) (BEGIN .  1320))
+      ((default . error) (RIGHT_PAREN .  1318))
+      ((default . error) (BEGIN .  1317))
       ((default . error) (BEGIN . (private_extension_declaration . 0)) 
(IDENTIFIER . (private_extension_declaration . 0)) (ENTRY . 
(private_extension_declaration . 0)) (FOR . (private_extension_declaration . 
0)) (FUNCTION . (private_extension_declaration . 0)) (GENERIC . 
(private_extension_declaration . 0)) (NOT . (private_extension_declaration . 
0)) (OVERRIDING . (private_extension_declaration . 0)) (PACKAGE . 
(private_extension_declaration . 0)) (PRAGMA . (private_extension_declaration 
[...]
       ((default . error) (WHEN . (variant_part . 0)) (END . (variant_part . 
0)) (CASE . (variant_part . 0)) (IDENTIFIER . (variant_part . 0)) (FOR . 
(variant_part . 0)))
       ((default . error) (END . (variant . 0)) (WHEN . (variant . 0)))
       ((default . error) (WHEN . (component_declaration . 0)) (END . 
(component_declaration . 0)) (CASE . (component_declaration . 0)) (IDENTIFIER . 
(component_declaration . 0)) (FOR . (component_declaration . 0)))
-      ((default . error) (SEMICOLON .  1319))
+      ((default . error) (SEMICOLON .  1316))
       ((default . error) (END . (component_clause . 0)) (IDENTIFIER . 
(component_clause . 0)))
-      ((default . error) (END . (sequence_of_statements_opt . 0)) (EXCEPTION . 
(sequence_of_statements_opt . 0)) (ACCEPT . (label_opt . 0)) (BEGIN . 
(label_opt . 0)) (CASE . (label_opt . 0)) (DECLARE . (label_opt . 0)) (FOR . 
(label_opt . 0)) (IF . (label_opt . 0)) (LOOP . (label_opt . 0)) (RETURN . 
(label_opt . 0)) (SELECT . (label_opt . 0)) (WHILE . (label_opt . 0)) 
(STRING_LITERAL . (label_opt . 0)) (CHARACTER_LITERAL . (label_opt . 0)) (ABORT 
. (label_opt . 0)) (DELAY . (label_opt .  [...]
-      ((default . error) (WHEN . (parameter_profile_opt . 0)) (LEFT_PAREN .  
782))
+      ((default . error) (END . (sequence_of_statements_opt . 0)) (EXCEPTION . 
(sequence_of_statements_opt . 0)) (ACCEPT . (label_opt . 0)) (BEGIN . 
(label_opt . 0)) (CASE . (label_opt . 0)) (DECLARE . (label_opt . 0)) (FOR . 
(label_opt . 0)) (IF . (label_opt . 0)) (LOOP . (label_opt . 0)) (RETURN . 
(label_opt . 0)) (SELECT . (label_opt . 0)) (WHILE . (label_opt . 0)) 
(STRING_LITERAL . (label_opt . 0)) (CHARACTER_LITERAL . (label_opt . 0)) (ABORT 
. (label_opt . 0)) (DELAY . (label_opt .  [...]
+      ((default . error) (WHEN . (parameter_profile_opt . 0)) (LEFT_PAREN .  
781))
       ((default . error) (WHEN . (entry_body_formal_part . 0)))
-      ((default . error) (END .  1324))
-      ((default . error) (SEMICOLON . (identifier_opt . 0)) (IDENTIFIER .  
695))
-      ((default . error) (SEMICOLON .  1326))
+      ((default . error) (END .  1321))
+      ((default . error) (SEMICOLON . (identifier_opt . 0)) (IDENTIFIER .  
694))
+      ((default . error) (SEMICOLON .  1323))
       ((default . error) (PROCEDURE . (entry_body . 0)) (OVERRIDING . 
(entry_body . 0)) (NOT . (entry_body . 0)) (FUNCTION . (entry_body . 0)) (FOR . 
(entry_body . 0)) (ENTRY . (entry_body . 0)) (END . (entry_body . 0)))]
      [((compilation_unit . 13)(compilation_unit_list . 14)(context_item . 
15)(function_specification . 16)(generic_declaration . 17)(generic_formal_part 
. 18)(generic_instantiation . 19)(generic_package_declaration . 
20)(generic_renaming_declaration . 21)(generic_subprogram_declaration . 
22)(library_item . 23)(library_unit_declaration . 
24)(library_unit_renaming_declaration . 25)(overriding_indicator_opt . 
26)(package_body . 27)(package_declaration . 28)(package_renaming_declaration . 
29 [...]
       ((attribute_reference . 51)(name . 86)(qualified_expression . 
54)(selected_component . 55))
@@ -3248,9 +3293,9 @@
       nil
       nil
       nil
-      ((identifier_list . 214)(parameter_specification . 515))
+      ((identifier_list . 214)(parameter_specification . 514))
       nil
-      ((access_definition . 513)(aliased_opt . 514)(null_exclusion_opt . 212))
+      ((aliased_opt . 513))
       ((general_access_modifier_opt . 510)(protected_opt . 511))
       nil
       nil
@@ -3401,12 +3446,11 @@
       nil
       ((attribute_reference . 51)(name . 386)(qualified_expression . 
54)(selected_component . 55))
       ((attribute_reference . 51)(name . 385)(qualified_expression . 
54)(selected_component . 55))
-      ((actual_parameter_part . 91)(aspect_specification_opt . 657))
       ((actual_parameter_part . 91)(aspect_specification_opt . 656))
-      ((accept_statement . 630)(assignment_statement . 
631)(asynchronous_select . 632)(attribute_reference . 51)(block_statement . 
633)(case_statement . 634)(conditional_entry_call . 635)(delay_statement . 
636)(exit_statement . 637)(extended_return_statement . 
638)(handled_sequence_of_statements . 639)(if_statement . 640)(iteration_scheme 
. 641)(label_opt . 642)(loop_statement . 643)(name . 644)(pragma . 
645)(procedure_call_statement . 646)(qualified_expression . 54)(raise_statement 
. 64 [...]
-      nil
-      ((aspect_specification_opt . 610))
+      ((actual_parameter_part . 91)(aspect_specification_opt . 655))
+      ((accept_statement . 629)(assignment_statement . 
630)(asynchronous_select . 631)(attribute_reference . 51)(block_statement . 
632)(case_statement . 633)(conditional_entry_call . 634)(delay_statement . 
635)(exit_statement . 636)(extended_return_statement . 
637)(handled_sequence_of_statements . 638)(if_statement . 639)(iteration_scheme 
. 640)(label_opt . 641)(loop_statement . 642)(name . 643)(pragma . 
644)(procedure_call_statement . 645)(qualified_expression . 54)(raise_statement 
. 64 [...]
       nil
+      ((aspect_specification_opt . 609))
       nil
       nil
       nil
@@ -3416,21 +3460,22 @@
       nil
       nil
       nil
-      ((iterator_specification . 605))
       nil
+      ((iterator_specification . 604))
       nil
       nil
       nil
       nil
-      ((aggregate . 151)(attribute_reference . 51)(factor . 153)(name . 
154)(primary . 157)(qualified_expression . 54)(relation . 
602)(selected_component . 55)(simple_expression . 164)(term . 165)(term_list . 
166)(unary_adding_operator . 167))
       nil
       ((aggregate . 151)(attribute_reference . 51)(factor . 153)(name . 
154)(primary . 157)(qualified_expression . 54)(relation . 
601)(selected_component . 55)(simple_expression . 164)(term . 165)(term_list . 
166)(unary_adding_operator . 167))
       nil
-      nil
       ((aggregate . 151)(attribute_reference . 51)(factor . 153)(name . 
154)(primary . 157)(qualified_expression . 54)(relation . 
600)(selected_component . 55)(simple_expression . 164)(term . 165)(term_list . 
166)(unary_adding_operator . 167))
       nil
+      nil
       ((aggregate . 151)(attribute_reference . 51)(factor . 153)(name . 
154)(primary . 157)(qualified_expression . 54)(relation . 
599)(selected_component . 55)(simple_expression . 164)(term . 165)(term_list . 
166)(unary_adding_operator . 167))
       nil
+      ((aggregate . 151)(attribute_reference . 51)(factor . 153)(name . 
154)(primary . 157)(qualified_expression . 54)(relation . 
598)(selected_component . 55)(simple_expression . 164)(term . 165)(term_list . 
166)(unary_adding_operator . 167))
+      nil
       nil
       nil
       ((multiplying_operator . 352))
@@ -3439,46 +3484,46 @@
       nil
       nil
       ((aspect_specification_opt . 128))
-      ((aliased_opt . 592))
-      ((attribute_reference . 51)(name . 589)(qualified_expression . 
54)(selected_component . 55))
-      ((abstract_subprogram_declaration . 295)(aspect_clause . 296)(at_clause 
. 297)(body . 298)(body_stub . 299)(declaration . 300)(declarations . 
301)(declarative_part_opt . 588)(entry_declaration . 
303)(enumeration_representation_clause . 304)(exception_declaration . 
305)(expression_function_declaration . 306)(full_type_declaration . 
307)(function_specification . 16)(generic_declaration . 
308)(generic_formal_part . 18)(generic_instantiation . 
309)(generic_package_declaration . 20)(gen [...]
+      ((aliased_opt . 591))
+      ((attribute_reference . 51)(name . 588)(qualified_expression . 
54)(selected_component . 55))
+      ((abstract_subprogram_declaration . 295)(aspect_clause . 296)(at_clause 
. 297)(body . 298)(body_stub . 299)(declaration . 300)(declarations . 
301)(declarative_part_opt . 587)(entry_declaration . 
303)(enumeration_representation_clause . 304)(exception_declaration . 
305)(expression_function_declaration . 306)(full_type_declaration . 
307)(function_specification . 16)(generic_declaration . 
308)(generic_formal_part . 18)(generic_instantiation . 
309)(generic_package_declaration . 20)(gen [...]
       nil
-      ((discriminant_part_opt . 587))
-      ((aspect_specification_opt . 585))
+      ((discriminant_part_opt . 586))
+      ((aspect_specification_opt . 584))
       nil
       nil
       nil
-      ((aspect_specification_opt . 581))
+      ((aspect_specification_opt . 580))
       nil
       nil
-      ((attribute_reference . 51)(name . 578)(qualified_expression . 
54)(selected_component . 55))
+      ((attribute_reference . 51)(name . 577)(qualified_expression . 
54)(selected_component . 55))
       nil
       nil
       nil
       nil
       ((actual_parameter_part . 91))
-      ((access_definition . 573)(null_exclusion_opt . 574))
+      ((access_definition . 572)(null_exclusion_opt . 573))
       nil
       nil
       ((actual_parameter_part . 91))
       nil
-      ((relational_operator . 567))
+      ((relational_operator . 566))
       nil
       nil
-      ((aggregate . 151)(attribute_reference . 51)(choice_relation . 
571)(factor . 153)(name . 154)(primary . 157)(qualified_expression . 
54)(selected_component . 55)(simple_expression . 446)(term . 165)(term_list . 
166)(unary_adding_operator . 167))
       ((aggregate . 151)(attribute_reference . 51)(choice_relation . 
570)(factor . 153)(name . 154)(primary . 157)(qualified_expression . 
54)(selected_component . 55)(simple_expression . 446)(term . 165)(term_list . 
166)(unary_adding_operator . 167))
-      nil
       ((aggregate . 151)(attribute_reference . 51)(choice_relation . 
569)(factor . 153)(name . 154)(primary . 157)(qualified_expression . 
54)(selected_component . 55)(simple_expression . 446)(term . 165)(term_list . 
166)(unary_adding_operator . 167))
       nil
       ((aggregate . 151)(attribute_reference . 51)(choice_relation . 
568)(factor . 153)(name . 154)(primary . 157)(qualified_expression . 
54)(selected_component . 55)(simple_expression . 446)(term . 165)(term_list . 
166)(unary_adding_operator . 167))
       nil
+      ((aggregate . 151)(attribute_reference . 51)(choice_relation . 
567)(factor . 153)(name . 154)(primary . 157)(qualified_expression . 
54)(selected_component . 55)(simple_expression . 446)(term . 165)(term_list . 
166)(unary_adding_operator . 167))
+      nil
       nil
       nil
       nil
-      ((relational_operator . 567))
+      ((relational_operator . 566))
       nil
       nil
-      ((aggregate . 151)(attribute_reference . 51)(factor . 
153)(membership_choice_list . 565)(membership_choice . 464)(name . 186)(primary 
. 157)(qualified_expression . 54)(range . 465)(selected_component . 
55)(simple_expression . 466)(term . 165)(term_list . 166)(unary_adding_operator 
. 167))
+      ((aggregate . 151)(attribute_reference . 51)(factor . 
153)(membership_choice_list . 564)(membership_choice . 464)(name . 186)(primary 
. 157)(qualified_expression . 54)(range . 465)(selected_component . 
55)(simple_expression . 466)(term . 165)(term_list . 166)(unary_adding_operator 
. 167))
       nil
       nil
       nil
@@ -3490,8 +3535,8 @@
       nil
       nil
       nil
-      ((access_definition . 556)(attribute_reference . 51)(name . 
557)(null_exclusion_opt . 212)(null_exclusion_opt_name . 
558)(qualified_expression . 54)(selected_component . 559))
-      ((discriminant_specification_opt . 553)(identifier_list . 254))
+      ((access_definition . 555)(attribute_reference . 51)(name . 
556)(null_exclusion_opt . 212)(null_exclusion_opt_name . 
557)(qualified_expression . 54)(selected_component . 558))
+      ((discriminant_specification_opt . 552)(identifier_list . 254))
       nil
       nil
       nil
@@ -3506,54 +3551,53 @@
       nil
       nil
       nil
-      ((aspect_specification_opt . 540))
+      ((aspect_specification_opt . 539))
       nil
       nil
       nil
       nil
       nil
-      ((aspect_specification_opt . 535))
+      ((aspect_specification_opt . 534))
       nil
       nil
       nil
       nil
-      ((aspect_specification_opt . 532))
-      ((attribute_reference . 51)(name . 531)(qualified_expression . 
54)(selected_component . 55))
-      ((actual_parameter_part . 91)(aspect_specification_opt . 530))
-      ((aggregate . 151)(attribute_reference . 51)(expression . 528)(factor . 
153)(name . 154)(primary . 157)(qualified_expression . 54)(relation_and_list . 
158)(relation_and_then_list . 159)(relation_or_list . 
160)(relation_or_else_list . 161)(relation_xor_list . 162)(relation . 
163)(selected_component . 55)(simple_expression . 164)(term . 165)(term_list . 
166)(unary_adding_operator . 167))
+      ((aspect_specification_opt . 531))
+      ((attribute_reference . 51)(name . 530)(qualified_expression . 
54)(selected_component . 55))
+      ((actual_parameter_part . 91)(aspect_specification_opt . 529))
+      ((aggregate . 151)(attribute_reference . 51)(expression . 527)(factor . 
153)(name . 154)(primary . 157)(qualified_expression . 54)(relation_and_list . 
158)(relation_and_then_list . 159)(relation_or_list . 
160)(relation_or_else_list . 161)(relation_xor_list . 162)(relation . 
163)(selected_component . 55)(simple_expression . 164)(term . 165)(term_list . 
166)(unary_adding_operator . 167))
       nil
       nil
       nil
       nil
       nil
-      ((attribute_reference . 51)(name . 526)(qualified_expression . 
54)(selected_component . 55))
+      ((attribute_reference . 51)(name . 525)(qualified_expression . 
54)(selected_component . 55))
       nil
       nil
+      ((access_definition . 521)(mode_opt . 522)(null_exclusion_opt . 212))
       nil
-      ((mode_opt . 522))
+      ((aggregate . 151)(association_opt . 173)(association_list . 
520)(attribute_reference . 51)(choice_expression . 
175)(choice_relation_and_list . 176)(choice_relation_or_list . 
177)(choice_relation_xor_list . 178)(choice_relation_and_then_list . 
179)(choice_relation_or_else_list . 180)(choice_relation . 181)(discrete_choice 
. 182)(discrete_choice_list . 183)(expression . 184)(expression_opt . 
185)(factor . 153)(name . 186)(primary . 157)(qualified_expression . 54)(range 
. 187)(relati [...]
       nil
-      ((aggregate . 151)(association_opt . 173)(association_list . 
521)(attribute_reference . 51)(choice_expression . 
175)(choice_relation_and_list . 176)(choice_relation_or_list . 
177)(choice_relation_xor_list . 178)(choice_relation_and_then_list . 
179)(choice_relation_or_else_list . 180)(choice_relation . 181)(discrete_choice 
. 182)(discrete_choice_list . 183)(expression . 184)(expression_opt . 
185)(factor . 153)(name . 186)(primary . 157)(qualified_expression . 54)(range 
. 187)(relati [...]
       nil
       nil
       nil
       nil
       nil
-      ((null_exclusion_opt . 786))
-      ((aggregate . 151)(attribute_reference . 51)(expression . 785)(factor . 
153)(name . 154)(primary . 157)(qualified_expression . 54)(relation_and_list . 
158)(relation_and_then_list . 159)(relation_or_list . 
160)(relation_or_else_list . 161)(relation_xor_list . 162)(relation . 
163)(selected_component . 55)(simple_expression . 164)(term . 165)(term_list . 
166)(unary_adding_operator . 167))
-      ((formal_part . 92)(parameter_and_result_profile . 784))
-      ((formal_part . 116)(parameter_profile_opt . 783))
+      ((null_exclusion_opt . 784))
+      ((formal_part . 92)(parameter_and_result_profile . 783))
+      ((formal_part . 116)(parameter_profile_opt . 782))
       ((actual_parameter_part . 91))
       nil
-      ((aspect_specification_opt . 781))
-      ((aggregate . 151)(attribute_reference . 51)(expression . 780)(factor . 
153)(name . 154)(primary . 157)(qualified_expression . 54)(relation_and_list . 
158)(relation_and_then_list . 159)(relation_or_list . 
160)(relation_or_else_list . 161)(relation_xor_list . 162)(relation . 
163)(selected_component . 55)(simple_expression . 164)(term . 165)(term_list . 
166)(unary_adding_operator . 167))
+      ((aspect_specification_opt . 780))
+      ((aggregate . 151)(attribute_reference . 51)(expression . 779)(factor . 
153)(name . 154)(primary . 157)(qualified_expression . 54)(relation_and_list . 
158)(relation_and_then_list . 159)(relation_or_list . 
160)(relation_or_else_list . 161)(relation_xor_list . 162)(relation . 
163)(selected_component . 55)(simple_expression . 164)(term . 165)(term_list . 
166)(unary_adding_operator . 167))
       nil
-      ((actual_parameter_part . 91)(formal_package_actual_part . 778))
+      ((actual_parameter_part . 91)(formal_package_actual_part . 777))
       nil
       nil
       nil
       nil
       nil
-      ((attribute_reference . 51)(name . 774)(qualified_expression . 
54)(selected_component . 55))
+      ((attribute_reference . 51)(name . 773)(qualified_expression . 
54)(selected_component . 55))
       nil
       nil
       nil
@@ -3565,7 +3609,7 @@
       nil
       nil
       nil
-      ((aggregate . 151)(attribute_reference . 51)(discrete_subtype_definition 
. 759)(discrete_subtype_definition_list . 760)(factor . 
153)(index_subtype_definition . 761)(index_subtype_definition_list . 762)(name 
. 763)(primary . 157)(qualified_expression . 54)(range . 
764)(selected_component . 55)(simple_expression . 765)(subtype_indication . 
766)(term . 165)(term_list . 166)(unary_adding_operator . 167))
+      ((aggregate . 151)(attribute_reference . 51)(discrete_subtype_definition 
. 758)(discrete_subtype_definition_list . 759)(factor . 
153)(index_subtype_definition . 760)(index_subtype_definition_list . 761)(name 
. 762)(primary . 157)(qualified_expression . 54)(range . 
763)(selected_component . 55)(simple_expression . 764)(subtype_indication . 
765)(term . 165)(term_list . 166)(unary_adding_operator . 167))
       nil
       nil
       nil
@@ -3580,72 +3624,72 @@
       nil
       nil
       nil
-      ((aggregate . 151)(attribute_reference . 51)(factor . 
153)(membership_choice . 753)(name . 186)(primary . 157)(qualified_expression . 
54)(range . 465)(selected_component . 55)(simple_expression . 466)(term . 
165)(term_list . 166)(unary_adding_operator . 167))
+      ((aggregate . 151)(attribute_reference . 51)(factor . 
153)(membership_choice . 752)(name . 186)(primary . 157)(qualified_expression . 
54)(range . 465)(selected_component . 55)(simple_expression . 466)(term . 
165)(term_list . 166)(unary_adding_operator . 167))
       nil
-      ((aggregate . 151)(attribute_reference . 51)(expression . 752)(factor . 
153)(name . 154)(primary . 157)(qualified_expression . 54)(relation_and_list . 
158)(relation_and_then_list . 159)(relation_or_list . 
160)(relation_or_else_list . 161)(relation_xor_list . 162)(relation . 
163)(selected_component . 55)(simple_expression . 164)(term . 165)(term_list . 
166)(unary_adding_operator . 167))
-      ((aggregate . 151)(attribute_reference . 51)(factor . 153)(name . 
154)(primary . 157)(qualified_expression . 54)(selected_component . 
55)(simple_expression . 751)(term . 165)(term_list . 166)(unary_adding_operator 
. 167))
+      ((aggregate . 151)(attribute_reference . 51)(expression . 751)(factor . 
153)(name . 154)(primary . 157)(qualified_expression . 54)(relation_and_list . 
158)(relation_and_then_list . 159)(relation_or_list . 
160)(relation_or_else_list . 161)(relation_xor_list . 162)(relation . 
163)(selected_component . 55)(simple_expression . 164)(term . 165)(term_list . 
166)(unary_adding_operator . 167))
+      ((aggregate . 151)(attribute_reference . 51)(factor . 153)(name . 
154)(primary . 157)(qualified_expression . 54)(selected_component . 
55)(simple_expression . 750)(term . 165)(term_list . 166)(unary_adding_operator 
. 167))
       nil
       nil
       nil
       nil
       nil
       nil
-      ((attribute_reference . 51)(name . 748)(qualified_expression . 
54)(selected_component . 55))
-      ((aggregate . 746)(record_rep . 747))
+      ((attribute_reference . 51)(name . 747)(qualified_expression . 
54)(selected_component . 55))
+      ((aggregate . 745)(record_rep . 746))
       nil
-      ((aggregate . 151)(attribute_reference . 51)(expression . 743)(factor . 
153)(name . 154)(primary . 157)(qualified_expression . 54)(relation_and_list . 
158)(relation_and_then_list . 159)(relation_or_list . 
160)(relation_or_else_list . 161)(relation_xor_list . 162)(relation . 
163)(selected_component . 55)(simple_expression . 164)(term . 165)(term_list . 
166)(unary_adding_operator . 167))
+      ((aggregate . 151)(attribute_reference . 51)(expression . 742)(factor . 
153)(name . 154)(primary . 157)(qualified_expression . 54)(relation_and_list . 
158)(relation_and_then_list . 159)(relation_or_list . 
160)(relation_or_else_list . 161)(relation_xor_list . 162)(relation . 
163)(selected_component . 55)(simple_expression . 164)(term . 165)(term_list . 
166)(unary_adding_operator . 167))
       ((actual_parameter_part . 91)(aspect_specification_opt . 168))
-      ((discriminant_part_opt . 741))
-      ((aspect_specification_opt . 707))
-      nil
-      ((attribute_reference . 51)(name . 737)(qualified_expression . 
54)(selected_component . 55)(subtype_indication . 738))
-      ((discriminant_part_opt . 735))
+      ((discriminant_part_opt . 740))
       ((aspect_specification_opt . 706))
       nil
+      ((attribute_reference . 51)(name . 736)(qualified_expression . 
54)(selected_component . 55)(subtype_indication . 737))
+      ((discriminant_part_opt . 734))
+      ((aspect_specification_opt . 705))
+      nil
       nil
       nil
       nil
       ((actual_parameter_part . 91))
       nil
       nil
-      ((constant_opt . 727))
+      ((constant_opt . 726))
       nil
       nil
-      ((paren_expression . 722))
-      ((formal_part . 116)(parameter_profile_opt . 720))
-      ((accept_statement . 630)(assignment_statement . 
631)(asynchronous_select . 632)(attribute_reference . 51)(block_statement . 
633)(case_statement . 634)(conditional_entry_call . 635)(delay_statement . 
636)(exit_statement . 637)(extended_return_statement . 
638)(handled_sequence_of_statements . 718)(if_statement . 640)(iteration_scheme 
. 641)(label_opt . 642)(loop_statement . 643)(name . 644)(pragma . 
645)(procedure_call_statement . 646)(qualified_expression . 54)(raise_statement 
. 64 [...]
-      ((attribute_reference . 51)(name . 210)(name_opt . 
717)(qualified_expression . 54)(selected_component . 55))
+      ((paren_expression . 721))
+      ((formal_part . 116)(parameter_profile_opt . 719))
+      ((accept_statement . 629)(assignment_statement . 
630)(asynchronous_select . 631)(attribute_reference . 51)(block_statement . 
632)(case_statement . 633)(conditional_entry_call . 634)(delay_statement . 
635)(exit_statement . 636)(extended_return_statement . 
637)(handled_sequence_of_statements . 717)(if_statement . 639)(iteration_scheme 
. 640)(label_opt . 641)(loop_statement . 642)(name . 643)(pragma . 
644)(procedure_call_statement . 645)(qualified_expression . 54)(raise_statement 
. 64 [...]
+      ((attribute_reference . 51)(name . 210)(name_opt . 
716)(qualified_expression . 54)(selected_component . 55))
       nil
       nil
       nil
       nil
-      ((case_expression_alternative . 715)(case_expression_alternative_list . 
716))
+      ((case_expression_alternative . 714)(case_expression_alternative_list . 
715))
       nil
       nil
-      ((aggregate . 151)(attribute_reference . 51)(expression . 709)(factor . 
153)(name . 154)(primary . 157)(qualified_expression . 54)(relation_and_list . 
158)(relation_and_then_list . 159)(relation_or_list . 
160)(relation_or_else_list . 161)(relation_xor_list . 162)(relation . 
163)(selected_component . 55)(simple_expression . 164)(term . 165)(term_list . 
166)(unary_adding_operator . 167))
       ((aggregate . 151)(attribute_reference . 51)(expression . 708)(factor . 
153)(name . 154)(primary . 157)(qualified_expression . 54)(relation_and_list . 
158)(relation_and_then_list . 159)(relation_or_list . 
160)(relation_or_else_list . 161)(relation_xor_list . 162)(relation . 
163)(selected_component . 55)(simple_expression . 164)(term . 165)(term_list . 
166)(unary_adding_operator . 167))
-      ((aspect_specification_opt . 707))
+      ((aggregate . 151)(attribute_reference . 51)(expression . 707)(factor . 
153)(name . 154)(primary . 157)(qualified_expression . 54)(relation_and_list . 
158)(relation_and_then_list . 159)(relation_or_list . 
160)(relation_or_else_list . 161)(relation_xor_list . 162)(relation . 
163)(selected_component . 55)(simple_expression . 164)(term . 165)(term_list . 
166)(unary_adding_operator . 167))
       ((aspect_specification_opt . 706))
+      ((aspect_specification_opt . 705))
       nil
       nil
       nil
       nil
-      ((attribute_reference . 51)(name . 702)(qualified_expression . 
54)(selected_component . 55))
-      ((accept_statement . 630)(assignment_statement . 
631)(asynchronous_select . 632)(attribute_reference . 51)(block_statement . 
633)(case_statement . 634)(conditional_entry_call . 635)(delay_statement . 
636)(exit_statement . 637)(extended_return_statement . 
638)(handled_sequence_of_statements . 701)(if_statement . 640)(iteration_scheme 
. 641)(label_opt . 642)(loop_statement . 643)(name . 644)(pragma . 
645)(procedure_call_statement . 646)(qualified_expression . 54)(raise_statement 
. 64 [...]
-      ((aggregate . 151)(attribute_reference . 51)(expression . 
184)(expression_opt . 700)(factor . 153)(name . 154)(primary . 
157)(qualified_expression . 54)(relation_and_list . 158)(relation_and_then_list 
. 159)(relation_or_list . 160)(relation_or_else_list . 161)(relation_xor_list . 
162)(relation . 163)(selected_component . 55)(simple_expression . 164)(term . 
165)(term_list . 166)(unary_adding_operator . 167))
-      ((abstract_subprogram_declaration . 295)(aspect_clause . 296)(at_clause 
. 297)(body . 298)(body_stub . 299)(declaration . 300)(declarations . 
301)(declarative_part_opt . 699)(entry_declaration . 
303)(enumeration_representation_clause . 304)(exception_declaration . 
305)(expression_function_declaration . 306)(full_type_declaration . 
307)(function_specification . 16)(generic_declaration . 
308)(generic_formal_part . 18)(generic_instantiation . 
309)(generic_package_declaration . 20)(gen [...]
-      ((aggregate . 151)(attribute_reference . 51)(expression . 698)(factor . 
153)(name . 154)(primary . 157)(qualified_expression . 54)(relation_and_list . 
158)(relation_and_then_list . 159)(relation_or_list . 
160)(relation_or_else_list . 161)(relation_xor_list . 162)(relation . 
163)(selected_component . 55)(simple_expression . 164)(term . 165)(term_list . 
166)(unary_adding_operator . 167))
-      ((identifier_opt . 696))
-      ((iterator_specification . 693)(iterator_specification_opt . 694))
+      ((attribute_reference . 51)(name . 701)(qualified_expression . 
54)(selected_component . 55))
+      ((accept_statement . 629)(assignment_statement . 
630)(asynchronous_select . 631)(attribute_reference . 51)(block_statement . 
632)(case_statement . 633)(conditional_entry_call . 634)(delay_statement . 
635)(exit_statement . 636)(extended_return_statement . 
637)(handled_sequence_of_statements . 700)(if_statement . 639)(iteration_scheme 
. 640)(label_opt . 641)(loop_statement . 642)(name . 643)(pragma . 
644)(procedure_call_statement . 645)(qualified_expression . 54)(raise_statement 
. 64 [...]
+      ((aggregate . 151)(attribute_reference . 51)(expression . 
184)(expression_opt . 699)(factor . 153)(name . 154)(primary . 
157)(qualified_expression . 54)(relation_and_list . 158)(relation_and_then_list 
. 159)(relation_or_list . 160)(relation_or_else_list . 161)(relation_xor_list . 
162)(relation . 163)(selected_component . 55)(simple_expression . 164)(term . 
165)(term_list . 166)(unary_adding_operator . 167))
+      ((abstract_subprogram_declaration . 295)(aspect_clause . 296)(at_clause 
. 297)(body . 298)(body_stub . 299)(declaration . 300)(declarations . 
301)(declarative_part_opt . 698)(entry_declaration . 
303)(enumeration_representation_clause . 304)(exception_declaration . 
305)(expression_function_declaration . 306)(full_type_declaration . 
307)(function_specification . 16)(generic_declaration . 
308)(generic_formal_part . 18)(generic_instantiation . 
309)(generic_package_declaration . 20)(gen [...]
+      ((aggregate . 151)(attribute_reference . 51)(expression . 697)(factor . 
153)(name . 154)(primary . 157)(qualified_expression . 54)(relation_and_list . 
158)(relation_and_then_list . 159)(relation_or_list . 
160)(relation_or_else_list . 161)(relation_xor_list . 162)(relation . 
163)(selected_component . 55)(simple_expression . 164)(term . 165)(term_list . 
166)(unary_adding_operator . 167))
+      ((identifier_opt . 695))
+      ((iterator_specification . 692)(iterator_specification_opt . 693))
       nil
-      ((aggregate . 151)(attribute_reference . 51)(expression . 
184)(expression_opt . 691)(factor . 153)(name . 154)(primary . 
157)(qualified_expression . 54)(relation_and_list . 158)(relation_and_then_list 
. 159)(relation_or_list . 160)(relation_or_else_list . 161)(relation_xor_list . 
162)(relation . 163)(selected_component . 55)(simple_expression . 164)(term . 
165)(term_list . 166)(unary_adding_operator . 167))
-      ((accept_statement . 630)(assignment_statement . 
631)(asynchronous_select . 632)(attribute_reference . 51)(block_statement . 
633)(case_statement . 634)(conditional_entry_call . 635)(delay_statement . 
636)(exit_statement . 637)(extended_return_statement . 638)(if_statement . 
640)(iteration_scheme . 641)(label_opt . 642)(loop_statement . 643)(name . 
644)(pragma . 645)(procedure_call_statement . 646)(qualified_expression . 
54)(raise_statement . 647)(requeue_statement . 648)(selected_c [...]
+      ((aggregate . 151)(attribute_reference . 51)(expression . 
184)(expression_opt . 690)(factor . 153)(name . 154)(primary . 
157)(qualified_expression . 54)(relation_and_list . 158)(relation_and_then_list 
. 159)(relation_or_list . 160)(relation_or_else_list . 161)(relation_xor_list . 
162)(relation . 163)(selected_component . 55)(simple_expression . 164)(term . 
165)(term_list . 166)(unary_adding_operator . 167))
+      ((accept_statement . 629)(assignment_statement . 
630)(asynchronous_select . 631)(attribute_reference . 51)(block_statement . 
632)(case_statement . 633)(conditional_entry_call . 634)(delay_statement . 
635)(exit_statement . 636)(extended_return_statement . 637)(if_statement . 
639)(iteration_scheme . 640)(label_opt . 641)(loop_statement . 642)(name . 
643)(pragma . 644)(procedure_call_statement . 645)(qualified_expression . 
54)(raise_statement . 646)(requeue_statement . 647)(selected_c [...]
       nil
-      ((attribute_reference . 51)(name . 688)(qualified_expression . 
54)(selected_component . 55))
-      ((attribute_reference . 51)(name . 686)(qualified_expression . 
54)(selected_component . 55))
-      ((aggregate . 151)(attribute_reference . 51)(expression . 
683)(extended_return_object_declaration . 
684)(extended_return_object_declaration_opt . 685)(factor . 153)(name . 
154)(primary . 157)(qualified_expression . 54)(relation_and_list . 
158)(relation_and_then_list . 159)(relation_or_list . 
160)(relation_or_else_list . 161)(relation_xor_list . 162)(relation . 
163)(selected_component . 55)(simple_expression . 164)(term . 165)(term_list . 
166)(unary_adding_operator . 167))
-      ((accept_statement . 671)(attribute_reference . 51)(delay_alternative . 
672)(delay_statement . 673)(entry_call_alternative . 674)(name . 
675)(procedure_call_statement . 676)(qualified_expression . 
54)(selected_component . 55)(select_alternative . 677)(select_alternative_list 
. 678)(select_alternative_list_opt . 679)(triggering_alternative . 680))
-      ((aggregate . 151)(attribute_reference . 51)(expression . 
184)(expression_opt . 668)(factor . 153)(name . 154)(primary . 
157)(qualified_expression . 54)(relation_and_list . 158)(relation_and_then_list 
. 159)(relation_or_list . 160)(relation_or_else_list . 161)(relation_xor_list . 
162)(relation . 163)(selected_component . 55)(simple_expression . 164)(term . 
165)(term_list . 166)(unary_adding_operator . 167))
+      ((attribute_reference . 51)(name . 687)(qualified_expression . 
54)(selected_component . 55))
+      ((attribute_reference . 51)(name . 685)(qualified_expression . 
54)(selected_component . 55))
+      ((aggregate . 151)(attribute_reference . 51)(expression . 
682)(extended_return_object_declaration . 
683)(extended_return_object_declaration_opt . 684)(factor . 153)(name . 
154)(primary . 157)(qualified_expression . 54)(relation_and_list . 
158)(relation_and_then_list . 159)(relation_or_list . 
160)(relation_or_else_list . 161)(relation_xor_list . 162)(relation . 
163)(selected_component . 55)(simple_expression . 164)(term . 165)(term_list . 
166)(unary_adding_operator . 167))
+      ((accept_statement . 670)(attribute_reference . 51)(delay_alternative . 
671)(delay_statement . 672)(entry_call_alternative . 673)(name . 
674)(procedure_call_statement . 675)(qualified_expression . 
54)(selected_component . 55)(select_alternative . 676)(select_alternative_list 
. 677)(select_alternative_list_opt . 678)(triggering_alternative . 679))
+      ((aggregate . 151)(attribute_reference . 51)(expression . 
184)(expression_opt . 667)(factor . 153)(name . 154)(primary . 
157)(qualified_expression . 54)(relation_and_list . 158)(relation_and_then_list 
. 159)(relation_or_list . 160)(relation_or_else_list . 161)(relation_xor_list . 
162)(relation . 163)(selected_component . 55)(simple_expression . 164)(term . 
165)(term_list . 166)(unary_adding_operator . 167))
       nil
       nil
       nil
@@ -3658,7 +3702,7 @@
       nil
       nil
       nil
-      ((accept_statement . 630)(assignment_statement . 
631)(asynchronous_select . 632)(attribute_reference . 51)(block_statement . 
633)(case_statement . 634)(compound_statement . 664)(conditional_entry_call . 
635)(delay_statement . 636)(exit_statement . 637)(extended_return_statement . 
638)(if_statement . 640)(iteration_scheme . 641)(loop_statement . 643)(name . 
644)(pragma . 645)(procedure_call_statement . 646)(qualified_expression . 
54)(raise_statement . 647)(requeue_statement . 648)(s [...]
+      ((accept_statement . 629)(assignment_statement . 
630)(asynchronous_select . 631)(attribute_reference . 51)(block_statement . 
632)(case_statement . 633)(compound_statement . 663)(conditional_entry_call . 
634)(delay_statement . 635)(exit_statement . 636)(extended_return_statement . 
637)(if_statement . 639)(iteration_scheme . 640)(loop_statement . 642)(name . 
643)(pragma . 644)(procedure_call_statement . 645)(qualified_expression . 
54)(raise_statement . 646)(requeue_statement . 647)(s [...]
       nil
       ((actual_parameter_part . 91))
       nil
@@ -3667,7 +3711,7 @@
       nil
       nil
       nil
-      ((accept_statement . 630)(assignment_statement . 
631)(asynchronous_select . 632)(attribute_reference . 51)(block_statement . 
633)(case_statement . 634)(conditional_entry_call . 635)(delay_statement . 
636)(exit_statement . 637)(extended_return_statement . 638)(if_statement . 
640)(iteration_scheme . 641)(label_opt . 642)(loop_statement . 643)(name . 
644)(pragma . 645)(procedure_call_statement . 646)(qualified_expression . 
54)(raise_statement . 647)(requeue_statement . 648)(selected_c [...]
+      ((accept_statement . 629)(assignment_statement . 
630)(asynchronous_select . 631)(attribute_reference . 51)(block_statement . 
632)(case_statement . 633)(conditional_entry_call . 634)(delay_statement . 
635)(exit_statement . 636)(extended_return_statement . 637)(if_statement . 
639)(iteration_scheme . 640)(label_opt . 641)(loop_statement . 642)(name . 
643)(pragma . 644)(procedure_call_statement . 645)(qualified_expression . 
54)(raise_statement . 646)(requeue_statement . 647)(selected_c [...]
       nil
       nil
       nil
@@ -3682,17 +3726,17 @@
       nil
       nil
       nil
-      ((accept_statement . 630)(assignment_statement . 
631)(asynchronous_select . 632)(attribute_reference . 51)(block_statement . 
633)(case_statement . 634)(conditional_entry_call . 635)(delay_statement . 
636)(exit_statement . 637)(extended_return_statement . 638)(if_statement . 
640)(iteration_scheme . 641)(label_opt . 642)(loop_statement . 643)(name . 
644)(pragma . 645)(procedure_call_statement . 646)(qualified_expression . 
54)(raise_statement . 647)(requeue_statement . 648)(selected_c [...]
+      ((accept_statement . 629)(assignment_statement . 
630)(asynchronous_select . 631)(attribute_reference . 51)(block_statement . 
632)(case_statement . 633)(conditional_entry_call . 634)(delay_statement . 
635)(exit_statement . 636)(extended_return_statement . 637)(if_statement . 
639)(iteration_scheme . 640)(label_opt . 641)(loop_statement . 642)(name . 
643)(pragma . 644)(procedure_call_statement . 645)(qualified_expression . 
54)(raise_statement . 646)(requeue_statement . 647)(selected_c [...]
       ((attribute_reference . 51)(name . 210)(name_opt . 
927)(qualified_expression . 54)(selected_component . 55))
       nil
       nil
       ((aggregate . 151)(attribute_reference . 51)(expression . 925)(factor . 
153)(name . 154)(primary . 157)(qualified_expression . 54)(relation_and_list . 
158)(relation_and_then_list . 159)(relation_or_list . 
160)(relation_or_else_list . 161)(relation_xor_list . 162)(relation . 
163)(selected_component . 55)(simple_expression . 164)(term . 165)(term_list . 
166)(unary_adding_operator . 167))
-      ((accept_statement . 630)(assignment_statement . 
631)(asynchronous_select . 632)(attribute_reference . 51)(block_statement . 
633)(case_statement . 634)(conditional_entry_call . 635)(delay_statement . 
636)(exit_statement . 637)(extended_return_statement . 638)(if_statement . 
640)(iteration_scheme . 641)(label_opt . 642)(loop_statement . 643)(name . 
644)(pragma . 645)(procedure_call_statement . 646)(qualified_expression . 
54)(raise_statement . 647)(requeue_statement . 648)(selected_c [...]
+      ((accept_statement . 629)(assignment_statement . 
630)(asynchronous_select . 631)(attribute_reference . 51)(block_statement . 
632)(case_statement . 633)(conditional_entry_call . 634)(delay_statement . 
635)(exit_statement . 636)(extended_return_statement . 637)(if_statement . 
639)(iteration_scheme . 640)(label_opt . 641)(loop_statement . 642)(name . 
643)(pragma . 644)(procedure_call_statement . 645)(qualified_expression . 
54)(raise_statement . 646)(requeue_statement . 647)(selected_c [...]
       nil
-      ((accept_statement . 630)(assignment_statement . 
631)(asynchronous_select . 632)(attribute_reference . 51)(block_statement . 
633)(case_statement . 634)(conditional_entry_call . 635)(delay_statement . 
636)(exit_statement . 637)(extended_return_statement . 638)(if_statement . 
640)(iteration_scheme . 641)(label_opt . 642)(loop_statement . 643)(name . 
644)(pragma . 645)(procedure_call_statement . 646)(qualified_expression . 
54)(raise_statement . 647)(requeue_statement . 648)(selected_c [...]
+      ((accept_statement . 629)(assignment_statement . 
630)(asynchronous_select . 631)(attribute_reference . 51)(block_statement . 
632)(case_statement . 633)(conditional_entry_call . 634)(delay_statement . 
635)(exit_statement . 636)(extended_return_statement . 637)(if_statement . 
639)(iteration_scheme . 640)(label_opt . 641)(loop_statement . 642)(name . 
643)(pragma . 644)(procedure_call_statement . 645)(qualified_expression . 
54)(raise_statement . 646)(requeue_statement . 647)(selected_c [...]
       nil
-      ((accept_statement . 630)(actual_parameter_part . 
91)(assignment_statement . 631)(asynchronous_select . 632)(attribute_reference 
. 51)(block_statement . 633)(case_statement . 634)(conditional_entry_call . 
635)(delay_statement . 636)(exit_statement . 637)(extended_return_statement . 
638)(if_statement . 640)(iteration_scheme . 641)(label_opt . 
642)(loop_statement . 643)(name . 644)(pragma . 645)(procedure_call_statement . 
646)(qualified_expression . 54)(raise_statement . 647)(requeue [...]
-      ((accept_statement . 630)(assignment_statement . 
631)(asynchronous_select . 632)(attribute_reference . 51)(block_statement . 
633)(case_statement . 634)(conditional_entry_call . 635)(delay_statement . 
636)(exit_statement . 637)(extended_return_statement . 638)(if_statement . 
640)(iteration_scheme . 641)(label_opt . 642)(loop_statement . 643)(name . 
644)(pragma . 645)(procedure_call_statement . 646)(qualified_expression . 
54)(raise_statement . 647)(requeue_statement . 648)(selected_c [...]
+      ((accept_statement . 629)(actual_parameter_part . 
91)(assignment_statement . 630)(asynchronous_select . 631)(attribute_reference 
. 51)(block_statement . 632)(case_statement . 633)(conditional_entry_call . 
634)(delay_statement . 635)(exit_statement . 636)(extended_return_statement . 
637)(if_statement . 639)(iteration_scheme . 640)(label_opt . 
641)(loop_statement . 642)(name . 643)(pragma . 644)(procedure_call_statement . 
645)(qualified_expression . 54)(raise_statement . 646)(requeue [...]
+      ((accept_statement . 629)(assignment_statement . 
630)(asynchronous_select . 631)(attribute_reference . 51)(block_statement . 
632)(case_statement . 633)(conditional_entry_call . 634)(delay_statement . 
635)(exit_statement . 636)(extended_return_statement . 637)(if_statement . 
639)(iteration_scheme . 640)(label_opt . 641)(loop_statement . 642)(name . 
643)(pragma . 644)(procedure_call_statement . 645)(qualified_expression . 
54)(raise_statement . 646)(requeue_statement . 647)(selected_c [...]
       nil
       nil
       nil
@@ -3727,15 +3771,15 @@
       nil
       ((elsif_expression_item . 888)(elsif_expression_list . 889))
       ((aggregate . 151)(attribute_reference . 51)(expression . 885)(factor . 
153)(name . 154)(primary . 157)(qualified_expression . 54)(relation_and_list . 
158)(relation_and_then_list . 159)(relation_or_list . 
160)(relation_or_else_list . 161)(relation_xor_list . 162)(relation . 
163)(selected_component . 55)(simple_expression . 164)(term . 165)(term_list . 
166)(unary_adding_operator . 167))
-      ((attribute_reference . 51)(name . 737)(qualified_expression . 
54)(selected_component . 55)(subtype_indication . 884))
-      ((aggregate . 151)(attribute_reference . 51)(discrete_subtype_definition 
. 883)(factor . 153)(name . 875)(primary . 157)(qualified_expression . 
54)(range . 764)(selected_component . 55)(simple_expression . 
765)(subtype_indication . 766)(term . 165)(term_list . 
166)(unary_adding_operator . 167))
+      ((attribute_reference . 51)(name . 736)(qualified_expression . 
54)(selected_component . 55)(subtype_indication . 884))
+      ((aggregate . 151)(attribute_reference . 51)(discrete_subtype_definition 
. 883)(factor . 153)(name . 875)(primary . 157)(qualified_expression . 
54)(range . 763)(selected_component . 55)(simple_expression . 
764)(subtype_indication . 765)(term . 165)(term_list . 
166)(unary_adding_operator . 167))
       ((attribute_reference . 51)(name . 881)(qualified_expression . 
54)(selected_component . 55))
       ((aggregate . 151)(attribute_reference . 51)(choice_expression . 
175)(choice_relation_and_list . 176)(choice_relation_or_list . 
177)(choice_relation_xor_list . 178)(choice_relation_and_then_list . 
179)(choice_relation_or_else_list . 180)(choice_relation . 181)(discrete_choice 
. 182)(discrete_choice_list . 879)(factor . 153)(name . 186)(primary . 
157)(qualified_expression . 54)(range . 187)(selected_component . 
55)(simple_expression . 459)(term . 165)(term_list . 166)(unary_adding_o [...]
       nil
       nil
       nil
       nil
-      ((aggregate . 151)(attribute_reference . 51)(discrete_subtype_definition 
. 874)(factor . 153)(identifier_list . 214)(name . 875)(parameter_specification 
. 215)(parameter_specification_list . 216)(primary . 157)(qualified_expression 
. 54)(range . 764)(selected_component . 55)(simple_expression . 
765)(subtype_indication . 766)(term . 165)(term_list . 
166)(unary_adding_operator . 167))
+      ((aggregate . 151)(attribute_reference . 51)(discrete_subtype_definition 
. 874)(factor . 153)(identifier_list . 214)(name . 875)(parameter_specification 
. 215)(parameter_specification_list . 216)(primary . 157)(qualified_expression 
. 54)(range . 763)(selected_component . 55)(simple_expression . 
764)(subtype_indication . 765)(term . 165)(term_list . 
166)(unary_adding_operator . 167))
       ((aspect_specification_opt . 873))
       ((aggregate . 151)(attribute_reference . 51)(case_expression . 
870)(expression . 871)(factor . 153)(if_expression . 872)(name . 154)(primary . 
157)(qualified_expression . 54)(relation_and_list . 158)(relation_and_then_list 
. 159)(relation_or_list . 160)(relation_or_else_list . 161)(relation_xor_list . 
162)(relation . 163)(selected_component . 55)(simple_expression . 164)(term . 
165)(term_list . 166)(unary_adding_operator . 167))
       ((aspect_specification_opt . 869))
@@ -3743,7 +3787,7 @@
       ((aspect_specification_opt . 867))
       ((aspect_specification_opt . 866))
       nil
-      ((access_definition . 863)(array_type_definition . 
864)(attribute_reference . 51)(name . 737)(null_exclusion_opt . 
212)(qualified_expression . 54)(selected_component . 55)(subtype_indication . 
865))
+      ((access_definition . 863)(array_type_definition . 
864)(attribute_reference . 51)(name . 736)(null_exclusion_opt . 
212)(qualified_expression . 54)(selected_component . 55)(subtype_indication . 
865))
       nil
       ((aggregate . 151)(attribute_reference . 51)(expression . 861)(factor . 
153)(name . 154)(primary . 157)(qualified_expression . 54)(relation_and_list . 
158)(relation_and_then_list . 159)(relation_or_list . 
160)(relation_or_else_list . 161)(relation_xor_list . 162)(relation . 
163)(selected_component . 55)(simple_expression . 164)(term . 165)(term_list . 
166)(unary_adding_operator . 167))
       ((attribute_reference . 51)(name . 210)(name_opt . 
860)(qualified_expression . 54)(selected_component . 55))
@@ -3772,7 +3816,7 @@
       nil
       ((aggregate . 151)(attribute_reference . 51)(expression . 815)(factor . 
153)(name . 154)(primary . 157)(qualified_expression . 54)(relation_and_list . 
158)(relation_and_then_list . 159)(relation_or_list . 
160)(relation_or_else_list . 161)(relation_xor_list . 162)(relation . 
163)(selected_component . 55)(simple_expression . 164)(term . 165)(term_list . 
166)(unary_adding_operator . 167))
       ((aggregate . 151)(attribute_reference . 51)(expression . 814)(factor . 
153)(name . 154)(primary . 157)(qualified_expression . 54)(relation_and_list . 
158)(relation_and_then_list . 159)(relation_or_list . 
160)(relation_or_else_list . 161)(relation_xor_list . 162)(relation . 
163)(selected_component . 55)(simple_expression . 164)(term . 165)(term_list . 
166)(unary_adding_operator . 167))
-      ((attribute_reference . 51)(name . 557)(qualified_expression . 
54)(selected_component . 813))
+      ((attribute_reference . 51)(name . 556)(qualified_expression . 
54)(selected_component . 813))
       nil
       ((aggregate . 151)(attribute_reference . 51)(name . 154)(primary . 
286)(qualified_expression . 54)(selected_component . 55))
       nil
@@ -3790,7 +3834,7 @@
       ((attribute_reference . 51)(interface_list . 799)(name . 
798)(qualified_expression . 54)(selected_component . 55))
       nil
       ((attribute_reference . 51)(interface_list . 797)(name . 
798)(qualified_expression . 54)(selected_component . 55))
-      ((actual_parameter_part . 91))
+      ((actual_parameter_part . 91)(and_interface_list_opt . 796))
       nil
       nil
       ((aggregate . 151)(association_opt . 173)(association_list . 
190)(attribute_reference . 51)(choice_expression . 
175)(choice_relation_and_list . 176)(choice_relation_or_list . 
177)(choice_relation_xor_list . 178)(choice_relation_and_then_list . 
179)(choice_relation_or_else_list . 180)(choice_relation . 181)(discrete_choice 
. 182)(discrete_choice_list . 183)(expression . 184)(expression_opt . 
185)(factor . 153)(name . 186)(primary . 157)(qualified_expression . 54)(range 
. 191)(relati [...]
@@ -3801,8 +3845,9 @@
       ((identifier_list . 214)(parameter_specification . 
215)(parameter_specification_list . 216))
       nil
       nil
-      nil
       ((attribute_reference . 51)(name . 790)(qualified_expression . 
54)(selected_component . 55))
+      ((aggregate . 151)(attribute_reference . 51)(expression . 789)(factor . 
153)(name . 154)(primary . 157)(qualified_expression . 54)(relation_and_list . 
158)(relation_and_then_list . 159)(relation_or_list . 
160)(relation_or_else_list . 161)(relation_xor_list . 162)(relation . 
163)(selected_component . 55)(simple_expression . 164)(term . 165)(term_list . 
166)(unary_adding_operator . 167))
+      nil
       nil
       nil
       nil
@@ -3819,13 +3864,13 @@
       nil
       nil
       nil
-      ((aggregate . 151)(association_opt . 173)(association_list . 
190)(attribute_reference . 51)(choice_expression . 
175)(choice_relation_and_list . 176)(choice_relation_or_list . 
177)(choice_relation_xor_list . 178)(choice_relation_and_then_list . 
179)(choice_relation_or_else_list . 180)(choice_relation . 181)(discrete_choice 
. 182)(discrete_choice_list . 183)(discrete_subtype_definition . 
759)(discrete_subtype_definition_list . 1059)(expression . 184)(expression_opt 
. 185)(factor . 15 [...]
-      ((aggregate . 151)(attribute_reference . 51)(factor . 153)(name . 
186)(primary . 157)(qualified_expression . 54)(range . 1035)(selected_component 
. 55)(simple_expression . 765)(term . 165)(term_list . 
166)(unary_adding_operator . 167))
+      ((aggregate . 151)(association_opt . 173)(association_list . 
190)(attribute_reference . 51)(choice_expression . 
175)(choice_relation_and_list . 176)(choice_relation_or_list . 
177)(choice_relation_xor_list . 178)(choice_relation_and_then_list . 
179)(choice_relation_or_else_list . 180)(choice_relation . 181)(discrete_choice 
. 182)(discrete_choice_list . 183)(discrete_subtype_definition . 
758)(discrete_subtype_definition_list . 1059)(expression . 184)(expression_opt 
. 185)(factor . 15 [...]
+      ((aggregate . 151)(attribute_reference . 51)(factor . 153)(name . 
186)(primary . 157)(qualified_expression . 54)(range . 1035)(selected_component 
. 55)(simple_expression . 764)(term . 165)(term_list . 
166)(unary_adding_operator . 167))
       nil
       nil
       ((attribute_reference . 51)(index_subtype_definition . 1055)(name . 
1056)(qualified_expression . 54)(selected_component . 55))
       nil
-      ((aggregate . 151)(attribute_reference . 51)(discrete_subtype_definition 
. 1053)(factor . 153)(name . 875)(primary . 157)(qualified_expression . 
54)(range . 764)(selected_component . 55)(simple_expression . 
765)(subtype_indication . 766)(term . 165)(term_list . 
166)(unary_adding_operator . 167))
+      ((aggregate . 151)(attribute_reference . 51)(discrete_subtype_definition 
. 1053)(factor . 153)(name . 875)(primary . 157)(qualified_expression . 
54)(range . 763)(selected_component . 55)(simple_expression . 
764)(subtype_indication . 765)(term . 165)(term_list . 
166)(unary_adding_operator . 167))
       nil
       ((attribute_reference . 51)(name . 1034)(qualified_expression . 
54)(selected_component . 55))
       nil
@@ -3849,7 +3894,7 @@
       nil
       nil
       nil
-      ((aggregate . 151)(attribute_reference . 51)(factor . 153)(name . 
186)(primary . 157)(qualified_expression . 54)(range . 1035)(selected_component 
. 55)(simple_expression . 765)(term . 165)(term_list . 
166)(unary_adding_operator . 167))
+      ((aggregate . 151)(attribute_reference . 51)(factor . 153)(name . 
186)(primary . 157)(qualified_expression . 54)(range . 1035)(selected_component 
. 55)(simple_expression . 764)(term . 165)(term_list . 
166)(unary_adding_operator . 167))
       ((attribute_reference . 51)(name . 1034)(qualified_expression . 
54)(selected_component . 55))
       nil
       ((aspect_specification_opt . 1031))
@@ -3898,7 +3943,7 @@
       nil
       ((attribute_reference . 51)(name . 981)(qualified_expression . 
54)(selected_component . 55))
       ((actual_parameter_part . 91))
-      ((aggregate . 151)(attribute_reference . 51)(discrete_subtype_definition 
. 980)(factor . 153)(name . 875)(primary . 157)(qualified_expression . 
54)(range . 764)(selected_component . 55)(simple_expression . 
765)(subtype_indication . 766)(term . 165)(term_list . 
166)(unary_adding_operator . 167))
+      ((aggregate . 151)(attribute_reference . 51)(discrete_subtype_definition 
. 980)(factor . 153)(name . 875)(primary . 157)(qualified_expression . 
54)(range . 763)(selected_component . 55)(simple_expression . 
764)(subtype_indication . 765)(term . 165)(term_list . 
166)(unary_adding_operator . 167))
       nil
       nil
       nil
@@ -3915,29 +3960,29 @@
       nil
       ((identifier_opt . 963))
       ((case_statement_alternative . 961)(case_statement_alternative_list . 
962))
-      ((accept_statement . 630)(assignment_statement . 
631)(asynchronous_select . 632)(attribute_reference . 51)(block_statement . 
633)(case_statement . 634)(conditional_entry_call . 635)(delay_statement . 
636)(exit_statement . 637)(extended_return_statement . 
638)(handled_sequence_of_statements . 959)(if_statement . 640)(iteration_scheme 
. 641)(label_opt . 642)(loop_statement . 643)(name . 644)(pragma . 
645)(procedure_call_statement . 646)(qualified_expression . 54)(raise_statement 
. 64 [...]
+      ((accept_statement . 629)(assignment_statement . 
630)(asynchronous_select . 631)(attribute_reference . 51)(block_statement . 
632)(case_statement . 633)(conditional_entry_call . 634)(delay_statement . 
635)(exit_statement . 636)(extended_return_statement . 
637)(handled_sequence_of_statements . 959)(if_statement . 639)(iteration_scheme 
. 640)(label_opt . 641)(loop_statement . 642)(name . 643)(pragma . 
644)(procedure_call_statement . 645)(qualified_expression . 54)(raise_statement 
. 64 [...]
       nil
       nil
       nil
       ((aggregate . 151)(attribute_reference . 51)(expression . 
184)(expression_opt . 957)(factor . 153)(name . 154)(primary . 
157)(qualified_expression . 54)(relation_and_list . 158)(relation_and_then_list 
. 159)(relation_or_list . 160)(relation_or_else_list . 161)(relation_xor_list . 
162)(relation . 163)(selected_component . 55)(simple_expression . 164)(term . 
165)(term_list . 166)(unary_adding_operator . 167))
       nil
-      ((accept_statement . 630)(assignment_statement . 
631)(asynchronous_select . 632)(attribute_reference . 51)(block_statement . 
633)(case_statement . 634)(conditional_entry_call . 635)(delay_statement . 
636)(exit_statement . 637)(extended_return_statement . 638)(if_statement . 
640)(iteration_scheme . 641)(label_opt . 642)(loop_statement . 643)(name . 
644)(pragma . 645)(procedure_call_statement . 646)(qualified_expression . 
54)(raise_statement . 647)(requeue_statement . 648)(selected_c [...]
+      ((accept_statement . 629)(assignment_statement . 
630)(asynchronous_select . 631)(attribute_reference . 51)(block_statement . 
632)(case_statement . 633)(conditional_entry_call . 634)(delay_statement . 
635)(exit_statement . 636)(extended_return_statement . 637)(if_statement . 
639)(iteration_scheme . 640)(label_opt . 641)(loop_statement . 642)(name . 
643)(pragma . 644)(procedure_call_statement . 645)(qualified_expression . 
54)(raise_statement . 646)(requeue_statement . 647)(selected_c [...]
       nil
       nil
       ((aggregate . 151)(attribute_reference . 51)(expression . 954)(factor . 
153)(name . 154)(primary . 157)(qualified_expression . 54)(relation_and_list . 
158)(relation_and_then_list . 159)(relation_or_list . 
160)(relation_or_else_list . 161)(relation_xor_list . 162)(relation . 
163)(selected_component . 55)(simple_expression . 164)(term . 165)(term_list . 
166)(unary_adding_operator . 167))
       nil
       nil
-      ((accept_statement . 630)(assignment_statement . 
631)(asynchronous_select . 632)(attribute_reference . 51)(block_statement . 
633)(case_statement . 634)(conditional_entry_call . 635)(delay_statement . 
636)(exit_statement . 637)(extended_return_statement . 
638)(handled_sequence_of_statements . 952)(if_statement . 640)(iteration_scheme 
. 641)(label_opt . 642)(loop_statement . 643)(name . 644)(pragma . 
645)(procedure_call_statement . 646)(qualified_expression . 54)(raise_statement 
. 64 [...]
+      ((accept_statement . 629)(assignment_statement . 
630)(asynchronous_select . 631)(attribute_reference . 51)(block_statement . 
632)(case_statement . 633)(conditional_entry_call . 634)(delay_statement . 
635)(exit_statement . 636)(extended_return_statement . 
637)(handled_sequence_of_statements . 952)(if_statement . 639)(iteration_scheme 
. 640)(label_opt . 641)(loop_statement . 642)(name . 643)(pragma . 
644)(procedure_call_statement . 645)(qualified_expression . 54)(raise_statement 
. 64 [...]
       nil
       nil
       ((aliased_opt . 951))
       nil
-      ((accept_statement . 630)(assignment_statement . 
631)(asynchronous_select . 632)(attribute_reference . 51)(block_statement . 
633)(case_statement . 634)(conditional_entry_call . 635)(delay_statement . 
636)(exit_statement . 637)(extended_return_statement . 638)(if_statement . 
640)(iteration_scheme . 641)(label_opt . 642)(loop_statement . 643)(name . 
644)(pragma . 645)(procedure_call_statement . 646)(qualified_expression . 
54)(raise_statement . 647)(requeue_statement . 648)(selected_c [...]
+      ((accept_statement . 629)(assignment_statement . 
630)(asynchronous_select . 631)(attribute_reference . 51)(block_statement . 
632)(case_statement . 633)(conditional_entry_call . 634)(delay_statement . 
635)(exit_statement . 636)(extended_return_statement . 637)(if_statement . 
639)(iteration_scheme . 640)(label_opt . 641)(loop_statement . 642)(name . 
643)(pragma . 644)(procedure_call_statement . 645)(qualified_expression . 
54)(raise_statement . 646)(requeue_statement . 647)(selected_c [...]
       nil
-      ((accept_statement . 671)(delay_alternative . 672)(delay_statement . 
945)(select_alternative . 947))
+      ((accept_statement . 670)(delay_alternative . 671)(delay_statement . 
945)(select_alternative . 947))
       nil
       nil
-      ((accept_statement . 630)(assignment_statement . 
631)(asynchronous_select . 632)(attribute_reference . 51)(block_statement . 
633)(case_statement . 634)(conditional_entry_call . 635)(delay_statement . 
636)(exit_statement . 637)(extended_return_statement . 638)(if_statement . 
640)(iteration_scheme . 641)(label_opt . 642)(loop_statement . 643)(name . 
644)(pragma . 645)(procedure_call_statement . 646)(qualified_expression . 
54)(raise_statement . 647)(requeue_statement . 648)(selected_c [...]
+      ((accept_statement . 629)(assignment_statement . 
630)(asynchronous_select . 631)(attribute_reference . 51)(block_statement . 
632)(case_statement . 633)(conditional_entry_call . 634)(delay_statement . 
635)(exit_statement . 636)(extended_return_statement . 637)(if_statement . 
639)(iteration_scheme . 640)(label_opt . 641)(loop_statement . 642)(name . 
643)(pragma . 644)(procedure_call_statement . 645)(qualified_expression . 
54)(raise_statement . 646)(requeue_statement . 647)(selected_c [...]
       ((delay_alternative . 944)(delay_statement . 945))
       nil
       nil
@@ -3961,12 +4006,12 @@
       nil
       ((accept_statement . 1163)(delay_alternative . 1164)(delay_statement . 
945))
       nil
-      ((accept_statement . 630)(assignment_statement . 
631)(asynchronous_select . 632)(attribute_reference . 51)(block_statement . 
633)(case_statement . 634)(conditional_entry_call . 635)(delay_statement . 
636)(exit_statement . 637)(extended_return_statement . 638)(if_statement . 
640)(iteration_scheme . 641)(label_opt . 642)(loop_statement . 643)(name . 
644)(pragma . 645)(procedure_call_statement . 646)(qualified_expression . 
54)(raise_statement . 647)(requeue_statement . 648)(selected_c [...]
+      ((accept_statement . 629)(assignment_statement . 
630)(asynchronous_select . 631)(attribute_reference . 51)(block_statement . 
632)(case_statement . 633)(conditional_entry_call . 634)(delay_statement . 
635)(exit_statement . 636)(extended_return_statement . 637)(if_statement . 
639)(iteration_scheme . 640)(label_opt . 641)(loop_statement . 642)(name . 
643)(pragma . 644)(procedure_call_statement . 645)(qualified_expression . 
54)(raise_statement . 646)(requeue_statement . 647)(selected_c [...]
       nil
       nil
       nil
       nil
-      ((accept_statement . 630)(assignment_statement . 
631)(asynchronous_select . 632)(attribute_reference . 51)(block_statement . 
633)(case_statement . 634)(conditional_entry_call . 635)(delay_statement . 
636)(exit_statement . 637)(extended_return_statement . 638)(if_statement . 
640)(iteration_scheme . 641)(label_opt . 642)(loop_statement . 643)(name . 
644)(pragma . 645)(procedure_call_statement . 646)(qualified_expression . 
54)(raise_statement . 647)(requeue_statement . 648)(selected_c [...]
+      ((accept_statement . 629)(assignment_statement . 
630)(asynchronous_select . 631)(attribute_reference . 51)(block_statement . 
632)(case_statement . 633)(conditional_entry_call . 634)(delay_statement . 
635)(exit_statement . 636)(extended_return_statement . 637)(if_statement . 
639)(iteration_scheme . 640)(label_opt . 641)(loop_statement . 642)(name . 
643)(pragma . 644)(procedure_call_statement . 645)(qualified_expression . 
54)(raise_statement . 646)(requeue_statement . 647)(selected_c [...]
       ((constant_opt . 1155))
       nil
       nil
@@ -4022,7 +4067,7 @@
       ((aspect_specification_opt . 1118))
       nil
       ((attribute_reference . 51)(name . 1117)(qualified_expression . 
54)(selected_component . 55))
-      ((attribute_reference . 51)(name . 737)(qualified_expression . 
54)(selected_component . 55)(subtype_indication . 1116))
+      ((attribute_reference . 51)(name . 736)(qualified_expression . 
54)(selected_component . 55)(subtype_indication . 1116))
       nil
       ((direct_name . 1114)(direct_name_opt . 1115))
       nil
@@ -4068,9 +4113,9 @@
       ((actual_parameter_part . 91)(aspect_specification_opt . 1081))
       nil
       nil
-      ((access_definition . 1075)(attribute_reference . 
51)(component_definition . 1078)(name . 737)(null_exclusion_opt . 
212)(qualified_expression . 54)(selected_component . 55)(subtype_indication . 
1077))
+      ((access_definition . 1075)(attribute_reference . 
51)(component_definition . 1078)(name . 736)(null_exclusion_opt . 
212)(qualified_expression . 54)(selected_component . 55)(subtype_indication . 
1077))
       nil
-      ((access_definition . 1075)(attribute_reference . 
51)(component_definition . 1076)(name . 737)(null_exclusion_opt . 
212)(qualified_expression . 54)(selected_component . 55)(subtype_indication . 
1077))
+      ((access_definition . 1075)(attribute_reference . 
51)(component_definition . 1076)(name . 736)(null_exclusion_opt . 
212)(qualified_expression . 54)(selected_component . 55)(subtype_indication . 
1077))
       nil
       ((actual_parameter_part . 91))
       nil
@@ -4088,9 +4133,9 @@
       nil
       ((actual_parameter_part . 91))
       nil
-      ((attribute_reference . 51)(name . 1232)(qualified_expression . 
54)(selected_component . 55))
+      ((attribute_reference . 51)(name . 1231)(qualified_expression . 
54)(selected_component . 55))
       nil
-      ((access_definition . 1230)(attribute_reference . 51)(name . 
737)(null_exclusion_opt . 212)(qualified_expression . 54)(selected_component . 
55)(subtype_indication . 1231))
+      ((access_definition . 1229)(attribute_reference . 51)(name . 
736)(null_exclusion_opt . 212)(qualified_expression . 54)(selected_component . 
55)(subtype_indication . 1230))
       nil
       nil
       nil
@@ -4101,29 +4146,29 @@
       nil
       nil
       nil
-      ((aggregate . 151)(attribute_reference . 51)(factor . 153)(name . 
154)(primary . 157)(qualified_expression . 54)(selected_component . 
55)(simple_expression . 1226)(term . 165)(term_list . 
166)(unary_adding_operator . 167))
+      ((aggregate . 151)(attribute_reference . 51)(factor . 153)(name . 
154)(primary . 157)(qualified_expression . 54)(selected_component . 
55)(simple_expression . 1225)(term . 165)(term_list . 
166)(unary_adding_operator . 167))
       nil
-      ((attribute_reference . 51)(interface_list . 1225)(name . 
798)(qualified_expression . 54)(selected_component . 55))
+      ((attribute_reference . 51)(interface_list . 1224)(name . 
798)(qualified_expression . 54)(selected_component . 55))
       nil
       nil
-      ((abstract_subprogram_declaration . 295)(aspect_clause . 296)(at_clause 
. 297)(body . 298)(body_stub . 299)(declaration . 300)(declarations . 
301)(declarative_part_opt . 830)(entry_declaration . 
303)(enumeration_representation_clause . 304)(exception_declaration . 
305)(expression_function_declaration . 306)(full_type_declaration . 
307)(function_specification . 16)(generic_declaration . 
308)(generic_formal_part . 18)(generic_instantiation . 
309)(generic_package_declaration . 20)(gen [...]
+      ((abstract_subprogram_declaration . 295)(aspect_clause . 296)(at_clause 
. 297)(body . 298)(body_stub . 299)(declaration . 300)(declarations . 
301)(declarative_part_opt . 830)(entry_declaration . 
303)(enumeration_representation_clause . 304)(exception_declaration . 
305)(expression_function_declaration . 306)(full_type_declaration . 
307)(function_specification . 16)(generic_declaration . 
308)(generic_formal_part . 18)(generic_instantiation . 
309)(generic_package_declaration . 20)(gen [...]
       nil
       nil
       nil
-      ((attribute_reference . 51)(interface_list . 1221)(name . 
798)(qualified_expression . 54)(selected_component . 55))
+      ((attribute_reference . 51)(interface_list . 1220)(name . 
798)(qualified_expression . 54)(selected_component . 55))
       nil
       nil
-      ((abstract_subprogram_declaration . 295)(aspect_clause . 296)(at_clause 
. 297)(body . 298)(body_stub . 299)(declaration . 300)(declarations . 
301)(declarative_part_opt . 838)(entry_declaration . 
303)(enumeration_representation_clause . 304)(exception_declaration . 
305)(expression_function_declaration . 306)(full_type_declaration . 
307)(function_specification . 16)(generic_declaration . 
308)(generic_formal_part . 18)(generic_instantiation . 
309)(generic_package_declaration . 20)(gen [...]
+      ((abstract_subprogram_declaration . 295)(aspect_clause . 296)(at_clause 
. 297)(body . 298)(body_stub . 299)(declaration . 300)(declarations . 
301)(declarative_part_opt . 838)(entry_declaration . 
303)(enumeration_representation_clause . 304)(exception_declaration . 
305)(expression_function_declaration . 306)(full_type_declaration . 
307)(function_specification . 16)(generic_declaration . 
308)(generic_formal_part . 18)(generic_instantiation . 
309)(generic_package_declaration . 20)(gen [...]
       nil
       nil
-      ((aggregate . 151)(attribute_reference . 51)(expression . 1217)(factor . 
153)(name . 154)(primary . 157)(qualified_expression . 54)(relation_and_list . 
158)(relation_and_then_list . 159)(relation_or_list . 
160)(relation_or_else_list . 161)(relation_xor_list . 162)(relation . 
163)(selected_component . 55)(simple_expression . 164)(term . 165)(term_list . 
166)(unary_adding_operator . 167))
-      ((aggregate . 151)(attribute_reference . 51)(factor . 153)(name . 
154)(primary . 157)(qualified_expression . 54)(selected_component . 
55)(simple_expression . 1216)(term . 165)(term_list . 
166)(unary_adding_operator . 167))
+      ((aggregate . 151)(attribute_reference . 51)(expression . 1216)(factor . 
153)(name . 154)(primary . 157)(qualified_expression . 54)(relation_and_list . 
158)(relation_and_then_list . 159)(relation_or_list . 
160)(relation_or_else_list . 161)(relation_xor_list . 162)(relation . 
163)(selected_component . 55)(simple_expression . 164)(term . 165)(term_list . 
166)(unary_adding_operator . 167))
+      ((aggregate . 151)(attribute_reference . 51)(factor . 153)(name . 
154)(primary . 157)(qualified_expression . 54)(selected_component . 
55)(simple_expression . 1215)(term . 165)(term_list . 
166)(unary_adding_operator . 167))
       nil
       nil
-      ((enumeration_literal . 1215))
+      ((enumeration_literal . 1214))
       nil
-      ((aggregate . 151)(attribute_reference . 51)(factor . 153)(name . 
154)(primary . 157)(qualified_expression . 54)(selected_component . 
55)(simple_expression . 1214)(term . 165)(term_list . 
166)(unary_adding_operator . 167))
-      ((access_definition . 1075)(attribute_reference . 
51)(component_definition . 1213)(name . 737)(null_exclusion_opt . 
212)(qualified_expression . 54)(selected_component . 55)(subtype_indication . 
1077))
+      ((aggregate . 151)(attribute_reference . 51)(factor . 153)(name . 
154)(primary . 157)(qualified_expression . 54)(selected_component . 
55)(simple_expression . 1213)(term . 165)(term_list . 
166)(unary_adding_operator . 167))
+      ((access_definition . 1075)(attribute_reference . 
51)(component_definition . 1212)(name . 736)(null_exclusion_opt . 
212)(qualified_expression . 54)(selected_component . 55)(subtype_indication . 
1077))
       nil
       nil
       nil
@@ -4132,8 +4177,8 @@
       nil
       nil
       nil
-      ((and_interface_list_opt . 1210))
-      ((actual_parameter_part . 91)(and_interface_list_opt . 1207)(constraint 
. 1208)(constraint_opt . 1209)(index_constraint . 806))
+      ((and_interface_list_opt . 1209))
+      ((actual_parameter_part . 91)(and_interface_list_opt . 1206)(constraint 
. 1207)(constraint_opt . 1208)(index_constraint . 806))
       nil
       nil
       nil
@@ -4153,16 +4198,16 @@
       nil
       ((aspect_specification_opt . 128))
       ((entry_body_formal_part . 1196)(formal_part . 
116)(parameter_profile_opt . 1197))
-      ((accept_statement . 630)(assignment_statement . 
631)(asynchronous_select . 632)(attribute_reference . 51)(block_statement . 
633)(case_statement . 634)(conditional_entry_call . 635)(delay_statement . 
636)(exit_statement . 637)(extended_return_statement . 
638)(handled_sequence_of_statements . 1194)(if_statement . 
640)(iteration_scheme . 641)(label_opt . 642)(loop_statement . 643)(name . 
644)(pragma . 645)(procedure_call_statement . 646)(qualified_expression . 
54)(raise_statement . 6 [...]
+      ((accept_statement . 629)(assignment_statement . 
630)(asynchronous_select . 631)(attribute_reference . 51)(block_statement . 
632)(case_statement . 633)(conditional_entry_call . 634)(delay_statement . 
635)(exit_statement . 636)(extended_return_statement . 
637)(handled_sequence_of_statements . 1194)(if_statement . 
639)(iteration_scheme . 640)(label_opt . 641)(loop_statement . 642)(name . 
643)(pragma . 644)(procedure_call_statement . 645)(qualified_expression . 
54)(raise_statement . 6 [...]
       nil
-      ((accept_statement . 630)(assignment_statement . 
631)(asynchronous_select . 632)(attribute_reference . 51)(block_statement . 
633)(case_statement . 634)(conditional_entry_call . 635)(delay_statement . 
636)(exit_statement . 637)(extended_return_statement . 
638)(handled_sequence_of_statements . 1193)(if_statement . 
640)(iteration_scheme . 641)(label_opt . 642)(loop_statement . 643)(name . 
644)(pragma . 645)(procedure_call_statement . 646)(qualified_expression . 
54)(raise_statement . 6 [...]
+      ((accept_statement . 629)(assignment_statement . 
630)(asynchronous_select . 631)(attribute_reference . 51)(block_statement . 
632)(case_statement . 633)(conditional_entry_call . 634)(delay_statement . 
635)(exit_statement . 636)(extended_return_statement . 
637)(handled_sequence_of_statements . 1193)(if_statement . 
639)(iteration_scheme . 640)(label_opt . 641)(loop_statement . 642)(name . 
643)(pragma . 644)(procedure_call_statement . 645)(qualified_expression . 
54)(raise_statement . 6 [...]
       nil
       nil
       nil
       nil
       ((identifier_opt . 1190))
       nil
-      ((accept_statement . 630)(assignment_statement . 
631)(asynchronous_select . 632)(attribute_reference . 51)(block_statement . 
633)(case_statement . 634)(conditional_entry_call . 635)(delay_statement . 
636)(exit_statement . 637)(extended_return_statement . 638)(if_statement . 
640)(iteration_scheme . 641)(label_opt . 642)(loop_statement . 643)(name . 
644)(pragma . 645)(procedure_call_statement . 646)(qualified_expression . 
54)(raise_statement . 647)(requeue_statement . 648)(selected_c [...]
+      ((accept_statement . 629)(assignment_statement . 
630)(asynchronous_select . 631)(attribute_reference . 51)(block_statement . 
632)(case_statement . 633)(conditional_entry_call . 634)(delay_statement . 
635)(exit_statement . 636)(extended_return_statement . 637)(if_statement . 
639)(iteration_scheme . 640)(label_opt . 641)(loop_statement . 642)(name . 
643)(pragma . 644)(procedure_call_statement . 645)(qualified_expression . 
54)(raise_statement . 646)(requeue_statement . 647)(selected_c [...]
       ((aggregate . 151)(attribute_reference . 51)(expression . 
184)(expression_opt . 1188)(factor . 153)(name . 154)(primary . 
157)(qualified_expression . 54)(relation_and_list . 158)(relation_and_then_list 
. 159)(relation_or_list . 160)(relation_or_else_list . 161)(relation_xor_list . 
162)(relation . 163)(selected_component . 55)(simple_expression . 164)(term . 
165)(term_list . 166)(unary_adding_operator . 167))
       nil
       nil
@@ -4171,7 +4216,7 @@
       nil
       nil
       nil
-      ((access_definition . 1179)(attribute_reference . 51)(name . 
737)(null_exclusion_opt . 212)(qualified_expression . 
54)(return_subtype_indication . 1180)(selected_component . 
55)(subtype_indication . 1181))
+      ((access_definition . 1179)(attribute_reference . 51)(name . 
736)(null_exclusion_opt . 212)(qualified_expression . 
54)(return_subtype_indication . 1180)(selected_component . 
55)(subtype_indication . 1181))
       nil
       nil
       nil
@@ -4179,11 +4224,11 @@
       nil
       nil
       nil
-      ((accept_statement . 630)(assignment_statement . 
631)(asynchronous_select . 632)(attribute_reference . 51)(block_statement . 
633)(case_statement . 634)(conditional_entry_call . 635)(delay_statement . 
636)(exit_statement . 637)(extended_return_statement . 638)(if_statement . 
640)(iteration_scheme . 641)(label_opt . 642)(loop_statement . 643)(name . 
644)(pragma . 645)(procedure_call_statement . 646)(qualified_expression . 
54)(raise_statement . 647)(requeue_statement . 648)(selected_c [...]
+      ((accept_statement . 629)(assignment_statement . 
630)(asynchronous_select . 631)(attribute_reference . 51)(block_statement . 
632)(case_statement . 633)(conditional_entry_call . 634)(delay_statement . 
635)(exit_statement . 636)(extended_return_statement . 637)(if_statement . 
639)(iteration_scheme . 640)(label_opt . 641)(loop_statement . 642)(name . 
643)(pragma . 644)(procedure_call_statement . 645)(qualified_expression . 
54)(raise_statement . 646)(requeue_statement . 647)(selected_c [...]
       nil
       ((identifier_opt . 1172))
       ((attribute_reference . 51)(exception_choice . 1171)(name . 
939)(qualified_expression . 54)(selected_component . 55))
-      ((accept_statement . 630)(assignment_statement . 
631)(asynchronous_select . 632)(attribute_reference . 51)(block_statement . 
633)(case_statement . 634)(conditional_entry_call . 635)(delay_statement . 
636)(exit_statement . 637)(extended_return_statement . 638)(if_statement . 
640)(iteration_scheme . 641)(label_opt . 642)(loop_statement . 643)(name . 
644)(pragma . 645)(procedure_call_statement . 646)(qualified_expression . 
54)(raise_statement . 647)(requeue_statement . 648)(selected_c [...]
+      ((accept_statement . 629)(assignment_statement . 
630)(asynchronous_select . 631)(attribute_reference . 51)(block_statement . 
632)(case_statement . 633)(conditional_entry_call . 634)(delay_statement . 
635)(exit_statement . 636)(extended_return_statement . 637)(if_statement . 
639)(iteration_scheme . 640)(label_opt . 641)(loop_statement . 642)(name . 
643)(pragma . 644)(procedure_call_statement . 645)(qualified_expression . 
54)(raise_statement . 646)(requeue_statement . 647)(selected_c [...]
       ((attribute_reference . 51)(exception_choice . 
937)(exception_choice_list . 1169)(name . 939)(qualified_expression . 
54)(selected_component . 55))
       nil
       nil
@@ -4200,14 +4245,14 @@
       nil
       nil
       nil
-      ((accept_statement . 630)(assignment_statement . 
631)(asynchronous_select . 632)(attribute_reference . 51)(block_statement . 
633)(case_statement . 634)(conditional_entry_call . 635)(delay_statement . 
636)(exit_statement . 637)(extended_return_statement . 638)(if_statement . 
640)(iteration_scheme . 641)(label_opt . 642)(loop_statement . 643)(name . 
644)(pragma . 645)(procedure_call_statement . 646)(qualified_expression . 
54)(raise_statement . 647)(requeue_statement . 648)(selected_c [...]
+      ((accept_statement . 629)(assignment_statement . 
630)(asynchronous_select . 631)(attribute_reference . 51)(block_statement . 
632)(case_statement . 633)(conditional_entry_call . 634)(delay_statement . 
635)(exit_statement . 636)(extended_return_statement . 637)(if_statement . 
639)(iteration_scheme . 640)(label_opt . 641)(loop_statement . 642)(name . 
643)(pragma . 644)(procedure_call_statement . 645)(qualified_expression . 
54)(raise_statement . 646)(requeue_statement . 647)(selected_c [...]
       nil
       nil
       nil
       nil
       nil
       nil
-      ((accept_statement . 630)(assignment_statement . 
631)(asynchronous_select . 632)(attribute_reference . 51)(block_statement . 
633)(case_statement . 634)(conditional_entry_call . 635)(delay_statement . 
636)(exit_statement . 637)(extended_return_statement . 638)(if_statement . 
640)(iteration_scheme . 641)(label_opt . 642)(loop_statement . 643)(name . 
644)(pragma . 645)(procedure_call_statement . 646)(qualified_expression . 
54)(raise_statement . 647)(requeue_statement . 648)(selected_c [...]
+      ((accept_statement . 629)(assignment_statement . 
630)(asynchronous_select . 631)(attribute_reference . 51)(block_statement . 
632)(case_statement . 633)(conditional_entry_call . 634)(delay_statement . 
635)(exit_statement . 636)(extended_return_statement . 637)(if_statement . 
639)(iteration_scheme . 640)(label_opt . 641)(loop_statement . 642)(name . 
643)(pragma . 644)(procedure_call_statement . 645)(qualified_expression . 
54)(raise_statement . 646)(requeue_statement . 647)(selected_c [...]
       nil
       nil
       nil
@@ -4222,23 +4267,22 @@
       nil
       nil
       nil
-      ((attribute_reference . 51)(interface_list . 1250)(name . 
798)(qualified_expression . 54)(selected_component . 55))
       nil
       nil
       nil
       nil
-      ((variant_list . 1246)(variant . 1247))
+      ((variant_list . 1244)(variant . 1245))
       nil
-      ((aspect_specification_opt . 1244))
+      ((aspect_specification_opt . 1242))
       nil
       nil
       nil
-      ((real_range_specification_opt . 1241))
-      ((identifier_opt . 1240))
+      ((real_range_specification_opt . 1239))
+      ((identifier_opt . 1238))
       nil
       nil
       nil
-      ((identifier_opt . 1237))
+      ((identifier_opt . 1235))
       nil
       nil
       nil
@@ -4249,49 +4293,47 @@
       nil
       nil
       ((actual_parameter_part . 91)(constraint . 1093)(index_constraint . 806))
+      ((aggregate . 151)(attribute_reference . 51)(factor . 153)(name . 
154)(primary . 157)(qualified_expression . 54)(selected_component . 
55)(simple_expression . 1294)(term . 165)(term_list . 
166)(unary_adding_operator . 167))
+      ((abstract_subprogram_declaration . 295)(aspect_clause . 296)(at_clause 
. 297)(body . 298)(body_stub . 299)(declaration . 300)(declarations . 
301)(declarative_part_opt . 830)(entry_declaration . 
303)(enumeration_representation_clause . 304)(exception_declaration . 
305)(expression_function_declaration . 306)(full_type_declaration . 
307)(function_specification . 16)(generic_declaration . 
308)(generic_formal_part . 18)(generic_instantiation . 
309)(generic_package_declaration . 20)(gen [...]
       nil
-      ((aggregate . 151)(attribute_reference . 51)(factor . 153)(name . 
154)(primary . 157)(qualified_expression . 54)(selected_component . 
55)(simple_expression . 1297)(term . 165)(term_list . 
166)(unary_adding_operator . 167))
-      ((abstract_subprogram_declaration . 295)(aspect_clause . 296)(at_clause 
. 297)(body . 298)(body_stub . 299)(declaration . 300)(declarations . 
301)(declarative_part_opt . 830)(entry_declaration . 
303)(enumeration_representation_clause . 304)(exception_declaration . 
305)(expression_function_declaration . 306)(full_type_declaration . 
307)(function_specification . 16)(generic_declaration . 
308)(generic_formal_part . 18)(generic_instantiation . 
309)(generic_package_declaration . 20)(gen [...]
-      nil
-      nil
-      ((abstract_subprogram_declaration . 295)(aspect_clause . 296)(at_clause 
. 297)(body . 298)(body_stub . 299)(declaration . 300)(declarations . 
301)(declarative_part_opt . 838)(entry_declaration . 
303)(enumeration_representation_clause . 304)(exception_declaration . 
305)(expression_function_declaration . 306)(full_type_declaration . 
307)(function_specification . 16)(generic_declaration . 
308)(generic_formal_part . 18)(generic_instantiation . 
309)(generic_package_declaration . 20)(gen [...]
       nil
+      ((abstract_subprogram_declaration . 295)(aspect_clause . 296)(at_clause 
. 297)(body . 298)(body_stub . 299)(declaration . 300)(declarations . 
301)(declarative_part_opt . 838)(entry_declaration . 
303)(enumeration_representation_clause . 304)(exception_declaration . 
305)(expression_function_declaration . 306)(full_type_declaration . 
307)(function_specification . 16)(generic_declaration . 
308)(generic_formal_part . 18)(generic_instantiation . 
309)(generic_package_declaration . 20)(gen [...]
       nil
       nil
-      ((aggregate . 151)(attribute_reference . 51)(factor . 153)(name . 
154)(primary . 157)(qualified_expression . 54)(selected_component . 
55)(simple_expression . 1294)(term . 165)(term_list . 
166)(unary_adding_operator . 167))
-      ((aggregate . 151)(attribute_reference . 51)(expression . 1293)(factor . 
153)(name . 154)(primary . 157)(qualified_expression . 54)(relation_and_list . 
158)(relation_and_then_list . 159)(relation_or_list . 
160)(relation_or_else_list . 161)(relation_xor_list . 162)(relation . 
163)(selected_component . 55)(simple_expression . 164)(term . 165)(term_list . 
166)(unary_adding_operator . 167))
       nil
-      ((aggregate . 151)(attribute_reference . 51)(choice_expression . 
175)(choice_relation_and_list . 176)(choice_relation_or_list . 
177)(choice_relation_xor_list . 178)(choice_relation_and_then_list . 
179)(choice_relation_or_else_list . 180)(choice_relation . 181)(discrete_choice 
. 182)(discrete_choice_list . 1291)(factor . 153)(name . 186)(primary . 
157)(qualified_expression . 54)(range . 187)(selected_component . 
55)(simple_expression . 459)(term . 165)(term_list . 166)(unary_adding_ [...]
-      ((variant . 1290))
+      ((aggregate . 151)(attribute_reference . 51)(factor . 153)(name . 
154)(primary . 157)(qualified_expression . 54)(selected_component . 
55)(simple_expression . 1291)(term . 165)(term_list . 
166)(unary_adding_operator . 167))
+      ((aggregate . 151)(attribute_reference . 51)(expression . 1290)(factor . 
153)(name . 154)(primary . 157)(qualified_expression . 54)(relation_and_list . 
158)(relation_and_then_list . 159)(relation_or_list . 
160)(relation_or_else_list . 161)(relation_xor_list . 162)(relation . 
163)(selected_component . 55)(simple_expression . 164)(term . 165)(term_list . 
166)(unary_adding_operator . 167))
       nil
+      ((aggregate . 151)(attribute_reference . 51)(choice_expression . 
175)(choice_relation_and_list . 176)(choice_relation_or_list . 
177)(choice_relation_xor_list . 178)(choice_relation_and_then_list . 
179)(choice_relation_or_else_list . 180)(choice_relation . 181)(discrete_choice 
. 182)(discrete_choice_list . 1288)(factor . 153)(name . 186)(primary . 
157)(qualified_expression . 54)(range . 187)(selected_component . 
55)(simple_expression . 459)(term . 165)(term_list . 166)(unary_adding_ [...]
+      ((variant . 1287))
       nil
-      ((record_definition . 1287))
       nil
+      ((record_definition . 1284))
       nil
       nil
       nil
       nil
       nil
-      ((aggregate . 151)(attribute_reference . 51)(expression . 
184)(expression_opt . 1286)(factor . 153)(name . 154)(primary . 
157)(qualified_expression . 54)(relation_and_list . 158)(relation_and_then_list 
. 159)(relation_or_list . 160)(relation_or_else_list . 161)(relation_xor_list . 
162)(relation . 163)(selected_component . 55)(simple_expression . 164)(term . 
165)(term_list . 166)(unary_adding_operator . 167))
+      ((aggregate . 151)(attribute_reference . 51)(expression . 
184)(expression_opt . 1283)(factor . 153)(name . 154)(primary . 
157)(qualified_expression . 54)(relation_and_list . 158)(relation_and_then_list 
. 159)(relation_or_list . 160)(relation_or_else_list . 161)(relation_xor_list . 
162)(relation . 163)(selected_component . 55)(simple_expression . 164)(term . 
165)(term_list . 166)(unary_adding_operator . 167))
       nil
-      ((identifier_opt . 1284))
-      ((identifier_opt . 1283))
+      ((identifier_opt . 1281))
+      ((identifier_opt . 1280))
       nil
       nil
       nil
       nil
-      ((accept_statement . 630)(assignment_statement . 
631)(asynchronous_select . 632)(attribute_reference . 51)(block_statement . 
633)(case_statement . 634)(conditional_entry_call . 635)(delay_statement . 
636)(exit_statement . 637)(extended_return_statement . 638)(if_statement . 
640)(iteration_scheme . 641)(label_opt . 642)(loop_statement . 643)(name . 
644)(pragma . 645)(procedure_call_statement . 646)(qualified_expression . 
54)(raise_statement . 647)(requeue_statement . 648)(selected_c [...]
+      ((accept_statement . 629)(assignment_statement . 
630)(asynchronous_select . 631)(attribute_reference . 51)(block_statement . 
632)(case_statement . 633)(conditional_entry_call . 634)(delay_statement . 
635)(exit_statement . 636)(extended_return_statement . 637)(if_statement . 
639)(iteration_scheme . 640)(label_opt . 641)(loop_statement . 642)(name . 
643)(pragma . 644)(procedure_call_statement . 645)(qualified_expression . 
54)(raise_statement . 646)(requeue_statement . 647)(selected_c [...]
       nil
       nil
       nil
       nil
-      ((aggregate . 151)(attribute_reference . 51)(expression . 1278)(factor . 
153)(name . 154)(primary . 157)(qualified_expression . 54)(relation_and_list . 
158)(relation_and_then_list . 159)(relation_or_list . 
160)(relation_or_else_list . 161)(relation_xor_list . 162)(relation . 
163)(selected_component . 55)(simple_expression . 164)(term . 165)(term_list . 
166)(unary_adding_operator . 167))
+      ((aggregate . 151)(attribute_reference . 51)(expression . 1275)(factor . 
153)(name . 154)(primary . 157)(qualified_expression . 54)(relation_and_list . 
158)(relation_and_then_list . 159)(relation_or_list . 
160)(relation_or_else_list . 161)(relation_xor_list . 162)(relation . 
163)(selected_component . 55)(simple_expression . 164)(term . 165)(term_list . 
166)(unary_adding_operator . 167))
       nil
       nil
       nil
       nil
       nil
-      ((accept_statement . 630)(assignment_statement . 
631)(asynchronous_select . 632)(attribute_reference . 51)(block_statement . 
633)(case_statement . 634)(conditional_entry_call . 635)(delay_statement . 
636)(exit_statement . 637)(extended_return_statement . 638)(if_statement . 
640)(iteration_scheme . 641)(label_opt . 642)(loop_statement . 643)(name . 
644)(pragma . 645)(procedure_call_statement . 646)(qualified_expression . 
54)(raise_statement . 647)(requeue_statement . 648)(selected_c [...]
+      ((accept_statement . 629)(assignment_statement . 
630)(asynchronous_select . 631)(attribute_reference . 51)(block_statement . 
632)(case_statement . 633)(conditional_entry_call . 634)(delay_statement . 
635)(exit_statement . 636)(extended_return_statement . 637)(if_statement . 
639)(iteration_scheme . 640)(label_opt . 641)(loop_statement . 642)(name . 
643)(pragma . 644)(procedure_call_statement . 645)(qualified_expression . 
54)(raise_statement . 646)(requeue_statement . 647)(selected_c [...]
       nil
       nil
       nil
@@ -4304,25 +4346,25 @@
       nil
       nil
       nil
-      ((aspect_specification_opt . 1304))
+      ((aspect_specification_opt . 1301))
       nil
       nil
       nil
       nil
-      ((aspect_specification_opt . 1301))
+      ((aspect_specification_opt . 1298))
       nil
       nil
       nil
       nil
-      ((aggregate . 151)(attribute_reference . 51)(factor . 153)(name . 
154)(primary . 157)(qualified_expression . 54)(selected_component . 
55)(simple_expression . 1318)(term . 165)(term_list . 
166)(unary_adding_operator . 167))
+      ((aggregate . 151)(attribute_reference . 51)(factor . 153)(name . 
154)(primary . 157)(qualified_expression . 54)(selected_component . 
55)(simple_expression . 1315)(term . 165)(term_list . 
166)(unary_adding_operator . 167))
       nil
       nil
       nil
-      ((aspect_clause . 1010)(at_clause . 297)(component_declaration . 
1011)(component_item . 1012)(component_list . 1013)(component_list_opt . 
1316)(enumeration_representation_clause . 304)(identifier_list . 
1015)(record_representation_clause . 328)(variant_part . 1016))
+      ((aspect_clause . 1010)(at_clause . 297)(component_declaration . 
1011)(component_item . 1012)(component_list . 1013)(component_list_opt . 
1313)(enumeration_representation_clause . 304)(identifier_list . 
1015)(record_representation_clause . 328)(variant_part . 1016))
       nil
       nil
-      ((abstract_subprogram_declaration . 295)(aspect_clause . 296)(at_clause 
. 297)(body . 298)(body_stub . 299)(declaration . 300)(declarations . 
301)(declarative_part_opt . 1313)(entry_declaration . 
303)(enumeration_representation_clause . 304)(exception_declaration . 
305)(expression_function_declaration . 306)(full_type_declaration . 
307)(function_specification . 16)(generic_declaration . 
308)(generic_formal_part . 18)(generic_instantiation . 
309)(generic_package_declaration . 20)(ge [...]
-      ((aggregate . 151)(attribute_reference . 51)(discrete_subtype_definition 
. 1312)(factor . 153)(name . 875)(primary . 157)(qualified_expression . 
54)(range . 764)(selected_component . 55)(simple_expression . 
765)(subtype_indication . 766)(term . 165)(term_list . 
166)(unary_adding_operator . 167))
+      ((abstract_subprogram_declaration . 295)(aspect_clause . 296)(at_clause 
. 297)(body . 298)(body_stub . 299)(declaration . 300)(declarations . 
301)(declarative_part_opt . 1310)(entry_declaration . 
303)(enumeration_representation_clause . 304)(exception_declaration . 
305)(expression_function_declaration . 306)(full_type_declaration . 
307)(function_specification . 16)(generic_declaration . 
308)(generic_formal_part . 18)(generic_instantiation . 
309)(generic_package_declaration . 20)(ge [...]
+      ((aggregate . 151)(attribute_reference . 51)(discrete_subtype_definition 
. 1309)(factor . 153)(name . 875)(primary . 157)(qualified_expression . 
54)(range . 763)(selected_component . 55)(simple_expression . 
764)(subtype_indication . 765)(term . 165)(term_list . 
166)(unary_adding_operator . 167))
       nil
       nil
       nil
@@ -4336,11 +4378,11 @@
       nil
       nil
       nil
-      ((accept_statement . 630)(assignment_statement . 
631)(asynchronous_select . 632)(attribute_reference . 51)(block_statement . 
633)(case_statement . 634)(conditional_entry_call . 635)(delay_statement . 
636)(exit_statement . 637)(extended_return_statement . 
638)(handled_sequence_of_statements . 1323)(if_statement . 
640)(iteration_scheme . 641)(label_opt . 642)(loop_statement . 643)(name . 
644)(pragma . 645)(procedure_call_statement . 646)(qualified_expression . 
54)(raise_statement . 6 [...]
-      ((formal_part . 116)(parameter_profile_opt . 1322))
+      ((accept_statement . 629)(assignment_statement . 
630)(asynchronous_select . 631)(attribute_reference . 51)(block_statement . 
632)(case_statement . 633)(conditional_entry_call . 634)(delay_statement . 
635)(exit_statement . 636)(extended_return_statement . 
637)(handled_sequence_of_statements . 1320)(if_statement . 
639)(iteration_scheme . 640)(label_opt . 641)(loop_statement . 642)(name . 
643)(pragma . 644)(procedure_call_statement . 645)(qualified_expression . 
54)(raise_statement . 6 [...]
+      ((formal_part . 116)(parameter_profile_opt . 1319))
       nil
       nil
-      ((identifier_opt . 1325))
+      ((identifier_opt . 1322))
       nil
       nil]))
   "Parser table.")
diff --git a/packages/ada-mode/ada-mode.el b/packages/ada-mode/ada-mode.el
index 8f76749..3248e13 100644
--- a/packages/ada-mode/ada-mode.el
+++ b/packages/ada-mode/ada-mode.el
@@ -4,9 +4,10 @@
 ;;
 ;; Author: Stephen Leake <address@hidden>
 ;; Maintainer: Stephen Leake <address@hidden>
-;; Keywords FIXME: languages, ada ELPA broken for multiple keywords
-;; Version: 5.1.5
-;; package-requires: ((wisi "1.0.5") (cl-lib "0.4") (emacs "24.2"))
+;; Keywords: languages
+;;  ada
+;; Version: 5.1.6
+;; package-requires: ((wisi "1.0.6") (cl-lib "0.4") (emacs "24.2"))
 ;; url: http://stephe-leake.org/emacs/ada-mode/emacs-ada-mode.html
 ;;
 ;; (Gnu ELPA requires single digits between dots in versions)
@@ -167,7 +168,7 @@
 (defun ada-mode-version ()
   "Return Ada mode version."
   (interactive)
-  (let ((version-string "5.1.5"))
+  (let ((version-string "5.1.6"))
     ;; must match:
     ;; ada-mode.texi
     ;; README
@@ -304,31 +305,20 @@ Values defined by cross reference packages.")
 
 ;;;; keymap and menus
 
-(defvar ada-ret-binding nil)
-(defvar ada-lfd-binding nil)
+(defvar ada-ret-binding 'ada-indent-newline-indent)
+(defvar ada-lfd-binding 'newline-and-indent)
 
-(defun ada-case-activate-keys ()
+(defun ada-case-activate-keys (map)
   "Modify the key bindings for all the keys that should adjust casing."
-  (interactive)
-  ;; We can't use post-self-insert-hook for \n, \r, because they are
-  ;; not self-insert.
-
-  ;; The 'or ...' is there to be sure that the value will not be
-  ;; changed again when this is called more than once, since we
-  ;; are rebinding the keys.
-  (or ada-ret-binding (setq ada-ret-binding (key-binding "\C-M")))
-  (or ada-lfd-binding (setq ada-lfd-binding (key-binding "\C-j")))
-
+  ;; we could just put these in the keymap below, but this is easier.
   (mapc (function
         (lambda(key)
           (define-key
-            ada-mode-map
+            map
             (char-to-string key)
             'ada-case-adjust-interactive)))
        '( ?_ ?% ?& ?* ?( ?) ?- ?= ?+
              ?| ?\; ?: ?' ?\" ?< ?, ?. ?> ?/ ?\n 32 ?\r ))
-
-  (define-key ada-mode-map [return] 'ada-case-adjust-interactive)
   )
 
 (defvar ada-mode-map
@@ -336,7 +326,7 @@ Values defined by cross reference packages.")
     ;; C-c <letter> are reserved for users
 
     ;; global-map has C-x ` 'next-error
-    (define-key map [return]    'ada-indent-newline-indent)
+    (define-key map [return]    'ada-case-adjust-interactive)
     (define-key map "\C-c`"     'ada-show-secondary-error)
     (define-key map "\C-c;"      (lambda () (error "use M-; instead"))) ; 
comment-dwim
     (define-key map "\C-c<"     'ada-goto-declaration-start)
@@ -352,9 +342,11 @@ Values defined by cross reference packages.")
     (define-key map "\C-c\C-i"          'ada-indent-statement)
     (define-key map "\C-c\C-m"   'ada-build-set-make)
     (define-key map "\C-c\C-n"          'ada-next-statement-keyword)
+    (define-key map "\C-c\M-n"          'ada-next-placeholder)
     (define-key map "\C-c\C-o"          'ada-find-other-file)
     (define-key map "\C-c\M-o"          'ada-find-other-file-noset)
     (define-key map "\C-c\C-p"          'ada-prev-statement-keyword)
+    (define-key map "\C-c\M-p"          'ada-prev-placeholder)
     (define-key map "\C-c\C-q"          'ada-xref-refresh)
     (define-key map "\C-c\C-r"          'ada-show-references)
     (define-key map "\C-c\M-r"          'ada-build-run)
@@ -367,6 +359,8 @@ Values defined by cross reference packages.")
     (define-key map "\C-c\M-y"   'ada-case-create-partial-exception)
     (define-key map [C-down-mouse-3] 'ada-popup-menu)
 
+    (ada-case-activate-keys map)
+
     map
   )  "Local keymap used for Ada mode.")
 
@@ -383,6 +377,7 @@ Values defined by cross reference packages.")
      ["Find and select project ..."   ada-build-prompt-select-prj-file t]
      ["Select project ..."            ada-prj-select                   t]
      ["Show project"                  ada-prj-show                     t]
+     ["Show project search path"      ada-prj-show-path                t]
     )
     ("Build"
      ["Next compilation error"     next-error                t]
@@ -407,6 +402,8 @@ Values defined by cross reference packages.")
      ["Show overriding"               ada-show-overriding          t]
      ["Show overridden"               ada-show-overridden          t]
      ["Goto prev position"            ada-goto-previous-pos        t]
+     ["Next placeholder"              ada-next-placeholder    t]
+     ["Previous placeholder"          ada-prev-placeholder    t]
      )
     ("Edit"
      ["Expand skeleton"             ada-expand              t]
@@ -426,6 +423,7 @@ Values defined by cross reference packages.")
      ["Adjust case at point"        ada-case-adjust-at-point  t]
      ["Adjust case region"          ada-case-adjust-region    t]
      ["Adjust case buffer"          ada-case-adjust-buffer    t]
+     ["Show casing files list"      ada-case-show-files       t]
      )
     ("Misc"
      ["Show last parse error"         ada-show-parse-error         t]
@@ -433,7 +431,6 @@ Values defined by cross reference packages.")
      ["Refresh cross reference cache" ada-xref-refresh             t]
      ["Reset parser"                  ada-reset-parser             t]
      )))
-(ada-case-activate-keys)
 
 ;; This doesn't need to be buffer-local because there can be only one
 ;; popup menu at a time.
@@ -515,6 +512,28 @@ Function is called with no arguments.")
   (when ada-expand
     (funcall ada-expand)))
 
+(defvar ada-next-placeholder nil
+  ;; skeleton function
+  "Function to call to goto next placeholder.")
+
+(defun ada-next-placeholder ()
+  "Goto next placeholder.
+Placeholders are defined by the skeleton backend."
+  (interactive)
+  (when ada-next-placeholder
+    (funcall ada-next-placeholder)))
+
+(defvar ada-prev-placeholder nil
+  ;; skeleton function
+  "Function to call to goto previous placeholder.")
+
+(defun ada-prev-placeholder ()
+  "Goto previous placeholder.
+Placeholders are defined by the skeleton backend."
+  (interactive)
+  (when ada-prev-placeholder
+    (funcall ada-prev-placeholder)))
+
 ;;;; abbrev, align
 
 (defvar ada-mode-abbrev-table nil
@@ -632,9 +651,9 @@ Function is called with no arguments.")
   "Function to scan a region, return a list of subprogram parameter 
declarations (in inverse declaration order).
 Function is called with two args BEGIN END (the region).
 Each parameter declaration is represented by a list
-'((identifier ...) in-p out-p not-null-p access-p constant-p protected-p type 
default)."
-  ;; mode is 'in | out | in out | [not null] access [constant | protected]'
-  ;; IMPROVEME: handle single-line trailing comments, or longer comments, in 
paramlist?
+'((identifier ...) aliased-p in-p out-p not-null-p access-p constant-p 
protected-p type default)."
+  ;; Summary of Ada syntax for a parameter specification:
+  ;; ... : [aliased] {[in] | out | in out | [null_exclusion] access [constant 
| protected]} ...
   )
 
 (defun ada-scan-paramlist (begin end)
@@ -649,12 +668,14 @@ Each parameter declaration is represented by a list
        len
        (ident-len 0)
        (type-len 0)
+       (aliased-p nil)
        (in-p nil)
        (out-p nil)
        (not-null-p nil)
        (access-p nil)
        ident-col
        colon-col
+       in-col
        out-col
        type-col
        default-col)
@@ -676,18 +697,19 @@ Each parameter declaration is represented by a list
 
       ;; we align the defaults after the types that have defaults, not after 
all types.
       ;; "constant", "protected" are treated as part of 'type'
-      (when (nth 8 param)
+      (when (nth 9 param)
        (setq type-len
              (max type-len
-                  (+ (length (nth 7 param))
-                     (if (nth 5 param) 10 0); "constant "
-                     (if (nth 6 param) 10 0); protected
+                  (+ (length (nth 8 param))
+                     (if (nth 6 param) 10 0); "constant "
+                     (if (nth 7 param) 10 0); protected
                      ))))
 
-      (setq in-p (or in-p (nth 1 param)))
-      (setq out-p (or out-p (nth 2 param)))
-      (setq not-null-p (or not-null-p (nth 3 param)))
-      (setq access-p (or access-p (nth 4 param)))
+      (setq aliased-p (or aliased-p (nth 1 param)))
+      (setq in-p (or in-p (nth 2 param)))
+      (setq out-p (or out-p (nth 3 param)))
+      (setq not-null-p (or not-null-p (nth 4 param)))
+      (setq access-p (or access-p (nth 5 param)))
       )
 
     (let ((space-before-p (save-excursion (skip-chars-backward " \t") (not 
(bolp))))
@@ -710,16 +732,19 @@ Each parameter declaration is represented by a list
     ;; compute columns.
     (setq ident-col (current-column))
     (setq colon-col (+ ident-col ident-len 1))
-    (setq out-col (+ colon-col (if in-p 5 0))); ": in "
+    (setq in-col
+         (+ colon-col (if aliased-p 10 2))); ": aliased ..."
+    (setq out-col (+ in-col (if in-p 3 0))); ": [aliased] in "
     (setq type-col
-         (+ colon-col
+         (+ in-col
             (cond
-             (not-null-p 18);    ": not null access "
-             (access-p 9);        ": access"
-             ((and in-p out-p) 9); ": in out "
-             (out-p 6);           ": out "
-             (in-p 5);            ": in "
-             (t 2))));           ": "
+             ;; 'not null' without access is part of the type
+             ((and not-null-p access-p) 16); ": [aliased] not null access "
+             (access-p 7);         ": [aliased] access "
+             ((and in-p out-p) 7); ": [aliased] in out "
+             (in-p 3);             ": [aliased] in "
+             (out-p 4);            ": [aliased] out "
+             (t 0))));             ": [aliased] "
 
     (setq default-col (+ 1 type-col type-len))
 
@@ -738,29 +763,42 @@ Each parameter declaration is represented by a list
       (insert ": ")
 
       (when (nth 1 param)
-       (insert "in "))
+       (insert "aliased "))
 
+      (indent-to in-col)
       (when (nth 2 param)
+       (insert "in "))
+
+      (when (nth 3 param)
        (indent-to out-col)
        (insert "out "))
 
-      (when (nth 3 param)
-       (insert "not null "))
+      (when (and (nth 4 param) ;; not null
+                (nth 5 param)) ;; access
+       (insert "not null access"))
 
-      (when (nth 4 param)
-       (insert "access "))
+      (when (and (not (nth 4 param)) ;; not null
+                (nth 5 param)) ;; access
+       (insert "access"))
 
       (indent-to type-col)
-      (when (nth 5 param)
-       (insert "constant "))
+
+      (when (and (nth 4 param) ;; not null
+                (not (nth 5 param))) ;; access
+       (insert "not null "))
+
       (when (nth 6 param)
+       (insert "constant "))
+
+      (when (nth 7 param)
        (insert "protected "))
-      (insert (nth 7 param)); type
 
-      (when (nth 8 param); default
+      (insert (nth 8 param)); type
+
+      (when (nth 9 param); default
        (indent-to default-col)
        (insert ":= ")
-       (insert (nth 8 param)))
+       (insert (nth 9 param)))
 
       (if (zerop i)
          (insert ")")
@@ -795,26 +833,29 @@ Each parameter declaration is represented by a list
       (insert " : ")
 
       (when (nth 1 param)
-       (insert "in "))
+       (insert "aliased "))
 
       (when (nth 2 param)
-       (insert "out "))
+       (insert "in "))
 
       (when (nth 3 param)
-       (insert "not null "))
+       (insert "out "))
 
       (when (nth 4 param)
-       (insert "access "))
+       (insert "not null "))
 
       (when (nth 5 param)
-       (insert "constant "))
+       (insert "access "))
+
       (when (nth 6 param)
+       (insert "constant "))
+      (when (nth 7 param)
        (insert "protected "))
-      (insert (nth 7 param)); type
+      (insert (nth 8 param)); type
 
-      (when (nth 8 param); default
+      (when (nth 9 param); default
        (insert " := ")
-       (insert (nth 8 param)))
+       (insert (nth 9 param)))
 
       (if (zerop i)
          (if (= (char-after) ?\;)
@@ -848,14 +889,26 @@ Each parameter declaration is represented by a list
 
 (defvar ada-case-full-exceptions '()
   "Alist of words (entities) that have special casing, built from
-`ada-case-exception-file' full word exceptions. Indexed by
+project file casing file list full word exceptions. Indexed by
 properly cased word; value is t.")
 
 (defvar ada-case-partial-exceptions '()
   "Alist of partial words that have special casing, built from
-`ada-case-exception-file' partial word exceptions. Indexed by
+project casing files list partial word exceptions. Indexed by
 properly cased word; value is t.")
 
+(defun ada-case-show-files ()
+  "Show current casing files list."
+  (interactive)
+  (if (ada-prj-get 'casing)
+      (progn
+       (pop-to-buffer (get-buffer-create "*casing files*"))
+       (erase-buffer)
+       (dolist (file (ada-prj-get 'casing))
+         (insert (format "%s\n" file))))
+    (message "no casing files")
+    ))
+
 (defun ada-case-save-exceptions (full-exceptions partial-exceptions file-name)
   "Save FULL-EXCEPTIONS, PARTIAL-EXCEPTIONS to the file FILE-NAME."
   (with-temp-file (expand-file-name file-name)
@@ -896,7 +949,7 @@ Return (cons full-exceptions partial-exceptions)."
        (cons full-exceptions partial-exceptions))
 
     ;; else file not readable; might be a new project with no
-    ;; exceptions yet, so just warn user, return empty pair
+    ;; exceptions yet, so just return empty pair
     (message "'%s' is not a readable file." file-name)
     '(nil . nil)
     ))
@@ -915,7 +968,7 @@ An item in both lists has the RESULT value."
   (setq ada-case-partial-exceptions (ada-case-merge-exceptions 
ada-case-partial-exceptions (cdr exceptions))))
 
 (defun ada-case-read-all-exceptions ()
-  "Read case exceptions from all files in `ada-case-exception-file',
+  "Read case exceptions from all files in project casing files,
 replacing current values of `ada-case-full-exceptions', 
`ada-case-partial-exceptions'."
   (interactive)
   (setq ada-case-full-exceptions '()
@@ -1232,7 +1285,7 @@ Optional PLIST defaults to `ada-prj-current-project'."
 
       ;; no project, just use default vars
       ;; must match code in ada-prj-default
-      (cl-case plist
+      (cl-case prop
        (ada_compiler    ada-compiler)
        (auto_case       ada-auto-case)
        (case_keyword    ada-case-keyword)
@@ -1499,9 +1552,6 @@ Return new value of PROJECT."
     project
     ))
 
-(defvar ada-project-search-path nil
-  "Search path for finding Ada project files")
-
 (defvar ada-select-prj-compiler nil
   "Alist of functions to call for compiler specific project file selection.
 Indexed by project variable ada_compiler.")
@@ -1549,7 +1599,6 @@ Indexed by project variable xref_tool.")
   (ada-case-read-all-exceptions)
 
   (setq compilation-search-path (ada-prj-get 'src_dir))
-  (setq ada-project-search-path (ada-prj-get 'prj_dir))
 
   (let ((func (cdr (assq (ada-prj-get 'ada_compiler) 
ada-select-prj-compiler))))
     (when func (funcall func)))
@@ -1571,6 +1620,16 @@ Indexed by project variable xref_tool.")
   (interactive)
   (message "current Emacs Ada mode project file: %s" ada-prj-current-file))
 
+(defvar ada-prj-show-path nil
+  ;; Supplied by compiler
+  "Function to show project search path used by compiler (and possibly xref 
tool)."
+  )
+
+(defun ada-prj-show-path ()
+  (interactive)
+  (when ada-prj-show-path
+    (funcall ada-prj-show-path)))
+
 (defvar ada-show-xref-tool-buffer nil
   ;; Supplied by xref tool
   "Function to show process buffer used by xref tool."
@@ -1656,10 +1715,10 @@ In particular, character constants are set to have 
string syntax."
               "\\|\\(--\\)"; 4: comment start
               )
              end t)
-       ;; The help for syntax-propertize-extend-region-functions
-       ;; implies that 'start end' will always include whole lines, in
-       ;; which case we don't need
-       ;; syntax-propertize-extend-region-functions
+       ;; syntax-propertize-extend-region-functions is set to
+       ;; syntax-propertize-wholelines by default. We assume no
+       ;; coding standard will permit a character literal at the
+       ;; start of a line (not preceded by whitespace).
        (cond
         ((match-beginning 1)
          (put-text-property
@@ -1740,7 +1799,7 @@ found.")
   (funcall ada-file-name-from-ada-name ada-name))
 
 (defvar ada-ada-name-from-file-name nil
-  ;; depends on ada-compiler, per-project
+  ;; supplied by compiler
   "Function called with one parameter FILE-NAME, which is a library
 unit name; it should return the Ada name that should be found in FILE-NAME.")
 
@@ -1760,6 +1819,7 @@ unit name; it should return the Ada name that should be 
found in FILE-NAME.")
     (error "parent '%s' not found; set project file?" ff-function-name))))
 
 (defun ada-ff-special-extract-separate ()
+  ;; match-string contains "separate (parent_name)"
   (let ((package-name (match-string 1)))
     (save-excursion
       (goto-char (match-end 0))
@@ -1832,6 +1892,30 @@ other file.")
   (when ada-which-function
     (funcall ada-which-function)))
 
+(defvar ada-on-context-clause nil
+  ;; supplied by indentation engine
+  "Function called with no parameters; it should return non-nil
+  if point is on a context clause.")
+
+(defun ada-on-context-clause ()
+  "See `ada-on-context-clause' variable."
+  (interactive)
+  (when ada-on-context-clause
+    (funcall ada-on-context-clause)))
+
+(defvar ada-goto-subunit-name nil
+  ;; supplied by indentation engine
+  "Function called with no parameters; if the current buffer
+  contains a subunit, move point to the subunit name (for
+  `ada-goto-declaration'), return t; otherwise leave point alone,
+  return nil.")
+
+(defun ada-goto-subunit-name ()
+  "See `ada-goto-subunit-name' variable."
+  (interactive)
+  (when ada-goto-subunit-name
+    (funcall ada-goto-subunit-name)))
+
 (defun ada-add-log-current-function ()
   "For `add-log-current-defun-function'; uses `ada-which-function'."
   ;; add-log-current-defun is typically called with point at the start
@@ -1936,18 +2020,23 @@ the other file."
   (interactive "P")
   (ada-check-current-project (buffer-file-name))
 
-  (if mark-active
-      (progn
-       (setq ff-function-name (buffer-substring-no-properties (point) (mark)))
-       (ff-get-file
-        compilation-search-path
-        (ada-file-name-from-ada-name ff-function-name)
-        ada-spec-suffixes
-        other-window)
-       (deactivate-mark))
-
-    ;; else use name at point
+  (cond
+   (mark-active
+    (setq ff-function-name (buffer-substring-no-properties (point) (mark)))
+    (ff-get-file
+     compilation-search-path
+     (ada-file-name-from-ada-name ff-function-name)
+     ada-spec-suffixes
+     other-window)
+    (deactivate-mark))
+
+   ((and (not (ada-on-context-clause))
+        (ada-goto-subunit-name))
+    (ada-goto-declaration other-window))
+
+   (t
     (ff-find-other-file other-window)))
+  )
 
 (defvar ada-operator-re
   
"\\+\\|-\\|/\\|\\*\\*\\|\\*\\|=\\|&\\|abs\\|mod\\|rem\\|and\\|not\\|or\\|xor\\|<=\\|<\\|>=\\|>"
@@ -1955,7 +2044,7 @@ the other file."
 
 (defun ada-identifier-at-point ()
   "Return the identifier around point, move point to start of
-identifier.  May be an Ada identifier or operator function name."
+identifier.  May be an Ada identifier or operator."
 
   (when (ada-in-comment-p)
     (error "Inside comment"))
@@ -1964,7 +2053,8 @@ identifier.  May be an Ada identifier or operator 
function name."
 
     (skip-chars-backward "a-zA-Z0-9_<>=+\\-\\*/&")
 
-    ;; Just in front of, or inside, a string => we could have an operator
+    ;; Just in front of, or inside, a string => we could have an
+    ;; operator function declaration.
     (cond
      ((ada-in-string-p)
       (cond
@@ -1983,7 +2073,7 @@ identifier.  May be an Ada identifier or operator 
function name."
           (looking-at (concat "\"\\(" ada-operator-re "\\)\"")))
       (setq identifier (concat "\"" (match-string-no-properties 1) "\"")))
 
-     ((looking-at "[a-zA-Z0-9_]+")
+     ((looking-at "[a-zA-Z0-9_]+\\|[+\\-*/&=<>]")
       (setq identifier (match-string-no-properties 0)))
 
      (t
@@ -2095,18 +2185,18 @@ buffer in another window."
   (when (null ada-xref-other-function)
     (error "no cross reference information available"))
 
-    (let ((target
-          (funcall ada-xref-other-function
-                   (ada-identifier-at-point)
-                   (buffer-file-name)
-                   (line-number-at-pos)
-                   (1+ (current-column))
-                   )))
-
-      (ada-goto-source (nth 0 target)
-                      (nth 1 target)
-                      (nth 2 target)
-                      other-window)
+  (let ((target
+        (funcall ada-xref-other-function
+                 (ada-identifier-at-point)
+                 (buffer-file-name)
+                 (line-number-at-pos)
+                 (1+ (current-column))
+                 )))
+
+    (ada-goto-source (nth 0 target)
+                    (nth 1 target)
+                    (nth 2 target)
+                    other-window)
     ))
 
 (defvar ada-xref-parent-function nil
@@ -2426,7 +2516,8 @@ The paragraph is indented on the first line."
           (not (looking-at "[ \t]*--")))
       (error "Not inside comment"))
 
-  (let* (indent from to
+  (let* ((inhibit-modification-hooks t) ;; don't run parser for font-lock; 
comment text is exposed
+        indent from to
         (opos (point-marker))
         ;; we bind `fill-prefix' here rather than in ada-mode because
         ;; setting it in ada-mode causes indent-region to use it for
@@ -2562,14 +2653,23 @@ The paragraph is indented on the first line."
          "access\\|"
          "constant\\|"
          "in[ \t]+reverse\\|"; loop iterator
+         "in[ \t]+not[ \t]+null[ \t]+access\\|"
          "in[ \t]+not[ \t]+null\\|"
+         "in[ \t]+out[ \t]+not[ \t]+null[ \t]+access\\|"
          "in[ \t]+out[ \t]+not[ \t]+null\\|"
          "in[ \t]+out\\|"
          "in\\|"
-         ;; "return\\|" can't distinguish between 'function ... return 
<type>;' and 'return ...;'
-         ;; An indentation engine can, so a rule for this is added there
-         "of[ \t]+reverse\\|"
-         "of\\|"
+         ;; "return" can't distinguish between 'function ... return <type>;' 
and 'return ...;'
+         ;; "new" can't distinguish between generic instantiation
+         ;;       package foo is new bar (...)
+         ;;    and allocation
+         ;;       a := new baz (...)
+         ;; A parsing indentation engine can, so rules for these are added 
there
+         "not[ \t]+null[ \t]access[ \t]all\\|"
+         "not[ \t]+null[ \t]access[ \t]constant\\|"
+         "not[ \t]+null[ \t]access\\|"
+         "not[ \t]+null\\|"
+         ;; "of" can't distinguish between array and iterable_name
          "out\\|"
          "subtype\\|"
          "type"
@@ -2584,15 +2684,17 @@ The paragraph is indented on the first line."
          (regexp-opt
           (append
            '("abort" "abs" "accept" "all"
-             "and" "array" "at" "begin" "case" "declare" "delay" "delta"
+             ;; "and" requires parser for types in interface_lists
+             "array" "at" "begin" "case" "declare" "delay" "delta"
              "digits" "do" "else" "elsif" "entry" "exception" "exit" "for"
              "generic" "if" "in" "limited" "loop" "mod" "not"
              "null" "or" "others" "private" "raise"
-             "range" "record" "rem" "renames" "reverse"
+             "range" "record" "rem" "reverse"
              "select" "separate" "task" "terminate"
              "then" "when" "while" "xor")
            (when (member ada-language-version '(ada95 ada2005 ada2012))
-             '("abstract" "aliased" "requeue" "tagged" "until"))
+             ;; "aliased" can't distinguish between object declaration and 
paramlist
+             '("abstract" "requeue" "tagged" "until"))
            (when (member ada-language-version '(ada2005 ada2012))
              '("interface" "overriding" "synchronized"))
            (when (member ada-language-version '(ada2012))
@@ -2602,6 +2704,12 @@ The paragraph is indented on the first line."
          "\\>")
         '(0 font-lock-keyword-face))
 
+   ;; after the above to handle 'is begin' in blocks
+   (list (concat
+         "\\<\\(is\\)\\>[ \t]*"
+         ada-name-regexp "?")
+        '(1 font-lock-keyword-face) '(2 font-lock-type-face nil t))
+
    ;; object and parameter declarations; word after ":" should be in
    ;; type-face if not already fontified or an exception.
    (list (concat
@@ -2615,33 +2723,10 @@ The paragraph is indented on the first line."
 
    ;; keywords followed by a name that should be in function-name-face if not 
already fontified
    (list (concat
-         "\\<\\("
-         "end"
-         "\\)\\>[ \t]*"
+         "\\<\\(end\\)\\>[ \t]*"
          ada-name-regexp "?")
      '(1 font-lock-keyword-face) '(2 font-lock-function-name-face nil t))
 
-   ;; Keywords followed by a name that could be a type or a function (generic 
instantiation).
-   (list (concat
-         "\\<\\("
-         "new"
-         "\\)\\>[ \t]*"
-         ada-name-regexp "?[ \t]*\\((\\)?")
-        '(1 font-lock-keyword-face)
-        '(2 (if (match-beginning 3)
-                font-lock-function-name-face
-              font-lock-type-face)
-            nil t))
-
-   ;; keywords followed by a name that should be in type-face if not already 
fontified (for subtypes)
-   ;; after "new" to handle "is new"
-   (list (concat
-         "\\<\\("
-         "is"
-         "\\)\\>[ \t]*"
-         ada-name-regexp "?")
-     '(1 font-lock-keyword-face) '(2 font-lock-type-face nil t))
-
    ;; Keywords followed by a comma separated list of names which
    ;; should be in constant-face, unless already fontified. Ada mode 4.01 used 
this.
    (list (concat
@@ -2708,6 +2793,7 @@ The paragraph is indented on the first line."
 
   (set (make-local-variable 'require-final-newline) t)
 
+  ;; 'font-lock-defaults' is a confusing name; it's buffer local
   (setq font-lock-defaults
        '(ada-font-lock-keywords
          nil t
@@ -2751,6 +2837,8 @@ The paragraph is indented on the first line."
 
   (easy-menu-add ada-mode-menu ada-mode-map)
 
+  (setq ada-case-strict (ada-prj-get 'case_strict))
+
   (run-mode-hooks 'ada-mode-hook)
 
   ;; If global-font-lock is not enabled, ada-syntax-propertize is
diff --git a/packages/ada-mode/ada-mode.info b/packages/ada-mode/ada-mode.info
index 6e06826..78b9799 100644
--- a/packages/ada-mode/ada-mode.info
+++ b/packages/ada-mode/ada-mode.info
@@ -114,15 +114,28 @@ the distribution.
    To see what version of Ada mode you have installed, invoke 'M-x
 ada-mode-version'.
 
+   You may also want to install additional utilities:
+
 * Menu:
 
+* Ada Reference Manual::
 * gnatinspect::
+* gpr_query::
 * Upgrading::
 
 
-File: ada-mode.info,  Node: gnatinspect,  Next: Upgrading,  Prev: 
Installation,  Up: Installation
+File: ada-mode.info,  Node: Ada Reference Manual,  Next: gnatinspect,  Up: 
Installation
+
+2.1 Ada Reference Manual
+========================
+
+The ELPA package ada-ref-man includes the Ada Reference Manual and
+Annotated Ada Reference Manual in info format.
 
-2.1 gnatinspect
+
+File: ada-mode.info,  Node: gnatinspect,  Next: gpr_query,  Prev: 
Installation,  Up: Installation
+
+2.2 gnatinspect
 ===============
 
 Ada mode has experimental support for the new AdaCore cross reference
@@ -149,9 +162,22 @@ created by gnatinspect:
      gcc -O2 -o sqlite3 shell.c sqlite3.c -ldl -lpthread
 
 
-File: ada-mode.info,  Node: Upgrading,  Prev: gnatinspect,  Up: Installation
+File: ada-mode.info,  Node: gpr_query,  Next: Upgrading,  Prev: gnatinspect,  
Up: Installation
+
+2.3 gpr_query
+=============
+
+'gpr_query' is similar to 'gnatinspect', but customized for Emacs
+ada-mode use.  To install it, install 'gnatinspect' as above (*note
+gnatinspect::), then:
+
+     cd ~/.emacs.d/elpa/ada-mode-5.xx/build
+     make install-gpr_query
+
+
+File: ada-mode.info,  Node: Upgrading,  Prev: gpr_query,  Up: Installation
 
-2.2 Upgrading from previous versions
+2.4 Upgrading from previous versions
 ====================================
 
 See the file NEWS for more details; here we summarize only important
@@ -259,12 +285,22 @@ is used to index several variables that point to the
 cross-reference-tool-specific functions for corresponding Ada mode
 operations.
 
-   To use a cross reference tool other than gnatxref, you must write
+   The default cross-reference tool is 'gnatxref', provided by the file
+'ada-gnat-xref.el'.  Two other tools are supported: 'gnat_inspect' and
+'gpr_query'.  To use these, add one of the following to '~/.emacs':
+
+     (require 'gnat-inspect)
+     (require 'gpr-query)
+
+   To use 'gpr_query', the Ada code 'gpr_query.adb' must be compiled;
+see *note Installation::.
+
+   To use a cross reference tool other than the above, you must write
 Emacs lisp code that provides the interface to the compiler, and set
-'ada-xref-tool' and the indirection variables.  This has already been
-done for 'gnatinspect'; set 'ada-xref-tool' to ''gnat_inspect'.
+'ada-xref-tool' and the indirection variables.
 
-   See 'ada-gnat-xref.el' and 'gnat-inspect.el' for examples.
+   See 'ada-gnat-xref.el', 'gnat-inspect.el', 'gpr-query.el' for
+examples.
 
 
 File: ada-mode.info,  Node: Other customization,  Prev: Other cross-reference, 
 Up: Customization
@@ -1452,7 +1488,7 @@ specifies the casing of one word or word fragment.  If an 
exception is
 defined in multiple files, the first occurrence is used.
 
    If the word starts with an asterisk ('*'), it defines the casing of a
-word fragemnt (or "substring"); part of a word between two underscores
+word fragment (or "substring"); part of a word between two underscores
 or word boundary.
 
    For example:
@@ -2416,44 +2452,46 @@ Tag Table:
 Node: Top945
 Node: Overview2576
 Node: Installation3787
-Node: gnatinspect4675
-Node: Upgrading5672
-Node: Customization6246
-Node: Non-standard file names6728
-Node: Other compiler8569
-Node: Other cross-reference9148
-Node: Other customization9867
-Node: Compiling Executing12337
-Node: Compile commands13072
-Node: Compiling Examples15810
-Node: No project files16642
-Node: Set compiler options22008
-Node: Set source search path23970
-Node: Use GNAT project file26423
-Node: Use multiple GNAT project files29197
-Node: Use a Makefile31917
-Node: Compiler errors33232
-Node: Project files34049
-Node: Project file overview35076
-Node: Project file variables36604
-Node: Moving Through Ada Code40234
-Node: Identifier completion42933
-Node: Indentation43895
-Node: Statement skeletons47947
-Node: Aligning code49732
-Node: Automatic casing50677
-Node: Comment Handling53381
-Node: Key summary53900
-Node: Developer overview56527
-Node: Directory structure56867
-Node: Package organization60353
-Node: Ada mode60588
-Node: gpr mode62784
-Node: GNAT core63067
-Node: Wisi64013
-Node: OpenToken64980
-Node: ELPA65582
-Node: GNU Free Documentation License66192
-Node: Index91353
+Node: Ada Reference Manual4769
+Node: gnatinspect5026
+Node: gpr_query6023
+Node: Upgrading6380
+Node: Customization6952
+Node: Non-standard file names7434
+Node: Other compiler9275
+Node: Other cross-reference9854
+Node: Other customization10865
+Node: Compiling Executing13335
+Node: Compile commands14070
+Node: Compiling Examples16808
+Node: No project files17640
+Node: Set compiler options23006
+Node: Set source search path24968
+Node: Use GNAT project file27421
+Node: Use multiple GNAT project files30195
+Node: Use a Makefile32915
+Node: Compiler errors34230
+Node: Project files35047
+Node: Project file overview36074
+Node: Project file variables37602
+Node: Moving Through Ada Code41232
+Node: Identifier completion43931
+Node: Indentation44893
+Node: Statement skeletons48945
+Node: Aligning code50730
+Node: Automatic casing51675
+Node: Comment Handling54379
+Node: Key summary54898
+Node: Developer overview57525
+Node: Directory structure57865
+Node: Package organization61351
+Node: Ada mode61586
+Node: gpr mode63782
+Node: GNAT core64065
+Node: Wisi65011
+Node: OpenToken65978
+Node: ELPA66580
+Node: GNU Free Documentation License67190
+Node: Index92351
 
 End Tag Table
diff --git a/packages/ada-mode/ada-mode.texi b/packages/ada-mode/ada-mode.texi
index 06e0d41..730b06a 100644
--- a/packages/ada-mode/ada-mode.texi
+++ b/packages/ada-mode/ada-mode.texi
@@ -26,11 +26,7 @@ developing GNU and promoting software freedom.''
 
 @titlepage
 @sp 10
address@hidden Ada Mode
address@hidden 2
address@hidden An Emacs major mode for programming in Ada
address@hidden Ada Mode Version 5.1.5
address@hidden 2
address@hidden Ada Mode Version 5.1.6
 @page
 @vskip 0pt plus 1filll
 @insertcopying
@@ -121,12 +117,21 @@ in the distribution.
 To see what version of Ada mode you have installed, invoke @kbd{M-x
 ada-mode-version}.
 
+You may also want to install additional utilities:
+
 @menu
+* Ada Reference Manual::
 * gnatinspect::
+* gpr_query::
 * Upgrading::
 @end menu
 
address@hidden gnatinspect, Upgrading, Installation, Installation
address@hidden Ada Reference Manual
address@hidden Ada Reference Manual
+The ELPA package ada-ref-man includes the Ada Reference Manual and
+Annotated Ada Reference Manual in info format.
+
address@hidden gnatinspect, gpr_query, Installation, Installation
 @section gnatinspect
 Ada mode has experimental support for the new AdaCore cross reference
 tool @code{gnatinspect}, which supports Ada, C, C++, and any other
@@ -156,7 +161,18 @@ cd gnatcoll-1.7w-src/src/sqlite/amalgamation/
 gcc -O2 -o sqlite3 shell.c sqlite3.c -ldl -lpthread
 @end example
 
address@hidden Upgrading,  , gnatinspect, Installation
address@hidden gpr_query, Upgrading, gnatinspect, Installation
address@hidden gpr_query
address@hidden is similar to @file{gnatinspect}, but customized for
+Emacs ada-mode use. To install it, install @file{gnatinspect} as above
+(@ref{gnatinspect}), then:
+
address@hidden
+cd ~/.emacs.d/elpa/ada-mode-5.xx/build
+make install-gpr_query
address@hidden example
+
address@hidden Upgrading,  , gpr_query, Installation
 @section Upgrading from previous versions
 
 See the file NEWS for more details; here we summarize only important
@@ -260,13 +276,25 @@ The project variable @code{ada_xref} (default elisp 
variable
 the cross-reference-tool-specific functions for corresponding Ada mode
 operations.
 
-To use a cross reference tool other than gnatxref, you must write
+The default cross-reference tool is @file{gnatxref}, provided by the
+file @file{ada-gnat-xref.el}. Two other tools are supported:
address@hidden and @file{gpr_query}. To use these, add one of the
+following to @file{~/.emacs}:
+
address@hidden
+(require 'gnat-inspect)
+(require 'gpr-query)
address@hidden example
+
+To use @file{gpr_query}, the Ada code @file{gpr_query.adb} must be
+compiled; see @ref{Installation}.
+
+To use a cross reference tool other than the above, you must write
 Emacs lisp code that provides the interface to the compiler, and set
address@hidden and the indirection variables. This has already
-been done for @code{gnatinspect}; set @code{ada-xref-tool} to
address@hidden'gnat_inspect}.
address@hidden and the indirection variables.
 
-See @file{ada-gnat-xref.el} and @file{gnat-inspect.el} for examples.
+See @file{ada-gnat-xref.el}, @file{gnat-inspect.el},
address@hidden for examples.
 
 @node Other customization,  , Other cross-reference, Customization
 @section Other customization
@@ -1543,7 +1571,7 @@ file specifies the casing of one word or word fragment. 
If an
 exception is defined in multiple files, the first occurrence is used.
 
 If the word starts with an asterisk (@code{*}), it defines the casing
-of a word fragemnt (or ``substring''); part of a word between two
+of a word fragment (or ``substring''); part of a word between two
 underscores or word boundary.
 
 For example:
diff --git a/packages/ada-mode/ada-ref-man.el b/packages/ada-mode/ada-ref-man.el
new file mode 100755
index 0000000..6344056
--- /dev/null
+++ b/packages/ada-mode/ada-ref-man.el
@@ -0,0 +1,12 @@
+;;; ada-ref-man.el --- Ada Reference Manual 2012
+;;
+;;; Copyright (C) 2014  Free Software Foundation, Inc.
+;;
+;; Author: Stephen Leake <address@hidden>
+;; Maintainer: Stephen Leake <address@hidden>
+;; Keywords: languages
+;;  ada
+;; Version: 2012.0
+;; url: http://stephe-leake.org/ada/arm.html
+;;
+;; (Gnu ELPA requires single digits between dots in versions)
diff --git a/packages/ada-mode/ada-skel.el b/packages/ada-mode/ada-skel.el
index a6216c1..48e6b32 100644
--- a/packages/ada-mode/ada-skel.el
+++ b/packages/ada-mode/ada-skel.el
@@ -145,7 +145,7 @@ This could end in a token recognized by `ada-skel-expand'."
 (define-skeleton ada-skel-for
   "Insert a for loop statement with an optional name (from `str')."
   ()
-  str & ":\n"
+  str & " :\n"
   "for " _ " loop\n"
   "end loop " str | -1 ";")
 
@@ -429,6 +429,15 @@ it is a name, and use the word before that as the token."
         (goto-char pos)
         nil)))))
 
+(defun ada-skel-next-placeholder ()
+  "Move point to after next placeholder."
+  (skip-syntax-forward "^!")
+  (skip-syntax-forward "w!"))
+
+(defun ada-skel-prev-placeholder ()
+  "Move point to after previous placeholder."
+  (skip-syntax-backward "^!"))
+
 (defun ada-skel-setup ()
   "Setup a buffer for ada-skel."
   (add-hook 'skeleton-end-hook 'ada-indent-statement nil t)
@@ -441,6 +450,8 @@ it is a name, and use the word before that as the token."
 (provide 'ada-skel)
 
 (setq ada-expand 'ada-skel-expand)
+(setq ada-next-placeholder 'ada-skel-next-placeholder)
+(setq ada-prev-placeholder 'ada-skel-prev-placeholder)
 
 (add-hook 'ada-mode-hook 'ada-skel-setup)
 
diff --git a/packages/ada-mode/ada-wisi.el b/packages/ada-mode/ada-wisi.el
index d86e93a..443ad66 100644
--- a/packages/ada-mode/ada-wisi.el
+++ b/packages/ada-mode/ada-wisi.el
@@ -33,12 +33,19 @@
 (require 'cl-lib)
 (require 'wisi)
 
+(defcustom ada-wisi-font-lock-size-threshold 100000
+  "Max size (in characters) for using wisi parser results for syntax 
highlighting."
+  :type 'integer
+  :group 'ada-indentation
+  :safe 'integerp)
+
 (defconst ada-wisi-class-list
   '(
     block-end
     block-middle ;; not start of statement
     block-start ;; start of block is start of statement
     close-paren
+    keyword    ;; cached only for face; not used in indentation
     list-break
     name
     name-paren ;; anything that looks like a procedure call, since the grammar 
can't distinguish most of them
@@ -49,24 +56,27 @@
     statement-end
     statement-other
     statement-start
-    type
     ))
 
 ;;;; indentation
 
 (defun ada-wisi-current-indentation ()
-  "Return indentation of current line, incremented by 1 if starts with 
open-paren."
+  "Return indentation appropriate for point on current line:
+if not in paren, beginning of line
+if in paren, pos following paren."
   (if (not (ada-in-paren-p))
       (current-indentation)
 
-    (save-excursion
-      (back-to-indentation)
-      (let ((cache (wisi-get-cache (point))))
-       (if (and cache
-                (eq 'open-paren (wisi-cache-class cache)))
-           (1+ (current-column))
-         (current-column))
-       ))))
+    (or
+     (save-excursion
+       (let ((line (line-number-at-pos)))
+        (ada-goto-open-paren 1)
+        (when (= line (line-number-at-pos))
+          (current-column))))
+     (save-excursion
+       (back-to-indentation)
+       (current-column)))
+    ))
 
 (defun ada-wisi-indent-cache (offset cache)
   "Return indentation of OFFSET plus indentation of line containing point. 
Point must be at CACHE."
@@ -295,6 +305,10 @@ point must be on CACHE. PREV-TOKEN is the token before the 
one being indented."
 
        (close-paren (wisi-indent-paren 0))
 
+       (keyword
+        ;; defer to after-cache)
+        nil)
+
        (name
         (cl-case (wisi-cache-nonterm cache)
           ((function_specification procedure_specification)
@@ -388,7 +402,7 @@ point must be on CACHE. PREV-TOKEN is the token before the 
one being indented."
              ;;     (Local_2 = 1)
              (+ (ada-wisi-current-indentation) ada-indent-broken))
 
-            (name
+            ((IDENTIFIER selected_component name)
              ;; test/indent.ads
              ;; CSCL_Type'
              ;;   (
@@ -408,6 +422,12 @@ point must be on CACHE. PREV-TOKEN is the token before the 
one being indented."
              ;;      (1.0),
              ;;    B => Integer
              ;;      (2.0));
+             ;;
+             ;; test/ada_mode-parens.adb
+             ;; Local_12 : Local_11_Type
+             ;;   := Local_11_Type'(A => Integer
+             ;;     (1.0),
+             ;; indenting (1.0)
              (+ (ada-wisi-current-indentation) ada-indent-broken))
 
             (t
@@ -497,6 +517,13 @@ point must be on CACHE. PREV-TOKEN is the token before the 
one being indented."
                 ;; indenting 'with'
                 (+ (current-column) 1))
 
+               (association_list
+                ;; test/ada_mode-parens.adb
+                ;; Local_13 : Local_11_Type
+                ;;   := (Integer'(1),
+                ;;       Integer'(2));
+                (ada-wisi-indent-cache 0 containing))
+
                (association_opt
                 ;; test/indent.ads
                 ;; 1 =>  --  Used to be aligned on "CSCL_Type'"
@@ -544,6 +571,12 @@ point must be on CACHE. PREV-TOKEN is the token before the 
one being indented."
                 ;; type Limited_Derived_Type_2a is abstract limited new 
Private_Type_1
                 ;; with record
                 ;; indenting 'with record'
+                ;;
+                ;; test/access_in_record.ads
+                ;; type A
+                ;;    is new Ada.Streams.Root_Stream_Type with record
+                ;; FIXME: line with 'record' use ada-indent-record-rel-type
+
                 (while (not (eq 'TYPE (wisi-cache-token containing)))
                   (setq containing (wisi-goto-containing containing)))
 
@@ -598,6 +631,12 @@ point must be on CACHE. PREV-TOKEN is the token before the 
one being indented."
                    (+ (current-indentation) ada-indent-broken))
                   ))
 
+               (private_extension_declaration
+                ;; test/ada_mode-nominal.ads
+                ;; type Limited_Derived_Type_3 is abstract limited
+                ;;   new Private_Type_1 with private;
+                (+ (current-indentation) ada-indent-broken))
+
                (private_type_declaration
                 ;; test/aspects.ads
                 ;; type Vector is tagged private
@@ -683,9 +722,6 @@ point must be on CACHE. PREV-TOKEN is the token before the 
one being indented."
                  nil)
                 ))))
             ))
-
-       (type
-        (ada-wisi-indent-containing ada-indent-broken cache t))
        ))
     ))
 
@@ -701,7 +737,7 @@ cached token, return new indentation for point."
        0)
 
      (t
-      (while (memq (wisi-cache-class cache) '(name name-paren type))
+      (while (memq (wisi-cache-class cache) '(keyword name name-paren type))
        ;; not useful for indenting
        (setq cache (wisi-backward-cache)))
 
@@ -826,8 +862,24 @@ cached token, return new indentation for point."
             (+ paren-column 1 ada-indent-broken))))
 
        ((return-1 return-2)
-        ;; hanging. Intent relative to line containing matching 'function'
-        (ada-prev-statement-keyword)
+        ;; test/ada_mode-nominal.adb
+        ;; function Function_Access_1
+        ;;   (A_Param : in Float)
+        ;;   return
+        ;;     Standard.Float
+        ;; indenting 'Standard.Float'
+        ;;
+        ;; test/ada_mode-expression_functions.ads
+        ;; function Square (A : in Float) return Float
+        ;;   is (A * A);
+        ;; indenting 'is'
+        ;;
+        ;; test/ada_mode-nominal.ads
+        ;; function Function_2g
+        ;;   (Param : in Private_Type_1)
+        ;;   return Float
+        ;;   is abstract;
+        ;; indenting 'is'
         (back-to-indentation)
         (+ (current-column) ada-indent-broken))
 
@@ -1135,11 +1187,12 @@ cached token, return new indentation for point."
       (while (not end)
        (setq cache (wisi-forward-cache))
        (cl-case (wisi-cache-nonterm cache)
-         (pragma nil)
-         (use_clause nil)
+         (pragma (wisi-goto-end-1 cache))
+         (use_clause (wisi-goto-end-1 cache))
          (with_clause
           (when (not begin)
-            (setq begin (point-at-bol))))
+            (setq begin (point-at-bol)))
+          (wisi-goto-end-1 cache))
          (t
           ;; start of compilation unit
           (setq end (point-at-bol))
@@ -1149,6 +1202,43 @@ cached token, return new indentation for point."
       (cons begin end)
     )))
 
+(defun ada-wisi-on-context-clause ()
+  "For `ada-on-context-clause'."
+
+  (save-excursion
+    (and (wisi-goto-statement-start)
+        (memq (wisi-cache-nonterm (wisi-goto-statement-start)) '(use_clause 
with_clause)))))
+
+(defun ada-wisi-goto-subunit-name ()
+  "For `ada-goto-subunit-name'."
+  (wisi-validate-cache (point-max))
+  (let ((end nil)
+       cache
+       (name-pos nil))
+    (save-excursion
+      ;; move to top declaration
+      (goto-char (point-min))
+      (setq cache (or (wisi-get-cache (point))
+                     (wisi-forward-cache)))
+      (while (not end)
+       (cl-case (wisi-cache-nonterm cache)
+         ((pragma use_clause with_clause)
+          (wisi-goto-end-1 cache)
+          (setq cache (wisi-forward-cache)))
+         (t
+          ;; start of compilation unit
+          (setq end t))
+         ))
+      (when (eq (wisi-cache-nonterm cache) 'subunit)
+       (wisi-forward-find-token '(IDENTIFIER name selected_component) 
(point-max)) ;; parent name
+       (wisi-forward-token)
+       (wisi-forward-find-token '(IDENTIFIER name selected_component) 
(point-max)) ;; subunit name
+       (setq name-pos (point)))
+      )
+    (when name-pos
+      (goto-char name-pos))
+    ))
+
 (defun ada-wisi-goto-declaration-start ()
   "For `ada-goto-declaration-start', which see.
 Also return cache at start."
@@ -1296,6 +1386,7 @@ Also return cache at start."
   (let (token
        text
        identifiers
+       (aliased-p nil)
        (in-p nil)
        (out-p nil)
        (not-null-p nil)
@@ -1322,10 +1413,11 @@ Also return cache at start."
        (skip-syntax-forward " ")
        (setq type-begin (point))
        (save-excursion
-         (while (member (car (wisi-forward-token)) '(IN OUT NOT NULL ACCESS 
CONSTANT PROTECTED))
+         (while (member (car (wisi-forward-token)) '(ALIASED IN OUT NOT NULL 
ACCESS CONSTANT PROTECTED))
            (skip-syntax-forward " ")
            (setq type-begin (point)))))
 
+       ((equal token 'ALIASED) (setq aliased-p t))
        ((equal token 'IN) (setq in-p t))
        ((equal token 'OUT) (setq out-p t))
        ((and (not type-end)
@@ -1343,26 +1435,25 @@ Also return cache at start."
        (wisi-forward-find-token 'SEMICOLON end t))
 
        ((member token '(SEMICOLON RIGHT_PAREN))
-       (if (equal token 'RIGHT_PAREN)
-           ;; all done
-           (progn
-             (setq done t)
-             (when (not type-end) (setq type-end (1- (point))))
-             (when default-begin (setq default (buffer-substring-no-properties 
default-begin (1- (point)))))
-             )
-         ;; else semicolon - one param done
-         (when (not type-end) (setq type-end (1- (point))))
-         (when default-begin (setq default (buffer-substring-no-properties 
default-begin (1- (point)))))
-         )
+       (when (not type-end)
+         (setq type-end (save-excursion (backward-char 1) 
(skip-syntax-backward " ") (point))))
 
        (setq type (buffer-substring-no-properties type-begin type-end))
+
+       (when default-begin
+         (setq default (buffer-substring-no-properties default-begin (1- 
(point)))))
+
+       (when (equal token 'RIGHT_PAREN)
+         (setq done t))
+
        (setq param (list (reverse identifiers)
-                         in-p out-p not-null-p access-p constant-p protected-p
+                         aliased-p in-p out-p not-null-p access-p constant-p 
protected-p
                          type default))
        (if paramlist
            (add-to-list 'paramlist param)
          (setq paramlist (list param)))
        (setq identifiers nil
+             aliased-p nil
              in-p nil
              out-p nil
              not-null-p nil
@@ -1434,7 +1525,7 @@ Also return cache at start."
           (setq result (ada-wisi-which-function-1 "protected" t)))
 
          ((subprogram_declaration
-           subprogram_specification ;; after 'generic'
+           generic_subprogram_declaration ;; after 'generic'
            null_procedure_declaration)
           (setq result (ada-wisi-which-function-1
                         (wisi-cache-text (wisi-forward-find-token '(FUNCTION 
PROCEDURE) (point-max)))
@@ -1457,7 +1548,7 @@ Also return cache at start."
   (interactive)
   (define-key ada-mode-map "\M-e" 'wisi-show-parse-error)
   (define-key ada-mode-map "\M-h" 'wisi-show-containing-or-previous-cache)
-  (define-key ada-mode-map "\M-i" 'wisi-goto-end)
+  (define-key ada-mode-map "\M-i" 'wisi-goto-statement-end)
   (define-key ada-mode-map "\M-j" 'wisi-show-cache)
   (define-key ada-mode-map "\M-k" 'wisi-show-token)
   )
@@ -1476,58 +1567,80 @@ Also return cache at start."
   ;; Handle escaped quotes in strings
   (setq wisi-string-quote-escape-doubled t)
 
-  ;; Handle bracket notation for non-ascii characters in strings. This
-  ;; is actually more forgiving than that; it will treat
-  ;; '"foo["bar"]baz" as a single string. But that will be caught by
-  ;; the compiler, so it's ok for us.
-  (setq wisi-string-quote-escape '(?\" . ?\[ ))
-
   (set (make-local-variable 'comment-indent-function) 'wisi-comment-indent)
 
   (add-hook 'hack-local-variables-hook 'ada-wisi-post-local-vars nil t)
   )
 
+(defun ada-wisi-face ()
+  "Return face for token in match-data 2"
+  (let (cache)
+    (when (< (point-max) ada-wisi-font-lock-size-threshold)
+      (wisi-validate-cache (line-end-position)))
+
+    (if        (setq cache (wisi-get-cache (match-beginning 2)))
+       (wisi-cache-face cache)
+      'default)
+    ))
+
 (defun ada-wisi-post-local-vars ()
   ;; run after file local variables are read because font-lock-add-keywords
   ;; evaluates font-lock-defaults, which depends on ada-language-version.
-  (font-lock-add-keywords 'ada-mode
-   ;; use keyword cache to distinguish between 'function ... return <type>;' 
and 'return ...;'
+  ;;
+  ;; use parse results to distinguish difficult cases, but don't
+  ;; require parse just for font-lock
+  ;;
+  ;; name is not found if on next line
+  (font-lock-add-keywords nil
    (list
     (list
+     "\\<\\(of[ \t]+reverse\\)\\>"  ;; following word is object
+     '(1 font-lock-keyword-face)
+     )
+    (list
      (concat
       "\\<\\("
+      "aliased[ \t]+not[ \t]+null[ \t]+access\\|"
+      "aliased[ \t]+not[ \t]+null\\|"
       "return[ \t]+access[ \t]+constant\\|"
-      "return[ \t]+access\\|"
+      "return[ \t]+access"
+      "\\)\\>[ \t]*"
+      ada-name-regexp "?")
+     '(1 font-lock-keyword-face)
+     '(2 font-lock-type-face nil t)
+     )
+    (list
+     (concat
+      "\\<\\("
+      "aliased\\|"
+      "and\\|"
+      "of\\|"
+      "new\\|"
+      "renames\\|"
       "return"
       "\\)\\>[ \t]*"
       ada-name-regexp "?")
      '(1 font-lock-keyword-face)
-     '(2 (if (eq (when (not (ada-in-string-or-comment-p))
-                  (wisi-validate-cache (match-end 2))
-                  (and (wisi-get-cache (match-beginning 2))
-                       (wisi-cache-class (wisi-get-cache (match-beginning 
2)))))
-                'type)
-            font-lock-type-face
-          'default)
-        nil t)
-     )))
+     '(2 (ada-wisi-face) nil t)
+     ))
+   nil ;; add at start of list, so these have precedence
+   )
 
-  (when global-font-lock-mode
-    ;; ensure the modified keywords are applied
-    (font-lock-refresh-defaults))
   )
 
 (add-hook 'ada-mode-hook 'ada-wisi-setup)
 
 (setq ada-fix-context-clause 'ada-wisi-context-clause)
-(setq ada-goto-declaration-start 'ada-wisi-goto-declaration-start)
 (setq ada-goto-declaration-end 'ada-wisi-goto-declaration-end)
+(setq ada-goto-declaration-start 'ada-wisi-goto-declaration-start)
 (setq ada-goto-declarative-region-start 
'ada-wisi-goto-declarative-region-start)
-(setq ada-goto-end 'wisi-goto-end)
+(setq ada-goto-end 'wisi-goto-statement-end)
+(setq ada-goto-subunit-name 'ada-wisi-goto-subunit-name)
 (setq ada-in-paramlist-p 'ada-wisi-in-paramlist-p)
 (setq ada-indent-statement 'wisi-indent-statement)
 (setq ada-make-subprogram-body 'ada-wisi-make-subprogram-body)
 (setq ada-next-statement-keyword 'wisi-forward-statement-keyword)
+(setq ada-on-context-clause 'ada-wisi-on-context-clause)
 (setq ada-prev-statement-keyword 'wisi-backward-statement-keyword)
 (setq ada-reset-parser 'wisi-invalidate-cache)
 (setq ada-scan-paramlist 'ada-wisi-scan-paramlist)
diff --git a/packages/ada-mode/gnat-core.el b/packages/ada-mode/gnat-core.el
index dad377a..b0449ee 100644
--- a/packages/ada-mode/gnat-core.el
+++ b/packages/ada-mode/gnat-core.el
@@ -56,6 +56,18 @@
 
     project))
 
+(defun gnat-prj-show-path ()
+  "For `ada-prj-show-path'."
+    (interactive)
+  (if (ada-prj-get 'prj_dir)
+      (progn
+       (pop-to-buffer (get-buffer-create "*GNAT project search path*"))
+       (erase-buffer)
+       (dolist (file (ada-prj-get 'prj_dir))
+         (insert (format "%s\n" file))))
+    (message "no GNAT project search path files")
+    ))
+
 (defun gnat-prj-parse-emacs-one (name value project)
   "Handle gnat-specific Emacs Ada project file settings.
 Return new PROJECT if NAME recognized, nil otherwise.
diff --git a/packages/ada-mode/gnat-inspect.el 
b/packages/ada-mode/gnat-inspect.el
index 1c05fa8..8017879 100644
--- a/packages/ada-mode/gnat-inspect.el
+++ b/packages/ada-mode/gnat-inspect.el
@@ -495,7 +495,6 @@ Enable mode if ARG is positive"
   (setq ada-make-package-body       'ada-gnat-make-package-body)
 
   (add-hook 'ada-syntax-propertize-hook 'gnatprep-syntax-propertize)
-  (add-hook 'ada-syntax-propertize-hook 'ada-gnat-syntax-propertize)
 
   ;; must be after indentation engine setup, because that resets the
   ;; indent function list.
@@ -519,7 +518,6 @@ Enable mode if ARG is positive"
   (setq ada-make-package-body       nil)
 
   (setq ada-syntax-propertize-hook (delq 'gnatprep-syntax-propertize 
ada-syntax-propertize-hook))
-  (setq ada-syntax-propertize-hook (delq 'ada-gnat-syntax-propertize 
ada-syntax-propertize-hook))
   (setq ada-mode-hook (delq 'ada-gnat-inspect-setup ada-mode-hook))
 
   (setq ada-xref-other-function      nil)
diff --git a/packages/ada-mode/gpr-grammar-wy.el 
b/packages/ada-mode/gpr-grammar-wy.el
index d5e00cd..3cefbb1 100644
--- a/packages/ada-mode/gpr-grammar-wy.el
+++ b/packages/ada-mode/gpr-grammar-wy.el
@@ -74,7 +74,12 @@
 (defconst gpr-grammar-wy--parse-table
    (wisi-compile-grammar
    '((AMPERSAND COLON COLON_EQUALS COMMA DOT EQUAL_GREATER QUOTE SEMICOLON 
VERTICAL_BAR IDENTIFIER STRING_LITERAL ABSTRACT AGGREGATE CASE CONFIGURATION 
END EXTERNAL EXTERNAL_AS_LIST FOR IS LEFT_PAREN LIBRARY NULL OTHERS PACKAGE 
PROJECT RIGHT_PAREN STANDARD TYPE USE WHEN WITH )
-     ((attribute_declaration
+     ((aggregate
+       ((LEFT_PAREN string_list RIGHT_PAREN )
+        (progn
+        (wisi-statement-action 1 'open-paren 3 'close-paren)
+        (wisi-containing-action 1 2))))
+      (attribute_declaration
        ((FOR IDENTIFIER USE expression SEMICOLON )
         (progn
         (wisi-statement-action 1 'statement-start 3 'statement-other 5 
'statement-end)
@@ -131,10 +136,8 @@
        ((term ))
        ((expression AMPERSAND term )))
       (external_value
-       ((EXTERNAL LEFT_PAREN string_list RIGHT_PAREN )
-        (wisi-statement-action 2 'open-paren 4 'close-paren))
-       ((EXTERNAL_AS_LIST LEFT_PAREN string_list RIGHT_PAREN )
-        (wisi-statement-action 2 'open-paren 4 'close-paren)))
+       ((EXTERNAL aggregate ))
+       ((EXTERNAL_AS_LIST aggregate )))
       (identifier_opt
        (())
        ((IDENTIFIER )))
@@ -182,36 +185,37 @@
         (wisi-statement-action 1 'statement-start 3 'block-start 5 'block-end 
7 'statement-end)
         (wisi-containing-action 3 4))))
       (string_expression
-       ((string_primary ))
-       ((string_expression AMPERSAND string_primary )))
+       ((string_primary )))
       (string_primary
        ((STRING_LITERAL ))
        ((name ))
        ((external_value ))
        ((attribute_reference )))
       (string_list
-       ((string_expression ))
-       ((string_list COMMA string_expression )))
+       ((expression ))
+       ((string_list COMMA expression )
+        (progn
+        (wisi-statement-action 2 'list-break)
+        (wisi-containing-action 2 3))))
       (term
        ((string_expression ))
        ((LEFT_PAREN RIGHT_PAREN ))
-       ((LEFT_PAREN string_list RIGHT_PAREN )
-        (wisi-statement-action
-        1 'open-paren
-        3 'close-paren)))
+       ((aggregate )))
       (typed_string_declaration
-       ((TYPE IDENTIFIER IS LEFT_PAREN string_list RIGHT_PAREN SEMICOLON )
-        (wisi-statement-action 1 'statement-start 4 'open-paren 6 'close-paren 
7 'statement-end)))
+       ((TYPE IDENTIFIER IS aggregate SEMICOLON )
+        (progn
+        (wisi-statement-action 1 'statement-start 5 'statement-end)
+        (wisi-containing-action 1 4))))
       (with_clause
        ((WITH string_list SEMICOLON ))))
      [((default . error) (ABSTRACT . (context_clause_opt . 0)) (AGGREGATE . 
(context_clause_opt . 0)) (CONFIGURATION . (context_clause_opt . 0)) (LIBRARY . 
(context_clause_opt . 0)) (STANDARD . (context_clause_opt . 0)) (PROJECT . 
(context_clause_opt . 0)) ($EOI . (context_clause_opt . 0)) (WITH .  7))
       ((default . error) ($EOI . (project_qualifier_opt . 1)) (PROJECT . 
(project_qualifier_opt . 1)))
-      ((default . error) (LIBRARY .  30) ($EOI . (project_qualifier_opt . 3)) 
(PROJECT . (project_qualifier_opt . 3)))
+      ((default . error) (LIBRARY .  34) ($EOI . (project_qualifier_opt . 3)) 
(PROJECT . (project_qualifier_opt . 3)))
       ((default . error) ($EOI . (project_qualifier_opt . 6)) (PROJECT . 
(project_qualifier_opt . 6)))
       ((default . error) ($EOI . (project_qualifier_opt . 5)) (PROJECT . 
(project_qualifier_opt . 5)))
       ((default . error) (IS . (identifier_opt . 0)) (IDENTIFIER .  16))
       ((default . error) ($EOI . (project_qualifier_opt . 2)) (PROJECT . 
(project_qualifier_opt . 2)))
-      ((default . error) (STRING_LITERAL .  17) (EXTERNAL .  18) 
(EXTERNAL_AS_LIST .  19) (DOT . (identifier_opt . 0)) (AMPERSAND . 
(identifier_opt . 0)) (SEMICOLON . (identifier_opt . 0)) (COMMA . 
(identifier_opt . 0)) (QUOTE . (identifier_opt . 0)) (IDENTIFIER .  16) 
(PROJECT .  20))
+      ((default . error) (LEFT_PAREN .  20) (STRING_LITERAL .  17) (EXTERNAL . 
 18) (EXTERNAL_AS_LIST .  19) (DOT . (identifier_opt . 0)) (AMPERSAND . 
(identifier_opt . 0)) (SEMICOLON . (identifier_opt . 0)) (COMMA . 
(identifier_opt . 0)) (QUOTE . (identifier_opt . 0)) (IDENTIFIER .  16) 
(PROJECT .  21))
       ((default . error) ($EOI .  15))
       ((default . error) (ABSTRACT . (context_clause_opt . 1)) (AGGREGATE . 
(context_clause_opt . 1)) (CONFIGURATION . (context_clause_opt . 1)) (LIBRARY . 
(context_clause_opt . 1)) (STANDARD . (context_clause_opt . 1)) (PROJECT . 
(context_clause_opt . 1)) ($EOI . (context_clause_opt . 1)) (WITH .  7))
       ((default . error) (PROJECT . (project_qualifier_opt . 0)) ($EOI . 
(project_qualifier_opt . 0)) (ABSTRACT .  1) (STANDARD .  6) (AGGREGATE .  2) 
(LIBRARY .  4) (CONFIGURATION .  3))
@@ -220,141 +224,132 @@
       ((default . error) ($EOI . (project_declaration_opt . 0)) (PROJECT .  5))
       ((default . error) (WITH . (context_clause . 1)) (ABSTRACT . 
(context_clause . 1)) (AGGREGATE . (context_clause . 1)) (CONFIGURATION . 
(context_clause . 1)) (LIBRARY . (context_clause . 1)) (STANDARD . 
(context_clause . 1)) (PROJECT . (context_clause . 1)) ($EOI . (context_clause 
. 1)))
       ((default . error) ($EOI . accept) (WITH . accept) (WHEN . accept) (USE 
. accept) (TYPE . accept) (STANDARD . accept) (RIGHT_PAREN . accept) (PROJECT . 
accept) (PACKAGE . accept) (OTHERS . accept) (NULL . accept) (LIBRARY . accept) 
(LEFT_PAREN . accept) (IS . accept) (FOR . accept) (EXTERNAL_AS_LIST . accept) 
(EXTERNAL . accept) (END . accept) (CONFIGURATION . accept) (CASE . accept) 
(AGGREGATE . accept) (ABSTRACT . accept) (STRING_LITERAL . accept) (IDENTIFIER 
. accept) (VERTICAL_ [...]
-      ((default . error) (IS . (identifier_opt . 1)) (RIGHT_PAREN . 
(identifier_opt . 1)) (COMMA . (identifier_opt . 1)) (DOT . (identifier_opt . 
1)) (AMPERSAND . (identifier_opt . 1)) (SEMICOLON . (identifier_opt . 1)) 
(QUOTE . (identifier_opt . 1)))
+      ((default . error) (RIGHT_PAREN . (identifier_opt . 1)) (COMMA . 
(identifier_opt . 1)) (IS . (identifier_opt . 1)) (DOT . (identifier_opt . 1)) 
(AMPERSAND . (identifier_opt . 1)) (SEMICOLON . (identifier_opt . 1)) (QUOTE . 
(identifier_opt . 1)))
       ((default . error) (RIGHT_PAREN . (string_primary . 0)) (COMMA . 
(string_primary . 0)) (AMPERSAND . (string_primary . 0)) (SEMICOLON . 
(string_primary . 0)))
-      ((default . error) (LEFT_PAREN .  38))
-      ((default . error) (LEFT_PAREN .  37))
+      ((default . error) (LEFT_PAREN .  43))
+      ((default . error) (LEFT_PAREN .  43))
+      ((default . error) (LEFT_PAREN .  20) (STRING_LITERAL .  17) (EXTERNAL . 
 18) (EXTERNAL_AS_LIST .  19) (DOT . (identifier_opt . 0)) (AMPERSAND . 
(identifier_opt . 0)) (RIGHT_PAREN . ( 41 (identifier_opt . 0))) (COMMA . 
(identifier_opt . 0)) (QUOTE . (identifier_opt . 0)) (IDENTIFIER .  16) 
(PROJECT .  21))
       ((default . error) (QUOTE . (attribute_prefix . 0)))
-      ((default . error) (QUOTE .  36))
+      ((default . error) (RIGHT_PAREN . (term . 2)) (COMMA . (term . 2)) 
(AMPERSAND . (term . 2)) (SEMICOLON . (term . 2)))
+      ((default . error) (QUOTE .  40))
       ((default . error) (RIGHT_PAREN . (string_primary . 3)) (COMMA . 
(string_primary . 3)) (AMPERSAND . (string_primary . 3)) (SEMICOLON . 
(string_primary . 3)))
+      ((default . error) (SEMICOLON . (string_list . 0)) (RIGHT_PAREN . 
(string_list . 0)) (COMMA . (string_list . 0)) (AMPERSAND .  39))
       ((default . error) (RIGHT_PAREN . (string_primary . 2)) (COMMA . 
(string_primary . 2)) (AMPERSAND . (string_primary . 2)) (SEMICOLON . 
(string_primary . 2)))
-      ((default . error) (IS . (name . 0)) (COMMA . (name . 0)) (RIGHT_PAREN . 
(name . 0)) (SEMICOLON . (name . 0)) (AMPERSAND . (name . 0)) (DOT . (name . 
0)) (QUOTE . (name . 0)))
-      ((default . error) (RIGHT_PAREN . (string_primary . 1)) (COMMA . 
(string_primary . 1)) (AMPERSAND . (string_primary . 1)) (SEMICOLON . 
(string_primary . 1)) (DOT .  35) (QUOTE . (attribute_prefix . 1)))
-      ((default . error) (SEMICOLON . (string_list . 0)) (RIGHT_PAREN . 
(string_list . 0)) (COMMA . (string_list . 0)) (AMPERSAND .  34))
+      ((default . error) (COMMA . (name . 0)) (RIGHT_PAREN . (name . 0)) (IS . 
(name . 0)) (SEMICOLON . (name . 0)) (AMPERSAND . (name . 0)) (DOT . (name . 
0)) (QUOTE . (name . 0)))
+      ((default . error) (RIGHT_PAREN . (string_primary . 1)) (COMMA . 
(string_primary . 1)) (AMPERSAND . (string_primary . 1)) (SEMICOLON . 
(string_primary . 1)) (DOT .  38) (QUOTE . (attribute_prefix . 1)))
+      ((default . error) (RIGHT_PAREN . (term . 0)) (COMMA . (term . 0)) 
(AMPERSAND . (term . 0)) (SEMICOLON . (term . 0)))
       ((default . error) (COMMA . (string_expression . 0)) (RIGHT_PAREN . 
(string_expression . 0)) (SEMICOLON . (string_expression . 0)) (AMPERSAND . 
(string_expression . 0)))
-      ((default . error) (COMMA .  32) (SEMICOLON .  33))
-      ((default . error) (IS .  31))
+      ((default . error) (COMMA .  36) (SEMICOLON .  37))
+      ((default . error) (COMMA . (expression . 0)) (RIGHT_PAREN . (expression 
. 0)) (SEMICOLON . (expression . 0)) (AMPERSAND . (expression . 0)))
+      ((default . error) (IS .  35))
       ((default . error) ($EOI . (project_qualifier_opt . 4)) (PROJECT . 
(project_qualifier_opt . 4)))
-      ((default . error) (END . (declarative_items . 0)) (TYPE . 
((declarative_items . 0)  51)) (IDENTIFIER . ((declarative_items . 0)  46)) 
(NULL . ((declarative_items . 0)  49)) (CASE . ((declarative_items . 0)  47)) 
(FOR . ((declarative_items . 0)  48)) (PACKAGE . ((declarative_items . 0)  50)))
-      ((default . error) (STRING_LITERAL .  17) (EXTERNAL .  18) 
(EXTERNAL_AS_LIST .  19) (DOT . (identifier_opt . 0)) (AMPERSAND . 
(identifier_opt . 0)) (RIGHT_PAREN . (identifier_opt . 0)) (COMMA . 
(identifier_opt . 0)) (SEMICOLON . (identifier_opt . 0)) (QUOTE . 
(identifier_opt . 0)) (IDENTIFIER .  16) (PROJECT .  20))
+      ((default . error) (END . (declarative_items . 0)) (TYPE . 
((declarative_items . 0)  57)) (IDENTIFIER . ((declarative_items . 0)  52)) 
(NULL . ((declarative_items . 0)  55)) (CASE . ((declarative_items . 0)  53)) 
(FOR . ((declarative_items . 0)  54)) (PACKAGE . ((declarative_items . 0)  56)))
+      ((default . error) (LEFT_PAREN .  20) (STRING_LITERAL .  17) (EXTERNAL . 
 18) (EXTERNAL_AS_LIST .  19) (DOT . (identifier_opt . 0)) (AMPERSAND . 
(identifier_opt . 0)) (RIGHT_PAREN . (identifier_opt . 0)) (COMMA . 
(identifier_opt . 0)) (SEMICOLON . (identifier_opt . 0)) (QUOTE . 
(identifier_opt . 0)) (IDENTIFIER .  16) (PROJECT .  21))
       ((default . error) (WITH . (with_clause . 0)) (ABSTRACT . (with_clause . 
0)) (AGGREGATE . (with_clause . 0)) (CONFIGURATION . (with_clause . 0)) 
(LIBRARY . (with_clause . 0)) (STANDARD . (with_clause . 0)) (PROJECT . 
(with_clause . 0)) ($EOI . (with_clause . 0)))
-      ((default . error) (STRING_LITERAL .  17) (EXTERNAL .  18) 
(EXTERNAL_AS_LIST .  19) (DOT . (identifier_opt . 0)) (SEMICOLON . 
(identifier_opt . 0)) (COMMA . (identifier_opt . 0)) (RIGHT_PAREN . 
(identifier_opt . 0)) (AMPERSAND . (identifier_opt . 0)) (QUOTE . 
(identifier_opt . 0)) (IDENTIFIER .  16) (PROJECT .  20))
-      ((default . error) (IDENTIFIER .  43))
-      ((default . error) (IDENTIFIER .  42))
-      ((default . error) (STRING_LITERAL .  17) (EXTERNAL .  18) 
(EXTERNAL_AS_LIST .  19) (DOT . (identifier_opt . 0)) (AMPERSAND . 
(identifier_opt . 0)) (RIGHT_PAREN . (identifier_opt . 0)) (COMMA . 
(identifier_opt . 0)) (QUOTE . (identifier_opt . 0)) (IDENTIFIER .  16) 
(PROJECT .  20))
-      ((default . error) (STRING_LITERAL .  17) (EXTERNAL .  18) 
(EXTERNAL_AS_LIST .  19) (DOT . (identifier_opt . 0)) (AMPERSAND . 
(identifier_opt . 0)) (RIGHT_PAREN . (identifier_opt . 0)) (COMMA . 
(identifier_opt . 0)) (QUOTE . (identifier_opt . 0)) (IDENTIFIER .  16) 
(PROJECT .  20))
+      ((default . error) (IDENTIFIER .  50))
+      ((default . error) (LEFT_PAREN .  20) (STRING_LITERAL .  17) (EXTERNAL . 
 18) (EXTERNAL_AS_LIST .  19) (DOT . (identifier_opt . 0)) (SEMICOLON . 
(identifier_opt . 0)) (COMMA . (identifier_opt . 0)) (RIGHT_PAREN . 
(identifier_opt . 0)) (AMPERSAND . (identifier_opt . 0)) (QUOTE . 
(identifier_opt . 0)) (IDENTIFIER .  16) (PROJECT .  21))
+      ((default . error) (IDENTIFIER .  48))
+      ((default . error) (SEMICOLON . (term . 1)) (AMPERSAND . (term . 1)) 
(COMMA . (term . 1)) (RIGHT_PAREN . (term . 1)))
+      ((default . error) (COMMA .  36) (RIGHT_PAREN .  47))
+      ((default . error) (LEFT_PAREN .  20) (STRING_LITERAL .  17) (EXTERNAL . 
 18) (EXTERNAL_AS_LIST .  19) (DOT . (identifier_opt . 0)) (AMPERSAND . 
(identifier_opt . 0)) (RIGHT_PAREN . (identifier_opt . 0)) (COMMA . 
(identifier_opt . 0)) (QUOTE . (identifier_opt . 0)) (IDENTIFIER .  16) 
(PROJECT .  21))
+      ((default . error) (AMPERSAND . (external_value . 1)) (SEMICOLON . 
(external_value . 1)) (RIGHT_PAREN . (external_value . 1)) (COMMA . 
(external_value . 1)))
+      ((default . error) (AMPERSAND . (external_value . 0)) (SEMICOLON . 
(external_value . 0)) (RIGHT_PAREN . (external_value . 0)) (COMMA . 
(external_value . 0)))
       ((default . error) ($EOI . (compilation_unit . 0)))
-      ((default . error) (COMMA .  32) (RIGHT_PAREN .  71))
-      ((default . error) (COMMA .  32) (RIGHT_PAREN .  70))
-      ((default . error) (LEFT_PAREN .  69) (COMMA . (attribute_reference . 
0)) (RIGHT_PAREN . (attribute_reference . 0)) (SEMICOLON . (attribute_reference 
. 0)) (AMPERSAND . (attribute_reference . 0)))
+      ((default . error) (COMMA . (aggregate . 0)) (RIGHT_PAREN . (aggregate . 
0)) (SEMICOLON . (aggregate . 0)) (AMPERSAND . (aggregate . 0)))
+      ((default . error) (LEFT_PAREN .  75) (COMMA . (attribute_reference . 
0)) (RIGHT_PAREN . (attribute_reference . 0)) (SEMICOLON . (attribute_reference 
. 0)) (AMPERSAND . (attribute_reference . 0)))
+      ((default . error) (SEMICOLON . (expression . 1)) (COMMA . (expression . 
1)) (RIGHT_PAREN . (expression . 1)) (AMPERSAND . (expression . 1)))
       ((default . error) (IS . (name . 1)) (COMMA . (name . 1)) (RIGHT_PAREN . 
(name . 1)) (SEMICOLON . (name . 1)) (AMPERSAND . (name . 1)) (DOT . (name . 
1)) (QUOTE . (name . 1)))
-      ((default . error) (SEMICOLON . (string_expression . 1)) (COMMA . 
(string_expression . 1)) (RIGHT_PAREN . (string_expression . 1)) (AMPERSAND . 
(string_expression . 1)))
-      ((default . error) (AMPERSAND .  34) (RIGHT_PAREN . (string_list . 1)) 
(SEMICOLON . (string_list . 1)) (COMMA . (string_list . 1)))
-      ((default . error) (COLON .  67) (COLON_EQUALS .  68))
+      ((default . error) (AMPERSAND .  39) (RIGHT_PAREN . (string_list . 1)) 
(SEMICOLON . (string_list . 1)) (COMMA . (string_list . 1)))
+      ((default . error) (COLON .  73) (COLON_EQUALS .  74))
       ((default . error) (DOT . (identifier_opt . 0)) (IS . (identifier_opt . 
0)) (IDENTIFIER .  16))
-      ((default . error) (IDENTIFIER .  65))
-      ((default . error) (SEMICOLON .  64))
+      ((default . error) (IDENTIFIER .  71))
+      ((default . error) (SEMICOLON .  70))
       ((default . error) (IS . (identifier_opt . 0)) (IDENTIFIER .  16))
-      ((default . error) (IDENTIFIER .  62))
+      ((default . error) (IDENTIFIER .  68))
       ((default . error) (WHEN . (simple_declarative_item . 2)) (END . 
(simple_declarative_item . 2)) (IDENTIFIER . (simple_declarative_item . 2)) 
(CASE . (simple_declarative_item . 2)) (FOR . (simple_declarative_item . 2)) 
(NULL . (simple_declarative_item . 2)) (PACKAGE . (simple_declarative_item . 
2)) (TYPE . (simple_declarative_item . 2)))
       ((default . error) (WHEN . (simple_declarative_item . 3)) (END . 
(simple_declarative_item . 3)) (IDENTIFIER . (simple_declarative_item . 3)) 
(CASE . (simple_declarative_item . 3)) (FOR . (simple_declarative_item . 3)) 
(NULL . (simple_declarative_item . 3)) (PACKAGE . (simple_declarative_item . 
3)) (TYPE . (simple_declarative_item . 3)))
       ((default . error) (WHEN . (declarative_items . 1)) (END . 
(declarative_items . 1)) (IDENTIFIER . (declarative_items . 1)) (CASE . 
(declarative_items . 1)) (FOR . (declarative_items . 1)) (NULL . 
(declarative_items . 1)) (PACKAGE . (declarative_items . 1)) (TYPE . 
(declarative_items . 1)))
-      ((default . error) (END .  60) (TYPE .  51) (IDENTIFIER .  46) (NULL .  
49) (CASE .  47) (FOR .  48) (PACKAGE .  50))
+      ((default . error) (END .  66) (TYPE .  57) (IDENTIFIER .  52) (NULL .  
55) (CASE .  53) (FOR .  54) (PACKAGE .  56))
       ((default . error) (WHEN . (declarative_item . 2)) (END . 
(declarative_item . 2)) (TYPE . (declarative_item . 2)) (PACKAGE . 
(declarative_item . 2)) (NULL . (declarative_item . 2)) (FOR . 
(declarative_item . 2)) (CASE . (declarative_item . 2)) (IDENTIFIER . 
(declarative_item . 2)))
       ((default . error) (WHEN . (package_declaration . 0)) (END . 
(package_declaration . 0)) (IDENTIFIER . (package_declaration . 0)) (CASE . 
(package_declaration . 0)) (FOR . (package_declaration . 0)) (NULL . 
(package_declaration . 0)) (PACKAGE . (package_declaration . 0)) (TYPE . 
(package_declaration . 0)))
       ((default . error) (WHEN . (declarative_item . 0)) (END . 
(declarative_item . 0)) (TYPE . (declarative_item . 0)) (PACKAGE . 
(declarative_item . 0)) (NULL . (declarative_item . 0)) (FOR . 
(declarative_item . 0)) (CASE . (declarative_item . 0)) (IDENTIFIER . 
(declarative_item . 0)))
       ((default . error) (WHEN . (declarative_item . 1)) (END . 
(declarative_item . 1)) (TYPE . (declarative_item . 1)) (PACKAGE . 
(declarative_item . 1)) (NULL . (declarative_item . 1)) (FOR . 
(declarative_item . 1)) (CASE . (declarative_item . 1)) (IDENTIFIER . 
(declarative_item . 1)))
       ((default . error) (SEMICOLON . (identifier_opt . 0)) (IDENTIFIER .  16))
       ((default . error) (WHEN . (declarative_items . 2)) (TYPE . 
(declarative_items . 2)) (PACKAGE . (declarative_items . 2)) (NULL . 
(declarative_items . 2)) (FOR . (declarative_items . 2)) (CASE . 
(declarative_items . 2)) (IDENTIFIER . (declarative_items . 2)) (END . 
(declarative_items . 2)))
+      ((default . error) (IS .  83))
       ((default . error) (IS .  82))
-      ((default . error) (IS .  81))
       ((default . error) (WHEN . (simple_declarative_item . 4)) (TYPE . 
(simple_declarative_item . 4)) (PACKAGE . (simple_declarative_item . 4)) (NULL 
. (simple_declarative_item . 4)) (FOR . (simple_declarative_item . 4)) (CASE . 
(simple_declarative_item . 4)) (IDENTIFIER . (simple_declarative_item . 4)) 
(END . (simple_declarative_item . 4)))
-      ((default . error) (USE .  80) (LEFT_PAREN .  79))
-      ((default . error) (DOT .  35) (IS .  78))
-      ((default . error) (IDENTIFIER .  77))
-      ((default . error) (LEFT_PAREN .  73) (STRING_LITERAL .  17) (EXTERNAL . 
 18) (EXTERNAL_AS_LIST .  19) (DOT . (identifier_opt . 0)) (AMPERSAND . 
(identifier_opt . 0)) (SEMICOLON . (identifier_opt . 0)) (QUOTE . 
(identifier_opt . 0)) (IDENTIFIER .  16) (PROJECT .  20))
-      ((default . error) (STRING_LITERAL .  72))
-      ((default . error) (AMPERSAND . (external_value . 1)) (SEMICOLON . 
(external_value . 1)) (RIGHT_PAREN . (external_value . 1)) (COMMA . 
(external_value . 1)))
-      ((default . error) (AMPERSAND . (external_value . 0)) (SEMICOLON . 
(external_value . 0)) (RIGHT_PAREN . (external_value . 0)) (COMMA . 
(external_value . 0)))
-      ((default . error) (RIGHT_PAREN .  98))
-      ((default . error) (STRING_LITERAL .  17) (EXTERNAL .  18) 
(EXTERNAL_AS_LIST .  19) (DOT . (identifier_opt . 0)) (AMPERSAND . 
(identifier_opt . 0)) (RIGHT_PAREN . ( 96 (identifier_opt . 0))) (COMMA . 
(identifier_opt . 0)) (QUOTE . (identifier_opt . 0)) (IDENTIFIER .  16) 
(PROJECT .  20))
-      ((default . error) (AMPERSAND .  94) (SEMICOLON .  95))
-      ((default . error) (SEMICOLON . (term . 0)) (AMPERSAND . ((term . 0)  
34)))
-      ((default . error) (SEMICOLON . (expression . 0)) (AMPERSAND . 
(expression . 0)))
-      ((default . error) (COLON_EQUALS .  93))
-      ((default . error) (END . (case_items . 0)) (WHEN . ((case_items . 0)  
90)))
-      ((default . error) (STRING_LITERAL .  89))
-      ((default . error) (LEFT_PAREN .  73) (STRING_LITERAL .  17) (EXTERNAL . 
 18) (EXTERNAL_AS_LIST .  19) (DOT . (identifier_opt . 0)) (AMPERSAND . 
(identifier_opt . 0)) (SEMICOLON . (identifier_opt . 0)) (QUOTE . 
(identifier_opt . 0)) (IDENTIFIER .  16) (PROJECT .  20))
-      ((default . error) (END . (simple_declarative_items . 0)) (IDENTIFIER . 
((simple_declarative_items . 0)  46)) (NULL . ((simple_declarative_items . 0)  
49)) (CASE . ((simple_declarative_items . 0)  47)) (FOR . 
((simple_declarative_items . 0)  48)))
-      ((default . error) (LEFT_PAREN .  85))
-      ((default . error) (SEMICOLON .  84))
+      ((default . error) (USE .  81) (LEFT_PAREN .  80))
+      ((default . error) (DOT .  38) (IS .  79))
+      ((default . error) (IDENTIFIER .  78))
+      ((default . error) (LEFT_PAREN .  20) (STRING_LITERAL .  17) (EXTERNAL . 
 18) (EXTERNAL_AS_LIST .  19) (DOT . (identifier_opt . 0)) (AMPERSAND . 
(identifier_opt . 0)) (SEMICOLON . (identifier_opt . 0)) (QUOTE . 
(identifier_opt . 0)) (IDENTIFIER .  16) (PROJECT .  21))
+      ((default . error) (STRING_LITERAL .  76))
+      ((default . error) (RIGHT_PAREN .  96))
+      ((default . error) (AMPERSAND .  39) (SEMICOLON .  95))
+      ((default . error) (COLON_EQUALS .  94))
+      ((default . error) (END . (case_items . 0)) (WHEN . ((case_items . 0)  
91)))
+      ((default . error) (STRING_LITERAL .  90))
+      ((default . error) (LEFT_PAREN .  20) (STRING_LITERAL .  17) (EXTERNAL . 
 18) (EXTERNAL_AS_LIST .  19) (DOT . (identifier_opt . 0)) (AMPERSAND . 
(identifier_opt . 0)) (SEMICOLON . (identifier_opt . 0)) (QUOTE . 
(identifier_opt . 0)) (IDENTIFIER .  16) (PROJECT .  21))
+      ((default . error) (END . (simple_declarative_items . 0)) (IDENTIFIER . 
((simple_declarative_items . 0)  52)) (NULL . ((simple_declarative_items . 0)  
55)) (CASE . ((simple_declarative_items . 0)  53)) (FOR . 
((simple_declarative_items . 0)  54)))
+      ((default . error) (LEFT_PAREN .  43))
+      ((default . error) (SEMICOLON .  85))
       ((default . error) ($EOI . (simple_project_declaration . 0)))
-      ((default . error) (STRING_LITERAL .  17) (EXTERNAL .  18) 
(EXTERNAL_AS_LIST .  19) (DOT . (identifier_opt . 0)) (AMPERSAND . 
(identifier_opt . 0)) (RIGHT_PAREN . (identifier_opt . 0)) (COMMA . 
(identifier_opt . 0)) (QUOTE . (identifier_opt . 0)) (IDENTIFIER .  16) 
(PROJECT .  20))
+      ((default . error) (SEMICOLON .  108))
       ((default . error) (END . (simple_declarative_items . 1)) (IDENTIFIER . 
(simple_declarative_items . 1)) (CASE . (simple_declarative_items . 1)) (FOR . 
(simple_declarative_items . 1)) (NULL . (simple_declarative_items . 1)))
-      ((default . error) (END .  110) (IDENTIFIER .  46) (NULL .  49) (CASE .  
47) (FOR .  48))
-      ((default . error) (AMPERSAND .  94) (SEMICOLON .  109))
-      ((default . error) (RIGHT_PAREN .  108))
-      ((default . error) (VERTICAL_BAR . (discrete_choice . 0)) (EQUAL_GREATER 
. (discrete_choice . 0)) (STRING_LITERAL .  104) (OTHERS .  105))
+      ((default . error) (END .  106) (IDENTIFIER .  52) (NULL .  55) (CASE .  
53) (FOR .  54))
+      ((default . error) (AMPERSAND .  39) (SEMICOLON .  105))
+      ((default . error) (RIGHT_PAREN .  104))
+      ((default . error) (VERTICAL_BAR . (discrete_choice . 0)) (EQUAL_GREATER 
. (discrete_choice . 0)) (STRING_LITERAL .  100) (OTHERS .  101))
       ((default . error) (END . (case_items . 1)) (WHEN . (case_items . 1)))
-      ((default . error) (END .  102) (WHEN .  90))
-      ((default . error) (LEFT_PAREN .  73) (STRING_LITERAL .  17) (EXTERNAL . 
 18) (EXTERNAL_AS_LIST .  19) (DOT . (identifier_opt . 0)) (AMPERSAND . 
(identifier_opt . 0)) (SEMICOLON . (identifier_opt . 0)) (QUOTE . 
(identifier_opt . 0)) (IDENTIFIER .  16) (PROJECT .  20))
-      ((default . error) (LEFT_PAREN .  73) (STRING_LITERAL .  17) (EXTERNAL . 
 18) (EXTERNAL_AS_LIST .  19) (DOT . (identifier_opt . 0)) (SEMICOLON . 
(identifier_opt . 0)) (AMPERSAND . (identifier_opt . 0)) (QUOTE . 
(identifier_opt . 0)) (IDENTIFIER .  16) (PROJECT .  20))
+      ((default . error) (END .  98) (WHEN .  91))
+      ((default . error) (LEFT_PAREN .  20) (STRING_LITERAL .  17) (EXTERNAL . 
 18) (EXTERNAL_AS_LIST .  19) (DOT . (identifier_opt . 0)) (AMPERSAND . 
(identifier_opt . 0)) (SEMICOLON . (identifier_opt . 0)) (QUOTE . 
(identifier_opt . 0)) (IDENTIFIER .  16) (PROJECT .  21))
       ((default . error) (WHEN . (simple_declarative_item . 0)) (TYPE . 
(simple_declarative_item . 0)) (PACKAGE . (simple_declarative_item . 0)) (NULL 
. (simple_declarative_item . 0)) (FOR . (simple_declarative_item . 0)) (CASE . 
(simple_declarative_item . 0)) (IDENTIFIER . (simple_declarative_item . 0)) 
(END . (simple_declarative_item . 0)))
-      ((default . error) (SEMICOLON . (term . 1)) (AMPERSAND . (term . 1)))
-      ((default . error) (COMMA .  32) (RIGHT_PAREN .  99))
       ((default . error) (AMPERSAND . (attribute_reference . 1)) (SEMICOLON . 
(attribute_reference . 1)) (RIGHT_PAREN . (attribute_reference . 1)) (COMMA . 
(attribute_reference . 1)))
-      ((default . error) (AMPERSAND . (term . 2)) (SEMICOLON . (term . 2)))
-      ((default . error) (SEMICOLON . (expression . 1)) (AMPERSAND . 
(expression . 1)))
-      ((default . error) (AMPERSAND .  94) (SEMICOLON .  119))
-      ((default . error) (CASE .  118))
+      ((default . error) (AMPERSAND .  39) (SEMICOLON .  114))
+      ((default . error) (CASE .  113))
       ((default . error) (WHEN . (case_items . 2)) (END . (case_items . 2)))
       ((default . error) (VERTICAL_BAR . (discrete_choice . 1)) (EQUAL_GREATER 
. (discrete_choice . 1)))
       ((default . error) (VERTICAL_BAR . (discrete_choice . 2)) (EQUAL_GREATER 
. (discrete_choice . 2)))
       ((default . error) (EQUAL_GREATER . (discrete_choice_list . 0)) 
(VERTICAL_BAR . (discrete_choice_list . 0)))
-      ((default . error) (VERTICAL_BAR .  117) (EQUAL_GREATER .  116))
-      ((default . error) (USE .  115))
+      ((default . error) (VERTICAL_BAR .  112) (EQUAL_GREATER .  111))
+      ((default . error) (USE .  110))
       ((default . error) (WHEN . (attribute_declaration . 0)) (END . 
(attribute_declaration . 0)) (TYPE . (attribute_declaration . 0)) (PACKAGE . 
(attribute_declaration . 0)) (NULL . (attribute_declaration . 0)) (FOR . 
(attribute_declaration . 0)) (CASE . (attribute_declaration . 0)) (IDENTIFIER . 
(attribute_declaration . 0)))
       ((default . error) (SEMICOLON . (identifier_opt . 0)) (IDENTIFIER .  16))
       ((default . error) (NULL . (simple_declarative_items . 2)) (FOR . 
(simple_declarative_items . 2)) (CASE . (simple_declarative_items . 2)) 
(IDENTIFIER . (simple_declarative_items . 2)) (END . (simple_declarative_items 
. 2)))
-      ((default . error) (COMMA .  32) (RIGHT_PAREN .  113))
-      ((default . error) (SEMICOLON .  125))
-      ((default . error) (SEMICOLON .  124))
-      ((default . error) (LEFT_PAREN .  73) (STRING_LITERAL .  17) (EXTERNAL . 
 18) (EXTERNAL_AS_LIST .  19) (DOT . (identifier_opt . 0)) (AMPERSAND . 
(identifier_opt . 0)) (SEMICOLON . (identifier_opt . 0)) (QUOTE . 
(identifier_opt . 0)) (IDENTIFIER .  16) (PROJECT .  20))
-      ((default . error) (END . (declarative_items . 0)) (WHEN . 
(declarative_items . 0)) (TYPE . ((declarative_items . 0)  51)) (IDENTIFIER . 
((declarative_items . 0)  46)) (NULL . ((declarative_items . 0)  49)) (CASE . 
((declarative_items . 0)  47)) (FOR . ((declarative_items . 0)  48)) (PACKAGE . 
((declarative_items . 0)  50)))
-      ((default . error) (EQUAL_GREATER . (discrete_choice . 0)) (VERTICAL_BAR 
. (discrete_choice . 0)) (STRING_LITERAL .  104) (OTHERS .  105))
-      ((default . error) (SEMICOLON .  120))
+      ((default . error) (WHEN . (typed_string_declaration . 0)) (END . 
(typed_string_declaration . 0)) (IDENTIFIER . (typed_string_declaration . 0)) 
(CASE . (typed_string_declaration . 0)) (FOR . (typed_string_declaration . 0)) 
(NULL . (typed_string_declaration . 0)) (PACKAGE . (typed_string_declaration . 
0)) (TYPE . (typed_string_declaration . 0)))
+      ((default . error) (SEMICOLON .  119))
+      ((default . error) (LEFT_PAREN .  20) (STRING_LITERAL .  17) (EXTERNAL . 
 18) (EXTERNAL_AS_LIST .  19) (DOT . (identifier_opt . 0)) (AMPERSAND . 
(identifier_opt . 0)) (SEMICOLON . (identifier_opt . 0)) (QUOTE . 
(identifier_opt . 0)) (IDENTIFIER .  16) (PROJECT .  21))
+      ((default . error) (END . (declarative_items . 0)) (WHEN . 
(declarative_items . 0)) (TYPE . ((declarative_items . 0)  57)) (IDENTIFIER . 
((declarative_items . 0)  52)) (NULL . ((declarative_items . 0)  55)) (CASE . 
((declarative_items . 0)  53)) (FOR . ((declarative_items . 0)  54)) (PACKAGE . 
((declarative_items . 0)  56)))
+      ((default . error) (EQUAL_GREATER . (discrete_choice . 0)) (VERTICAL_BAR 
. (discrete_choice . 0)) (STRING_LITERAL .  100) (OTHERS .  101))
+      ((default . error) (SEMICOLON .  115))
       ((default . error) (WHEN . (simple_declarative_item . 1)) (TYPE . 
(simple_declarative_item . 1)) (PACKAGE . (simple_declarative_item . 1)) (NULL 
. (simple_declarative_item . 1)) (FOR . (simple_declarative_item . 1)) (CASE . 
(simple_declarative_item . 1)) (IDENTIFIER . (simple_declarative_item . 1)) 
(END . (simple_declarative_item . 1)))
       ((default . error) (WHEN . (case_statement . 0)) (END . (case_statement 
. 0)) (TYPE . (case_statement . 0)) (PACKAGE . (case_statement . 0)) (NULL . 
(case_statement . 0)) (FOR . (case_statement . 0)) (CASE . (case_statement . 
0)) (IDENTIFIER . (case_statement . 0)))
       ((default . error) (EQUAL_GREATER . (discrete_choice_list . 1)) 
(VERTICAL_BAR . (discrete_choice_list . 1)))
-      ((default . error) (END . (case_item . 0)) (WHEN . (case_item . 0)) 
(TYPE .  51) (IDENTIFIER .  46) (NULL .  49) (CASE .  47) (FOR .  48) (PACKAGE 
.  50))
-      ((default . error) (AMPERSAND .  94) (SEMICOLON .  126))
+      ((default . error) (END . (case_item . 0)) (WHEN . (case_item . 0)) 
(TYPE .  57) (IDENTIFIER .  52) (NULL .  55) (CASE .  53) (FOR .  54) (PACKAGE 
.  56))
+      ((default . error) (AMPERSAND .  39) (SEMICOLON .  120))
       ((default . error) (WHEN . (package_spec . 0)) (END . (package_spec . 
0)) (TYPE . (package_spec . 0)) (PACKAGE . (package_spec . 0)) (NULL . 
(package_spec . 0)) (FOR . (package_spec . 0)) (CASE . (package_spec . 0)) 
(IDENTIFIER . (package_spec . 0)))
-      ((default . error) (WHEN . (typed_string_declaration . 0)) (END . 
(typed_string_declaration . 0)) (IDENTIFIER . (typed_string_declaration . 0)) 
(CASE . (typed_string_declaration . 0)) (FOR . (typed_string_declaration . 0)) 
(NULL . (typed_string_declaration . 0)) (PACKAGE . (typed_string_declaration . 
0)) (TYPE . (typed_string_declaration . 0)))
       ((default . error) (WHEN . (attribute_declaration . 1)) (IDENTIFIER . 
(attribute_declaration . 1)) (CASE . (attribute_declaration . 1)) (FOR . 
(attribute_declaration . 1)) (NULL . (attribute_declaration . 1)) (PACKAGE . 
(attribute_declaration . 1)) (TYPE . (attribute_declaration . 1)) (END . 
(attribute_declaration . 1)))]
      [((compilation_unit . 8)(context_clause . 9)(context_clause_opt . 
10)(simple_project_declaration . 11)(with_clause . 12))
       nil
       nil
       nil
       nil
-      ((identifier_opt . 29))
+      ((identifier_opt . 33))
       nil
-      ((attribute_prefix . 21)(attribute_reference . 22)(external_value . 
23)(identifier_opt . 24)(name . 25)(string_expression . 26)(string_primary . 
27)(string_list . 28))
+      ((aggregate . 22)(attribute_prefix . 23)(attribute_reference . 
24)(expression . 25)(external_value . 26)(identifier_opt . 27)(name . 
28)(string_expression . 29)(string_primary . 30)(string_list . 31)(term . 32))
       nil
       ((with_clause . 14))
       ((project_qualifier_opt . 13))
       nil
       nil
-      ((project_declaration_opt . 39)(simple_project_declaration . 11))
-      nil
-      nil
-      nil
-      nil
-      nil
-      nil
+      ((project_declaration_opt . 46)(simple_project_declaration . 11))
       nil
       nil
       nil
       nil
+      ((aggregate . 45))
+      ((aggregate . 44))
+      ((aggregate . 22)(attribute_prefix . 23)(attribute_reference . 
24)(expression . 25)(external_value . 26)(identifier_opt . 27)(name . 
28)(string_expression . 29)(string_primary . 30)(string_list . 42)(term . 32))
       nil
       nil
       nil
@@ -362,76 +357,73 @@
       nil
       nil
       nil
-      ((attribute_declaration . 52)(case_statement . 53)(declarative_item . 
54)(declarative_items . 55)(package_declaration . 56)(package_spec . 
57)(simple_declarative_item . 58)(typed_string_declaration . 59))
-      ((attribute_prefix . 21)(attribute_reference . 22)(external_value . 
23)(identifier_opt . 24)(name . 25)(string_expression . 45)(string_primary . 
27))
       nil
-      ((attribute_prefix . 21)(attribute_reference . 22)(external_value . 
23)(identifier_opt . 24)(name . 25)(string_primary . 44))
       nil
       nil
-      ((attribute_prefix . 21)(attribute_reference . 22)(external_value . 
23)(identifier_opt . 24)(name . 25)(string_expression . 26)(string_primary . 
27)(string_list . 41))
-      ((attribute_prefix . 21)(attribute_reference . 22)(external_value . 
23)(identifier_opt . 24)(name . 25)(string_expression . 26)(string_primary . 
27)(string_list . 40))
       nil
       nil
       nil
       nil
+      ((attribute_declaration . 58)(case_statement . 59)(declarative_item . 
60)(declarative_items . 61)(package_declaration . 62)(package_spec . 
63)(simple_declarative_item . 64)(typed_string_declaration . 65))
+      ((aggregate . 22)(attribute_prefix . 23)(attribute_reference . 
24)(expression . 51)(external_value . 26)(identifier_opt . 27)(name . 
28)(string_expression . 29)(string_primary . 30)(term . 32))
       nil
       nil
+      ((aggregate . 22)(attribute_prefix . 23)(attribute_reference . 
24)(external_value . 26)(identifier_opt . 27)(name . 28)(string_expression . 
29)(string_primary . 30)(term . 49))
       nil
       nil
-      ((identifier_opt . 24)(name . 66))
       nil
+      ((aggregate . 22)(attribute_prefix . 23)(attribute_reference . 
24)(expression . 25)(external_value . 26)(identifier_opt . 27)(name . 
28)(string_expression . 29)(string_primary . 30)(string_list . 42)(term . 32))
       nil
-      ((identifier_opt . 63))
       nil
       nil
       nil
       nil
-      ((attribute_declaration . 52)(case_statement . 53)(declarative_item . 
61)(package_declaration . 56)(package_spec . 57)(simple_declarative_item . 
58)(typed_string_declaration . 59))
       nil
       nil
       nil
       nil
-      ((identifier_opt . 83))
+      ((identifier_opt . 27)(name . 72))
       nil
       nil
+      ((identifier_opt . 69))
       nil
       nil
       nil
       nil
+      ((attribute_declaration . 58)(case_statement . 59)(declarative_item . 
67)(package_declaration . 62)(package_spec . 63)(simple_declarative_item . 
64)(typed_string_declaration . 65))
       nil
-      ((attribute_prefix . 21)(attribute_reference . 22)(expression . 
74)(external_value . 23)(identifier_opt . 24)(name . 25)(string_expression . 
75)(string_primary . 27)(term . 76))
       nil
       nil
       nil
+      ((identifier_opt . 84))
       nil
-      ((attribute_prefix . 21)(attribute_reference . 22)(external_value . 
23)(identifier_opt . 24)(name . 25)(string_expression . 26)(string_primary . 
27)(string_list . 97))
       nil
       nil
       nil
       nil
-      ((case_item . 91)(case_items . 92))
       nil
-      ((attribute_prefix . 21)(attribute_reference . 22)(expression . 
88)(external_value . 23)(identifier_opt . 24)(name . 25)(string_expression . 
75)(string_primary . 27)(term . 76))
-      ((attribute_declaration . 52)(case_statement . 
53)(simple_declarative_item . 86)(simple_declarative_items . 87))
       nil
+      ((aggregate . 22)(attribute_prefix . 23)(attribute_reference . 
24)(expression . 77)(external_value . 26)(identifier_opt . 27)(name . 
28)(string_expression . 29)(string_primary . 30)(term . 32))
       nil
       nil
-      ((attribute_prefix . 21)(attribute_reference . 22)(external_value . 
23)(identifier_opt . 24)(name . 25)(string_expression . 26)(string_primary . 
27)(string_list . 112))
       nil
-      ((attribute_declaration . 52)(case_statement . 
53)(simple_declarative_item . 111))
       nil
+      ((case_item . 92)(case_items . 93))
       nil
-      ((discrete_choice . 106)(discrete_choice_list . 107))
+      ((aggregate . 22)(attribute_prefix . 23)(attribute_reference . 
24)(expression . 89)(external_value . 26)(identifier_opt . 27)(name . 
28)(string_expression . 29)(string_primary . 30)(term . 32))
+      ((attribute_declaration . 58)(case_statement . 
59)(simple_declarative_item . 87)(simple_declarative_items . 88))
+      ((aggregate . 86))
       nil
-      ((case_item . 103))
-      ((attribute_prefix . 21)(attribute_reference . 22)(expression . 
101)(external_value . 23)(identifier_opt . 24)(name . 25)(string_expression . 
75)(string_primary . 27)(term . 76))
-      ((attribute_prefix . 21)(attribute_reference . 22)(external_value . 
23)(identifier_opt . 24)(name . 25)(string_expression . 75)(string_primary . 
27)(term . 100))
       nil
       nil
       nil
+      ((attribute_declaration . 58)(case_statement . 
59)(simple_declarative_item . 107))
       nil
       nil
+      ((discrete_choice . 102)(discrete_choice_list . 103))
       nil
+      ((case_item . 99))
+      ((aggregate . 22)(attribute_prefix . 23)(attribute_reference . 
24)(expression . 97)(external_value . 26)(identifier_opt . 27)(name . 
28)(string_expression . 29)(string_primary . 30)(term . 32))
       nil
       nil
       nil
@@ -441,20 +433,20 @@
       nil
       nil
       nil
-      ((identifier_opt . 114))
       nil
       nil
+      ((identifier_opt . 109))
       nil
       nil
-      ((attribute_prefix . 21)(attribute_reference . 22)(expression . 
123)(external_value . 23)(identifier_opt . 24)(name . 25)(string_expression . 
75)(string_primary . 27)(term . 76))
-      ((attribute_declaration . 52)(case_statement . 53)(declarative_item . 
54)(declarative_items . 122)(package_declaration . 56)(package_spec . 
57)(simple_declarative_item . 58)(typed_string_declaration . 59))
-      ((discrete_choice . 121))
       nil
+      ((aggregate . 22)(attribute_prefix . 23)(attribute_reference . 
24)(expression . 118)(external_value . 26)(identifier_opt . 27)(name . 
28)(string_expression . 29)(string_primary . 30)(term . 32))
+      ((attribute_declaration . 58)(case_statement . 59)(declarative_item . 
60)(declarative_items . 117)(package_declaration . 62)(package_spec . 
63)(simple_declarative_item . 64)(typed_string_declaration . 65))
+      ((discrete_choice . 116))
       nil
       nil
       nil
-      ((attribute_declaration . 52)(case_statement . 53)(declarative_item . 
61)(package_declaration . 56)(package_spec . 57)(simple_declarative_item . 
58)(typed_string_declaration . 59))
       nil
+      ((attribute_declaration . 58)(case_statement . 59)(declarative_item . 
67)(package_declaration . 62)(package_spec . 63)(simple_declarative_item . 
64)(typed_string_declaration . 65))
       nil
       nil
       nil]))
diff --git a/packages/ada-mode/gpr-mode.el b/packages/ada-mode/gpr-mode.el
index cd9ddd6..1bf11c8 100644
--- a/packages/ada-mode/gpr-mode.el
+++ b/packages/ada-mode/gpr-mode.el
@@ -36,6 +36,7 @@
 
 ;; we reuse several ada-mode functions
 (require 'ada-mode)
+(require 'cl-lib)
 
 (defvar gpr-mode-map
   (let ((map (make-sparse-keymap)))
@@ -77,8 +78,9 @@
     ["------"        nil nil]
     ["Find and select project ..." ada-build-prompt-select-prj-file t]
     ["Select project ..."          ada-prj-select                   t]
-    ["Set as current project"      gpr-set-as-project               t]
+    ["Parse and select current file" gpr-set-as-project             t]
     ["Show current project"        ada-prj-show                     t]
+    ["Show project search path"    ada-prj-show-path                t]
     ["Next compilation error"      next-error                       t]
     ["Show secondary error"        ada-show-secondary-error         t]
     ["Show last parse error"       gpr-show-parse-error             t]
@@ -208,6 +210,14 @@ of the package or project point is in or just after, or 
nil.")
 (defun gpr-set-as-project (&optional file)
   "Set FILE (default current buffer file) as Emacs project file."
   (interactive)
+  (save-some-buffers t)
+  ;; Kill sessions to catch changed env vars
+  ;; FIXME: need dispatching kill single session
+  (cl-ecase ada-xref-tool
+    (gnat_xref nil)
+    (gnat_inspect (gnat-inspect-kill-all-sessions))
+    (gpr_query (gpr-query-kill-all-sessions))
+    )
   (ada-parse-prj-file (or file (buffer-file-name)))
   (ada-select-prj-file (or file (buffer-file-name))))
 
@@ -237,7 +247,7 @@ of the package or project point is in or just after, or 
nil.")
         ((?\_ . "w"))))
 
   (gpr-set-ff-special-constructs)
-  (setq ff-search-directories 'ada-project-search-path)
+  (setq ff-search-directories 'compilation-search-path);; includes project 
search path
 
   (set (make-local-variable 'add-log-current-defun-function)
        'gpr-add-log-current-function)
diff --git a/packages/ada-mode/gpr-mode.info b/packages/ada-mode/gpr-mode.info
index 8313779..a001029 100644
--- a/packages/ada-mode/gpr-mode.info
+++ b/packages/ada-mode/gpr-mode.info
@@ -1,7 +1,7 @@
-This is ../gpr-mode.info, produced by makeinfo version 4.13 from
-../gpr-mode.texi.
+This is gpr-mode.info, produced by makeinfo version 5.2 from
+gpr-mode.texi.
 
-Copyright (C) 2013  Free Software Foundation, Inc.
+Copyright (C) 2013 Free Software Foundation, Inc.
 
      Permission is granted to copy, distribute and/or modify this
      document under the terms of the GNU Free Documentation License,
@@ -14,7 +14,6 @@ Copyright (C) 2013  Free Software Foundation, Inc.
      (a) The FSF's Back-Cover Text is: "You have the freedom to copy and
      modify this GNU manual.  Buying copies from the FSF supports it in
      developing GNU and promoting software freedom."
-
 INFO-DIR-SECTION Emacs editing modes
 START-INFO-DIR-ENTRY
 * gpr mode: (gpr-mode).         Emacs mode for editing and navigating gpr 
files (gnat project files).
@@ -23,7 +22,7 @@ END-INFO-DIR-ENTRY
 
 File: gpr-mode.info,  Node: Top,  Next: Overview,  Prev: (dir),  Up: (dir)
 
-   Copyright (C) 2013  Free Software Foundation, Inc.
+Copyright (C) 2013 Free Software Foundation, Inc.
 
      Permission is granted to copy, distribute and/or modify this
      document under the terms of the GNU Free Documentation License,
@@ -55,8 +54,8 @@ File: gpr-mode.info,  Node: Overview,  Next: Installation,  
Prev: Top,  Up: Top
 1 Overview
 **********
 
-gpr files are the project files used by the GNAT compiler and
-associated tools. They describe search paths, compiler options, etc.
+gpr files are the project files used by the GNAT compiler and associated
+tools.  They describe search paths, compiler options, etc.
 
    *Note GNAT Project Manager: (gnat_ugn)GNAT Project Manager, for
 general information on gpr files.
@@ -64,7 +63,7 @@ general information on gpr files.
    The Emacs mode for gpr files helps the user in reading existing code
 and facilitates writing new code.
 
-   When you open a file with a file extension of `.gpr', Emacs will
+   When you open a file with a file extension of '.gpr', Emacs will
 automatically load and activate gpr mode.
 
 
@@ -74,20 +73,20 @@ File: gpr-mode.info,  Node: Installation,  Next: 
Customization,  Prev: Overview,
 **************
 
 gpr mode is distributed in the Gnu ELPA package archive, bundled with
-Ada mode; it can be installed via `M-x list-packages' (*note Packages:
-(emacs)Packages.).
+Ada mode; it can be installed via 'M-x list-packages' (*note
+(emacs)Packages::).
 
    gpr mode is also available as a separate distribution bundled with
 Ada mode, from the Emacs Ada mode website
-`http://stephe-leake.org/emacs/ada-mode/emacs-ada-mode.html'. The
+<http://stephe-leake.org/emacs/ada-mode/emacs-ada-mode.html>.  The
 separate distribution may be more recent.
 
-   For installing the separate distribution, see the `README' file in
+   For installing the separate distribution, see the 'README' file in
 the distribution.
 
    gpr mode does not have a separate version; it uses the Ada mode
-version number. To see what version of Ada mode you have installed, do
-`M-x ada-mode-version'.
+version number.  To see what version of Ada mode you have installed, do
+'M-x ada-mode-version'.
 
 
 File: gpr-mode.info,  Node: Customization,  Next: Moving Through Gpr Code,  
Prev: Installation,  Up: Top
@@ -96,36 +95,33 @@ File: gpr-mode.info,  Node: Customization,  Next: Moving 
Through Gpr Code,  Prev
 ***************
 
 gpr mode uses the Ada mode indentation variables; they can be set via
-the menu `Ada | Customize' from an Ada mode buffer.  Click on the
-`Help' button there for help on using customize.
+the menu 'Ada | Customize' from an Ada mode buffer.  Click on the 'Help'
+button there for help on using customize.
 
    To modify a specific variable, you can directly call the function
-`customize-variable'; just type `M-x customize-variable <RET>
+'customize-variable'; just type 'M-x customize-variable <RET>
 VARIABLE-NAME <RET>').
 
    Alternately, you can specify variable settings in the Emacs
-configuration file, `~/.emacs'. This file is coded in Emacs lisp, and
+configuration file, '~/.emacs'.  This file is coded in Emacs lisp, and
 the syntax to set a variable is the following:
      (setq variable-name value)
 
    Some general Emacs settings that are useful for gpr files:
-`delete-trailing-whitespace'
+'delete-trailing-whitespace'
      Deletes space, tab at end of line and blank lines at end of buffer.
-
-`untabify'
+'untabify'
      Deletes tab characters that have crept into the file.
-
-`indent-tabs-mode'
+'indent-tabs-mode'
      Don't insert tab characters when indenting.
-
-`hippie-expand'
-     Bind `hippie-expand' to a key; it expands the word before point,
+'hippie-expand'
+     Bind 'hippie-expand' to a key; it expands the word before point,
      using words from current buffer, other buffers, file names, etc;
-     see `hippie-expand-try-functions-list'. You can also add
-     `skeleton-hippie-try' to that list (*note Statement skeletons::).
+     see 'hippie-expand-try-functions-list'.  You can also add
+     'skeleton-hippie-try' to that list (*note Statement skeletons::).
 
-   The above can all be set by the following code in your `~/.emacs'.
-Note that some are functions are added to `before-save-hook'; they run
+   The above can all be set by the following code in your '~/.emacs'.
+Note that some are functions are added to 'before-save-hook'; they run
 just before a buffer is written to disk.
      (setq-default indent-tabs-mode nil)
      (require 'gpr-mode)
@@ -144,39 +140,38 @@ File: gpr-mode.info,  Node: Moving Through Gpr Code,  
Next: Identifier completio
 4 Moving Through Gpr Code
 *************************
 
-These commands navigate through gpr code. All these functions are
+These commands navigate through gpr code.  All these functions are
 available through the gpr menu and keybindings.
 
-`C-c C-o'
-     If point is on a `with' clause, position point on the
-     corresponding package declaration.
+'C-c C-o'
+     If point is on a 'with' clause, position point on the corresponding
+     package declaration.
 
-`C-u SPACE'
+'C-u SPACE'
      Jump back to the previous location.
 
-
 
 File: gpr-mode.info,  Node: Identifier completion,  Next: Indentation,  Prev: 
Moving Through Gpr Code,  Up: Top
 
 5 Identifier completion
 ***********************
 
-Emacs provides a general way of completing identifiers: `M-/' (bound to
-`dabbrev-expand'). This is an easy way to type faster: you just have to
+Emacs provides a general way of completing identifiers: 'M-/' (bound to
+'dabbrev-expand').  This is an easy way to type faster: you just have to
 type the first few letters of an identifier, and then loop through all
 the possible completions.
 
-   `M-/' works by parsing all open gpr files for possible completions.
+   'M-/' works by parsing all open gpr files for possible completions.
 
-   For instance, if the words `my_identifier' and `my_subprogram' are
-the only words starting with `my' in any of the open gpr files, then
-you will have this scenario:
+   For instance, if the words 'my_identifier' and 'my_subprogram' are
+the only words starting with 'my' in any of the open gpr files, then you
+will have this scenario:
 
      You type:  myM-/
-     Emacs inserts:  `my_identifier'
-     If you press M-/ once again, Emacs replaces `my_identifier' with
-     `my_subprogram'.
-     Pressing M-/ once more will bring you back to `my_identifier'.
+     Emacs inserts:  'my_identifier'
+     If you press M-/ once again, Emacs replaces 'my_identifier' with
+     'my_subprogram'.
+     Pressing M-/ once more will bring you back to 'my_identifier'.
 
    This is a very fast way to do completion, and the casing of words
 will also be respected.
@@ -187,42 +182,41 @@ File: gpr-mode.info,  Node: Indentation,  Next: Statement 
skeletons,  Prev: Iden
 6 Indentation
 *************
 
-gpr mode comes with a full set of rules for automatic indentation. You
+gpr mode comes with a full set of rules for automatic indentation.  You
 can also configure the indentation, via the following variables:
 
-`ada-indent'                  (default value: 3)
+'ada-indent' (default value: 3)
      Number of columns for default indentation.
 
-`ada-indent-broken'           (default value: 2)
+'ada-indent-broken' (default value: 2)
      Number of columns to indent the continuation of a broken line.
 
-`ada-indent-when'             (default value: 3)
-     Indentation for `when' relative to `exception', `case', or `or' in
-     `select'.
-
-`ada-indent-with'             (default value: ada-indent-broken)
-     Indentation for the lines in a `with' context clause.
+'ada-indent-when' (default value: 3)
+     Indentation for 'when' relative to 'exception', 'case', or 'or' in
+     'select'.
 
+'ada-indent-with' (default value: ada-indent-broken)
+     Indentation for the lines in a 'with' context clause.
 
    The following keys indent portions of the text:
-`RET'
+
+'RET'
      Insert and indent a new line.
 
-`TAB'
+'TAB'
      Indent the current line, or the current region.
 
-`C-c TAB'
+'C-c TAB'
      Indent the current declaration.
 
-
    The indentation algorithm relies on a grammar parser to identify the
-syntactic role for keywords and other words in the code. If the code is
+syntactic role for keywords and other words in the code.  If the code is
 accepted by the parser, the indentation is done according to the rules
 in the indentation engine.
 
    If the code is not accepted (because it is partially complete during
 editing), the indentation engine falls back to the trivial algorithm of
-indenting each new line the same as the previous line. Once enough new
+indenting each new line the same as the previous line.  Once enough new
 text has been entered to make the code acceptable to the parser, the
 declaration is properly indented.
 
@@ -232,13 +226,13 @@ declaration is properly indented.
           ("../../1553/test",
            "../../system/test");
 
-   when you type `RET (', `(' is indented to the same column as `for',
-because the parser does not find `);'. Then when you type the final `;'
-followed by <TAB>, all three lines are indented, putting `(' where it
+   when you type 'RET (', '(' is indented to the same column as 'for',
+because the parser does not find ');'.  Then when you type the final ';'
+followed by <TAB>, all three lines are indented, putting '(' where it
 belongs.
 
    To be more user friendly, the parser accepts a superset of the gpr
-grammer. For example, the parser accepts this code for a `case'
+grammer.  For example, the parser accepts this code for a 'case'
 statement:
 
      case is
@@ -251,7 +245,7 @@ omitted.
 Statement skeletons::.
 
    In rare cases, the parser gets confused; it can be reset by invoking
-menu <gpr | Misc | Reset parser>. Please report such cases as a bug.
+menu <gpr | Misc | Reset parser>.  Please report such cases as a bug.
 
 
 File: gpr-mode.info,  Node: Statement skeletons,  Next: GNU Free Documentation 
License,  Prev: Indentation,  Up: Top
@@ -259,8 +253,8 @@ File: gpr-mode.info,  Node: Statement skeletons,  Next: GNU 
Free Documentation L
 7 Statement skeletons
 *********************
 
-`C-c C-e' expands the previous one or two words into a statment
-skeleton. For example, `c a s e C-c C-e' expands to:
+'C-c C-e' expands the previous one or two words into a statment
+skeleton.  For example, 'c a s e C-c C-e' expands to:
 
      case  is
      when =>
@@ -269,8 +263,8 @@ skeleton. For example, `c a s e C-c C-e' expands to:
    All skeleton expansions are accepted by the indentation parser, so
 this is a convenient way to insert statements with correct indentation.
 
-   For named packages, the name is taken from the word before point,
-and the package keyword from the word before that:
+   For named packages, the name is taken from the word before point, and
+the package keyword from the word before that:
 
      package A_Package
 
@@ -291,7 +285,7 @@ Appendix A GNU Free Documentation License
                      Version 1.3, 3 November 2008
 
      Copyright (C) 2000, 2001, 2002, 2007, 2008, 2009 Free Software 
Foundation, Inc.
-     `http://fsf.org/'
+     <http://fsf.org/>
 
      Everyone is permitted to copy and distribute verbatim copies
      of this license document, but changing it is not allowed.
@@ -316,21 +310,21 @@ Appendix A GNU Free Documentation License
      free program should come with manuals providing the same freedoms
      that the software does.  But this License is not limited to
      software manuals; it can be used for any textual work, regardless
-     of subject matter or whether it is published as a printed book.
-     We recommend this License principally for works whose purpose is
+     of subject matter or whether it is published as a printed book.  We
+     recommend this License principally for works whose purpose is
      instruction or reference.
 
   1. APPLICABILITY AND DEFINITIONS
 
      This License applies to any manual or other work, in any medium,
-     that contains a notice placed by the copyright holder saying it
-     can be distributed under the terms of this License.  Such a notice
+     that contains a notice placed by the copyright holder saying it can
+     be distributed under the terms of this License.  Such a notice
      grants a world-wide, royalty-free license, unlimited in duration,
      to use that work under the conditions stated herein.  The
      "Document", below, refers to any such manual or work.  Any member
-     of the public is a licensee, and is addressed as "you".  You
-     accept the license if you copy, modify or distribute the work in a
-     way requiring permission under copyright law.
+     of the public is a licensee, and is addressed as "you".  You accept
+     the license if you copy, modify or distribute the work in a way
+     requiring permission under copyright law.
 
      A "Modified Version" of the Document means any work containing the
      Document or a portion of it, either copied verbatim, or with
@@ -348,12 +342,12 @@ Appendix A GNU Free Documentation License
      regarding them.
 
      The "Invariant Sections" are certain Secondary Sections whose
-     titles are designated, as being those of Invariant Sections, in
-     the notice that says that the Document is released under this
-     License.  If a section does not fit the above definition of
-     Secondary then it is not allowed to be designated as Invariant.
-     The Document may contain zero Invariant Sections.  If the Document
-     does not identify any Invariant Sections then there are none.
+     titles are designated, as being those of Invariant Sections, in the
+     notice that says that the Document is released under this License.
+     If a section does not fit the above definition of Secondary then it
+     is not allowed to be designated as Invariant.  The Document may
+     contain zero Invariant Sections.  If the Document does not identify
+     any Invariant Sections then there are none.
 
      The "Cover Texts" are certain short passages of text that are
      listed, as Front-Cover Texts or Back-Cover Texts, in the notice
@@ -364,27 +358,27 @@ Appendix A GNU Free Documentation License
      A "Transparent" copy of the Document means a machine-readable copy,
      represented in a format whose specification is available to the
      general public, that is suitable for revising the document
-     straightforwardly with generic text editors or (for images
-     composed of pixels) generic paint programs or (for drawings) some
-     widely available drawing editor, and that is suitable for input to
-     text formatters or for automatic translation to a variety of
-     formats suitable for input to text formatters.  A copy made in an
-     otherwise Transparent file format whose markup, or absence of
-     markup, has been arranged to thwart or discourage subsequent
-     modification by readers is not Transparent.  An image format is
-     not Transparent if used for any substantial amount of text.  A
-     copy that is not "Transparent" is called "Opaque".
+     straightforwardly with generic text editors or (for images composed
+     of pixels) generic paint programs or (for drawings) some widely
+     available drawing editor, and that is suitable for input to text
+     formatters or for automatic translation to a variety of formats
+     suitable for input to text formatters.  A copy made in an otherwise
+     Transparent file format whose markup, or absence of markup, has
+     been arranged to thwart or discourage subsequent modification by
+     readers is not Transparent.  An image format is not Transparent if
+     used for any substantial amount of text.  A copy that is not
+     "Transparent" is called "Opaque".
 
      Examples of suitable formats for Transparent copies include plain
      ASCII without markup, Texinfo input format, LaTeX input format,
-     SGML or XML using a publicly available DTD, and
-     standard-conforming simple HTML, PostScript or PDF designed for
-     human modification.  Examples of transparent image formats include
-     PNG, XCF and JPG.  Opaque formats include proprietary formats that
-     can be read and edited only by proprietary word processors, SGML or
-     XML for which the DTD and/or processing tools are not generally
-     available, and the machine-generated HTML, PostScript or PDF
-     produced by some word processors for output purposes only.
+     SGML or XML using a publicly available DTD, and standard-conforming
+     simple HTML, PostScript or PDF designed for human modification.
+     Examples of transparent image formats include PNG, XCF and JPG.
+     Opaque formats include proprietary formats that can be read and
+     edited only by proprietary word processors, SGML or XML for which
+     the DTD and/or processing tools are not generally available, and
+     the machine-generated HTML, PostScript or PDF produced by some word
+     processors for output purposes only.
 
      The "Title Page" means, for a printed book, the title page itself,
      plus such following pages as are needed to hold, legibly, the
@@ -422,8 +416,8 @@ Appendix A GNU Free Documentation License
      may not use technical measures to obstruct or control the reading
      or further copying of the copies you make or distribute.  However,
      you may accept compensation in exchange for copies.  If you
-     distribute a large enough number of copies you must also follow
-     the conditions in section 3.
+     distribute a large enough number of copies you must also follow the
+     conditions in section 3.
 
      You may also lend copies, under the same conditions stated above,
      and you may publicly display copies.
@@ -437,12 +431,11 @@ Appendix A GNU Free Documentation License
      these Cover Texts: Front-Cover Texts on the front cover, and
      Back-Cover Texts on the back cover.  Both covers must also clearly
      and legibly identify you as the publisher of these copies.  The
-     front cover must present the full title with all words of the
-     title equally prominent and visible.  You may add other material
-     on the covers in addition.  Copying with changes limited to the
-     covers, as long as they preserve the title of the Document and
-     satisfy these conditions, can be treated as verbatim copying in
-     other respects.
+     front cover must present the full title with all words of the title
+     equally prominent and visible.  You may add other material on the
+     covers in addition.  Copying with changes limited to the covers, as
+     long as they preserve the title of the Document and satisfy these
+     conditions, can be treated as verbatim copying in other respects.
 
      If the required texts for either cover are too voluminous to fit
      legibly, you should put the first ones listed (as many as fit
@@ -450,40 +443,39 @@ Appendix A GNU Free Documentation License
      adjacent pages.
 
      If you publish or distribute Opaque copies of the Document
-     numbering more than 100, you must either include a
-     machine-readable Transparent copy along with each Opaque copy, or
-     state in or with each Opaque copy a computer-network location from
-     which the general network-using public has access to download
-     using public-standard network protocols a complete Transparent
-     copy of the Document, free of added material.  If you use the
-     latter option, you must take reasonably prudent steps, when you
-     begin distribution of Opaque copies in quantity, to ensure that
-     this Transparent copy will remain thus accessible at the stated
-     location until at least one year after the last time you
-     distribute an Opaque copy (directly or through your agents or
-     retailers) of that edition to the public.
+     numbering more than 100, you must either include a machine-readable
+     Transparent copy along with each Opaque copy, or state in or with
+     each Opaque copy a computer-network location from which the general
+     network-using public has access to download using public-standard
+     network protocols a complete Transparent copy of the Document, free
+     of added material.  If you use the latter option, you must take
+     reasonably prudent steps, when you begin distribution of Opaque
+     copies in quantity, to ensure that this Transparent copy will
+     remain thus accessible at the stated location until at least one
+     year after the last time you distribute an Opaque copy (directly or
+     through your agents or retailers) of that edition to the public.
 
      It is requested, but not required, that you contact the authors of
-     the Document well before redistributing any large number of
-     copies, to give them a chance to provide you with an updated
-     version of the Document.
+     the Document well before redistributing any large number of copies,
+     to give them a chance to provide you with an updated version of the
+     Document.
 
   4. MODIFICATIONS
 
      You may copy and distribute a Modified Version of the Document
      under the conditions of sections 2 and 3 above, provided that you
-     release the Modified Version under precisely this License, with
-     the Modified Version filling the role of the Document, thus
-     licensing distribution and modification of the Modified Version to
-     whoever possesses a copy of it.  In addition, you must do these
-     things in the Modified Version:
+     release the Modified Version under precisely this License, with the
+     Modified Version filling the role of the Document, thus licensing
+     distribution and modification of the Modified Version to whoever
+     possesses a copy of it.  In addition, you must do these things in
+     the Modified Version:
 
        A. Use in the Title Page (and on the covers, if any) a title
-          distinct from that of the Document, and from those of
-          previous versions (which should, if there were any, be listed
-          in the History section of the Document).  You may use the
-          same title as a previous version if the original publisher of
-          that version gives permission.
+          distinct from that of the Document, and from those of previous
+          versions (which should, if there were any, be listed in the
+          History section of the Document).  You may use the same title
+          as a previous version if the original publisher of that
+          version gives permission.
 
        B. List on the Title Page, as authors, one or more persons or
           entities responsible for authorship of the modifications in
@@ -513,31 +505,30 @@ Appendix A GNU Free Documentation License
 
        I. Preserve the section Entitled "History", Preserve its Title,
           and add to it an item stating at least the title, year, new
-          authors, and publisher of the Modified Version as given on
-          the Title Page.  If there is no section Entitled "History" in
-          the Document, create one stating the title, year, authors,
-          and publisher of the Document as given on its Title Page,
-          then add an item describing the Modified Version as stated in
-          the previous sentence.
+          authors, and publisher of the Modified Version as given on the
+          Title Page.  If there is no section Entitled "History" in the
+          Document, create one stating the title, year, authors, and
+          publisher of the Document as given on its Title Page, then add
+          an item describing the Modified Version as stated in the
+          previous sentence.
 
        J. Preserve the network location, if any, given in the Document
           for public access to a Transparent copy of the Document, and
           likewise the network locations given in the Document for
-          previous versions it was based on.  These may be placed in
-          the "History" section.  You may omit a network location for a
-          work that was published at least four years before the
-          Document itself, or if the original publisher of the version
-          it refers to gives permission.
+          previous versions it was based on.  These may be placed in the
+          "History" section.  You may omit a network location for a work
+          that was published at least four years before the Document
+          itself, or if the original publisher of the version it refers
+          to gives permission.
 
        K. For any section Entitled "Acknowledgements" or "Dedications",
-          Preserve the Title of the section, and preserve in the
-          section all the substance and tone of each of the contributor
+          Preserve the Title of the section, and preserve in the section
+          all the substance and tone of each of the contributor
           acknowledgements and/or dedications given therein.
 
-       L. Preserve all the Invariant Sections of the Document,
-          unaltered in their text and in their titles.  Section numbers
-          or the equivalent are not considered part of the section
-          titles.
+       L. Preserve all the Invariant Sections of the Document, unaltered
+          in their text and in their titles.  Section numbers or the
+          equivalent are not considered part of the section titles.
 
        M. Delete any section Entitled "Endorsements".  Such a section
           may not be included in the Modified Version.
@@ -550,11 +541,11 @@ Appendix A GNU Free Documentation License
 
      If the Modified Version includes new front-matter sections or
      appendices that qualify as Secondary Sections and contain no
-     material copied from the Document, you may at your option
-     designate some or all of these sections as invariant.  To do this,
-     add their titles to the list of Invariant Sections in the Modified
-     Version's license notice.  These titles must be distinct from any
-     other section titles.
+     material copied from the Document, you may at your option designate
+     some or all of these sections as invariant.  To do this, add their
+     titles to the list of Invariant Sections in the Modified Version's
+     license notice.  These titles must be distinct from any other
+     section titles.
 
      You may add a section Entitled "Endorsements", provided it contains
      nothing but endorsements of your Modified Version by various
@@ -563,15 +554,15 @@ Appendix A GNU Free Documentation License
      definition of a standard.
 
      You may add a passage of up to five words as a Front-Cover Text,
-     and a passage of up to 25 words as a Back-Cover Text, to the end
-     of the list of Cover Texts in the Modified Version.  Only one
-     passage of Front-Cover Text and one of Back-Cover Text may be
-     added by (or through arrangements made by) any one entity.  If the
-     Document already includes a cover text for the same cover,
-     previously added by you or by arrangement made by the same entity
-     you are acting on behalf of, you may not add another; but you may
-     replace the old one, on explicit permission from the previous
-     publisher that added the old one.
+     and a passage of up to 25 words as a Back-Cover Text, to the end of
+     the list of Cover Texts in the Modified Version.  Only one passage
+     of Front-Cover Text and one of Back-Cover Text may be added by (or
+     through arrangements made by) any one entity.  If the Document
+     already includes a cover text for the same cover, previously added
+     by you or by arrangement made by the same entity you are acting on
+     behalf of, you may not add another; but you may replace the old
+     one, on explicit permission from the previous publisher that added
+     the old one.
 
      The author(s) and publisher(s) of the Document do not by this
      License give permission to use their names for publicity for or to
@@ -581,8 +572,8 @@ Appendix A GNU Free Documentation License
 
      You may combine the Document with other documents released under
      this License, under the terms defined in section 4 above for
-     modified versions, provided that you include in the combination
-     all of the Invariant Sections of all of the original documents,
+     modified versions, provided that you include in the combination all
+     of the Invariant Sections of all of the original documents,
      unmodified, and list them all as Invariant Sections of your
      combined work in its license notice, and that you preserve all
      their Warranty Disclaimers.
@@ -609,20 +600,20 @@ Appendix A GNU Free Documentation License
      documents released under this License, and replace the individual
      copies of this License in the various documents with a single copy
      that is included in the collection, provided that you follow the
-     rules of this License for verbatim copying of each of the
-     documents in all other respects.
+     rules of this License for verbatim copying of each of the documents
+     in all other respects.
 
      You may extract a single document from such a collection, and
      distribute it individually under this License, provided you insert
-     a copy of this License into the extracted document, and follow
-     this License in all other respects regarding verbatim copying of
-     that document.
+     a copy of this License into the extracted document, and follow this
+     License in all other respects regarding verbatim copying of that
+     document.
 
   7. AGGREGATION WITH INDEPENDENT WORKS
 
      A compilation of the Document or its derivatives with other
-     separate and independent documents or works, in or on a volume of
-     a storage or distribution medium, is called an "aggregate" if the
+     separate and independent documents or works, in or on a volume of a
+     storage or distribution medium, is called an "aggregate" if the
      copyright resulting from the compilation is not used to limit the
      legal rights of the compilation's users beyond what the individual
      works permit.  When the Document is included in an aggregate, this
@@ -667,8 +658,8 @@ Appendix A GNU Free Documentation License
 
      However, if you cease all violation of this License, then your
      license from a particular copyright holder is reinstated (a)
-     provisionally, unless and until the copyright holder explicitly
-     and finally terminates your license, and (b) permanently, if the
+     provisionally, unless and until the copyright holder explicitly and
+     finally terminates your license, and (b) permanently, if the
      copyright holder fails to notify you of the violation by some
      reasonable means prior to 60 days after the cessation.
 
@@ -680,33 +671,33 @@ Appendix A GNU Free Documentation License
      after your receipt of the notice.
 
      Termination of your rights under this section does not terminate
-     the licenses of parties who have received copies or rights from
-     you under this License.  If your rights have been terminated and
-     not permanently reinstated, receipt of a copy of some or all of
-     the same material does not give you any rights to use it.
+     the licenses of parties who have received copies or rights from you
+     under this License.  If your rights have been terminated and not
+     permanently reinstated, receipt of a copy of some or all of the
+     same material does not give you any rights to use it.
 
- 10. FUTURE REVISIONS OF THIS LICENSE
+  10. FUTURE REVISIONS OF THIS LICENSE
 
      The Free Software Foundation may publish new, revised versions of
      the GNU Free Documentation License from time to time.  Such new
      versions will be similar in spirit to the present version, but may
      differ in detail to address new problems or concerns.  See
-     `http://www.gnu.org/copyleft/'.
+     <http://www.gnu.org/copyleft/>.
 
      Each version of the License is given a distinguishing version
      number.  If the Document specifies that a particular numbered
      version of this License "or any later version" applies to it, you
      have the option of following the terms and conditions either of
      that specified version or of any later version that has been
-     published (not as a draft) by the Free Software Foundation.  If
-     the Document does not specify a version number of this License,
-     you may choose any version ever published (not as a draft) by the
-     Free Software Foundation.  If the Document specifies that a proxy
-     can decide which future versions of this License can be used, that
+     published (not as a draft) by the Free Software Foundation.  If the
+     Document does not specify a version number of this License, you may
+     choose any version ever published (not as a draft) by the Free
+     Software Foundation.  If the Document specifies that a proxy can
+     decide which future versions of this License can be used, that
      proxy's public statement of acceptance of a version permanently
      authorizes you to choose that version for the Document.
 
- 11. RELICENSING
+  11. RELICENSING
 
      "Massive Multiauthor Collaboration Site" (or "MMC Site") means any
      World Wide Web server that publishes copyrightable works and also
@@ -736,7 +727,6 @@ Appendix A GNU Free Documentation License
      site under CC-BY-SA on the same site at any time before August 1,
      2009, provided the MMC is eligible for relicensing.
 
-
 ADDENDUM: How to use this License for your documents
 ====================================================
 
@@ -753,7 +743,7 @@ notices just after the title page:
        Free Documentation License''.
 
    If you have Invariant Sections, Front-Cover Texts and Back-Cover
-Texts, replace the "with...Texts." line with this:
+Texts, replace the "with...Texts."  line with this:
 
          with the Invariant Sections being LIST THEIR TITLES, with
          the Front-Cover Texts being LIST, and with the Back-Cover Texts
@@ -764,9 +754,9 @@ combination of the three, merge those two alternatives to 
suit the
 situation.
 
    If your document contains nontrivial examples of program code, we
-recommend releasing these examples in parallel under your choice of
-free software license, such as the GNU General Public License, to
-permit their use in free software.
+recommend releasing these examples in parallel under your choice of free
+software license, such as the GNU General Public License, to permit
+their use in free software.
 
 
 File: gpr-mode.info,  Node: Index,  Prev: GNU Free Documentation License,  Up: 
Top
@@ -783,15 +773,15 @@ Index
 
 
 Tag Table:
-Node: Top969
-Node: Overview1952
-Node: Installation2510
-Node: Customization3268
-Node: Moving Through Gpr Code5191
-Node: Identifier completion5641
-Node: Indentation6602
-Node: Statement skeletons8978
-Node: GNU Free Documentation License9733
-Node: Index34914
+Node: Top960
+Node: Overview1939
+Node: Installation2498
+Node: Customization3249
+Node: Moving Through Gpr Code5171
+Node: Identifier completion5621
+Node: Indentation6583
+Node: Statement skeletons8913
+Node: GNU Free Documentation License9669
+Node: Index34831
 
 End Tag Table
diff --git a/packages/ada-mode/gpr-mode.texi b/packages/ada-mode/gpr-mode.texi
index def6797..a293793 100644
--- a/packages/ada-mode/gpr-mode.texi
+++ b/packages/ada-mode/gpr-mode.texi
@@ -26,7 +26,7 @@ developing GNU and promoting software freedom.''
 
 @titlepage
 @sp 10
address@hidden Mode}
address@hidden gpr Mode
 @sp 2
 @subtitle An Emacs major mode for editing and navigating gpr files
 @sp 2
diff --git a/packages/ada-mode/gpr-query.el b/packages/ada-mode/gpr-query.el
index 71761c3..ae4ed8e 100644
--- a/packages/ada-mode/gpr-query.el
+++ b/packages/ada-mode/gpr-query.el
@@ -47,9 +47,7 @@
 
 (cl-defstruct (gpr-query--session)
   (process nil) ;; running gpr_query
-  (buffer nil)  ;; receives output of gpr_query
-  (sent-kill-p nil)
-  (closed-p nil))
+  (buffer nil)) ;; receives output of gpr_query
 
 (defconst gpr-query-buffer-name-prefix " *gpr_query-")
 
@@ -162,6 +160,14 @@ Return buffer that holds output."
       (current-buffer)
       )))
 
+(defun gpr-query-kill-session (session)
+  (let ((process (gpr-query--session-process session)))
+    (when (process-live-p process)
+      (process-send-string (gpr-query--session-process session) "exit\n")
+      (while (process-live-p process)
+       (accept-process-output process 1.0)))
+    ))
+
 (defun gpr-query-kill-all-sessions ()
   (interactive)
   (let ((count 0))
@@ -397,7 +403,10 @@ Enable mode if ARG is positive"
 (defun gpr-query-refresh ()
   "For `ada-xref-refresh-function', using gpr_query."
   (interactive)
-  (with-current-buffer (gpr-query-session-send "refresh" t)))
+  ;; need to kill session to get changed env vars etc
+  (let ((session (gpr-query-cached-session)))
+    (gpr-query-kill-session session)
+    (gpr-query--start-process session)))
 
 (defun gpr-query-other (identifier file line col)
   "For `ada-xref-other-function', using gpr_query."
@@ -407,6 +416,11 @@ Enable mode if ARG is positive"
     (setq identifier (substring identifier 1 (1- (length identifier))))
     )
 
+  (when (eq system-type 'windows-nt)
+    ;; Since Windows file system is case insensitive, GNAT and Emacs
+    ;; can disagree on the case, so convert all to lowercase.
+    (setq file (downcase file)))
+
   (let ((cmd (format "refs %s:%s:%d:%d" identifier (file-name-nondirectory 
file) line col))
        (decl-loc nil)
        (body-loc nil)
@@ -445,14 +459,20 @@ Enable mode if ARG is positive"
        (cond
         ((looking-at gpr-query-ident-file-type-regexp)
          ;; process line
-         ;; 'expand-file-name' converts Windows directory separators to normal 
Emacs
-         (let* ((found-file (expand-file-name (match-string 1)))
+         (let* ((found-file (match-string 1))
                 (found-line (string-to-number (match-string 2)))
                 (found-col  (string-to-number (match-string 3)))
                 (found-type (match-string 4))
                 (dist       (gpr-query-dist found-line line found-col col))
                 )
 
+           (when (eq system-type 'windows-nt)
+             ;; 'expand-file-name' converts Windows directory
+             ;; separators to normal Emacs.  Since Windows file
+             ;; system is case insensitive, GNAT and Emacs can
+             ;; disagree on the case, so convert all to lowercase.
+             (setq found-file (downcase (expand-file-name found-file))))
+
            (when (string-equal found-type "declaration")
              (setq decl-loc (list found-file found-line (1- found-col))))
 
@@ -550,7 +570,6 @@ Enable mode if ARG is positive"
   (setq ada-make-package-body       'ada-gnat-make-package-body)
 
   (add-hook 'ada-syntax-propertize-hook 'gnatprep-syntax-propertize)
-  (add-hook 'ada-syntax-propertize-hook 'ada-gnat-syntax-propertize)
 
   ;; must be after indentation engine setup, because that resets the
   ;; indent function list.
@@ -574,7 +593,6 @@ Enable mode if ARG is positive"
   (setq ada-make-package-body       nil)
 
   (setq ada-syntax-propertize-hook (delq 'gnatprep-syntax-propertize 
ada-syntax-propertize-hook))
-  (setq ada-syntax-propertize-hook (delq 'ada-gnat-syntax-propertize 
ada-syntax-propertize-hook))
   (setq ada-mode-hook (delq 'ada-gpr-query-setup ada-mode-hook))
 
   (setq ada-xref-other-function      nil)
diff --git a/packages/ada-mode/gpr-skel.el b/packages/ada-mode/gpr-skel.el
index 2ddc5d1..eef3b76 100644
--- a/packages/ada-mode/gpr-skel.el
+++ b/packages/ada-mode/gpr-skel.el
@@ -213,7 +213,7 @@ it is a name, and use the word before that as the token."
       ;; hippie is asking us to try the "next" completion; we don't have one
       nil
     (let ((pos (point))
-         (undo-len (length pending-undo-list)))
+         (undo-len (if (sequencep pending-undo-list) (length 
pending-undo-list) 0)))
       (undo-boundary)
       (condition-case nil
          (progn
@@ -221,7 +221,7 @@ it is a name, and use the word before that as the token."
            t)
        ('error
         ;; undo hook action if any
-        (unless (= undo-len (length pending-undo-list))
+        (unless (= undo-len (if (sequencep pending-undo-list) (length 
pending-undo-list) 0))
           (undo))
 
         ;; undo motion
diff --git a/packages/ada-mode/gpr-wisi.el b/packages/ada-mode/gpr-wisi.el
index bb4dd63..48f5523 100644
--- a/packages/ada-mode/gpr-wisi.el
+++ b/packages/ada-mode/gpr-wisi.el
@@ -44,6 +44,7 @@
     block-middle
     block-end
     close-paren
+    list-break
     open-paren
     statement-end
     statement-other
@@ -51,7 +52,8 @@
     ))
 
 (defun gpr-wisi-indent-cache (offset cache)
-  "Return indentation of OFFSET relative to CACHE or containing ancestor of 
CACHE that is at a line beginning."
+  "Return indentation of OFFSET relative to indentation of line containing 
CACHE
+or containing ancestor of CACHE that is at a line beginning."
   (let ((indent (current-indentation)))
     (while (and cache
                (not (= (current-column) indent)))
@@ -113,6 +115,20 @@
            (gpr-wisi-indent-cache ada-indent cache))
           ))
 
+       (list-break
+        ;; test/gpr/simple.gpr
+        ;; type GNAT_Version_Type
+        ;;   is ("7.0.1",
+        ;;       "6.2.2", "6.2.1",
+        ;;       "GPL-2012", "GPL-2011");
+        ;;
+        ;; for Source_Dirs use
+        ;;   ("../auto",
+        ;;    External ("GNAT_VERSION") & "/foo",
+        ;;    "../../1553");
+        (wisi-goto-containing cache)
+        (1+ (current-column)))
+
        (open-paren
         (1+ (current-column)))
 
diff --git a/packages/ada-ref-man/README b/packages/ada-ref-man/README
new file mode 100755
index 0000000..f80fab9
--- /dev/null
+++ b/packages/ada-ref-man/README
@@ -0,0 +1,10 @@
+Emacs info version of Ada Reference Manual 2012
+
+The Ada Reference Manual is provided as a Gnu ELPA package; to install
+the package, add to ~./emacs:
+
+(package-initialize)
+
+then invoke M-x list-packages, install Ada Reference Manual.
+
+(end of file)
diff --git a/packages/ada-ref-man/aarm2012.info 
b/packages/ada-ref-man/aarm2012.info
new file mode 100644
index 0000000..419a80e
--- /dev/null
+++ b/packages/ada-ref-man/aarm2012.info
@@ -0,0 +1,147476 @@
+This is aarm2012.info, produced by texi2any version 5.2 from
+aarm2012.texinfo.
+
+INFO-DIR-SECTION GNU Ada tools
+START-INFO-DIR-ENTRY
+* Ada Reference Manual: (arm2012).
+* Annotated ARM: (arm2012).
+END-INFO-DIR-ENTRY
+
+
+File: aarm2012.info,  Node: Top,  Next: Front Matter,  Up: (dir)
+
+Annotated Ada Reference Manual
+******************************
+
+Ada Reference Manual, ISO/IEC 8652:2012(E)
+
+                    Annotated Ada Reference Manual
+
+                         ISO/IEC 8652:2012(E)
+
+                    Language and Standard Libraries
+
+* Menu:
+
+* Front Matter:: Copyright, Foreword, etc.
+* 1 ::        General
+* 2 ::        Lexical Elements
+* 3 ::        Declarations and Types
+* 4 ::        Names and Expressions
+* 5 ::        Statements
+* 6 ::        Subprograms
+* 7 ::        Packages
+* 8 ::        Visibility Rules
+* 9 ::        Tasks and Synchronization
+* 10 ::       Program Structure and Compilation Issues
+* 11 ::       Exceptions
+* 12 ::       Generic Units
+* 13 ::       Representation Issues
+* Annex A ::  Predefined Language Environment
+* Annex B ::  Interface to Other Languages
+* Annex C ::  Systems Programming
+* Annex D ::  Real-Time Systems
+* Annex E ::  Distributed Systems
+* Annex F ::  Information Systems
+* Annex G ::  Numerics
+* Annex H ::  High Integrity Systems
+* Annex J ::  Obsolescent Features
+* Annex K ::  Language-Defined Aspects and Attributes
+* Annex L ::  Language-Defined Pragmas
+* Annex M ::  Summary of Documentation Requirements
+* Annex N ::  Glossary
+* Annex P ::  Syntax Summary
+* Annex Q ::  Language-Defined Entities
+* Index ::    Index
+
+
+File: aarm2012.info,  Node: Front Matter,  Next: 1,  Prev: Top,  Up: Top
+
+Front Matter
+************
+
+Copyright � 1992, 1993, 1994, 1995 Intermetrics, Inc.
+
+Copyright � 2000 The MITRE Corporation, Inc.
+
+Copyright � 2004, 2005, 2006 AXE Consultants
+
+Copyright � 2004, 2005, 2006 Ada-Europe
+
+Copyright � 2008, 2009, 2010, 2011, 2012 AXE Consultants
+
+ 
+
+
+
+
+
+Ada Reference Manual - Language and Standard Libraries
+
+Copyright � 1992, 1993, 1994, 1995, Intermetrics, Inc.
+
+This copyright is assigned to the U.S. Government.  All rights reserved.
+
+This document may be copied, in whole or in part, in any form or by any
+means, as is or with alterations, provided that (1) alterations are
+clearly marked as alterations and (2) this copyright notice is included
+unmodified in any copy.  Compiled copies of standard library units and
+examples need not contain this copyright notice so long as the notice is
+included in all copies of source code and documentation.
+
+-------  
+
+Technical Corrigendum 1
+
+Copyright � 2000, The MITRE Corporation.  All Rights Reserved.
+
+This document may be copied, in whole or in part, in any form or by any
+means, as is, or with alterations, provided that (1) alterations are
+clearly marked as alterations and (2) this copyright notice is included
+unmodified in any copy.  Any other use or distribution of this document
+is prohibited without the prior express permission of MITRE.
+
+You use this document on the condition that you indemnify and hold
+harmless MITRE, its Board of Trustees, officers, agents, and employees,
+from any and all liability or damages to yourself or your hardware or
+software, or third parties, including attorneys' fees, court costs, and
+other related costs and expenses, arising out of your use of this
+document irrespective of the cause of said liability.
+
+MITRE MAKES THIS DOCUMENT AVAILABLE ON AN "AS IS" BASIS AND MAKES NO
+WARRANTY, EXPRESS OR IMPLIED, AS TO THE ACCURACY, CAPABILITY, EFFICIENCY
+MERCHANTABILITY, OR FUNCTIONING OF THIS DOCUMENT. IN NO EVENT WILL MITRE
+BE LIABLE FOR ANY GENERAL, CONSEQUENTIAL, INDIRECT, INCIDENTAL,
+EXEMPLARY, OR SPECIAL DAMAGES, EVEN IF MITRE HAS BEEN ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGES.
+
+ 
+
+Amendment 1
+
+Copyright � 2004, 2005, 2006, 2007, AXE Consultants.  All Rights
+Reserved.
+
+This document may be copied, in whole or in part, in any form or by any
+means, as is, or with alterations, provided that (1) alterations are
+clearly marked as alterations and (2) this copyright notice is included
+unmodified in any copy.  Any other use or distribution of this document
+is prohibited without the prior express permission of AXE.
+
+You use this document on the condition that you indemnify and hold
+harmless AXE, its board, officers, agents, and employees, from any and
+all liability or damages to yourself or your hardware or software, or
+third parties, including attorneys' fees, court costs, and other related
+costs and expenses, arising out of your use of this document
+irrespective of the cause of said liability.
+
+AXE MAKES THIS DOCUMENT AVAILABLE ON AN "AS IS" BASIS AND MAKES NO
+WARRANTY, EXPRESS OR IMPLIED, AS TO THE ACCURACY, CAPABILITY, EFFICIENCY
+MERCHANTABILITY, OR FUNCTIONING OF THIS DOCUMENT. IN NO EVENT WILL AXE
+BE LIABLE FOR ANY GENERAL, CONSEQUENTIAL, INDIRECT, INCIDENTAL,
+EXEMPLARY, OR SPECIAL DAMAGES, EVEN IF AXE HAS BEEN ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGES.
+
+Third Edition
+
+Copyright � 2008, 2009, 2010, 2011, 2012 AXE Consultants.  All Rights
+Reserved.
+
+This document may be copied, in whole or in part, in any form or by any
+means, as is, or with alterations, provided that (1) alterations are
+clearly marked as alterations and (2) this copyright notice is included
+unmodified in any copy.  Any other use or distribution of this document
+is prohibited without the prior express permission of AXE.
+
+You use this document on the condition that you indemnify and hold
+harmless AXE, its board, officers, agents, and employees, from any and
+all liability or damages to yourself or your hardware or software, or
+third parties, including attorneys' fees, court costs, and other related
+costs and expenses, arising out of your use of this document
+irrespective of the cause of said liability.
+
+AXE MAKES THIS DOCUMENT AVAILABLE ON AN "AS IS" BASIS AND MAKES NO
+WARRANTY, EXPRESS OR IMPLIED, AS TO THE ACCURACY, CAPABILITY, EFFICIENCY
+MERCHANTABILITY, OR FUNCTIONING OF THIS DOCUMENT. IN NO EVENT WILL AXE
+BE LIABLE FOR ANY GENERAL, CONSEQUENTIAL, INDIRECT, INCIDENTAL,
+EXEMPLARY, OR SPECIAL DAMAGES, EVEN IF AXE HAS BEEN ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGES.
+
+ 
+
+Ada 2005 Consolidated Standard
+
+Copyright � 2004, 2005, 2006, Ada-Europe.
+
+This document may be copied, in whole or in part, in any form or by any
+means, as is, or with alterations, provided that (1) alterations are
+clearly marked as alterations and (2) this copyright notice is included
+unmodified in any copy.  Any other use or distribution of this document
+is prohibited without the prior express permission of Ada-Europe.
+
+You use this document on the condition that you indemnify and hold
+harmless Ada-Europe and its Board from any and all liability or damages
+to yourself or your hardware or software, or third parties, including
+attorneys' fees, court costs, and other related costs and expenses,
+arising out of your use of this document irrespective of the cause of
+said liability.
+
+ADA-EUROPE MAKES THIS DOCUMENT AVAILABLE ON AN "AS IS" BASIS AND MAKES
+NO WARRANTY, EXPRESS OR IMPLIED, AS TO THE ACCURACY, CAPABILITY,
+EFFICIENCY MERCHANTABILITY, OR FUNCTIONING OF THIS DOCUMENT. IN NO EVENT
+WILL ADA-EUROPE BE LIABLE FOR ANY GENERAL, CONSEQUENTIAL, INDIRECT,
+INCIDENTAL, EXEMPLARY, OR SPECIAL DAMAGES, EVEN IF ADA-EUROPE HAS BEEN
+ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+
+* Menu:
+
+* 0.1 :: Foreword to this version of the Ada Reference Manual
+* 0.2 :: Foreword
+* 0.3 :: Introduction
+* 0.99 :: International Standard
+
+
+File: aarm2012.info,  Node: 0.1,  Next: 0.2,  Up: Front Matter
+
+0.1 Foreword
+============
+
+1/3
+ISO (the International Organization for Standardization) and IEC (the
+International Electrotechnical Commission) form the specialized system
+for worldwide standardization.  National bodies that are members of ISO
+or IEC participate in the development of International Standards through
+technical committees established by the respective organization to deal
+with particular fields of technical activity.  ISO and IEC technical
+committees collaborate in fields of mutual interest.  Other
+international organizations, governmental and non-governmental, in
+liaison with ISO and IEC, also take part in the work.  In the field of
+information technology, ISO and IEC have established a joint technical
+committee, ISO/IEC JTC 1.
+
+1.1/3
+International Standards are drafted in accordance with the rules given
+in the ISO/IEC Directives, Part 2.
+
+2/3
+The main task of the joint technical committee is to prepare
+International Standards.  Draft International Standards adopted by the
+joint technical committee are circulated to national bodies for voting.
+Publication as an International Standard requires approval by at least
+75 % of the national bodies casting a vote.
+
+2.1/3
+Attention is drawn to the possibility that some of the elements of this
+document may be the subject of patent rights.  ISO and IEC shall not be
+held responsible for identifying any or all such patent rights.
+
+3/3
+International Standard ISO/IEC 8652 was prepared by Joint Technical
+Committee ISO/IEC JTC 1, Information Technology Subcommittee SC22,
+Programming languages, their environments and system software
+interfaces.
+
+4/3
+{AI05-0299-1AI05-0299-1} This third edition cancels and replaces the
+second edition (ISO/IEC 8652:1995), which has been technically revised.
+It also incorporates the Technical Corrigendum ISO/IEC
+8652:1995:COR.1:2001 and Amendment ISO/IEC 8652:1995:AMD 1:2007.
+
+5.a/3
+          Discussion: This document is the Annotated Ada Reference
+          Manual (AARM). It contains the entire text of the Ada 2012
+          standard (ISO/IEC 8652:201x), plus various annotations.  It is
+          intended primarily for compiler writers, validation test
+          writers, and other language lawyers.  The annotations include
+          detailed rationale for individual rules and explanations of
+          some of the more arcane interactions among the rules.
+
+
+File: aarm2012.info,  Node: 0.2,  Next: 0.99,  Prev: 0.1,  Up: Front Matter
+
+0.2 Introduction
+================
+
+1
+This is the Annotated Ada Reference Manual.
+
+2
+Other available Ada documents include:
+
+3/3
+   * {AI95-00387-01AI95-00387-01} {AI05-0245-1AI05-0245-1} Ada 2012
+     Rationale.  This gives an introduction to the changes and new
+     features in Ada 2012, and explains the rationale behind them.
+     Programmers should read this rationale before reading this Standard
+     in depth.  Rationales for Ada 83, Ada 95, and Ada 2005 are also
+     available.
+
+3.a/3
+          Discussion: {AI05-0245-1AI05-0245-1} As of this writing
+          (December 2012), only five chapters of the Ada 2012 Rationale
+          have been published.  Additional chapters are in development
+          and should be published during 2013.
+
+4/1
+   * This paragraph was deleted.
+
+5/3
+   * The Ada Reference Manual (RM). This is the International Standard
+     -- ISO/IEC 8652:201x.
+
+Design Goals
+
+6/3
+{AI95-00387-01AI95-00387-01} Ada was originally designed with three
+overriding concerns: program reliability and maintenance, programming as
+a human activity, and efficiency.  The 1995 revision to the language was
+designed to provide greater flexibility and extensibility, additional
+control over storage management and synchronization, and standardized
+packages oriented toward supporting important application areas, while
+at the same time retaining the original emphasis on reliability,
+maintainability, and efficiency.  This third edition provides further
+flexibility and adds more standardized packages within the framework
+provided by the 1995 revision.
+
+7
+The need for languages that promote reliability and simplify maintenance
+is well established.  Hence emphasis was placed on program readability
+over ease of writing.  For example, the rules of the language require
+that program variables be explicitly declared and that their type be
+specified.  Since the type of a variable is invariant, compilers can
+ensure that operations on variables are compatible with the properties
+intended for objects of the type.  Furthermore, error-prone notations
+have been avoided, and the syntax of the language avoids the use of
+encoded forms in favor of more English-like constructs.  Finally, the
+language offers support for separate compilation of program units in a
+way that facilitates program development and maintenance, and which
+provides the same degree of checking between units as within a unit.
+
+8
+Concern for the human programmer was also stressed during the design.
+Above all, an attempt was made to keep to a relatively small number of
+underlying concepts integrated in a consistent and systematic way while
+continuing to avoid the pitfalls of excessive involution.  The design
+especially aims to provide language constructs that correspond
+intuitively to the normal expectations of users.
+
+9
+Like many other human activities, the development of programs is
+becoming ever more decentralized and distributed.  Consequently, the
+ability to assemble a program from independently produced software
+components continues to be a central idea in the design.  The concepts
+of packages, of private types, and of generic units are directly related
+to this idea, which has ramifications in many other aspects of the
+language.  An allied concern is the maintenance of programs to match
+changing requirements; type extension and the hierarchical library
+enable a program to be modified while minimizing disturbance to existing
+tested and trusted components.
+
+10
+No language can avoid the problem of efficiency.  Languages that require
+over-elaborate compilers, or that lead to the inefficient use of storage
+or execution time, force these inefficiencies on all machines and on all
+programs.  Every construct of the language was examined in the light of
+present implementation techniques.  Any proposed construct whose
+implementation was unclear or that required excessive machine resources
+was rejected.
+
+Language Summary
+
+11
+An Ada program is composed of one or more program units.  Program units
+may be subprograms (which define executable algorithms), packages (which
+define collections of entities), task units (which define concurrent
+computations), protected units (which define operations for the
+coordinated sharing of data between tasks), or generic units (which
+define parameterized forms of packages and subprograms).  Each program
+unit normally consists of two parts: a specification, containing the
+information that must be visible to other units, and a body, containing
+the implementation details, which need not be visible to other units.
+Most program units can be compiled separately.
+
+12
+This distinction of the specification and body, and the ability to
+compile units separately, allows a program to be designed, written, and
+tested as a set of largely independent software components.
+
+13
+An Ada program will normally make use of a library of program units of
+general utility.  The language provides means whereby individual
+organizations can construct their own libraries.  All libraries are
+structured in a hierarchical manner; this enables the logical
+decomposition of a subsystem into individual components.  The text of a
+separately compiled program unit must name the library units it
+requires.
+
+14
+Program Units
+
+15
+A subprogram is the basic unit for expressing an algorithm.  There are
+two kinds of subprograms: procedures and functions.  A procedure is the
+means of invoking a series of actions.  For example, it may read data,
+update variables, or produce some output.  It may have parameters, to
+provide a controlled means of passing information between the procedure
+and the point of call.  A function is the means of invoking the
+computation of a value.  It is similar to a procedure, but in addition
+will return a result.
+
+16
+A package is the basic unit for defining a collection of logically
+related entities.  For example, a package can be used to define a set of
+type declarations and associated operations.  Portions of a package can
+be hidden from the user, thus allowing access only to the logical
+properties expressed by the package specification.
+
+17
+Subprogram and package units may be compiled separately and arranged in
+hierarchies of parent and child units giving fine control over
+visibility of the logical properties and their detailed implementation.
+
+18
+A task unit is the basic unit for defining a task whose sequence of
+actions may be executed concurrently with those of other tasks.  Such
+tasks may be implemented on multicomputers, multiprocessors, or with
+interleaved execution on a single processor.  A task unit may define
+either a single executing task or a task type permitting the creation of
+any number of similar tasks.
+
+19/2
+{AI95-00114-01AI95-00114-01} A protected unit is the basic unit for
+defining protected operations for the coordinated use of data shared
+between tasks.  Simple mutual exclusion is provided automatically, and
+more elaborate sharing protocols can be defined.  A protected operation
+can either be a subprogram or an entry.  A protected entry specifies a
+Boolean expression (an entry barrier) that must be True before the body
+of the entry is executed.  A protected unit may define a single
+protected object or a protected type permitting the creation of several
+similar objects.
+
+20
+Declarations and Statements
+
+21
+The body of a program unit generally contains two parts: a declarative
+part, which defines the logical entities to be used in the program unit,
+and a sequence of statements, which defines the execution of the program
+unit.
+
+22
+The declarative part associates names with declared entities.  For
+example, a name may denote a type, a constant, a variable, or an
+exception.  A declarative part also introduces the names and parameters
+of other nested subprograms, packages, task units, protected units, and
+generic units to be used in the program unit.
+
+23
+The sequence of statements describes a sequence of actions that are to
+be performed.  The statements are executed in succession (unless a
+transfer of control causes execution to continue from another place).
+
+24
+An assignment statement changes the value of a variable.  A procedure
+call invokes execution of a procedure after associating any actual
+parameters provided at the call with the corresponding formal
+parameters.
+
+25
+Case statements and if statements allow the selection of an enclosed
+sequence of statements based on the value of an expression or on the
+value of a condition.
+
+26
+The loop statement provides the basic iterative mechanism in the
+language.  A loop statement specifies that a sequence of statements is
+to be executed repeatedly as directed by an iteration scheme, or until
+an exit statement is encountered.
+
+27
+A block statement comprises a sequence of statements preceded by the
+declaration of local entities used by the statements.
+
+28
+Certain statements are associated with concurrent execution.  A delay
+statement delays the execution of a task for a specified duration or
+until a specified time.  An entry call statement is written as a
+procedure call statement; it requests an operation on a task or on a
+protected object, blocking the caller until the operation can be
+performed.  A called task may accept an entry call by executing a
+corresponding accept statement, which specifies the actions then to be
+performed as part of the rendezvous with the calling task.  An entry
+call on a protected object is processed when the corresponding entry
+barrier evaluates to true, whereupon the body of the entry is executed.
+The requeue statement permits the provision of a service as a number of
+related activities with preference control.  One form of the select
+statement allows a selective wait for one of several alternative
+rendezvous.  Other forms of the select statement allow conditional or
+timed entry calls and the asynchronous transfer of control in response
+to some triggering event.
+
+29
+Execution of a program unit may encounter error situations in which
+normal program execution cannot continue.  For example, an arithmetic
+computation may exceed the maximum allowed value of a number, or an
+attempt may be made to access an array component by using an incorrect
+index value.  To deal with such error situations, the statements of a
+program unit can be textually followed by exception handlers that
+specify the actions to be taken when the error situation arises.
+Exceptions can be raised explicitly by a raise statement.
+
+30
+Data Types
+
+31
+Every object in the language has a type, which characterizes a set of
+values and a set of applicable operations.  The main classes of types
+are elementary types (comprising enumeration, numeric, and access types)
+and composite types (including array and record types).
+
+32/2
+{AI95-00285-01AI95-00285-01} {AI95-00387-01AI95-00387-01} An enumeration
+type defines an ordered set of distinct enumeration literals, for
+example a list of states or an alphabet of characters.  The enumeration
+types Boolean, Character, Wide_Character, and Wide_Wide_Character are
+predefined.
+
+33
+Numeric types provide a means of performing exact or approximate
+numerical computations.  Exact computations use integer types, which
+denote sets of consecutive integers.  Approximate computations use
+either fixed point types, with absolute bounds on the error, or floating
+point types, with relative bounds on the error.  The numeric types
+Integer, Float, and Duration are predefined.
+
+34/2
+{AI95-00285-01AI95-00285-01} {AI95-00387-01AI95-00387-01} Composite
+types allow definitions of structured objects with related components.
+The composite types in the language include arrays and records.  An
+array is an object with indexed components of the same type.  A record
+is an object with named components of possibly different types.  Task
+and protected types are also forms of composite types.  The array types
+String, Wide_String, and Wide_Wide_String are predefined.
+
+35
+Record, task, and protected types may have special components called
+discriminants which parameterize the type.  Variant record structures
+that depend on the values of discriminants can be defined within a
+record type.
+
+36
+Access types allow the construction of linked data structures.  A value
+of an access type represents a reference to an object declared as
+aliased or to an object created by the evaluation of an allocator.
+Several variables of an access type may designate the same object, and
+components of one object may designate the same or other objects.  Both
+the elements in such linked data structures and their relation to other
+elements can be altered during program execution.  Access types also
+permit references to subprograms to be stored, passed as parameters, and
+ultimately dereferenced as part of an indirect call.
+
+37
+Private types permit restricted views of a type.  A private type can be
+defined in a package so that only the logically necessary properties are
+made visible to the users of the type.  The full structural details that
+are externally irrelevant are then only available within the package and
+any child units.
+
+38
+From any type a new type may be defined by derivation.  A type, together
+with its derivatives (both direct and indirect) form a derivation class.
+Class-wide operations may be defined that accept as a parameter an
+operand of any type in a derivation class.  For record and private
+types, the derivatives may be extensions of the parent type.  Types that
+support these object-oriented capabilities of class-wide operations and
+type extension must be tagged, so that the specific type of an operand
+within a derivation class can be identified at run time.  When an
+operation of a tagged type is applied to an operand whose specific type
+is not known until run time, implicit dispatching is performed based on
+the tag of the operand.
+
+38.1/2
+{AI95-00387-01AI95-00387-01} Interface types provide abstract models
+from which other interfaces and types may be composed and derived.  This
+provides a reliable form of multiple inheritance.  Interface types may
+also be implemented by task types and protected types thereby enabling
+concurrent programming and inheritance to be merged.
+
+39
+The concept of a type is further refined by the concept of a subtype,
+whereby a user can constrain the set of allowed values of a type.
+Subtypes can be used to define subranges of scalar types, arrays with a
+limited set of index values, and records and private types with
+particular discriminant values.
+
+40
+Other Facilities
+
+41/2
+{AI95-00387-01AI95-00387-01} Aspect clauses can be used to specify the
+mapping between types and features of an underlying machine.  For
+example, the user can specify that objects of a given type must be
+represented with a given number of bits, or that the components of a
+record are to be represented using a given storage layout.  Other
+features allow the controlled use of low level, nonportable, or
+implementation-dependent aspects, including the direct insertion of
+machine code.
+
+42/2
+{AI95-00387-01AI95-00387-01} The predefined environment of the language
+provides for input-output and other capabilities by means of standard
+library packages.  Input-output is supported for values of user-defined
+as well as of predefined types.  Standard means of representing values
+in display form are also provided.
+
+42.1/2
+{AI95-00387-01AI95-00387-01} The predefined standard library packages
+provide facilities such as string manipulation, containers of various
+kinds (vectors, lists, maps, etc.), mathematical functions, random
+number generation, and access to the execution environment.
+
+42.2/2
+{AI95-00387-01AI95-00387-01} The specialized annexes define further
+predefined library packages and facilities with emphasis on areas such
+as real-time scheduling, interrupt handling, distributed systems,
+numerical computation, and high-integrity systems.
+
+43
+Finally, the language provides a powerful means of parameterization of
+program units, called generic program units.  The generic parameters can
+be types and subprograms (as well as objects and packages) and so allow
+general algorithms and data structures to be defined that are applicable
+to all types of a given class.
+
+Language Changes
+
+Paragraphs 44 through 57 have been removed as they described differences
+from the first edition of Ada (Ada 83).
+
+57.1/3
+{AI95-00387-01AI95-00387-01} This International Standard replaces the
+second edition of 1995.  It modifies the previous edition by making
+changes and additions that improve the capability of the language and
+the reliability of programs written in the language.  This edition
+incorporates the changes from Amendment 1 (ISO/IEC 8652:1995:AMD
+1:2007), which were designed to improve the portability of programs,
+interfacing to other languages, and both the object-oriented and
+real-time capabilities.
+
+57.2/3
+{AI95-00387-01AI95-00387-01} {AI05-0299-1AI05-0299-1} Significant
+changes originating in Amendment 1 are incorporated:
+
+57.3/3
+   * Support for program text is extended to cover the entire ISO/IEC
+     10646:2003 repertoire.  Execution support now includes the 32-bit
+     character set.  See subclauses *note 2.1::, *note 3.5.2::, *note
+     3.6.3::, *note A.1::, *note A.3::, and *note A.4::.
+
+57.4/3
+   * The object-oriented model has been improved by the addition of an
+     interface facility which provides multiple inheritance and
+     additional flexibility for type extensions.  See subclauses *note
+     3.4::, *note 3.9::, and *note 7.3::.  An alternative notation for
+     calling operations more akin to that used in other languages has
+     also been added.  See subclause *note 4.1.3::.
+
+57.5/3
+   * Access types have been further extended to unify properties such as
+     the ability to access constants and to exclude null values.  See
+     clause *note 3.10::.  Anonymous access types are now permitted more
+     freely and anonymous access-to-subprogram types are introduced.
+     See subclauses *note 3.3::, *note 3.6::, *note 3.10::, and *note
+     8.5.1::.
+
+57.6/3
+   * The control of structure and visibility has been enhanced to permit
+     mutually dependent references between units and finer control over
+     access from the private part of a package.  See subclauses *note
+     3.10.1:: and *note 10.1.2::.  In addition, limited types have been
+     made more useful by the provision of aggregates, constants, and
+     constructor functions.  See subclauses *note 4.3::, *note 6.5::,
+     and *note 7.5::.
+
+57.7/3
+   * The predefined environment has been extended to include additional
+     time and calendar operations, improved string handling, a
+     comprehensive container library, file and directory management, and
+     access to environment variables.  See subclauses *note 9.6.1::,
+     *note A.4::, *note A.16::, *note A.17::, and *note A.18::.
+
+57.8/3
+   * Two of the Specialized Needs Annexes have been considerably
+     enhanced:
+
+57.9/2
+             * The Real-Time Systems Annex now includes the Ravenscar
+               profile for high-integrity systems, further dispatching
+               policies such as Round Robin and Earliest Deadline First,
+               support for timing events, and support for control of CPU
+               time utilization.  See subclauses *note D.2::, *note
+               D.13::, *note D.14::, and *note D.15::.
+
+57.10/3
+             * The Numerics Annex now includes support for real and
+               complex vectors and matrices as previously defined in
+               ISO/IEC 13813:1997 plus further basic operations for
+               linear algebra.  See subclause *note G.3::.
+
+57.11/3
+   * The overall reliability of the language has been enhanced by a
+     number of improvements.  These include new syntax which detects
+     accidental overloading, as well as pragmas for making assertions
+     and giving better control over the suppression of checks.  See
+     subclauses *note 6.1::, *note 11.4.2::, and *note 11.5::.
+
+57.12/3
+{AI05-0245-1AI05-0245-1} In addition, this third edition makes
+enhancements to address two important issues, namely, the particular
+problems of multiprocessor architectures, and the need to further
+increase the capabilities regarding assertions for correctness.  It also
+makes additional changes and additions that improve the capability of
+the language and the reliability of programs written in the language.
+
+57.13/3
+{AI05-0245-1AI05-0245-1} {AI05-0299-1AI05-0299-1} The following
+significant changes with respect to the 1995 edition as amended by
+Amendment 1 are incorporated:
+
+57.14/3
+   * New syntax (the aspect specification) is introduced to enable
+     properties to be specified for various entities in a more
+     structured manner than through pragmas.  See subclause *note
+     13.1.1::.
+
+57.15/3
+   * The concept of assertions introduced in the 2005 edition is
+     extended with the ability to specify preconditions and
+     postconditions for subprograms, and invariants for private types.
+     The concept of constraints in defining subtypes is supplemented
+     with subtype predicates that enable subsets to be specified other
+     than as simple ranges.  These properties are all indicated using
+     aspect specifications.  See subclauses *note 3.2.4::, *note
+     6.1.1::, and *note 7.3.2::.
+
+57.16/3
+   * New forms of expressions are introduced.  These are if expressions,
+     case expressions, quantified expressions, and expression functions.
+     As well as being useful for programming in general by avoiding the
+     introduction of unnecessary assignments, they are especially
+     valuable in conditions and invariants since they avoid the need to
+     introduce auxiliary functions.  See subclauses *note 4.5.7::, *note
+     4.5.8::, and *note 6.8::.  Membership tests are also made more
+     flexible.  See subclauses *note 4.4:: and *note 4.5.2::.
+
+57.17/3
+   * A number of changes are made to subprogram parameters.  Functions
+     may now have parameters of all modes.  In order to mitigate
+     consequent (and indeed existing) problems of inadvertent order
+     dependence, rules are introduced to reduce aliasing.  A parameter
+     may now be explicitly marked as aliased and the type of a parameter
+     may be incomplete in certain circumstances.  See subclauses *note
+     3.10.1::, *note 6.1::, and *note 6.4.1::.
+
+57.18/3
+   * The use of access types is now more flexible.  The rules for
+     accessibility and certain conversions are improved.  See subclauses
+     *note 3.10.2::, *note 4.5.2::, *note 4.6::, and *note 8.6::.
+     Furthermore, better control of storage pools is provided.  See
+     subclause *note 13.11.4::.
+
+57.19/3
+   * The Real-Time Systems Annex now includes facilities for defining
+     domains of processors and assigning tasks to them.  Improvements
+     are made to scheduling and budgeting facilities.  See subclauses
+     *note D.10.1::, *note D.14::, and *note D.16::.
+
+57.20/3
+   * A number of important improvements are made to the standard
+     library.  These include packages for conversions between strings
+     and UTF encodings, and classification functions for wide and wide
+     wide characters.  Internationalization is catered for by a package
+     giving locale information.  See subclauses *note A.3::, *note
+     A.4.11::, and *note A.19::.  The container library is extended to
+     include bounded forms of the existing containers and new containers
+     for indefinite objects, multiway trees, and queues.  See subclause
+     *note A.18::.
+
+57.21/3
+   * Finally, certain features are added primarily to ease the use of
+     containers, such as the ability to iterate over all elements in a
+     container without having to encode the iteration.  These can also
+     be used for iteration over arrays, and within quantified
+     expressions.  See subclauses *note 4.1.5::, *note 4.1.6::, *note
+     5.5.1::, and *note 5.5.2::.
+
+Instructions for Comment Submission
+
+58/1
+Informal comments on this International Standard may be sent via e-mail
+to address@hidden  If appropriate, the Project Editor will
+initiate the defect correction procedure.
+
+59
+Comments should use the following format:
+
+60/3
+        !topic Title summarizing comment
+        !reference Ada 2012 RMss.ss(pp)
+        !from Author Name yy-mm-dd
+        !keywords keywords related to topic
+        !discussion
+
+        text of discussion
+
+61/3
+where ss.ss is the clause or subclause number, pp is the paragraph
+number where applicable, and yy-mm-dd is the date the comment was sent.
+The date is optional, as is the !keywords line.
+
+62/1
+Please use a descriptive "Subject" in your e-mail message, and limit
+each message to a single comment.
+
+63
+When correcting typographical errors or making minor wording
+suggestions, please put the correction directly as the topic of the
+comment; use square brackets [ ] to indicate text to be omitted and
+curly braces { } to indicate text to be added, and provide enough
+context to make the nature of the suggestion self-evident or put
+additional information in the body of the comment, for example:
+
+64
+        !topic [c]{C}haracter
+        !topic it[']s meaning is not defined
+
+65
+Formal requests for interpretations and for reporting defects in this
+International Standard may be made in accordance with the ISO/IEC JTC 1
+Directives and the ISO/IEC JTC 1/SC 22 policy for interpretations.
+National Bodies may submit a Defect Report to ISO/IEC JTC 1/SC 22 for
+resolution under the JTC 1 procedures.  A response will be provided and,
+if appropriate, a Technical Corrigendum will be issued in accordance
+with the procedures.
+
+Acknowledgements for the Ada 83 edition
+
+65.1/3
+Ada is the result of a collective effort to design a common language for
+programming large scale and real-time systems.
+
+65.2/3
+The common high order language program began in 1974.  The requirements
+of the United States Department of Defense were formalized in a series
+of documents which were extensively reviewed by the Services, industrial
+organizations, universities, and foreign military departments.  The Ada
+language was designed in accordance with the final (1978) form of these
+requirements, embodied in the Steelman specification.
+
+65.3/3
+The Ada design team was led by Jean D. Ichbiah and has included Bernd
+Krieg-Brueckner, Brian A. Wichmann, Henry F. Ledgard, Jean-Claude
+Heliard, Jean-Loup Gailly, Jean-Raymond Abrial, John G.P. Barnes, Mike
+Woodger, Olivier Roubine, Paul N. Hilfinger, and Robert Firth.
+
+65.4/3
+At various stages of the project, several people closely associated with
+the design team made major contributions.  They include J.B. Goodenough,
+R.F. Brender, M.W. Davis, G. Ferran, K. Lester, L. MacLaren, E. Morel,
+I.R. Nassi, I.C. Pyle, S.A. Schuman, and S.C. Vestal.
+
+65.5/3
+Two parallel efforts that were started in the second phase of this
+design had a deep influence on the language.  One was the development of
+a formal definition using denotational semantics, with the participation
+of V. Donzeau-Gouge, G. Kahn, and B. Lang.  The other was the design of
+a test translator with the participation of K. Ripken, P. Boullier, P.
+Cadiou, J. Holden, J.F. Hueras, R.G. Lange, and D.T. Cornhill.  The
+entire effort benefitted from the dedicated assistance of Lyn Churchill
+and Marion Myers, and the effective technical support of B. Gravem, W.L.
+Heimerdinger, and P. Cleve.  H.G. Schmitz served as program manager.
+
+65.6/3
+Over the five years spent on this project, several intense week-long
+design reviews were conducted, with the participation of P. Belmont, B.
+Brosgol, P. Cohen, R. Dewar, A. Evans, G. Fisher, H. Harte, A.L. Hisgen,
+P. Knueven, M. Kronental, N. Lomuto, E. Ploedereder, G. Seegmueller, V.
+Stenning, D. Taffs, and also F. Belz, R. Converse, K. Correll, A.N.
+Habermann, J. Sammet, S. Squires, J. Teller, P. Wegner, and P.R.
+Wetherall.
+
+65.7/3
+Several persons had a constructive influence with their comments,
+criticisms and suggestions.  They include P. Brinch Hansen, G. Goos,
+C.A.R. Hoare, Mark Rain, W.A. Wulf, and also E. Boebert, P. Bonnard, H.
+Clausen, M. Cox, G. Dismukes, R. Eachus, T. Froggatt, H. Ganzinger, C.
+Hewitt, S. Kamin, R. Kotler, O. Lecarme, J.A.N. Lee, J.L. Mansion, F.
+Minel, T. Phinney, J. Roehrich, V. Schneider, A. Singer, D. Slosberg,
+I.C. Wand, the reviewers of Ada-Europe, AdaTech, Afcet, those of the
+LMSC review team, and those of the Ada Tokyo Study Group.
+
+65.8/3
+These reviews and comments, the numerous evaluation reports received at
+the end of the first and second phase, the nine hundred language issue
+reports and test and evaluation reports received from fifteen different
+countries during the third phase of the project, the thousands of
+comments received during the ANSI Canvass, and the on-going work of the
+IFIP Working Group 2.4 on system implementation languages and that of
+the Purdue Europe LTPL-E committee, all had a substantial influence on
+the final definition of Ada.
+
+65.9/3
+The Military Departments and Agencies have provided a broad base of
+support including funding, extensive reviews, and countless individual
+contributions by the members of the High Order Language Working Group
+and other interested personnel.  In particular, William A. Whitaker
+provided leadership for the program during the formative stages.  David
+A. Fisher was responsible for the successful development and refinement
+of the language requirement documents that led to the Steelman
+specification.
+
+65.10/3
+The Ada 83 language definition was developed by Cii Honeywell Bull and
+later Alsys, and by Honeywell Systems and Research Center, under
+contract to the United States Department of Defense.  William E. Carlson
+and later Larry E. Druffel served as the technical representatives of
+the United States Government and effectively coordinated the efforts of
+all participants in the Ada program.
+
+Acknowledgements for the Ada 95 edition
+
+66
+This International Standard was prepared by the Ada 9X Mapping/Revision
+Team based at Intermetrics, Inc., which has included: W. Carlson,
+Program Manager; T. Taft, Technical Director; J. Barnes (consultant); B.
+Brosgol (consultant); R. Duff (Oak Tree Software); M. Edwards; C.
+Garrity; R. Hilliard; O. Pazy (consultant); D. Rosenfeld; L. Shafer; W.
+White; M. Woodger.
+
+67
+The following consultants to the Ada 9X Project contributed to the
+Specialized Needs Annexes: T. Baker (Real-Time/Systems Programming --
+SEI, FSU); K. Dritz (Numerics -- Argonne National Laboratory); A.
+Gargaro (Distributed Systems -- Computer Sciences); J. Goodenough
+(Real-Time/Systems Programming -- SEI); J. McHugh (Secure Systems --
+consultant); B. Wichmann (Safety-Critical Systems -- NPL: UK).
+
+68
+This work was regularly reviewed by the Ada 9X Distinguished Reviewers
+and the members of the Ada 9X Rapporteur Group (XRG): E. Ploedereder,
+Chairman of DRs and XRG (University of Stuttgart: Germany); B. Bardin
+(Hughes); J. Barnes (consultant: UK); B. Brett (DEC); B. Brosgol
+(consultant); R. Brukardt (RR Software); N. Cohen (IBM); R. Dewar (NYU);
+G. Dismukes (TeleSoft); A. Evans (consultant); A. Gargaro (Computer
+Sciences); M. Gerhardt (ESL); J. Goodenough (SEI); S. Heilbrunner
+(University of Salzburg: Austria); P. Hilfinger (UC/Berkeley); B.
+K�llberg (CelsiusTech: Sweden); M. Kamrad II (Unisys); J. van Katwijk
+(Delft University of Technology: The Netherlands); V. Kaufman (Russia);
+P. Kruchten (Rational); R. Landwehr (CCI: Germany); C. Lester
+(Portsmouth Polytechnic: UK); L. M�nsson (TELIA Research: Sweden); S.
+Michell (Multiprocessor Toolsmiths: Canada); M. Mills (US Air Force); D.
+Pogge (US Navy); K. Power (Boeing); O. Roubine (Verdix: France); A.
+Strohmeier (Swiss Fed Inst of Technology: Switzerland); W. Taylor
+(consultant: UK); J. Tokar (Tartan); E. Vasilescu (Grumman); J. Vladik
+(Prospeks s.r.o.: Czech Republic); S. Van Vlierberghe (OFFIS: Belgium).
+
+69
+Other valuable feedback influencing the revision process was provided by
+the Ada 9X Language Precision Team (Odyssey Research Associates), the
+Ada 9X User/Implementer Teams (AETECH, Tartan, TeleSoft), the Ada 9X
+Implementation Analysis Team (New York University) and the Ada
+community-at-large.
+
+70
+Special thanks go to R. Mathis, Convenor of ISO/IEC JTC 1/SC 22 Working
+Group 9.
+
+71
+The Ada 9X Project was sponsored by the Ada Joint Program Office.
+Christine M. Anderson at the Air Force Phillips Laboratory (Kirtland
+AFB, NM) was the project manager.
+
+Acknowledgements for the Corrigendum version
+
+71.1/3
+The editor [R. Brukardt (USA)] would like to thank the many people whose
+hard work and assistance has made this update possible.
+
+71.2/1
+Thanks go out to all of the members of the ISO/IEC JTC 1/SC 22/WG 9 Ada
+Rapporteur Group, whose work on creating and editing the wording
+corrections was critical to the entire process.  Especially valuable
+contributions came from the chairman of the ARG, E. Ploedereder
+(Germany), who kept the process moving; J. Barnes (UK) and K. Ishihata
+(Japan), whose extremely detailed reviews kept the editor on his toes;
+G. Dismukes (USA), M. Kamrad (USA), P. Leroy (France), S. Michell
+(Canada), T. Taft (USA), J. Tokar (USA), and other members too numerous
+to mention.
+
+71.3/1
+Special thanks go to R. Duff (USA) for his explanations of the previous
+system of formatting of these documents during the tedious conversion to
+more modern formats.  Special thanks also go to the convenor of ISO/IEC
+JTC 1/SC 22/WG 9, J. Moore (USA), without whose help and support the
+Corrigendum and this consolidated reference manual would not have been
+possible.
+
+Acknowledgements for the Amendment 1 version
+
+71.4/3
+The editor [R. Brukardt (USA)] would like to thank the many people whose
+hard work and assistance has made this update possible.
+
+71.5/2
+Thanks go out to all of the members of the ISO/IEC JTC 1/SC 22/WG 9 Ada
+Rapporteur Group, whose work on creating and editing the wording
+corrections was critical to the entire process.  Especially valuable
+contributions came from the chairman of the ARG, P. Leroy (France), who
+kept the process on schedule; J. Barnes (UK) whose careful reviews found
+many typographical errors; T. Taft (USA), who always seemed to have a
+suggestion when we were stuck, and who also was usually able to provide
+the valuable service of explaining why things were as they are; S. Baird
+(USA), who found many obscure problems with the proposals; and A. Burns
+(UK), who pushed many of the real-time proposals to completion.  Other
+ARG members who contributed were: R. Dewar (USA), G. Dismukes (USA), R.
+Duff (USA), K. Ishihata (Japan), S. Michell (Canada), E. Ploedereder
+(Germany), J.P. Rosen (France), E. Schonberg (USA), J. Tokar (USA), and
+T. Vardanega (Italy).
+
+71.6/2
+Special thanks go to Ada-Europe and the Ada Resource Association,
+without whose help and support the Amendment and this consolidated
+reference manual would not have been possible.  M. Heaney (USA) requires
+special thanks for his tireless work on the containers packages.
+Finally, special thanks go to the convenor of ISO/IEC JTC 1/SC 22/WG 9,
+J. Moore (USA), who guided the document through the standardization
+process.
+
+Acknowledgements for the Ada 2012 edition
+
+71.7/3
+The editor [R. Brukardt (USA)] would like to thank the many people whose
+hard work and assistance has made this revision possible.
+
+71.8/3
+Thanks go out to all of the members of the ISO/IEC JTC 1/SC 22/WG 9 Ada
+Rapporteur Group, whose work on creating and editing the wording changes
+was critical to the entire process.  Especially valuable contributions
+came from the chairman of the ARG, E. Schonberg (USA), who guided the
+work; T. Taft (USA), whose insights broke many logjams, both in design
+and wording; J. Barnes (UK) whose careful reviews uncovered many
+editorial errors; S. Baird (USA), who repeatedly found obscure
+interactions with the proposals that the rest of us missed.  Other ARG
+members who substantially contributed were: A. Burns (UK), J. Cousins
+(UK), R. Dewar (USA), G. Dismukes (USA), R. Duff (USA), P. Leroy
+(France), B. Moore (Canada), E. Ploedereder (Germany), J.P. Rosen
+(France), B. Thomas (USA), and T. Vardanega (Italy).
+
+71.9/3
+Special thanks go to Ada-Europe and the Ada Resource Association,
+without whose help and support this third edition of the Ada Standard
+would not have been possible.  A special mention has to go to A.
+Beneschan (USA) for his efforts in eliminating sloppiness in our
+wording.  M. Heaney (USA) also deserves a mention for his efforts to
+improve the containers packages.  Finally, special thanks go to the
+convenor of ISO/IEC JTC 1/SC 22/WG 9, J. Tokar (USA), who guided the
+document through the standardization process.
+
+Changes
+
+72
+The International Standard is the same as this version of the Reference
+Manual, except:
+
+73
+   * This list of Changes is not included in the International Standard.
+
+74
+   * The "Acknowledgements" page is not included in the International
+     Standard.
+
+75
+   * The text in the running headers and footers on each page is
+     slightly different in the International Standard.
+
+76
+   * The title page(s) are different in the International Standard.
+
+77
+   * This document is formatted for 8.5-by-11-inch paper, whereas the
+     International Standard is formatted for A4 paper (210-by-297mm);
+     thus, the page breaks are in different places.
+
+77.1/3
+   * This paragraph was deleted.
+
+77.2/3
+   * {AI05-0299-1AI05-0299-1} The "Using this version of the Ada
+     Reference Manual" subclause is not included in the International
+     Standard.
+
+77.3/3
+   * Paragraph numbers are not included in the International Standard.
+
+Using this version of the Ada Reference Manual
+
+77.4/3
+This document has been revised with the corrections specified in
+Technical Corrigendum 1 (ISO/IEC 8652:1995/COR.1:2001) and Amendment 1
+(ISO/IEC 8652/AMD 1:2007), along with changes specifically for this
+third edition.  In addition, more annotations have been added and a
+variety of editorial errors have been corrected.
+
+77.5/3
+Changes to the original 8652:1995 can be identified by the version
+number following the paragraph number.  Paragraphs with a version number
+of /1 were changed by Technical Corrigendum 1 or were editorial
+corrections at that time, while paragraphs with a version number of /2
+were changed by Amendment 1 or were more recent editorial corrections,
+and paragraphs with a version number of /3 were changed by the third
+(2012) edition of the Standard or were still more recent editorial
+corrections.  Paragraphs not so marked are unchanged by the third
+edition, Amendment 1, Technical Corrigendum 1, or editorial corrections.
+Paragraph numbers of unchanged paragraphs are the same as in the 1995
+edition of the Ada Reference Manual.  Inserted text is indicated by
+underlining, and deleted text is indicated by strikethroughs.  Some
+versions also use color to indicate the version of the change.Where
+paragraphs are inserted, the paragraph numbers are of the form pp.nn,
+where pp is the number of the preceding paragraph, and nn is an
+insertion number.  For instance, the first paragraph inserted after
+paragraph 8 is numbered 8.1, the second paragraph inserted is numbered
+8.2, and so on.  Deleted paragraphs are indicated by the text This
+paragraph was deleted.  Deleted paragraphs include empty paragraphs that
+were numbered in the 1995 edition of the Ada Reference Manual.  Similar
+markings and numbering are used for changes to annotations.
+
+77.a/3
+          To be honest: The paragraph number is considered part of the
+          paragraph; when a paragraph is moved to a different paragraph
+          number, it is marked as changed even if the contents have not
+          changed.
+
+
+File: aarm2012.info,  Node: 0.99,  Prev: 0.2,  Up: Front Matter
+
+0.99
+====
+
+========== INTERNATIONAL STANDARD   ISO/IEC 8652:2012(E)
+
+==========  
+
+Information technology -- Programming
+Languages -- Ada
+
+ 
+
+
+File: aarm2012.info,  Node: 1,  Next: 2,  Prev: Front Matter,  Up: Top
+
+1 General
+*********
+
+2.a/3
+          Discussion: This Annotated Ada Reference Manual (AARM)
+          contains the entire text of the third edition of the Ada
+          Reference Manual (the Ada 2012 RM), plus certain annotations.
+          The annotations give a more in-depth analysis of the language.
+          They describe the reason for each nonobvious rule, and point
+          out interesting ramifications of the rules and interactions
+          among the rules (interesting to language lawyers, that is).
+          Differences between Ada 83, Ada 95, Ada 2005, and Ada 2012 are
+          listed.  (The text you are reading now is an annotation.)
+
+2.b/3
+          The AARM stresses detailed correctness and uniformity over
+          readability and understandability.  We're not trying to make
+          the language "appear" simple here; on the contrary, we're
+          trying to expose hidden complexities, so we can more easily
+          detect language bugs.  The Ada 2012 RM, on the other hand, is
+          intended to be a more readable document for programmers.
+
+2.c
+          The annotations in the AARM are as follows:
+
+2.d/3
+             * Text that is logically redundant is shown [in square
+               brackets, like this].  Technically, such text could be
+               written as a Note in the Ada 2012 RM (and the Ada 95 and
+               2005 RMs before it), since it is really a theorem that
+               can be proven from the nonredundant rules of the
+               language.  We use the square brackets instead when it
+               seems to make the Ada 2012 RM more readable.
+
+2.e
+             * The rules of the language (and some AARM-only text) are
+               categorized, and placed under certain sub-headings that
+               indicate the category.  For example, the distinction
+               between Name Resolution Rules and Legality Rules is
+               particularly important, as explained in *note 8.6::.
+
+2.f
+             * Text under the following sub-headings appears in both
+               documents:
+
+2.g
+                       * The unlabeled text at the beginning of each
+                         clause or subclause,
+
+2.h
+                       * Syntax,
+
+2.i
+                       * Name Resolution Rules,
+
+2.j
+                       * Legality Rules,
+
+2.k
+                       * Static Semantics,
+
+2.l
+                       * Post-Compilation Rules,
+
+2.m
+                       * Dynamic Semantics,
+
+2.n
+                       * Bounded (Run-Time) Errors,
+
+2.o
+                       * Erroneous Execution,
+
+2.p
+                       * Implementation Requirements,
+
+2.q
+                       * Documentation Requirements,
+
+2.r
+                       * Metrics,
+
+2.s
+                       * Implementation Permissions,
+
+2.t
+                       * Implementation Advice,
+
+2.u
+                       * NOTES,
+
+2.v
+                       * Examples.
+
+2.w/3
+             * Text under the following sub-headings does not appear in
+               the Ada 2012 RM:
+
+2.x
+                       * Language Design Principles,
+
+2.y
+                       * Inconsistencies With Ada 83,
+
+2.z
+                       * Incompatibilities With Ada 83,
+
+2.aa
+                       * Extensions to Ada 83,
+
+2.bb/2
+                       * Wording Changes from Ada 83,
+
+2.bb.1/2
+                       * Inconsistencies With Ada 95,
+
+2.bb.2/2
+                       * Incompatibilities With Ada 95,
+
+2.bb.3/2
+                       * Extensions to Ada 95,
+
+2.bb.4/3
+                       * Wording Changes from Ada 95,
+
+2.bb.5/3
+                       * Inconsistencies With Ada 2005,
+
+2.bb.6/3
+                       * Incompatibilities With Ada 2005,
+
+2.bb.7/3
+                       * Extensions to Ada 2005,
+
+2.bb.8/3
+                       * Wording Changes from Ada 2005.
+
+2.cc
+             * The AARM also includes the following kinds of
+               annotations.  These do not necessarily annotate the
+               immediately preceding rule, although they often do.
+
+2.dd
+          Reason: An explanation of why a certain rule is necessary, or
+          why it is worded in a certain way.
+
+2.ee
+          Ramification: An obscure ramification of the rules that is of
+          interest only to language lawyers.  (If a ramification of the
+          rules is of interest to programmers, then it appears under
+          NOTES.)
+
+2.ff
+          Proof: An informal proof explaining how a given Note or
+          [marked-as-redundant] piece of text follows from the other
+          rules of the language.
+
+2.gg
+          Implementation Note: A hint about how to implement a feature,
+          or a particular potential pitfall that an implementer needs to
+          be aware of.
+
+2.hh
+          Change: Change annotations are not used in this version.
+          Changes from previous versions have been removed.  Changes in
+          this version are marked with versioned paragraph numbers, as
+          explained in the "Corrigendum Changes" clause of the
+          "Introduction".
+
+2.ii
+          Discussion: Other annotations not covered by the above.
+
+2.jj
+          To be honest: A rule that is considered logically necessary to
+          the definition of the language, but which is so obscure or
+          pedantic that only a language lawyer would care.  These are
+          the only annotations that could be considered part of the
+          language definition.
+
+2.kk
+          Glossary entry: The text of a Glossary entry -- this text will
+          also appear in *note Annex N::, "*note Annex N:: Glossary".
+
+2.ll/3
+          Discussion: In general, the Ada 2012 RM text appears in the
+          normal font, whereas AARM-only text appears in a smaller font.
+          Notes also appear in the smaller font, as recommended by
+          ISO/IEC style guidelines.  Ada examples are also usually
+          printed in a smaller font.
+
+2.mm
+          If you have trouble finding things, be sure to use the index.
+          Each defined term appears there, and also in italics, like
+          this.  Syntactic categories defined in BNF are also indexed.
+
+2.nn
+          A definition marked "[distributed]" is the main definition for
+          a term whose complete definition is given in pieces
+          distributed throughout the document.  The pieces are marked
+          "[partial]" or with a phrase explaining what cases the partial
+          definition applies to.
+
+* Menu:
+
+* 1.1 ::      Scope
+* 1.2 ::      Normative References
+* 1.3 ::      Terms and Definitions
+
+
+File: aarm2012.info,  Node: 1.1,  Next: 1.2,  Up: 1
+
+1.1 Scope
+=========
+
+1/3
+{AI05-0299-1AI05-0299-1} This International Standard specifies the form
+and meaning of programs written in Ada.  Its purpose is to promote the
+portability of Ada programs to a variety of computing systems.
+
+2/3
+{AI05-0299-1AI05-0299-1} Ada is a programming language designed to
+support the construction of long-lived, highly reliable software
+systems.  The language includes facilities to define packages of related
+types, objects, and operations.  The packages may be parameterized and
+the types may be extended to support the construction of libraries of
+reusable, adaptable software components.  The operations may be
+implemented as subprograms using conventional sequential control
+structures, or as entries that include synchronization of concurrent
+threads of control as part of their invocation.  Ada supports
+object-oriented programming by providing classes and interfaces,
+inheritance, polymorphism of variables and methods, and generic units.
+The language treats modularity in the physical sense as well, with a
+facility to support separate compilation.
+
+3/3
+{AI05-0269-1AI05-0269-1} {AI05-0299-1AI05-0299-1} The language provides
+rich support for real-time, concurrent programming, and includes
+facilities for multicore and multiprocessor programming.  Errors can be
+signaled as exceptions and handled explicitly.  The language also covers
+systems programming; this requires precise control over the
+representation of data and access to system-dependent properties.
+Finally, a predefined environment of standard packages is provided,
+including facilities for, among others, input-output, string
+manipulation, numeric elementary functions, and random number
+generation, and definition and use of containers.
+
+* Menu:
+
+* 1.1.1 ::    Extent
+* 1.1.2 ::    Structure
+* 1.1.3 ::    Conformity of an Implementation with the Standard
+* 1.1.4 ::    Method of Description and Syntax Notation
+* 1.1.5 ::    Classification of Errors
+
+
+File: aarm2012.info,  Node: 1.1.1,  Next: 1.1.2,  Up: 1.1
+
+1.1.1 Extent
+------------
+
+1
+This International Standard specifies:
+
+2
+   * The form of a program written in Ada;
+
+3
+   * The effect of translating and executing such a program;
+
+4
+   * The manner in which program units may be combined to form Ada
+     programs;
+
+5
+   * The language-defined library units that a conforming implementation
+     is required to supply;
+
+6
+   * The permissible variations within the standard, and the manner in
+     which they are to be documented;
+
+7
+   * Those violations of the standard that a conforming implementation
+     is required to detect, and the effect of attempting to translate or
+     execute a program containing such violations;
+
+8
+   * Those violations of the standard that a conforming implementation
+     is not required to detect.
+
+9
+This International Standard does not specify:
+
+10
+   * The means whereby a program written in Ada is transformed into
+     object code executable by a processor;
+
+11
+   * The means whereby translation or execution of programs is invoked
+     and the executing units are controlled;
+
+12
+   * The size or speed of the object code, or the relative execution
+     speed of different language constructs;
+
+13
+   * The form or contents of any listings produced by implementations;
+     in particular, the form or contents of error or warning messages;
+
+14
+   * The effect of unspecified execution.
+
+15
+   * The size of a program or program unit that will exceed the capacity
+     of a particular conforming implementation.
+
+
+File: aarm2012.info,  Node: 1.1.2,  Next: 1.1.3,  Prev: 1.1.1,  Up: 1.1
+
+1.1.2 Structure
+---------------
+
+1/3
+{AI05-0299-1AI05-0299-1} This International Standard contains thirteen
+clauses, fifteen annexes, and an index.
+
+1.a/3
+          Discussion: {AI05-0299-1AI05-0299-1} What Ada 83 called a
+          "chapter" and Ada 95 (and Ada 2005) called a "section" is
+          called a "clause" in this Standard.  Similarly, what Ada 83
+          called a "section" and Ada 95 (and Ada 2005) called a "clause"
+          is called a "subclause" in this Standard.  Confused yet?  This
+          terminology is out of our hands; it is (and was) forced by
+          ever-changing ISO rules for drafting Standards.
+
+2
+The core of the Ada language consists of:
+
+3/3
+   * {AI05-0299-1AI05-0299-1} Clauses 1 through 13
+
+4
+   * *note Annex A::, "*note Annex A:: Predefined Language Environment"
+
+5
+   * *note Annex B::, "*note Annex B:: Interface to Other Languages"
+
+6
+   * *note Annex J::, "*note Annex J:: Obsolescent Features"
+
+7
+The following Specialized Needs Annexes define features that are needed
+by certain application areas:
+
+8
+   * *note Annex C::, "*note Annex C:: Systems Programming"
+
+9
+   * *note Annex D::, "*note Annex D:: Real-Time Systems"
+
+10
+   * *note Annex E::, "*note Annex E:: Distributed Systems"
+
+11
+   * *note Annex F::, "*note Annex F:: Information Systems"
+
+12
+   * *note Annex G::, "*note Annex G:: Numerics"
+
+13
+   * *note Annex H::, "*note Annex H:: High Integrity Systems"
+
+14
+The core language and the Specialized Needs Annexes are normative,
+except that the material in each of the items listed below is
+informative:
+
+15
+   * Text under a NOTES or Examples heading.
+
+16/3
+   * {AI05-0299-1AI05-0299-1} Each subclause whose title starts with the
+     word "Example" or "Examples".
+
+17
+All implementations shall conform to the core language.  In addition, an
+implementation may conform separately to one or more Specialized Needs
+Annexes.
+
+18
+The following Annexes are informative:
+
+19
+   * *note Annex K::, "*note Annex K:: Language-Defined Aspects and
+     Attributes"
+
+20
+   * *note Annex L::, "*note Annex L:: Language-Defined Pragmas"
+
+21/3
+   * {AI05-0004-1AI05-0004-1} *note Annex M::, "*note Annex M:: Summary
+     of Documentation Requirements"
+
+22
+   * *note Annex N::, "*note Annex N:: Glossary"
+
+23
+   * *note Annex P::, "*note Annex P:: Syntax Summary"
+
+23.1/3
+   * {AI05-0262-1AI05-0262-1} *note Annex Q::, "*note Annex Q::
+     Language-Defined Entities"
+
+23.a
+          Discussion: The idea of the Specialized Needs Annexes is that
+          implementations can choose to target certain application
+          areas.  For example, an implementation specifically targeted
+          to embedded machines might support the application-specific
+          features for Real-time Systems, but not the
+          application-specific features for Information Systems.
+
+23.b
+          The Specialized Needs Annexes extend the core language only in
+          ways that users, implementations, and standards bodies are
+          allowed to extend the language; for example, via additional
+          library units, attributes, representation items (see *note
+          13.1::), pragmas, and constraints on semantic details that are
+          left unspecified by the core language.  Many implementations
+          already provide much of the functionality defined by
+          Specialized Needs Annexes; our goal is to increase uniformity
+          among implementations by defining standard ways of providing
+          the functionality.
+
+23.c/2
+          {AI95-00114-01AI95-00114-01} We recommend that the
+          certification procedures allow implementations to certify the
+          core language, plus any set of the Specialized Needs Annexes.
+          We recommend that implementations not be allowed to certify a
+          portion of one of the Specialized Needs Annexes, although
+          implementations can, of course, provide uncertified support
+          for such portions.  We have designed the Specialized Needs
+          Annexes assuming that this recommendation is followed.  Thus,
+          our decisions about what to include and what not to include in
+          those annexes are based on the assumption that each annex is
+          certified in an "all-or-nothing" manner.
+
+23.d
+          An implementation may, of course, support extensions that are
+          different from (but possibly related to) those defined by one
+          of the Specialized Needs Annexes.  We recommend that, where
+          appropriate, implementations do this by adding library units
+          that are children of existing language-defined library
+          packages.
+
+23.e
+          An implementation should not provide extensions that conflict
+          with those defined in the Specialized Needs Annexes, in the
+          following sense: Suppose an implementation supports a certain
+          error-free program that uses only functionality defined in the
+          core and in the Specialized Needs Annexes.  The implementation
+          should ensure that that program will still be error free in
+          some possible full implementation of all of the Specialized
+          Needs Annexes, and that the semantics of the program will not
+          change.  For example, an implementation should not provide a
+          package with the same name as one defined in one of the
+          Specialized Needs Annexes, but that behaves differently, even
+          if that implementation does not claim conformance to that
+          Annex.
+
+23.f
+          Note that the Specialized Needs Annexes do not conflict with
+          each other; it is the intent that a single implementation can
+          conform to all of them.
+
+24/3
+{AI05-0299-1AI05-0299-1} Each section is divided into subclauses that
+have a common structure.  Each clause and subclause first introduces its
+subject.  After the introductory text, text is labeled with the
+following headings:
+
+                     _Language Design Principles_
+
+24.a
+          These are not rules of the language, but guiding principles or
+          goals used in defining the rules of the language.  In some
+          cases, the goal is only partially met; such cases are
+          explained.
+
+24.b/3
+          {AI05-0005-1AI05-0005-1} This is not part of the definition of
+          the language, and does not appear in the Ada 2012 RM.
+
+                               _Syntax_
+
+25
+     Syntax rules (indented).
+
+                        _Name Resolution Rules_
+
+26/3
+{AI05-0299-1AI05-0299-1} Compile-time rules that are used in name
+resolution, including overload resolution.
+
+26.a
+          Discussion: These rules are observed at compile time.  (We say
+          "observed" rather than "checked," because these rules are not
+          individually checked.  They are really just part of the
+          Legality Rules in Clause *note 8:: that require exactly one
+          interpretation of each constituent of a complete context.)
+          The only rules used in overload resolution are the Syntax
+          Rules and the Name Resolution Rules.
+
+26.b
+          When dealing with nonoverloadable declarations it sometimes
+          makes no semantic difference whether a given rule is a Name
+          Resolution Rule or a Legality Rule, and it is sometimes
+          difficult to decide which it should be.  We generally make a
+          given rule a Name Resolution Rule only if it has to be.  For
+          example, "The name, if any, in a raise_statement shall be the
+          name of an exception."  is under "Legality Rules."
+
+                           _Legality Rules_
+
+27
+Rules that are enforced at compile time.  A construct is legal if it
+obeys all of the Legality Rules.
+
+27.a
+          Discussion: These rules are not used in overload resolution.
+
+27.b
+          Note that run-time errors are always attached to exceptions;
+          for example, it is not "illegal" to divide by zero, it just
+          raises an exception.
+
+                          _Static Semantics_
+
+28
+A definition of the compile-time effect of each construct.
+
+28.a
+          Discussion: The most important compile-time effects represent
+          the effects on the symbol table associated with declarations
+          (implicit or explicit).  In addition, we use this heading as a
+          bit of a grab bag for equivalences, package specifications,
+          etc.  For example, this is where we put statements like
+          so-and-so is equivalent to such-and-such.  (We ought to try to
+          really mean it when we say such things!)  Similarly,
+          statements about magically-generated implicit declarations go
+          here.  These rules are generally written as statements of fact
+          about the semantics, rather than as a
+          you-shall-do-such-and-such sort of thing.
+
+                       _Post-Compilation Rules_
+
+29
+Rules that are enforced before running a partition.  A partition is
+legal if its compilation units are legal and it obeys all of the
+Post-Compilation Rules.
+
+29.a
+          Discussion: It is not specified exactly when these rules are
+          checked, so long as they are checked for any given partition
+          before that partition starts running.  An implementation may
+          choose to check some such rules at compile time, and reject
+          compilation_units accordingly.  Alternatively, an
+          implementation may check such rules when the partition is
+          created (usually known as "link time"), or when the partition
+          is mapped to a particular piece of hardware (but before the
+          partition starts running).
+
+                          _Dynamic Semantics_
+
+30
+A definition of the run-time effect of each construct.
+
+30.a
+          Discussion: This heading describes what happens at run time.
+          Run-time checks, which raise exceptions upon failure, are
+          described here.  Each item that involves a run-time check is
+          marked with the name of the check -- these are the same check
+          names that are used in a pragma Suppress.  Principle: Every
+          check should have a name, usable in a pragma Suppress.
+
+                      _Bounded (Run-Time) Errors_
+
+31
+Situations that result in bounded (run-time) errors (see *note 1.1.5::).
+
+31.a
+          Discussion: The "bounds" of each such error are described here
+          -- that is, we characterize the set of all possible behaviors
+          that can result from a bounded error occurring at run time.
+
+                         _Erroneous Execution_
+
+32
+Situations that result in erroneous execution (see *note 1.1.5::).
+
+                     _Implementation Requirements_
+
+33
+Additional requirements for conforming implementations.
+
+33.a
+          Discussion: ...as opposed to rules imposed on the programmer.
+          An example might be, "The smallest representable duration,
+          Duration'Small, shall not be greater than twenty
+          milliseconds."
+
+33.b
+          It's really just an issue of how the rule is worded.  We could
+          write the same rule as "The smallest representable duration is
+          an implementation-defined value less than or equal to 20
+          milliseconds" and then it would be under "Static Semantics."
+
+                     _Documentation Requirements_
+
+34
+Documentation requirements for conforming implementations.
+
+34.a
+          Discussion: These requirements are beyond those that are
+          implicitly specified by the phrase "implementation defined".
+          The latter require documentation as well, but we don't repeat
+          these cases under this heading.  Usually this heading is used
+          for when the description of the documentation requirement is
+          longer and does not correspond directly to one, narrow
+          normative sentence.
+
+                               _Metrics_
+
+35
+Metrics that are specified for the time/space properties of the
+execution of certain language constructs.
+
+                     _Implementation Permissions_
+
+36
+Additional permissions given to the implementer.
+
+36.a
+          Discussion: For example, "The implementation is allowed to
+          impose further restrictions on the record aggregates allowed
+          in code statements."  When there are restrictions on the
+          permission, those restrictions are given here also.  For
+          example, "An implementation is allowed to restrict the kinds
+          of subprograms that are allowed to be main subprograms.
+          However, it shall support at least parameterless procedures."
+          -- we don't split this up between here and "Implementation
+          Requirements."
+
+                        _Implementation Advice_
+
+37
+Optional advice given to the implementer.  The word "should" is used to
+indicate that the advice is a recommendation, not a requirement.  It is
+implementation defined whether or not a given recommendation is obeyed.
+
+37.a/2
+          Implementation defined: Whether or not each recommendation
+          given in Implementation Advice is followed -- see *note M.3::,
+          "*note M.3:: Implementation Advice" for a listing.
+
+37.b/1
+          Discussion: The advice generally shows the intended
+          implementation, but the implementer is free to ignore it.  The
+          implementer is the sole arbiter of whether or not the advice
+          has been obeyed, if not, whether the reason is a good one, and
+          whether the required documentation is sufficient.  It would be
+          wrong for the ACATS to enforce any of this advice.
+
+37.c
+          For example, "Whenever possible, the implementation should
+          choose a value no greater than fifty microseconds for the
+          smallest representable duration, Duration'Small."
+
+37.d
+          We use this heading, for example, when the rule is so low
+          level or implementation-oriented as to be untestable.  We also
+          use this heading when we wish to encourage implementations to
+          behave in a certain way in most cases, but we do not wish to
+          burden implementations by requiring the behavior.
+
+     NOTES
+
+38
+     1  Notes emphasize consequences of the rules described in the
+     (sub)clause or elsewhere.  This material is informative.
+
+                              _Examples_
+
+39
+Examples illustrate the possible forms of the constructs described.
+This material is informative.
+
+39.a
+          Discussion:  
+
+          The next three headings list all language changes between Ada
+          83 and Ada 95.  Language changes are any change that changes
+          the set of text strings that are legal Ada programs, or
+          changes the meaning of any legal program.  Wording changes,
+          such as changes in terminology, are not language changes.
+          Each language change falls into one of the following three
+          categories:
+
+                     _Inconsistencies With Ada 83_
+
+39.b
+          This heading lists all of the upward inconsistencies between
+          Ada 83 and Ada 95.  Upward inconsistencies are situations in
+          which a legal Ada 83 program is a legal Ada 95 program with
+          different semantics.  This type of upward incompatibility is
+          the worst type for users, so we only tolerate it in rare
+          situations.
+
+39.c
+          (Note that the semantics of a program is not the same thing as
+          the behavior of the program.  Because of Ada's indeterminacy,
+          the "semantics" of a given feature describes a set of
+          behaviors that can be exhibited by that feature.  The set can
+          contain more than one allowed behavior.  Thus, when we ask
+          whether the semantics changes, we are asking whether the set
+          of behaviors changes.)
+
+39.d/3
+          This is not part of the definition of the language, and does
+          not appear in the Ada 95, Ada 2005, or Ada 2012 RM.
+
+                    _Incompatibilities With Ada 83_
+
+39.e
+          This heading lists all of the upward incompatibilities between
+          Ada 83 and Ada 95, except for the ones listed under
+          "Inconsistencies With Ada 83" above.  These are the situations
+          in which a legal Ada 83 program is illegal in Ada 95.  We do
+          not generally consider a change that turns erroneous execution
+          into an exception, or into an illegality, to be upwardly
+          incompatible.
+
+39.f/3
+          This is not part of the definition of the language, and does
+          not appear in the Ada 95, Ada 2005, or Ada 2012 RM.
+
+                        _Extensions to Ada 83_
+
+39.g
+          This heading is used to list all upward compatible language
+          changes; that is, language extensions.  These are the
+          situations in which a legal Ada 95 program is not a legal Ada
+          83 program.  The vast majority of language changes fall into
+          this category.
+
+39.h/3
+          This is not part of the definition of the language, and does
+          not appear in the Ada 95, Ada 2005, or Ada 2012 RM.
+
+39.i
+           
+
+          As explained above, the next heading does not represent any
+          language change:
+
+                     _Wording Changes from Ada 83_
+
+39.j/2
+          This heading lists some of the nonsemantic changes between the
+          Ada 83 RM and the Ada 95 RM. It is incomplete; we have not
+          attempted to list all wording changes, but only the
+          "interesting" ones.
+
+39.k/3
+          This is not part of the definition of the language, and does
+          not appear in the Ada 95, Ada 2005, or Ada 2012 RM.
+
+39.l/2
+          Discussion:  
+
+          The next three headings list all language changes between Ada
+          95 and Ada 2005 (the language defined by the Ada 95 standard
+          plus Technical Corrigendum 1 plus Amendment 1).  Each language
+          change falls into one of the following three categories:
+
+                     _Inconsistencies With Ada 95_
+
+39.m/2
+          This heading lists all of the upward inconsistencies between
+          Ada 95 and Ada 2005.  Upward inconsistencies are situations in
+          which a legal Ada 95 program is a legal Ada 2005 program with
+          different semantics.
+
+39.n/3
+          {AI05-0005-1AI05-0005-1} Inconsistencies marked with
+          Corrigendum: are corrections to the original Ada 95 definition
+          introduced by Corrigendum 1.  Inconsistencies marked with
+          Amendment Correction: are corrections to the original Ada 95
+          definition added by Amendment 1.  Formally, these are
+          inconsistencies caused by Ada Issues classified as Binding
+          Interpretations; implementations of Ada 95 are supposed to
+          follow these corrections, not the original flawed language
+          definition.  Thus, these strictly speaking are not
+          inconsistencies between Ada 95 and Ada 2005.  Practically,
+          however, they very well may be, as early Ada 95
+          implementations might not follow the recommendation.
+          Inconsistencies so marked are not portable between Ada 95
+          implementations, while usually Ada 2005 will have more clearly
+          defined behavior.  Therefore, we document these for
+          completeness.
+
+39.o/3
+          This is not part of the definition of the language, and does
+          not appear in the Ada 2005 or Ada 2012 RM.
+
+                    _Incompatibilities With Ada 95_
+
+39.p/2
+          This heading lists all of the upward incompatibilities between
+          Ada 95 and Ada 2005, except for the ones listed under
+          "Inconsistencies With Ada 95" above.  These are the situations
+          in which a legal Ada 95 program is illegal in Ada 2005.
+
+39.q/3
+          {AI05-0005-1AI05-0005-1} As with inconsistencies,
+          incompatibilities marked with Corrigendum: are corrections to
+          the original Ada 95 definition introduced by Corrigendum 1.
+          Incompatibilities marked with Amendment Correction: are
+          corrections to the original Ada 95 definition added by
+          Amendment 1.  Formally, these are incompatibilities caused by
+          Ada Issues classified as Binding Interpretations;
+          implementations of Ada 95 are supposed to follow these
+          corrections, not the original flawed language definition.
+          Thus, these strictly speaking are not incompatibilities
+          between Ada 95 and Ada 2005.  Practically, however, they very
+          well may be, as early Ada 95 implementations might not follow
+          the recommendation.  Therefore, some Ada 95 implementations
+          may be able to compile the examples, while others might not.
+          In contrast, Ada 2005 compilers will have consistent behavior.
+          Therefore, we document these for completeness.
+
+39.r/3
+          This is not part of the definition of the language, and does
+          not appear in the Ada 2005 or Ada 2012 RM.
+
+                        _Extensions to Ada 95_
+
+39.s/2
+          This heading is used to list all upward compatible language
+          changes; that is, language extensions.  These are the
+          situations in which a legal Ada 2005 program is not a legal
+          Ada 95 program.  The vast majority of language changes fall
+          into this category.
+
+39.t/3
+          {AI05-0005-1AI05-0005-1} As with incompatibilities, extensions
+          marked with Corrigendum: are corrections to the original Ada
+          95 definition introduced by Corrigendum 1.  Extensions marked
+          with Amendment Correction: are corrections to the original Ada
+          95 definition added by Amendment 1.  Formally, these are
+          extensions allowed by Ada Issues classified as Binding
+          Interpretations.  As corrections, implementations of Ada 95
+          are allowed to implement these extensions.  Thus, these
+          strictly speaking are not extensions of Ada 95; they're part
+          of Ada 95.  Practically, however, they very well may be
+          extensions, as early Ada 95 implementations might not
+          implement the extension.  Therefore, some Ada 95
+          implementations may be able to compile the examples, while
+          others might not.  In contrast, Ada 2005 compilers will always
+          support the extensions.  Therefore, we document these for
+          completeness.
+
+39.u/3
+          This is not part of the definition of the language, and does
+          not appear in the Ada 2005 or Ada 2012 RM.
+
+39.v/2
+           
+
+          As explained above, the next heading does not represent any
+          language change:
+
+                     _Wording Changes from Ada 95_
+
+39.w/2
+          This heading lists some of the nonsemantic changes between the
+          Ada 95 RM and the Ada 2005 RM. This heading lists only
+          "interesting" changes (for instance, editorial corrections are
+          not listed).  Changes which come from Technical Corrigendum 1
+          are marked Corrigendum; unmarked changes come from Amendment
+          1.
+
+39.x/3
+          This is not part of the definition of the language, and does
+          not appear in the Ada 2005 or Ada 2012 RM.
+
+39.y/3
+          Discussion:  
+
+          The next three headings list all language changes between Ada
+          2005 (the language defined by the Ada 95 standard plus
+          Technical Corrigendum 1 plus Amendment 1) and Ada 2012 (the
+          language defined by the third edition of the Standard).  Each
+          language change falls into one of the following three
+          categories:
+
+                    _Inconsistencies With Ada 2005_
+
+39.z/3
+          This heading lists all of the upward inconsistencies between
+          Ada 2005 and Ada 2012.  Upward inconsistencies are situations
+          in which a legal Ada 2005 program is a legal Ada 2012 program
+          with different semantics.
+
+39.aa/3
+          Inconsistencies marked with Correction: are corrections to the
+          original Ada 2005 definition added by the third edition of the
+          Standard.  Formally, these are inconsistencies caused by Ada
+          Issues classified as Binding Interpretations; implementations
+          of Ada 2005 are supposed to follow these corrections, not the
+          original flawed language definition.  Thus, these strictly
+          speaking are not inconsistencies between Ada 2005 and Ada
+          2012.  Practically, however, they very well may be, as early
+          Ada 2005 implementations might not follow the recommendation.
+          Inconsistencies so marked are not portable between Ada 2005
+          implementations, while usually Ada 2012 will have more clearly
+          defined behavior.  Therefore, we document these for
+          completeness.
+
+39.bb/3
+          This is not part of the definition of the language, and does
+          not appear in the Ada 2012 RM.
+
+                   _Incompatibilities With Ada 2005_
+
+39.cc/3
+          This heading lists all of the upward incompatibilities between
+          Ada 2005 and Ada 2012, except for the ones listed under
+          "Inconsistencies With Ada 2005" above.  These are the
+          situations in which a legal Ada 2005 program is illegal in Ada
+          2012.
+
+39.dd/3
+          As with inconsistencies, incompatibilities marked with
+          Correction: are corrections to the original Ada 2005
+          definition added by the third edition.  Formally, these are
+          incompatibilities caused by Ada Issues classified as Binding
+          Interpretations; implementations of Ada 2005 are supposed to
+          follow these corrections, not the original flawed language
+          definition.  Thus, these strictly speaking are not
+          incompatibilities between Ada 2005 and Ada 2012.  Practically,
+          however, they very well may be, as early Ada 2005
+          implementations might not follow the recommendation.
+          Therefore, some Ada 2005 implementations may be able to
+          compile the examples, while others might not.  In contrast,
+          Ada 2012 compilers will have consistent behavior.  Therefore,
+          we document these for completeness.
+
+39.ee/3
+          This is not part of the definition of the language, and does
+          not appear in the Ada 2012 RM.
+
+                       _Extensions to Ada 2005_
+
+39.ff/3
+          This heading is used to list all upward compatible language
+          changes; that is, language extensions.  These are the
+          situations in which a legal Ada 2012 program is not a legal
+          Ada 2005 program.  The vast majority of language changes fall
+          into this category.
+
+39.gg/3
+          As with incompatibilities, extensions marked with Correction:
+          are corrections to the original Ada 2005 definition added by
+          the third edition.  Formally, these are extensions allowed by
+          Ada Issues classified as Binding Interpretations.  As
+          corrections, implementations of Ada 2005 (and sometimes Ada
+          95) are allowed to implement these extensions.  Thus, these
+          strictly speaking are not extensions of Ada 2005; they're part
+          of Ada 2005.  Practically, however, they very well may be
+          extensions, as early Ada 2005 implementations might not
+          implement the extension.  Therefore, some Ada 2005
+          implementations may be able to compile the examples, while
+          others might not.  In contrast, Ada 2012 compilers will always
+          support the extensions.  Therefore, we document these for
+          completeness.
+
+39.hh/3
+          This is not part of the definition of the language, and does
+          not appear in the Ada 2012 RM.
+
+39.ii/3
+           
+
+          As explained above, the next heading does not represent any
+          language change:
+
+                    _Wording Changes from Ada 2005_
+
+39.jj/3
+          This heading lists some of the nonsemantic changes between the
+          Ada 2005 RM and the Ada 2012 RM. This heading lists only
+          "interesting" changes (for instance, editorial corrections are
+          not listed).  Items marked Correction: come from Ada Issues
+          classified as Binding Interpretations and strictly speaking
+          belong to Ada 2005; other items only belong to Ada 2012.
+
+39.kk/3
+          This is not part of the definition of the language, and does
+          not appear in the Ada 2012 RM.
+
+
+File: aarm2012.info,  Node: 1.1.3,  Next: 1.1.4,  Prev: 1.1.2,  Up: 1.1
+
+1.1.3 Conformity of an Implementation with the Standard
+-------------------------------------------------------
+
+                     _Implementation Requirements_
+
+1
+A conforming implementation shall:
+
+1.a
+          Discussion: The implementation is the software and hardware
+          that implements the language.  This includes compiler, linker,
+          operating system, hardware, etc.
+
+1.b
+          We first define what it means to "conform" in general --
+          basically, the implementation has to properly implement the
+          normative rules given throughout the standard.  Then we define
+          what it means to conform to a Specialized Needs Annex -- the
+          implementation must support the core features plus the
+          features of that Annex.  Finally, we define what it means to
+          "conform to the Standard" -- this requires support for the
+          core language, and allows partial (but not conflicting)
+          support for the Specialized Needs Annexes.
+
+2
+   * Translate and correctly execute legal programs written in Ada,
+     provided that they are not so large as to exceed the capacity of
+     the implementation;
+
+3
+   * Identify all programs or program units that are so large as to
+     exceed the capacity of the implementation (or raise an appropriate
+     exception at run time);
+
+3.a
+          Implementation defined: Capacity limitations of the
+          implementation.
+
+4
+   * Identify all programs or program units that contain errors whose
+     detection is required by this International Standard;
+
+4.a
+          Discussion: Note that we no longer use the term "rejection" of
+          programs or program units.  We require that programs or
+          program units with errors or that exceed some capacity limit
+          be "identified".  The way in which errors or capacity problems
+          are reported is not specified.
+
+4.b
+          An implementation is allowed to use standard error-recovery
+          techniques.  We do not disallow such techniques from being
+          used across compilation_unit or compilation boundaries.
+
+4.c
+          See also the Implementation Requirements of *note 10.2::,
+          which disallow the execution of illegal partitions.
+
+5
+   * Supply all language-defined library units required by this
+     International Standard;
+
+5.a
+          Implementation Note: An implementation cannot add to or modify
+          the visible part of a language-defined library unit, except
+          where such permission is explicitly granted, unless such
+          modifications are semantically neutral with respect to the
+          client compilation units of the library unit.  An
+          implementation defines the contents of the private part and
+          body of language-defined library units.
+
+5.b
+          An implementation can add with_clauses and use_clauses, since
+          these modifications are semantically neutral to clients.  (The
+          implementation might need with_clauses in order to implement
+          the private part, for example.)  Similarly, an implementation
+          can add a private part even in cases where a private part is
+          not shown in the standard.  Explicit declarations can be
+          provided implicitly or by renaming, provided the changes are
+          semantically neutral.
+
+5.c
+          Wherever in the standard the text of a language-defined
+          library unit contains an italicized phrase starting with
+          "implementation-defined", the implementation's version will
+          replace that phrase with some implementation-defined text that
+          is syntactically legal at that place, and follows any other
+          applicable rules.
+
+5.d
+          Note that modifications are permitted, even if there are other
+          tools in the environment that can detect the changes (such as
+          a program library browser), so long as the modifications make
+          no difference with respect to the static or dynamic semantics
+          of the resulting programs, as defined by the standard.
+
+6
+   * Contain no variations except those explicitly permitted by this
+     International Standard, or those that are impossible or impractical
+     to avoid given the implementation's execution environment;
+
+6.a
+          Implementation defined: Variations from the standard that are
+          impractical to avoid given the implementation's execution
+          environment.
+
+6.b
+          Reason: The "impossible or impractical" wording comes from
+          AI-325.  It takes some judgement and common sense to interpret
+          this.  Restricting compilation units to less than 4 lines is
+          probably unreasonable, whereas restricting them to less than 4
+          billion lines is probably reasonable (at least given today's
+          technology).  We do not know exactly where to draw the line,
+          so we have to make the rule vague.
+
+7
+   * Specify all such variations in the manner prescribed by this
+     International Standard.
+
+8
+The external effect of the execution of an Ada program is defined in
+terms of its interactions with its external environment.  The following
+are defined as external interactions:
+
+9
+   * Any interaction with an external file (see *note A.7::);
+
+10
+   * The execution of certain code_statements (see *note 13.8::); which
+     code_statements cause external interactions is implementation
+     defined.
+
+10.a
+          Implementation defined: Which code_statements cause external
+          interactions.
+
+11
+   * Any call on an imported subprogram (see *note Annex B::), including
+     any parameters passed to it;
+
+12
+   * Any result returned or exception propagated from a main subprogram
+     (see *note 10.2::) or an exported subprogram (see *note Annex B::)
+     to an external caller;
+
+12.a
+          Discussion: By "result returned" we mean to include function
+          results and values returned in [in] out parameters.
+
+12.a.1/1
+          {8652/00948652/0094} {AI95-00119-01AI95-00119-01} The lack of
+          a result from a program that does not terminate is also
+          included here.
+
+13
+   * [Any read or update of an atomic or volatile object (see *note
+     C.6::);]
+
+14
+   * The values of imported and exported objects (see *note Annex B::)
+     at the time of any other interaction with the external environment.
+
+14.a/3
+          To be honest: {AI05-0229-1AI05-0229-1} Also other uses of
+          imported and exported entities, as defined by the
+          implementation, if the implementation supports such importing
+          or exporting.
+
+15
+A conforming implementation of this International Standard shall produce
+for the execution of a given Ada program a set of interactions with the
+external environment whose order and timing are consistent with the
+definitions and requirements of this International Standard for the
+semantics of the given program.
+
+15.a
+          Ramification: There is no need to produce any of the "internal
+          effects" defined for the semantics of the program -- all of
+          these can be optimized away -- so long as an appropriate
+          sequence of external interactions is produced.
+
+15.b
+          Discussion: See also *note 11.6:: which specifies various
+          liberties associated with optimizations in the presence of
+          language-defined checks, that could change the external
+          effects that might be produced.  These alternative external
+          effects are still consistent with the standard, since *note
+          11.6:: is part of the standard.
+
+15.c
+          Note also that we only require "an appropriate sequence of
+          external interactions" rather than "the same sequence..."  An
+          optimizer may cause a different sequence of external
+          interactions to be produced than would be produced without the
+          optimizer, so long as the new sequence still satisfies the
+          requirements of the standard.  For example, optimization might
+          affect the relative rate of progress of two concurrent tasks,
+          thereby altering the order in which two external interactions
+          occur.
+
+15.d/2
+          Note that the Ada 83 RM explicitly mentions the case of an
+          "exact effect" of a program, but since so few programs have
+          their effects defined that exactly, we don't even mention this
+          "special" case.  In particular, almost any program that uses
+          floating point or tasking has to have some level of
+          inexactness in the specification of its effects.  And if one
+          includes aspects of the timing of the external interactions in
+          the external effect of the program (as is appropriate for a
+          real-time language), no "exact effect" can be specified.  For
+          example, if two external interactions initiated by a single
+          task are separated by a "delay 1.0;" then the language rules
+          imply that the two external interactions have to be separated
+          in time by at least one second, as defined by the clock
+          associated with the delay_relative_statement.  This in turn
+          implies that the time at which an external interaction occurs
+          is part of the characterization of the external interaction,
+          at least in some cases, again making the specification of the
+          required "exact effect" impractical.
+
+16
+An implementation that conforms to this Standard shall support each
+capability required by the core language as specified.  In addition, an
+implementation that conforms to this Standard may conform to one or more
+Specialized Needs Annexes (or to none).  Conformance to a Specialized
+Needs Annex means that each capability required by the Annex is provided
+as specified.
+
+16.a
+          Discussion: The last sentence defines what it means to say
+          that an implementation conforms to a Specialized Needs Annex,
+          namely, only by supporting all capabilities required by the
+          Annex.
+
+17/3
+{AI05-0229-1AI05-0229-1} An implementation conforming to this
+International Standard may provide additional aspects, attributes,
+library units, and pragmas.  However, it shall not provide any aspect,
+attribute, library unit, or pragma having the same name as an aspect,
+attribute, library unit, or pragma (respectively) specified in a
+Specialized Needs Annex unless the provided construct is either as
+specified in the Specialized Needs Annex or is more limited in
+capability than that required by the Annex.  A program that attempts to
+use an unsupported capability of an Annex shall either be identified by
+the implementation before run time or shall raise an exception at run
+time.
+
+17.a
+          Discussion: The last sentence of the preceding paragraph
+          defines what an implementation is allowed to do when it does
+          not "conform" to a Specialized Needs Annex.  In particular,
+          the sentence forbids implementations from providing a
+          construct with the same name as a corresponding construct in a
+          Specialized Needs Annex but with a different syntax (e.g., an
+          extended syntax) or quite different semantics.  The phrase
+          concerning "more limited in capability" is intended to give
+          permission to provide a partial implementation, such as not
+          implementing a subprogram in a package or having a restriction
+          not permitted by an implementation that conforms to the Annex.
+          For example, a partial implementation of the package
+          Ada.Decimal might have Decimal.Max_Decimal_Digits as 15
+          (rather than the required 18).  This allows a partial
+          implementation to grow to a fully conforming implementation.
+
+17.b
+          A restricted implementation might be restricted by not
+          providing some subprograms specified in one of the packages
+          defined by an Annex.  In this case, a program that tries to
+          use the missing subprogram will usually fail to compile.
+          Alternatively, the implementation might declare the subprogram
+          as abstract, so it cannot be called.  Alternatively, a
+          subprogram body might be implemented just to raise
+          Program_Error.  The advantage of this approach is that a
+          program to be run under a fully conforming Annex
+          implementation can be checked syntactically and semantically
+          under an implementation that only partially supports the
+          Annex.  Finally, an implementation might provide a package
+          declaration without the corresponding body, so that programs
+          can be compiled, but partitions cannot be built and executed.
+
+17.c
+          To ensure against wrong answers being delivered by a partial
+          implementation, implementers are required to raise an
+          exception when a program attempts to use an unsupported
+          capability and this can be detected only at run time.  For
+          example, a partial implementation of Ada.Decimal might require
+          the length of the Currency string to be 1, and hence, an
+          exception would be raised if a subprogram were called in the
+          package Edited_Output with a length greater than 1.
+
+                     _Documentation Requirements_
+
+18
+Certain aspects of the semantics are defined to be either implementation
+defined or unspecified.  In such cases, the set of possible effects is
+specified, and the implementation may choose any effect in the set.
+Implementations shall document their behavior in implementation-defined
+situations, but documentation is not required for unspecified
+situations.  The implementation-defined characteristics are summarized
+in *note M.2::.
+
+18.a
+          Discussion: We used to use the term "implementation dependent"
+          instead of "unspecified".  However, that sounded too much like
+          "implementation defined".  Furthermore, the term "unspecified"
+          is used in the ANSI C and POSIX standards for this purpose, so
+          that is another advantage.  We also use "not specified" and
+          "not specified by the language" as synonyms for "unspecified."
+          The documentation requirement is the only difference between
+          implementation defined and unspecified.
+
+18.b
+          Note that the "set of possible effects" can be "all imaginable
+          effects", as is the case with erroneous execution.
+
+19
+The implementation may choose to document implementation-defined
+behavior either by documenting what happens in general, or by providing
+some mechanism for the user to determine what happens in a particular
+case.
+
+19.a
+          Discussion: For example, if the standard says that library
+          unit elaboration order is implementation defined, the
+          implementation might describe (in its user's manual) the
+          algorithm it uses to determine the elaboration order.  On the
+          other hand, the implementation might provide a command that
+          produces a description of the elaboration order for a
+          partition upon request from the user.  It is also acceptable
+          to provide cross references to existing documentation (for
+          example, a hardware manual), where appropriate.
+
+19.b
+          Note that dependence of a program on implementation-defined or
+          unspecified functionality is not defined to be an error; it
+          might cause the program to be less portable, however.
+
+19.c/2
+          Documentation Requirement: The behavior of implementations in
+          implementation-defined situations shall be documented -- see
+          *note M.2::, "*note M.2:: Implementation-Defined
+          Characteristics" for a listing.
+
+                        _Implementation Advice_
+
+20
+If an implementation detects the use of an unsupported Specialized Needs
+Annex feature at run time, it should raise Program_Error if feasible.
+
+20.a.1/2
+          Implementation Advice: Program_Error should be raised when an
+          unsupported Specialized Needs Annex feature is used at run
+          time.
+
+20.a
+          Reason: The reason we don't require Program_Error is that
+          there are situations where other exceptions might make sense.
+          For example, if the Real Time Systems Annex requires that the
+          range of System.Priority include at least 30 values, an
+          implementation could conform to the Standard (but not to the
+          Annex) if it supported only 12 values.  Since the rules of the
+          language require Constraint_Error to be raised for
+          out-of-range values, we cannot require Program_Error to be
+          raised instead.
+
+21
+If an implementation wishes to provide implementation-defined extensions
+to the functionality of a language-defined library unit, it should
+normally do so by adding children to the library unit.
+
+21.a.1/2
+          Implementation Advice: Implementation-defined extensions to
+          the functionality of a language-defined library unit should be
+          provided by adding children to the library unit.
+
+21.a
+          Implementation Note: If an implementation has support code
+          ("run-time system code") that is needed for the execution of
+          user-defined code, it can put that support code in child
+          packages of System.  Otherwise, it has to use some trick to
+          avoid polluting the user's namespace.  It is important that
+          such tricks not be available to user-defined code (not in the
+          standard mode, at least) -- that would defeat the purpose.
+
+     NOTES
+
+22
+     2  The above requirements imply that an implementation conforming
+     to this Standard may support some of the capabilities required by a
+     Specialized Needs Annex without supporting all required
+     capabilities.
+
+22.a
+          Discussion: A conforming implementation can partially support
+          a Specialized Needs Annex.  Such an implementation does not
+          conform to the Annex, but it does conform to the Standard.
+
+
+File: aarm2012.info,  Node: 1.1.4,  Next: 1.1.5,  Prev: 1.1.3,  Up: 1.1
+
+1.1.4 Method of Description and Syntax Notation
+-----------------------------------------------
+
+1
+The form of an Ada program is described by means of a context-free
+syntax together with context-dependent requirements expressed by
+narrative rules.
+
+2
+The meaning of Ada programs is described by means of narrative rules
+defining both the effects of each construct and the composition rules
+for constructs.
+
+3
+The context-free syntax of the language is described using a simple
+variant of Backus-Naur Form.  In particular:
+
+4
+   * Lower case words in a sans-serif font, some containing embedded
+     underlines, are used to denote syntactic categories, for example:
+
+5
+          case_statement
+
+6
+   * Boldface words are used to denote reserved words, for example:
+
+7
+          array
+
+8
+   * Square brackets enclose optional items.  Thus the two following
+     rules are equivalent.
+
+9/2
+          {AI95-00433-01AI95-00433-01}
+          simple_return_statement ::= return [expression];
+          simple_return_statement ::= return; | return expression;
+
+10
+   * Curly brackets enclose a repeated item.  The item may appear zero
+     or more times; the repetitions occur from left to right as with an
+     equivalent left-recursive rule.  Thus the two following rules are
+     equivalent.
+
+11
+          term ::= factor {multiplying_operator factor}
+          term ::= factor | term multiplying_operator factor
+
+12
+   * A vertical line separates alternative items unless it occurs
+     immediately after an opening curly bracket, in which case it stands
+     for itself:
+
+13
+          constraint ::= scalar_constraint | composite_constraint
+          discrete_choice_list ::= discrete_choice {| discrete_choice}
+
+14
+   * If the name of any syntactic category starts with an italicized
+     part, it is equivalent to the category name without the italicized
+     part.  The italicized part is intended to convey some semantic
+     information.  For example subtype_name and task_name are both
+     equivalent to name alone.
+
+14.a
+          Discussion: The grammar given in this International Standard
+          is not LR(1).  In fact, it is ambiguous; the ambiguities are
+          resolved by the overload resolution rules (see *note 8.6::).
+
+14.b
+          We often use "if" to mean "if and only if" in definitions.
+          For example, if we define "photogenic" by saying, "A type is
+          photogenic if it has the following properties...," we mean
+          that a type is photogenic if and only if it has those
+          properties.  It is usually clear from the context, and adding
+          the "and only if" seems too cumbersome.
+
+14.c
+          When we say, for example, "a declarative_item of a
+          declarative_part", we are talking about a declarative_item
+          immediately within that declarative_part.  When we say "a
+          declarative_item in, or within, a declarative_part", we are
+          talking about a declarative_item anywhere in the
+          declarative_part, possibly deeply nested within other
+          declarative_parts.  (This notation doesn't work very well for
+          names, since the name "of" something also has another
+          meaning.)
+
+14.d
+          When we refer to the name of a language-defined entity (for
+          example, Duration), we mean the language-defined entity even
+          in programs where the declaration of the language-defined
+          entity is hidden by another declaration.  For example, when we
+          say that the expected type for the expression of a
+          delay_relative_statement is Duration, we mean the
+          language-defined type Duration that is declared in Standard,
+          not some type Duration the user might have declared.
+
+14.1/3
+{AI95-00285-01AI95-00285-01} {AI05-0004-1AI05-0004-1}
+{AI05-0262-1AI05-0262-1} The delimiters, compound delimiters, reserved
+words, and numeric_literals are exclusively made of the characters whose
+code point is between 16#20# and 16#7E#, inclusively.  The special
+characters for which names are defined in this International Standard
+(see *note 2.1::) belong to the same range.  [For example, the character
+E in the definition of exponent is the character whose name is "LATIN
+CAPITAL LETTER E", not "GREEK CAPITAL LETTER EPSILON".]
+
+14.e/2
+          Discussion: This just means that programs can be written in
+          plain ASCII characters; no characters outside of the 7-bit
+          range are required.
+
+14.2/3
+{AI95-00395-01AI95-00395-01} {AI05-0227-1AI05-0227-1}
+{AI05-0299-1AI05-0299-1} When this International Standard mentions the
+conversion of some character or sequence of characters to upper case, it
+means the character or sequence of characters obtained by using simple
+upper case mapping, as defined by documents referenced in the note in
+Clause 1 of ISO/IEC 10646:2011.
+
+14.e.1/3
+          This paragraph was deleted.
+
+15
+A syntactic category is a nonterminal in the grammar defined in BNF
+under "Syntax."  Names of syntactic categories are set in a different
+font, like_this.
+
+16
+A construct is a piece of text (explicit or implicit) that is an
+instance of a syntactic category defined under "Syntax".
+
+16.a
+          Ramification: For example, an expression is a construct.  A
+          declaration is a construct, whereas the thing declared by a
+          declaration is an "entity."
+
+16.b
+          Discussion: "Explicit" and "implicit" don't mean exactly what
+          you might think they mean: The text of an instance of a
+          generic is considered explicit, even though it does not appear
+          explicitly (in the nontechnical sense) in the program text,
+          and even though its meaning is not defined entirely in terms
+          of that text.
+
+17
+A constituent of a construct is the construct itself, or any construct
+appearing within it.
+
+18
+Whenever the run-time semantics defines certain actions to happen in an
+arbitrary order, this means that the implementation shall arrange for
+these actions to occur in a way that is equivalent to some sequential
+order, following the rules that result from that sequential order.  When
+evaluations are defined to happen in an arbitrary order, with conversion
+of the results to some subtypes, or with some run-time checks, the
+evaluations, conversions, and checks may be arbitrarily interspersed, so
+long as each expression is evaluated before converting or checking its
+value.  [Note that the effect of a program can depend on the order
+chosen by the implementation.  This can happen, for example, if two
+actual parameters of a given call have side effects.]
+
+18.a
+          Discussion: Programs will be more portable if their external
+          effect does not depend on the particular order chosen by an
+          implementation.
+
+18.b
+          Ramification: Additional reordering permissions are given in
+          *note 11.6::, "*note 11.6:: Exceptions and Optimization".
+
+18.c
+          There is no requirement that the implementation always choose
+          the same order in a given kind of situation.  In fact, the
+          implementation is allowed to choose a different order for two
+          different executions of the same construct.  However, we
+          expect most implementations will behave in a relatively
+          predictable manner in most situations.
+
+18.d
+          Reason: The "sequential order" wording is intended to allow
+          the programmer to rely on "benign" side effects.  For example,
+          if F is a function that returns a unique integer by
+          incrementing some global and returning the result, a call such
+          as P(F, F) is OK if the programmer cares only that the two
+          results of F are unique; the two calls of F cannot be executed
+          in parallel, unless the compiler can prove that parallel
+          execution is equivalent to some sequential order.
+
+     NOTES
+
+19
+     3  The syntax rules describing structured constructs are presented
+     in a form that corresponds to the recommended paragraphing.  For
+     example, an if_statement is defined as:
+
+20
+          if_statement ::=
+              if condition then
+                sequence_of_statements
+             {elsif condition then
+                sequence_of_statements}
+             [else
+                sequence_of_statements]
+              end if;
+
+21
+     4  The line breaks and indentation in the syntax rules indicate the
+     recommended line breaks and indentation in the corresponding
+     constructs.  The preferred places for other line breaks are after
+     semicolons.
+
+                     _Wording Changes from Ada 95_
+
+21.a/2
+          {AI95-00285-01AI95-00285-01} We now explicitly say that the
+          lexical elements of the language (with a few exceptions) are
+          made up of characters in the lower half of the Latin-1
+          character set.  This is needed to avoid confusion given the
+          new capability to use most ISO 10646 characters in identifiers
+          and strings.
+
+21.b/2
+          {AI95-00395-01AI95-00395-01} We now explicitly define what the
+          Standard means by upper case, as there are many possibilities
+          for ISO 10646 characters.
+
+21.c/2
+          {AI95-00433-01AI95-00433-01} The example for square brackets
+          has been changed as there is no longer a return_statement
+          syntax rule.
+
+                    _Wording Changes from Ada 2005_
+
+21.d/3
+          {AI05-0227-1AI05-0227-1} Correction: Upper case is defined by
+          "simple upper case mapping", because "full case folding" is a
+          mapping (mostly) to lower case.
+
+
+File: aarm2012.info,  Node: 1.1.5,  Prev: 1.1.4,  Up: 1.1
+
+1.1.5 Classification of Errors
+------------------------------
+
+                     _Implementation Requirements_
+
+1
+The language definition classifies errors into several different
+categories:
+
+2
+   * Errors that are required to be detected prior to run time by every
+     Ada implementation;
+
+3
+     These errors correspond to any violation of a rule given in this
+     International Standard, other than those listed below.  In
+     particular, violation of any rule that uses the terms shall,
+     allowed, permitted, legal, or illegal belongs to this category.
+     Any program that contains such an error is not a legal Ada program;
+     on the other hand, the fact that a program is legal does not mean,
+     per se, that the program is free from other forms of error.
+
+4
+     The rules are further classified as either compile time rules, or
+     post compilation rules, depending on whether a violation has to be
+     detected at the time a compilation unit is submitted to the
+     compiler, or may be postponed until the time a compilation unit is
+     incorporated into a partition of a program.
+
+4.a
+          Ramification: See, for example, *note 10.1.3::, "*note
+          10.1.3:: Subunits of Compilation Units", for some errors that
+          are detected only after compilation.  Implementations are
+          allowed, but not required, to detect post compilation rules at
+          compile time when possible.
+
+5
+   * Errors that are required to be detected at run time by the
+     execution of an Ada program;
+
+6
+     The corresponding error situations are associated with the names of
+     the predefined exceptions.  Every Ada compiler is required to
+     generate code that raises the corresponding exception if such an
+     error situation arises during program execution.  [If such an error
+     situation is certain to arise in every execution of a construct,
+     then an implementation is allowed (although not required) to report
+     this fact at compilation time.]
+
+7
+   * Bounded errors;
+
+8
+     The language rules define certain kinds of errors that need not be
+     detected either prior to or during run time, but if not detected,
+     the range of possible effects shall be bounded.  The errors of this
+     category are called bounded errors.  The possible effects of a
+     given bounded error are specified for each such error, but in any
+     case one possible effect of a bounded error is the raising of the
+     exception Program_Error.
+
+9
+   * Erroneous execution.
+
+10
+     In addition to bounded errors, the language rules define certain
+     kinds of errors as leading to erroneous execution.  Like bounded
+     errors, the implementation need not detect such errors either prior
+     to or during run time.  Unlike bounded errors, there is no
+     language-specified bound on the possible effect of erroneous
+     execution; the effect is in general not predictable.
+
+10.a
+          Ramification: Executions are erroneous, not programs or parts
+          of programs.  Once something erroneous happens, the execution
+          of the entire program is erroneous from that point on, and
+          potentially before given possible reorderings permitted by
+          *note 11.6:: and elsewhere.  We cannot limit it to just one
+          partition, since partitions are not required to live in
+          separate address spaces.  (But implementations are encouraged
+          to limit it as much as possible.)
+
+10.b
+          Suppose a program contains a pair of things that will be
+          executed "in an arbitrary order."  It is possible that one
+          order will result in something sensible, whereas the other
+          order will result in erroneous execution.  If the
+          implementation happens to choose the first order, then the
+          execution is not erroneous.  This may seem odd, but it is not
+          harmful.
+
+10.c
+          Saying that something is erroneous is semantically equivalent
+          to saying that the behavior is unspecified.  However,
+          "erroneous" has a slightly more disapproving flavor.
+
+                     _Implementation Permissions_
+
+11
+[ An implementation may provide nonstandard modes of operation.
+Typically these modes would be selected by a pragma or by a command line
+switch when the compiler is invoked.  When operating in a nonstandard
+mode, the implementation may reject compilation_units that do not
+conform to additional requirements associated with the mode, such as an
+excessive number of warnings or violation of coding style guidelines.
+Similarly, in a nonstandard mode, the implementation may apply special
+optimizations or alternative algorithms that are only meaningful for
+programs that satisfy certain criteria specified by the implementation.  
+In any case, an implementation shall support a standard mode that
+conforms to the requirements of this International Standard; in
+particular, in the standard mode, all legal compilation_units shall be
+accepted.]
+
+11.a
+          Discussion: These permissions are designed to authorize
+          explicitly the support for alternative modes.  Of course,
+          nothing we say can prevent them anyway, but this (redundant)
+          paragraph is designed to indicate that such alternative modes
+          are in some sense "approved" and even encouraged where they
+          serve the specialized needs of a given user community, so long
+          as the standard mode, designed to foster maximum portability,
+          is always available.
+
+                        _Implementation Advice_
+
+12
+If an implementation detects a bounded error or erroneous execution, it
+should raise Program_Error.
+
+12.a.1/2
+          Implementation Advice: If a bounded error or erroneous
+          execution is detected, Program_Error should be raised.
+
+                     _Wording Changes from Ada 83_
+
+12.a
+          Some situations that are erroneous in Ada 83 are no longer
+          errors at all.  For example, depending on the parameter
+          passing mechanism when unspecified is possibly nonportable,
+          but not erroneous.
+
+12.b
+          Other situations that are erroneous in Ada 83 are changed to
+          be bounded errors.  In particular, evaluating an uninitialized
+          scalar variable is a bounded error.  The possible results are
+          to raise Program_Error (as always), or to produce a
+          machine-representable value (which might not be in the subtype
+          of the variable).  Violating a Range_Check or Overflow_Check
+          raises Constraint_Error, even if the value came from an
+          uninitialized variable.  This means that optimizers can no
+          longer "assume" that all variables are initialized within
+          their subtype's range.  Violating a check that is suppressed
+          remains erroneous.
+
+12.c
+          The "incorrect order dependences" category of errors is
+          removed.  All such situations are simply considered potential
+          nonportabilities.  This category was removed due to the
+          difficulty of defining what it means for two executions to
+          have a "different effect."  For example, if a function with a
+          side effect is called twice in a single expression, it is not
+          in principle possible for the compiler to decide whether the
+          correctness of the resulting program depends on the order of
+          execution of the two function calls.  A compile time warning
+          might be appropriate, but raising of Program_Error at run time
+          would not be.
+
+
+File: aarm2012.info,  Node: 1.2,  Next: 1.3,  Prev: 1.1,  Up: 1
+
+1.2 Normative References
+========================
+
+1/3
+{AI05-0299-1AI05-0299-1} The following documents, in whole or in part,
+are normatively referenced in this document and are indispensable for
+its application.  For dated references, only the edition cited applies.
+For undated references, the latest edition of the referenced document
+(including any amendments) applies.
+
+1.1/3
+{AI05-0127-2AI05-0127-2} {AI05-0299-1AI05-0299-1} ISO 639-3:2007, Codes
+for the representation of names of languages -- Part 3: Alpha-3 code for
+comprehensive coverage of languages.
+
+2
+ISO/IEC 646:1991, Information technology -- ISO 7-bit coded character
+set for information interchange.
+
+3/2
+{AI95-00415-01AI95-00415-01} ISO/IEC 1539-1:2004, Information technology
+-- Programming languages -- Fortran -- Part 1: Base language.
+
+4/2
+{AI95-00415-01AI95-00415-01} ISO/IEC 1989:2002, Information technology
+-- Programming languages -- COBOL.
+
+4.1/3
+{AI05-0127-2AI05-0127-2} {AI05-0299-1AI05-0299-1} ISO/IEC 3166-1:2006,
+Codes for the representation of names of countries and their
+subdivisions -- Part 1: Country Codes.
+
+5
+ISO/IEC 6429:1992, Information technology -- Control functions for coded
+graphic character sets.
+
+5.1/2
+{AI95-00351-01AI95-00351-01} ISO 8601:2004, Data elements and
+interchange formats -- Information interchange -- Representation of
+dates and times.
+
+6/3
+{AI05-0299-1AI05-0299-1} ISO/IEC 8859-1:1998, Information technology --
+8-bit single-byte coded graphic character sets -- Part 1: Latin alphabet
+No.  1.
+
+7/3
+{AI95-00415-01AI95-00415-01} {AI05-0266-1AI05-0266-1} ISO/IEC 9899:2011,
+Information technology -- Programming languages -- C.
+
+8/3
+{8652/00018652/0001} {AI95-00124-01AI95-00124-01}
+{AI95-00285-01AI95-00285-01} {AI05-0266-1AI05-0266-1} ISO/IEC
+10646:2011, Information technology -- Universal Multiple-Octet Coded
+Character Set (UCS).
+
+8.a.1/2
+          This paragraph was deleted.{8652/00018652/0001}
+          {AI95-00124-01AI95-00124-01} {AI95-00285-01AI95-00285-01}
+
+9/3
+{AI95-00376-01AI95-00376-01} {AI05-0266-1AI05-0266-1} ISO/IEC
+14882:2011, Information technology -- Programming languages -- C++.
+
+10/2
+{AI95-00285-01AI95-00285-01} ISO/IEC TR 19769:2004, Information
+technology -- Programming languages, their environments and system
+software interfaces -- Extensions for the programming language C to
+support new character data types.
+
+10.a
+          Discussion: POSIX, Portable Operating System Interface (POSIX)
+          -- Part 1: System Application Program Interface (API) [C
+          Language], The Institute of Electrical and Electronics
+          Engineers, 1990.
+
+                     _Wording Changes from Ada 95_
+
+10.b/2
+          {AI95-00285-01AI95-00285-01} {AI95-00376-01AI95-00376-01}
+          {AI95-00415-01AI95-00415-01} Updated references to the most
+          recent versions of these standards.  Added C++ and time
+          standards.  Added C character set technical report.
+
+                    _Wording Changes from Ada 2005_
+
+10.c/3
+          {AI05-0127-2AI05-0127-2} Added language and country code
+          standards for locale support.
+
+10.d/3
+          {AI05-0266-1AI05-0266-1} Updated references to the most recent
+          versions of these standards.
+
+
+File: aarm2012.info,  Node: 1.3,  Prev: 1.2,  Up: 1
+
+1.3 Terms and Definitions
+=========================
+
+1/2
+{AI95-00415-01AI95-00415-01} Terms are defined throughout this
+International Standard, indicated by italic type.  Terms explicitly
+defined in this International Standard are not to be presumed to refer
+implicitly to similar terms defined elsewhere.  Mathematical terms not
+defined in this International Standard are to be interpreted according
+to the CRC Concise Encyclopedia of Mathematics, Second Edition.  Other
+terms not defined in this International Standard are to be interpreted
+according to the Webster's Third New International Dictionary of the
+English Language.  Informal descriptions of some terms are also given in
+*note Annex N::, "*note Annex N:: Glossary".  
+
+1.a
+          Discussion: The index contains an entry for every defined
+          term.
+
+1.a.1/2
+          {AI95-00415-01AI95-00415-01} The contents of the CRC Concise
+          Encyclopedia of Mathematics, Second Edition can be accessed on
+          http://www.mathworld.com (http://www.mathworld.com).  The ISBN
+          number of the book is ISBN 1584883472.
+
+1.b
+          Glossary entry: Each term defined in *note Annex N:: is marked
+          like this.
+
+1.c/3
+          Discussion: Here are some AARM-only definitions: The Ada
+          Rapporteur Group (ARG) interprets the Ada Reference Manual.  
+          An Ada Issue (AI) is a numbered ruling from the ARG. Ada
+          Issues created for Ada 83 are denoted as "AI83", while Ada
+          Issues created for Ada 95 are denoted as "AI95" in this
+          document.  Similarly, Ada Issues created for Ada 2005 are
+          denoted as "AI05" The Ada Commentary Integration Document
+          (ACID) is an edition of the Ada 83 RM in which clearly marked
+          insertions and deletions indicate the effect of integrating
+          the approved AIs.  The Uniformity Rapporteur Group (URG)
+          issued recommendations intended to increase uniformity across
+          Ada implementations.  The functions of the URG have been
+          assumed by the ARG. A Uniformity Issue (UI) was a numbered
+          recommendation from the URG. A Defect Report and Response is
+          an official query to WG9 about an error in the standard.
+          Defect Reports are processed by the ARG, and are referenced
+          here by their ISO numbers: 8652/nnnn.  Most changes to the Ada
+          95 standard include reference(s) to the Defect Report(s) that
+          prompted the change.  The Ada Conformity Assessment Test Suite
+          (ACATS) is a set of tests intended to check the conformity of
+          Ada implementations to this standard.  This set of tests was
+          previously known as the Ada Compiler Validation Capability
+          (ACVC).
+
+
+File: aarm2012.info,  Node: 2,  Next: 3,  Prev: 1,  Up: Top
+
+2 Lexical Elements
+******************
+
+1/3
+{AI05-0299-1AI05-0299-1} [The text of a program consists of the texts of
+one or more compilations.  The text of a compilation is a sequence of
+lexical elements, each composed of characters; the rules of composition
+are given in this clause.  Pragmas, which provide certain information
+for the compiler, are also described in this clause.]
+
+* Menu:
+
+* 2.1 ::      Character Set
+* 2.2 ::      Lexical Elements, Separators, and Delimiters
+* 2.3 ::      Identifiers
+* 2.4 ::      Numeric Literals
+* 2.5 ::      Character Literals
+* 2.6 ::      String Literals
+* 2.7 ::      Comments
+* 2.8 ::      Pragmas
+* 2.9 ::      Reserved Words
+
+
+File: aarm2012.info,  Node: 2.1,  Next: 2.2,  Up: 2
+
+2.1 Character Set
+=================
+
+1/3
+{AI95-00285-01AI95-00285-01} {AI95-00395-01AI95-00395-01}
+{AI05-0266-1AI05-0266-1} The character repertoire for the text of an Ada
+program consists of the entire coding space described by the ISO/IEC
+10646:2011 Universal Multiple-Octet Coded Character Set.  This coding
+space is organized in planes, each plane comprising 65536 characters.  
+
+1.a/2
+          This paragraph was deleted.{AI95-00285-01AI95-00285-01}
+
+1.b/2
+          This paragraph was deleted.{AI95-00285-01AI95-00285-01}
+
+1.c/3
+          Discussion: {AI95-00285-01AI95-00285-01}
+          {AI05-0266-1AI05-0266-1} It is our intent to follow the
+          terminology of ISO/IEC 10646:2011 where appropriate, and to
+          remain compatible with the character classifications defined
+          in *note A.3::, "*note A.3:: Character Handling".
+
+                               _Syntax_
+
+     Paragraphs 2 and 3 were deleted.
+
+3.1/3
+     {AI95-00285-01AI95-00285-01} {AI95-00395-01AI95-00395-01}
+     {AI05-0266-1AI05-0266-1} A character is defined by this
+     International Standard for each cell in the coding space described
+     by ISO/IEC 10646:2011, regardless of whether or not ISO/IEC
+     10646:2011 allocates a character to that cell.
+
+                          _Static Semantics_
+
+4/3
+{AI95-00285-01AI95-00285-01} {AI95-00395-01AI95-00395-01}
+{AI05-0079-1AI05-0079-1} {AI05-0262-1AI05-0262-1}
+{AI05-0266-1AI05-0266-1} The coded representation for characters is
+implementation defined [(it need not be a representation defined within
+ISO/IEC 10646:2011)].  A character whose relative code point in its
+plane is 16#FFFE# or 16#FFFF# is not allowed anywhere in the text of a
+program.  The only characters allowed outside of comments are those in
+categories other_format, format_effector, and graphic_character.
+
+4.a
+          Implementation defined: The coded representation for the text
+          of an Ada program.
+
+4.b/2
+          Ramification: {AI95-00285-01AI95-00285-01} Note that this rule
+          doesn't really have much force, since the implementation can
+          represent characters in the source in any way it sees fit.
+          For example, an implementation could simply define that what
+          seems to be an other_private_use character is actually a
+          representation of the space character.
+
+4.1/3
+{AI95-00285-01AI95-00285-01} {AI05-0266-1AI05-0266-1}
+{AI05-0299-1AI05-0299-1} The semantics of an Ada program whose text is
+not in Normalization Form KC (as defined by Clause 21 of ISO/IEC
+10646:2011) is implementation defined.
+
+4.c/2
+          Implementation defined: The semantics of an Ada program whose
+          text is not in Normalization Form KC.
+
+5/3
+{AI95-00285-01AI95-00285-01} {AI05-0266-1AI05-0266-1}
+{AI05-0299-1AI05-0299-1} The description of the language definition in
+this International Standard uses the character properties General
+Category, Simple Uppercase Mapping, Uppercase Mapping, and Special Case
+Condition of the documents referenced by the note in Clause 1 of ISO/IEC
+10646:2011.  The actual set of graphic symbols used by an implementation
+for the visual representation of the text of an Ada program is not
+specified.  
+
+6/3
+{AI95-00285-01AI95-00285-01} {AI05-0266-1AI05-0266-1} Characters are
+categorized as follows:
+
+6.a/3
+          Discussion: {AI05-0005-1AI05-0005-1} {AI05-0262-1AI05-0262-1}
+          {AI05-0266-1AI05-0266-1} Our character classification
+          considers that the cells not allocated in ISO/IEC 10646:2011
+          are graphic characters, except for those whose relative code
+          point in their plane is 16#FFFE# or 16#FFFF#.  This seems to
+          provide the best compatibility with future versions of ISO/IEC
+          10646, as future characters can already be used in Ada
+          character and string literals.
+
+7/2
+
+               This paragraph was deleted.{AI95-00285-01AI95-00285-01}
+
+8/2
+{AI95-00285-01AI95-00285-01} letter_uppercase
+               Any character whose General Category is defined to be
+               "Letter, Uppercase".
+
+9/2
+{AI95-00285-01AI95-00285-01} letter_lowercase
+               Any character whose General Category is defined to be
+               "Letter, Lowercase".
+
+9.a/1
+          This paragraph was deleted.{8652/00018652/0001}
+          {AI95-00124-01AI95-00124-01}
+
+9.1/2
+{AI95-00285-01AI95-00285-01} letter_titlecase
+               Any character whose General Category is defined to be
+               "Letter, Titlecase".
+
+9.2/2
+{AI95-00285-01AI95-00285-01} letter_modifier
+               Any character whose General Category is defined to be
+               "Letter, Modifier".
+
+9.3/2
+{AI95-00285-01AI95-00285-01} letter_other
+               Any character whose General Category is defined to be
+               "Letter, Other".
+
+9.4/2
+{AI95-00285-01AI95-00285-01} mark_non_spacing
+               Any character whose General Category is defined to be
+               "Mark, Non-Spacing".
+
+9.5/2
+{AI95-00285-01AI95-00285-01} mark_spacing_combining
+               Any character whose General Category is defined to be
+               "Mark, Spacing Combining".
+
+10/2
+{AI95-00285-01AI95-00285-01} number_decimal
+               Any character whose General Category is defined to be
+               "Number, Decimal".
+
+10.1/2
+{AI95-00285-01AI95-00285-01} number_letter
+               Any character whose General Category is defined to be
+               "Number, Letter".
+
+10.2/2
+{AI95-00285-01AI95-00285-01} punctuation_connector
+               Any character whose General Category is defined to be
+               "Punctuation, Connector".
+
+10.3/2
+{AI95-00285-01AI95-00285-01} other_format
+               Any character whose General Category is defined to be
+               "Other, Format".
+
+11/2
+{AI95-00285-01AI95-00285-01} separator_space
+               Any character whose General Category is defined to be
+               "Separator, Space".
+
+12/2
+{AI95-00285-01AI95-00285-01} separator_line
+               Any character whose General Category is defined to be
+               "Separator, Line".
+
+12.1/2
+{AI95-00285-01AI95-00285-01} separator_paragraph
+               Any character whose General Category is defined to be
+               "Separator, Paragraph".
+
+13/3
+{AI95-00285-01AI95-00285-01} {AI05-0262-1AI05-0262-1} format_effector
+               The characters whose code points are 16#09# (CHARACTER
+               TABULATION), 16#0A# (LINE FEED), 16#0B# (LINE
+               TABULATION), 16#0C# (FORM FEED), 16#0D# (CARRIAGE
+               RETURN), 16#85# (NEXT LINE), and the characters in
+               categories separator_line and separator_paragraph.  
+
+13.a/2
+          Discussion: ISO/IEC 10646:2003 does not define the names of
+          control characters, but rather refers to the names defined by
+          ISO/IEC 6429:1992.  These are the names that we use here.
+
+13.1/2
+{AI95-00285-01AI95-00285-01} other_control
+               Any character whose General Category is defined to be
+               "Other, Control", and which is not defined to be a
+               format_effector.
+
+13.2/2
+{AI95-00285-01AI95-00285-01} other_private_use
+               Any character whose General Category is defined to be
+               "Other, Private Use".
+
+13.3/2
+{AI95-00285-01AI95-00285-01} other_surrogate
+               Any character whose General Category is defined to be
+               "Other, Surrogate".
+
+14/3
+{AI95-00285-01AI95-00285-01} {AI95-00395-01AI95-00395-01}
+{AI05-0262-1AI05-0262-1} graphic_character
+               Any character that is not in the categories
+               other_control, other_private_use, other_surrogate,
+               format_effector, and whose relative code point in its
+               plane is neither 16#FFFE# nor 16#FFFF#.
+
+14.a/2
+          This paragraph was deleted.
+
+14.b/2
+          Discussion: {AI95-00285-01AI95-00285-01} We considered basing
+          the definition of lexical elements on Annex A of ISO/IEC TR
+          10176 (4th edition), which lists the characters which should
+          be supported in identifiers for all programming languages, but
+          we finally decided against this option.  Note that it is not
+          our intent to diverge from ISO/IEC TR 10176, except to the
+          extent that ISO/IEC TR 10176 itself diverges from ISO/IEC
+          10646:2003 (which is the case at the time of this writing
+          [January 2005]).
+
+14.c/2
+          More precisely, we intend to align strictly with ISO/IEC
+          10646:2003.  It must be noted that ISO/IEC TR 10176 is a
+          Technical Report while ISO/IEC 10646:2003 is a Standard.  If
+          one has to make a choice, one should conform with the Standard
+          rather than with the Technical Report.  And, it turns out that
+          one must make a choice because there are important differences
+          between the two:
+
+14.d/2
+             * ISO/IEC TR 10176 is still based on ISO/IEC 10646:2000
+               while ISO/IEC 10646:2003 has already been published for a
+               year.  We cannot afford to delay the adoption of our
+               amendment until ISO/IEC TR 10176 has been revised.
+
+14.e/2
+             * There are considerable differences between the two
+               editions of ISO/IEC 10646, notably in supporting
+               characters beyond the BMP (this might be significant for
+               some languages, e.g.  Korean).
+
+14.f/2
+             * ISO/IEC TR 10176 does not define case conversion tables,
+               which are essential for a case-insensitive language like
+               Ada.  To get case conversion tables, we would have to
+               reference either ISO/IEC 10646:2003 or Unicode, or we
+               would have to invent our own.
+
+14.g/2
+          For the purpose of defining the lexical elements of the
+          language, we need character properties like categorization, as
+          well as case conversion tables.  These are mentioned in
+          ISO/IEC 10646:2003 as useful for implementations, with a
+          reference to Unicode.  Machine-readable tables are available
+          on the web at URLs:
+
+14.h/2
+               http://www.unicode.org/Public/4.0-Update/UnicodeData-4.0.0.txt 
(http://www.unicode.org/Public/4.0-Update/UnicodeData-4.0.0.txt)
+               http://www.unicode.org/Public/4.0-Update/CaseFolding-4.0.0.txt 
(http://www.unicode.org/Public/4.0-Update/CaseFolding-4.0.0.txt)
+
+14.i/2
+          with an explanatory document found at URL:
+
+14.j/2
+               http://www.unicode.org/Public/4.0-Update/UCD-4.0.0.html 
(http://www.unicode.org/Public/4.0-Update/UCD-4.0.0.html)
+
+14.k/2
+          The actual text of the standard only makes specific references
+          to the corresponding clauses of ISO/IEC 10646:2003, not to
+          Unicode.
+
+15/3
+{AI95-00285-01AI95-00285-01} {AI05-0266-1AI05-0266-1} The following
+names are used when referring to certain characters (the first name is
+that given in ISO/IEC 10646:2011): 
+
+15.a/3
+          Discussion: {AI95-00285-01AI95-00285-01}
+          {AI05-0266-1AI05-0266-1} This table serves to show the
+          correspondence between ISO/IEC 10646:2011 names and the
+          graphic symbols (glyphs) used in this International Standard.
+          These are the characters that play a special role in the
+          syntax of Ada.
+
+  graphic symbol   name                      graphic symbol   name
+         "         quotation mark                   :         colon
+         #         number sign                      ;         semicolon
+         &         ampersand                        <         less-than sign
+         '         apostrophe, tick                 =         equals sign
+         (         left parenthesis                 >         greater-than sign
+         )         right parenthesis                _         low line, 
underline
+         *         asterisk, multiply               |         vertical line
+         +         plus sign                        /         solidus, divide
+         ,         comma                            !         exclamation point
+         -         hyphen-minus, minus              %         percent sign
+         .         full stop, dot, point
+
+                     _Implementation Requirements_
+
+16/3
+{AI05-0286-1AI05-0286-1} An Ada implementation shall accept Ada source
+code in UTF-8 encoding, with or without a BOM (see *note A.4.11::),
+where every character is represented by its code point.  The character
+pair CARRIAGE RETURN/LINE FEED (code points 16#0D# 16#0A#) signifies a
+single end of line (see *note 2.2::); every other occurrence of a
+format_effector other than the character whose code point position is
+16#09# (CHARACTER TABULATION) also signifies a single end of line.
+
+16.a/3
+          Reason: {AI05-0079-1AI05-0079-1} {AI05-0286-1AI05-0286-1} This
+          is simply requiring that an Ada implementation be able to
+          directly process the ACATS, which is provided in the described
+          format.  Note that files that only contain characters with
+          code points in the first 128 (which is the majority of the
+          ACATS) are represented in the same way in both UTF-8 and in
+          "plain" string format.  The ACATS includes a BOM in files that
+          have any characters with code points greater than 127.  Note
+          that the BOM contains characters not legal in Ada source code,
+          so an implementation can use that to automatically distinguish
+          between files formatted as plain Latin-1 strings and UTF-8
+          with BOM.
+
+16.b/3
+          We allow line endings to be both represented as the pair CR LF
+          (as in Windows and the ACATS), and as single format_effector
+          characters (usually LF, as in Linux), in order that files
+          created by standard tools on most operating systems will meet
+          the standard format.  We specify how many line endings each
+          represent so that compilers use the same line numbering for
+          standard source files.
+
+16.c/3
+          This requirement increases portability by having a format that
+          is accepted by all Ada compilers.  Note that implementations
+          can support other source representations, including structured
+          representations like a parse tree.
+
+                     _Implementation Permissions_
+
+17/3
+{AI95-00285-01AI95-00285-01} {AI05-0266-1AI05-0266-1} The categories
+defined above, as well as case mapping and folding, may be based on an
+implementation-defined version of ISO/IEC 10646 (2003 edition or later).
+
+17.b/3
+          Ramification: The exact categories, case mapping, and case
+          folding chosen affects identifiers, the result of
+          '[[Wide_]Wide_]Image, and packages Wide_Characters.Handling
+          and Wide_Wide_Characters.Handling.
+
+17.c/3
+          Discussion: This permission allows implementations to upgrade
+          to using a newer character set standard whenever that makes
+          sense, rather than having to wait for the next Ada Standard.
+          But the character set standard used cannot be older than
+          ISO/IEC 10646:2003 (which is essentially similar to Unicode
+          4.0).
+
+     NOTES
+
+18/2
+     1  {AI95-00285-01AI95-00285-01} The characters in categories
+     other_control, other_private_use, and other_surrogate are only
+     allowed in comments.
+
+19.a/3
+          This paragraph was deleted.{AI05-0286-1AI05-0286-1}
+
+                        _Extensions to Ada 83_
+
+19.b
+          Ada 95 allows 8-bit and 16-bit characters, as well as
+          implementation-specified character sets.
+
+                     _Wording Changes from Ada 83_
+
+19.c/3
+          {AI95-00285-01AI95-00285-01} {AI05-0299-1AI05-0299-1} The
+          syntax rules in this subclause are modified to remove the
+          emphasis on basic characters vs.  others.  (In this day and
+          age, there is no need to point out that you can write programs
+          without using (for example) lower case letters.)  In
+          particular, character (representing all characters usable
+          outside comments) is added, and basic_graphic_character,
+          other_special_character, and basic_character are removed.
+          Special_character is expanded to include Ada 83's
+          other_special_character, as well as new 8-bit characters not
+          present in Ada 83.  Ada 2005 removes special_character
+          altogether; we want to stick to ISO/IEC 10646:2003 character
+          classifications.  Note that the term "basic letter" is used in
+          *note A.3::, "*note A.3:: Character Handling" to refer to
+          letters without diacritical marks.
+
+19.d/2
+          {AI95-00285-01AI95-00285-01} Character names now come from
+          ISO/IEC 10646:2003.
+
+19.e/2
+          This paragraph was deleted.{AI95-00285-01AI95-00285-01}
+
+                        _Extensions to Ada 95_
+
+19.f/2
+          {AI95-00285-01AI95-00285-01} {AI95-00395-01AI95-00395-01}
+          Program text can use most characters defined by
+          ISO-10646:2003.  This subclause has been rewritten to use the
+          categories defined in that Standard.  This should ease
+          programming in languages other than English.
+
+                    _Inconsistencies With Ada 2005_
+
+19.g/3
+          {AI05-0299-1AI05-0299-1} {AI05-0266-1AI05-0266-1} An
+          implementation is allowed (but not required) to use a newer
+          character set standard to determine the categories, case
+          mapping, and case folding.  Doing so will change the results
+          of attributes '[[Wide_]Wide_]Image and the packages
+          [Wide_]Wide_Characters.Handling in the case of a few rarely
+          used characters.  (This also could make some identifiers
+          illegal, for characters that are no longer classified as
+          letters.)  This is unlikely to be a problem in practice.
+          Moreover, truly portable Ada 2012 programs should avoid using
+          in these contexts any characters that would have different
+          classifications in any character set standards issued since
+          10646:2003 (since the compiler can use any such standard as
+          the basis for its classifications).
+
+                    _Wording Changes from Ada 2005_
+
+19.h/3
+          {AI05-0079-1AI05-0079-1} Correction: Clarified that only
+          characters in the categories defined here are allowed in the
+          source of an Ada program.  This was clear in Ada 95, but
+          Amendment 1 dropped the wording instead of correcting it.
+
+19.i/3
+          {AI05-0286-1AI05-0286-1} A standard source representation is
+          defined that all compilers are expected to process.  Since
+          this is the same format as the ACATS, it seems unlikely that
+          there are any implementations that don't meet this
+          requirement.  Moreover, other representations are still
+          permitted, and the "impossible or impractical" loophole (see
+          *note 1.1.3::) can be invoked for any implementations that
+          cannot directly process the ACATS.
+
+
+File: aarm2012.info,  Node: 2.2,  Next: 2.3,  Prev: 2.1,  Up: 2
+
+2.2 Lexical Elements, Separators, and Delimiters
+================================================
+
+                          _Static Semantics_
+
+1
+The text of a program consists of the texts of one or more compilations.
+The text of each compilation is a sequence of separate lexical elements.
+Each lexical element is formed from a sequence of characters, and is
+either a delimiter, an identifier, a reserved word, a numeric_literal, a
+character_literal, a string_literal, or a comment.  The meaning of a
+program depends only on the particular sequences of lexical elements
+that form its compilations, excluding comments.
+
+2/3
+{AI95-00285-01AI95-00285-01} {AI05-0262-1AI05-0262-1} The text of a
+compilation is divided into lines.  In general, the representation for
+an end of line is implementation defined.  However, a sequence of one or
+more format_effectors other than the character whose code point is
+16#09# (CHARACTER TABULATION) signifies at least one end of line.
+
+2.a
+          Implementation defined: The representation for an end of line.
+
+3/2
+{AI95-00285-01AI95-00285-01} [In some cases an explicit separator is
+required to separate adjacent lexical elements.]  A separator is any of
+a separator_space, a format_effector, or the end of a line, as follows:
+
+4/2
+   * {AI95-00285-01AI95-00285-01} A separator_space is a separator
+     except within a comment, a string_literal, or a character_literal.
+
+5/3
+   * {AI95-00285-01AI95-00285-01} {AI05-0262-1AI05-0262-1} The character
+     whose code point is 16#09# (CHARACTER TABULATION) is a separator
+     except within a comment.
+
+6
+   * The end of a line is always a separator.
+
+7
+One or more separators are allowed between any two adjacent lexical
+elements, before the first of each compilation, or after the last.  At
+least one separator is required between an identifier, a reserved word,
+or a numeric_literal and an adjacent identifier, reserved word, or
+numeric_literal.
+
+7.1/3
+{AI05-0079-1AI05-0079-1} One or more other_format characters are allowed
+anywhere that a separator is[; any such characters have no effect on the
+meaning of an Ada program].
+
+8/2
+{AI95-00285-01AI95-00285-01} A delimiter is either one of the following
+characters:
+
+9
+     &    '    (    )    *    +    ,    -    .    /    :    ;    <    =    >   
 |
+
+10
+or one of the following compound delimiters each composed of two
+adjacent special characters
+
+11
+     =>    ..    **    :=    /=    >=    <=    <<    >>    <>
+
+12
+Each of the special characters listed for single character delimiters is
+a single delimiter except if this character is used as a character of a
+compound delimiter, or as a character of a comment, string_literal,
+character_literal, or numeric_literal.
+
+13
+The following names are used when referring to compound delimiters:
+
+     delimiter  name=> arrow
+.. double dot
+** double star, exponentiate
+:= assignment (pronounced: "becomes")
+/= inequality (pronounced: "not equal")
+>= greater than or equal
+<= less than or equal
+<< left label bracket
+>> right label bracket
+<> box
+                     _Implementation Requirements_
+
+14
+An implementation shall support lines of at least 200 characters in
+length, not counting any characters used to signify the end of a line.
+An implementation shall support lexical elements of at least 200
+characters in length.  The maximum supported line length and lexical
+element length are implementation defined.
+
+14.a
+          Implementation defined: Maximum supported line length and
+          lexical element length.
+
+14.b
+          Discussion: From URG recommendation.
+
+                     _Wording Changes from Ada 95_
+
+14.c/3
+          {AI95-00285-01AI95-00285-01} {AI05-0299-1AI05-0299-1} The
+          wording was updated to use the new character categories
+          defined in the preceding subclause.
+
+                       _Extensions to Ada 2005_
+
+14.d/3
+          {AI05-0079-1AI05-0079-1} Correction: Clarified that
+          other_format characters are allowed anywhere that separators
+          are allowed.  This was intended in Ada 2005, but didn't
+          actually make it into the wording.
+
+
+File: aarm2012.info,  Node: 2.3,  Next: 2.4,  Prev: 2.2,  Up: 2
+
+2.3 Identifiers
+===============
+
+1
+Identifiers are used as names.
+
+                               _Syntax_
+
+2/2
+     {AI95-00285-01AI95-00285-01} {AI95-00395-01AI95-00395-01}
+     identifier ::=
+        identifier_start {identifier_start | identifier_extend}
+
+3/2
+     {AI95-00285-01AI95-00285-01} {AI95-00395-01AI95-00395-01}
+     identifier_start ::=
+          letter_uppercase
+        | letter_lowercase
+        | letter_titlecase
+        | letter_modifier
+        | letter_other
+        | number_letter
+
+3.1/3
+     {AI95-00285-01AI95-00285-01} {AI95-00395-01AI95-00395-01}
+     {AI05-0091-1AI05-0091-1} identifier_extend ::=
+          mark_non_spacing
+        | mark_spacing_combining
+        | number_decimal
+        | punctuation_connector
+
+4/3
+     {AI95-00395-01AI95-00395-01} {AI05-0091-1AI05-0091-1} An identifier
+     shall not contain two consecutive characters in category
+     punctuation_connector, or end with a character in that category.
+
+4.a/3
+          Reason: This rule was stated in the syntax in Ada 95, but that
+          has gotten too complex in Ada 2005.
+
+                          _Static Semantics_
+
+5/3
+{AI95-00285-01AI95-00285-01} {AI05-0091-1AI05-0091-1}
+{AI05-0227-1AI05-0227-1} {AI05-0266-1AI05-0266-1}
+{AI05-0299-1AI05-0299-1} Two identifiers are considered the same if they
+consist of the same sequence of characters after applying
+locale-independent simple case folding, as defined by documents
+referenced in the note in Clause 1 of ISO/IEC 10646:2011.
+
+5.a/3
+          Discussion: {AI05-0227-1AI05-0227-1} Simple case folding is a
+          mapping to lower case, so this is matching the defining (lower
+          case) version of a reserved word.  We could have mentioned
+          case folding of the reserved words, but as that is an identity
+          function, it would have no effect.
+
+5.a.1/3
+          {AI05-0227-1AI05-0227-1} The "documents referenced" means
+          Unicode.  Note that simple case folding is supposed to be
+          compatible between Unicode versions, so the Unicode version
+          used doesn't matter.
+
+5.3/3
+{AI95-00395-01AI95-00395-01} {AI05-0091-1AI05-0091-1}
+{AI05-0227-1AI05-0227-1} After applying simple case folding, an
+identifier shall not be identical to a reserved word.
+
+5.b/3
+          Implementation Note: We match the reserved words after
+          applying case folding so that the rules for identifiers and
+          reserved words are the same.  Since a compiler usually will
+          lexically process identifiers and reserved words the same way
+          (often with the same code), this will prevent a lot of
+          headaches.
+
+5.c/3
+          Ramification: {AI05-0227-1AI05-0227-1} The rules for reserved
+          words differ in one way: they define case conversion on
+          letters rather than sequences.  This means that it is possible
+          that there exist some unusual sequences that are neither
+          identifiers nor reserved words.  We are not aware of any such
+          sequences so long as we use simple case folding (as opposed to
+          full case folding), but we have defined the rules in case any
+          are introduced in future character set standards.  This
+          originally was a problem when converting to upper case: "if"
+          and "acce�" have upper case conversions of "IF" and "ACCESS"
+          respectively.  We would not want these to be treated as
+          reserved words.  But neither of these cases exist when using
+          simple case folding.
+
+                     _Implementation Permissions_
+
+6
+In a nonstandard mode, an implementation may support other upper/lower
+case equivalence rules for identifiers[, to accommodate local
+conventions].
+
+6.a/3
+          Discussion: {AI95-00285-01AI95-00285-01}
+          {AI05-0227-1AI05-0227-1} For instance, in most languages, the
+          simple case folded equivalent of LATIN CAPITAL LETTER I (an
+          upper case letter without a dot above) is LATIN SMALL LETTER I
+          (a lower case letter with a dot above).  In Turkish, though,
+          LATIN CAPITAL LETTER I and LATIN CAPITAL LETTER I WITH DOT
+          ABOVE are two distinct letters, so the case folded equivalent
+          of LATIN CAPITAL LETTER I is LATIN SMALL LETTER DOTLESS I, and
+          the case folded equivalent of LATIN CAPITAL LETTER I WITH DOT
+          ABOVE is LATIN SMALL LETTER I. Take for instance the following
+          identifier (which is the name of a city on the Tigris river in
+          Eastern Anatolia):
+
+6.b/3
+               DIYARBAKIR -- The first i is dotted, the second isn't.
+
+6.c/3
+          A Turkish reader would expect that the above identifier is
+          equivalent to:
+
+6.d/3
+               diyarbakir
+
+6.d.1/3
+          However, locale-independent simple case folding (and thus Ada)
+          maps this to:
+
+6.d.2/3
+               dIyarbakir
+
+6.e/3
+          which is different from any of the following identifiers:
+
+6.f/2
+               diyarbakir
+               diyarbakir
+               diyarbakir
+               diyarbakir
+
+6.f.1/3
+          including the "correct" matching identifier for Turkish.
+          Upper case conversion (used in '[Wide_]Wide_Image) introduces
+          additional problems.
+
+6.g/3
+          An implementation targeting the Turkish market is allowed (in
+          fact, expected) to provide a nonstandard mode where case
+          folding is appropriate for Turkish.
+
+6.j/2
+          Lithuanian and Azeri are two other languages that present
+          similar idiosyncrasies.
+
+     NOTES
+
+6.1/2
+     2  {AI95-00285-01AI95-00285-01} Identifiers differing only in the
+     use of corresponding upper and lower case letters are considered
+     the same.
+
+                              _Examples_
+
+7
+Examples of identifiers:
+
+8/2
+     {AI95-00433-01AI95-00433-01} Count      X    Get_Symbol   Ethelyn   Marion
+     Snobol_4   X1   Page_Count   Store_Next_Item
+     [Unicode 928][Unicode 955][Unicode 940][Unicode 964][Unicode 969][Unicode 
957]      -- Plato
+     [Unicode 1063][Unicode 1072][Unicode 1081][Unicode 1082][Unicode 
1086][Unicode 1074][Unicode 1089][Unicode 1082][Unicode 1080][Unicode 1081]  -- 
Tchaikovsky
+     [Unicode 952]  [Unicode 966]        -- Angles
+
+                     _Wording Changes from Ada 83_
+
+8.a
+          We no longer include reserved words as identifiers.  This is
+          not a language change.  In Ada 83, identifier included
+          reserved words.  However, this complicated several other rules
+          (for example, regarding implementation-defined attributes and
+          pragmas, etc.).  We now explicitly allow certain reserved
+          words for attribute designators, to make up for the loss.
+
+8.b
+          Ramification: Because syntax rules are relevant to overload
+          resolution, it means that if it looks like a reserved word, it
+          is not an identifier.  As a side effect, implementations
+          cannot use reserved words as implementation-defined attributes
+          or pragma names.
+
+                        _Extensions to Ada 95_
+
+8.c/2
+          {AI95-00285-01AI95-00285-01} An identifier can use any letter
+          defined by ISO-10646:2003, along with several other
+          categories.  This should ease programming in languages other
+          than English.
+
+                   _Incompatibilities With Ada 2005_
+
+8.d/3
+          {AI05-0091-1AI05-0091-1} Correction: other_format characters
+          were removed from identifiers as the Unicode recommendations
+          have changed.  This change can only affect programs written
+          for the original Ada 2005, so there should be few such
+          programs.
+
+8.e/3
+          {AI05-0227-1AI05-0227-1} Correction: We now specify simple
+          case folding rather than full case folding.  That potentially
+          could change identifier equivalence, although it is more
+          likely that identifiers that are considered the same in
+          original Ada 2005 will now be considered different.  This
+          change was made because the original Ada 2005 definition was
+          incompatible (and even inconsistent in unusual cases) with the
+          Ada 95 identifier equivalence rules.  As such, the Ada 2005
+          rules were rarely fully implemented, and in any case, only Ada
+          2005 identifiers containing wide characters could be affected.
+
+
+File: aarm2012.info,  Node: 2.4,  Next: 2.5,  Prev: 2.3,  Up: 2
+
+2.4 Numeric Literals
+====================
+
+1
+There are two kinds of numeric_literals, real literals and integer
+literals.  A real literal is a numeric_literal that includes a point; an
+integer literal is a numeric_literal without a point.
+
+                               _Syntax_
+
+2
+     numeric_literal ::= decimal_literal | based_literal
+
+     NOTES
+
+3
+     3  The type of an integer literal is universal_integer.  The type
+     of a real literal is universal_real.
+
+* Menu:
+
+* 2.4.1 ::    Decimal Literals
+* 2.4.2 ::    Based Literals
+
+
+File: aarm2012.info,  Node: 2.4.1,  Next: 2.4.2,  Up: 2.4
+
+2.4.1 Decimal Literals
+----------------------
+
+1
+A decimal_literal is a numeric_literal in the conventional decimal
+notation (that is, the base is ten).
+
+                               _Syntax_
+
+2
+     decimal_literal ::= numeral [.numeral] [exponent]
+
+3
+     numeral ::= digit {[underline] digit}
+
+4
+     exponent ::= E [+] numeral | E - numeral
+
+4.1/2
+     {AI95-00285-01AI95-00285-01} digit ::=
+     0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9
+
+5
+     An exponent for an integer literal shall not have a minus sign.
+
+5.a
+          Ramification: Although this rule is in this subclause, it
+          applies also to the next subclause.
+
+                          _Static Semantics_
+
+6
+An underline character in a numeric_literal does not affect its meaning.
+The letter E of an exponent can be written either in lower case or in
+upper case, with the same meaning.
+
+6.a
+          Ramification: Although these rules are in this subclause, they
+          apply also to the next subclause.
+
+7
+An exponent indicates the power of ten by which the value of the
+decimal_literal without the exponent is to be multiplied to obtain the
+value of the decimal_literal with the exponent.
+
+                              _Examples_
+
+8
+Examples of decimal literals:
+
+9
+     12        0      1E6    123_456    --  integer literals
+
+     12.0      0.0    0.456  3.14159_26 --  real literals
+
+                     _Wording Changes from Ada 83_
+
+9.a
+          We have changed the syntactic category name integer to be
+          numeral.  We got this idea from ACID. It avoids the confusion
+          between this and integers.  (Other places don't offer similar
+          confusions.  For example, a string_literal is different from a
+          string.)
+
+
+File: aarm2012.info,  Node: 2.4.2,  Prev: 2.4.1,  Up: 2.4
+
+2.4.2 Based Literals
+--------------------
+
+1
+[ A based_literal is a numeric_literal expressed in a form that
+specifies the base explicitly.]
+
+                               _Syntax_
+
+2
+     based_literal ::=
+        base # based_numeral [.based_numeral] # [exponent]
+
+3
+     base ::= numeral
+
+4
+     based_numeral ::=
+        extended_digit {[underline] extended_digit}
+
+5
+     extended_digit ::= digit | A | B | C | D | E | F
+
+                           _Legality Rules_
+
+6
+The base (the numeric value of the decimal numeral preceding the first
+#) shall be at least two and at most sixteen.  The extended_digits A
+through F represent the digits ten through fifteen, respectively.  The
+value of each extended_digit of a based_literal shall be less than the
+base.
+
+                          _Static Semantics_
+
+7
+The conventional meaning of based notation is assumed.  An exponent
+indicates the power of the base by which the value of the based_literal
+without the exponent is to be multiplied to obtain the value of the
+based_literal with the exponent.  The base and the exponent, if any, are
+in decimal notation.
+
+8
+The extended_digits A through F can be written either in lower case or
+in upper case, with the same meaning.
+
+                              _Examples_
+
+9
+Examples of based literals:
+
+10
+     2#1111_1111#  16#FF#       016#0ff#   --  integer literals of value 255
+     16#E#E1       2#1110_0000#            --  integer literals of value 224
+     16#F.FF#E+2   2#1.1111_1111_1110#E11  --  real literals of value 4095.0
+
+                     _Wording Changes from Ada 83_
+
+10.a
+          The rule about which letters are allowed is now encoded in
+          BNF, as suggested by Mike Woodger.  This is clearly more
+          readable.
+
+
+File: aarm2012.info,  Node: 2.5,  Next: 2.6,  Prev: 2.4,  Up: 2
+
+2.5 Character Literals
+======================
+
+1
+[A character_literal is formed by enclosing a graphic character between
+two apostrophe characters.]
+
+                               _Syntax_
+
+2
+     character_literal ::= 'graphic_character'
+
+     NOTES
+
+3
+     4  A character_literal is an enumeration literal of a character
+     type.  See *note 3.5.2::.
+
+                              _Examples_
+
+4
+Examples of character literals:
+
+5/2
+     {AI95-00433-01AI95-00433-01} 'A'     '*'     '''     ' '
+     'L'     '[Unicode 1051]'     '[Unicode 923]'    -- Various els.
+     '[Unicode 8734]'     '[Unicode 1488]'            -- Big numbers - 
infinity and aleph.
+
+                     _Wording Changes from Ada 83_
+
+5.a/3
+          {AI05-0299-1AI05-0299-1} The definitions of the values of
+          literals are in Clauses 3 and 4, rather than here, since it
+          requires knowledge of types.
+
+
+File: aarm2012.info,  Node: 2.6,  Next: 2.7,  Prev: 2.5,  Up: 2
+
+2.6 String Literals
+===================
+
+1
+[A string_literal is formed by a sequence of graphic characters
+(possibly none) enclosed between two quotation marks used as string
+brackets.  They are used to represent operator_symbols (see *note
+6.1::), values of a string type (see *note 4.2::), and array
+subaggregates (see *note 4.3.3::).  ]
+
+                               _Syntax_
+
+2
+     string_literal ::= "{string_element}"
+
+3
+     string_element ::= "" | non_quotation_mark_graphic_character
+
+4
+     A string_element is either a pair of quotation marks (""), or a
+     single graphic_character other than a quotation mark.
+
+                          _Static Semantics_
+
+5
+The sequence of characters of a string_literal is formed from the
+sequence of string_elements between the bracketing quotation marks, in
+the given order, with a string_element that is "" becoming a single
+quotation mark in the sequence of characters, and any other
+string_element being reproduced in the sequence.
+
+6
+A null string literal is a string_literal with no string_elements
+between the quotation marks.
+
+     NOTES
+
+7
+     5  An end of line cannot appear in a string_literal.
+
+7.1/2
+     6  {AI95-00285-01AI95-00285-01} No transformation is performed on
+     the sequence of characters of a string_literal.
+
+                              _Examples_
+
+8
+Examples of string literals:
+
+9/2
+     {AI95-00433-01AI95-00433-01} "Message of the day:"
+
+     ""                    --  a null string literal
+     " "   "A"   """"      --  three string literals of length 1
+
+     "Characters such as $, %, and } are allowed in string literals"
+     "Archimedes said ""[Unicode 917][Unicode 973][Unicode 961][Unicode 
951][Unicode 954][Unicode 945]"""
+     "Volume of cylinder (PIr�h) = "
+
+                     _Wording Changes from Ada 83_
+
+9.a
+          The wording has been changed to be strictly lexical.  No
+          mention is made of string or character values, since
+          string_literals are also used to represent operator_symbols,
+          which don't have a defined value.
+
+9.b
+          The syntax is described differently.
+
+                     _Wording Changes from Ada 95_
+
+9.c/2
+          {AI95-00285-01AI95-00285-01} We explicitly say that the
+          characters of a string_literal should be used as is.  In
+          particular, no normalization or folding should be performed on
+          a string_literal.
+
+
+File: aarm2012.info,  Node: 2.7,  Next: 2.8,  Prev: 2.6,  Up: 2
+
+2.7 Comments
+============
+
+1
+A comment starts with two adjacent hyphens and extends up to the end of
+the line.
+
+                               _Syntax_
+
+2
+     comment ::= --{non_end_of_line_character}
+
+3
+     A comment may appear on any line of a program.
+
+                          _Static Semantics_
+
+4
+The presence or absence of comments has no influence on whether a
+program is legal or illegal.  Furthermore, comments do not influence the
+meaning of a program; their sole purpose is the enlightenment of the
+human reader.
+
+                              _Examples_
+
+5
+Examples of comments:
+
+6
+     --  the last sentence above echoes the Algol 68 report 
+
+     end;  --  processing of Line is complete 
+
+     --  a long comment may be split onto
+     --  two or more consecutive lines   
+
+     ----------------  the first two hyphens start the comment  
+
+
+File: aarm2012.info,  Node: 2.8,  Next: 2.9,  Prev: 2.7,  Up: 2
+
+2.8 Pragmas
+===========
+
+1
+A pragma is a compiler directive.  There are language-defined pragmas
+that give instructions for optimization, listing control, etc.  An
+implementation may support additional (implementation-defined) pragmas.
+
+                     _Language Design Principles_
+
+1.a/3
+          {AI05-0100-1AI05-0100-1} {AI05-0163-1AI05-0163-1} In general,
+          if all pragmas are treated as unrecognized pragmas, the
+          program should remain both syntactically and semantically
+          legal.  There are a few exceptions to this general principle
+          (for example, pragma Import can eliminate the need for a
+          completion), but the principle remains, and is strictly true
+          at the syntactic level.  Certainly any implementation-defined
+          pragmas should obey this principle both syntactically and
+          semantically, so that if the pragmas are not recognized by
+          some other implementation, the program will remain legal.
+
+                               _Syntax_
+
+2
+     pragma ::=
+        pragma identifier [(pragma_argument_association {, 
+     pragma_argument_association})];
+
+3/3
+     {AI05-0290-1AI05-0290-1} pragma_argument_association ::=
+          [pragma_argument_identifier =>] name
+        | [pragma_argument_identifier =>] expression
+        | pragma_argument_aspect_mark =>  name
+        | pragma_argument_aspect_mark =>  expression
+
+4/3
+     {AI05-0290-1AI05-0290-1} In a pragma, any
+     pragma_argument_associations without a pragma_argument_identifier
+     or pragma_argument_aspect_mark shall precede any associations with
+     a pragma_argument_identifier or pragma_argument_aspect_mark.
+
+5
+     Pragmas are only allowed at the following places in a program:
+
+6
+        * After a semicolon delimiter, but not within a formal_part or
+          discriminant_part.
+
+7/3
+        * {AI05-0100-1AI05-0100-1} {AI05-0163-1AI05-0163-1} At any place
+          where the syntax rules allow a construct defined by a
+          syntactic category whose name ends with "declaration", "item",
+          "statement", "clause", or "alternative", or one of the
+          syntactic categories variant or exception_handler; but not in
+          place of such a construct if the construct is required, or is
+          part of a list that is required to have at least one such
+          construct.
+
+7.1/3
+        * {AI05-0163-1AI05-0163-1} In place of a statement in a
+          sequence_of_statements.
+
+7.2/3
+        * {AI05-0100-1AI05-0100-1} At any place where a compilation_unit
+          is allowed.
+
+8
+     Additional syntax rules and placement restrictions exist for
+     specific pragmas.
+
+8.a
+          Discussion: The above rule is written in text, rather than in
+          BNF; the syntactic category pragma is not used in any BNF
+          syntax rule.
+
+8.b
+          Ramification: A pragma is allowed where a
+          generic_formal_parameter_declaration is allowed.
+
+9
+The name of a pragma is the identifier following the reserved word
+pragma.  The name or expression of a pragma_argument_association is a
+pragma argument.
+
+9.a/2
+          To be honest: {AI95-00284-02AI95-00284-02} For compatibility
+          with Ada 83, the name of a pragma may also be "interface",
+          which is not an identifier (because it is a reserved word).
+          See *note J.12::.
+
+10/3
+{AI05-0272-1AI05-0272-1} An identifier specific to a pragma is an
+identifier or reserved word that is used in a pragma argument with
+special meaning for that pragma.
+
+10.a
+          To be honest: Whenever the syntax rules for a given pragma
+          allow "identifier" as an argument of the pragma, that
+          identifier is an identifier specific to that pragma.
+
+10.b/3
+          {AI05-0272-1AI05-0272-1} In a few cases, a reserved word is
+          allowed as "an identifier specific to a pragma".  Even in
+          these cases, the syntax still is written as identifier (the
+          reserved word(s) are not shown).  For example, the restriction
+          No_Use_Of_Attribute (see *note 13.12.1::) allows the reserved
+          words which can be attribute designators, but the syntax for a
+          restriction does not include these reserved words.
+
+                          _Static Semantics_
+
+11
+If an implementation does not recognize the name of a pragma, then it
+has no effect on the semantics of the program.  Inside such a pragma,
+the only rules that apply are the Syntax Rules.
+
+11.a
+          To be honest: This rule takes precedence over any other rules
+          that imply otherwise.
+
+11.b
+          Ramification: Note well: this rule applies only to pragmas
+          whose name is not recognized.  If anything else is wrong with
+          a pragma (at compile time), the pragma is illegal.  This is
+          true whether the pragma is language defined or implementation
+          defined.
+
+11.c
+          For example, an expression in an unrecognized pragma does not
+          cause freezing, even though the rules in *note 13.14::, "*note
+          13.14:: Freezing Rules" say it does; the above rule overrules
+          those other rules.  On the other hand, an expression in a
+          recognized pragma causes freezing, even if this makes
+          something illegal.
+
+11.d
+          For another example, an expression that would be ambiguous is
+          not illegal if it is inside an unrecognized pragma.
+
+11.e
+          Note, however, that implementations have to recognize pragma
+          Inline(Foo) and freeze things accordingly, even if they choose
+          to never do inlining.
+
+11.f
+          Obviously, the contradiction needs to be resolved one way or
+          the other.  The reasons for resolving it this way are: The
+          implementation is simple -- the compiler can just ignore the
+          pragma altogether.  The interpretation of constructs appearing
+          inside implementation-defined pragmas is implementation
+          defined.  For example: "pragma Mumble(X);".  If the current
+          implementation has never heard of Mumble, then it doesn't know
+          whether X is a name, an expression, or an identifier specific
+          to the pragma Mumble.
+
+11.g
+          To be honest: The syntax of individual pragmas overrides the
+          general syntax for pragma.
+
+11.h
+          Ramification: Thus, an identifier specific to a pragma is not
+          a name, syntactically; if it were, the visibility rules would
+          be invoked, which is not what we want.
+
+11.i/3
+          {AI05-0229-1AI05-0229-1} This also implies that named
+          associations do not allow one to give the arguments in an
+          arbitrary order -- the order given in the syntax rule for each
+          individual pragma must be obeyed.  However, it is generally
+          possible to leave out earlier arguments when later ones are
+          given; for example, this is allowed by the syntax rule for
+          pragma Import (see *note J.15.5::, "*note J.15.5:: Interfacing
+          Pragmas").  As for subprogram calls, positional notation
+          precedes named notation.
+
+11.j
+          Note that Ada 83 had no pragmas for which the order of named
+          associations mattered, since there was never more than one
+          argument that allowed named associations.
+
+11.k
+          To be honest: The interpretation of the arguments of
+          implementation-defined pragmas is implementation defined.
+          However, the syntax rules have to be obeyed.
+
+                          _Dynamic Semantics_
+
+12
+Any pragma that appears at the place of an executable construct is
+executed.  Unless otherwise specified for a particular pragma, this
+execution consists of the evaluation of each evaluable pragma argument
+in an arbitrary order.
+
+12.a
+          Ramification: For a pragma that appears at the place of an
+          elaborable construct, execution is elaboration.
+
+12.b
+          An identifier specific to a pragma is neither a name nor an
+          expression -- such identifiers are not evaluated (unless an
+          implementation defines them to be evaluated in the case of an
+          implementation-defined pragma).
+
+12.c
+          The "unless otherwise specified" part allows us (and
+          implementations) to make exceptions, so a pragma can contain
+          an expression that is not evaluated.  Note that pragmas in
+          type_definitions may contain expressions that depend on
+          discriminants.
+
+12.d
+          When we wish to define a pragma with some run-time effect, we
+          usually make sure that it appears in an executable context;
+          otherwise, special rules are needed to define the run-time
+          effect and when it happens.
+
+                     _Implementation Requirements_
+
+13
+The implementation shall give a warning message for an unrecognized
+pragma name.
+
+13.a
+          Ramification: An implementation is also allowed to have modes
+          in which a warning message is suppressed, or in which the
+          presence of an unrecognized pragma is a compile-time error.
+
+                     _Implementation Permissions_
+
+14
+An implementation may provide implementation-defined pragmas; the name
+of an implementation-defined pragma shall differ from those of the
+language-defined pragmas.
+
+14.a
+          Implementation defined: Implementation-defined pragmas.
+
+14.b
+          Ramification: The semantics of implementation-defined pragmas,
+          and any associated rules (such as restrictions on their
+          placement or arguments), are, of course, implementation
+          defined.  Implementation-defined pragmas may have run-time
+          effects.
+
+15
+An implementation may ignore an unrecognized pragma even if it violates
+some of the Syntax Rules, if detecting the syntax error is too complex.
+
+15.a
+          Reason: Many compilers use extra post-parsing checks to
+          enforce the syntax rules, since the Ada syntax rules are not
+          LR(k) (for any k).  (The grammar is ambiguous, in fact.)  This
+          paragraph allows them to ignore an unrecognized pragma,
+          without having to perform such post-parsing checks.
+
+                        _Implementation Advice_
+
+16/3
+{AI05-0163-1AI05-0163-1} Normally, implementation-defined pragmas should
+have no semantic effect for error-free programs; that is, if the
+implementation-defined pragmas in a working program are replaced with
+unrecognized pragmas, the program should still be legal, and should
+still have the same semantics.
+
+16.a.1/2
+          Implementation Advice: Implementation-defined pragmas should
+          have no semantic effect for error-free programs.
+
+16.a
+          Ramification: Note that "semantics" is not the same as
+          "effect;" as explained in *note 1.1.3::, the semantics defines
+          a set of possible effects.
+
+16.b
+          Note that adding a pragma to a program might cause an error
+          (either at compile time or at run time).  On the other hand,
+          if the language-specified semantics for a feature are in part
+          implementation defined, it makes sense to support pragmas that
+          control the feature, and that have real semantics; thus, this
+          paragraph is merely a recommendation.
+
+17
+Normally, an implementation should not define pragmas that can make an
+illegal program legal, except as follows:
+
+18/3
+   * {AI05-0229-1AI05-0229-1} A pragma used to complete a declaration;
+
+18.a/3
+          Discussion: {AI05-0229-1AI05-0229-1} There are no
+          language-defined pragmas which can be completions; pragma
+          Import was defined this way in Ada 95 and Ada 2005, but in Ada
+          2012 pragma Import just sets aspect Import which disallows
+          having any completion.
+
+19
+   * A pragma used to configure the environment by adding, removing, or
+     replacing library_items.
+
+19.a.1/2
+          Implementation Advice: Implementation-defined pragmas should
+          not make an illegal program legal, unless they complete a
+          declaration or configure the library_items in an environment.
+
+19.a
+          Ramification: For example, it is OK to support Interface,
+          System_Name, Storage_Unit, and Memory_Size pragmas for upward
+          compatibility reasons, even though all of these pragmas can
+          make an illegal program legal.  (The latter three can affect
+          legality in a rather subtle way: They affect the value of
+          named numbers in System, and can therefore affect the legality
+          in cases where static expressions are required.)
+
+19.b
+          On the other hand, adding implementation-defined pragmas to a
+          legal program can make it illegal.  For example, a common kind
+          of implementation-defined pragma is one that promises some
+          property that allows more efficient code to be generated.  If
+          the promise is a lie, it is best if the user gets an error
+          message.
+
+                    _Incompatibilities With Ada 83_
+
+19.c
+          In Ada 83, "bad" pragmas are ignored.  In Ada 95, they are
+          illegal, except in the case where the name of the pragma
+          itself is not recognized by the implementation.
+
+                        _Extensions to Ada 83_
+
+19.d
+          Implementation-defined pragmas may affect the legality of a
+          program.
+
+                     _Wording Changes from Ada 83_
+
+19.e
+          Implementation-defined pragmas may affect the run-time
+          semantics of the program.  This was always true in Ada 83
+          (since it was not explicitly forbidden by RM83), but it was
+          not clear, because there was no definition of "executing" or
+          "elaborating" a pragma.
+
+                       _Extensions to Ada 2005_
+
+19.f/3
+          {AI05-0163-1AI05-0163-1} Correction: Allow pragmas in place of
+          a statement, even if there are no other statements in a
+          sequence_of_statements.
+
+19.g/3
+          {AI05-0272-1AI05-0272-1} Identifiers specific to a pragma can
+          be reserved words.
+
+19.h/3
+          {AI05-0290-1AI05-0290-1} Pragma arguments can be identified
+          with aspect_marks; this allows identifier'Class in this
+          context.  As usual, this is only allowed if specifically
+          allowed by a particular pragma.
+
+                    _Wording Changes from Ada 2005_
+
+19.i/3
+          {AI05-0100-1AI05-0100-1} Correction: Clarified where pragmas
+          are (and are not) allowed.
+
+                               _Syntax_
+
+20
+     The forms of List, Page, and Optimize pragmas are as follows:
+
+21
+       pragma List(identifier);
+
+22
+       pragma Page;
+
+23
+       pragma Optimize(identifier);
+
+24
+     [Other pragmas are defined throughout this International Standard,
+     and are summarized in *note Annex L::.]
+
+24.a
+          Ramification: The language-defined pragmas are supported by
+          every implementation, although "supporting" some of them (for
+          example, Inline) requires nothing more than checking the
+          arguments, since they act only as advice to the
+          implementation.
+
+                          _Static Semantics_
+
+25
+A pragma List takes one of the identifiers On or Off as the single
+argument.  This pragma is allowed anywhere a pragma is allowed.  It
+specifies that listing of the compilation is to be continued or
+suspended until a List pragma with the opposite argument is given within
+the same compilation.  The pragma itself is always listed if the
+compiler is producing a listing.
+
+26
+A pragma Page is allowed anywhere a pragma is allowed.  It specifies
+that the program text which follows the pragma should start on a new
+page (if the compiler is currently producing a listing).
+
+27
+A pragma Optimize takes one of the identifiers Time, Space, or Off as
+the single argument.  This pragma is allowed anywhere a pragma is
+allowed, and it applies until the end of the immediately enclosing
+declarative region, or for a pragma at the place of a compilation_unit,
+to the end of the compilation.  It gives advice to the implementation as
+to whether time or space is the primary optimization criterion, or that
+optional optimizations should be turned off.  [It is implementation
+defined how this advice is followed.]
+
+27.a
+          Implementation defined: Effect of pragma Optimize.
+
+27.b
+          Discussion: For example, a compiler might use Time vs.  Space
+          to control whether generic instantiations are implemented with
+          a macro-expansion model, versus a shared-generic-body model.
+
+27.c
+          We don't define what constitutes an "optimization" -- in fact,
+          it cannot be formally defined in the context of Ada.  One
+          compiler might call something an optional optimization,
+          whereas another compiler might consider that same thing to be
+          a normal part of code generation.  Thus, the programmer cannot
+          rely on this pragma having any particular portable effect on
+          the generated code.  Some compilers might even ignore the
+          pragma altogether.
+
+                              _Examples_
+
+28
+Examples of pragmas:
+
+29/3
+     {AI95-00433-01AI95-00433-01} {AI05-0229-1AI05-0229-1} pragma List(Off); 
-- turn off listing generation
+     pragma Optimize(Off); -- turn off optional optimizations
+     pragma Pure(Rational_Numbers); -- set categorization for package
+     pragma Assert(Exists(File_Name),
+                   Message => "Nonexistent file"); -- assert file exists
+
+                        _Extensions to Ada 83_
+
+29.a
+          The Optimize pragma now allows the identifier Off to request
+          that normal optimization be turned off.
+
+29.b
+          An Optimize pragma may appear anywhere pragmas are allowed.
+
+                     _Wording Changes from Ada 83_
+
+29.c
+          We now describe the pragmas Page, List, and Optimize here, to
+          act as examples, and to remove the normative material from
+          *note Annex L::, "*note Annex L:: Language-Defined Pragmas",
+          so it can be entirely an informative annex.
+
+                     _Wording Changes from Ada 95_
+
+29.d/2
+          {AI95-00433-01AI95-00433-01} Updated the example of named
+          pragma parameters, because the second parameter of pragma
+          Suppress is obsolescent.
+
+                    _Wording Changes from Ada 2005_
+
+29.e/3
+          {AI05-0229-1AI05-0229-1} Updated the example of pragmas,
+          because both pragmas Inline and Import are obsolescent.
+
+
+File: aarm2012.info,  Node: 2.9,  Prev: 2.8,  Up: 2
+
+2.9 Reserved Words
+==================
+
+                               _Syntax_
+
+1/1
+     This paragraph was deleted.
+
+2/3
+     {AI95-00284-02AI95-00284-02} {AI95-00395-01AI95-00395-01}
+     {AI05-0091-1AI05-0091-1} The following are the reserved words.
+     Within a program, some or all of the letters of a reserved word may
+     be in upper case.
+
+2.a
+          Discussion: Reserved words have special meaning in the syntax.
+          In addition, certain reserved words are used as attribute
+          names.
+
+2.b
+          The syntactic category identifier no longer allows reserved
+          words.  We have added the few reserved words that are legal
+          explicitly to the syntax for attribute_reference.  Allowing
+          identifier to include reserved words has been a source of
+          confusion for some users, and differs from the way they are
+          treated in the C and Pascal language definitions.
+
+abort      else        new          return
+abs        elsif       not          reverse
+abstract   end         null
+accept     entry                    select
+access     exception   of           separate
+aliased    exit        or           some
+all                    others       subtype
+and        for         out          synchronized
+array      function    overriding
+at                                  tagged
+           generic     package      task
+begin      goto        pragma       terminate
+body                   private      then
+           if          procedure    type
+case       in          protected
+constant   interface                until
+           is          raise        use
+declare                range
+delay      limited     record       when
+delta      loop        rem          while
+digits                 renames      with
+do         mod         requeue
+                                    xor
+
+     NOTES
+
+3
+     7  The reserved words appear in lower case boldface in this
+     International Standard, except when used in the designator of an
+     attribute (see *note 4.1.4::).  Lower case boldface is also used
+     for a reserved word in a string_literal used as an operator_symbol.
+     This is merely a convention -- programs may be written in whatever
+     typeface is desired and available.
+
+                    _Incompatibilities With Ada 83_
+
+3.a
+          The following words are not reserved in Ada 83, but are
+          reserved in Ada 95: abstract, aliased, protected, requeue,
+          tagged, until.
+
+                     _Wording Changes from Ada 83_
+
+3.b/3
+          {AI05-0299-1AI05-0299-1} The subclause entitled "Allowed
+          Replacements of Characters" has been moved to *note Annex J::,
+          "*note Annex J:: Obsolescent Features".
+
+                    _Incompatibilities With Ada 95_
+
+3.c/2
+          {AI95-00284-02AI95-00284-02} The following words are not
+          reserved in Ada 95, but are reserved in Ada 2005: interface,
+          overriding, synchronized.  A special allowance is made for
+          pragma Interface (see *note J.12::).  Uses of these words as
+          identifiers will need to be changed, but we do not expect them
+          to be common.
+
+                     _Wording Changes from Ada 95_
+
+3.d/2
+          {AI95-00395-01AI95-00395-01} The definition of upper case
+          equivalence has been modified to allow identifiers using all
+          of the characters of ISO 10646.  This change has no effect on
+          the character sequences that are reserved words, but does make
+          some unusual sequences of characters illegal.
+
+                   _Incompatibilities With Ada 2005_
+
+3.e/3
+          {AI05-0091-1AI05-0091-1} Correction: Removed other_format
+          characters from reserved words in order to be compatible with
+          the latest Unicode recommendations.  This change can only
+          affect programs written for original Ada 2005, and there is
+          little reason to put other_format characters into reserved
+          words in the first place, so there should be very few such
+          programs.
+
+3.f/3
+          {AI05-0176-1AI05-0176-1} The following word is not reserved in
+          Ada 2005, but is reserved in Ada 2012: some.  Uses of this
+          word as an identifier will need to be changed, but we do not
+          expect them to be common.
+
+
+File: aarm2012.info,  Node: 3,  Next: 4,  Prev: 2,  Up: Top
+
+3 Declarations and Types
+************************
+
+1/3
+{AI05-0299-1AI05-0299-1} This clause describes the types in the language
+and the rules for declaring constants, variables, and named numbers.
+
+* Menu:
+
+* 3.1 ::      Declarations
+* 3.2 ::      Types and Subtypes
+* 3.3 ::      Objects and Named Numbers
+* 3.4 ::      Derived Types and Classes
+* 3.5 ::      Scalar Types
+* 3.6 ::      Array Types
+* 3.7 ::      Discriminants
+* 3.8 ::      Record Types
+* 3.9 ::      Tagged Types and Type Extensions
+* 3.10 ::     Access Types
+* 3.11 ::     Declarative Parts
+
+
+File: aarm2012.info,  Node: 3.1,  Next: 3.2,  Up: 3
+
+3.1 Declarations
+================
+
+1
+The language defines several kinds of named entities that are declared
+by declarations.  The entity's name is defined by the declaration,
+usually by a defining_identifier (*note 3.1: S0022.), but sometimes by a
+defining_character_literal (*note 3.5.1: S0040.) or
+defining_operator_symbol (*note 6.1: S0171.).
+
+2
+There are several forms of declaration.  A basic_declaration is a form
+of declaration defined as follows.
+
+                               _Syntax_
+
+3/3
+     {AI95-00348-01AI95-00348-01} {AI05-0177-1AI05-0177-1}
+     basic_declaration ::=
+          type_declaration   | subtype_declaration
+        | object_declaration   | number_declaration
+        | subprogram_declaration   | abstract_subprogram_declaration
+        | null_procedure_declaration   | expression_function_declaration
+        | package_declaration   | renaming_declaration
+        | exception_declaration   | generic_declaration
+        | generic_instantiation
+
+4
+     defining_identifier ::= identifier
+
+                          _Static Semantics_
+
+5
+A declaration is a language construct that associates a name with (a
+view of) an entity.  A declaration may appear explicitly in the program
+text (an explicit declaration), or may be supposed to occur at a given
+place in the text as a consequence of the semantics of another construct
+(an implicit declaration).
+
+5.a
+          Discussion: An implicit declaration generally declares a
+          predefined or inherited operation associated with the
+          definition of a type.  This term is used primarily when
+          allowing explicit declarations to override implicit
+          declarations, as part of a type declaration.
+
+6/3
+{AI95-00318-02AI95-00318-02} {AI05-0255-1AI05-0255-1}
+{AI05-0277-1AI05-0277-1} Each of the following is defined to be a
+declaration: any basic_declaration (*note 3.1: S0021.); an
+enumeration_literal_specification (*note 3.5.1: S0039.); a
+discriminant_specification (*note 3.7: S0062.); a component_declaration
+(*note 3.8: S0070.); a loop_parameter_specification (*note 5.5: S0158.);
+an iterator_specification (*note 5.5.2: S0159.); a
+parameter_specification (*note 6.1: S0175.); a subprogram_body (*note
+6.3: S0177.); an extended_return_object_declaration (*note 6.5: S0185.);
+an entry_declaration (*note 9.5.2: S0218.); an entry_index_specification
+(*note 9.5.2: S0224.); a choice_parameter_specification (*note 11.2:
+S0267.); a generic_formal_parameter_declaration (*note 12.1: S0274.).
+
+6.a
+          Discussion: This list (when basic_declaration is expanded out)
+          contains all syntactic categories that end in "_declaration"
+          or "_specification", except for program unit _specifications.
+          Moreover, it contains subprogram_body.  A subprogram_body is a
+          declaration, whether or not it completes a previous
+          declaration.  This is a bit strange, subprogram_body is not
+          part of the syntax of basic_declaration or
+          library_unit_declaration.  A renaming-as-body is considered a
+          declaration.  An accept_statement is not considered a
+          declaration.  Completions are sometimes declarations, and
+          sometimes not.
+
+7
+All declarations contain a definition for a view of an entity.  A view
+consists of an identification of the entity (the entity of the view),
+plus view-specific characteristics that affect the use of the entity
+through that view (such as mode of access to an object, formal parameter
+names and defaults for a subprogram, or visibility to components of a
+type).  In most cases, a declaration also contains the definition for
+the entity itself (a renaming_declaration is an example of a declaration
+that does not define a new entity, but instead defines a view of an
+existing entity (see *note 8.5::)).
+
+7.a/2
+          Glossary entry: A view of an entity reveals some or all of the
+          properties of the entity.  A single entity may have multiple
+          views.
+
+7.b
+          Discussion: Most declarations define a view (of some entity)
+          whose view-specific characteristics are unchanging for the
+          life of the view.  However, subtypes are somewhat unusual in
+          that they inherit characteristics from whatever view of their
+          type is currently visible.  Hence, a subtype is not a view of
+          a type; it is more of an indirect reference.  By contrast, a
+          private type provides a single, unchanging (partial) view of
+          its full type.
+
+7.1/3
+{AI05-0080-1AI05-0080-1} When it is clear from context, the term object
+is used in place of view of an object.  Similarly, the terms type and
+subtype are used in place of view of a type and view of a subtype,
+respectively.
+
+7.c/3
+          Discussion: Rules interpreted at compile time generally refer
+          to views of entities, rather than the entities themselves.
+          This is necessary to preserve privacy; characteristics that
+          are not visible should not be used in compile-time rules.
+          Thus, Static Semantics and Legality Rules generally implicitly
+          have "view of".  Legality Rules that need to look into the
+          private part are the exception to this interpretation.
+
+7.d/3
+          On the other hand, run-time rules can work either way, so
+          "view of" should not be assumed in Dynamic Semantics rules.
+
+8
+For each declaration, the language rules define a certain region of text
+called the scope of the declaration (see *note 8.2::).  Most
+declarations associate an identifier with a declared entity.  Within its
+scope, and only there, there are places where it is possible to use the
+identifier to refer to the declaration, the view it defines, and the
+associated entity; these places are defined by the visibility rules (see
+*note 8.3::).  At such places the identifier is said to be a name of the
+entity (the direct_name or selector_name); the name is said to denote
+the declaration, the view, and the associated entity (see *note 8.6::).
+The declaration is said to declare the name, the view, and in most
+cases, the entity itself.
+
+9
+As an alternative to an identifier, an enumeration literal can be
+declared with a character_literal as its name (see *note 3.5.1::), and a
+function can be declared with an operator_symbol as its name (see *note
+6.1::).
+
+10
+The syntax rules use the terms defining_identifier,
+defining_character_literal (*note 3.5.1: S0040.), and
+defining_operator_symbol (*note 6.1: S0171.) for the defining occurrence
+of a name; these are collectively called defining names.  The terms
+direct_name and selector_name are used for usage occurrences of
+identifiers, character_literals, and operator_symbols.  These are
+collectively called usage names.
+
+10.a
+          To be honest: The terms identifier, character_literal, and
+          operator_symbol are used directly in contexts where the normal
+          visibility rules do not apply (such as the identifier that
+          appears after the end of a task_body).  Analogous conventions
+          apply to the use of designator, which is the collective term
+          for identifier and operator_symbol.
+
+                          _Dynamic Semantics_
+
+11
+The process by which a construct achieves its run-time effect is called
+execution.  This process is also called elaboration for declarations and
+evaluation for expressions.  One of the terms execution, elaboration, or
+evaluation is defined by this International Standard for each construct
+that has a run-time effect.
+
+11.a
+          Glossary entry: The process by which a construct achieves its
+          run-time effect is called execution.  Execution of a
+          declaration is also called elaboration.  Execution of an
+          expression is also called evaluation.
+
+11.b
+          To be honest: The term elaboration is also used for the
+          execution of certain constructs that are not declarations, and
+          the term evaluation is used for the execution of certain
+          constructs that are not expressions.  For example,
+          subtype_indications are elaborated, and ranges are evaluated.
+
+11.c
+          For bodies, execution and elaboration are both explicitly
+          defined.  When we refer specifically to the execution of a
+          body, we mean the explicit definition of execution for that
+          kind of body, not its elaboration.
+
+11.d
+          Discussion: Technically, "the execution of a declaration" and
+          "the elaboration of a declaration" are synonymous.  We use the
+          term "elaboration" of a construct when we know the construct
+          is elaborable.  When we are talking about more arbitrary
+          constructs, we use the term "execution".  For example, we use
+          the term "erroneous execution", to refer to any erroneous
+          execution, including erroneous elaboration or evaluation.
+
+11.e
+          When we explicitly define evaluation or elaboration for a
+          construct, we are implicitly defining execution of that
+          construct.
+
+11.f
+          We also use the term "execution" for things like statements,
+          which are executable, but neither elaborable nor evaluable.
+          We considered using the term "execution" only for
+          nonelaborable, nonevaluable constructs, and defining the term
+          "action" to mean what we have defined "execution" to mean.  We
+          rejected this idea because we thought three terms that mean
+          the same thing was enough -- four would be overkill.  Thus,
+          the term "action" is used only informally in the standard
+          (except where it is defined as part of a larger term, such as
+          "protected action").
+
+11.f.1/2
+          Glossary entry: The process by which a declaration achieves
+          its run-time effect is called elaboration.  Elaboration is one
+          of the forms of execution.
+
+11.f.2/2
+          Glossary entry: The process by which an expression achieves
+          its run-time effect is called evaluation.  Evaluation is one
+          of the forms of execution.
+
+11.g
+          To be honest: A construct is elaborable if elaboration is
+          defined for it.  A construct is evaluable if evaluation is
+          defined for it.  A construct is executable if execution is
+          defined for it.
+
+11.h
+          Discussion: Don't confuse "elaborable" with "preelaborable"
+          (defined in *note 10.2.1::).
+
+11.i/2
+          {AI95-00114-01AI95-00114-01} Evaluation of an evaluable
+          construct produces a result that is either a value, a
+          denotation, or a range.  The following are evaluable:
+          expression; name prefix; range; entry_index_specification; and
+          possibly discrete_range.  The last one is curious -- RM83 uses
+          the term "evaluation of a discrete_range," but never defines
+          it.  One might presume that the evaluation of a discrete_range
+          consists of the evaluation of the range or the
+          subtype_indication, depending on what it is.  But
+          subtype_indications are not evaluated; they are elaborated.
+
+11.j
+          Intuitively, an executable construct is one that has a defined
+          run-time effect (which may be null).  Since execution includes
+          elaboration and evaluation as special cases, all elaborable
+          and all evaluable constructs are also executable.  Hence, most
+          constructs in Ada are executable.  An important exception is
+          that the constructs inside a generic unit are not executable
+          directly, but rather are used as a template for (generally)
+          executable constructs in instances of the generic.
+
+     NOTES
+
+12
+     1  At compile time, the declaration of an entity declares the
+     entity.  At run time, the elaboration of the declaration creates
+     the entity.
+
+12.a
+          Ramification: Syntactic categories for declarations are named
+          either entity_declaration (if they include a trailing
+          semicolon) or entity_specification (if not).
+
+12.b
+          The various kinds of named entities that can be declared are
+          as follows: an object (including components and parameters), a
+          named number, a type (the name always refers to its first
+          subtype), a subtype, a subprogram (including enumeration
+          literals and operators), a single entry, an entry family, a
+          package, a protected or task unit (which corresponds to either
+          a type or a single object), an exception, a generic unit, a
+          label, and the name of a statement.
+
+12.c
+          Identifiers are also associated with names of pragmas,
+          arguments to pragmas, and with attributes, but these are not
+          user-definable.
+
+                     _Wording Changes from Ada 83_
+
+12.d
+          The syntax rule for defining_identifier is new.  It is used
+          for the defining occurrence of an identifier.  Usage
+          occurrences use the direct_name or selector_name syntactic
+          categories.  Each occurrence of an identifier (or
+          simple_name), character_literal, or operator_symbol in the Ada
+          83 syntax rules is handled as follows in Ada 95:
+
+12.e
+             * It becomes a defining_identifier,
+               defining_character_literal, or defining_operator_symbol
+               (or some syntactic category composed of these), to
+               indicate a defining occurrence;
+
+12.f/3
+             * {AI05-0299-1AI05-0299-1} It becomes a direct_name, in
+               usage occurrences where the usage is required (in Clause
+               *note 8::) to be directly visible;
+
+12.g/3
+             * {AI05-0299-1AI05-0299-1} It becomes a selector_name, in
+               usage occurrences where the usage is required (in Clause
+               *note 8::) to be visible but not necessarily directly
+               visible;
+
+12.h
+             * It remains an identifier, character_literal, or
+               operator_symbol, in cases where the visibility rules do
+               not apply (such as the designator that appears after the
+               end of a subprogram_body).
+
+12.i
+          For declarations that come in "two parts" (program unit
+          declaration plus body, private or incomplete type plus full
+          type, deferred constant plus full constant), we consider both
+          to be defining occurrences.  Thus, for example, the syntax for
+          package_body uses defining_identifier after the reserved word
+          body, as opposed to direct_name.
+
+12.j
+          The defining occurrence of a statement name is in its implicit
+          declaration, not where it appears in the program text.
+          Considering the statement name itself to be the defining
+          occurrence would complicate the visibility rules.
+
+12.k
+          The phrase "visible by selection" is not used in Ada 95.  It
+          is subsumed by simply "visible" and the Name Resolution Rules
+          for selector_names.
+
+12.l/3
+          {AI05-0299-1AI05-0299-1} (Note that in Ada 95, a declaration
+          is visible at all places where one could have used a
+          selector_name, not just at places where a selector_name was
+          actually used.  Thus, the places where a declaration is
+          directly visible are a subset of the places where it is
+          visible.  See Clause *note 8:: for details.)
+
+12.m
+          We use the term "declaration" to cover _specifications that
+          declare (views of) objects, such as parameter_specifications.
+          In Ada 83, these are referred to as a "form of declaration,"
+          but it is not entirely clear that they are considered simply
+          "declarations."
+
+12.n/3
+          {AI05-0299-1AI05-0299-1} RM83 contains an incomplete
+          definition of "elaborated" in this subclause: it defines
+          "elaborated" for declarations, declarative_parts,
+          declarative_items and compilation_units, but "elaboration" is
+          defined elsewhere for various other constructs.  To make
+          matters worse, Ada 95 has a different set of elaborable
+          constructs.  Instead of correcting the list, it is more
+          maintainable to refer to the term "elaborable," which is
+          defined in a distributed manner.
+
+12.o
+          RM83 uses the term "has no other effect" to describe an
+          elaboration that doesn't do anything except change the state
+          from not-yet-elaborated to elaborated.  This was a confusing
+          wording, because the answer to "other than what?"  was to be
+          found many pages away.  In Ada 95, we change this wording to
+          "has no effect" (for things that truly do nothing at run
+          time), and "has no effect other than to establish that
+          so-and-so can happen without failing the Elaboration_Check"
+          (for things where it matters).
+
+12.p
+          We make it clearer that the term "execution" covers
+          elaboration and evaluation as special cases.  This was implied
+          in RM83.  For example, "erroneous execution" can include any
+          execution, and RM83-9.4(3) has, "The task designated by any
+          other task object depends on the master whose execution
+          creates the task object;" the elaboration of the master's
+          declarative_part is doing the task creation.
+
+                     _Wording Changes from Ada 95_
+
+12.q/2
+          {AI95-00318-02AI95-00318-02} Added extended_return_statement
+          to the list of declarations.
+
+12.r/2
+          {AI95-00348-01AI95-00348-01} Added null procedures (see *note
+          6.7::) to the syntax.
+
+                    _Wording Changes from Ada 2005_
+
+12.s/3
+          {AI05-0177-1AI05-0177-1} Added expression functions (see *note
+          6.8::) to the syntax.
+
+
+File: aarm2012.info,  Node: 3.2,  Next: 3.3,  Prev: 3.1,  Up: 3
+
+3.2 Types and Subtypes
+======================
+
+                          _Static Semantics_
+
+1
+A type is characterized by a set of values, and a set of primitive
+operations which implement the fundamental aspects of its semantics.  An
+object of a given type is a run-time entity that contains (has) a value
+of the type.
+
+1.a/2
+          Glossary entry: Each object has a type.  A type has an
+          associated set of values, and a set of primitive operations
+          which implement the fundamental aspects of its semantics.
+          Types are grouped into categories.  Most language-defined
+          categories of types are also classes of types.
+
+1.b/3
+          Glossary entry: A subtype is a type together with optional
+          constraints, null exclusions, and predicates, which constrain
+          the values of the subtype to satisfy certain conditions.  The
+          values of a subtype are a subset of the values of its type.
+
+2/2
+{AI95-00442-01AI95-00442-01} Types are grouped into categories of types.
+There exist several language-defined categories of types (see NOTES
+below), reflecting the similarity of their values and primitive
+operations.  [Most categories of types form classes of types.]
+Elementary types are those whose values are logically indivisible; 
+composite types are those whose values are composed of component values.
+
+2.a/2
+          Proof: {AI95-00442-01AI95-00442-01} The formal definition of
+          category and class is found in *note 3.4::.
+
+2.b/2
+          Glossary entry: A class is a set of types that is closed under
+          derivation, which means that if a given type is in the class,
+          then all types derived from that type are also in the class.
+          The set of types of a class share common properties, such as
+          their primitive operations.
+
+2.b.1/2
+          Glossary entry: A category of types is a set of types with one
+          or more common properties, such as primitive operations.  A
+          category of types that is closed under derivation is also
+          known as a class.
+
+2.c
+          Glossary entry: An elementary type does not have components.
+
+2.d/2
+          Glossary entry: A composite type may have components.
+
+2.e
+          Glossary entry: A scalar type is either a discrete type or a
+          real type.
+
+2.f
+          Glossary entry: An access type has values that designate
+          aliased objects.  Access types correspond to "pointer types"
+          or "reference types" in some other languages.
+
+2.g
+          Glossary entry: A discrete type is either an integer type or
+          an enumeration type.  Discrete types may be used, for example,
+          in case_statements and as array indices.
+
+2.h
+          Glossary entry: A real type has values that are approximations
+          of the real numbers.  Floating point and fixed point types are
+          real types.
+
+2.i
+          Glossary entry: Integer types comprise the signed integer
+          types and the modular types.  A signed integer type has a base
+          range that includes both positive and negative numbers, and
+          has operations that may raise an exception when the result is
+          outside the base range.  A modular type has a base range whose
+          lower bound is zero, and has operations with "wraparound"
+          semantics.  Modular types subsume what are called "unsigned
+          types" in some other languages.
+
+2.j
+          Glossary entry: An enumeration type is defined by an
+          enumeration of its values, which may be named by identifiers
+          or character literals.
+
+2.k
+          Glossary entry: A character type is an enumeration type whose
+          values include characters.
+
+2.l
+          Glossary entry: A record type is a composite type consisting
+          of zero or more named components, possibly of different types.
+
+2.m
+          Glossary entry: A record extension is a type that extends
+          another type by adding additional components.
+
+2.n
+          Glossary entry: An array type is a composite type whose
+          components are all of the same type.  Components are selected
+          by indexing.
+
+2.o/2
+          Glossary entry: A task type is a composite type used to
+          represent active entities which execute concurrently and which
+          can communicate via queued task entries.  The top-level task
+          of a partition is called the environment task.
+
+2.p/2
+          Glossary entry: A protected type is a composite type whose
+          components are accessible only through one of its protected
+          operations which synchronize concurrent access by multiple
+          tasks.
+
+2.q/2
+          Glossary entry: A private type gives a view of a type that
+          reveals only some of its properties.  The remaining properties
+          are provided by the full view given elsewhere.  Private types
+          can be used for defining abstractions that hide unnecessary
+          details from their clients.
+
+2.r/2
+          Glossary entry: A private extension is a type that extends
+          another type, with the additional properties hidden from its
+          clients.
+
+2.s/2
+          Glossary entry: An incomplete type gives a view of a type that
+          reveals only some of its properties.  The remaining properties
+          are provided by the full view given elsewhere.  Incomplete
+          types can be used for defining recursive data structures.
+
+3
+The elementary types are the scalar types (discrete and real) and the
+access types (whose values provide access to objects or subprograms).  
+Discrete types are either integer types or are defined by enumeration of
+their values (enumeration types).  Real types are either floating point
+types or fixed point types.
+
+4/2
+{AI95-00251-01AI95-00251-01} {AI95-00326-01AI95-00326-01} The composite
+types are the record types, record extensions, array types, interface
+types, task types, and protected types.
+
+4.a/2
+          This paragraph was deleted.{AI95-00442-01AI95-00442-01}
+
+4.1/2
+{AI95-00326-01AI95-00326-01} There can be multiple views of a type with
+varying sets of operations.  [An incomplete type represents an
+incomplete view (see *note 3.10.1::) of a type with a very restricted
+usage, providing support for recursive data structures.  A private type
+or private extension represents a partial view (see *note 7.3::) of a
+type, providing support for data abstraction.  The full view (see *note
+3.2.1::) of a type represents its complete definition.]  An incomplete
+or partial view is considered a composite type[, even if the full view
+is not].
+
+4.b/3
+          Proof: {AI05-0299-1AI05-0299-1} The real definitions of the
+          views are in the referenced subclauses.
+
+5/2
+{AI95-00326-01AI95-00326-01} Certain composite types (and views thereof)
+have special components called discriminants whose values affect the
+presence, constraints, or initialization of other components.
+Discriminants can be thought of as parameters of the type.
+
+6/2
+{AI95-00366-01AI95-00366-01} The term subcomponent is used in this
+International Standard in place of the term component to indicate either
+a component, or a component of another subcomponent.  Where other
+subcomponents are excluded, the term component is used instead.
+Similarly, a part of an object or value is used to mean the whole object
+or value, or any set of its subcomponents.  The terms component,
+subcomponent, and part are also applied to a type meaning the component,
+subcomponent, or part of objects and values of the type.
+
+6.a
+          Discussion: The definition of "part" here is designed to
+          simplify rules elsewhere.  By design, the intuitive meaning of
+          "part" will convey the correct result to the casual reader,
+          while this formalistic definition will answer the concern of
+          the compiler-writer.
+
+6.b
+          We use the term "part" when talking about the parent part,
+          ancestor part, or extension part of a type extension.  In
+          contexts such as these, the part might represent an empty set
+          of subcomponents (e.g.  in a null record extension, or a
+          nonnull extension of a null record).  We also use "part" when
+          specifying rules such as those that apply to an object with a
+          "controlled part" meaning that it applies if the object as a
+          whole is controlled, or any subcomponent is.
+
+7/2
+{AI95-00231-01AI95-00231-01} The set of possible values for an object of
+a given type can be subjected to a condition that is called a constraint
+(the case of a null constraint that specifies no restriction is also
+included)[; the rules for which values satisfy a given kind of
+constraint are given in *note 3.5:: for range_constraints, *note 3.6.1::
+for index_constraints, and *note 3.7.1:: for discriminant_constraints].
+The set of possible values for an object of an access type can also be
+subjected to a condition that excludes the null value (see *note
+3.10::).
+
+8/2
+{AI95-00231-01AI95-00231-01} {AI95-00415-01AI95-00415-01} A subtype of a
+given type is a combination of the type, a constraint on values of the
+type, and certain attributes specific to the subtype.  The given type is
+called the type of the subtype.  Similarly, the associated constraint is
+called the constraint of the subtype.   The set of values of a subtype
+consists of the values of its type that satisfy its constraint and any
+exclusion of the null value.  Such values belong to the subtype.  
+
+8.a
+          Discussion: We make a strong distinction between a type and
+          its subtypes.  In particular, a type is not a subtype of
+          itself.  There is no constraint associated with a type (not
+          even a null one), and type-related attributes are distinct
+          from subtype-specific attributes.
+
+8.b
+          Discussion: We no longer use the term "base type."  All types
+          were "base types" anyway in Ada 83, so the term was redundant,
+          and occasionally confusing.  In the RM95 we say simply "the
+          type of the subtype" instead of "the base type of the
+          subtype."
+
+8.c
+          Ramification: The value subset for a subtype might be empty,
+          and need not be a proper subset.
+
+8.d/2
+          To be honest: {AI95-00442-01AI95-00442-01} Any name of a
+          category of types (such as "discrete", "real", or "limited")
+          is also used to qualify its subtypes, as well as its objects,
+          values, declarations, and definitions, such as an "integer
+          type declaration" or an "integer value."  In addition, if a
+          term such as "parent subtype" or "index subtype" is defined,
+          then the corresponding term for the type of the subtype is
+          "parent type" or "index type."
+
+8.e
+          Discussion: We use these corresponding terms without
+          explicitly defining them, when the meaning is obvious.
+
+9
+A subtype is called an unconstrained subtype if its type has unknown
+discriminants, or if its type allows range, index, or discriminant
+constraints, but the subtype does not impose such a constraint;
+otherwise, the subtype is called a constrained subtype (since it has no
+unconstrained characteristics).
+
+9.a
+          Discussion: In an earlier version of Ada 9X, "constrained"
+          meant "has a nonnull constraint."  However, we changed to this
+          definition since we kept having to special case composite
+          non-array/nondiscriminated types.  It also corresponds better
+          to the (now obsolescent) attribute 'Constrained.
+
+9.b
+          For scalar types, "constrained" means "has a nonnull
+          constraint".  For composite types, in implementation terms,
+          "constrained" means that the size of all objects of the
+          subtype is the same, assuming a typical implementation model.
+
+9.c
+          Class-wide subtypes are always unconstrained.
+
+     NOTES
+
+10/2
+     2  {AI95-00442-01AI95-00442-01} Any set of types can be called a
+     "category" of types, and any set of types that is closed under
+     derivation (see *note 3.4::) can be called a "class" of types.
+     However, only certain categories and classes are used in the
+     description of the rules of the language -- generally those that
+     have their own particular set of primitive operations (see *note
+     3.2.3::), or that correspond to a set of types that are matched by
+     a given kind of generic formal type (see *note 12.5::).  The
+     following are examples of "interesting" language-defined classes:
+     elementary, scalar, discrete, enumeration, character, boolean,
+     integer, signed integer, modular, real, floating point, fixed
+     point, ordinary fixed point, decimal fixed point, numeric, access,
+     access-to-object, access-to-subprogram, composite, array, string,
+     (untagged) record, tagged, task, protected, nonlimited.  Special
+     syntax is provided to define types in each of these classes.  In
+     addition to these classes, the following are examples of
+     "interesting" language-defined categories: abstract, incomplete,
+     interface, limited, private, record.
+
+10.a
+          Discussion: A value is a run-time entity with a given type
+          which can be assigned to an object of an appropriate subtype
+          of the type.  An operation is a program entity that operates
+          on zero or more operands to produce an effect, or yield a
+          result, or both.
+
+10.b/2
+          Ramification: {AI95-00442-01AI95-00442-01} Note that a type's
+          category (and class) depends on the place of the reference --
+          a private type is composite outside and possibly elementary
+          inside.  It's really the view that is elementary or composite.
+          Note that although private types are composite, there are some
+          properties that depend on the corresponding full view -- for
+          example, parameter passing modes, and the constraint checks
+          that apply in various places.
+
+10.c/2
+          {AI95-00345-01AI95-00345-01} {AI95-00442-01AI95-00442-01}
+          Every property of types forms a category, but not every
+          property of types represents a class.  For example, the set of
+          all abstract types does not form a class, because this set is
+          not closed under derivation.  Similarly, the set of all
+          interface types does not form a class.
+
+10.d/2
+          {AI95-00442-01AI95-00442-01} The set of limited types does not
+          form a class (since nonlimited types can inherit from limited
+          interfaces), but the set of nonlimited types does.  The set of
+          tagged record types and the set of tagged private types do not
+          form a class (because each of them can be extended to create a
+          type of the other category); that implies that the set of
+          record types and the set of private types also do not form a
+          class (even though untagged record types and untagged private
+          types do form a class).  In all of these cases, we can talk
+          about the category of the type; for instance, we can talk
+          about the "category of limited types"..
+
+10.e/2
+          {AI95-00442-01AI95-00442-01} Normatively, the language-defined
+          classes are those that are defined to be inherited on
+          derivation by *note 3.4::; other properties either aren't
+          interesting or form categories, not classes.
+
+11/2
+     {AI95-00442-01AI95-00442-01} These language-defined categories are
+     organized like this:
+
+12/2
+          {AI95-00345-01AI95-00345-01} all types
+             elementary
+                scalar
+                   discrete
+                      enumeration
+                         character
+                         boolean
+                         other enumeration
+                      integer
+                         signed integer
+                         modular integer
+                   real
+                      floating point
+                      fixed point
+                         ordinary fixed point
+                         decimal fixed point
+                access
+                   access-to-object
+                   access-to-subprogram
+             composite
+                untagged
+                   array
+                      string
+                      other array
+                   record
+                   task
+                   protected
+                tagged (including interfaces)
+                   nonlimited tagged record
+                   limited tagged
+                      limited tagged record
+                      synchronized tagged
+                         tagged task
+                         tagged protected
+
+13/2
+     {AI95-00345-01AI95-00345-01} {AI95-00442-01AI95-00442-01} There are
+     other categories, such as "numeric" and "discriminated", which
+     represent other categorization dimensions, but do not fit into the
+     above strictly hierarchical picture.
+
+13.a.1/2
+          Discussion: {AI95-00345-01AI95-00345-01}
+          {AI95-00442-01AI95-00442-01} Note that this is also true for
+          some categories mentioned in the chart.  The category "task"
+          includes both untagged tasks and tagged tasks.  Similarly for
+          "protected", "limited", and "nonlimited" (note that limited
+          and nonlimited are not shown for untagged composite types).
+
+                     _Wording Changes from Ada 83_
+
+13.a/3
+          {AI05-0299-1AI05-0299-1} This subclause now precedes the
+          subclauses on objects and named numbers, to cut down on the
+          number of forward references.
+
+13.b
+          We have dropped the term "base type" in favor of simply "type"
+          (all types in Ada 83 were "base types" so it wasn't clear when
+          it was appropriate/necessary to say "base type").  Given a
+          subtype S of a type T, we call T the "type of the subtype S."
+
+                     _Wording Changes from Ada 95_
+
+13.c/2
+          {AI95-00231-01AI95-00231-01} Added a mention of null
+          exclusions when we're talking about constraints (these are not
+          constraints, but they are similar).
+
+13.d/2
+          {AI95-00251-01AI95-00251-01} Defined an interface type to be a
+          composite type.
+
+13.e/2
+          {AI95-00326-01AI95-00326-01} Revised the wording so that it is
+          clear that an incomplete view is similar to a partial view in
+          terms of the language.
+
+13.f/2
+          {AI95-00366-01AI95-00366-01} Added a definition of component
+          of a type, subcomponent of a type, and part of a type.  These
+          are commonly used in the standard, but they were not
+          previously defined.
+
+13.g/3
+          {AI95-00442-01AI95-00442-01} {AI05-0299-1AI05-0299-1} Reworded
+          most of this subclause to use category rather than class,
+          since so many interesting properties are not, strictly
+          speaking, classes.  Moreover, there was no normative
+          description of exactly which properties formed classes, and
+          which did not.  The real definition of class, along with a
+          list of properties, is now in *note 3.4::.
+
+* Menu:
+
+* 3.2.1 ::    Type Declarations
+* 3.2.2 ::    Subtype Declarations
+* 3.2.3 ::    Classification of Operations
+* 3.2.4 ::    Subtype Predicates
+
+
+File: aarm2012.info,  Node: 3.2.1,  Next: 3.2.2,  Up: 3.2
+
+3.2.1 Type Declarations
+-----------------------
+
+1
+A type_declaration declares a type and its first subtype.
+
+                               _Syntax_
+
+2
+     type_declaration ::=  full_type_declaration
+        | incomplete_type_declaration
+        | private_type_declaration
+        | private_extension_declaration
+
+3/3
+     {AI05-0183-1AI05-0183-1} full_type_declaration ::=
+          type defining_identifier [known_discriminant_part] is 
+     type_definition
+             [aspect_specification];
+        | task_type_declaration
+        | protected_type_declaration
+
+4/2
+     {AI95-00251-01AI95-00251-01} type_definition ::=
+          enumeration_type_definition   | integer_type_definition
+        | real_type_definition   | array_type_definition
+        | record_type_definition   | access_type_definition
+        | derived_type_definition   | interface_type_definition
+
+                           _Legality Rules_
+
+5
+A given type shall not have a subcomponent whose type is the given type
+itself.
+
+                          _Static Semantics_
+
+6
+The defining_identifier (*note 3.1: S0022.) of a type_declaration (*note
+3.2.1: S0023.) denotes the first subtype of the type.  The
+known_discriminant_part (*note 3.7: S0061.), if any, defines the
+discriminants of the type (see *note 3.7::, "*note 3.7::
+Discriminants").  The remainder of the type_declaration (*note 3.2.1:
+S0023.) defines the remaining characteristics of (the view of) the type.
+
+7/2
+{AI95-00230-01AI95-00230-01} A type defined by a type_declaration (*note
+3.2.1: S0023.) is a named type; such a type has one or more nameable
+subtypes.  Certain other forms of declaration also include type
+definitions as part of the declaration for an object.  The type defined
+by such a declaration is anonymous -- it has no nameable subtypes.  For
+explanatory purposes, this International Standard sometimes refers to an
+anonymous type by a pseudo-name, written in italics, and uses such
+pseudo-names at places where the syntax normally requires an identifier.
+For a named type whose first subtype is T, this International Standard
+sometimes refers to the type of T as simply "the type T".
+
+7.a/2
+          Ramification: {AI95-00230-01AI95-00230-01} The only
+          user-defined types that can be anonymous in the above sense
+          are array, access, task, and protected types.  An anonymous
+          array, task, or protected type can be defined as part of an
+          object_declaration.  An anonymous access type can be defined
+          as part of numerous other constructs.
+
+8/2
+{AI95-00230-01AI95-00230-01} {AI95-00326-01AI95-00326-01} A named type
+that is declared by a full_type_declaration (*note 3.2.1: S0024.), or an
+anonymous type that is defined by an access_definition or as part of
+declaring an object of the type, is called a full type.  The declaration
+of a full type also declares the full view of the type.  The
+type_definition (*note 3.2.1: S0025.), task_definition (*note 9.1:
+S0207.), protected_definition (*note 9.4: S0212.), or access_definition
+(*note 3.10: S0084.) that defines a full type is called a full type
+definition.  [Types declared by other forms of type_declaration (*note
+3.2.1: S0023.) are not separate types; they are partial or incomplete
+views of some full type.]
+
+8.a
+          To be honest: Class-wide, universal, and root numeric types
+          are full types.
+
+8.b/2
+          Reason: {AI95-00230-01AI95-00230-01} We need to mention
+          access_definition separately, as it may occur in renames,
+          which do not declare objects.
+
+9
+The definition of a type implicitly declares certain predefined
+operators that operate on the type, according to what classes the type
+belongs, as specified in *note 4.5::, "*note 4.5:: Operators and
+Expression Evaluation".
+
+9.a
+          Discussion: We no longer talk about the implicit declaration
+          of basic operations.  These are treated like an if_statement
+          -- they don't need to be declared, but are still applicable to
+          only certain classes of types.
+
+10
+The predefined types [(for example the types Boolean, Wide_Character,
+Integer, root_integer, and universal_integer)] are the types that are
+defined in [a predefined library package called] Standard[; this package
+also includes the [(implicit)] declarations of their predefined
+operators].  [The package Standard is described in *note A.1::.]
+
+10.a
+          Ramification: We use the term "predefined" to refer to
+          entities declared in the visible part of Standard, to
+          implicitly declared operators of a type whose semantics are
+          defined by the language, to Standard itself, and to the
+          "predefined environment".  We do not use this term to refer to
+          library packages other than Standard.  For example Text_IO is
+          a language-defined package, not a predefined package, and
+          Text_IO.Put_Line is not a predefined operation.
+
+                          _Dynamic Semantics_
+
+11
+The elaboration of a full_type_declaration consists of the elaboration
+of the full type definition.  Each elaboration of a full type definition
+creates a distinct type and its first subtype.
+
+11.a
+          Reason: The creation is associated with the type definition,
+          rather than the type declaration, because there are types that
+          are created by full type definitions that are not immediately
+          contained within a type declaration (e.g.  an array object
+          declaration, a singleton task declaration, etc.).
+
+11.b
+          Ramification: Any implicit declarations that occur immediately
+          following the full type definition are elaborated where they
+          (implicitly) occur.
+
+                              _Examples_
+
+12
+Examples of type definitions:
+
+13
+     (White, Red, Yellow, Green, Blue, Brown, Black)
+     range 1 .. 72
+     array(1 .. 10) of Integer
+
+14
+Examples of type declarations:
+
+15
+     type Color  is (White, Red, Yellow, Green, Blue, Brown, Black);
+     type Column is range 1 .. 72;
+     type Table  is array(1 .. 10) of Integer;
+
+     NOTES
+
+16
+     3  Each of the above examples declares a named type.  The
+     identifier given denotes the first subtype of the type.  Other
+     named subtypes of the type can be declared with
+     subtype_declarations (see *note 3.2.2::).  Although names do not
+     directly denote types, a phrase like "the type Column" is sometimes
+     used in this International Standard to refer to the type of Column,
+     where Column denotes the first subtype of the type.  For an example
+     of the definition of an anonymous type, see the declaration of the
+     array Color_Table in *note 3.3.1::; its type is anonymous -- it has
+     no nameable subtypes.
+
+                     _Wording Changes from Ada 83_
+
+16.a
+          The syntactic category full_type_declaration now includes task
+          and protected type declarations.
+
+16.b/3
+          {AI05-0299-1AI05-0299-1} We have generalized the concept of
+          first-named subtype (now called simply "first subtype") to
+          cover all kinds of types, for uniformity of description
+          elsewhere.  RM83 defined first-named subtype in Section 13.
+          We define first subtype here, because it is now a more
+          fundamental concept.  We renamed the term, because in Ada 95
+          some first subtypes have no name.
+
+16.c/2
+          {AI95-00230-01AI95-00230-01} We no longer elaborate
+          discriminant_parts, because there is nothing to do, and it was
+          complex to say that you only wanted to elaborate it once for a
+          private or incomplete type.  This is also consistent with the
+          fact that subprogram specifications are not elaborated
+          (neither in Ada 83 nor in Ada 95).  Note, however, that an
+          access_definition appearing in a discriminant_part is
+          elaborated at the full_type_declaration (for a nonlimited
+          type) or when an object with such a discriminant is created
+          (for a limited type).
+
+                     _Wording Changes from Ada 95_
+
+16.d/2
+          {AI95-00230-01AI95-00230-01} Added wording so that anonymous
+          access types are always full types, even if they appear in
+          renames.
+
+16.e/2
+          {AI95-00251-01AI95-00251-01} Added interface types (see *note
+          3.9.4::) to the syntax.
+
+16.f/2
+          {AI95-00326-01AI95-00326-01} Added a definition of full view,
+          so that all types have a well-defined full view.
+
+                       _Extensions to Ada 2005_
+
+16.g/3
+          {AI05-0183-1AI05-0183-1} An optional aspect_specification can
+          be used in a full_type_declaration.  This is described in
+          *note 13.1.1::.
+
+
+File: aarm2012.info,  Node: 3.2.2,  Next: 3.2.3,  Prev: 3.2.1,  Up: 3.2
+
+3.2.2 Subtype Declarations
+--------------------------
+
+1
+A subtype_declaration declares a subtype of some previously declared
+type, as defined by a subtype_indication.
+
+                               _Syntax_
+
+2/3
+     {AI05-0183-1AI05-0183-1} subtype_declaration ::=
+        subtype defining_identifier is subtype_indication
+             [aspect_specification];
+
+3/2
+     {AI95-00231-01AI95-00231-01} subtype_indication ::=  [
+     null_exclusion] subtype_mark [constraint]
+
+4
+     subtype_mark ::= subtype_name
+
+4.a
+          Ramification: Note that name includes attribute_reference;
+          thus, S'Base can be used as a subtype_mark.
+
+4.b
+          Reason: We considered changing subtype_mark to subtype_name.
+          However, existing users are used to the word "mark," so we're
+          keeping it.
+
+5
+     constraint ::= scalar_constraint | composite_constraint
+
+6
+     scalar_constraint ::=
+          range_constraint | digits_constraint | delta_constraint
+
+7
+     composite_constraint ::=
+          index_constraint | discriminant_constraint
+
+                        _Name Resolution Rules_
+
+8
+A subtype_mark shall resolve to denote a subtype.  The type determined
+by a subtype_mark is the type of the subtype denoted by the
+subtype_mark.
+
+8.a/3
+          Ramification: {AI05-0005-1AI05-0005-1} Types are never
+          directly named; all subtype_marks denote subtypes -- possibly
+          an unconstrained (base) subtype, but never the type.  When we
+          use the term anonymous type we really mean a type with no
+          nameable subtypes.
+
+                          _Dynamic Semantics_
+
+9
+The elaboration of a subtype_declaration consists of the elaboration of
+the subtype_indication.  The elaboration of a subtype_indication creates
+a new subtype.  If the subtype_indication does not include a constraint,
+the new subtype has the same (possibly null) constraint as that denoted
+by the subtype_mark.  The elaboration of a subtype_indication that
+includes a constraint proceeds as follows:
+
+10
+   * The constraint is first elaborated.
+
+11
+   * A check is then made that the constraint is compatible with the
+     subtype denoted by the subtype_mark.
+
+11.a
+          Ramification: The checks associated with constraint
+          compatibility are all Range_Checks.  Discriminant_Checks and
+          Index_Checks are associated only with checks that a value
+          satisfies a constraint.
+
+12
+The condition imposed by a constraint is the condition obtained after
+elaboration of the constraint.  The rules defining compatibility are
+given for each form of constraint in the appropriate subclause.  These
+rules are such that if a constraint is compatible with a subtype, then
+the condition imposed by the constraint cannot contradict any condition
+already imposed by the subtype on its values.  The exception
+Constraint_Error is raised if any check of compatibility fails.
+
+12.a
+          To be honest: The condition imposed by a constraint is named
+          after it -- a range_constraint imposes a range constraint,
+          etc.
+
+12.b
+          Ramification: A range_constraint causes freezing of its type.
+          Other constraints do not.
+
+     NOTES
+
+13
+     4  A scalar_constraint may be applied to a subtype of an
+     appropriate scalar type (see *note 3.5::, *note 3.5.9::, and *note
+     J.3::), even if the subtype is already constrained.  On the other
+     hand, a composite_constraint may be applied to a composite subtype
+     (or an access-to-composite subtype) only if the composite subtype
+     is unconstrained (see *note 3.6.1:: and *note 3.7.1::).
+
+                              _Examples_
+
+14
+Examples of subtype declarations:
+
+15/2
+     {AI95-00433-01AI95-00433-01} subtype Rainbow   is Color range Red .. 
Blue;        --  see *note 3.2.1::
+     subtype Red_Blue  is Rainbow;
+     subtype Int       is Integer;
+     subtype Small_Int is Integer range -10 .. 10;
+     subtype Up_To_K   is Column range 1 .. K;            --  see *note 3.2.1::
+     subtype Square    is Matrix(1 .. 10, 1 .. 10);       --  see *note 3.6::
+     subtype Male      is Person(Sex => M);               --  see *note 
3.10.1::
+     subtype Binop_Ref is not null Binop_Ptr;             --  see *note 3.10::
+
+                    _Incompatibilities With Ada 83_
+
+15.a
+          In Ada 95, all range_constraints cause freezing of their type.
+          Hence, a type-related representation item for a scalar type
+          has to precede any range_constraints whose type is the scalar
+          type.
+
+                     _Wording Changes from Ada 83_
+
+15.b
+          Subtype_marks allow only subtype names now, since types are
+          never directly named.  There is no need for RM83-3.3.2(3),
+          which says a subtype_mark can denote both the type and the
+          subtype; in Ada 95, you denote an unconstrained (base) subtype
+          if you want, but never the type.
+
+15.c
+          The syntactic category type_mark is now called subtype_mark,
+          since it always denotes a subtype.
+
+                        _Extensions to Ada 95_
+
+15.d/2
+          {AI95-00231-01AI95-00231-01} An optional null_exclusion can be
+          used in a subtype_indication.  This is described in *note
+          3.10::.
+
+                       _Extensions to Ada 2005_
+
+15.e/3
+          {AI05-0183-1AI05-0183-1} An optional aspect_specification can
+          be used in a subtype_declaration.  This is described in *note
+          13.1.1::.
+
+
+File: aarm2012.info,  Node: 3.2.3,  Next: 3.2.4,  Prev: 3.2.2,  Up: 3.2
+
+3.2.3 Classification of Operations
+----------------------------------
+
+                          _Static Semantics_
+
+1/2
+{AI95-00416-01AI95-00416-01} An operation operates on a type T if it
+yields a value of type T, if it has an operand whose expected type (see
+*note 8.6::) is T, or if it has an access parameter or access result
+type (see *note 6.1::) designating T. A predefined operator, or other
+language-defined operation such as assignment or a membership test, that
+operates on a type, is called a predefined operation of the type.  The
+primitive operations of a type are the predefined operations of the
+type, plus any user-defined primitive subprograms.
+
+1.a
+          Glossary entry: The primitive operations of a type are the
+          operations (such as subprograms) declared together with the
+          type declaration.  They are inherited by other types in the
+          same class of types.  For a tagged type, the primitive
+          subprograms are dispatching subprograms, providing run-time
+          polymorphism.  A dispatching subprogram may be called with
+          statically tagged operands, in which case the subprogram body
+          invoked is determined at compile time.  Alternatively, a
+          dispatching subprogram may be called using a dispatching call,
+          in which case the subprogram body invoked is determined at run
+          time.
+
+1.b
+          To be honest: Protected subprograms are not considered to be
+          "primitive subprograms," even though they are subprograms, and
+          they are inherited by derived types.
+
+1.c
+          Discussion: We use the term "primitive subprogram" in most of
+          the rest of the manual.  The term "primitive operation" is
+          used mostly in conceptual discussions.
+
+2
+The primitive subprograms of a specific type are defined as follows:
+
+3
+   * The predefined operators of the type (see *note 4.5::);
+
+4
+   * For a derived type, the inherited (see *note 3.4::) user-defined
+     subprograms;
+
+5
+   * For an enumeration type, the enumeration literals (which are
+     considered parameterless functions -- see *note 3.5.1::);
+
+6
+   * For a specific type declared immediately within a
+     package_specification, any subprograms (in addition to the
+     enumeration literals) that are explicitly declared immediately
+     within the same package_specification and that operate on the type;
+
+6.1/3
+   * {AI05-0128-1AI05-0128-1} For a specific type with an explicitly
+     declared primitive "=" operator whose result type is Boolean, the
+     corresponding "/=" operator (see *note 6.6::);
+
+7/2
+   * {AI95-00200-01AI95-00200-01} For a nonformal type, any subprograms
+     not covered above [that are explicitly declared immediately within
+     the same declarative region as the type] and that override (see
+     *note 8.3::) other implicitly declared primitive subprograms of the
+     type.
+
+7.a
+          Discussion: In Ada 83, only subprograms declared in the
+          visible part were "primitive" (i.e.  derivable).  In Ada 95,
+          mostly because of child library units, we include all
+          operations declared in the private part as well, and all
+          operations that override implicit declarations.
+
+7.b
+          Ramification: It is possible for a subprogram to be primitive
+          for more than one type, though it is illegal for a subprogram
+          to be primitive for more than one tagged type.  See *note
+          3.9::.
+
+7.c
+          Discussion: The order of the implicit declarations when there
+          are both predefined operators and inherited subprograms is
+          described in *note 3.4::, "*note 3.4:: Derived Types and
+          Classes".
+
+7.d/2
+          Ramification: {AI95-00200-01AI95-00200-01} Subprograms
+          declared in a generic package specification are never
+          primitive for a formal type, even if they happen to override
+          an operation of the formal type.  This includes formal
+          subprograms, which are never primitive operations (that's true
+          even for an abstract formal subprogram).
+
+8
+A primitive subprogram whose designator is an operator_symbol is called
+a primitive operator.
+
+                    _Incompatibilities With Ada 83_
+
+8.a
+          The attribute S'Base is no longer defined for nonscalar
+          subtypes.  Since this was only permitted as the prefix of
+          another attribute, and there are no interesting nonscalar
+          attributes defined for an unconstrained composite or access
+          subtype, this should not affect any existing programs.
+
+                        _Extensions to Ada 83_
+
+8.b
+          The primitive subprograms (derivable subprograms) include
+          subprograms declared in the private part of a package
+          specification as well, and those that override implicitly
+          declared subprograms, even if declared in a body.
+
+                     _Wording Changes from Ada 83_
+
+8.c
+          We have dropped the confusing term operation of a type in
+          favor of the more useful primitive operation of a type and the
+          phrase operates on a type.
+
+8.d
+          The description of S'Base has been moved to *note 3.5::,
+          "*note 3.5:: Scalar Types" because it is now defined only for
+          scalar types.
+
+                     _Wording Changes from Ada 95_
+
+8.e/2
+          {AI95-00200-01AI95-00200-01} Clarified that a formal
+          subprogram that happens to override a primitive operation of a
+          formal type is not a primitive operation (and thus not a
+          dispatching operation) of the formal type.
+
+8.f/2
+          {AI95-00416-01AI95-00416-01} Added wording to include access
+          result types in the kinds of operations that operate on a type
+          T.
+
+                    _Wording Changes from Ada 2005_
+
+8.g/3
+          {AI05-0128-1AI05-0128-1} Correction: The implicitly declared
+          "/=" for a primitive "=" operator is also primitive; this
+          makes it eligible to be made visible by a use type clause.
+
+
+File: aarm2012.info,  Node: 3.2.4,  Prev: 3.2.3,  Up: 3.2
+
+3.2.4 Subtype Predicates
+------------------------
+
+1/3
+{AI05-0153-3AI05-0153-3} {AI05-0269-1AI05-0269-1}
+{AI05-0299-1AI05-0299-1} The language-defined predicate aspects
+Static_Predicate and Dynamic_Predicate may be used to define properties
+of subtypes.  A predicate specification is an aspect_specification for
+one of the two predicate aspects.  General rules for aspects and
+aspect_specifications are found in Clause *note 13:: (*note 13.1:: and
+*note 13.1.1:: respectively).
+
+1.a/3
+          Aspect Description for Static_Predicate: Condition that must
+          hold true for objects of a given subtype; the subtype may be
+          static.
+
+1.b/3
+          Aspect Description for Dynamic_Predicate: Condition that must
+          hold true for objects of a given subtype; the subtype is not
+          static.
+
+                        _Name Resolution Rules_
+
+2/3
+{AI05-0153-3AI05-0153-3} The expected type for a predicate aspect
+expression is any boolean type.
+
+                          _Static Semantics_
+
+3/3
+{AI05-0153-3AI05-0153-3} A predicate specification may be given on a
+type_declaration or a subtype_declaration, and applies to the declared
+subtype.  In addition, predicate specifications apply to certain other
+subtypes:
+
+4/3
+   * For a (first) subtype defined by a derived type declaration, the
+     predicates of the parent subtype and the progenitor subtypes apply.
+
+5/3
+   * For a subtype created by a subtype_indication, the predicate of the
+     subtype denoted by the subtype_mark applies.
+
+6/3
+{AI05-0153-3AI05-0153-3} The predicate of a subtype consists of all
+predicate specifications that apply, and-ed together; if no predicate
+specifications apply, the predicate is True [(in particular, the
+predicate of a base subtype is True)].
+
+7/3
+{AI05-0290-1AI05-0290-1} Predicate checks are defined to be enabled or
+disabled for a given subtype as follows:
+
+8/3
+   * If a subtype is declared by a type_declaration or
+     subtype_declaration that includes a predicate specification, then:
+
+9/3
+        * if performing checks is required by the Static_Predicate
+          assertion policy (see *note 11.4.2::) and the declaration
+          includes a Static_Predicate specification, then predicate
+          checks are enabled for the subtype;
+
+10/3
+        * if performing checks is required by the Dynamic_Predicate
+          assertion policy (see *note 11.4.2::) and the declaration
+          includes a Dynamic_Predicate specification, then predicate
+          checks are enabled for the subtype;
+
+11/3
+        * otherwise, predicate checks are disabled for the subtype[,
+          regardless of whether predicate checking is enabled for any
+          other subtypes mentioned in the declaration];
+
+12/3
+   * If a subtype is defined by a derived type declaration that does not
+     include a predicate specification, then predicate checks are
+     enabled for the subtype if and only if predicate checks are enabled
+     for at least one of the parent subtype and the progenitor subtypes;
+
+13/3
+   * If a subtype is created by a subtype_indication other than in one
+     of the previous cases, then predicate checks are enabled for the
+     subtype if and only if predicate checks are enabled for the subtype
+     denoted by the subtype_mark;
+
+14/3
+   * Otherwise, predicate checks are disabled for the given subtype.
+
+14.a/3
+          Discussion: In this case, no predicate specifications can
+          apply to the subtype and so it doesn't typically matter
+          whether predicate checks are enabled.  This rule does make a
+          difference, however, when determining whether predicate checks
+          are enabled for another type when this type is one of multiple
+          progenitors.  See the "derived type declaration" wording
+          above.
+
+14.b/3
+          Even when predicate checks are disabled, a predicate cam
+          affect various Legality Rules, the results of membership
+          tests, the items in a for loop, and the result of the Valid
+          attribute.
+
+                           _Legality Rules_
+
+15/3
+{AI05-0153-3AI05-0153-3} {AI05-0269-1AI05-0269-1} The expression of a
+Static_Predicate specification shall be predicate-static; that is, one
+of the following:
+
+16/3
+   * a static expression;
+
+17/3
+   * a membership test whose simple_expression is the current instance,
+     and whose membership_choice_list meets the requirements for a
+     static membership test (see *note 4.9::);
+
+18/3
+   * a case_expression whose selecting_expression is the current
+     instance, and whose dependent_expressions are static expressions;
+
+19/3
+   * a call to a predefined equality or ordering operator, where one
+     operand is the current instance, and the other is a static
+     expression;
+
+20/3
+   * {AI05-0262-1AI05-0262-1} a call to a predefined boolean logical
+     operator, where each operand is predicate-static;
+
+21/3
+   * {AI05-0269-1AI05-0269-1} a short-circuit control form where both
+     operands are predicate-static; or
+
+22/3
+   * a parenthesized predicate-static expression.
+
+23/3
+{AI05-0262-1AI05-0262-1} A predicate shall not be specified for an
+incomplete subtype.
+
+23.a/3
+          Reason: The expression of such a predicate could not depend on
+          the properties of the value of the type (since it doesn't have
+          any), so it is useless and we don't want to require the added
+          complexity needed to support it.
+
+24/3
+{AI05-0287-1AI05-0287-1} If a predicate applies to a subtype, then that
+predicate shall not mention any other subtype to which the same
+predicate applies.
+
+24.a/3
+          Reason: This is intended to prevent recursive predicates,
+          which cause definitional problems for static predicates.
+          Inside of the predicate, the subtype name refers to the
+          current instance of the subtype, which is an object, so a
+          direct use of the subtype name cannot be recursive.  But other
+          subtypes naming the same type might:
+
+24.b/3
+                  type Really_Ugly is private;
+               private
+                  subtype Ugly is Really_Ugly;
+                  type Really_Ugly is new Integer
+                     with Static_Predicate => Really_Ugly not in Ugly; -- 
Illegal!
+
+25/3
+{AI05-0153-3AI05-0153-3} An index subtype, discrete_range of an
+index_constraint or slice, or a discrete_subtype_definition of a
+constrained_array_definition, entry_declaration, or
+entry_index_specification shall not denote a subtype to which predicate
+specifications apply.
+
+26/3
+{AI05-0153-3AI05-0153-3} The prefix of an attribute_reference whose
+attribute_designator is First, Last, or Range shall not denote a scalar
+subtype to which predicate specifications apply.
+
+26.a/3
+          Reason: {AI05-0297-1AI05-0297-1} This is to prevent confusion
+          about whether the First value is the lowest value of the
+          subtype (which does not depend on the predicate) or the lowest
+          value of the subtype which meets the predicate.  (For a
+          dynamic predicate, determining this latter value is expensive
+          as it would usually require a loop.)  For a static subtype
+          that has a static predicate, the First_Valid and Last_Valid
+          attributes (see *note 3.5.5::) can be used instead.
+
+27/3
+{AI05-0153-3AI05-0153-3} {AI05-0262-1AI05-0262-1}
+{AI05-0287-1AI05-0287-1} The discrete_subtype_definition of a
+loop_parameter_specification shall not denote a nonstatic subtype to
+which predicate specifications apply or any subtype to which
+Dynamic_Predicate specifications apply.
+
+28/3
+{AI05-0153-3AI05-0153-3} {AI05-0262-1AI05-0262-1} The discrete_choice of
+a named_array_aggregate shall not denote a nonstatic subtype to which
+predicate specifications apply.
+
+28.a/3
+          Reason: {AI05-0262-1AI05-0262-1} This rule prevents
+          noncontiguous dynamically bounded array aggregates, which
+          could be expensive to check for.  (Array aggregates have rules
+          to prevent problems with static subtypes.)  We define this
+          rule here so that the runtime generic body check applies.
+
+29/3
+{AI05-0262-1AI05-0262-1} In addition to the places where Legality Rules
+normally apply (see *note 12.3::), these rules apply also in the private
+part of an instance of a generic unit.
+
+                          _Dynamic Semantics_
+
+30/3
+{AI05-0153-3AI05-0153-3} {AI05-0290-1AI05-0290-1} If predicate checks
+are enabled for a given subtype, then:
+
+31/3
+          [On every subtype conversion, the predicate of the target
+          subtype is evaluated, and a check is performed that the
+          predicate is True.  This includes all parameter passing,
+          except for certain parameters passed by reference, which are
+          covered by the following rule: ] After normal completion and
+          leaving of a subprogram, for each in out or out parameter that
+          is passed by reference, the predicate of the subtype of the
+          actual is evaluated, and a check is performed that the
+          predicate is True.  For an object created by an
+          object_declaration with no explicit initialization expression,
+          or by an uninitialized allocator, if any subcomponents have
+          default_expressions, the predicate of the nominal subtype of
+          the created object is evaluated, and a check is performed that
+          the predicate is True.  Assertions.Assertion_Error is raised
+          if any of these checks fail.
+
+31.a/3
+          Ramification: Predicates are not evaluated at the point of the
+          (sub)type declaration.
+
+31.b/3
+          Implementation Note: Static_Predicate checks can be removed
+          even in the presence of potentially invalid values, just as
+          constraint checks can be removed.
+
+32/3
+{AI05-0262-1AI05-0262-1} A value satisfies a predicate if the predicate
+is True for that value.
+
+33/3
+{AI05-0153-3AI05-0153-3} {AI05-0276-1AI05-0276-1} If any of the above
+Legality Rules is violated in an instance of a generic unit,
+Program_Error is raised at the point of the violation.
+
+33.a/3
+          Discussion: This is the usual way around the contract model;
+          this applies even in instance bodies.  Note that errors in
+          instance specifications will be detected at compile-time by
+          the "re-check" of the specification, only errors in the body
+          should raise Program_Error.
+
+     NOTES
+
+34/3
+     5  {AI05-0153-3AI05-0153-3} A predicate specification does not
+     cause a subtype to be considered constrained.
+
+35/3
+     6  {AI05-0153-3AI05-0153-3} A Static_Predicate, like a constraint,
+     always remains True for all objects of the subtype, except in the
+     case of uninitialized variables and other invalid values.  A
+     Dynamic_Predicate, on the other hand, is checked as specified
+     above, but can become False at other times.  For example, the
+     predicate of a record subtype is not checked when a subcomponent is
+     modified.
+
+                       _Extensions to Ada 2005_
+
+35.a/3
+          {AI05-0153-3AI05-0153-3} {AI05-0262-1AI05-0262-1}
+          {AI05-0276-1AI05-0276-1} {AI05-0290-1AI05-0290-1} Predicate
+          aspects are new in Ada 2012.
+
+
+File: aarm2012.info,  Node: 3.3,  Next: 3.4,  Prev: 3.2,  Up: 3
+
+3.3 Objects and Named Numbers
+=============================
+
+1
+[Objects are created at run time and contain a value of a given type.
+An object can be created and initialized as part of elaborating a
+declaration, evaluating an allocator, aggregate, or function_call, or
+passing a parameter by copy.  Prior to reclaiming the storage for an
+object, it is finalized if necessary (see *note 7.6.1::).]
+
+                          _Static Semantics_
+
+2
+All of the following are objects:
+
+2.a
+          Glossary entry: An object is either a constant or a variable.
+          An object contains a value.  An object is created by an
+          object_declaration or by an allocator.  A formal parameter is
+          (a view of) an object.  A subcomponent of an object is an
+          object.
+
+3
+   * the entity declared by an object_declaration;
+
+4
+   * a formal parameter of a subprogram, entry, or generic subprogram;
+
+5
+   * a generic formal object;
+
+6
+   * a loop parameter;
+
+7
+   * a choice parameter of an exception_handler;
+
+8
+   * an entry index of an entry_body;
+
+9
+   * the result of dereferencing an access-to-object value (see *note
+     4.1::);
+
+10/3
+   * {AI95-00416-01AI95-00416-01} {AI05-0015-1AI05-0015-1} the return
+     object of a function;
+
+11
+   * the result of evaluating an aggregate;
+
+11.1/3
+   * {AI05-0003-1AI05-0003-1} a qualified_expression whose operand
+     denotes an object;
+
+12
+   * a component, slice, or view conversion of another object.
+
+13/3
+{AI05-0054-2AI05-0054-2} An object is either a constant object or a
+variable object.  Similarly, a view of an object is either a constant or
+a variable.  All views of a constant elementary object are constant.
+All views of a constant composite object are constant, except for parts
+that are of controlled or immutably limited types; variable views of
+those parts and their subcomponents may exist.  In this sense, objects
+of controlled and immutably limited types are inherently mutable.  A
+constant view of an object cannot be used to modify its value.  The
+terms constant and variable by themselves refer to constant and variable
+views of objects.
+
+14
+The value of an object is read when the value of any part of the object
+is evaluated, or when the value of an enclosing object is evaluated.
+The value of a variable is updated when an assignment is performed to
+any part of the variable, or when an assignment is performed to an
+enclosing object.
+
+14.a
+          Ramification: Reading and updating are intended to include
+          read/write references of any kind, even if they are not
+          associated with the evaluation of a particular construct.
+          Consider, for example, the expression "X.all(F)", where X is
+          an access-to-array object, and F is a function.  The
+          implementation is allowed to first evaluate "X.all" and then
+          F. Finally, a read is performed to get the value of the F'th
+          component of the array.  Note that the array is not
+          necessarily read as part of the evaluation of "X.all".  This
+          is important, because if F were to free X using
+          Unchecked_Deallocation, we want the execution of the final
+          read to be erroneous.
+
+15
+Whether a view of an object is constant or variable is determined by the
+definition of the view.  The following (and no others) represent
+constants:
+
+16
+   * an object declared by an object_declaration with the reserved word
+     constant;
+
+16.a/2
+          To be honest: {AI95-00385-01AI95-00385-01} We mean the word
+          constant as defined by the grammar for object_declaration, not
+          some random word constant.  Thus,
+
+16.b/2
+               X : access constant T;
+
+16.c/2
+          is not a constant.
+
+17
+   * a formal parameter or generic formal object of mode in;
+
+18
+   * a discriminant;
+
+18.1/3
+   * {AI05-0262-1AI05-0262-1} a loop parameter unless specified to be a
+     variable for a generalized loop (see *note 5.5.2::);
+
+19/3
+   * {AI05-0262-1AI05-0262-1} a choice parameter or entry index;
+
+20
+   * the dereference of an access-to-constant value;
+
+20.1/3
+   * {AI05-0015-1AI05-0015-1} the return object declared by an
+     extended_return_statement with the reserved word constant;
+
+21/3
+   * {AI05-0015-1AI05-0015-1} the object denoted by a function_call or
+     an aggregate;
+
+21.1/3
+   * {AI05-0003-1AI05-0003-1} the result of evaluating a
+     qualified_expression;
+
+21.2/3
+   * {AI05-0120-1AI05-0120-1} within the body of a protected function
+     (or a function declared immediately within a protected_body), the
+     current instance of the enclosing protected unit;
+
+22
+   * a selected_component, indexed_component, slice, or view conversion
+     of a constant.
+
+23/3
+{AI05-0264-1AI05-0264-1} At the place where a view of an object is
+defined, a nominal subtype is associated with the view.  The object's
+actual subtype (that is, its subtype) can be more restrictive than the
+nominal subtype of the view; it always is if the nominal subtype is an
+indefinite subtype.  A subtype is an indefinite subtype if it is an
+unconstrained array subtype, or if it has unknown discriminants or
+unconstrained discriminants without defaults (see *note 3.7::);
+otherwise, the subtype is a definite subtype [(all elementary subtypes
+are definite subtypes)].  [A class-wide subtype is defined to have
+unknown discriminants, and is therefore an indefinite subtype.  An
+indefinite subtype does not by itself provide enough information to
+create an object; an additional constraint or explicit initialization
+expression is necessary (see *note 3.3.1::).  A component cannot have an
+indefinite nominal subtype.]
+
+23.1/3
+{AI05-0008-1AI05-0008-1} A view of a composite object is known to be
+constrained if:
+
+23.2/3
+   * its nominal subtype is constrained, and is not an untagged partial
+     view; or
+
+23.3/3
+   * its nominal subtype is indefinite; or
+
+23.4/3
+   * {AI05-0008-1AI05-0008-1} {AI05-0093-1AI05-0093-1} its type is
+     immutably limited (see *note 7.5::); or
+
+23.5/3
+   * it is part of a stand-alone constant (including a generic formal
+     object of mode in); or
+
+23.6/3
+   * it is part of a formal parameter of mode in; or
+
+23.7/3
+   * it is part of the object denoted by a function_call or aggregate;
+     or
+
+23.8/3
+   * it is part of a constant return object of an
+     extended_return_statement; or
+
+23.9/3
+   * {AI05-0008-1AI05-0008-1} {AI05-0041-1AI05-0041-1} it is a
+     dereference of a pool-specific access type, and there is no
+     ancestor of its type that has a constrained partial view.
+
+23.a/3
+          Discussion: We do not include dereferences of general access
+          types because they might denote stand-alone aliased
+          unconstrained variables.  That's true even for
+          access-to-constant types (the denoted object does not have to
+          be a constant).
+
+23.b/3
+          {AI05-0005-1AI05-0005-1} {AI05-0008-1AI05-0008-1} There are
+          other cases that could have been included in this definition
+          (view conversions, the current instance of a type, objects of
+          a formal discriminated private type), but these are not
+          relevant to the places this term is used, so they were not
+          included.  If this term is used in additional places, the
+          definition should be checked to see if any of these additional
+          cases are relevant and appropriate wording added if necessary.
+
+23.10/3
+{AI05-0008-1AI05-0008-1} {AI05-0041-1AI05-0041-1} For the purposes of
+determining within a generic body whether an object is known to be
+constrained:
+
+23.11/3
+   * if a subtype is a descendant of an untagged generic formal private
+     or derived type, and the subtype is not an unconstrained array
+     subtype, it is not considered indefinite and is considered to have
+     a constrained partial view;
+
+23.12/3
+   * if a subtype is a descendant of a formal access type, it is not
+     considered pool-specific.
+
+24
+A named number provides a name for a numeric value known at compile
+time.  It is declared by a number_declaration.
+
+     NOTES
+
+25
+     7  A constant cannot be the target of an assignment operation, nor
+     be passed as an in out or out parameter, between its initialization
+     and finalization, if any.
+
+25.1/3
+     8  {AI05-0054-2AI05-0054-2} The value of a constant object cannot
+     be changed after its initialization, except in some cases where the
+     object has a controlled or immutably limited part (see *note 7.5::,
+     *note 7.6::, and *note 13.9.1::).
+
+26/3
+     9  {AI05-0264-1AI05-0264-1} The nominal and actual subtypes of an
+     elementary object are always the same.  For a discriminated or
+     array object, if the nominal subtype is constrained, then so is the
+     actual subtype.
+
+                        _Extensions to Ada 83_
+
+26.a
+          There are additional kinds of objects (choice parameters and
+          entry indices of entry bodies).
+
+26.b
+          The result of a function and of evaluating an aggregate are
+          considered (constant) objects.  This is necessary to explain
+          the action of finalization on such things.  Because a
+          function_call is also syntactically a name (see *note 4.1::),
+          the result of a function_call can be renamed, thereby allowing
+          repeated use of the result without calling the function again.
+
+                     _Wording Changes from Ada 83_
+
+26.c/3
+          {AI05-0299-1AI05-0299-1} This subclause now follows the
+          subclauses on types and subtypes, to cut down on the number of
+          forward references.
+
+26.d
+          The term nominal subtype is new.  It is used to distinguish
+          what is known at compile time about an object's constraint,
+          versus what its "true" run-time constraint is.
+
+26.e
+          The terms definite and indefinite (which apply to subtypes)
+          are new.  They are used to aid in the description of generic
+          formal type matching, and to specify when an explicit initial
+          value is required in an object_declaration.
+
+26.f
+          We have moved the syntax for object_declaration and
+          number_declaration down into their respective subclauses, to
+          keep the syntax close to the description of the associated
+          semantics.
+
+26.g
+          We talk about variables and constants here, since the
+          discussion is not specific to object_declarations, and it
+          seems better to have the list of the kinds of constants
+          juxtaposed with the kinds of objects.
+
+26.h
+          We no longer talk about indirect updating due to parameter
+          passing.  Parameter passing is handled in 6.2 and 6.4.1 in a
+          way that there is no need to mention it here in the definition
+          of read and update.  Reading and updating now includes the
+          case of evaluating or assigning to an enclosing object.
+
+                     _Wording Changes from Ada 95_
+
+26.i/2
+          {AI95-00416-01AI95-00416-01} Clarified that the return object
+          is the object created by a function call.
+
+                       _Extensions to Ada 2005_
+
+26.j/3
+          {AI05-0015-1AI05-0015-1} Added wording to allow return objects
+          to be declared as constants, and corrected the definition of
+          return objects as objects.
+
+                    _Wording Changes from Ada 2005_
+
+26.k/3
+          {AI05-0008-1AI05-0008-1} {AI05-0041-1AI05-0041-1}
+          {AI05-0093-1AI05-0093-1} Correction: Added a definition of
+          known to be constrained, for use in other rules.
+
+26.l/3
+          {AI05-0054-2AI05-0054-2} Correction: We now recognize the fact
+          that not all declared constant objects are immutable; for
+          those that a variable view can be constructed, they can be
+          changed via that view.
+
+26.m/3
+          {AI05-0120-1AI05-0120-1} Correction: Added the current
+          instance of a protected object to the list of constant views;
+          since the list claims to include all possibilities, it had
+          better include that one.
+
+26.n/3
+          {AI05-0003-1AI05-0003-1} The result of a qualified_expression
+          is defined to be a constant view and is defined to be an
+          object if the operand of the qualified_expression is an
+          object.  These definitions, combined with some grammar
+          changes, allow qualified_expressions to be used in more
+          places.  See *note 4.1:: for details.
+
+* Menu:
+
+* 3.3.1 ::    Object Declarations
+* 3.3.2 ::    Number Declarations
+
+
+File: aarm2012.info,  Node: 3.3.1,  Next: 3.3.2,  Up: 3.3
+
+3.3.1 Object Declarations
+-------------------------
+
+1/3
+{AI05-0262-1AI05-0262-1} An object_declaration declares a stand-alone
+object with a given nominal subtype and, optionally, an explicit initial
+value given by an initialization expression.  For an array, access,
+task, or protected object, the object_declaration may include the
+definition of the (anonymous) type of the object.
+
+                               _Syntax_
+
+2/3
+     {AI95-00385-01AI95-00385-01} {AI95-00406-01AI95-00406-01}
+     {AI05-0183-1AI05-0183-1} object_declaration ::=
+         defining_identifier_list : [aliased] [constant] 
+     subtype_indication [:= expression]
+             [aspect_specification];
+       | defining_identifier_list : [aliased] [constant] 
+     access_definition [:= expression]
+             [aspect_specification];
+       | defining_identifier_list : [aliased] [constant] 
+     array_type_definition [:= expression]
+             [aspect_specification];
+       | single_task_declaration
+       | single_protected_declaration
+
+3
+     defining_identifier_list ::=
+       defining_identifier {, defining_identifier}
+
+                        _Name Resolution Rules_
+
+4
+For an object_declaration with an expression following the compound
+delimiter :=, the type expected for the expression is that of the
+object.  This expression is called the initialization expression.  
+
+                           _Legality Rules_
+
+5/2
+{AI95-00287-01AI95-00287-01} An object_declaration without the reserved
+word constant declares a variable object.  If it has a
+subtype_indication or an array_type_definition that defines an
+indefinite subtype, then there shall be an initialization expression.
+
+                          _Static Semantics_
+
+6/3
+{AI05-0264-1AI05-0264-1} {AI05-0299-1AI05-0299-1} An object_declaration
+with the reserved word constant declares a constant object.  If it has
+an initialization expression, then it is called a full constant
+declaration.  Otherwise, it is called a deferred constant declaration.
+The rules for deferred constant declarations are given in subclause
+*note 7.4::.  The rules for full constant declarations are given in this
+subclause.
+
+7
+Any declaration that includes a defining_identifier_list with more than
+one defining_identifier is equivalent to a series of declarations each
+containing one defining_identifier from the list, with the rest of the
+text of the declaration copied for each declaration in the series, in
+the same order as the list.  The remainder of this International
+Standard relies on this equivalence; explanations are given for
+declarations with a single defining_identifier.
+
+8/2
+{AI95-00385-01AI95-00385-01} The subtype_indication, access_definition,
+or full type definition of an object_declaration defines the nominal
+subtype of the object.  The object_declaration declares an object of the
+type of the nominal subtype.
+
+8.a/2
+          Discussion: {AI95-00385-01AI95-00385-01} The phrase "full type
+          definition" here includes the case of an anonymous array,
+          access, task, or protected type.
+
+8.1/2
+{AI95-00373-01AI95-00373-01} A component of an object is said to require
+late initialization if it has an access discriminant value constrained
+by a per-object expression, or if it has an initialization expression
+that includes a name denoting the current instance of the type or
+denoting an access discriminant.
+
+8.b/2
+          Reason: Such components can depend on the values of other
+          components of the object.  We want to initialize them as late
+          and as reproducibly as possible.
+
+                          _Dynamic Semantics_
+
+9/2
+{AI95-00363-01AI95-00363-01} If a composite object declared by an
+object_declaration has an unconstrained nominal subtype, then if this
+subtype is indefinite or the object is constant the actual subtype of
+this object is constrained.  The constraint is determined by the bounds
+or discriminants (if any) of its initial value; the object is said to be
+constrained by its initial value.  When not constrained by its initial
+value, the actual and nominal subtypes of the object are the same.  If
+its actual subtype is constrained, the object is called a constrained
+object.
+
+10
+For an object_declaration without an initialization expression, any
+initial values for the object or its subcomponents are determined by the
+implicit initial values defined for its nominal subtype, as follows:
+
+11
+   * The implicit initial value for an access subtype is the null value
+     of the access type.
+
+11.1/3
+   * {AI05-0228-1AI05-0228-1} The implicit initial value for a scalar
+     subtype that has the Default_Value aspect specified is the value of
+     that aspect converted to the nominal subtype (which might raise
+     Constraint_Error -- see *note 4.6::, "*note 4.6:: Type
+     Conversions");
+
+11.a.1/3
+          Ramification: This is a Dynamic Semantics rule, so the
+          visibility of the aspect_specification is not relevant -- if
+          the full type for a private type has the Default_Value aspect
+          specified, partial views of the type also have this implicit
+          initial value.
+
+12
+   * The implicit initial (and only) value for each discriminant of a
+     constrained discriminated subtype is defined by the subtype.
+
+13/3
+   * {AI05-0228-1AI05-0228-1} For a (definite) composite subtype, the
+     implicit initial value of each component with a default_expression
+     is obtained by evaluation of this expression and conversion to the
+     component's nominal subtype (which might raise Constraint_Error),
+     unless the component is a discriminant of a constrained subtype
+     (the previous case), or is in an excluded variant (see *note
+     3.8.1::).  For each component that does not have a
+     default_expression, if the composite subtype has the
+     Default_Component_Value aspect specified, the implicit initial
+     value is the value of that aspect converted to the component's
+     nominal subtype; otherwise, any implicit initial values are those
+     determined by the component's nominal subtype.
+
+14
+   * For a protected or task subtype, there is an implicit component (an
+     entry queue) corresponding to each entry, with its implicit initial
+     value being an empty queue.
+
+14.a
+          Implementation Note: The implementation may add implicit
+          components for its own use, which might have implicit initial
+          values.  For a task subtype, such components might represent
+          the state of the associated thread of control.  For a type
+          with dynamic-sized components, such implicit components might
+          be used to hold the offset to some explicit component.
+
+15
+The elaboration of an object_declaration proceeds in the following
+sequence of steps:
+
+16/2
+     1.  {AI95-00385-01AI95-00385-01} The subtype_indication (*note
+     3.2.2: S0027.), access_definition (*note 3.10: S0084.),
+     array_type_definition (*note 3.6: S0051.), single_task_declaration
+     (*note 9.1: S0206.), or single_protected_declaration (*note 9.4:
+     S0211.) is first elaborated.  This creates the nominal subtype (and
+     the anonymous type in the last four cases).
+
+17
+     2.  If the object_declaration includes an initialization
+     expression, the (explicit) initial value is obtained by evaluating
+     the expression and converting it to the nominal subtype (which
+     might raise Constraint_Error -- see *note 4.6::).  
+
+18/2
+     3.  {8652/00028652/0002} {AI95-00171-01AI95-00171-01}
+     {AI95-00373-01AI95-00373-01} The object is created, and, if there
+     is not an initialization expression, the object is initialized by
+     default.  When an object is initialized by default, any per-object
+     constraints (see *note 3.8::) are elaborated and any implicit
+     initial values for the object or for its subcomponents are obtained
+     as determined by the nominal subtype.  Any initial values (whether
+     explicit or implicit) are assigned to the object or to the
+     corresponding subcomponents.  As described in *note 5.2:: and *note
+     7.6::, Initialize and Adjust procedures can be called.  
+
+18.a
+          Discussion: For a per-object constraint that contains some
+          per-object expressions and some non-per-object expressions,
+          the values used for the constraint consist of the values of
+          the non-per-object expressions evaluated at the point of the
+          type_declaration, and the values of the per-object expressions
+          evaluated at the point of the creation of the object.
+
+18.b
+          The elaboration of per-object constraints was presumably
+          performed as part of the dependent compatibility check in Ada
+          83.  If the object is of a limited type with an access
+          discriminant, the access_definition is elaborated at this time
+          (see *note 3.7::).
+
+18.c
+          Reason: The reason we say that evaluating an explicit
+          initialization expression happens before creating the object
+          is that in some cases it is impossible to know the size of the
+          object being created until its initial value is known, as in
+          "X: String := Func_Call(...);".  The implementation can create
+          the object early in the common case where the size can be
+          known early, since this optimization is semantically neutral.
+
+19/2
+       This paragraph was deleted.{AI95-00373-01AI95-00373-01}
+
+19.a
+          Ramification: Since the initial values have already been
+          converted to the appropriate nominal subtype, the only
+          Constraint_Errors that might occur as part of these
+          assignments are for values outside their base range that are
+          used to initialize unconstrained numeric subcomponents.  See
+          *note 3.5::.
+
+20/2
+{AI95-00373-01AI95-00373-01} For the third step above, evaluations and
+assignments are performed in an arbitrary order subject to the following
+restrictions:
+
+20.1/2
+   * {AI95-00373-01AI95-00373-01} Assignment to any part of the object
+     is preceded by the evaluation of the value that is to be assigned.
+
+20.a.1/2
+          Reason: Duh.  But we ought to say it.  Note that, like any
+          rule in the International Standard, it doesn't prevent an
+          "as-if" optimization; as long as the semantics as observed
+          from the program are correct, the compiler can generate any
+          code it wants.
+
+20.2/2
+   * {AI95-00373-01AI95-00373-01} The evaluation of a default_expression
+     that includes the name of a discriminant is preceded by the
+     assignment to that discriminant.
+
+20.a.2/2
+          Reason: Duh again.  But we have to say this, too.  It's odd
+          that Ada 95 only required the default expressions to be
+          evaluated before the discriminant is used; it says nothing
+          about discriminant values that come from subtype_indications.
+
+20.3/2
+   * {AI95-00373-01AI95-00373-01} The evaluation of the
+     default_expression for any component that depends on a discriminant
+     is preceded by the assignment to that discriminant.
+
+20.a
+          Reason: For example:
+
+20.b
+               type R(D : Integer := F) is
+                   record
+                       S : String(1..D) := (others => G);
+                   end record;
+
+20.c
+               X : R;
+
+20.d
+          For the elaboration of the declaration of X, it is important
+          that F be evaluated before the aggregate.
+
+20.4/3
+   * {AI95-00373-01AI95-00373-01} {AI05-0092-1AI05-0092-1} The
+     assignments to any components, including implicit components, not
+     requiring late initialization precede the initial value evaluations
+     for any components requiring late initialization; if two components
+     both require late initialization, then assignments to parts of the
+     component occurring earlier in the order of the component
+     declarations precede the initial value evaluations of the component
+     occurring later.
+
+20.e/2
+          Reason: Components that require late initialization can refer
+          to the entire object during their initialization.  We want
+          them to be initialized as late as possible to reduce the
+          chance that their initialization depends on uninitialized
+          components.  For instance:
+
+20.f/2
+               type T (D : Natural) is
+                 limited record
+                   C1 : T1 (T'Access);
+                   C2 : Natural := F (D);
+                   C3 : String (1 .. D) := (others => ' ');
+                 end record;
+
+20.g/2
+          Component C1 requires late initialization.  The initialization
+          could depend on the values of any component of T, including D,
+          C2, or C3.  Therefore, we want to it to be initialized last.
+          Note that C2 and C3 do not require late initialization; they
+          only have to be initialized after D.
+
+20.h/2
+          It is possible for there to be more than one component that
+          requires late initialization.  In this case, the language
+          can't prevent problems, because all of the components can't be
+          the last one initialized.  In this case, we specify the order
+          of initialization for components requiring late
+          initialization; by doing so, programmers can arrange their
+          code to avoid accessing uninitialized components, and such
+          arrangements are portable.  Note that if the program accesses
+          an uninitialized component, *note 13.9.1:: defines the
+          execution to be erroneous.
+
+21/3
+{AI05-0228-1AI05-0228-1} [There is no implicit initial value defined for
+a scalar subtype unless the Default_Value aspect has been specified for
+the type.]  In the absence of an explicit initialization or the
+specification of the Default_Value aspect, a newly created scalar object
+might have a value that does not belong to its subtype (see *note
+13.9.1:: and *note H.1::).
+
+21.a
+          To be honest: It could even be represented by a bit pattern
+          that doesn't actually represent any value of the type at all,
+          such as an invalid internal code for an enumeration type, or a
+          NaN for a floating point type.  It is a generally a bounded
+          error to reference scalar objects with such "invalid
+          representations", as explained in *note 13.9.1::, "*note
+          13.9.1:: Data Validity".
+
+21.b
+          Ramification: There is no requirement that two objects of the
+          same scalar subtype have the same implicit initial "value" (or
+          representation).  It might even be the case that two
+          elaborations of the same object_declaration produce two
+          different initial values.  However, any particular
+          uninitialized object is default-initialized to a single value
+          (or invalid representation).  Thus, multiple reads of such an
+          uninitialized object will produce the same value each time (if
+          the implementation chooses not to detect the error).
+
+     NOTES
+
+22
+     10  Implicit initial values are not defined for an indefinite
+     subtype, because if an object's nominal subtype is indefinite, an
+     explicit initial value is required.
+
+23/3
+     11  {AI05-0092-1AI05-0092-1} {AI05-0255-1AI05-0255-1} As indicated
+     above, a stand-alone object is an object declared by an
+     object_declaration.  Similar definitions apply to "stand-alone
+     constant" and "stand-alone variable."  A subcomponent of an object
+     is not a stand-alone object, nor is an object that is created by an
+     allocator.  An object declared by a loop_parameter_specification,
+     iterator_specification, parameter_specification,
+     entry_index_specification, choice_parameter_specification,
+     extended_return_statement, or a formal_object_declaration of mode
+     in out is not considered a stand-alone object.
+
+24
+     12  The type of a stand-alone object cannot be abstract (see *note
+     3.9.3::).
+
+                              _Examples_
+
+25
+Example of a multiple object declaration:
+
+26
+     --  the multiple object declaration 
+
+27/2
+     {AI95-00433-01AI95-00433-01} John, Paul : not null Person_Name := new 
Person(Sex => M);  --  see *note 3.10.1::
+
+28
+     --  is equivalent to the two single object declarations in the order given
+
+29/2
+     {AI95-00433-01AI95-00433-01} John : not null Person_Name := new 
Person(Sex => M);
+     Paul : not null Person_Name := new Person(Sex => M);
+
+30
+Examples of variable declarations:
+
+31/2
+     {AI95-00433-01AI95-00433-01} Count, Sum  : Integer;
+     Size        : Integer range 0 .. 10_000 := 0;
+     Sorted      : Boolean := False;
+     Color_Table : array(1 .. Max) of Color;
+     Option      : Bit_Vector(1 .. 10) := (others => True);
+     Hello       : aliased String := "Hi, world.";
+     [Unicode 952], [Unicode 966]        : Float range -PI .. +PI;
+
+32
+Examples of constant declarations:
+
+33/2
+     {AI95-00433-01AI95-00433-01} Limit     : constant Integer := 10_000;
+     Low_Limit : constant Integer := Limit/10;
+     Tolerance : constant Real := Dispersion(1.15);
+     Hello_Msg : constant access String := Hello'Access; -- see *note 3.10.2::
+
+                        _Extensions to Ada 83_
+
+33.a
+          The syntax rule for object_declaration is modified to allow
+          the aliased reserved word.
+
+33.b
+          A variable declared by an object_declaration can be
+          constrained by its initial value; that is, a variable of a
+          nominally unconstrained array subtype, or discriminated type
+          without defaults, can be declared so long as it has an
+          explicit initial value.  In Ada 83, this was permitted for
+          constants, and for variables created by allocators, but not
+          for variables declared by object_declarations.  This is
+          particularly important for tagged class-wide types, since
+          there is no way to constrain them explicitly, and so an
+          initial value is the only way to provide a constraint.  It is
+          also important for generic formal private types with unknown
+          discriminants.
+
+33.c
+          We now allow an unconstrained_array_definition in an
+          object_declaration.  This allows an object of an anonymous
+          array type to have its bounds determined by its initial value.
+          This is for uniformity: If one can write "X: constant
+          array(Integer range 1..10) of Integer := ...;" then it makes
+          sense to also allow "X: constant array(Integer range <>) of
+          Integer := ...;".  (Note that if anonymous array types are
+          ever sensible, a common situation is for a table implemented
+          as an array.  Tables are often constant, and for constants,
+          there's usually no point in forcing the user to count the
+          number of elements in the value.)
+
+                     _Wording Changes from Ada 83_
+
+33.d
+          We have moved the syntax for object_declarations into this
+          subclause.
+
+33.e
+          Deferred constants no longer have a separate syntax rule, but
+          rather are incorporated in object_declaration as constants
+          declared without an initialization expression.
+
+                     _Inconsistencies With Ada 95_
+
+33.f/2
+          {AI95-00363-01AI95-00363-01} Unconstrained aliased objects of
+          types with discriminants with defaults are no longer
+          constrained by their initial values.  This means that a
+          program that raised Constraint_Error from an attempt to change
+          the discriminants will no longer do so.  The change only
+          affects programs that depended on the raising of
+          Constraint_Error in this case, so the inconsistency is
+          unlikely to occur outside of the ACATS. This change may
+          however cause compilers to implement these objects
+          differently, possibly taking additional memory or time.  This
+          is unlikely to be worse than the differences caused by any
+          major compiler upgrade.
+
+                        _Extensions to Ada 95_
+
+33.g/2
+          {AI95-00287-01AI95-00287-01} A constant may have a limited
+          type; the initialization expression has to be built-in-place
+          (see *note 7.5::).
+
+33.h/2
+          {AI95-00385-01AI95-00385-01} {AI95-00406-01AI95-00406-01} A
+          stand-alone object may have an anonymous access type.
+
+                     _Wording Changes from Ada 95_
+
+33.i/2
+          {8652/00028652/0002} {AI95-00171-01AI95-00171-01} Corrigendum:
+          Corrected wording to say that per-object constraints are
+          elaborated (not evaluated).
+
+33.j/2
+          {AI95-00373-01AI95-00373-01} The rules for evaluating default
+          initialization have been tightened.  In particular, components
+          whose default initialization can refer to the rest of the
+          object are required to be initialized last.
+
+33.k/2
+          {AI95-00433-01AI95-00433-01} Added examples of various new
+          constructs.
+
+                       _Extensions to Ada 2005_
+
+33.l/3
+          {AI05-0183-1AI05-0183-1} An optional aspect_specification can
+          be used in an object_declaration.  This is described in *note
+          13.1.1::.
+
+                    _Wording Changes from Ada 2005_
+
+33.m/3
+          {AI05-0228-1AI05-0228-1} Implicit initial values can now be
+          given for scalar types and for scalar array components, using
+          the Default_Value (see *note 3.5::) and
+          Default_Component_Value (see *note 3.6::) aspects; the
+          extension is documented there.
+
+
+File: aarm2012.info,  Node: 3.3.2,  Prev: 3.3.1,  Up: 3.3
+
+3.3.2 Number Declarations
+-------------------------
+
+1
+A number_declaration declares a named number.
+
+1.a/3
+          Discussion: {AI05-0299-1AI05-0299-1} If a value or other
+          property of a construct is required to be static that means it
+          is required to be determined prior to execution.  A static
+          expression is an expression whose value is computed at compile
+          time and is usable in contexts where the actual value might
+          affect the legality of the construct.  This is fully defined
+          in subclause *note 4.9::.
+
+                               _Syntax_
+
+2
+     number_declaration ::=
+          defining_identifier_list : constant := static_expression;
+
+                        _Name Resolution Rules_
+
+3
+The static_expression given for a number_declaration is expected to be
+of any numeric type.
+
+                           _Legality Rules_
+
+4/3
+{AI05-0299-1AI05-0299-1} The static_expression given for a number
+declaration shall be a static expression, as defined by subclause *note
+4.9::.
+
+                          _Static Semantics_
+
+5
+The named number denotes a value of type universal_integer if the type
+of the static_expression is an integer type.  The named number denotes a
+value of type universal_real if the type of the static_expression is a
+real type.
+
+6
+The value denoted by the named number is the value of the
+static_expression, converted to the corresponding universal type.  
+
+                          _Dynamic Semantics_
+
+7
+The elaboration of a number_declaration has no effect.
+
+7.a
+          Proof: Since the static_expression was evaluated at compile
+          time.
+
+                              _Examples_
+
+8
+Examples of number declarations:
+
+9
+     Two_Pi        : constant := 2.0*Ada.Numerics.Pi;   -- a real number (see 
*note A.5::)
+
+10/2
+     {AI95-00433-01AI95-00433-01} Max           : constant := 500;             
      -- an integer number
+     Max_Line_Size : constant := Max/6;                 -- the integer 83
+     Power_16      : constant := 2**16;                 -- the integer 65_536
+     One, Un, Eins : constant := 1;                     -- three different 
names for 1
+
+                        _Extensions to Ada 83_
+
+10.a
+          We now allow a static expression of any numeric type to
+          initialize a named number.  For integer types, it was possible
+          in Ada 83 to use 'Pos to define a named number, but there was
+          no way to use a static expression of some nonuniversal real
+          type to define a named number.  This change is upward
+          compatible because of the preference rule for the operators of
+          the root numeric types.
+
+                     _Wording Changes from Ada 83_
+
+10.b
+          We have moved the syntax rule into this subclause.
+
+10.c
+          AI83-00263 describes the elaboration of a number declaration
+          in words similar to that of an object_declaration.  However,
+          since there is no expression to be evaluated and no object to
+          be created, it seems simpler to say that the elaboration has
+          no effect.
+
+
+File: aarm2012.info,  Node: 3.4,  Next: 3.5,  Prev: 3.3,  Up: 3
+
+3.4 Derived Types and Classes
+=============================
+
+1/2
+{AI95-00401-01AI95-00401-01} {AI95-00419-01AI95-00419-01} A
+derived_type_definition defines a derived type (and its first subtype)
+whose characteristics are derived from those of a parent type, and
+possibly from progenitor types.  
+
+1.a/2
+          Glossary entry: A derived type is a type defined in terms of
+          one or more other types given in a derived type definition.
+          The first of those types is the parent type of the derived
+          type and any others are progenitor types.  Each class
+          containing the parent type or a progenitor type also contains
+          the derived type.  The derived type inherits properties such
+          as components and primitive operations from the parent and
+          progenitors.  A type together with the types derived from it
+          (directly or indirectly) form a derivation class.
+
+1.1/2
+{AI95-00442-01AI95-00442-01} A class of types is a set of types that is
+closed under derivation; that is, if the parent or a progenitor type of
+a derived type belongs to a class, then so does the derived type.  By
+saying that a particular group of types forms a class, we are saying
+that all derivatives of a type in the set inherit the characteristics
+that define that set.  The more general term category of types is used
+for a set of types whose defining characteristics are not necessarily
+inherited by derivatives; for example, limited, abstract, and interface
+are all categories of types, but not classes of types.
+
+1.b/2
+          Ramification: A class of types is also a category of types.
+
+                               _Syntax_
+
+2/2
+     {AI95-00251-01AI95-00251-01} {AI95-00419-01AI95-00419-01}
+     derived_type_definition ::=
+         [abstract] [limited] new parent_subtype_indication [[and 
+     interface_list] record_extension_part]
+
+                           _Legality Rules_
+
+3/2
+{AI95-00251-01AI95-00251-01} {AI95-00401-01AI95-00401-01}
+{AI95-00419-01AI95-00419-01} The parent_subtype_indication defines the
+parent subtype; its type is the parent type.  The interface_list defines
+the progenitor types (see *note 3.9.4::).  A derived type has one parent
+type and zero or more progenitor types.
+
+3.a/2
+          Glossary entry: The parent of a derived type is the first type
+          given in the definition of the derived type.  The parent can
+          be almost any kind of type, including an interface type.
+
+4
+A type shall be completely defined (see *note 3.11.1::) prior to being
+specified as the parent type in a derived_type_definition -- [the
+full_type_declarations for the parent type and any of its subcomponents
+have to precede the derived_type_definition.]
+
+4.a
+          Discussion: This restriction does not apply to the ancestor
+          type of a private extension -- see *note 7.3::; such a type
+          need not be completely defined prior to the
+          private_extension_declaration.  However, the restriction does
+          apply to record extensions, so the ancestor type will have to
+          be completely defined prior to the full_type_declaration
+          corresponding to the private_extension_declaration.
+
+4.b
+          Reason: We originally hoped we could relax this restriction.
+          However, we found it too complex to specify the rules for a
+          type derived from an incompletely defined limited type that
+          subsequently became nonlimited.
+
+5/2
+{AI95-00401-01AI95-00401-01} If there is a record_extension_part, the
+derived type is called a record extension of the parent type.  A
+record_extension_part shall be provided if and only if the parent type
+is a tagged type.  [An interface_list shall be provided only if the
+parent type is a tagged type.]
+
+5.a.1/2
+          Proof: {AI95-00401-01AI95-00401-01} The syntax only allows an
+          interface_list to appear with a record_extension_part, and a
+          record_extension_part can only be provided if the parent type
+          is a tagged type.  We give the last sentence anyway for
+          completeness.
+
+5.a
+          Implementation Note: We allow a record extension to inherit
+          discriminants; an early version of Ada 9X did not.  If the
+          parent subtype is unconstrained, it can be implemented as
+          though its discriminants were repeated in a new
+          known_discriminant_part and then used to constrain the old
+          ones one-for-one.  However, in an extension aggregate, the
+          discriminants in this case do not appear in the component
+          association list.
+
+5.b/2
+          Ramification: {AI95-00114-01AI95-00114-01} This rule needs to
+          be rechecked in the visible part of an instance of a generic
+          unit because of the "only if" part of the rule.  For example:
+
+5.c/2
+               generic
+                  type T is private;
+               package P is
+                  type Der is new T;
+               end P;
+
+5.d/2
+               package I is new P (Some_Tagged_Type); -- illegal
+
+5.e/2
+          {AI95-00114-01AI95-00114-01} The instantiation is illegal
+          because a tagged type is being extended in the visible part
+          without a record_extension_part.  Note that this is legal in
+          the private part or body of an instance, both to avoid a
+          contract model violation, and because no code that can see
+          that the type is actually tagged can also see the derived type
+          declaration.
+
+5.f/2
+          No recheck is needed for derived types with a
+          record_extension_part, as that has to be derived from
+          something that is known to be tagged (otherwise the template
+          is illegal).
+
+5.1/3
+{AI95-00419-01AI95-00419-01} {AI05-0096-1AI05-0096-1} If the reserved
+word limited appears in a derived_type_definition, the parent type shall
+be a limited type.  If the parent type is a tagged formal type, then in
+addition to the places where Legality Rules normally apply (see *note
+12.3::), this rule applies also in the private part of an instance of a
+generic unit.
+
+5.g/2
+          Reason: We allow limited because we don't inherit limitedness
+          from interfaces, so we must have a way to derive a limited
+          type from interfaces.  The word limited has to be legal when
+          the parent could be an interface, and that includes generic
+          formal abstract types.  Since we have to allow it in this
+          case, we might as well allow it everywhere as documentation,
+          to make it explicit that the type is limited.
+
+5.h/2
+          However, we do not want to allow limited when the parent is
+          nonlimited: limitedness cannot change in a derivation tree.
+
+5.i/3
+          If the parent type is an untagged limited formal type with an
+          actual type that is nonlimited, we allow derivation as a
+          limited type in the private part or body as no place could
+          have visibility on the resulting type where it was known to be
+          nonlimited (outside of the instance).  (See the previous
+          paragraph's annotations for an explanation of this.)  However,
+          if the parent type is a tagged limited formal type with an
+          actual type that is nonlimited, it would be possible to pass a
+          value of the limited type extension to a class-wide type of
+          the parent, which would be nonlimited.  That's too weird to
+          allow (even though all of the extension components would have
+          to be nonlimited because the rules of *note 3.9.1:: are
+          rechecked), so we have a special rule to prevent that in the
+          private part (type extension from a formal type is illegal in
+          a generic package body).
+
+                          _Static Semantics_
+
+6
+The first subtype of the derived type is unconstrained if a
+known_discriminant_part is provided in the declaration of the derived
+type, or if the parent subtype is unconstrained.  Otherwise, the
+constraint of the first subtype corresponds to that of the parent
+subtype in the following sense: it is the same as that of the parent
+subtype except that for a range constraint (implicit or explicit), the
+value of each bound of its range is replaced by the corresponding value
+of the derived type.
+
+6.a
+          Discussion: A digits_constraint in a subtype_indication for a
+          decimal fixed point subtype always imposes a range constraint,
+          implicitly if there is no explicit one given.  See *note
+          3.5.9::, "*note 3.5.9:: Fixed Point Types".
+
+6.1/2
+{AI95-00231-01AI95-00231-01} The first subtype of the derived type
+excludes null (see *note 3.10::) if and only if the parent subtype
+excludes null.
+
+7/3
+{AI05-0110-1AI05-0110-1} The characteristics and implicitly declared
+primitive subprograms of the derived type are defined as follows:
+
+7.a/3
+          Ramification: {AI05-0110-1AI05-0110-1} The characteristics of
+          a type do not include its primitive subprograms (primitive
+          subprograms include predefined operators).  The rules
+          governing availability/visibility and inheritance of
+          characteristics are separate from those for primitive
+          subprograms.
+
+8/2
+   * {AI95-00251-01AI95-00251-01} {AI95-00401-01AI95-00401-01}
+     {AI95-00442-01AI95-00442-01} [If the parent type or a progenitor
+     type belongs to a class of types, then the derived type also
+     belongs to that class.]  The following sets of types, as well as
+     any higher-level sets composed from them, are classes in this
+     sense[, and hence the characteristics defining these classes are
+     inherited by derived types from their parent or progenitor types]:
+     signed integer, modular integer, ordinary fixed, decimal fixed,
+     floating point, enumeration, boolean, character,
+     access-to-constant, general access-to-variable, pool-specific
+     access-to-variable, access-to-subprogram, array, string, non-array
+     composite, nonlimited, untagged record, tagged, task, protected,
+     and synchronized tagged.
+
+8.a
+          Discussion: This is inherent in our notion of a "class" of
+          types.  It is not mentioned in the initial definition of
+          "class" since at that point type derivation has not been
+          defined.  In any case, this rule ensures that every class of
+          types is closed under derivation.
+
+9
+   * If the parent type is an elementary type or an array type, then the
+     set of possible values of the derived type is a copy of the set of
+     possible values of the parent type.  For a scalar type, the base
+     range of the derived type is the same as that of the parent type.
+
+9.a
+          Discussion: The base range of a type defined by an
+          integer_type_definition or a real_type_definition is
+          determined by the _definition, and is not necessarily the same
+          as that of the corresponding root numeric type from which the
+          newly defined type is implicitly derived.  Treating numerics
+          types as implicitly derived from one of the two root numeric
+          types is simply to link them into a type hierarchy; such an
+          implicit derivation does not follow all the rules given here
+          for an explicit derived_type_definition.
+
+10
+   * If the parent type is a composite type other than an array type,
+     then the components, protected subprograms, and entries that are
+     declared for the derived type are as follows:
+
+11
+             * The discriminants specified by a new
+               known_discriminant_part, if there is one; otherwise, each
+               discriminant of the parent type (implicitly declared in
+               the same order with the same specifications) -- in the
+               latter case, the discriminants are said to be inherited,
+               or if unknown in the parent, are also unknown in the
+               derived type;
+
+12
+             * Each nondiscriminant component, entry, and protected
+               subprogram of the parent type, implicitly declared in the
+               same order with the same declarations; these components,
+               entries, and protected subprograms are said to be
+               inherited;
+
+12.a
+          Ramification: The profiles of entries and protected
+          subprograms do not change upon type derivation, although the
+          type of the "implicit" parameter identified by the prefix of
+          the name in a call does.
+
+12.b
+          To be honest: Any name in the parent type_declaration that
+          denotes the current instance of the type is replaced with a
+          name denoting the current instance of the derived type,
+          converted to the parent type.
+
+13
+             * Each component declared in a record_extension_part, if
+               any.
+
+14
+     Declarations of components, protected subprograms, and entries,
+     whether implicit or explicit, occur immediately within the
+     declarative region of the type, in the order indicated above,
+     following the parent subtype_indication.
+
+14.a
+          Discussion: The order of declarations within the region
+          matters for record_aggregates and extension_aggregates.
+
+14.b
+          Ramification: In most cases, these things are implicitly
+          declared immediately following the parent subtype_indication.
+          However, *note 7.3.1::, "*note 7.3.1:: Private Operations"
+          defines some cases in which they are implicitly declared
+          later, and some cases in which the are not declared at all.
+
+14.c
+          Discussion: The place of the implicit declarations of
+          inherited components matters for visibility -- they are not
+          visible in the known_discriminant_part nor in the parent
+          subtype_indication, but are usually visible within the
+          record_extension_part, if any (although there are restrictions
+          on their use).  Note that a discriminant specified in a new
+          known_discriminant_part is not considered "inherited" even if
+          it has the same name and subtype as a discriminant of the
+          parent type.
+
+15/2
+   * This paragraph was deleted.{AI95-00419-01AI95-00419-01}
+
+16
+   * [For each predefined operator of the parent type, there is a
+     corresponding predefined operator of the derived type.]
+
+16.a
+          Proof: This is a ramification of the fact that each class that
+          includes the parent type also includes the derived type, and
+          the fact that the set of predefined operators that is defined
+          for a type, as described in *note 4.5::, is determined by the
+          classes to which it belongs.
+
+16.b
+          Reason: Predefined operators are handled separately because
+          they follow a slightly different rule than user-defined
+          primitive subprograms.  In particular the systematic
+          replacement described below does not apply fully to the
+          relational operators for Boolean and the exponentiation
+          operator for Integer.  The relational operators for a type
+          derived from Boolean still return Standard.Boolean.  The
+          exponentiation operator for a type derived from Integer still
+          expects Standard.Integer for the right operand.  In addition,
+          predefined operators "reemerge" when a type is the actual type
+          corresponding to a generic formal type, so they need to be
+          well defined even if hidden by user-defined primitive
+          subprograms.
+
+17/2
+   * {AI95-00401-01AI95-00401-01} For each user-defined primitive
+     subprogram (other than a user-defined equality operator -- see
+     below) of the parent type or of a progenitor type that already
+     exists at the place of the derived_type_definition, there exists a
+     corresponding inherited primitive subprogram of the derived type
+     with the same defining name.  Primitive user-defined equality
+     operators of the parent type and any progenitor types are also
+     inherited by the derived type, except when the derived type is a
+     nonlimited record extension, and the inherited operator would have
+     a profile that is type conformant with the profile of the
+     corresponding predefined equality operator; in this case, the
+     user-defined equality operator is not inherited, but is rather
+     incorporated into the implementation of the predefined equality
+     operator of the record extension (see *note 4.5.2::).  
+
+17.a
+          Ramification: We say "...already exists..."  rather than "is
+          visible" or "has been declared" because there are certain
+          operations that are declared later, but still exist at the
+          place of the derived_type_definition, and there are operations
+          that are never declared, but still exist.  These cases are
+          explained in *note 7.3.1::.
+
+17.b
+          Note that nonprivate extensions can appear only after the last
+          primitive subprogram of the parent -- the freezing rules
+          ensure this.
+
+17.c
+          Reason: A special case is made for the equality operators on
+          nonlimited record extensions because their predefined equality
+          operators are already defined in terms of the primitive
+          equality operator of their parent type (and of the tagged
+          components of the extension part).  Inheriting the parent's
+          equality operator as is would be undesirable, because it would
+          ignore any components of the extension part.  On the other
+          hand, if the parent type is limited, then any user-defined
+          equality operator is inherited as is, since there is no
+          predefined equality operator to take its place.
+
+17.d/2
+          Ramification: {AI95-00114-01AI95-00114-01} Because
+          user-defined equality operators are not inherited by
+          nonlimited record extensions, the formal parameter names of =
+          and /= revert to Left and Right, even if different formal
+          parameter names were used in the user-defined equality
+          operators of the parent type.
+
+17.e/2
+          Discussion: {AI95-00401-01AI95-00401-01} This rule only
+          describes what operations are inherited; the rules that
+          describe what happens when there are conflicting inherited
+          subprograms are found in *note 8.3::.
+
+18/3
+     {AI95-00401-01AI95-00401-01} {AI05-0164-1AI05-0164-1}
+     {AI05-0240-1AI05-0240-1} The profile of an inherited subprogram
+     (including an inherited enumeration literal) is obtained from the
+     profile of the corresponding (user-defined) primitive subprogram of
+     the parent or progenitor type, after systematic replacement of each
+     subtype of its profile (see *note 6.1::) that is of the parent or
+     progenitor type, other than those subtypes found in the designated
+     profile of an access_definition, with a corresponding subtype of
+     the derived type.  For a given subtype of the parent or progenitor
+     type, the corresponding subtype of the derived type is defined as
+     follows:
+
+19
+             * If the declaration of the derived type has neither a
+               known_discriminant_part nor a record_extension_part, then
+               the corresponding subtype has a constraint that
+               corresponds (as defined above for the first subtype of
+               the derived type) to that of the given subtype.
+
+20
+             * If the derived type is a record extension, then the
+               corresponding subtype is the first subtype of the derived
+               type.
+
+21
+             * If the derived type has a new known_discriminant_part but
+               is not a record extension, then the corresponding subtype
+               is constrained to those values that when converted to the
+               parent type belong to the given subtype (see *note
+               4.6::).  
+
+21.a
+          Reason: An inherited subprogram of an untagged type has an
+          Intrinsic calling convention, which precludes the use of the
+          Access attribute.  We preclude 'Access because correctly
+          performing all required constraint checks on an indirect call
+          to such an inherited subprogram was felt to impose an
+          undesirable implementation burden.
+
+21.b/3
+          {AI05-0164-1AI05-0164-1} Note that the exception to
+          substitution of the parent or progenitor type applies only in
+          the profiles of anonymous access-to-subprogram types.  The
+          exception is necessary to avoid calling an
+          access-to-subprogram with types and/or constraints different
+          than expected by the actual routine.
+
+22/2
+     {AI95-00401-01AI95-00401-01} The same formal parameters have
+     default_expressions in the profile of the inherited subprogram.
+     [Any type mismatch due to the systematic replacement of the parent
+     or progenitor type by the derived type is handled as part of the
+     normal type conversion associated with parameter passing -- see
+     *note 6.4.1::.]
+
+22.a/2
+          Reason: {AI95-00401-01AI95-00401-01} We don't introduce the
+          type conversion explicitly here since conversions to record
+          extensions or on access parameters are not generally legal.
+          Furthermore, any type conversion would just be "undone" since
+          the subprogram of the parent or progenitor is ultimately being
+          called anyway.  (Null procedures can be inherited from a
+          progenitor without being overridden, so it is possible to call
+          subprograms of an interface.)
+
+23/2
+{AI95-00401-01AI95-00401-01} If a primitive subprogram of the parent or
+progenitor type is visible at the place of the derived_type_definition,
+then the corresponding inherited subprogram is implicitly declared
+immediately after the derived_type_definition.  Otherwise, the inherited
+subprogram is implicitly declared later or not at all, as explained in
+*note 7.3.1::.
+
+24
+A derived type can also be defined by a private_extension_declaration
+(*note 7.3: S0194.) (see *note 7.3::) or a
+formal_derived_type_definition (*note 12.5.1: S0285.) (see *note
+12.5.1::).  Such a derived type is a partial view of the corresponding
+full or actual type.
+
+25
+All numeric types are derived types, in that they are implicitly derived
+from a corresponding root numeric type (see *note 3.5.4:: and *note
+3.5.6::).
+
+                          _Dynamic Semantics_
+
+26
+The elaboration of a derived_type_definition creates the derived type
+and its first subtype, and consists of the elaboration of the
+subtype_indication (*note 3.2.2: S0027.) and the record_extension_part
+(*note 3.9.1: S0075.), if any.  If the subtype_indication (*note 3.2.2:
+S0027.) depends on a discriminant, then only those expressions that do
+not depend on a discriminant are evaluated.
+
+26.a/2
+          Discussion: {AI95-00251-01AI95-00251-01} We don't mention the
+          interface_list, because it does not need elaboration (see
+          *note 3.9.4::).  This is consistent with the handling of
+          discriminant_parts, which aren't elaborated either.
+
+27/2
+{AI95-00391-01AI95-00391-01} {AI95-00401-01AI95-00401-01} For the
+execution of a call on an inherited subprogram, a call on the
+corresponding primitive subprogram of the parent or progenitor type is
+performed; the normal conversion of each actual parameter to the subtype
+of the corresponding formal parameter (see *note 6.4.1::) performs any
+necessary type conversion as well.  If the result type of the inherited
+subprogram is the derived type, the result of calling the subprogram of
+the parent or progenitor is converted to the derived type, or in the
+case of a null extension, extended to the derived type using the
+equivalent of an extension_aggregate with the original result as the
+ancestor_part and null record as the record_component_association_list.  
+
+27.a/2
+          Discussion: {AI95-00391-01AI95-00391-01} If an inherited
+          function returns the derived type, and the type is a nonnull
+          record extension, then the inherited function shall be
+          overridden, unless the type is abstract (in which case the
+          function is abstract, and (unless overridden) cannot be called
+          except via a dispatching call).  See *note 3.9.3::.
+
+     NOTES
+
+28
+     13  Classes are closed under derivation -- any class that contains
+     a type also contains its derivatives.  Operations available for a
+     given class of types are available for the derived types in that
+     class.
+
+29
+     14  Evaluating an inherited enumeration literal is equivalent to
+     evaluating the corresponding enumeration literal of the parent
+     type, and then converting the result to the derived type.  This
+     follows from their equivalence to parameterless functions.  
+
+30
+     15  A generic subprogram is not a subprogram, and hence cannot be a
+     primitive subprogram and cannot be inherited by a derived type.  On
+     the other hand, an instance of a generic subprogram can be a
+     primitive subprogram, and hence can be inherited.
+
+31
+     16  If the parent type is an access type, then the parent and the
+     derived type share the same storage pool; there is a null access
+     value for the derived type and it is the implicit initial value for
+     the type.  See *note 3.10::.
+
+32
+     17  If the parent type is a boolean type, the predefined relational
+     operators of the derived type deliver a result of the predefined
+     type Boolean (see *note 4.5.2::).  If the parent type is an integer
+     type, the right operand of the predefined exponentiation operator
+     is of the predefined type Integer (see *note 4.5.6::).
+
+33
+     18  Any discriminants of the parent type are either all inherited,
+     or completely replaced with a new set of discriminants.
+
+34
+     19  For an inherited subprogram, the subtype of a formal parameter
+     of the derived type need not have any value in common with the
+     first subtype of the derived type.
+
+34.a
+          Proof: This happens when the parent subtype is constrained to
+          a range that does not overlap with the range of a subtype of
+          the parent type that appears in the profile of some primitive
+          subprogram of the parent type.  For example:
+
+34.b
+               type T1 is range 1..100;
+               subtype S1 is T1 range 1..10;
+               procedure P(X : in S1);  -- P is a primitive subprogram
+               type T2 is new T1 range 11..20;
+               -- implicitly declared:
+               -- procedure P(X : in T2'Base range 1..10);
+               --      X cannot be in T2'First .. T2'Last
+
+35
+     20  If the reserved word abstract is given in the declaration of a
+     type, the type is abstract (see *note 3.9.3::).
+
+35.1/2
+     21  {AI95-00251-01AI95-00251-01} {AI95-00401-01AI95-00401-01} An
+     interface type that has a progenitor type "is derived from" that
+     type.  A derived_type_definition, however, never defines an
+     interface type.
+
+35.2/2
+     22  {AI95-00345-01AI95-00345-01} It is illegal for the parent type
+     of a derived_type_definition to be a synchronized tagged type.
+
+35.a/3
+          Proof: {AI05-0299-1AI05-0299-1} *note 3.9.1:: prohibits record
+          extensions whose parent type is a synchronized tagged type,
+          and this subclause requires tagged types to have a record
+          extension.  Thus there are no legal derivations.  Note that a
+          synchronized interface can be used as a progenitor in an
+          interface_type_definition as well as in task and protected
+          types, but we do not allow concrete extensions of any
+          synchronized tagged type.
+
+                              _Examples_
+
+36
+Examples of derived type declarations:
+
+37
+     type Local_Coordinate is new Coordinate;   --  two different types
+     type Midweek is new Day range Tue .. Thu;  --  see *note 3.5.1::
+     type Counter is new Positive;              --  same range as Positive 
+
+38
+     type Special_Key is new Key_Manager.Key;   --  see *note 7.3.1::
+       -- the inherited subprograms have the following specifications: 
+       --         procedure Get_Key(K : out Special_Key);
+       --         function "<"(X,Y : Special_Key) return Boolean;
+
+                     _Inconsistencies With Ada 83_
+
+38.a
+          When deriving from a (nonprivate, nonderived) type in the same
+          visible part in which it is defined, if a predefined operator
+          had been overridden prior to the derivation, the derived type
+          will inherit the user-defined operator rather than the
+          predefined operator.  The work-around (if the new behavior is
+          not the desired behavior) is to move the definition of the
+          derived type prior to the overriding of any predefined
+          operators.
+
+                    _Incompatibilities With Ada 83_
+
+38.b
+          When deriving from a (nonprivate, nonderived) type in the same
+          visible part in which it is defined, a primitive subprogram of
+          the parent type declared before the derived type will be
+          inherited by the derived type.  This can cause upward
+          incompatibilities in cases like this:
+
+38.c
+                  package P is
+                     type T is (A, B, C, D);
+                     function F( X : T := A ) return Integer;
+                     type NT is new T;
+                     -- inherits F as
+                     -- function F( X : NT := A ) return Integer;
+                     -- in Ada 95 only
+                     ...
+                  end P;
+                  ...
+                  use P;  -- Only one declaration of F from P is use-visible in
+                          -- Ada 83;  two declarations of F are use-visible in
+                          -- Ada 95.
+               begin
+                  ...
+                  if F > 1 then ... -- legal in Ada 83, ambiguous in Ada 95
+
+                        _Extensions to Ada 83_
+
+38.d
+          The syntax for a derived_type_definition is amended to include
+          an optional record_extension_part (see *note 3.9.1::).
+
+38.e
+          A derived type may override the discriminants of the parent by
+          giving a new discriminant_part.
+
+38.f
+          The parent type in a derived_type_definition may be a derived
+          type defined in the same visible part.
+
+38.g
+          When deriving from a type in the same visible part in which it
+          is defined, the primitive subprograms declared prior to the
+          derivation are inherited as primitive subprograms of the
+          derived type.  See *note 3.2.3::.
+
+                     _Wording Changes from Ada 83_
+
+38.h
+          We now talk about the classes to which a type belongs, rather
+          than a single class.
+
+                        _Extensions to Ada 95_
+
+38.i/2
+          {AI05-0190-1AI05-0190-1} {AI95-00251-01AI95-00251-01}
+          {AI95-00401-01AI95-00401-01} A derived type may inherit from
+          multiple (interface) progenitors, as well as the parent type
+          -- see *note 3.9.4::, "*note 3.9.4:: Interface Types".
+
+38.j/2
+          {AI95-00419-01AI95-00419-01} A derived type may specify that
+          it is a limited type.  This is required for interface
+          ancestors (from which limitedness is not inherited), but it is
+          generally useful as documentation of limitedness.
+
+                     _Wording Changes from Ada 95_
+
+38.k/2
+          {AI95-00391-01AI95-00391-01} Defined the result of functions
+          for null extensions (which we no longer require to be
+          overridden - see *note 3.9.3::).
+
+38.l/2
+          {AI95-00442-01AI95-00442-01} Defined the term "category of
+          types" and used it in wording elsewhere; also specified the
+          language-defined categories that form classes of types (this
+          was never normatively specified in Ada 95).
+
+                   _Incompatibilities With Ada 2005_
+
+38.m/3
+          {AI05-0096-1AI05-0096-1} Correction: Added a (re)check that
+          limited type extensions never are derived from nonlimited
+          types in generic private parts.  This is disallowed as it
+          would make it possible to pass a limited object to a
+          nonlimited class-wide type, which could then be copied.  This
+          is only possible using Ada 2005 syntax, so examples in
+          existing programs should be rare.
+
+                    _Wording Changes from Ada 2005_
+
+38.n/3
+          {AI05-0110-1AI05-0110-1} Correction: Added wording to clarify
+          that the characteristics of derived types are formally defined
+          here.  (This is the only place in the Standard that actually
+          spells out what sorts of things are actually characteristics,
+          which is rather important.)
+
+38.o/3
+          {AI05-0164-1AI05-0164-1} Correction: Added wording to ensure
+          that anonymous access-to-subprogram types don't get modified
+          on derivation.
+
+* Menu:
+
+* 3.4.1 ::    Derivation Classes
+
+
+File: aarm2012.info,  Node: 3.4.1,  Up: 3.4
+
+3.4.1 Derivation Classes
+------------------------
+
+1
+In addition to the various language-defined classes of types, types can
+be grouped into derivation classes.
+
+                          _Static Semantics_
+
+2/2
+{AI95-00251-01AI95-00251-01} {AI95-00401-01AI95-00401-01} A derived type
+is derived from its parent type directly; it is derived indirectly from
+any type from which its parent type is derived.  A derived type,
+interface type, type extension, task type, protected type, or formal
+derived type is also derived from every ancestor of each of its
+progenitor types, if any.  The derivation class of types for a type T
+(also called the class rooted at T) is the set consisting of T (the root
+type of the class) and all types derived from T (directly or indirectly)
+plus any associated universal or class-wide types (defined below).
+
+2.a
+          Discussion: Note that the definition of "derived from" is a
+          recursive definition.  We don't define a root type for all
+          interesting language-defined classes, though presumably we
+          could.
+
+2.b
+          To be honest: By the class-wide type "associated" with a type
+          T, we mean the type T'Class.  Similarly, the universal type
+          associated with root_integer, root_real, and root_fixed are
+          universal_integer, universal_real, and universal_fixed,
+          respectively.
+
+3/2
+{AI95-00230-01AI95-00230-01} Every type is either a specific type, a
+class-wide type, or a universal type.  A specific type is one defined by
+a type_declaration, a formal_type_declaration, or a full type definition
+embedded in another construct.  Class-wide and universal types are
+implicitly defined, to act as representatives for an entire class of
+types, as follows:
+
+3.a
+          To be honest: The root types root_integer, root_real, and
+          root_fixed are also specific types.  They are declared in the
+          specification of package Standard.
+
+4
+Class-wide types
+               Class-wide types are defined for [(and belong to)] each
+               derivation class rooted at a tagged type (see *note
+               3.9::).  Given a subtype S of a tagged type T, S'Class is
+               the subtype_mark for a corresponding subtype of the
+               tagged class-wide type T'Class.  Such types are called
+               "class-wide" because when a formal parameter is defined
+               to be of a class-wide type T'Class, an actual parameter
+               of any type in the derivation class rooted at T is
+               acceptable (see *note 8.6::).
+
+5
+               The set of values for a class-wide type T'Class is the
+               discriminated union of the set of values of each specific
+               type in the derivation class rooted at T (the tag acts as
+               the implicit discriminant -- see *note 3.9::).
+               Class-wide types have no primitive subprograms of their
+               own.  However, as explained in *note 3.9.2::, operands of
+               a class-wide type T'Class can be used as part of a
+               dispatching call on a primitive subprogram of the type T.
+               The only components [(including discriminants)] of
+               T'Class that are visible are those of T. If S is a first
+               subtype, then S'Class is a first subtype.
+
+5.a
+          Reason: We want S'Class to be a first subtype when S is, so
+          that an attribute_definition_clause (*note 13.3: S0309.) like
+          "for S'Class'Output use ...;" will be legal.
+
+6/2
+{AI95-00230-01AI95-00230-01} Universal types
+               Universal types are defined for [(and belong to)] the
+               integer, real, fixed point, and access classes, and are
+               referred to in this standard as respectively,
+               universal_integer, universal_real, universal_fixed, and
+               universal_access.  These are analogous to class-wide
+               types for these language-defined elementary classes.  As
+               with class-wide types, if a formal parameter is of a
+               universal type, then an actual parameter of any type in
+               the corresponding class is acceptable.  In addition, a
+               value of a universal type (including an integer or real
+               numeric_literal, or the literal null) is "universal" in
+               that it is acceptable where some particular type in the
+               class is expected (see *note 8.6::).
+
+7
+               The set of values of a universal type is the
+               undiscriminated union of the set of values possible for
+               any definable type in the associated class.  Like
+               class-wide types, universal types have no primitive
+               subprograms of their own.  However, their "universality"
+               allows them to be used as operands with the primitive
+               subprograms of any type in the corresponding class.
+
+7.a
+          Discussion: A class-wide type is only class-wide in one
+          direction, from specific to class-wide, whereas a universal
+          type is class-wide (universal) in both directions, from
+          specific to universal and back.
+
+7.b/2
+          {AI95-00230-01AI95-00230-01} We considered defining class-wide
+          or perhaps universal types for all derivation classes, not
+          just tagged classes and these four elementary classes.
+          However, this was felt to overly weaken the strong-typing
+          model in some situations.  Tagged types preserve strong type
+          distinctions thanks to the run-time tag.  Class-wide or
+          universal types for untagged types would weaken the
+          compile-time type distinctions without providing a
+          compensating run-time-checkable distinction.
+
+7.c
+          We considered defining standard names for the universal
+          numeric types so they could be used in formal parameter
+          specifications.  However, this was felt to impose an undue
+          implementation burden for some implementations.
+
+7.d
+          To be honest: Formally, the set of values of a universal type
+          is actually a copy of the undiscriminated union of the values
+          of the types in its class.  This is because we want each value
+          to have exactly one type, with explicit or implicit conversion
+          needed to go between types.  An alternative, consistent model
+          would be to associate a class, rather than a particular type,
+          with a value, even though any given expression would have a
+          particular type.  In that case, implicit type conversions
+          would not generally need to change the value, although an
+          associated subtype conversion might need to.
+
+8
+The integer and real numeric classes each have a specific root type in
+addition to their universal type, named respectively root_integer and
+root_real.
+
+9
+A class-wide or universal type is said to cover all of the types in its
+class.  A specific type covers only itself.
+
+10/2
+{AI95-00230-01AI95-00230-01} {AI95-00251-01AI95-00251-01} A specific
+type T2 is defined to be a descendant of a type T1 if T2 is the same as
+T1, or if T2 is derived (directly or indirectly) from T1.  A class-wide
+type T2'Class is defined to be a descendant of type T1 if T2 is a
+descendant of T1.  Similarly, the numeric universal types are defined to
+be descendants of the root types of their classes.  If a type T2 is a
+descendant of a type T1, then T1 is called an ancestor of T2.  An
+ultimate ancestor of a type is an ancestor of that type that is not
+itself a descendant of any other type.  Every untagged type has a unique
+ultimate ancestor.
+
+10.a
+          Ramification: A specific type is a descendant of itself.
+          Class-wide types are considered descendants of the
+          corresponding specific type, and do not have any descendants
+          of their own.
+
+10.b
+          A specific type is an ancestor of itself.  The root of a
+          derivation class is an ancestor of all types in the class,
+          including any class-wide types in the class.
+
+10.c
+          Discussion: The terms root, parent, ancestor, and ultimate
+          ancestor are all related.  For example:
+
+10.d/2
+             * {AI95-00251-01AI95-00251-01} Each type has at most one
+               parent, and one or more ancestor types; each untagged
+               type has exactly one ultimate ancestor.  In Ada 83, the
+               term "parent type" was sometimes used more generally to
+               include any ancestor type (e.g.  RM83-9.4(14)).  In Ada
+               95, we restrict parent to mean the immediate ancestor.
+
+10.e
+             * A class of types has at most one root type; a derivation
+               class has exactly one root type.
+
+10.f
+             * The root of a class is an ancestor of all of the types in
+               the class (including itself).
+
+10.g
+             * The type root_integer is the root of the integer class,
+               and is the ultimate ancestor of all integer types.  A
+               similar statement applies to root_real.
+
+10.h/2
+          Glossary entry: An ancestor of a type is the type itself or,
+          in the case of a type derived from other types, its parent
+          type or one of its progenitor types or one of their ancestors.
+          Note that ancestor and descendant are inverse relationships.
+
+10.i/2
+          Glossary entry: A type is a descendant of itself, its parent
+          and progenitor types, and their ancestors.  Note that
+          descendant and ancestor are inverse relationships.
+
+11
+An inherited component [(including an inherited discriminant)] of a
+derived type is inherited from a given ancestor of the type if the
+corresponding component was inherited by each derived type in the chain
+of derivations going back to the given ancestor.
+
+     NOTES
+
+12
+     23  Because operands of a universal type are acceptable to the
+     predefined operators of any type in their class, ambiguity can
+     result.  For universal_integer and universal_real, this potential
+     ambiguity is resolved by giving a preference (see *note 8.6::) to
+     the predefined operators of the corresponding root types
+     (root_integer and root_real, respectively).  Hence, in an
+     apparently ambiguous expression like
+
+13
+          1 + 4 < 7
+
+14
+     where each of the literals is of type universal_integer, the
+     predefined operators of root_integer will be preferred over those
+     of other specific integer types, thereby resolving the ambiguity.
+
+14.a
+          Ramification: Except for this preference, a root numeric type
+          is essentially like any other specific type in the associated
+          numeric class.  In particular, the result of a predefined
+          operator of a root numeric type is not "universal" (implicitly
+          convertible) even if both operands were.
+
+                     _Wording Changes from Ada 95_
+
+14.b/2
+          {AI95-00230-01AI95-00230-01} Updated the wording to define the
+          universal_access type.  This was defined to make null for
+          anonymous access types sensible.
+
+14.c/2
+          {AI95-00251-01AI95-00251-01} {AI95-00401-01AI95-00401-01} The
+          definitions of ancestors and descendants were updated to allow
+          multiple ancestors (necessary to support interfaces).
+
+
+File: aarm2012.info,  Node: 3.5,  Next: 3.6,  Prev: 3.4,  Up: 3
+
+3.5 Scalar Types
+================
+
+1
+Scalar types comprise enumeration types, integer types, and real types.
+Enumeration types and integer types are called discrete types; each
+value of a discrete type has a position number which is an integer
+value.  Integer types and real types are called numeric types.  [All
+scalar types are ordered, that is, all relational operators are
+predefined for their values.]
+
+                               _Syntax_
+
+2
+     range_constraint ::=  range range
+
+3
+     range ::=  range_attribute_reference
+        | simple_expression .. simple_expression
+
+3.a
+          Discussion: These need to be simple_expressions rather than
+          more general expressions because ranges appear in membership
+          tests and other contexts where expression ..  expression would
+          be ambiguous.
+
+4
+A range has a lower bound and an upper bound and specifies a subset of
+the values of some scalar type (the type of the range).  A range with
+lower bound L and upper bound R is described by "L ..  R". If R is less
+than L, then the range is a null range, and specifies an empty set of
+values.  Otherwise, the range specifies the values of the type from the
+lower bound to the upper bound, inclusive.  A value belongs to a range
+if it is of the type of the range, and is in the subset of values
+specified by the range.  A value satisfies a range constraint if it
+belongs to the associated range.  One range is included in another if
+all values that belong to the first range also belong to the second.
+
+                        _Name Resolution Rules_
+
+5
+For a subtype_indication containing a range_constraint, either directly
+or as part of some other scalar_constraint, the type of the range shall
+resolve to that of the type determined by the subtype_mark of the
+subtype_indication.  For a range of a given type, the simple_expressions
+of the range (likewise, the simple_expressions of the equivalent range
+for a range_attribute_reference) are expected to be of the type of the
+range.
+
+5.a
+          Discussion: In Ada 95, constraints only appear within
+          subtype_indications; things that look like constraints that
+          appear in type declarations are called something else like
+          real_range_specifications.
+
+5.b/3
+          {AI05-0299-1AI05-0299-1} We say "the expected type is ..."  or
+          "the type is expected to be ..."  depending on which reads
+          better.  They are fundamentally equivalent, and both feed into
+          the type resolution rules of subclause *note 8.6::.
+
+5.c
+          In some cases, it doesn't work to use expected types.  For
+          example, in the above rule, we say that the "type of the range
+          shall resolve to ..."  rather than "the expected type for the
+          range is ...".  We then use "expected type" for the bounds.
+          If we used "expected" at both points, there would be an
+          ambiguity, since one could apply the rules of *note 8.6::
+          either on determining the type of the range, or on determining
+          the types of the individual bounds.  It is clearly important
+          to allow one bound to be of a universal type, and the other of
+          a specific type, so we need to use "expected type" for the
+          bounds.  Hence, we used "shall resolve to" for the type of the
+          range as a whole.  There are other situations where "expected
+          type" is not quite right, and we use "shall resolve to"
+          instead.
+
+                          _Static Semantics_
+
+6
+The base range of a scalar type is the range of finite values of the
+type that can be represented in every unconstrained object of the type;
+it is also the range supported at a minimum for intermediate values
+during the evaluation of expressions involving predefined operators of
+the type.
+
+6.a
+          Implementation Note: Note that in some machine architectures
+          intermediates in an expression (particularly if static), and
+          register-resident variables might accommodate a wider range.
+          The base range does not include the values of this wider range
+          that are not assignable without overflow to memory-resident
+          objects.
+
+6.b
+          Ramification: The base range of an enumeration type is the
+          range of values of the enumeration type.
+
+6.c
+          Reason: If the representation supports infinities, the base
+          range is nevertheless restricted to include only the
+          representable finite values, so that 'Base'First and
+          'Base'Last are always guaranteed to be finite.
+
+6.d
+          To be honest: By a "value that can be assigned without
+          overflow" we don't mean to restrict ourselves to values that
+          can be represented exactly.  Values between machine
+          representable values can be assigned, but on subsequent
+          reading, a slightly different value might be retrieved, as
+          (partially) determined by the number of digits of precision of
+          the type.
+
+7
+[A constrained scalar subtype is one to which a range constraint
+applies.]  The range of a constrained scalar subtype is the range
+associated with the range constraint of the subtype.  The range of an
+unconstrained scalar subtype is the base range of its type.
+
+                          _Dynamic Semantics_
+
+8
+A range is compatible with a scalar subtype if and only if it is either
+a null range or each bound of the range belongs to the range of the
+subtype.  A range_constraint is compatible with a scalar subtype if and
+only if its range is compatible with the subtype.
+
+8.a
+          Ramification: Only range_constraints (explicit or implicit)
+          impose conditions on the values of a scalar subtype.  The
+          other scalar_constraints, digits_constraints and
+          delta_constraints impose conditions on the subtype denoted by
+          the subtype_mark in a subtype_indication, but don't impose a
+          condition on the values of the subtype being defined.
+          Therefore, a scalar subtype is not called constrained if all
+          that applies to it is a digits_constraint.  Decimal subtypes
+          are subtle, because a digits_constraint without a
+          range_constraint nevertheless includes an implicit
+          range_constraint.
+
+9
+The elaboration of a range_constraint consists of the evaluation of the
+range.  The evaluation of a range determines a lower bound and an upper
+bound.  If simple_expressions are given to specify bounds, the
+evaluation of the range evaluates these simple_expressions in an
+arbitrary order, and converts them to the type of the range.  If a
+range_attribute_reference is given, the evaluation of the range consists
+of the evaluation of the range_attribute_reference.
+
+10
+Attributes
+
+11
+For every scalar subtype S, the following attributes are defined:
+
+12
+S'First
+               S'First denotes the lower bound of the range of S. The
+               value of this attribute is of the type of S.
+
+12.a
+          Ramification: Evaluating S'First never raises
+          Constraint_Error.
+
+13
+S'Last
+               S'Last denotes the upper bound of the range of S. The
+               value of this attribute is of the type of S.
+
+13.a
+          Ramification: Evaluating S'Last never raises Constraint_Error.
+
+14
+S'Range
+               S'Range is equivalent to the range S'First ..  S'Last.
+
+15
+S'Base
+               S'Base denotes an unconstrained subtype of the type of S.
+               This unconstrained subtype is called the base subtype of
+               the type.  
+
+16
+S'Min
+               S'Min denotes a function with the following
+               specification:
+
+17
+                    function S'Min(Left, Right : S'Base)
+                      return S'Base
+
+18
+               The function returns the lesser of the values of the two
+               parameters.
+
+18.a
+          Discussion: The formal parameter names are italicized because
+          they cannot be used in calls -- see *note 6.4::.  Such a
+          specification cannot be written by the user because an
+          attribute_reference is not permitted as the designator of a
+          user-defined function, nor can its formal parameters be
+          anonymous.
+
+19
+S'Max
+               S'Max denotes a function with the following
+               specification:
+
+20
+                    function S'Max(Left, Right : S'Base)
+                      return S'Base
+
+21
+               The function returns the greater of the values of the two
+               parameters.
+
+22
+S'Succ
+               S'Succ denotes a function with the following
+               specification:
+
+23
+                    function S'Succ(Arg : S'Base)
+                      return S'Base
+
+24
+               For an enumeration type, the function returns the value
+               whose position number is one more than that of the value
+               of Arg; Constraint_Error is raised if there is no such
+               value of the type.  For an integer type, the function
+               returns the result of adding one to the value of Arg.
+               For a fixed point type, the function returns the result
+               of adding small to the value of Arg.  For a floating
+               point type, the function returns the machine number (as
+               defined in *note 3.5.7::) immediately above the value of
+               Arg; Constraint_Error is raised if there is no such
+               machine number.
+
+24.a
+          Ramification: S'Succ for a modular integer subtype wraps
+          around if the value of Arg is S'Base'Last.  S'Succ for a
+          signed integer subtype might raise Constraint_Error if the
+          value of Arg is S'Base'Last, or it might return the
+          out-of-base-range value S'Base'Last+1, as is permitted for all
+          predefined numeric operations.
+
+25
+S'Pred
+               S'Pred denotes a function with the following
+               specification:
+
+26
+                    function S'Pred(Arg : S'Base)
+                      return S'Base
+
+27
+               For an enumeration type, the function returns the value
+               whose position number is one less than that of the value
+               of Arg; Constraint_Error is raised if there is no such
+               value of the type.  For an integer type, the function
+               returns the result of subtracting one from the value of
+               Arg.  For a fixed point type, the function returns the
+               result of subtracting small from the value of Arg.  For a
+               floating point type, the function returns the machine
+               number (as defined in *note 3.5.7::) immediately below
+               the value of Arg; Constraint_Error is raised if there is
+               no such machine number.
+
+27.a
+          Ramification: S'Pred for a modular integer subtype wraps
+          around if the value of Arg is S'Base'First.  S'Pred for a
+          signed integer subtype might raise Constraint_Error if the
+          value of Arg is S'Base'First, or it might return the
+          out-of-base-range value S'Base'First-1, as is permitted for
+          all predefined numeric operations.
+
+27.1/2
+S'Wide_Wide_Image
+               {AI95-00285-01AI95-00285-01} S'Wide_Wide_Image denotes a
+               function with the following specification:
+
+27.2/2
+                    function S'Wide_Wide_Image(Arg : S'Base)
+                      return Wide_Wide_String
+
+27.3/2
+               The function returns an image of the value of Arg, that
+               is, a sequence of characters representing the value in
+               display form.  The lower bound of the result is one.
+
+27.4/2
+               The image of an integer value is the corresponding
+               decimal literal, without underlines, leading zeros,
+               exponent, or trailing spaces, but with a single leading
+               character that is either a minus sign or a space.
+
+27.b/2
+          Implementation Note: If the machine supports negative zeros
+          for signed integer types, it is not specified whether " 0" or
+          "-0" should be returned for negative zero.  We don't have
+          enough experience with such machines to know what is
+          appropriate, and what other languages do.  In any case, the
+          implementation should be consistent.
+
+27.5/2
+               The image of an enumeration value is either the
+               corresponding identifier in upper case or the
+               corresponding character literal (including the two
+               apostrophes); neither leading nor trailing spaces are
+               included.  For a nongraphic character (a value of a
+               character type that has no enumeration literal associated
+               with it), the result is a corresponding language-defined
+               name in upper case (for example, the image of the
+               nongraphic character identified as nul is "NUL" -- the
+               quotes are not part of the image).
+
+27.c/2
+          Implementation Note: For an enumeration type T that has
+          "holes" (caused by an enumeration_representation_clause (*note
+          13.4: S0310.)), T'Wide_Image should raise Program_Error if the
+          value is one of the holes (which is a bounded error anyway,
+          since holes can be generated only via uninitialized variables
+          and similar things).
+
+27.6/2
+               The image of a floating point value is a decimal real
+               literal best approximating the value (rounded away from
+               zero if halfway between) with a single leading character
+               that is either a minus sign or a space, a single digit
+               (that is nonzero unless the value is zero), a decimal
+               point, S'Digits-1 (see *note 3.5.8::) digits after the
+               decimal point (but one if S'Digits is one), an upper case
+               E, the sign of the exponent (either + or -), and two or
+               more digits (with leading zeros if necessary)
+               representing the exponent.  If S'Signed_Zeros is True,
+               then the leading character is a minus sign for a
+               negatively signed zero.
+
+27.d/2
+          To be honest: Leading zeros are present in the exponent only
+          if necessary to make the exponent at least two digits.
+
+27.e/2
+          Reason: This image is intended to conform to that produced by
+          Text_IO.Float_IO.Put in its default format.
+
+27.f/2
+          Implementation Note: The rounding direction is specified here
+          to ensure portability of output results.
+
+27.7/2
+               The image of a fixed point value is a decimal real
+               literal best approximating the value (rounded away from
+               zero if halfway between) with a single leading character
+               that is either a minus sign or a space, one or more
+               digits before the decimal point (with no redundant
+               leading zeros), a decimal point, and S'Aft (see *note
+               3.5.10::) digits after the decimal point.
+
+27.g/2
+          Reason: This image is intended to conform to that produced by
+          Text_IO.Fixed_IO.Put.
+
+27.h/2
+          Implementation Note: The rounding direction is specified here
+          to ensure portability of output results.
+
+27.i/2
+          Implementation Note: For a machine that supports negative
+          zeros, it is not specified whether " 0.000" or "-0.000" is
+          returned.  See corresponding comment above about integer types
+          with signed zeros.
+
+28
+S'Wide_Image
+               S'Wide_Image denotes a function with the following
+               specification:
+
+29
+                    function S'Wide_Image(Arg : S'Base)
+                      return Wide_String
+
+30/3
+               {AI95-00285-01AI95-00285-01} {AI05-0262-1AI05-0262-1}
+               {AI05-0264-1AI05-0264-1} The function returns an image of
+               the value of Arg as a Wide_String.  The lower bound of
+               the result is one.  The image has the same sequence of
+               graphic characters as defined for S'Wide_Wide_Image if
+               all the graphic characters are defined in Wide_Character;
+               otherwise, the sequence of characters is implementation
+               defined (but no shorter than that of S'Wide_Wide_Image
+               for the same value of Arg).
+
+30.a/2
+          Implementation defined: The sequence of characters of the
+          value returned by S'Wide_Image when some of the graphic
+          characters of S'Wide_Wide_Image are not defined in
+          Wide_Character.
+
+               Paragraphs 31 through 34 were moved to Wide_Wide_Image.
+
+35
+S'Image
+               S'Image denotes a function with the following
+               specification:
+
+36
+                    function S'Image(Arg : S'Base)
+                      return String
+
+37/3
+               {AI95-00285-01AI95-00285-01} {AI05-0264-1AI05-0264-1} The
+               function returns an image of the value of Arg as a
+               String.  The lower bound of the result is one.  The image
+               has the same sequence of graphic characters as that
+               defined for S'Wide_Wide_Image if all the graphic
+               characters are defined in Character; otherwise, the
+               sequence of characters is implementation defined (but no
+               shorter than that of S'Wide_Wide_Image for the same value
+               of Arg).
+
+37.a/2
+          Implementation defined: The sequence of characters of the
+          value returned by S'Image when some of the graphic characters
+          of S'Wide_Wide_Image are not defined in Character.
+
+37.1/2
+S'Wide_Wide_Width
+               {AI95-00285-01AI95-00285-01} S'Wide_Wide_Width denotes
+               the maximum length of a Wide_Wide_String returned by
+               S'Wide_Wide_Image over all values of the subtype S. It
+               denotes zero for a subtype that has a null range.  Its
+               type is universal_integer.
+
+38
+S'Wide_Width
+               S'Wide_Width denotes the maximum length of a Wide_String
+               returned by S'Wide_Image over all values of the subtype
+               S. It denotes zero for a subtype that has a null range.
+               Its type is universal_integer.
+
+39
+S'Width
+               S'Width denotes the maximum length of a String returned
+               by S'Image over all values of the subtype S. It denotes
+               zero for a subtype that has a null range.  Its type is
+               universal_integer.
+
+39.1/2
+S'Wide_Wide_Value
+               {AI95-00285-01AI95-00285-01} S'Wide_Wide_Value denotes a
+               function with the following specification:
+
+39.2/2
+                    function S'Wide_Wide_Value(Arg : Wide_Wide_String)
+                      return S'Base
+
+39.3/2
+               This function returns a value given an image of the value
+               as a Wide_Wide_String, ignoring any leading or trailing
+               spaces.
+
+39.4/3
+               {AI05-0264-1AI05-0264-1} For the evaluation of a call on
+               S'Wide_Wide_Value for an enumeration subtype S, if the
+               sequence of characters of the parameter (ignoring leading
+               and trailing spaces) has the syntax of an enumeration
+               literal and if it corresponds to a literal of the type of
+               S (or corresponds to the result of S'Wide_Wide_Image for
+               a nongraphic character of the type), the result is the
+               corresponding enumeration value; otherwise,
+               Constraint_Error is raised.
+
+39.a.1/2
+          Discussion: It's not crystal clear that Range_Check is
+          appropriate here, but it doesn't seem worthwhile to invent a
+          whole new check name just for this weird case, so we decided
+          to lump it in with Range_Check.
+
+39.a.2/2
+          To be honest: {8652/00968652/0096}
+          {AI95-00053-01AI95-00053-01} A sequence of characters
+          corresponds to the result of S'Wide_Wide_Image if it is the
+          same ignoring case.  Thus, the case of an image of a
+          nongraphic character does not matter.  For example,
+          Character'Wide_Wide_Value("nul") does not raise
+          Constraint_Error, even though Character'Wide_Wide_Image
+          returns "NUL" for the nul character.
+
+39.5/3
+               {AI05-0264-1AI05-0264-1} For the evaluation of a call on
+               S'Wide_Wide_Value for an integer subtype S, if the
+               sequence of characters of the parameter (ignoring leading
+               and trailing spaces) has the syntax of an integer
+               literal, with an optional leading sign character (plus or
+               minus for a signed type; only plus for a modular type),
+               and the corresponding numeric value belongs to the base
+               range of the type of S, then that value is the result; 
+               otherwise, Constraint_Error is raised.
+
+39.a.3/2
+          Discussion: We considered allowing 'Value to return a
+          representable but out-of-range value without a
+          Constraint_Error.  However, we currently require (see *note
+          4.9::) in an assignment_statement like "X :=
+          <numeric_literal>;" that the value of the numeric-literal be
+          in X's base range (at compile time), so it seems unfriendly
+          and confusing to have a different range allowed for 'Value.
+          Furthermore, for modular types, without the requirement for
+          being in the base range, 'Value would have to handle
+          arbitrarily long literals (since overflow never occurs for
+          modular types).
+
+39.6/2
+               For the evaluation of a call on S'Wide_Wide_Value for a
+               real subtype S, if the sequence of characters of the
+               parameter (ignoring leading and trailing spaces) has the
+               syntax of one of the following:
+
+39.7/2
+                  * numeric_literal
+
+39.8/2
+                  * numeral.[exponent]
+
+39.9/2
+                  * .numeral[exponent]
+
+39.10/2
+                  * base#based_numeral.#[exponent]
+
+39.11/2
+                  * base#.based_numeral#[exponent]
+
+39.12/3
+               {AI05-0264-1AI05-0264-1} with an optional leading sign
+               character (plus or minus), and if the corresponding
+               numeric value belongs to the base range of the type of S,
+               then that value is the result; otherwise,
+               Constraint_Error is raised.  The sign of a zero value is
+               preserved (positive if none has been specified) if
+               S'Signed_Zeros is True.
+
+40
+S'Wide_Value
+               S'Wide_Value denotes a function with the following
+               specification:
+
+41
+                    function S'Wide_Value(Arg : Wide_String)
+                      return S'Base
+
+42
+               This function returns a value given an image of the value
+               as a Wide_String, ignoring any leading or trailing
+               spaces.
+
+43/3
+               {AI95-00285-01AI95-00285-01} {AI05-0264-1AI05-0264-1} For
+               the evaluation of a call on S'Wide_Value for an
+               enumeration subtype S, if the sequence of characters of
+               the parameter (ignoring leading and trailing spaces) has
+               the syntax of an enumeration literal and if it
+               corresponds to a literal of the type of S (or corresponds
+               to the result of S'Wide_Image for a value of the type),
+               the result is the corresponding enumeration value; 
+               otherwise, Constraint_Error is raised.  For a numeric
+               subtype S, the evaluation of a call on S'Wide_Value with
+               Arg of type Wide_String is equivalent to a call on
+               S'Wide_Wide_Value for a corresponding Arg of type
+               Wide_Wide_String.
+
+43.a/2
+          This paragraph was deleted.
+
+43.a.1/2
+          This paragraph was deleted.{8652/00968652/0096}
+          {AI95-00053-01AI95-00053-01}
+
+43.b/2
+          Reason: S'Wide_Value is subtly different from
+          S'Wide_Wide_Value for enumeration subtypes since S'Wide_Image
+          might produce a different sequence of characters than
+          S'Wide_Wide_Image if the enumeration literal uses characters
+          outside of the predefined type Wide_Character.  That is why we
+          don't just define S'Wide_Value in terms of S'Wide_Wide_Value
+          for enumeration subtypes.  S'Wide_Value and S'Wide_Wide_Value
+          for numeric subtypes yield the same result given the same
+          sequence of characters.
+
+               Paragraphs 44 through 51 were moved to Wide_Wide_Value.
+
+52
+S'Value
+               S'Value denotes a function with the following
+               specification:
+
+53
+                    function S'Value(Arg : String)
+                      return S'Base
+
+54
+               This function returns a value given an image of the value
+               as a String, ignoring any leading or trailing spaces.
+
+55/3
+               {AI95-00285-01AI95-00285-01} {AI05-0264-1AI05-0264-1} For
+               the evaluation of a call on S'Value for an enumeration
+               subtype S, if the sequence of characters of the parameter
+               (ignoring leading and trailing spaces) has the syntax of
+               an enumeration literal and if it corresponds to a literal
+               of the type of S (or corresponds to the result of S'Image
+               for a value of the type), the result is the corresponding
+               enumeration value; otherwise, Constraint_Error is raised.
+               For a numeric subtype S, the evaluation of a call on
+               S'Value with Arg of type String is equivalent to a call
+               on S'Wide_Wide_Value for a corresponding Arg of type
+               Wide_Wide_String.
+
+55.a/2
+          Reason: {AI95-00285-01AI95-00285-01} S'Value is subtly
+          different from S'Wide_Wide_Value for enumeration subtypes; see
+          the discussion under S'Wide_Value.
+
+                     _Implementation Permissions_
+
+56/2
+{AI95-00285-01AI95-00285-01} An implementation may extend the
+Wide_Wide_Value, [Wide_Value, Value, Wide_Wide_Image, Wide_Image, and
+Image] attributes of a floating point type to support special values
+such as infinities and NaNs.
+
+56.a/2
+          Proof: {AI95-00285-01AI95-00285-01} The permission is really
+          only necessary for Wide_Wide_Value, because Value and
+          Wide_Value are defined in terms of Wide_Wide_Value, and
+          because the behavior of Wide_Wide_Image, Wide_Image, and Image
+          is already unspecified for things like infinities and NaNs.
+
+56.b
+          Reason: This is to allow implementations to define full
+          support for IEEE arithmetic.  See also the similar permission
+          for Get in *note A.10.9::.
+
+56.1/3
+{AI05-0182-1AI05-0182-1} {AI05-0262-1AI05-0262-1}
+{AI05-0269-1AI05-0269-1} An implementation may extend the
+Wide_Wide_Value, Wide_Value, and Value attributes of a character type to
+accept strings of the form "Hex_hhhhhhhh" (ignoring case) for any
+character (not just the ones for which Wide_Wide_Image would produce
+that form -- see *note 3.5.2::), as well as three-character strings of
+the form "'X'", where X is any character, including nongraphic
+characters.
+
+                          _Static Semantics_
+
+56.2/3
+{AI05-0228-1AI05-0228-1} For a scalar type, the following
+language-defined representation aspect may be specified with an
+aspect_specification (see *note 13.1.1::):
+
+56.3/3
+Default_Value
+               This aspect shall be specified by a static expression,
+               and that expression shall be explicit, even if the aspect
+               has a boolean type.  Default_Value shall be specified
+               only on a full_type_declaration.
+
+56.c/3
+          Reason: The part about requiring an explicit expression is to
+          disallow omitting the value for this aspect, which would
+          otherwise be allowed by the rules of *note 13.1.1::.
+
+56.d/3
+          This is a representation aspect in order to disallow
+          specifying it on a derived type that has inherited primitive
+          subprograms; that is necessary as the sizes of out parameters
+          could be different whether or not a Default_Value is specified
+          (see *note 6.4.1::).
+
+56.e/3
+          Aspect Description for Default_Value: Default value for a
+          scalar subtype.
+
+56.4/3
+{AI05-0228-1AI05-0228-1} If a derived type with no primitive subprograms
+inherits a boolean Default_Value aspect, the aspect may be specified to
+have any value for the derived type.
+
+56.f/3
+          Reason: This overrides the *note 13.1.1:: rule that says that
+          a boolean aspect with a value True cannot be changed.
+
+                        _Name Resolution Rules_
+
+56.5/3
+{AI05-0228-1AI05-0228-1} The expected type for the expression specified
+for the Default_Value aspect is the type defined by the
+full_type_declaration on which it appears.
+
+     NOTES
+
+57
+     24  The evaluation of S'First or S'Last never raises an exception.
+     If a scalar subtype S has a nonnull range, S'First and S'Last
+     belong to this range.  These values can, for example, always be
+     assigned to a variable of subtype S.
+
+57.a
+          Discussion: This paragraph addresses an issue that came up
+          with Ada 83, where for fixed point types, the end points of
+          the range specified in the type definition were not
+          necessarily within the base range of the type.  However, it
+          was later clarified (and we reconfirm it in *note 3.5.9::,
+          "*note 3.5.9:: Fixed Point Types") that the First and Last
+          attributes reflect the true bounds chosen for the type, not
+          the bounds specified in the type definition (which might be
+          outside the ultimately chosen base range).
+
+58
+     25  For a subtype of a scalar type, the result delivered by the
+     attributes Succ, Pred, and Value might not belong to the subtype;
+     similarly, the actual parameters of the attributes Succ, Pred, and
+     Image need not belong to the subtype.
+
+59
+     26  For any value V (including any nongraphic character) of an
+     enumeration subtype S, S'Value(S'Image(V)) equals V, as do
+     S'Wide_Value(S'Wide_Image(V)) and
+     S'Wide_Wide_Value(S'Wide_Wide_Image(V)). None of these expressions
+     ever raise Constraint_Error.
+
+                              _Examples_
+
+60
+Examples of ranges:
+
+61
+     -10 .. 10
+     X .. X + 1
+     0.0 .. 2.0*Pi
+     Red .. Green     -- see *note 3.5.1::
+     1 .. 0           -- a null range
+     Table'Range      -- a range attribute reference (see *note 3.6::)
+
+62
+Examples of range constraints:
+
+63
+     range -999.0 .. +999.0
+     range S'First+1 .. S'Last-1
+
+                    _Incompatibilities With Ada 83_
+
+63.a/1
+          S'Base is no longer defined for nonscalar types.  One
+          conceivable existing use of S'Base for nonscalar types is
+          S'Base'Size where S is a generic formal private type.
+          However, that is not generally useful because the actual
+          subtype corresponding to S might be a constrained array or
+          discriminated type, which would mean that S'Base'Size might
+          very well overflow (for example, S'Base'Size where S is a
+          constrained subtype of String will generally be 8 *
+          (Integer'Last + 1)).  For derived discriminated types that are
+          packed, S'Base'Size might not even be well defined if the
+          first subtype is constrained, thereby allowing some amount of
+          normally required "dope" to have been squeezed out in the
+          packing.  Hence our conclusion is that S'Base'Size is not
+          generally useful in a generic, and does not justify keeping
+          the attribute Base for nonscalar types just so it can be used
+          as a prefix.
+
+                        _Extensions to Ada 83_
+
+63.b
+          The attribute S'Base for a scalar subtype is now permitted
+          anywhere a subtype_mark is permitted.  S'Base'First ..
+          S'Base'Last is the base range of the type.  Using an
+          attribute_definition_clause (*note 13.3: S0309.), one cannot
+          specify any subtype-specific attributes for the subtype
+          denoted by S'Base (the base subtype).
+
+63.c
+          The attribute S'Range is now allowed for scalar subtypes.
+
+63.d
+          The attributes S'Min and S'Max are now defined, and made
+          available for all scalar types.
+
+63.e
+          The attributes S'Succ, S'Pred, S'Image, S'Value, and S'Width
+          are now defined for real types as well as discrete types.
+
+63.f
+          Wide_String versions of S'Image and S'Value are defined.
+          These are called S'Wide_Image and S'Wide_Value to avoid
+          introducing ambiguities involving uses of these attributes
+          with string literals.
+
+                     _Wording Changes from Ada 83_
+
+63.g
+          We now use the syntactic category range_attribute_reference
+          since it is now syntactically distinguished from other
+          attribute references.
+
+63.h
+          The definition of S'Base has been moved here from 3.3.3 since
+          it now applies only to scalar types.
+
+63.i
+          More explicit rules are provided for nongraphic characters.
+
+                        _Extensions to Ada 95_
+
+63.j/2
+          {AI95-00285-01AI95-00285-01} The attributes Wide_Wide_Image,
+          Wide_Wide_Value, and Wide_Wide_Width are new.  Note that
+          Wide_Image and Wide_Value are now defined in terms of
+          Wide_Wide_Image and Wide_Wide_Value, but the image of types
+          other than characters have not changed.
+
+                     _Wording Changes from Ada 95_
+
+63.k/2
+          {AI95-00285-01AI95-00285-01} The Wide_Image and Wide_Value
+          attributes are now defined in terms of Wide_Wide_Image and
+          Wide_Wide_Value, but the images of numeric types have not
+          changed.
+
+                    _Inconsistencies With Ada 2005_
+
+63.l/3
+          {AI05-0181-1AI05-0181-1} Correction: Soft hyphen (code point
+          173) is nongraphic in ISO/IEC 10646:2011 (and also in the 2003
+          version of that standard).  Thus, we have given it the
+          language-defined name soft_hyphen.  This changes the result of
+          Character'Image (and all of the related types and Image
+          attributes) for this character, and changes the behavior of
+          Character'Value (and all of the related types and Value
+          attributes) for this character, and (in unusual
+          circumstances), changes the result for Character'Width (and
+          all of the related types and Width attributes).  The vast
+          majority of programs won't see any difference, as they are
+          already prepared to handle nongraphic characters.
+
+63.m/3
+          {AI05-0182-1AI05-0182-1} Correction: Added an Implementation
+          Permissions to let Wide_Wide_Value, Wide_Value, and Value
+          accept strings in the form of literals containing nongraphic
+          characters and "Hex_hhhhhhhh" for Latin-1 and graphic
+          characters.  These were required to raise Constraint_Error in
+          Ada 2005.  Since these attributes aren't very useful,
+          implementations were inconsistent as to whether these were
+          accepted, and since code that would care why the attribute
+          failed seems unlikely, this should not be a problem in
+          practice.
+
+                       _Extensions to Ada 2005_
+
+63.n/3
+          {AI05-0228-1AI05-0228-1} The new aspect Default_Value allows
+          defining implicit initial values (see *note 3.3.1::) for
+          scalar types.
+
+* Menu:
+
+* 3.5.1 ::    Enumeration Types
+* 3.5.2 ::    Character Types
+* 3.5.3 ::    Boolean Types
+* 3.5.4 ::    Integer Types
+* 3.5.5 ::    Operations of Discrete Types
+* 3.5.6 ::    Real Types
+* 3.5.7 ::    Floating Point Types
+* 3.5.8 ::    Operations of Floating Point Types
+* 3.5.9 ::    Fixed Point Types
+* 3.5.10 ::   Operations of Fixed Point Types
+
+
+File: aarm2012.info,  Node: 3.5.1,  Next: 3.5.2,  Up: 3.5
+
+3.5.1 Enumeration Types
+-----------------------
+
+1
+[ An enumeration_type_definition defines an enumeration type.]
+
+                               _Syntax_
+
+2
+     enumeration_type_definition ::=
+        (enumeration_literal_specification {, 
+     enumeration_literal_specification})
+
+3
+     enumeration_literal_specification ::=  defining_identifier | 
+     defining_character_literal
+
+4
+     defining_character_literal ::= character_literal
+
+                           _Legality Rules_
+
+5/3
+{AI05-0227-1AI05-0227-1} {AI05-0299-1AI05-0299-1} The
+defining_identifiers in upper case [and the defining_character_literals]
+listed in an enumeration_type_definition shall be distinct.
+
+5.a/3
+          Proof: {AI05-0227-1AI05-0227-1} For character literals, this
+          is a ramification of the normal disallowance of homographs
+          explicitly declared immediately in the same declarative
+          region.
+
+5.b/3
+          Reason: {AI05-0227-1AI05-0227-1} To ease implementation of the
+          attribute Wide_Wide_Value, we require that all enumeration
+          literals have distinct images.
+
+                          _Static Semantics_
+
+6/3
+{AI05-0006-1AI05-0006-1} Each enumeration_literal_specification is the
+explicit declaration of the corresponding enumeration literal: it
+declares a parameterless function, whose defining name is the
+defining_identifier (*note 3.1: S0022.) or defining_character_literal
+(*note 3.5.1: S0040.), and whose result subtype is the base subtype of
+the enumeration type.
+
+6.a
+          Reason: This rule defines the profile of the enumeration
+          literal, which is used in the various types of conformance.
+
+6.b
+          Ramification: The parameterless function associated with an
+          enumeration literal is fully defined by the
+          enumeration_type_definition; a body is not permitted for it,
+          and it never fails the Elaboration_Check when called.
+
+6.c/3
+          Discussion: {AI05-0006-1AI05-0006-1} The result subtype is
+          primarily a concern when an enumeration literal is used as the
+          expression of a case statement, due to the full coverage
+          requirement based on the nominal subtype.
+
+7
+Each enumeration literal corresponds to a distinct value of the
+enumeration type, and to a distinct position number.  The position
+number of the value of the first listed enumeration literal is zero; the
+position number of the value of each subsequent enumeration literal is
+one more than that of its predecessor in the list.
+
+8
+[The predefined order relations between values of the enumeration type
+follow the order of corresponding position numbers.]
+
+9
+[ If the same defining_identifier or defining_character_literal is
+specified in more than one enumeration_type_definition (*note 3.5.1:
+S0038.), the corresponding enumeration literals are said to be
+overloaded.  At any place where an overloaded enumeration literal occurs
+in the text of a program, the type of the enumeration literal has to be
+determinable from the context (see *note 8.6::).]
+
+                          _Dynamic Semantics_
+
+10
+The elaboration of an enumeration_type_definition creates the
+enumeration type and its first subtype, which is constrained to the base
+range of the type.
+
+10.a
+          Ramification: The first subtype of a discrete type is always
+          constrained, except in the case of a derived type whose parent
+          subtype is Whatever'Base.
+
+11
+When called, the parameterless function associated with an enumeration
+literal returns the corresponding value of the enumeration type.
+
+     NOTES
+
+12
+     27  If an enumeration literal occurs in a context that does not
+     otherwise suffice to determine the type of the literal, then
+     qualification by the name of the enumeration type is one way to
+     resolve the ambiguity (see *note 4.7::).
+
+                              _Examples_
+
+13
+Examples of enumeration types and subtypes:
+
+14
+     type Day    is (Mon, Tue, Wed, Thu, Fri, Sat, Sun);
+     type Suit   is (Clubs, Diamonds, Hearts, Spades);
+     type Gender is (M, F);
+     type Level  is (Low, Medium, Urgent);
+     type Color  is (White, Red, Yellow, Green, Blue, Brown, Black);
+     type Light  is (Red, Amber, Green); -- Red and Green are overloaded
+
+15
+     type Hexa   is ('A', 'B', 'C', 'D', 'E', 'F');
+     type Mixed  is ('A', 'B', '*', B, None, '?', '%');
+
+16
+     subtype Weekday is Day   range Mon .. Fri;
+     subtype Major   is Suit  range Hearts .. Spades;
+     subtype Rainbow is Color range Red .. Blue;  --  the Color Red, not the 
Light
+
+                     _Wording Changes from Ada 83_
+
+16.a
+          The syntax rule for defining_character_literal is new.  It is
+          used for the defining occurrence of a character_literal,
+          analogously to defining_identifier.  Usage occurrences use the
+          name or selector_name syntactic categories.
+
+16.b
+          We emphasize the fact that an enumeration literal denotes a
+          function, which is called to produce a value.
+
+                   _Incompatibilities With Ada 2005_
+
+16.c/3
+          {AI05-0227-1AI05-0227-1} Correction: Required that all
+          enumeration literals in a type have distinct images; this
+          might not be the case since upper case conversion can map
+          distinct characters to the same upper case character.  This
+          can only happen for identifiers using Unicode characters first
+          allowed by Ada 2005; moreover, the original definition of Ada
+          2005 was confused and appeared to require inconsistent results
+          from the Image attribute, so implementations that allowed
+          problematic cases are rare; the problematic cases are very
+          rare; so it is expected that this change would only affect
+          test programs.
+
+                    _Wording Changes from Ada 2005_
+
+16.d/3
+          {AI05-0006-1AI05-0006-1} Correction: Defined the result
+          subtype of an enumeration literal to close a minor language
+          hole.
+
+
+File: aarm2012.info,  Node: 3.5.2,  Next: 3.5.3,  Prev: 3.5.1,  Up: 3.5
+
+3.5.2 Character Types
+---------------------
+
+                          _Static Semantics_
+
+1
+An enumeration type is said to be a character type if at least one of
+its enumeration literals is a character_literal.
+
+2/3
+{AI95-00285-01AI95-00285-01} {AI05-0181-1AI05-0181-1}
+{AI05-0262-1AI05-0262-1} {AI05-0266-1AI05-0266-1} The predefined type
+Character is a character type whose values correspond to the 256 code
+points of Row 00 (also known as Latin-1) of the ISO/IEC 10646:2011 Basic
+Multilingual Plane (BMP). Each of the graphic characters of Row 00 of
+the BMP has a corresponding character_literal in Character.  Each of the
+nongraphic characters of Row 00 has a corresponding language-defined
+name, which is not usable as an enumeration literal, but which is usable
+with the attributes Image, Wide_Image, Wide_Wide_Image, Value,
+Wide_Value, and Wide_Wide_Value; these names are given in the definition
+of type Character in *note A.1::, "*note A.1:: The Package Standard",
+but are set in italics.  
+
+2.a/3
+          Discussion: {AI05-0262-1AI05-0262-1} Code point is defined in
+          ISO/IEC 10646:2011.
+
+3/3
+{AI95-00285-01AI95-00285-01} {AI05-0262-1AI05-0262-1} The predefined
+type Wide_Character is a character type whose values correspond to the
+65536 code points of the ISO/IEC 10646:2011 Basic Multilingual Plane
+(BMP). Each of the graphic characters of the BMP has a corresponding
+character_literal in Wide_Character.  The first 256 values of
+Wide_Character have the same character_literal or language-defined name
+as defined for Character.  Each of the graphic_characters has a
+corresponding character_literal.
+
+4/3
+{AI95-00285-01AI95-00285-01} {AI05-0262-1AI05-0262-1} The predefined
+type Wide_Wide_Character is a character type whose values correspond to
+the 2147483648 code points of the ISO/IEC 10646:2011 character set.
+Each of the graphic_characters has a corresponding character_literal in
+Wide_Wide_Character.  The first 65536 values of Wide_Wide_Character have
+the same character_literal or language-defined name as defined for
+Wide_Character.
+
+5/3
+{AI95-00285-01AI95-00285-01} {AI05-0262-1AI05-0262-1} The characters
+whose code point is larger than 16#FF# and which are not
+graphic_characters have language-defined names which are formed by
+appending to the string "Hex_" the representation of their code point in
+hexadecimal as eight extended digits.  As with other language-defined
+names, these names are usable only with the attributes (Wide_)Wide_Image
+and (Wide_)Wide_Value; they are not usable as enumeration literals.
+
+5.a/2
+          Reason: {AI95-00285-01AI95-00285-01} The language-defined
+          names are not usable as enumeration literals to avoid
+          "polluting" the name space.  Since Wide_Character and
+          Wide_Wide_Character are defined in Standard, if the
+          language-defined names were usable as enumeration literals,
+          they would hide other nonoverloadable declarations with the
+          same names in use-d packages.]}
+
+Paragraphs 6 and 7 were deleted.
+
+     NOTES
+
+8
+     28  The language-defined library package Characters.Latin_1 (see
+     *note A.3.3::) includes the declaration of constants denoting
+     control characters, lower case characters, and special characters
+     of the predefined type Character.
+
+8.a
+          To be honest: The package ASCII does the same, but only for
+          the first 128 characters of Character.  Hence, it is an
+          obsolescent package, and we no longer mention it here.
+
+9/3
+     29  {AI05-0299-1AI05-0299-1} A conventional character set such as
+     EBCDIC can be declared as a character type; the internal codes of
+     the characters can be specified by an
+     enumeration_representation_clause as explained in subclause *note
+     13.4::.
+
+                              _Examples_
+
+10
+Example of a character type:
+
+11
+     type Roman_Digit is ('I', 'V', 'X', 'L', 'C', 'D', 'M');
+
+                     _Inconsistencies With Ada 83_
+
+11.a
+          The declaration of Wide_Character in package Standard hides
+          use-visible declarations with the same defining identifier.
+          In the unlikely event that an Ada 83 program had depended on
+          such a use-visible declaration, and the program remains legal
+          after the substitution of Standard.Wide_Character, the meaning
+          of the program will be different.
+
+                    _Incompatibilities With Ada 83_
+
+11.b
+          The presence of Wide_Character in package Standard means that
+          an expression such as
+
+11.c
+               'a' = 'b'
+
+11.d
+          is ambiguous in Ada 95, whereas in Ada 83 both literals could
+          be resolved to be of type Character.
+
+11.e
+          The change in visibility rules (see *note 4.2::) for character
+          literals means that additional qualification might be
+          necessary to resolve expressions involving overloaded
+          subprograms and character literals.
+
+                        _Extensions to Ada 83_
+
+11.f
+          The type Character has been extended to have 256 positions,
+          and the type Wide_Character has been added.  Note that this
+          change was already approved by the ARG for Ada 83 conforming
+          compilers.
+
+11.g
+          The rules for referencing character literals are changed (see
+          *note 4.2::), so that the declaration of the character type
+          need not be directly visible to use its literals, similar to
+          null and string literals.  Context is used to resolve their
+          type.
+
+                     _Inconsistencies With Ada 95_
+
+11.h/2
+          {AI95-00285-01AI95-00285-01} Ada 95 defined most characters in
+          Wide_Character to be graphic characters, while Ada 2005 uses
+          the categorizations from ISO-10646:2003.  It also provides
+          language-defined names for all nongraphic characters.  That
+          means that in Ada 2005, Wide_Character'Wide_Value will raise
+          Constraint_Error for a string representing a character_literal
+          of a nongraphic character, while Ada 95 would have accepted
+          it.  Similarly, the result of Wide_Character'Wide_Image will
+          change for such nongraphic characters.
+
+11.i/3
+          {AI95-00395-01AI95-00395-01} {AI05-0005-1AI05-0005-1}
+          {AI05-0262-1AI05-0262-1} The language-defined names FFFE and
+          FFFF were replaced by a consistent set of language-defined
+          names for all nongraphic characters with code points greater
+          than 16#FF#.  That means that in Ada 2005,
+          Wide_Character'Wide_Value("FFFE") will raise Constraint_Error
+          while Ada 95 would have accepted it.  Similarly, the result of
+          Wide_Character'Wide_Image will change for the position numbers
+          16#FFFE# and 16#FFFF#.  It is very unlikely that this will
+          matter in practice, as these names do not represent usable
+          characters.
+
+11.j/2
+          {AI95-00285-01AI95-00285-01} {AI95-00395-01AI95-00395-01}
+          Because of the previously mentioned changes to the
+          Wide_Character'Wide_Image of various character values, the
+          value of attribute Wide_Width will change for some subtypes of
+          Wide_Character.  However, the new language-defined names were
+          chosen so that the value of Wide_Character'Wide_Width itself
+          does not change.
+
+11.k/2
+          {AI95-00285-01AI95-00285-01} The declaration of
+          Wide_Wide_Character in package Standard hides use-visible
+          declarations with the same defining identifier.  In the (very)
+          unlikely event that an Ada 95 program had depended on such a
+          use-visible declaration, and the program remains legal after
+          the substitution of Standard.Wide_Wide_Character, the meaning
+          of the program will be different.
+
+                        _Extensions to Ada 95_
+
+11.l/2
+          {AI95-00285-01AI95-00285-01} The type Wide_Wide_Character is
+          new.
+
+                     _Wording Changes from Ada 95_
+
+11.m/2
+          {AI95-00285-01AI95-00285-01} Characters are now defined in
+          terms of the entire ISO/IEC 10646:2003 character set.
+
+11.n/3
+          {AI95-00285-01AI95-00285-01} {AI05-0248-1AI05-0248-1} We
+          dropped the Implementation Advice for nonstandard
+          interpretation of character sets; an implementation can do
+          what it wants in a nonstandard mode, so there isn't much point
+          to any advice.
+
+                    _Wording Changes from Ada 2005_
+
+11.o/3
+          {AI05-0181-1AI05-0181-1} Correction: Removed the position
+          numbers of nongraphic characters from the text, as it is wrong
+          and thus misleading.
+
+11.p/3
+          {AI05-0262-1AI05-0262-1} Changed "code position" to "code
+          point" consistently throughout the standard, as ISO/IEC
+          10646:2011 prefers "code point" and we are referring to the
+          definition in that Standard.  This change also reduces
+          confusion between "code point" and "position number"; while
+          these have the same values for the predefined character types,
+          there is no required relationship for other character types.
+
+
+File: aarm2012.info,  Node: 3.5.3,  Next: 3.5.4,  Prev: 3.5.2,  Up: 3.5
+
+3.5.3 Boolean Types
+-------------------
+
+                          _Static Semantics_
+
+1
+There is a predefined enumeration type named Boolean, [declared in the
+visible part of package Standard].  It has the two enumeration literals
+False and True ordered with the relation False < True.  Any descendant
+of the predefined type Boolean is called a boolean type.
+
+1.a
+          Implementation Note: An implementation is not required to
+          support enumeration representation clauses on boolean types
+          that impose an unacceptable implementation burden.  See *note
+          13.4::, "*note 13.4:: Enumeration Representation Clauses".
+          However, it is generally straightforward to support
+          representations where False is zero and True is 2**n - 1 for
+          some n.
+
+
+File: aarm2012.info,  Node: 3.5.4,  Next: 3.5.5,  Prev: 3.5.3,  Up: 3.5
+
+3.5.4 Integer Types
+-------------------
+
+1
+An integer_type_definition defines an integer type; it defines either a
+signed integer type, or a modular integer type.  The base range of a
+signed integer type includes at least the values of the specified range.
+A modular type is an integer type with all arithmetic modulo a specified
+positive modulus; such a type corresponds to an unsigned type with
+wrap-around semantics.  
+
+                               _Syntax_
+
+2
+     integer_type_definition ::= signed_integer_type_definition | 
+     modular_type_definition
+
+3
+     signed_integer_type_definition ::= range static_
+     simple_expression .. static_simple_expression
+
+3.a
+          Discussion: We don't call this a range_constraint, because it
+          is rather different -- not only is it required to be static,
+          but the associated overload resolution rules are different
+          than for normal range constraints.  A similar comment applies
+          to real_range_specification.  This used to be
+          integer_range_specification but when we added support for
+          modular types, it seemed overkill to have three levels of
+          syntax rules, and just calling these
+          signed_integer_range_specification and
+          modular_range_specification loses the fact that they are
+          defining different classes of types, which is important for
+          the generic type matching rules.
+
+4
+     modular_type_definition ::= mod static_expression
+
+                        _Name Resolution Rules_
+
+5
+Each simple_expression in a signed_integer_type_definition is expected
+to be of any integer type; they need not be of the same type.  The
+expression in a modular_type_definition is likewise expected to be of
+any integer type.
+
+                           _Legality Rules_
+
+6
+The simple_expressions of a signed_integer_type_definition shall be
+static, and their values shall be in the range System.Min_Int ..
+System.Max_Int.
+
+7
+The expression of a modular_type_definition shall be static, and its
+value (the modulus) shall be positive, and shall be no greater than
+System.Max_Binary_Modulus if a power of 2, or no greater than
+System.Max_Nonbinary_Modulus if not.
+
+7.a
+          Reason: For a 2's-complement machine, supporting nonbinary
+          moduli greater than System.Max_Int can be quite difficult,
+          whereas essentially any binary moduli are straightforward to
+          support, up to 2*System.Max_Int+2, so this justifies having
+          two separate limits.
+
+                          _Static Semantics_
+
+8
+The set of values for a signed integer type is the (infinite) set of
+mathematical integers[, though only values of the base range of the type
+are fully supported for run-time operations].  The set of values for a
+modular integer type are the values from 0 to one less than the modulus,
+inclusive.
+
+9
+A signed_integer_type_definition defines an integer type whose base
+range includes at least the values of the simple_expressions and is
+symmetric about zero, excepting possibly an extra negative value.  A
+signed_integer_type_definition also defines a constrained first subtype
+of the type, with a range whose bounds are given by the values of the
+simple_expressions, converted to the type being defined.
+
+9.a/2
+          Implementation Note: {AI95-00114-01AI95-00114-01} The base
+          range of a signed integer type might be much larger than is
+          necessary to satisfy the above requirements.
+
+9.a.1/1
+          To be honest: The conversion mentioned above is not an
+          implicit subtype conversion (which is something that happens
+          at overload resolution, see *note 4.6::), although it happens
+          implicitly.  Therefore, the freezing rules are not invoked on
+          the type (which is important so that representation items can
+          be given for the type).  
+
+10
+A modular_type_definition defines a modular type whose base range is
+from zero to one less than the given modulus.  A modular_type_definition
+also defines a constrained first subtype of the type with a range that
+is the same as the base range of the type.
+
+11
+There is a predefined signed integer subtype named Integer[, declared in
+the visible part of package Standard].  It is constrained to the base
+range of its type.
+
+11.a
+          Reason: Integer is a constrained subtype, rather than an
+          unconstrained subtype.  This means that on assignment to an
+          object of subtype Integer, a range check is required.  On the
+          other hand, an object of subtype Integer'Base is
+          unconstrained, and no range check (only overflow check) is
+          required on assignment.  For example, if the object is held in
+          an extended-length register, its value might be outside of
+          Integer'First ..  Integer'Last.  All parameter and result
+          subtypes of the predefined integer operators are of such
+          unconstrained subtypes, allowing extended-length registers to
+          be used as operands or for the result.  In an earlier version
+          of Ada 95, Integer was unconstrained.  However, the fact that
+          certain Constraint_Errors might be omitted or appear elsewhere
+          was felt to be an undesirable upward inconsistency in this
+          case.  Note that for Float, the opposite conclusion was
+          reached, partly because of the high cost of performing range
+          checks when not actually necessary.  Objects of subtype Float
+          are unconstrained, and no range checks, only overflow checks,
+          are performed for them.
+
+12
+Integer has two predefined subtypes, [declared in the visible part of
+package Standard:]
+
+13
+     subtype Natural  is Integer range 0 .. Integer'Last;
+     subtype Positive is Integer range 1 .. Integer'Last;
+
+14
+A type defined by an integer_type_definition is implicitly derived from
+root_integer, an anonymous predefined (specific) integer type, whose
+base range is System.Min_Int ..  System.Max_Int.  However, the base
+range of the new type is not inherited from root_integer, but is instead
+determined by the range or modulus specified by the
+integer_type_definition.  [Integer literals are all of the type
+universal_integer, the universal type (see *note 3.4.1::) for the class
+rooted at root_integer, allowing their use with the operations of any
+integer type.]
+
+14.a
+          Discussion: This implicit derivation is not considered exactly
+          equivalent to explicit derivation via a
+          derived_type_definition.  In particular, integer types defined
+          via a derived_type_definition inherit their base range from
+          their parent type.  A type defined by an
+          integer_type_definition does not necessarily inherit its base
+          range from root_integer.  It is not specified whether the
+          implicit derivation from root_integer is direct or indirect,
+          not that it really matters.  All we want is for all integer
+          types to be descendants of root_integer.
+
+14.a.1/1
+          {8652/00998652/0099} {AI95-00152-01AI95-00152-01} Note that
+          this derivation does not imply any inheritance of subprograms.
+          Subprograms are inherited only for types derived by a
+          derived_type_definition (*note 3.4: S0035.) (see *note 3.4::),
+          or a private_extension_declaration (*note 7.3: S0194.) (see
+          *note 7.3::, *note 7.3.1::, and *note 12.5.1::).
+
+14.b
+          Implementation Note: It is the intent that even nonstandard
+          integer types (see below) will be descendants of root_integer,
+          even though they might have a base range that exceeds that of
+          root_integer.  This causes no problem for static calculations,
+          which are performed without range restrictions (see *note
+          4.9::).  However for run-time calculations, it is possible
+          that Constraint_Error might be raised when using an operator
+          of root_integer on the result of 'Val applied to a value of a
+          nonstandard integer type.
+
+15
+The position number of an integer value is equal to the value.
+
+16/2
+{AI95-00340-01AI95-00340-01} For every modular subtype S, the following
+attributes are defined:
+
+16.1/2
+S'Mod
+               {AI95-00340-01AI95-00340-01} S'Mod denotes a function
+               with the following specification:
+
+16.2/2
+                    function S'Mod (Arg : universal_integer)
+                      return S'Base
+
+16.3/2
+               This function returns Arg mod S'Modulus, as a value of
+               the type of S.
+
+17
+S'Modulus
+               S'Modulus yields the modulus of the type of S, as a value
+               of the type universal_integer.
+
+                          _Dynamic Semantics_
+
+18
+The elaboration of an integer_type_definition creates the integer type
+and its first subtype.
+
+19
+For a modular type, if the result of the execution of a predefined
+operator (see *note 4.5::) is outside the base range of the type, the
+result is reduced modulo the modulus of the type to a value that is
+within the base range of the type.
+
+20
+For a signed integer type, the exception Constraint_Error is raised by
+the execution of an operation that cannot deliver the correct result
+because it is outside the base range of the type.  [ For any integer
+type, Constraint_Error is raised by the operators "/", "rem", and "mod"
+if the right operand is zero.]
+
+                     _Implementation Requirements_
+
+21
+In an implementation, the range of Integer shall include the range
+-2**15+1 ..  +2**15-1.
+
+22
+If Long_Integer is predefined for an implementation, then its range
+shall include the range -2**31+1 ..  +2**31-1.
+
+23
+System.Max_Binary_Modulus shall be at least 2**16.
+
+                     _Implementation Permissions_
+
+24
+For the execution of a predefined operation of a signed integer type,
+the implementation need not raise Constraint_Error if the result is
+outside the base range of the type, so long as the correct result is
+produced.
+
+24.a
+          Discussion: Constraint_Error is never raised for operations on
+          modular types, except for divide-by-zero (and
+          rem/mod-by-zero).
+
+25
+An implementation may provide additional predefined signed integer
+types[, declared in the visible part of Standard], whose first subtypes
+have names of the form Short_Integer, Long_Integer, Short_Short_Integer,
+Long_Long_Integer, etc.  Different predefined integer types are allowed
+to have the same base range.  However, the range of Integer should be no
+wider than that of Long_Integer.  Similarly, the range of Short_Integer
+(if provided) should be no wider than Integer.  Corresponding
+recommendations apply to any other predefined integer types.  There need
+not be a named integer type corresponding to each distinct base range
+supported by an implementation.  The range of each first subtype should
+be the base range of its type.
+
+25.a
+          Implementation defined: The predefined integer types declared
+          in Standard.
+
+26
+An implementation may provide nonstandard integer types, descendants of
+root_integer that are declared outside of the specification of package
+Standard, which need not have all the standard characteristics of a type
+defined by an integer_type_definition.  For example, a nonstandard
+integer type might have an asymmetric base range or it might not be
+allowed as an array or loop index (a very long integer).  Any type
+descended from a nonstandard integer type is also nonstandard.  An
+implementation may place arbitrary restrictions on the use of such
+types; it is implementation defined whether operators that are
+predefined for "any integer type" are defined for a particular
+nonstandard integer type.  [In any case, such types are not permitted as
+explicit_generic_actual_parameters for formal scalar types -- see *note
+12.5.2::.]
+
+26.a
+          Implementation defined: Any nonstandard integer types and the
+          operators defined for them.
+
+27
+For a one's complement machine, the high bound of the base range of a
+modular type whose modulus is one less than a power of 2 may be equal to
+the modulus, rather than one less than the modulus.  It is
+implementation defined for which powers of 2, if any, this permission is
+exercised.
+
+27.1/1
+{8652/00038652/0003} {AI95-00095-01AI95-00095-01} For a one's complement
+machine, implementations may support nonbinary modulus values greater
+than System.Max_Nonbinary_Modulus.  It is implementation defined which
+specific values greater than System.Max_Nonbinary_Modulus, if any, are
+supported.
+
+27.a.1/1
+          Reason: On a one's complement machine, the natural full word
+          type would have a modulus of 2**Word_Size-1.  However, we
+          would want to allow the all-ones bit pattern (which represents
+          negative zero as a number) in logical operations.  These
+          permissions are intended to allow that and the natural modulus
+          value without burdening implementations with supporting
+          expensive modulus values.
+
+                        _Implementation Advice_
+
+28
+An implementation should support Long_Integer in addition to Integer if
+the target machine supports 32-bit (or longer) arithmetic.  No other
+named integer subtypes are recommended for package Standard.  Instead,
+appropriate named integer subtypes should be provided in the library
+package Interfaces (see *note B.2::).
+
+28.a.1/2
+          Implementation Advice: Long_Integer should be declared in
+          Standard if the target supports 32-bit arithmetic.  No other
+          named integer subtypes should be declared in Standard.
+
+28.a
+          Implementation Note: To promote portability, implementations
+          should explicitly declare the integer (sub)types Integer and
+          Long_Integer in Standard, and leave other predefined integer
+          types anonymous.  For implementations that already support
+          Byte_Integer, etc., upward compatibility argues for keeping
+          such declarations in Standard during the transition period,
+          but perhaps generating a warning on use.  A separate package
+          Interfaces in the predefined environment is available for
+          pre-declaring types such as Integer_8, Integer_16, etc.  See
+          *note B.2::.  In any case, if the user declares a subtype
+          (first or not) whose range fits in, for example, a byte, the
+          implementation can store variables of the subtype in a single
+          byte, even if the base range of the type is wider.
+
+29
+An implementation for a two's complement machine should support modular
+types with a binary modulus up to System.Max_Int*2+2.  An implementation
+should support a nonbinary modulus up to Integer'Last.
+
+29.a.1/2
+          Implementation Advice: For a two's complement target, modular
+          types with a binary modulus up to System.Max_Int*2+2 should be
+          supported.  A nonbinary modulus up to Integer'Last should be
+          supported.
+
+29.a
+          Reason: Modular types provide bit-wise "and", "or", "xor", and
+          "not" operations.  It is important for systems programming
+          that these be available for all integer types of the target
+          hardware.
+
+29.b
+          Ramification: Note that on a one's complement machine, the
+          largest supported modular type would normally have a nonbinary
+          modulus.  On a two's complement machine, the largest supported
+          modular type would normally have a binary modulus.
+
+29.c
+          Implementation Note: Supporting a nonbinary modulus greater
+          than Integer'Last can impose an undesirable implementation
+          burden on some machines.
+
+     NOTES
+
+30
+     30  Integer literals are of the anonymous predefined integer type
+     universal_integer.  Other integer types have no literals.  However,
+     the overload resolution rules (see *note 8.6::, "*note 8.6:: The
+     Context of Overload Resolution") allow expressions of the type
+     universal_integer whenever an integer type is expected.
+
+31
+     31  The same arithmetic operators are predefined for all signed
+     integer types defined by a signed_integer_type_definition (see
+     *note 4.5::, "*note 4.5:: Operators and Expression Evaluation").
+     For modular types, these same operators are predefined, plus
+     bit-wise logical operators (and, or, xor, and not).  In addition,
+     for the unsigned types declared in the language-defined package
+     Interfaces (see *note B.2::), functions are defined that provide
+     bit-wise shifting and rotating.
+
+32
+     32  Modular types match a generic_formal_parameter_declaration of
+     the form "type T is mod <>;"; signed integer types match "type T is
+     range <>;" (see *note 12.5.2::).
+
+                              _Examples_
+
+33
+Examples of integer types and subtypes:
+
+34
+     type Page_Num  is range 1 .. 2_000;
+     type Line_Size is range 1 .. Max_Line_Size;
+
+35
+     subtype Small_Int   is Integer   range -10 .. 10;
+     subtype Column_Ptr  is Line_Size range 1 .. 10;
+     subtype Buffer_Size is Integer   range 0 .. Max;
+
+36
+     type Byte        is mod 256; -- an unsigned byte
+     type Hash_Index  is mod 97;  -- modulus is prime
+
+                        _Extensions to Ada 83_
+
+36.a
+          An implementation is allowed to support any number of distinct
+          base ranges for integer types, even if fewer integer types are
+          explicitly declared in Standard.
+
+36.b
+          Modular (unsigned, wrap-around) types are new.
+
+                     _Wording Changes from Ada 83_
+
+36.c
+          Ada 83's integer types are now called "signed" integer types,
+          to contrast them with "modular" integer types.
+
+36.d
+          Standard.Integer, Standard.Long_Integer, etc., denote
+          constrained subtypes of predefined integer types, consistent
+          with the Ada 95 model that only subtypes have names.
+
+36.e
+          We now impose minimum requirements on the base range of
+          Integer and Long_Integer.
+
+36.f
+          We no longer explain integer type definition in terms of an
+          equivalence to a normal type derivation, except to say that
+          all integer types are by definition implicitly derived from
+          root_integer.  This is for various reasons.
+
+36.g
+          First of all, the equivalence with a type derivation and a
+          subtype declaration was not perfect, and was the source of
+          various AIs (for example, is the conversion of the bounds
+          static?  Is a numeric type a derived type with respect to
+          other rules of the language?)
+
+36.h
+          Secondly, we don't want to require that every integer size
+          supported shall have a corresponding named type in Standard.
+          Adding named types to Standard creates nonportabilities.
+
+36.i
+          Thirdly, we don't want the set of types that match a formal
+          derived type "type T is new Integer;" to depend on the
+          particular underlying integer representation chosen to
+          implement a given user-defined integer type.  Hence, we would
+          have needed anonymous integer types as parent types for the
+          implicit derivation anyway.  We have simply chosen to identify
+          only one anonymous integer type -- root_integer, and stated
+          that every integer type is derived from it.
+
+36.j
+          Finally, the "fiction" that there were distinct preexisting
+          predefined types for every supported representation breaks
+          down for fixed point with arbitrary smalls, and was never
+          exploited for enumeration types, array types, etc.  Hence,
+          there seems little benefit to pushing an explicit equivalence
+          between integer type definition and normal type derivation.
+
+                        _Extensions to Ada 95_
+
+36.k/2
+          {AI95-00340-01AI95-00340-01} The Mod attribute is new.  It
+          eases mixing of signed and unsigned values in an expression,
+          which can be difficult as there may be no type which can
+          contain all of the values of both of the types involved.
+
+                     _Wording Changes from Ada 95_
+
+36.l/2
+          {8652/00038652/0003} {AI95-00095-01AI95-00095-01} Corrigendum:
+          Added additional permissions for modular types on one's
+          complement machines.
+
+
+File: aarm2012.info,  Node: 3.5.5,  Next: 3.5.6,  Prev: 3.5.4,  Up: 3.5
+
+3.5.5 Operations of Discrete Types
+----------------------------------
+
+                          _Static Semantics_
+
+1
+For every discrete subtype S, the following attributes are defined:
+
+2
+S'Pos
+               S'Pos denotes a function with the following
+               specification:
+
+3
+                    function S'Pos(Arg : S'Base)
+                      return universal_integer
+
+4
+               This function returns the position number of the value of
+               Arg, as a value of type universal_integer.
+
+5
+S'Val
+               S'Val denotes a function with the following
+               specification:
+
+6
+                    function S'Val(Arg : universal_integer)
+                      return S'Base
+
+7
+               This function returns a value of the type of S whose
+               position number equals the value of Arg.  For the
+               evaluation of a call on S'Val, if there is no value in
+               the base range of its type with the given position
+               number, Constraint_Error is raised.
+
+7.a
+          Ramification: By the overload resolution rules, a formal
+          parameter of type universal_integer allows an actual parameter
+          of any integer type.
+
+7.b
+          Reason: We considered allowing S'Val for a signed integer
+          subtype S to return an out-of-range value, but since checks
+          were required for enumeration and modular types anyway, the
+          allowance didn't seem worth the complexity of the rule.
+
+7.1/3
+{AI05-0297-1AI05-0297-1} For every static discrete subtype S for which
+there exists at least one value belonging to S that satisfies any
+predicate of S, the following attributes are defined:
+
+7.2/3
+S'First_Valid
+               {AI05-0297-1AI05-0297-1} S'First_Valid denotes the
+               smallest value that belongs to S and satisfies the
+               predicate of S. The value of this attribute is of the
+               type of S.
+
+7.3/3
+S'Last_Valid
+               {AI05-0297-1AI05-0297-1} S'Last_Valid denotes the largest
+               value that belongs to S and satisfies the predicate of S.
+               The value of this attribute is of the type of S.
+
+7.4/3
+{AI05-0297-1AI05-0297-1} [First_Valid and Last_Valid
+attribute_references are always static expressions.  Any explicit
+predicate of S can only have been specified by a Static_Predicate
+aspect.]
+
+7.c/3
+          Proof: An attribute_reference is static if the prefix is a
+          static subtype (see *note 4.9::), (true by definition) and any
+          arguments are static (there are none).  Similarly, a dynamic
+          predicate always makes a subtype nonstatic.  QED.
+
+7.d/3
+          Reason: We require there to be at least one value so that
+          these are always values of the subtype.  (This sidesteps the
+          question of what to return for a subtype with no values.)
+
+7.e/3
+          Discussion: These attributes are intended primarily for use in
+          the case where the Static_Predicate aspect of S has been
+          specified; First and Last are equivalent if these are allowed
+          and there is no predicate.
+
+                        _Implementation Advice_
+
+8
+For the evaluation of a call on S'Pos for an enumeration subtype, if the
+value of the operand does not correspond to the internal code for any
+enumeration literal of its type [(perhaps due to an uninitialized
+variable)], then the implementation should raise Program_Error.  This is
+particularly important for enumeration types with noncontiguous internal
+codes specified by an enumeration_representation_clause (*note 13.4:
+S0310.).
+
+8.a.1/2
+          Implementation Advice: Program_Error should be raised for the
+          evaluation of S'Pos for an enumeration type, if the value of
+          the operand does not correspond to the internal code for any
+          enumeration literal of the type.
+
+8.a
+          Reason: We say Program_Error here, rather than
+          Constraint_Error, because the main reason for such values is
+          uninitialized variables, and the normal way to indicate such a
+          use (if detected) is to raise Program_Error.  (Other reasons
+          would involve the misuse of low-level features such as
+          Unchecked_Conversion.)
+
+     NOTES
+
+9
+     33  Indexing and loop iteration use values of discrete types.
+
+10/3
+     34  {AI05-0299-1AI05-0299-1} The predefined operations of a
+     discrete type include the assignment operation, qualification, the
+     membership tests, and the relational operators; for a boolean type
+     they include the short-circuit control forms and the logical
+     operators; for an integer type they include type conversion to and
+     from other numeric types, as well as the binary and unary adding
+     operators - and +, the multiplying operators, the unary operator
+     abs, and the exponentiation operator.  The assignment operation is
+     described in *note 5.2::.  The other predefined operations are
+     described in Clause *note 4::.
+
+11
+     35  As for all types, objects of a discrete type have Size and
+     Address attributes (see *note 13.3::).
+
+12
+     36  For a subtype of a discrete type, the result delivered by the
+     attribute Val might not belong to the subtype; similarly, the
+     actual parameter of the attribute Pos need not belong to the
+     subtype.  The following relations are satisfied (in the absence of
+     an exception) by these attributes:
+
+13
+             S'Val(S'Pos(X)) = X
+             S'Pos(S'Val(N)) = N
+
+                              _Examples_
+
+14
+Examples of attributes of discrete subtypes:
+
+15
+     --  For the types and subtypes declared in subclause *note 3.5.1:: the 
following hold: 
+
+16
+     --  Color'First   = White,   Color'Last   = Black
+     --  Rainbow'First = Red,     Rainbow'Last = Blue
+
+17
+     --  Color'Succ(Blue) = Rainbow'Succ(Blue) = Brown
+     --  Color'Pos(Blue)  = Rainbow'Pos(Blue)  = 4
+     --  Color'Val(0)     = Rainbow'Val(0)     = White
+
+                        _Extensions to Ada 83_
+
+17.a
+          The attributes S'Succ, S'Pred, S'Width, S'Image, and S'Value
+          have been generalized to apply to real types as well (see
+          *note 3.5::, "*note 3.5:: Scalar Types").
+
+                       _Extensions to Ada 2005_
+
+17.b/3
+          {AI05-0297-1AI05-0297-1} The attributes S'First_Valid and
+          S'Last_Valid are new.
+
+
+File: aarm2012.info,  Node: 3.5.6,  Next: 3.5.7,  Prev: 3.5.5,  Up: 3.5
+
+3.5.6 Real Types
+----------------
+
+1
+Real types provide approximations to the real numbers, with relative
+bounds on errors for floating point types, and with absolute bounds for
+fixed point types.
+
+                               _Syntax_
+
+2
+     real_type_definition ::=
+        floating_point_definition | fixed_point_definition
+
+                          _Static Semantics_
+
+3
+A type defined by a real_type_definition is implicitly derived from
+root_real, an anonymous predefined (specific) real type.  [Hence, all
+real types, whether floating point or fixed point, are in the derivation
+class rooted at root_real.]
+
+3.a
+          Ramification: It is not specified whether the derivation from
+          root_real is direct or indirect, not that it really matters.
+          All we want is for all real types to be descendants of
+          root_real.
+
+3.a.1/1
+          {8652/00998652/0099} {AI95-00152-01AI95-00152-01} Note that
+          this derivation does not imply any inheritance of subprograms.
+          Subprograms are inherited only for types derived by a
+          derived_type_definition (*note 3.4: S0035.) (see *note 3.4::),
+          or a private_extension_declaration (*note 7.3: S0194.) (see
+          *note 7.3::, *note 7.3.1::, and *note 12.5.1::).
+
+4
+[ Real literals are all of the type universal_real, the universal type
+(see *note 3.4.1::) for the class rooted at root_real, allowing their
+use with the operations of any real type.  Certain multiplying operators
+have a result type of universal_fixed (see *note 4.5.5::), the universal
+type for the class of fixed point types, allowing the result of the
+multiplication or division to be used where any specific fixed point
+type is expected.]
+
+                          _Dynamic Semantics_
+
+5
+The elaboration of a real_type_definition consists of the elaboration of
+the floating_point_definition or the fixed_point_definition.
+
+                     _Implementation Requirements_
+
+6
+An implementation shall perform the run-time evaluation of a use of a
+predefined operator of root_real with an accuracy at least as great as
+that of any floating point type definable by a
+floating_point_definition.
+
+6.a
+          Ramification: Static calculations using the operators of
+          root_real are exact, as for all static calculations.  See
+          *note 4.9::.
+
+6.b
+          Implementation Note: The Digits attribute of the type used to
+          represent root_real at run time is at least as great as that
+          of any other floating point type defined by a
+          floating_point_definition, and its safe range includes that of
+          any such floating point type with the same Digits attribute.
+          On some machines, there might be real types with less accuracy
+          but a wider range, and hence run-time calculations with
+          root_real might not be able to accommodate all values that can
+          be represented at run time in such floating point or fixed
+          point types.
+
+                     _Implementation Permissions_
+
+7/2
+{AI95-00114-01AI95-00114-01} [For the execution of a predefined
+operation of a real type, the implementation need not raise
+Constraint_Error if the result is outside the base range of the type, so
+long as the correct result is produced, or the Machine_Overflows
+attribute of the type is False (see *note G.2::).]
+
+8
+An implementation may provide nonstandard real types, descendants of
+root_real that are declared outside of the specification of package
+Standard, which need not have all the standard characteristics of a type
+defined by a real_type_definition.  For example, a nonstandard real type
+might have an asymmetric or unsigned base range, or its predefined
+operations might wrap around or "saturate" rather than overflow (modular
+or saturating arithmetic), or it might not conform to the accuracy model
+(see *note G.2::).  Any type descended from a nonstandard real type is
+also nonstandard.  An implementation may place arbitrary restrictions on
+the use of such types; it is implementation defined whether operators
+that are predefined for "any real type" are defined for a particular
+nonstandard real type.  [In any case, such types are not permitted as
+explicit_generic_actual_parameters for formal scalar types -- see *note
+12.5.2::.]
+
+8.a
+          Implementation defined: Any nonstandard real types and the
+          operators defined for them.
+
+     NOTES
+
+9
+     37  As stated, real literals are of the anonymous predefined real
+     type universal_real.  Other real types have no literals.  However,
+     the overload resolution rules (see *note 8.6::) allow expressions
+     of the type universal_real whenever a real type is expected.
+
+                     _Wording Changes from Ada 83_
+
+9.a
+          The syntax rule for real_type_definition is modified to use
+          the new syntactic categories floating_point_definition and
+          fixed_point_definition, instead of floating_point_constraint
+          and fixed_point_constraint, because the semantics of a type
+          definition are significantly different than the semantics of a
+          constraint.
+
+9.b
+          All discussion of model numbers, safe ranges, and machine
+          numbers is moved to *note 3.5.7::, *note 3.5.8::, and *note
+          G.2::.  Values of a fixed point type are now described as
+          being multiples of the small of the fixed point type, and we
+          have no need for model numbers, safe ranges, etc.  for fixed
+          point types.
+
+
+File: aarm2012.info,  Node: 3.5.7,  Next: 3.5.8,  Prev: 3.5.6,  Up: 3.5
+
+3.5.7 Floating Point Types
+--------------------------
+
+1
+For floating point types, the error bound is specified as a relative
+precision by giving the required minimum number of significant decimal
+digits.
+
+                               _Syntax_
+
+2
+     floating_point_definition ::=
+       digits static_expression [real_range_specification]
+
+3
+     real_range_specification ::=
+       range static_simple_expression .. static_simple_expression
+
+                        _Name Resolution Rules_
+
+4
+The requested decimal precision, which is the minimum number of
+significant decimal digits required for the floating point type, is
+specified by the value of the expression given after the reserved word
+digits.  This expression is expected to be of any integer type.
+
+5
+Each simple_expression of a real_range_specification is expected to be
+of any real type[; the types need not be the same].
+
+                           _Legality Rules_
+
+6
+The requested decimal precision shall be specified by a static
+expression whose value is positive and no greater than
+System.Max_Base_Digits.  Each simple_expression of a
+real_range_specification shall also be static.  If the
+real_range_specification is omitted, the requested decimal precision
+shall be no greater than System.Max_Digits.
+
+6.a
+          Reason: We have added Max_Base_Digits to package System.  It
+          corresponds to the requested decimal precision of root_real.
+          System.Max_Digits corresponds to the maximum value for Digits
+          that may be specified in the absence of a
+          real_range_specification, for upward compatibility.  These
+          might not be the same if root_real has a base range that does
+          not include � 10.0**(4*Max_Base_Digits).
+
+7
+A floating_point_definition is illegal if the implementation does not
+support a floating point type that satisfies the requested decimal
+precision and range.
+
+7.a
+          Implementation defined: What combinations of requested decimal
+          precision and range are supported for floating point types.
+
+                          _Static Semantics_
+
+8
+The set of values for a floating point type is the (infinite) set of
+rational numbers.  The machine numbers of a floating point type are the
+values of the type that can be represented exactly in every
+unconstrained variable of the type.  The base range (see *note 3.5::) of
+a floating point type is symmetric around zero, except that it can
+include some extra negative values in some implementations.
+
+8.a
+          Implementation Note: For example, if a 2's complement
+          representation is used for the mantissa rather than a
+          sign-mantissa or 1's complement representation, then there is
+          usually one extra negative machine number.
+
+8.b
+          To be honest: If the Signed_Zeros attribute is True, then
+          minus zero could in a sense be considered a value of the type.
+          However, for most purposes, minus zero behaves the same as
+          plus zero.
+
+9
+The base decimal precision of a floating point type is the number of
+decimal digits of precision representable in objects of the type.  The
+safe range of a floating point type is that part of its base range for
+which the accuracy corresponding to the base decimal precision is
+preserved by all predefined operations.
+
+9.a
+          Implementation Note: In most cases, the safe range and base
+          range are the same.  However, for some hardware, values near
+          the boundaries of the base range might result in excessive
+          inaccuracies or spurious overflows when used with certain
+          predefined operations.  For such hardware, the safe range
+          would omit such values.
+
+10
+A floating_point_definition defines a floating point type whose base
+decimal precision is no less than the requested decimal precision.  If a
+real_range_specification is given, the safe range of the floating point
+type (and hence, also its base range) includes at least the values of
+the simple expressions given in the real_range_specification.  If a
+real_range_specification is not given, the safe (and base) range of the
+type includes at least the values of the range -10.0**(4*D) ..
++10.0**(4*D) where D is the requested decimal precision.  [The safe
+range might include other values as well.  The attributes Safe_First and
+Safe_Last give the actual bounds of the safe range.]
+
+11
+A floating_point_definition also defines a first subtype of the type.  
+If a real_range_specification is given, then the subtype is constrained
+to a range whose bounds are given by a conversion of the values of the
+simple_expressions of the real_range_specification to the type being
+defined.  Otherwise, the subtype is unconstrained.
+
+11.a.1/1
+          To be honest: The conversion mentioned above is not an
+          implicit subtype conversion (which is something that happens
+          at overload resolution, see *note 4.6::), although it happens
+          implicitly.  Therefore, the freezing rules are not invoked on
+          the type (which is important so that representation items can
+          be given for the type).  
+
+12
+There is a predefined, unconstrained, floating point subtype named
+Float[, declared in the visible part of package Standard].
+
+                          _Dynamic Semantics_
+
+13
+[The elaboration of a floating_point_definition creates the floating
+point type and its first subtype.]
+
+                     _Implementation Requirements_
+
+14
+In an implementation that supports floating point types with 6 or more
+digits of precision, the requested decimal precision for Float shall be
+at least 6.
+
+15
+If Long_Float is predefined for an implementation, then its requested
+decimal precision shall be at least 11.
+
+                     _Implementation Permissions_
+
+16
+An implementation is allowed to provide additional predefined floating
+point types[, declared in the visible part of Standard], whose
+(unconstrained) first subtypes have names of the form Short_Float,
+Long_Float, Short_Short_Float, Long_Long_Float, etc.  Different
+predefined floating point types are allowed to have the same base
+decimal precision.  However, the precision of Float should be no greater
+than that of Long_Float.  Similarly, the precision of Short_Float (if
+provided) should be no greater than Float.  Corresponding
+recommendations apply to any other predefined floating point types.
+There need not be a named floating point type corresponding to each
+distinct base decimal precision supported by an implementation.
+
+16.a
+          Implementation defined: The predefined floating point types
+          declared in Standard.
+
+                        _Implementation Advice_
+
+17
+An implementation should support Long_Float in addition to Float if the
+target machine supports 11 or more digits of precision.  No other named
+floating point subtypes are recommended for package Standard.  Instead,
+appropriate named floating point subtypes should be provided in the
+library package Interfaces (see *note B.2::).
+
+17.a.1/2
+          Implementation Advice: Long_Float should be declared in
+          Standard if the target supports 11 or more digits of
+          precision.  No other named float subtypes should be declared
+          in Standard.
+
+17.a
+          Implementation Note: To promote portability, implementations
+          should explicitly declare the floating point (sub)types Float
+          and Long_Float in Standard, and leave other predefined float
+          types anonymous.  For implementations that already support
+          Short_Float, etc., upward compatibility argues for keeping
+          such declarations in Standard during the transition period,
+          but perhaps generating a warning on use.  A separate package
+          Interfaces in the predefined environment is available for
+          pre-declaring types such as Float_32, IEEE_Float_64, etc.  See
+          *note B.2::.
+
+     NOTES
+
+18
+     38  If a floating point subtype is unconstrained, then assignments
+     to variables of the subtype involve only Overflow_Checks, never
+     Range_Checks.
+
+                              _Examples_
+
+19
+Examples of floating point types and subtypes:
+
+20
+     type Coefficient is digits 10 range -1.0 .. 1.0;
+
+21
+     type Real is digits 8;
+     type Mass is digits 7 range 0.0 .. 1.0E35;
+
+22
+     subtype Probability is Real range 0.0 .. 1.0;   --   a subtype with a 
smaller range
+
+                     _Inconsistencies With Ada 83_
+
+22.a
+          No Range_Checks, only Overflow_Checks, are performed on
+          variables (or parameters) of an unconstrained floating point
+          subtype.  This is upward compatible for programs that do not
+          raise Constraint_Error.  For those that do raise
+          Constraint_Error, it is possible that the exception will be
+          raised at a later point, or not at all, if extended range
+          floating point registers are used to hold the value of the
+          variable (or parameter).
+
+22.b
+          Reason: This change was felt to be justified by the
+          possibility of improved performance on machines with
+          extended-range floating point registers.  An implementation
+          need not take advantage of this relaxation in the range
+          checking; it can hide completely the use of extended range
+          registers if desired, presumably at some run-time expense.
+
+                     _Wording Changes from Ada 83_
+
+22.c
+          The syntax rules for floating_point_constraint and
+          floating_accuracy_definition are removed.  The syntax rules
+          for floating_point_definition and real_range_specification are
+          new.
+
+22.d
+          A syntax rule for digits_constraint is given in *note 3.5.9::,
+          "*note 3.5.9:: Fixed Point Types".  In *note J.3:: we indicate
+          that a digits_constraint may be applied to a floating point
+          subtype_mark as well (to be compatible with Ada 83's
+          floating_point_constraint).
+
+22.e
+          Discussion of model numbers is postponed to *note 3.5.8:: and
+          *note G.2::.  The concept of safe numbers has been replaced by
+          the concept of the safe range of values.  The bounds of the
+          safe range are given by T'Safe_First ..  T'Safe_Last, rather
+          than -T'Safe_Large ..  T'Safe_Large, since on some machines
+          the safe range is not perfectly symmetric.  The concept of
+          machine numbers is new, and is relevant to the definition of
+          Succ and Pred for floating point numbers.
+
+
+File: aarm2012.info,  Node: 3.5.8,  Next: 3.5.9,  Prev: 3.5.7,  Up: 3.5
+
+3.5.8 Operations of Floating Point Types
+----------------------------------------
+
+                          _Static Semantics_
+
+1
+The following attribute is defined for every floating point subtype S:
+
+2/1
+S'Digits
+               {8652/00048652/0004} {AI95-00203-01AI95-00203-01}
+               S'Digits denotes the requested decimal precision for the
+               subtype S. The value of this attribute is of the type
+               universal_integer.  The requested decimal precision of
+               the base subtype of a floating point type T is defined to
+               be the largest value of d for which
+               ceiling(d * log(10) / log(T'Machine_Radix)) + g <=
+               T'Model_Mantissa
+               where g is 0 if Machine_Radix is a positive power of 10
+               and 1 otherwise.
+
+     NOTES
+
+3
+     39  The predefined operations of a floating point type include the
+     assignment operation, qualification, the membership tests, and
+     explicit conversion to and from other numeric types.  They also
+     include the relational operators and the following predefined
+     arithmetic operators: the binary and unary adding operators - and
+     +, certain multiplying operators, the unary operator abs, and the
+     exponentiation operator.
+
+4
+     40  As for all types, objects of a floating point type have Size
+     and Address attributes (see *note 13.3::).  Other attributes of
+     floating point types are defined in *note A.5.3::.
+
+                     _Wording Changes from Ada 95_
+
+4.a/2
+          {8652/00048652/0004} {AI95-00203-01AI95-00203-01} Corrigendum:
+          Corrected the formula for Digits when the Machine_Radix is 10.
+
+
+File: aarm2012.info,  Node: 3.5.9,  Next: 3.5.10,  Prev: 3.5.8,  Up: 3.5
+
+3.5.9 Fixed Point Types
+-----------------------
+
+1
+A fixed point type is either an ordinary fixed point type, or a decimal
+fixed point type.  The error bound of a fixed point type is specified as
+an absolute value, called the delta of the fixed point type.
+
+                               _Syntax_
+
+2
+     fixed_point_definition ::= ordinary_fixed_point_definition | 
+     decimal_fixed_point_definition
+
+3
+     ordinary_fixed_point_definition ::=
+        delta static_expression  real_range_specification
+
+4
+     decimal_fixed_point_definition ::=
+        delta static_expression digits static_expression [
+     real_range_specification]
+
+5
+     digits_constraint ::=
+        digits static_expression [range_constraint]
+
+                        _Name Resolution Rules_
+
+6
+For a type defined by a fixed_point_definition, the delta of the type is
+specified by the value of the expression given after the reserved word
+delta; this expression is expected to be of any real type.  For a type
+defined by a decimal_fixed_point_definition (a decimal fixed point
+type), the number of significant decimal digits for its first subtype
+(the digits of the first subtype) is specified by the expression given
+after the reserved word digits; this expression is expected to be of any
+integer type.
+
+                           _Legality Rules_
+
+7
+In a fixed_point_definition or digits_constraint, the expressions given
+after the reserved words delta and digits shall be static; their values
+shall be positive.
+
+8/2
+{AI95-00100-01AI95-00100-01} The set of values of a fixed point type
+comprise the integral multiples of a number called the small of the
+type.  The machine numbers of a fixed point type are the values of the
+type that can be represented exactly in every unconstrained variable of
+the type.  For a type defined by an ordinary_fixed_point_definition (an
+ordinary fixed point type), the small may be specified by an
+attribute_definition_clause (*note 13.3: S0309.) (see *note 13.3::); if
+so specified, it shall be no greater than the delta of the type.  If not
+specified, the small of an ordinary fixed point type is an
+implementation-defined power of two less than or equal to the delta.
+
+8.a
+          Implementation defined: The small of an ordinary fixed point
+          type.
+
+9
+For a decimal fixed point type, the small equals the delta; the delta
+shall be a power of 10.  If a real_range_specification is given, both
+bounds of the range shall be in the range -(10**digits-1)*delta ..
++(10**digits-1)*delta.
+
+10
+A fixed_point_definition is illegal if the implementation does not
+support a fixed point type with the given small and specified range or
+digits.
+
+10.a
+          Implementation defined: What combinations of small, range, and
+          digits are supported for fixed point types.
+
+11
+For a subtype_indication with a digits_constraint, the subtype_mark
+shall denote a decimal fixed point subtype.
+
+11.a
+          To be honest: Or, as an obsolescent feature, a floating point
+          subtype is permitted -- see *note J.3::.
+
+                          _Static Semantics_
+
+12
+The base range (see *note 3.5::) of a fixed point type is symmetric
+around zero, except possibly for an extra negative value in some
+implementations.
+
+13
+An ordinary_fixed_point_definition defines an ordinary fixed point type
+whose base range includes at least all multiples of small that are
+between the bounds specified in the real_range_specification.  The base
+range of the type does not necessarily include the specified bounds
+themselves.  An ordinary_fixed_point_definition (*note 3.5.9: S0048.)
+also defines a constrained first subtype of the type, with each bound of
+its range given by the closer to zero of:
+
+14
+   * the value of the conversion to the fixed point type of the
+     corresponding expression of the real_range_specification; 
+
+14.a.1/1
+          To be honest: The conversion mentioned above is not an
+          implicit subtype conversion (which is something that happens
+          at overload resolution, see *note 4.6::), although it happens
+          implicitly.  Therefore, the freezing rules are not invoked on
+          the type (which is important so that representation items can
+          be given for the type).  
+
+15
+   * the corresponding bound of the base range.
+
+16
+A decimal_fixed_point_definition defines a decimal fixed point type
+whose base range includes at least the range -(10**digits-1)*delta ..
++(10**digits-1)*delta.  A decimal_fixed_point_definition also defines a
+constrained first subtype of the type.  If a real_range_specification is
+given, the bounds of the first subtype are given by a conversion of the
+values of the expressions of the real_range_specification.  Otherwise,
+the range of the first subtype is -(10**digits-1)*delta ..
++(10**digits-1)*delta.
+
+16.a.1/1
+          To be honest: The conversion mentioned above is not an
+          implicit subtype conversion (which is something that happens
+          at overload resolution, see *note 4.6::), although it happens
+          implicitly.  Therefore, the freezing rules are not invoked on
+          the type (which is important so that representation items can
+          be given for the type).  
+
+                          _Dynamic Semantics_
+
+17
+The elaboration of a fixed_point_definition creates the fixed point type
+and its first subtype.
+
+18
+For a digits_constraint on a decimal fixed point subtype with a given
+delta, if it does not have a range_constraint, then it specifies an
+implicit range -(10**D-1)*delta ..  +(10**D-1)*delta, where D is the
+value of the expression.  A digits_constraint is compatible with a
+decimal fixed point subtype if the value of the expression is no greater
+than the digits of the subtype, and if it specifies (explicitly or
+implicitly) a range that is compatible with the subtype.
+
+18.a
+          Discussion: Except for the requirement that the digits
+          specified be no greater than the digits of the subtype being
+          constrained, a digits_constraint is essentially equivalent to
+          a range_constraint.
+
+18.b
+          Consider the following example:
+
+18.c
+               type D is delta 0.01 digits 7 range -0.00 .. 9999.99;
+
+18.d/1
+          The compatibility rule implies that the digits_constraint
+          "digits 6" specifies an implicit range of "-9999.99 ..
+          9999.99".  Thus, "digits 6" is not compatible with the
+          constraint of D, but "digits 6 range 0.00 ..  9999.99" is
+          compatible.
+
+18.e/2
+          {AI95-00114-01AI95-00114-01} A value of a scalar type belongs
+          to a constrained subtype of the type if it belongs to the
+          range of the subtype.  Attributes like Digits and Delta have
+          no effect on this fundamental rule.  So the obsolescent forms
+          of digits_constraints and delta_constraints that are called
+          "accuracy constraints" in RM83 don't really represent
+          constraints on the values of the subtype, but rather primarily
+          affect compatibility of the "constraint" with the subtype
+          being "constrained."  In this sense, they might better be
+          called "subtype assertions" rather than "constraints."
+
+18.f
+          Note that the digits_constraint on a decimal fixed point
+          subtype is a combination of an assertion about the digits of
+          the subtype being further constrained, and a constraint on the
+          range of the subtype being defined, either explicit or
+          implicit.
+
+19
+The elaboration of a digits_constraint consists of the elaboration of
+the range_constraint, if any.  If a range_constraint is given, a check
+is made that the bounds of the range are both in the range
+-(10**D-1)*delta ..  +(10**D-1)*delta, where D is the value of the
+(static) expression given after the reserved word digits.  If this check
+fails, Constraint_Error is raised.
+
+                     _Implementation Requirements_
+
+20
+The implementation shall support at least 24 bits of precision
+(including the sign bit) for fixed point types.
+
+20.a
+          Reason: This is sufficient to represent Standard.Duration with
+          a small no more than 50 milliseconds.
+
+                     _Implementation Permissions_
+
+21
+Implementations are permitted to support only smalls that are a power of
+two.  In particular, all decimal fixed point type declarations can be
+disallowed.  Note however that conformance with the Information Systems
+Annex requires support for decimal smalls, and decimal fixed point type
+declarations with digits up to at least 18.
+
+21.a
+          Implementation Note: The accuracy requirements for
+          multiplication, division, and conversion (see *note G.2.1::,
+          "*note G.2.1:: Model of Floating Point Arithmetic") are such
+          that support for arbitrary smalls should be practical without
+          undue implementation effort.  Therefore, implementations
+          should support fixed point types with arbitrary values for
+          small (within reason).  One reasonable limitation would be to
+          limit support to fixed point types that can be converted to
+          the most precise floating point type without loss of precision
+          (so that Fixed_IO is implementable in terms of Float_IO).
+
+     NOTES
+
+22
+     41  The base range of an ordinary fixed point type need not include
+     the specified bounds themselves so that the range specification can
+     be given in a natural way, such as:
+
+23
+             type Fraction is delta 2.0**(-15) range -1.0 .. 1.0;
+  
+
+24
+     With 2's complement hardware, such a type could have a signed
+     16-bit representation, using 1 bit for the sign and 15 bits for
+     fraction, resulting in a base range of -1.0 ..  1.0-2.0**(-15).
+
+                              _Examples_
+
+25
+Examples of fixed point types and subtypes:
+
+26
+     type Volt is delta 0.125 range 0.0 .. 255.0;
+
+27
+       -- A pure fraction which requires all the available
+       -- space in a word can be declared as the type Fraction:
+     type Fraction is delta System.Fine_Delta range -1.0 .. 1.0;
+       -- Fraction'Last = 1.0 - System.Fine_Delta
+
+28
+     type Money is delta 0.01 digits 15;  -- decimal fixed point
+     subtype Salary is Money digits 10;
+       -- Money'Last = 10.0**13 - 0.01, Salary'Last = 10.0**8 - 0.01
+
+                     _Inconsistencies With Ada 83_
+
+28.a
+          In Ada 95, S'Small always equals S'Base'Small, so if an
+          implementation chooses a small for a fixed point type smaller
+          than required by the delta, the value of S'Small in Ada 95
+          might not be the same as it was in Ada 83.
+
+                        _Extensions to Ada 83_
+
+28.b/3
+          {AI05-0005-1AI05-0005-1} Decimal fixed point types are new,
+          though their capabilities are essentially similar to that
+          available in Ada 83 with a fixed point type whose small equals
+          its delta and both are a power of 10.  However, in the
+          Information Systems Annex, additional requirements are placed
+          on the support of decimal fixed point types (e.g.  a minimum
+          of 18 digits of precision).
+
+                     _Wording Changes from Ada 83_
+
+28.c
+          The syntax rules for fixed_point_constraint and
+          fixed_accuracy_definition are removed.  The syntax rule for
+          fixed_point_definition is new.  A syntax rule for
+          delta_constraint is included in the Obsolescent features (to
+          be compatible with Ada 83's fixed_point_constraint).
+
+                     _Wording Changes from Ada 95_
+
+28.d/2
+          {AI95-00100-01AI95-00100-01} Added wording to define the
+          machine numbers of fixed point types; this is needed by the
+          static evaluation rules.
+
+
+File: aarm2012.info,  Node: 3.5.10,  Prev: 3.5.9,  Up: 3.5
+
+3.5.10 Operations of Fixed Point Types
+--------------------------------------
+
+                          _Static Semantics_
+
+1
+The following attributes are defined for every fixed point subtype S:
+
+2/1
+S'Small
+               {8652/00058652/0005} {AI95-00054-01AI95-00054-01} S'Small
+               denotes the small of the type of S. The value of this
+               attribute is of the type universal_real.  Small may be
+               specified for nonderived ordinary fixed point types via
+               an attribute_definition_clause (*note 13.3: S0309.) (see
+               *note 13.3::); the expression of such a clause shall be
+               static.
+
+2.a/3
+          Aspect Description for Small: Scale factor for a fixed point
+          type.
+
+3
+S'Delta
+               S'Delta denotes the delta of the fixed point subtype S.
+               The value of this attribute is of the type
+               universal_real.
+
+3.a
+          Reason: The delta is associated with the subtype as opposed to
+          the type, because of the possibility of an (obsolescent)
+          delta_constraint.
+
+4
+S'Fore
+               S'Fore yields the minimum number of characters needed
+               before the decimal point for the decimal representation
+               of any value of the subtype S, assuming that the
+               representation does not include an exponent, but includes
+               a one-character prefix that is either a minus sign or a
+               space.  (This minimum number does not include superfluous
+               zeros or underlines, and is at least 2.)  The value of
+               this attribute is of the type universal_integer.
+
+5
+S'Aft
+               S'Aft yields the number of decimal digits needed after
+               the decimal point to accommodate the delta of the subtype
+               S, unless the delta of the subtype S is greater than 0.1,
+               in which case the attribute yields the value one.
+               [(S'Aft is the smallest positive integer N for which
+               (10**N)*S'Delta is greater than or equal to one.)]  The
+               value of this attribute is of the type universal_integer.
+
+6
+The following additional attributes are defined for every decimal fixed
+point subtype S:
+
+7
+S'Digits
+               S'Digits denotes the digits of the decimal fixed point
+               subtype S, which corresponds to the number of decimal
+               digits that are representable in objects of the subtype.
+               The value of this attribute is of the type
+               universal_integer.  Its value is determined as follows: 
+
+8
+                  * For a first subtype or a subtype defined by a
+                    subtype_indication with a digits_constraint, the
+                    digits is the value of the expression given after
+                    the reserved word digits;
+
+9
+                  * For a subtype defined by a subtype_indication
+                    without a digits_constraint, the digits of the
+                    subtype is the same as that of the subtype denoted
+                    by the subtype_mark in the subtype_indication.
+
+9.a
+          Implementation Note: Although a decimal subtype can be both
+          range-constrained and digits-constrained, the digits
+          constraint is intended to control the Size attribute of the
+          subtype.  For decimal types, Size can be important because
+          input/output of decimal types is so common.
+
+10
+                  * The digits of a base subtype is the largest integer
+                    D such that the range -(10**D-1)*delta ..
+                    +(10**D-1)*delta is included in the base range of
+                    the type.
+
+11
+S'Scale
+               S'Scale denotes the scale of the subtype S, defined as
+               the value N such that S'Delta = 10.0**(-N). [The scale
+               indicates the position of the point relative to the
+               rightmost significant digits of values of subtype S.] The
+               value of this attribute is of the type universal_integer.
+
+11.a
+          Ramification: S'Scale is negative if S'Delta is greater than
+          one.  By contrast, S'Aft is always positive.
+
+12
+S'Round
+               S'Round denotes a function with the following
+               specification:
+
+13
+                    function S'Round(X : universal_real)
+                      return S'Base
+
+14
+               The function returns the value obtained by rounding X
+               (away from 0, if X is midway between two values of the
+               type of S).
+
+     NOTES
+
+15
+     42  All subtypes of a fixed point type will have the same value for
+     the Delta attribute, in the absence of delta_constraints (see *note
+     J.3::).
+
+16
+     43  S'Scale is not always the same as S'Aft for a decimal subtype;
+     for example, if S'Delta = 1.0 then S'Aft is 1 while S'Scale is 0.
+
+17
+     44  The predefined operations of a fixed point type include the
+     assignment operation, qualification, the membership tests, and
+     explicit conversion to and from other numeric types.  They also
+     include the relational operators and the following predefined
+     arithmetic operators: the binary and unary adding operators - and
+     +, multiplying operators, and the unary operator abs.
+
+18
+     45  As for all types, objects of a fixed point type have Size and
+     Address attributes (see *note 13.3::).  Other attributes of fixed
+     point types are defined in *note A.5.4::.
+
+                     _Wording Changes from Ada 95_
+
+18.a/2
+          {8652/00058652/0005} {AI95-00054-01AI95-00054-01} Corrigendum:
+          Clarified that small may be specified only for ordinary fixed
+          point types.
+
+
+File: aarm2012.info,  Node: 3.6,  Next: 3.7,  Prev: 3.5,  Up: 3
+
+3.6 Array Types
+===============
+
+1
+An array object is a composite object consisting of components which all
+have the same subtype.  The name for a component of an array uses one or
+more index values belonging to specified discrete types.  The value of
+an array object is a composite value consisting of the values of the
+components.
+
+                               _Syntax_
+
+2
+     array_type_definition ::=
+        unconstrained_array_definition | constrained_array_definition
+
+3
+     unconstrained_array_definition ::=
+        array(index_subtype_definition {, index_subtype_definition}) of 
+     component_definition
+
+4
+     index_subtype_definition ::= subtype_mark range <>
+
+5
+     constrained_array_definition ::=
+        array (discrete_subtype_definition {, 
+     discrete_subtype_definition}) of component_definition
+
+6
+     discrete_subtype_definition ::= discrete_subtype_indication | range
+
+7/2
+     {AI95-00230-01AI95-00230-01} {AI95-00406-01AI95-00406-01}
+     component_definition ::=
+        [aliased] subtype_indication
+      | [aliased] access_definition
+
+                        _Name Resolution Rules_
+
+8
+For a discrete_subtype_definition that is a range, the range shall
+resolve to be of some specific discrete type[; which discrete type shall
+be determined without using any context other than the bounds of the
+range itself (plus the preference for root_integer -- see *note 8.6::).]
+
+                           _Legality Rules_
+
+9
+Each index_subtype_definition or discrete_subtype_definition in an
+array_type_definition defines an index subtype; its type (the index
+type) shall be discrete.
+
+9.a
+          Discussion: An index is a discrete quantity used to select
+          along a given dimension of an array.  A component is selected
+          by specifying corresponding values for each of the indices.
+
+10
+The subtype defined by the subtype_indication of a component_definition
+(the component subtype) shall be a definite subtype.
+
+10.a
+          Ramification: This applies to all uses of
+          component_definition, including in record_type_definitions and
+          protected_definitions.
+
+11/2
+This paragraph was deleted.{AI95-00363-01AI95-00363-01}
+
+                          _Static Semantics_
+
+12
+An array is characterized by the number of indices (the dimensionality
+of the array), the type and position of each index, the lower and upper
+bounds for each index, and the subtype of the components.  The order of
+the indices is significant.
+
+13
+A one-dimensional array has a distinct component for each possible index
+value.  A multidimensional array has a distinct component for each
+possible sequence of index values that can be formed by selecting one
+value for each index position (in the given order).  The possible values
+for a given index are all the values between the lower and upper bounds,
+inclusive; this range of values is called the index range.  The bounds
+of an array are the bounds of its index ranges.  The length of a
+dimension of an array is the number of values of the index range of the
+dimension (zero for a null range).  The length of a one-dimensional
+array is the length of its only dimension.
+
+14
+An array_type_definition defines an array type and its first subtype.
+For each object of this array type, the number of indices, the type and
+position of each index, and the subtype of the components are as in the
+type definition[; the values of the lower and upper bounds for each
+index belong to the corresponding index subtype of its type, except for
+null arrays (see *note 3.6.1::)].
+
+15
+An unconstrained_array_definition defines an array type with an
+unconstrained first subtype.  Each index_subtype_definition (*note 3.6:
+S0053.) defines the corresponding index subtype to be the subtype
+denoted by the subtype_mark (*note 3.2.2: S0028.).  [ The compound
+delimiter <> (called a box) of an index_subtype_definition stands for an
+undefined range (different objects of the type need not have the same
+bounds).]
+
+16
+A constrained_array_definition defines an array type with a constrained
+first subtype.  Each discrete_subtype_definition (*note 3.6: S0055.)
+defines the corresponding index subtype, as well as the corresponding
+index range for the constrained first subtype.  The constraint of the
+first subtype consists of the bounds of the index ranges.
+
+16.a/3
+          Discussion: {AI05-0005-1AI05-0005-1} Although there is no
+          nameable unconstrained array subtype in this case, the
+          predefined slicing and concatenation operations can operate on
+          and yield values that do not necessarily belong to the first
+          array subtype.  This is also true for Ada 83.
+
+17
+The discrete subtype defined by a discrete_subtype_definition (*note
+3.6: S0055.) is either that defined by the subtype_indication (*note
+3.2.2: S0027.), or a subtype determined by the range as follows:
+
+18
+   * If the type of the range resolves to root_integer, then the
+     discrete_subtype_definition defines a subtype of the predefined
+     type Integer with bounds given by a conversion to Integer of the
+     bounds of the range; 
+
+18.a
+          Reason: This ensures that indexing over the discrete subtype
+          can be performed with regular Integers, rather than only
+          universal_integers.
+
+18.b
+          Discussion: We considered doing this by simply creating a
+          "preference" for Integer when resolving the range.  However,
+          this can introduce Beaujolais effects when the
+          simple_expressions involve calls on functions visible due to
+          use clauses.
+
+19
+   * Otherwise, the discrete_subtype_definition defines a subtype of the
+     type of the range, with the bounds given by the range.
+
+20
+The component_definition of an array_type_definition defines the nominal
+subtype of the components.  If the reserved word aliased appears in the
+component_definition, then each component of the array is aliased (see
+*note 3.10::).
+
+                          _Dynamic Semantics_
+
+21
+The elaboration of an array_type_definition creates the array type and
+its first subtype, and consists of the elaboration of any
+discrete_subtype_definition (*note 3.6: S0055.)s and the
+component_definition (*note 3.6: S0056.).
+
+22/2
+{8652/00028652/0002} {AI95-00171-01AI95-00171-01}
+{AI95-00230-01AI95-00230-01} The elaboration of a
+discrete_subtype_definition that does not contain any per-object
+expressions creates the discrete subtype, and consists of the
+elaboration of the subtype_indication (*note 3.2.2: S0027.) or the
+evaluation of the range.  The elaboration of a
+discrete_subtype_definition that contains one or more per-object
+expressions is defined in *note 3.8::.  The elaboration of a
+component_definition (*note 3.6: S0056.) in an array_type_definition
+(*note 3.6: S0051.) consists of the elaboration of the
+subtype_indication (*note 3.2.2: S0027.) or access_definition.  The
+elaboration of any discrete_subtype_definition (*note 3.6: S0055.)s and
+the elaboration of the component_definition (*note 3.6: S0056.) are
+performed in an arbitrary order.
+
+                          _Static Semantics_
+
+22.1/3
+{AI05-0228-1AI05-0228-1} For an array type with a scalar component type,
+the following language-defined representation aspect may be specified
+with an aspect_specification (see *note 13.1.1::):
+
+22.2/3
+Default_Component_Value
+               This aspect shall be specified by a static expression,
+               and that expression shall be explicit, even if the aspect
+               has a boolean type.  Default_Component_Value shall be
+               specified only on a full_type_declaration.
+
+22.a/3
+          Reason: The part about requiring an explicit expression is to
+          disallow omitting the value for this aspect, which would
+          otherwise be allowed by the rules of *note 13.1.1::.
+
+22.b/3
+          This is a representation attribute in order to disallow
+          specifying it on a derived type that has inherited primitive
+          subprograms; that is necessary as the sizes of out parameters
+          could be different whether or not a Default_Value is specified
+          (see *note 6.4.1::).
+
+22.c/3
+          Aspect Description for Default_Component_Value: Default value
+          for the components of an array-of-scalar subtype.
+
+22.3/3
+{AI05-0228-1AI05-0228-1} If a derived type with no primitive subprograms
+inherits a boolean Default_Component_Value aspect, the aspect may be
+specified to have any value for the derived type.
+
+22.d/3
+          Reason: This overrides the *note 13.1.1:: rule that says that
+          a boolean aspect with a value True cannot be changed.
+
+                        _Name Resolution Rules_
+
+22.4/3
+{AI05-0228-1AI05-0228-1} The expected type for the expression specified
+for the Default_Component_Value aspect is the component type of the
+array type defined by the full_type_declaration on which it appears.
+
+     NOTES
+
+23
+     46  All components of an array have the same subtype.  In
+     particular, for an array of components that are one-dimensional
+     arrays, this means that all components have the same bounds and
+     hence the same length.
+
+24
+     47  Each elaboration of an array_type_definition creates a distinct
+     array type.  A consequence of this is that each object whose
+     object_declaration contains an array_type_definition is of its own
+     unique type.
+
+                              _Examples_
+
+25
+Examples of type declarations with unconstrained array definitions:
+
+26
+     type Vector     is array(Integer  range <>) of Real;
+     type Matrix     is array(Integer  range <>, Integer range <>) of Real;
+     type Bit_Vector is array(Integer  range <>) of Boolean;
+     type Roman      is array(Positive range <>) of Roman_Digit; -- see *note 
3.5.2::
+
+27
+Examples of type declarations with constrained array definitions:
+
+28
+     type Table    is array(1 .. 10) of Integer;
+     type Schedule is array(Day) of Boolean;
+     type Line     is array(1 .. Max_Line_Size) of Character;
+
+29
+Examples of object declarations with array type definitions:
+
+30/2
+     {AI95-00433-01AI95-00433-01} Grid      : array(1 .. 80, 1 .. 100) of 
Boolean;
+     Mix       : array(Color range Red .. Green) of Boolean;
+     Msg_Table : constant array(Error_Code) of access constant String :=
+           (Too_Big => new String'("Result too big"), Too_Small => ...);
+     Page      : array(Positive range <>) of Line :=  --  an array of arrays
+       (1 | 50  => Line'(1 | Line'Last => '+', others => '-'),  -- see *note 
4.3.3::
+        2 .. 49 => Line'(1 | Line'Last => '|', others => ' '));
+         -- Page is constrained by its initial value to (1..50)
+
+                        _Extensions to Ada 83_
+
+30.a
+          The syntax rule for component_definition is modified to allow
+          the reserved word aliased.
+
+30.b
+          The syntax rules for unconstrained_array_definition and
+          constrained_array_definition are modified to use
+          component_definition (instead of
+          component_subtype_indication).  The effect of this change is
+          to allow the reserved word aliased before the component
+          subtype_indication.
+
+30.c
+          A range in a discrete_subtype_definition may use arbitrary
+          universal expressions for each bound (e.g.  -1 ..  3+5),
+          rather than strictly "implicitly convertible" operands.  The
+          subtype defined will still be a subtype of Integer.
+
+                     _Wording Changes from Ada 83_
+
+30.d
+          We introduce a new syntactic category,
+          discrete_subtype_definition, as distinct from discrete_range.
+          These two constructs have the same syntax, but their semantics
+          are quite different (one defines a subtype, with a preference
+          for Integer subtypes, while the other just selects a subrange
+          of an existing subtype).  We use this new syntactic category
+          in for loops and entry families.
+
+30.e
+          The syntax for index_constraint and discrete_range have been
+          moved to their own subclause, since they are no longer used
+          here.
+
+30.f
+          The syntax rule for component_definition (formerly
+          component_subtype_definition) is moved here from RM83-3.7.
+
+                        _Extensions to Ada 95_
+
+30.g/2
+          {AI95-00230-01AI95-00230-01} {AI95-00406-01AI95-00406-01}
+          Array components can have an anonymous access type.
+
+30.h/2
+          {AI95-00363-01AI95-00363-01} The prohibition against
+          unconstrained discriminated aliased components has been
+          lifted.  It has been replaced by a prohibition against the
+          actual troublemakers: general access discriminant constraints
+          (see *note 3.7.1::).
+
+                     _Wording Changes from Ada 95_
+
+30.i/2
+          {8652/00028652/0002} {AI95-00171-01AI95-00171-01} Corrigendum:
+          Added wording to allow the elaboration of per-object
+          constraints for constrained arrays.
+
+                       _Extensions to Ada 2005_
+
+30.j/3
+          {AI05-0228-1AI05-0228-1} The new aspect
+          Default_Component_Value allows defining implicit initial
+          values (see *note 3.3.1::) for arrays of scalar types.
+
+* Menu:
+
+* 3.6.1 ::    Index Constraints and Discrete Ranges
+* 3.6.2 ::    Operations of Array Types
+* 3.6.3 ::    String Types
+
+
+File: aarm2012.info,  Node: 3.6.1,  Next: 3.6.2,  Up: 3.6
+
+3.6.1 Index Constraints and Discrete Ranges
+-------------------------------------------
+
+1
+An index_constraint determines the range of possible values for every
+index of an array subtype, and thereby the corresponding array bounds.
+
+                               _Syntax_
+
+2
+     index_constraint ::=  (discrete_range {, discrete_range})
+
+3
+     discrete_range ::= discrete_subtype_indication | range
+
+                        _Name Resolution Rules_
+
+4
+The type of a discrete_range is the type of the subtype defined by the
+subtype_indication, or the type of the range.  For an index_constraint,
+each discrete_range shall resolve to be of the type of the corresponding
+index.
+
+4.a
+          Discussion: In Ada 95, index_constraints only appear in a
+          subtype_indication; they no longer appear in
+          constrained_array_definitions.
+
+                           _Legality Rules_
+
+5
+An index_constraint shall appear only in a subtype_indication whose
+subtype_mark denotes either an unconstrained array subtype, or an
+unconstrained access subtype whose designated subtype is an
+unconstrained array subtype; in either case, the index_constraint shall
+provide a discrete_range for each index of the array type.
+
+                          _Static Semantics_
+
+6
+A discrete_range defines a range whose bounds are given by the range, or
+by the range of the subtype defined by the subtype_indication.
+
+                          _Dynamic Semantics_
+
+7
+An index_constraint is compatible with an unconstrained array subtype if
+and only if the index range defined by each discrete_range is compatible
+(see *note 3.5::) with the corresponding index subtype.  If any of the
+discrete_ranges defines a null range, any array thus constrained is a
+null array, having no components.  An array value satisfies an
+index_constraint if at each index position the array value and the
+index_constraint have the same index bounds.
+
+7.a
+          Ramification: There is no need to define compatibility with a
+          constrained array subtype, because one is not allowed to
+          constrain it again.
+
+8
+The elaboration of an index_constraint consists of the evaluation of the
+discrete_range(s), in an arbitrary order.  The evaluation of a
+discrete_range consists of the elaboration of the subtype_indication or
+the evaluation of the range.
+
+     NOTES
+
+9
+     48  The elaboration of a subtype_indication consisting of a
+     subtype_mark followed by an index_constraint checks the
+     compatibility of the index_constraint with the subtype_mark (see
+     *note 3.2.2::).
+
+10
+     49  Even if an array value does not satisfy the index constraint of
+     an array subtype, Constraint_Error is not raised on conversion to
+     the array subtype, so long as the length of each dimension of the
+     array value and the array subtype match.  See *note 4.6::.
+
+                              _Examples_
+
+11
+Examples of array declarations including an index constraint:
+
+12
+     Board     : Matrix(1 .. 8,  1 .. 8);  --  see *note 3.6::
+     Rectangle : Matrix(1 .. 20, 1 .. 30);
+     Inverse   : Matrix(1 .. N,  1 .. N);  --  N need not be static 
+
+13
+     Filter    : Bit_Vector(0 .. 31);
+
+14
+Example of array declaration with a constrained array subtype:
+
+15
+     My_Schedule : Schedule;  --  all arrays of type Schedule have the same 
bounds
+
+16
+Example of record type with a component that is an array:
+
+17
+     type Var_Line(Length : Natural) is
+        record
+           Image : String(1 .. Length);
+        end record;
+
+18
+     Null_Line : Var_Line(0);  --  Null_Line.Image is a null array
+
+                        _Extensions to Ada 83_
+
+18.a
+          We allow the declaration of a variable with a nominally
+          unconstrained array subtype, so long as it has an
+          initialization expression to determine its bounds.
+
+                     _Wording Changes from Ada 83_
+
+18.b
+          We have moved the syntax for index_constraint and
+          discrete_range here since they are no longer used in
+          constrained_array_definitions.  We therefore also no longer
+          have to describe the (special) semantics of index_constraints
+          and discrete_ranges that appear in
+          constrained_array_definitions.
+
+18.c
+          The rules given in RM83-3.6.1(5,7-10), which define the bounds
+          of an array object, are redundant with rules given elsewhere,
+          and so are not repeated here.  RM83-3.6.1(6), which requires
+          that the (nominal) subtype of an array variable be
+          constrained, no longer applies, so long as the variable is
+          explicitly initialized.
+
+
+File: aarm2012.info,  Node: 3.6.2,  Next: 3.6.3,  Prev: 3.6.1,  Up: 3.6
+
+3.6.2 Operations of Array Types
+-------------------------------
+
+                           _Legality Rules_
+
+1
+[The argument N used in the attribute_designators for the N-th dimension
+of an array shall be a static expression of some integer type.]  The
+value of N shall be positive (nonzero) and no greater than the
+dimensionality of the array.
+
+                          _Static Semantics_
+
+2/1
+{8652/00068652/0006} {AI95-00030-01AI95-00030-01} The following
+attributes are defined for a prefix A that is of an array type [(after
+any implicit dereference)], or denotes a constrained array subtype:
+
+2.a
+          Ramification: These attributes are not defined if A is a
+          subtype-mark for an access-to-array subtype.  They are defined
+          (by implicit dereference) for access-to-array values.
+
+3
+A'First
+               A'First denotes the lower bound of the first index range;
+               its type is the corresponding index type.
+
+4
+A'First(N)
+               A'First(N) denotes the lower bound of the N-th index
+               range; its type is the corresponding index type.
+
+5
+A'Last
+               A'Last denotes the upper bound of the first index range;
+               its type is the corresponding index type.
+
+6
+A'Last(N)
+               A'Last(N) denotes the upper bound of the N-th index
+               range; its type is the corresponding index type.
+
+7
+A'Range
+               A'Range is equivalent to the range A'First ..  A'Last,
+               except that the prefix A is only evaluated once.
+
+8
+A'Range(N)
+               A'Range(N) is equivalent to the range A'First(N) ..
+               A'Last(N), except that the prefix A is only evaluated
+               once.
+
+9
+A'Length
+               A'Length denotes the number of values of the first index
+               range (zero for a null range); its type is
+               universal_integer.
+
+10
+A'Length(N)
+               A'Length(N) denotes the number of values of the N-th
+               index range (zero for a null range); its type is
+               universal_integer.
+
+                        _Implementation Advice_
+
+11/3
+{AI05-0229-1AI05-0229-1} An implementation should normally represent
+multidimensional arrays in row-major order, consistent with the notation
+used for multidimensional array aggregates (see *note 4.3.3::).
+However, if convention Fortran is specified for a multidimensional array
+type, then column-major order should be used instead (see *note B.5::,
+"*note B.5:: Interfacing with Fortran").
+
+11.a/2
+          Implementation Advice: Multidimensional arrays should be
+          represented in row-major order, unless the array has
+          convention Fortran.
+
+     NOTES
+
+12
+     50  The attribute_references A'First and A'First(1) denote the same
+     value.  A similar relation exists for the attribute_references
+     A'Last, A'Range, and A'Length.  The following relation is satisfied
+     (except for a null array) by the above attributes if the index type
+     is an integer type:
+
+13
+             A'Length(N) = A'Last(N) - A'First(N) + 1
+
+14
+     51  An array type is limited if its component type is limited (see
+     *note 7.5::).
+
+15
+     52  The predefined operations of an array type include the
+     membership tests, qualification, and explicit conversion.  If the
+     array type is not limited, they also include assignment and the
+     predefined equality operators.  For a one-dimensional array type,
+     they include the predefined concatenation operators (if nonlimited)
+     and, if the component type is discrete, the predefined relational
+     operators; if the component type is boolean, the predefined logical
+     operators are also included.
+
+16/2
+     53  {AI95-00287-01AI95-00287-01} A component of an array can be
+     named with an indexed_component.  A value of an array type can be
+     specified with an array_aggregate.  For a one-dimensional array
+     type, a slice of the array can be named; also, string literals are
+     defined if the component type is a character type.
+
+                              _Examples_
+
+17
+Examples (using arrays declared in the examples of subclause *note
+3.6.1::):
+
+18
+     --  Filter'First      =   0   Filter'Last       =  31   Filter'Length =  
32
+     --  Rectangle'Last(1) =  20   Rectangle'Last(2) =  30
+
+
+File: aarm2012.info,  Node: 3.6.3,  Prev: 3.6.2,  Up: 3.6
+
+3.6.3 String Types
+------------------
+
+                          _Static Semantics_
+
+1
+A one-dimensional array type whose component type is a character type is
+called a string type.
+
+2/2
+{AI95-00285-01AI95-00285-01} [There are three predefined string types,
+String, Wide_String, and Wide_Wide_String, each indexed by values of the
+predefined subtype Positive; these are declared in the visible part of
+package Standard:]
+
+3
+     [subtype Positive is Integer range 1 .. Integer'Last;
+
+4/2
+     {AI95-00285-01AI95-00285-01} type String is array(Positive range <>) of 
Character;
+     type Wide_String is array(Positive range <>) of Wide_Character;
+     type Wide_Wide_String is array(Positive range <>) of Wide_Wide_Character;
+     ]
+
+     NOTES
+
+5
+     54  String literals (see *note 2.6:: and *note 4.2::) are defined
+     for all string types.  The concatenation operator & is predefined
+     for string types, as for all nonlimited one-dimensional array
+     types.  The ordering operators <, <=, >, and >= are predefined for
+     string types, as for all one-dimensional discrete array types;
+     these ordering operators correspond to lexicographic order (see
+     *note 4.5.2::).
+
+                              _Examples_
+
+6
+Examples of string objects:
+
+7
+     Stars      : String(1 .. 120) := (1 .. 120 => '*' );
+     Question   : constant String  := "How many characters?";
+        -- Question'First = 1, Question'Last = 20
+        -- Question'Length = 20 (the number of characters)
+
+8
+     Ask_Twice  : String  := Question & Question;   -- constrained to (1..40)
+     Ninety_Six : constant Roman   := "XCVI";   -- see *note 3.5.2:: and *note 
3.6::
+
+                     _Inconsistencies With Ada 83_
+
+8.a
+          The declaration of Wide_String in Standard hides a use-visible
+          declaration with the same defining_identifier.  In rare cases,
+          this might result in an inconsistency between Ada 83 and Ada
+          95.
+
+                    _Incompatibilities With Ada 83_
+
+8.b
+          Because both String and Wide_String are always directly
+          visible, an expression like
+
+8.c
+               "a" < "bc"
+
+8.d
+          is now ambiguous, whereas in Ada 83 both string literals could
+          be resolved to type String.
+
+                        _Extensions to Ada 83_
+
+8.e
+          The type Wide_String is new (though it was approved by ARG for
+          Ada 83 compilers as well).
+
+                     _Wording Changes from Ada 83_
+
+8.f
+          We define the term string type as a natural analogy to the
+          term character type.
+
+                     _Inconsistencies With Ada 95_
+
+8.g/2
+          {AI95-00285-01AI95-00285-01} The declaration of
+          Wide_Wide_String in Standard hides a use-visible declaration
+          with the same defining_identifier.  In the (very) unlikely
+          event that an Ada 95 program had depended on such a
+          use-visible declaration, and the program remains legal after
+          the substitution of Standard.Wide_Wide_String, the meaning of
+          the program will be different.
+
+                        _Extensions to Ada 95_
+
+8.h/2
+          {AI95-00285-01AI95-00285-01} The type Wide_Wide_String is new.
+
+
+File: aarm2012.info,  Node: 3.7,  Next: 3.8,  Prev: 3.6,  Up: 3
+
+3.7 Discriminants
+=================
+
+1/2
+{AI95-00251-01AI95-00251-01} {AI95-00326-01AI95-00326-01} [ A composite
+type (other than an array or interface type) can have discriminants,
+which parameterize the type.  A known_discriminant_part specifies the
+discriminants of a composite type.  A discriminant of an object is a
+component of the object, and is either of a discrete type or an access
+type.  An unknown_discriminant_part in the declaration of a view of a
+type specifies that the discriminants of the type are unknown for the
+given view; all subtypes of such a view are indefinite subtypes.]
+
+1.a/2
+          Glossary entry: A discriminant is a parameter for a composite
+          type.  It can control, for example, the bounds of a component
+          of the type if the component is an array.  A discriminant for
+          a task type can be used to pass data to a task of the type
+          upon creation.
+
+1.b/2
+          Discussion: {AI95-00114-01AI95-00114-01} A view of a type, and
+          all subtypes of the view, have unknown discriminants when the
+          number or names of the discriminants, if any, are unknown at
+          the point of the type declaration for the view.  A
+          discriminant_part of (<>) is used to indicate unknown
+          discriminants.
+
+                     _Language Design Principles_
+
+1.c/2
+          {AI95-00402-01AI95-00402-01} When an access discriminant is
+          initialized at the time of object creation with an allocator
+          of an anonymous type, the allocated object and the object with
+          the discriminant are tied together for their lifetime.  They
+          should be allocated out of the same storage pool, and then at
+          the end of the lifetime of the enclosing object, finalized and
+          reclaimed together.  In this case, the allocated object is
+          called a coextension (see *note 3.10.2::).
+
+1.d/2
+          Discussion: The above principle when applied to a nonlimited
+          type implies that such an object may be copied only to a
+          shorter-lived object, because attempting to assign it to a
+          longer-lived object would fail because the access
+          discriminants would not match.  In a copy, the lifetime
+          connection between the enclosing object and the allocated
+          object does not exist.  The allocated object is tied in the
+          above sense only to the original object.  Other copies have
+          only secondary references to it.
+
+1.e/2
+          Note that when an allocator appears as a constraint on an
+          access discriminant in a subtype_indication that is elaborated
+          independently from object creation, no such connection exists.
+          For example, if a named constrained subtype is declared via
+          "subtype Constr is Rec(Acc_Discrim => new T);" or if such an
+          allocator appears in the subtype_indication for a component,
+          the allocator is evaluated when the subtype_indication is
+          elaborated, and hence its lifetime is typically longer than
+          the objects or components that will later be subject to the
+          constraint.  In these cases, the allocated object should not
+          be reclaimed until the subtype_indication goes out of scope.
+
+                               _Syntax_
+
+2
+     discriminant_part ::= unknown_discriminant_part | 
+     known_discriminant_part
+
+3
+     unknown_discriminant_part ::= (<>)
+
+4
+     known_discriminant_part ::=
+        (discriminant_specification {; discriminant_specification})
+
+5/2
+     {AI95-00231-01AI95-00231-01} discriminant_specification ::=
+        defining_identifier_list : [null_exclusion] subtype_mark [:= 
+     default_expression]
+      | defining_identifier_list : access_definition [:= 
+     default_expression]
+
+6
+     default_expression ::= expression
+
+                        _Name Resolution Rules_
+
+7
+The expected type for the default_expression of a
+discriminant_specification is that of the corresponding discriminant.
+
+                           _Legality Rules_
+
+8/2
+{8652/00078652/0007} {AI95-00098-01AI95-00098-01}
+{AI95-00251-01AI95-00251-01} A discriminant_part is only permitted in a
+declaration for a composite type that is not an array or interface type
+[(this includes generic formal types)].  A type declared with a
+known_discriminant_part is called a discriminated type, as is a type
+that inherits (known) discriminants.
+
+8.a
+          Implementation Note: Discriminants on array types were
+          considered, but were omitted to ease (existing)
+          implementations.
+
+8.b
+          Discussion: Note that the above definition for "discriminated
+          type" does not include types declared with an
+          unknown_discriminant_part.  This seems consistent with Ada 83,
+          where such types (in a generic formal part) would not be
+          considered discriminated types.  Furthermore, the full type
+          for a type with unknown discriminants need not even be
+          composite, much less have any discriminants.
+
+8.b.1/1
+          {8652/00078652/0007} {AI95-00098-01AI95-00098-01} On the other
+          hand, unknown_discriminant_parts cannot be applied to type
+          declarations that cannot have a known_discriminant_part.
+          There is no point in having unknown discriminants on a type
+          that can never have discriminants (for instance, a formal
+          modular type), even when these are allowed syntactically.
+
+9/2
+{AI95-00231-01AI95-00231-01} {AI95-00254-01AI95-00254-01} The subtype of
+a discriminant may be defined by an optional null_exclusion and a
+subtype_mark, in which case the subtype_mark shall denote a discrete or
+access subtype, or it may be defined by an access_definition.  A
+discriminant that is defined by an access_definition is called an access
+discriminant and is of an anonymous access type.
+
+9.a/2
+          This paragraph was deleted.{AI95-00230-01AI95-00230-01}
+
+9.b
+          Reason: Note that discriminants of a named access type are not
+          considered "access discriminants."  Similarly, "access
+          parameter" only refers to a formal parameter defined by an
+          access_definition.
+
+9.1/3
+{AI95-00402-01AI95-00402-01} {AI05-0214-1AI05-0214-1}
+Default_expressions shall be provided either for all or for none of the
+discriminants of a known_discriminant_part (*note 3.7: S0061.).  No
+default_expression (*note 3.7: S0063.)s are permitted in a
+known_discriminant_part (*note 3.7: S0061.) in a declaration of a
+nonlimited tagged type [or a generic formal type].
+
+9.c/2
+          Reason: The all-or-none rule is related to the rule that a
+          discriminant constraint shall specify values for all
+          discriminants.  One could imagine a different rule that
+          allowed a constraint to specify only some of the
+          discriminants, with the others provided by default.  Having
+          defaults for discriminants has a special significance -- it
+          allows objects of the type to be unconstrained, with the
+          discriminants alterable as part of assigning to the object.
+
+9.d/3
+          {AI05-0214-1AI05-0214-1} Defaults for discriminants of tagged
+          types are disallowed so that every object of a nonlimited
+          tagged type is constrained, either by an explicit constraint,
+          or by its initial discriminant values.  This substantially
+          simplifies the semantic rules and the implementation of
+          inherited dispatching operations.  We don't need this rule for
+          limited tagged types, as the discriminants of such objects
+          cannot be changed after the object is created in any case --
+          no full-object assignment is supported, and that is required
+          to change discriminant values.  For generic formal types, the
+          restriction simplifies the type matching rules.  If one simply
+          wants a "default" value for the discriminants, a constrained
+          subtype can be declared for future use.
+
+10/3
+{AI95-00230-01AI95-00230-01} {AI95-00402-01AI95-00402-01}
+{AI95-00419-01AI95-00419-01} {AI05-0063-1AI05-0063-1} A
+discriminant_specification for an access discriminant may have a
+default_expression only in the declaration for an immutably limited type
+(see *note 7.5::).  In addition to the places where Legality Rules
+normally apply (see *note 12.3::), this rule applies also in the private
+part of an instance of a generic unit.
+
+10.a/3
+          Discussion: This rule implies that a type can have a default
+          for an access discriminant if the type is limited, but not if
+          the only reason it's limited is because of a limited
+          component.  Compare the definition of limited type and
+          immutably limited type in *note 7.5::.
+
+10.b/3
+          Ramification: A (nonformal) limited private type can always
+          have a default for an access discriminant, because having the
+          default itself makes the type immutably limited.  Such a
+          private type must necessarily have a full type with the same
+          access discriminant with a default, and thus the full type
+          will always be immutably limited (if legal).
+
+10.c/2
+          Reason: {AI95-00230-01AI95-00230-01} We considered the
+          following rules for access discriminants:
+
+10.d
+             * If a type has an access discriminant, this automatically
+               makes it limited, just like having a limited component
+               automatically makes a type limited.  This was rejected
+               because it decreases program readability, and because it
+               seemed error prone (two bugs in a previous version of the
+               RM9X were attributable to this rule).
+
+10.e/2
+             * A type with an access discriminant shall be limited.
+               This is equivalent to the rule we actually chose for Ada
+               95, except that it allows a type to have an access
+               discriminant if it is limited just because of a limited
+               component.  For example, any record containing a task
+               would be allowed to have an access discriminant, whereas
+               the actual rule requires "limited record".  This rule was
+               also rejected due to readability concerns, and because
+               would interact badly with the rules for limited types
+               that "become nonlimited".
+
+10.e.1/3
+             * {AI05-0063-1AI05-0063-1} A type may have an access
+               discriminant if it is an immutably limited type.  This
+               was the rule chosen for Ada 95.
+
+10.f/2
+             * Any type may have an access discriminant.  For nonlimited
+               type, there is no special accessibility for access
+               discriminants; they're the same as any other anonymous
+               access component.  For a limited type, they have the
+               special accessibility of Ada 95.  However, this doesn't
+               work because a limited partial view can have a nonlimited
+               full view -- giving the two views different
+               accessibility.
+
+10.f.1/3
+             * {AI05-0063-1AI05-0063-1} Any type may have an access
+               discriminant, as above.  However, special accessibility
+               rules only apply to types that are immutably limited
+               (task, protected, and explicitly limited records).
+               However, this breaks privacy; worse, Legality Rules
+               depend on the definition of accessibility.
+
+10.f.2/3
+             * {AI05-0063-1AI05-0063-1} Any type may have an access
+               discriminant, as above.  Limited types have special
+               accessibility, while nonlimited types have normal
+               accessibility.  However, a limited partial view with an
+               access discriminant can only be completed by an immutably
+               limited type.  That prevents accessibility from changing.
+               A runtime accessibility check is required on generic
+               formal types with access discriminants.  However,
+               changing between limited and nonlimited types would have
+               far-reaching consequences for access discriminants --
+               which is uncomfortable.
+
+10.g/2
+             * Any type may have an access discriminant.  All types have
+               special accessibility.  This was considered early during
+               the Ada 9X process, but was dropped for "unpleasant
+               complexities", which unfortunately aren't recorded.  It
+               does seem that an accessibility check would be needed on
+               assignment of such a type, to avoid copying an object
+               with a discriminant pointing to a local object into a
+               more global object (and thus creating a dangling
+               pointer).
+
+10.h/2
+             * Any type may have an access discriminant, but access
+               discriminants cannot have defaults.  All types have
+               special accessibility.  This gets rid of the problems on
+               assignment (you couldn't change such a discriminant), but
+               it would be horribly incompatible with Ada 95.
+
+10.h.1/3
+             * {AI05-0063-1AI05-0063-1} Any type may have an access
+               discriminant, but access discriminants may have defaults
+               only if they are of an immutably limited type.  This is
+               the rule chosen for Ada 2005, as it is not incompatible,
+               and it doesn't require weird accessibility checks.
+
+11/2
+This paragraph was deleted.{AI95-00402-01AI95-00402-01}
+
+12
+For a type defined by a derived_type_definition, if a
+known_discriminant_part is provided in its declaration, then:
+
+13
+   * The parent subtype shall be constrained;
+
+14
+   * If the parent type is not a tagged type, then each discriminant of
+     the derived type shall be used in the constraint defining the
+     parent subtype;
+
+14.a
+          Implementation Note: This ensures that the new discriminant
+          can share storage with an existing discriminant.
+
+15
+   * If a discriminant is used in the constraint defining the parent
+     subtype, the subtype of the discriminant shall be statically
+     compatible (see *note 4.9.1::) with the subtype of the
+     corresponding parent discriminant.
+
+15.a
+          Reason: This ensures that on conversion (or extension via an
+          extension aggregate) to a distantly related type, if the
+          discriminants satisfy the target type's requirements they
+          satisfy all the intermediate types' requirements as well.
+
+15.b
+          Ramification: There is no requirement that the new
+          discriminant have the same (or any) default_expression as the
+          parent's discriminant.
+
+16/3
+This paragraph was deleted.{AI05-0102-1AI05-0102-1}
+
+16.a/3
+          This paragraph was deleted.
+
+                          _Static Semantics_
+
+17
+A discriminant_specification declares a discriminant; the subtype_mark
+denotes its subtype unless it is an access discriminant, in which case
+the discriminant's subtype is the anonymous access-to-variable subtype
+defined by the access_definition.
+
+18
+[For a type defined by a derived_type_definition, each discriminant of
+the parent type is either inherited, constrained to equal some new
+discriminant of the derived type, or constrained to the value of an
+expression.]  When inherited or constrained to equal some new
+discriminant, the parent discriminant and the discriminant of the
+derived type are said to correspond.  Two discriminants also correspond
+if there is some common discriminant to which they both correspond.  A
+discriminant corresponds to itself as well.  If a discriminant of a
+parent type is constrained to a specific value by a
+derived_type_definition, then that discriminant is said to be specified
+by that derived_type_definition.
+
+18.a
+          Ramification: The correspondence relationship is transitive,
+          symmetric, and reflexive.  That is, if A corresponds to B, and
+          B corresponds to C, then A, B, and C each corresponds to A, B,
+          and C in all combinations.
+
+19
+A constraint that appears within the definition of a discriminated type
+depends on a discriminant of the type if it names the discriminant as a
+bound or discriminant value.  A component_definition depends on a
+discriminant if its constraint depends on the discriminant, or on a
+discriminant that corresponds to it.
+
+19.a
+          Ramification: A constraint in a task_body is not considered to
+          depend on a discriminant of the task type, even if it names
+          it.  It is only the constraints in the type definition itself
+          that are considered dependents.  Similarly for protected
+          types.
+
+20
+A component depends on a discriminant if:
+
+21
+   * Its component_definition depends on the discriminant; or
+
+21.a
+          Ramification: A component does not depend on a discriminant
+          just because its default_expression refers to the
+          discriminant.
+
+22
+   * It is declared in a variant_part that is governed by the
+     discriminant; or
+
+23
+   * It is a component inherited as part of a derived_type_definition,
+     and the constraint of the parent_subtype_indication depends on the
+     discriminant; or
+
+23.a
+          Reason: When the parent subtype depends on a discriminant, the
+          parent part of the derived type is treated like a
+          discriminant-dependent component.
+
+23.b
+          Ramification: Because of this rule, we don't really need to
+          worry about "corresponding" discriminants, since all the
+          inherited components will be discriminant-dependent if there
+          is a new known_discriminant_part whose discriminants are used
+          to constrain the old discriminants.
+
+24
+   * It is a subcomponent of a component that depends on the
+     discriminant.
+
+24.a
+          Reason: The concept of discriminant-dependent (sub)components
+          is primarily used in various rules that disallow renaming or
+          'Access, or specify that certain discriminant-changing
+          assignments are erroneous.  The goal is to allow
+          implementations to move around or change the size of
+          discriminant-dependent subcomponents upon a
+          discriminant-changing assignment to an enclosing object.  The
+          above definition specifies that all subcomponents of a
+          discriminant-dependent component or parent part are themselves
+          discriminant-dependent, even though their presence or size
+          does not in fact depend on a discriminant.  This is because it
+          is likely that they will move in a discriminant-changing
+          assignment if they are a component of one of several
+          discriminant-dependent parts of the same record.
+
+25
+Each value of a discriminated type includes a value for each component
+of the type that does not depend on a discriminant[; this includes the
+discriminants themselves].  The values of discriminants determine which
+other component values are present in the value of the discriminated
+type.
+
+25.a
+          To be honest: Which values are present might depend on
+          discriminants of some ancestor type that are constrained in an
+          intervening derived_type_definition.  That's why we say
+          "values of discriminants" instead of "values of the
+          discriminants" -- a subtle point.
+
+26
+A type declared with a known_discriminant_part is said to have known
+discriminants; its first subtype is unconstrained.  A type declared with
+an unknown_discriminant_part is said to have unknown discriminants.  A
+type declared without a discriminant_part has no discriminants, unless
+it is a derived type; if derived, such a type has the same sort of
+discriminants (known, unknown, or none) as its parent (or ancestor)
+type.  A tagged class-wide type also has unknown discriminants.  [Any
+subtype of a type with unknown discriminants is an unconstrained and
+indefinite subtype (see *note 3.2:: and *note 3.3::).]
+
+26.a/2
+          Discussion: {AI95-00114-01AI95-00114-01} An
+          unknown_discriminant_part "(<>)" is only permitted in the
+          declaration of a (generic or nongeneric) private type, private
+          extension, incomplete type, or formal derived type.  Hence,
+          only such types, descendants thereof, and class-wide types can
+          have unknown discriminants.  An unknown_discriminant_part is
+          used to indicate that the corresponding actual or full type
+          might have discriminants without defaults, or be an
+          unconstrained array subtype.  Tagged class-wide types are also
+          considered to have unknown discriminants because discriminants
+          can be added by type extensions, so the total number of
+          discriminants of any given value of a tagged class-wide type
+          is not known at compile time.
+
+26.b/2
+          {AI95-00287-01AI95-00287-01} A subtype with unknown
+          discriminants is indefinite, and hence an object of such a
+          subtype needs explicit initialization.  A limited private type
+          with unknown discriminants is "extremely" limited; objects of
+          such a type can be initialized only by subprograms (either
+          procedures with a parameter of the type, or a function
+          returning the type) declared in the package.  Subprograms
+          declared elsewhere can operate on and even return the type,
+          but they can only initialize the object by calling
+          (ultimately) a subprogram in the package declaring the type.
+          Such a type is useful for keeping complete control over object
+          creation within the package declaring the type.
+
+26.c
+          A partial view of a type might have unknown discriminants,
+          while the full view of the same type might have known,
+          unknown, or no discriminants.
+
+                          _Dynamic Semantics_
+
+27/2
+{AI95-00230-01AI95-00230-01} {AI95-00416-01AI95-00416-01} For an access
+discriminant, its access_definition is elaborated when the value of the
+access discriminant is defined: by evaluation of its default_expression,
+by elaboration of a discriminant_constraint, or by an assignment that
+initializes the enclosing object.  
+
+27.a/2
+          Ramification: {AI95-00231-01AI95-00231-01}
+          {AI95-00416-01AI95-00416-01} The conversion of the expression
+          defining the access discriminant to the anonymous access type
+          raises Program_Error for an object created by an allocator of
+          an access type T, if the initial value is an access parameter
+          that designates a view whose accessibility level is deeper
+          than that of T.
+
+     NOTES
+
+28
+     55  If a discriminated type has default_expressions for its
+     discriminants, then unconstrained variables of the type are
+     permitted, and the values of the discriminants can be changed by an
+     assignment to such a variable.  If defaults are not provided for
+     the discriminants, then all variables of the type are constrained,
+     either by explicit constraint or by their initial value; the values
+     of the discriminants of such a variable cannot be changed after
+     initialization.
+
+28.a
+          Discussion: This connection between discriminant defaults and
+          unconstrained variables can be a source of confusion.  For Ada
+          95, we considered various ways to break the connection between
+          defaults and unconstrainedness, but ultimately gave up for
+          lack of a sufficiently simple and intuitive alternative.
+
+28.b
+          An unconstrained discriminated subtype with defaults is called
+          a mutable subtype, and a variable of such a subtype is called
+          a mutable variable, because the discriminants of such a
+          variable can change.  There are no mutable arrays (that is,
+          the bounds of an array object can never change), because there
+          is no way in the language to define default values for the
+          bounds.  Similarly, there are no mutable class-wide subtypes,
+          because there is no way to define the default tag, and
+          defaults for discriminants are not allowed in the tagged case.
+          Mutable tags would also require a way for the maximum possible
+          size of such a class-wide subtype to be known.  (In some
+          implementations, all mutable variables are allocated with the
+          maximum possible size.  This approach is appropriate for
+          real-time applications where implicit use of the heap is
+          inappropriate.)
+
+29
+     56  The default_expression for a discriminant of a type is
+     evaluated when an object of an unconstrained subtype of the type is
+     created.
+
+30
+     57  Assignment to a discriminant of an object (after its
+     initialization) is not allowed, since the name of a discriminant is
+     a constant; neither assignment_statements nor assignments inherent
+     in passing as an in out or out parameter are allowed.  Note however
+     that the value of a discriminant can be changed by assigning to the
+     enclosing object, presuming it is an unconstrained variable.
+
+30.a/2
+          Discussion: {AI95-00114-01AI95-00114-01} An
+          unknown_discriminant_part is permitted only in the declaration
+          of a private type (including generic formal private), private
+          extension, incomplete type, or generic formal derived type.
+          These are the things that will have a corresponding completion
+          or generic actual, which will either define the discriminants,
+          or say there are none.  The (<>) indicates that the
+          actual/full subtype might be an indefinite subtype.  An
+          unknown_discriminant_part is not permitted in a normal
+          untagged derived type declaration, because there is no
+          separate full type declaration for such a type.  Note that
+          (<>) allows unconstrained array bounds; those are somewhat
+          like undefaulted discriminants.
+
+30.b
+          For a derived type, either the discriminants are inherited as
+          is, or completely respecified in a new discriminant_part.  In
+          this latter case, each discriminant of the parent type shall
+          be constrained, either to a specific value, or to equal one of
+          the new discriminants.  Constraining a parent type's
+          discriminant to equal one of the new discriminants is like a
+          renaming of the discriminant, except that the subtype of the
+          new discriminant can be more restrictive than that of the
+          parent's one.  In any case, the new discriminant can share
+          storage with the parent's discriminant.
+
+31
+     58  A discriminant that is of a named access type is not called an
+     access discriminant; that term is used only for discriminants
+     defined by an access_definition.
+
+                              _Examples_
+
+32
+Examples of discriminated types:
+
+33
+     type Buffer(Size : Buffer_Size := 100)  is        -- see *note 3.5.4::
+        record
+           Pos   : Buffer_Size := 0;
+           Value : String(1 .. Size);
+        end record;
+
+34
+     type Matrix_Rec(Rows, Columns : Integer) is
+        record
+           Mat : Matrix(1 .. Rows, 1 .. Columns);       -- see *note 3.6::
+        end record;
+
+35
+     type Square(Side : Integer) is new
+        Matrix_Rec(Rows => Side, Columns => Side);
+
+36
+     type Double_Square(Number : Integer) is
+        record
+           Left  : Square(Number);
+           Right : Square(Number);
+        end record;
+
+37/3
+     {AI95-00433-01AI95-00433-01} {AI05-0229-1AI05-0229-1} task type 
Worker(Prio : System.Priority; Buf : access Buffer)
+        with Priority => Prio is -- see *note D.1::
+        -- discriminants used to parameterize the task type (see *note 9.1::)
+        entry Fill;
+        entry Drain;
+     end Worker;
+
+                        _Extensions to Ada 83_
+
+37.a
+          The syntax for a discriminant_specification is modified to
+          allow an access discriminant, with a type specified by an
+          access_definition (see *note 3.10::).
+
+37.b/2
+          {AI95-00251-01AI95-00251-01} Discriminants are allowed on all
+          composite types other than array and interface types.
+
+37.c
+          Discriminants may be of an access type.
+
+                     _Wording Changes from Ada 83_
+
+37.d
+          Discriminant_parts are not elaborated, though an
+          access_definition is elaborated when the discriminant is
+          initialized.
+
+                        _Extensions to Ada 95_
+
+37.e/2
+          {AI95-00230-01AI95-00230-01} {AI95-00402-01AI95-00402-01}
+          {AI95-00416-01AI95-00416-01} Access discriminants (anonymous
+          access types used as a discriminant) can be used on any type
+          allowing discriminants.  Defaults aren't allowed on
+          discriminants of nonlimited types, however, so that
+          accessibility problems don't happen on assignment.
+
+37.f/2
+          {AI95-00231-01AI95-00231-01} null_exclusion can be used in the
+          declaration of a discriminant.
+
+                     _Wording Changes from Ada 95_
+
+37.g/2
+          {8652/00078652/0007} {AI95-00098-01AI95-00098-01} Corrigendum:
+          The wording was clarified so that types that cannot have
+          discriminants cannot have an unknown_discriminant_part.
+
+37.h/2
+          {AI95-00251-01AI95-00251-01} Added wording to prevent
+          interfaces from having discriminants.  We don't want
+          interfaces to have any components.
+
+37.i/2
+          {AI95-00254-01AI95-00254-01} Removed wording which implied or
+          required an access discriminant to have an access-to-object
+          type (anonymous access types can now be access-to-subprogram
+          types as well).
+
+37.j/3
+          {AI95-00326-01AI95-00326-01} {AI05-0299-1AI05-0299-1} Fixed
+          the wording of the introduction to this subclause to reflect
+          that both incomplete and partial views can have unknown
+          discriminants.  That was always true, but for some reason this
+          wording specified partial views.
+
+37.k/2
+          {AI95-00419-01AI95-00419-01} Changed the wording to use the
+          new term "explicitly limited record", which makes the intent
+          much clearer (and eliminates confusion with derived types that
+          happen to contain the reserved word limited).
+
+                   _Incompatibilities With Ada 2005_
+
+37.l/3
+          {AI05-0063-1AI05-0063-1} Correction: Changed the rules for
+          when access discriminants can have defaults to depend on the
+          new definition for immutably limited types; this will help
+          ensure that unusual corner cases are properly handled.  Note
+          that the Ada 2005 rule was unintentionally incompatible with
+          the Ada 95 rule (as enforced by the ACATS); this change brings
+          it back into alignment with actual practice.  So there should
+          be no practical incompatibility.
+
+                       _Extensions to Ada 2005_
+
+37.m/3
+          {AI05-0214-1AI05-0214-1} A limited tagged type may now have
+          defaults for its discriminants.
+
+                    _Wording Changes from Ada 2005_
+
+37.n/3
+          {AI05-0102-1AI05-0102-1} Correction: Moved implicit conversion
+          Legality Rule to *note 8.6::.
+
+* Menu:
+
+* 3.7.1 ::    Discriminant Constraints
+* 3.7.2 ::    Operations of Discriminated Types
+
+
+File: aarm2012.info,  Node: 3.7.1,  Next: 3.7.2,  Up: 3.7
+
+3.7.1 Discriminant Constraints
+------------------------------
+
+1
+A discriminant_constraint specifies the values of the discriminants for
+a given discriminated type.
+
+                     _Language Design Principles_
+
+1.a/3
+          {AI05-0299-1AI05-0299-1} The rules in this subclause are
+          intentionally parallel to those given in *note 4.3.1::, "*note
+          4.3.1:: Record Aggregates".
+
+                               _Syntax_
+
+2
+     discriminant_constraint ::=
+        (discriminant_association {, discriminant_association})
+
+3
+     discriminant_association ::=
+        [discriminant_selector_name {| discriminant_selector_name} =>] 
+     expression
+
+4
+     A discriminant_association is said to be named if it has one or
+     more discriminant_selector_names; it is otherwise said to be
+     positional.  In a discriminant_constraint, any positional
+     associations shall precede any named associations.
+
+                        _Name Resolution Rules_
+
+5
+Each selector_name of a named discriminant_association (*note 3.7.1:
+S0065.) shall resolve to denote a discriminant of the subtype being
+constrained; the discriminants so named are the associated discriminants
+of the named association.  For a positional association, the associated
+discriminant is the one whose discriminant_specification (*note 3.7:
+S0062.) occurred in the corresponding position in the
+known_discriminant_part (*note 3.7: S0061.) that defined the
+discriminants of the subtype being constrained.
+
+6
+The expected type for the expression in a discriminant_association is
+that of the associated discriminant(s).
+
+                           _Legality Rules_
+
+7/3
+{8652/00088652/0008} {AI95-00168-01AI95-00168-01}
+{AI95-00363-01AI95-00363-01} {AI05-0041-1AI05-0041-1} A
+discriminant_constraint is only allowed in a subtype_indication whose
+subtype_mark denotes either an unconstrained discriminated subtype, or
+an unconstrained access subtype whose designated subtype is an
+unconstrained discriminated subtype.  However, in the case of an access
+subtype, a discriminant_constraint (*note 3.7.1: S0064.) is legal only
+if any dereference of a value of the access type is known to be
+constrained (see *note 3.3::).  In addition to the places where Legality
+Rules normally apply (see *note 12.3::), these rules apply also in the
+private part of an instance of a generic unit.
+
+7.a.1/2
+          This paragraph was deleted.{8652/00088652/0008}
+          {AI95-00168-01AI95-00168-01} {AI95-00363-01AI95-00363-01}
+
+7.a/2
+          Reason: {AI95-00363-01AI95-00363-01} The second rule is
+          necessary to prevent objects from changing so that they no
+          longer match their constraint.  In Ada 95, we attempted to
+          prevent this by banning every case where an aliased object
+          could be unconstrained or be changed by an enclosing
+          assignment.  New ways to cause this problem were being
+          discovered frequently, meaning that new rules had to be
+          dreamed up to cover them.  Meanwhile, aliased objects and
+          components were getting more and more limited.  In Ada 2005,
+          we sweep away all of that cruft and replace it by a simple
+          rule "thou shalt not create an access subtype that can point
+          to an item whose discriminants can be changed by assignment".
+
+7.b/3
+          Discussion: {AI05-0041-1AI05-0041-1} The second rule will only
+          use the indefinite or dereference bullets in the definition of
+          "known to be constrained".  The rule is worded in terms of
+          "known to be constrained" in order to capture the special
+          rules that apply in generic bodies (rather than repeating them
+          and getting them subtly wrong).
+
+8
+A named discriminant_association with more than one selector_name is
+allowed only if the named discriminants are all of the same type.  A
+discriminant_constraint shall provide exactly one value for each
+discriminant of the subtype being constrained.
+
+9/3
+This paragraph was deleted.{AI05-0102-1AI05-0102-1}
+
+9.a/3
+          Ramification: In addition, *note 8.6:: requires that the
+          expression associated with an access discriminant is
+          convertible (see *note 4.6::) to the anonymous access type.
+          This implies both convertibility of designated types, and
+          static accessibility.  This implies that if an object of type
+          T with an access discriminant is created by an allocator for
+          an access type A, then it requires that the type of the
+          expression associated with the access discriminant have an
+          accessibility level that is not statically deeper than that of
+          A. This is to avoid dangling references.
+
+                          _Dynamic Semantics_
+
+10
+A discriminant_constraint is compatible with an unconstrained
+discriminated subtype if each discriminant value belongs to the subtype
+of the corresponding discriminant.
+
+10.a
+          Ramification: The "dependent compatibility check" has been
+          eliminated in Ada 95.  Any checking on subcomponents is
+          performed when (and if) an object is created.
+
+10.b
+          Discussion: There is no need to define compatibility with a
+          constrained discriminated subtype, because one is not allowed
+          to constrain it again.
+
+11
+A composite value satisfies a discriminant constraint if and only if
+each discriminant of the composite value has the value imposed by the
+discriminant constraint.
+
+12
+For the elaboration of a discriminant_constraint, the expressions in the
+discriminant_associations are evaluated in an arbitrary order and
+converted to the type of the associated discriminant (which might raise
+Constraint_Error -- see *note 4.6::); the expression of a named
+association is evaluated (and converted) once for each associated
+discriminant.  The result of each evaluation and conversion is the value
+imposed by the constraint for the associated discriminant.
+
+12.a
+          Reason: We convert to the type, not the subtype, so that the
+          definition of compatibility of discriminant constraints is not
+          vacuous.
+
+     NOTES
+
+13
+     59  The rules of the language ensure that a discriminant of an
+     object always has a value, either from explicit or implicit
+     initialization.
+
+13.a
+          Discussion: Although it is illegal to constrain a class-wide
+          tagged subtype, it is possible to have a partially constrained
+          class-wide subtype: If the subtype S is defined by T(A => B),
+          then S'Class is partially constrained in the sense that
+          objects of subtype S'Class have to have discriminants
+          corresponding to A equal to B, but there can be other
+          discriminants defined in extensions that are not constrained
+          to any particular value.
+
+                              _Examples_
+
+14/3
+{AI05-0299-1AI05-0299-1} Examples (using types declared above in
+subclause *note 3.7::):
+
+15
+     Large   : Buffer(200);  --  constrained, always 200 characters
+                             --   (explicit discriminant value)
+     Message : Buffer;       --  unconstrained, initially 100 characters
+                             --   (default discriminant value)
+     Basis   : Square(5);    --  constrained, always 5 by 5
+     Illegal : Square;       --  illegal, a Square has to be constrained
+
+                     _Inconsistencies With Ada 83_
+
+15.a
+          Dependent compatibility checks are no longer performed on
+          subtype declaration.  Instead they are deferred until object
+          creation (see *note 3.3.1::).  This is upward compatible for a
+          program that does not raise Constraint_Error.
+
+                     _Wording Changes from Ada 83_
+
+15.b
+          Everything in RM83-3.7.2(7-12), which specifies the initial
+          values for discriminants, is now redundant with 3.3.1, 6.4.1,
+          8.5.1, and 12.4.  Therefore, we don't repeat it here.  Since
+          the material is largely intuitive, but nevertheless
+          complicated to state formally, it doesn't seem worth putting
+          it in a "NOTE."
+
+                    _Incompatibilities With Ada 95_
+
+15.c/2
+          {8652/00088652/0008} {AI95-00168-01AI95-00168-01}
+          {AI95-00363-01AI95-00363-01} The Corrigendum added a
+          restriction on discriminant_constraints for general access
+          subtypes.  Such constraints are prohibited if the designated
+          type can be treated as constrained somewhere in the program.
+          Ada 2005 goes further and prohibits such
+          discriminant_constraints if the designated type has (or might
+          have, in the case of a formal type) defaults for its
+          discriminants.  The use of general access subtypes is rare,
+          and this eliminates a boatload of problems that required many
+          restrictions on the use of aliased objects and components (now
+          lifted).  Similarly, Ada 2005 prohibits
+          discriminant_constraints on any access type whose designated
+          type has a partial view that is constrained.  Such a type will
+          not be constrained in the heap to avoid privacy problems.
+          Again, the use of such subtypes is rare (they can only happen
+          within the package and its child units).
+
+                    _Wording Changes from Ada 2005_
+
+15.d/3
+          {AI05-0041-1AI05-0041-1} Correction: Revised the rules on
+          access subtypes having discriminant constraints to depend on
+          the "known to be constrained" rules.  This centralizes the
+          rules so that future fixes need to be made in only one place,
+          as well as fixing bugs in obscure cases.
+
+15.e/3
+          {AI05-0102-1AI05-0102-1} Correction: Moved implicit conversion
+          Legality Rule to *note 8.6::.
+
+
+File: aarm2012.info,  Node: 3.7.2,  Prev: 3.7.1,  Up: 3.7
+
+3.7.2 Operations of Discriminated Types
+---------------------------------------
+
+1
+[If a discriminated type has default_expressions for its discriminants,
+then unconstrained variables of the type are permitted, and the
+discriminants of such a variable can be changed by assignment to the
+variable.  For a formal parameter of such a type, an attribute is
+provided to determine whether the corresponding actual parameter is
+constrained or unconstrained.]
+
+                          _Static Semantics_
+
+2
+For a prefix A that is of a discriminated type [(after any implicit
+dereference)], the following attribute is defined:
+
+3/3
+A'Constrained
+               {AI05-0214-1AI05-0214-1} Yields the value True if A
+               denotes a constant, a value, a tagged object, or a
+               constrained variable, and False otherwise.
+
+3.a/3
+          Implementation Note: {AI05-0214-1AI05-0214-1} This attribute
+          is primarily used on parameters, to determine whether the
+          discriminants can be changed as part of an assignment.  The
+          Constrained attribute is statically True for in parameters.
+          For in out and out parameters of a discriminated type, the
+          value of this attribute needs to be passed as an implicit
+          parameter, in general.  However, if the type is tagged or does
+          not have defaults for its discriminants, the attribute is
+          statically True, so no implicit parameter is needed.
+          Parameters of a limited untagged type with defaulted
+          discriminants need this implicit parameter, unless there are
+          no nonlimited views, because they might be passed to a
+          subprogram whose body has visibility on a nonlimited view of
+          the type, and hence might be able to assign to the object and
+          change its discriminants.
+
+3.b/3
+          Reason: {AI05-0214-1AI05-0214-1} All tagged objects are known
+          to be constrained (as nonlimited tagged types cannot have
+          discriminant defaults, and limited tagged objects are
+          immutably limited), and are always considered constrained by
+          this attribute to avoid distributed overhead for parameters of
+          limited classwide types, as limited tagged objects may
+          technically be unconstrained if they use defaulted
+          discriminants.  Such objects still cannot have their
+          discriminants changed, as assignment is not supported for
+          them, so there is no use for this attribute that would justify
+          the overhead of passing it with all classwide parameters.
+
+3.c/3
+          Discussion: {AI05-0005-1AI05-0005-1} {AI05-0214-1AI05-0214-1}
+          If the type of A is a type derived from an untagged partial
+          view of a tagged type such that it is not a tagged type, then
+          A is not considered a tagged object, and A'Constrained can
+          return either True or False depending on the nature of the
+          object.
+
+                         _Erroneous Execution_
+
+4
+The execution of a construct is erroneous if the construct has a
+constituent that is a name denoting a subcomponent that depends on
+discriminants, and the value of any of these discriminants is changed by
+this execution between evaluating the name and the last use (within this
+execution) of the subcomponent denoted by the name.
+
+4.a
+          Ramification: This rule applies to assignment_statements,
+          calls (except when the discriminant-dependent subcomponent is
+          an in parameter passed by copy), indexed_components, and
+          slices.  Ada 83 only covered the first two cases.  AI83-00585
+          pointed out the situation with the last two cases.  The cases
+          of object_renaming_declarations and generic formal in out
+          objects are handled differently, by disallowing the situation
+          at compile time.
+
+                        _Extensions to Ada 83_
+
+4.b/1
+          For consistency with other attributes, we are allowing the
+          prefix of Constrained to be a value as well as an object of a
+          discriminated type, and also an implicit dereference.  These
+          extensions are not important capabilities, but there seems no
+          reason to make this attribute different from other similar
+          attributes.  We are curious what most Ada 83 compilers do with
+          F(1).X'Constrained.
+
+4.c
+          We now handle in a general way the cases of erroneousness
+          identified by AI83-00585, where the prefix of an
+          indexed_component or slice is discriminant-dependent, and the
+          evaluation of the index or discrete range changes the value of
+          a discriminant.
+
+                     _Wording Changes from Ada 83_
+
+4.d
+          We have moved all discussion of erroneous use of names that
+          denote discriminant-dependent subcomponents to this subclause.
+          In Ada 83, it used to appear separately under
+          assignment_statements and subprogram calls.
+
+                    _Wording Changes from Ada 2005_
+
+4.e/3
+          {AI05-0214-1AI05-0214-1} A'Constrained is now defined to
+          return True for any A that is a tagged object.  This doesn't
+          change the result for any A allowed by previous versions of
+          Ada; the change is necessary to avoid unnecessary overhead for
+          limited tagged parameters.
+
+
+File: aarm2012.info,  Node: 3.8,  Next: 3.9,  Prev: 3.7,  Up: 3
+
+3.8 Record Types
+================
+
+1
+A record object is a composite object consisting of named components.
+The value of a record object is a composite value consisting of the
+values of the components.  
+
+                               _Syntax_
+
+2
+     record_type_definition ::= [[abstract] tagged] [limited] 
+     record_definition
+
+3
+     record_definition ::=
+         record
+            component_list
+         end record
+       | null record
+
+4
+     component_list ::=
+           component_item {component_item}
+        | {component_item} variant_part
+        |  null;
+
+5/1
+     {8652/00098652/0009} {AI95-00137-01AI95-00137-01} component_item
+     ::= component_declaration | aspect_clause
+
+6/3
+     {AI05-0183-1AI05-0183-1} component_declaration ::=
+        defining_identifier_list : component_definition [:= 
+     default_expression]
+             [aspect_specification];
+
+                        _Name Resolution Rules_
+
+7
+The expected type for the default_expression, if any, in a
+component_declaration is the type of the component.
+
+                           _Legality Rules_
+
+8/2
+This paragraph was deleted.{AI95-00287-01AI95-00287-01}
+
+9/2
+{AI95-00366-01AI95-00366-01} Each component_declaration declares a
+component of the record type.  Besides components declared by
+component_declarations, the components of a record type include any
+components declared by discriminant_specifications of the record type
+declaration.  [The identifiers of all components of a record type shall
+be distinct.]
+
+9.a/3
+          Proof: {AI05-0299-1AI05-0299-1} The identifiers of all
+          components of a record type have to be distinct because they
+          are all declared immediately within the same declarative
+          region.  See Clause *note 8::.
+
+10
+Within a type_declaration, a name that denotes a component, protected
+subprogram, or entry of the type is allowed only in the following cases:
+
+11/3
+   * {AI05-0004-1AI05-0004-1} {AI05-0295-1AI05-0295-1} A name that
+     denotes any component, protected subprogram, or entry is allowed
+     within an aspect_specification, an operational item, or a
+     representation item that occurs within the declaration of the
+     composite type.
+
+12/3
+   * {AI05-0264-1AI05-0264-1} A name that denotes a noninherited
+     discriminant is allowed within the declaration of the type, but not
+     within the discriminant_part.  If the discriminant is used to
+     define the constraint of a component, the bounds of an entry
+     family, or the constraint of the parent subtype in a
+     derived_type_definition, then its name shall appear alone as a
+     direct_name (not as part of a larger expression or expanded name).
+     A discriminant shall not be used to define the constraint of a
+     scalar component.
+
+12.a
+          Reason: The penultimate restriction simplifies implementation,
+          and allows the outer discriminant and the inner discriminant
+          or bound to possibly share storage.
+
+12.b
+          Ramification: Other rules prevent such a discriminant from
+          being an inherited one.
+
+12.c
+          Reason: The last restriction is inherited from Ada 83.  The
+          restriction is not really necessary from a language design
+          point of view, but we did not remove it, in order to avoid
+          unnecessary changes to existing compilers.
+
+12.d
+          Discussion: Note that a discriminant can be used to define the
+          constraint for a component that is of an access-to-composite
+          type.
+
+12.e/2
+          Reason: {AI95-00373-01AI95-00373-01} The above rules, and a
+          similar one in *note 6.1:: for formal parameters, are intended
+          to allow initializations of components or parameters to occur
+          in a (nearly) arbitrary order -- whatever order is most
+          efficient (subject to the restrictions of *note 3.3.1::),
+          since one default_expression cannot depend on the value of
+          another one.  They also prevent circularities.
+
+12.f/3
+          Ramification: {AI05-0295-1AI05-0295-1} Inherited discriminants
+          are not allowed to be denoted, except within
+          aspect_specifications and representation items.  However, the
+          discriminant_selector_name of the parent subtype_indication is
+          allowed to denote a discriminant of the parent.
+
+13
+If the name of the current instance of a type (see *note 8.6::) is used
+to define the constraint of a component, then it shall appear as a
+direct_name that is the prefix of an attribute_reference whose result is
+of an access type, and the attribute_reference shall appear alone.
+
+13.a
+          Reason: This rule allows T'Access or T'Unchecked_Access, but
+          disallows, for example, a range constraint (1..T'Size).
+          Allowing things like (1..T'Size) would mean that a per-object
+          constraint could affect the size of the object, which would be
+          bad.
+
+                          _Static Semantics_
+
+13.1/3
+{AI95-00318-02AI95-00318-02} {AI05-0004-1AI05-0004-1} If a
+record_type_definition includes the reserved word limited, the type is
+called an explicitly limited record type.
+
+14
+The component_definition of a component_declaration defines the
+(nominal) subtype of the component.  If the reserved word aliased
+appears in the component_definition, then the component is aliased (see
+*note 3.10::).
+
+15
+If the component_list of a record type is defined by the reserved word
+null and there are no discriminants, then the record type has no
+components and all records of the type are null records.  A
+record_definition of null record is equivalent to record null; end
+record.
+
+15.a
+          Ramification: This short-hand is available both for declaring
+          a record type and a record extension -- see *note 3.9.1::.
+
+                          _Dynamic Semantics_
+
+16
+The elaboration of a record_type_definition creates the record type and
+its first subtype, and consists of the elaboration of the
+record_definition.  The elaboration of a record_definition consists of
+the elaboration of its component_list, if any.
+
+17
+The elaboration of a component_list consists of the elaboration of the
+component_items and variant_part, if any, in the order in which they
+appear.  The elaboration of a component_declaration consists of the
+elaboration of the component_definition.
+
+17.a
+          Discussion: If the defining_identifier_list has more than one
+          defining_identifier, we presume here that the transformation
+          explained in *note 3.3.1:: has already taken place.
+          Alternatively, we could say that the component_definition is
+          elaborated once for each defining_identifier in the list.
+
+18/2
+{8652/00028652/0002} {AI95-00171-01AI95-00171-01}
+{AI95-00230-01AI95-00230-01} Within the definition of a composite type,
+if a component_definition or discrete_subtype_definition (see *note
+9.5.2::) includes a name that denotes a discriminant of the type, or
+that is an attribute_reference whose prefix denotes the current instance
+of the type, the expression containing the name is called a per-object
+expression, and the constraint or range being defined is called a
+per-object constraint.  For the elaboration of a component_definition of
+a component_declaration or the discrete_subtype_definition (*note 3.6:
+S0055.) of an entry_declaration (*note 9.5.2: S0218.) for an entry
+family (see *note 9.5.2::), if the component subtype is defined by an
+access_definition or if the constraint or range of the
+subtype_indication or discrete_subtype_definition (*note 3.6: S0055.) is
+not a per-object constraint, then the access_definition,
+subtype_indication, or discrete_subtype_definition (*note 3.6: S0055.)
+is elaborated.  On the other hand, if the constraint or range is a
+per-object constraint, then the elaboration consists of the evaluation
+of any included expression that is not part of a per-object expression.
+Each such expression is evaluated once unless it is part of a named
+association in a discriminant constraint, in which case it is evaluated
+once for each associated discriminant.
+
+18.1/1
+{8652/00028652/0002} {AI95-00171-01AI95-00171-01} When a per-object
+constraint is elaborated [(as part of creating an object)], each
+per-object expression of the constraint is evaluated.  For other
+expressions, the values determined during the elaboration of the
+component_definition (*note 3.6: S0056.) or entry_declaration (*note
+9.5.2: S0218.) are used.  Any checks associated with the enclosing
+subtype_indication or discrete_subtype_definition are performed[,
+including the subtype compatibility check (see *note 3.2.2::),] and the
+associated subtype is created.
+
+18.a
+          Discussion: The evaluation of other expressions that appear in
+          component_definitions and discrete_subtype_definitions is
+          performed when the type definition is elaborated.  The
+          evaluation of expressions that appear as default_expressions
+          is postponed until an object is created.  Expressions in
+          representation items that appear within a composite type
+          definition are evaluated according to the rules of the
+          particular representation item.
+
+     NOTES
+
+19
+     60  A component_declaration with several identifiers is equivalent
+     to a sequence of single component_declarations, as explained in
+     *note 3.3.1::.
+
+20
+     61  The default_expression of a record component is only evaluated
+     upon the creation of a default-initialized object of the record
+     type (presuming the object has the component, if it is in a
+     variant_part -- see *note 3.3.1::).
+
+21
+     62  The subtype defined by a component_definition (see *note 3.6::)
+     has to be a definite subtype.
+
+22
+     63  If a record type does not have a variant_part, then the same
+     components are present in all values of the type.
+
+23
+     64  A record type is limited if it has the reserved word limited in
+     its definition, or if any of its components are limited (see *note
+     7.5::).
+
+24
+     65  The predefined operations of a record type include membership
+     tests, qualification, and explicit conversion.  If the record type
+     is nonlimited, they also include assignment and the predefined
+     equality operators.
+
+25/2
+     66  {AI95-00287-01AI95-00287-01} A component of a record can be
+     named with a selected_component.  A value of a record can be
+     specified with a record_aggregate.
+
+                              _Examples_
+
+26
+Examples of record type declarations:
+
+27
+     type Date is
+        record
+           Day   : Integer range 1 .. 31;
+           Month : Month_Name;
+           Year  : Integer range 0 .. 4000;
+        end record;
+
+28
+     type Complex is
+        record
+           Re : Real := 0.0;
+           Im : Real := 0.0;
+        end record;
+
+29
+Examples of record variables:
+
+30
+     Tomorrow, Yesterday : Date;
+     A, B, C : Complex;
+
+31
+     -- both components of A, B, and C are implicitly initialized to zero 
+
+                        _Extensions to Ada 83_
+
+31.a
+          The syntax rule for component_declaration is modified to use
+          component_definition (instead of
+          component_subtype_definition).  The effect of this change is
+          to allow the reserved word aliased before the
+          component_subtype_definition.
+
+31.b
+          A short-hand is provided for defining a null record type (and
+          a null record extension), as these will be more common for
+          abstract root types (and derived types without additional
+          components).
+
+31.c
+          The syntax rule for record_type_definition is modified to
+          allow the reserved words tagged and limited.  Tagging is new.
+          Limitedness is now orthogonal to privateness.  In Ada 83 the
+          syntax implied that limited private was sort of more private
+          than private.  However, limitedness really has nothing to do
+          with privateness; limitedness simply indicates the lack of
+          assignment capabilities, and makes perfect sense for
+          nonprivate types such as record types.
+
+                     _Wording Changes from Ada 83_
+
+31.d/1
+          {8652/00098652/0009} {AI95-00137-01AI95-00137-01} The syntax
+          rules now allow aspect_clauses to appear in a
+          record_definition.  This is not a language extension, because
+          Legality Rules prevent all language-defined representation
+          clauses from appearing there.  However, an
+          implementation-defined attribute_definition_clause could
+          appear there.  The reason for this change is to allow the
+          rules for aspect_clauses and representation pragmas to be as
+          similar as possible.
+
+                        _Extensions to Ada 95_
+
+31.e/2
+          {AI95-00287-01AI95-00287-01} Record components can have an
+          anonymous access type.
+
+31.f/2
+          {AI95-00287-01AI95-00287-01} Limited components can be
+          initialized, so long as the expression is one that allows
+          building the object in place (such as an aggregate or
+          function_call).
+
+                     _Wording Changes from Ada 95_
+
+31.g/2
+          {8652/00028652/0002} {AI95-00171-01AI95-00171-01} Corrigendum:
+          Improved the description of the elaboration of per-object
+          constraints.
+
+31.h/2
+          {8652/00098652/0009} {AI95-00137-01AI95-00137-01} Corrigendum:
+          Changed representation clauses to aspect clauses to reflect
+          that they are used for more than just representation.
+
+31.i/2
+          {AI95-00318-02AI95-00318-02} Defined explicitly limited record
+          type to use in other rules.
+
+                       _Extensions to Ada 2005_
+
+31.j/3
+          {AI05-0183-1AI05-0183-1} An optional aspect_specification can
+          be used in a component_declaration.  This is described in
+          *note 13.1.1::.
+
+* Menu:
+
+* 3.8.1 ::    Variant Parts and Discrete Choices
+
+
+File: aarm2012.info,  Node: 3.8.1,  Up: 3.8
+
+3.8.1 Variant Parts and Discrete Choices
+----------------------------------------
+
+1
+A record type with a variant_part specifies alternative lists of
+components.  Each variant defines the components for the value or values
+of the discriminant covered by its discrete_choice_list.
+
+1.a
+          Discussion: Discrete_choice_lists and discrete_choices are
+          said to cover values as defined below; which
+          discrete_choice_list covers a value determines which of
+          various alternatives is chosen.  These are used in
+          variant_parts, array_aggregates, and case_statements.
+
+                     _Language Design Principles_
+
+1.b
+          The definition of "cover" in this subclause and the rules
+          about discrete choices are designed so that they are also
+          appropriate for array aggregates and case statements.
+
+1.c
+          The rules of this subclause intentionally parallel those for
+          case statements.
+
+                               _Syntax_
+
+2
+     variant_part ::=
+        case discriminant_direct_name is
+            variant
+           {variant}
+        end case;
+
+3
+     variant ::=
+        when discrete_choice_list =>
+           component_list
+
+4
+     discrete_choice_list ::= discrete_choice {| discrete_choice}
+
+5/3
+     {AI05-0153-3AI05-0153-3} {AI05-0158-1AI05-0158-1} discrete_choice
+     ::= choice_expression | discrete_subtype_indication | 
+     range | others
+
+                        _Name Resolution Rules_
+
+6
+The discriminant_direct_name shall resolve to denote a discriminant
+(called the discriminant of the variant_part) specified in the
+known_discriminant_part of the full_type_declaration that contains the
+variant_part.  The expected type for each discrete_choice in a variant
+is the type of the discriminant of the variant_part.
+
+6.a
+          Ramification: A full_type_declaration with a variant_part has
+          to have a (new) known_discriminant_part; the discriminant of
+          the variant_part cannot be an inherited discriminant.
+
+                           _Legality Rules_
+
+7
+The discriminant of the variant_part shall be of a discrete type.
+
+7.a
+          Ramification: It shall not be of an access type, named or
+          anonymous.
+
+8/3
+{AI05-0153-3AI05-0153-3} The choice_expressions, subtype_indications,
+and ranges given as discrete_choices in a variant_part shall be static.
+The discrete_choice others shall appear alone in a discrete_choice_list,
+and such a discrete_choice_list, if it appears, shall be the last one in
+the enclosing construct.
+
+9
+A discrete_choice is defined to cover a value in the following cases:
+
+10/3
+   * {AI05-0262-1AI05-0262-1} A discrete_choice that is a
+     choice_expression covers a value if the value equals the value of
+     the choice_expression converted to the expected type.
+
+10.1/3
+   * {AI05-0153-3AI05-0153-3} {AI05-0262-1AI05-0262-1} A discrete_choice
+     that is a subtype_indication covers all values (possibly none) that
+     belong to the subtype and that satisfy the static predicate of the
+     subtype (see *note 3.2.4::).
+
+10.a/3
+          Ramification: {AI05-0262-1AI05-0262-1} A dynamic predicate is
+          never allowed in this case (for variants, case_statements, and
+          case_expressions, a subtype with a dynamic predicate isn't
+          static and thus isn't allowed in a discrete_choice, and for a
+          choice in an array_aggregate, a dynamic predicate is
+          explicitly disallowed -- see *note 3.2.4::).
+
+11/3
+   * {AI05-0153-3AI05-0153-3} A discrete_choice that is a range covers
+     all values (possibly none) that belong to the range.
+
+12
+   * The discrete_choice others covers all values of its expected type
+     that are not covered by previous discrete_choice_lists of the same
+     construct.
+
+12.a
+          Ramification: For case_statements, this includes values
+          outside the range of the static subtype (if any) to be covered
+          by the choices.  It even includes values outside the base
+          range of the case expression's type, since values of numeric
+          types (and undefined values of any scalar type?)  can be
+          outside their base range.
+
+13
+A discrete_choice_list covers a value if one of its discrete_choices
+covers the value.
+
+14
+The possible values of the discriminant of a variant_part shall be
+covered as follows:
+
+15/3
+   * {AI05-0153-3AI05-0153-3} {AI05-0188-1AI05-0188-1}
+     {AI05-0262-1AI05-0262-1} If the discriminant is of a static
+     constrained scalar subtype then, except within an instance of a
+     generic unit, each non-others discrete_choice (*note 3.8.1: S0074.)
+     shall cover only values in that subtype that satisfy its predicate,
+     and each value of that subtype that satisfies its predicate shall
+     be covered by some discrete_choice (*note 3.8.1: S0074.) [(either
+     explicitly or by others)];
+
+15.a/3
+          Reason: {AI05-0188-1AI05-0188-1} The exemption for a
+          discriminated type declared in an instance allows the
+          following example:
+
+15.b/3
+               generic
+                  type T is new Integer;
+               package G is
+                  type Rec (Discrim : T) is record
+                     case Discrim is
+                        when -10 .. -1 =>
+                           Foo : Float;
+                        when others =>
+                           null;
+                     end case;
+                  end record;
+               end G;
+
+15.c/3
+               package I is new G (Natural); -- Legal
+
+16/3
+   * {AI05-0264-1AI05-0264-1} If the type of the discriminant is a
+     descendant of a generic formal scalar type, then the variant_part
+     shall have an others discrete_choice;
+
+16.a
+          Reason: The base range is not known statically in this case.
+
+17
+   * Otherwise, each value of the base range of the type of the
+     discriminant shall be covered [(either explicitly or by others)].
+
+18
+Two distinct discrete_choices of a variant_part shall not cover the same
+value.
+
+                          _Static Semantics_
+
+19
+If the component_list of a variant is specified by null, the variant has
+no components.
+
+20
+The discriminant of a variant_part is said to govern the variant_part
+and its variants.  In addition, the discriminant of a derived type
+governs a variant_part and its variants if it corresponds (see *note
+3.7::) to the discriminant of the variant_part.
+
+                          _Dynamic Semantics_
+
+21
+A record value contains the values of the components of a particular
+variant only if the value of the discriminant governing the variant is
+covered by the discrete_choice_list of the variant.  This rule applies
+in turn to any further variant that is, itself, included in the
+component_list of the given variant.
+
+21.1/3
+{AI05-0290-1AI05-0290-1} When an object of a discriminated type T is
+initialized by default, Constraint_Error is raised if no
+discrete_choice_list of any variant of a variant_part of T covers the
+value of the discriminant that governs the variant_part.  When a
+variant_part appears in the component_list of another variant V, this
+test is only applied if the value of the discriminant governing V is
+covered by the discrete_choice_list of V.
+
+21.a/3
+          Implementation Note: This is not a "check"; it cannot be
+          suppressed.  However, in most cases it is not necessary to
+          generate any code to raise this exception.  A test is needed
+          (and can fail) in the case where the discriminant subtype has
+          a Static_Predicate specified, it also has predicate checking
+          disabled, and the discriminant governs a variant_part which
+          lacks a when others choice.
+
+21.b/3
+          The test also could fail for a static discriminant subtype
+          with range checking suppressed and the discriminant governs a
+          variant_part which lacks a when others choice.  But execution
+          is erroneous if a range check that would have failed is
+          suppressed (see *note 11.5::), so an implementation does not
+          have to generate code to check this case.  (An unchecked
+          failed predicate does not cause erroneous execution, so the
+          test is required in that case.)
+
+21.c/3
+          Like the checks associated with a per-object constraint, this
+          test is not made during the elaboration of a
+          subtype_indication.
+
+22
+The elaboration of a variant_part consists of the elaboration of the
+component_list of each variant in the order in which they appear.
+
+                              _Examples_
+
+23
+Example of record type with a variant part:
+
+24
+     type Device is (Printer, Disk, Drum);
+     type State  is (Open, Closed);
+
+25
+     type Peripheral(Unit : Device := Disk) is
+        record
+           Status : State;
+           case Unit is
+              when Printer =>
+                 Line_Count : Integer range 1 .. Page_Size;
+              when others =>
+                 Cylinder   : Cylinder_Index;
+                 Track      : Track_Number;
+              end case;
+           end record;
+
+26
+Examples of record subtypes:
+
+27
+     subtype Drum_Unit is Peripheral(Drum);
+     subtype Disk_Unit is Peripheral(Disk);
+
+28
+Examples of constrained record variables:
+
+29
+     Writer   : Peripheral(Unit  => Printer);
+     Archive  : Disk_Unit;
+
+                        _Extensions to Ada 83_
+
+29.a
+          In Ada 83, the discriminant of a variant_part is not allowed
+          to be of a generic formal type.  This restriction is removed
+          in Ada 95; an others discrete_choice is required in this case.
+
+                     _Wording Changes from Ada 83_
+
+29.b
+          The syntactic category choice is removed.  The syntax rules
+          for variant, array_aggregate, and case_statement now use
+          discrete_choice_list or discrete_choice instead.  The syntax
+          rule for record_aggregate now defines its own syntax for named
+          associations.
+
+29.c/3
+          {AI05-0299-1AI05-0299-1} We have added the term Discrete
+          Choice to the title since this is where they are talked about.
+          This is analogous to the name of the subclause "Index
+          Constraints and Discrete Ranges" in the subclause on Array
+          Types.
+
+29.d
+          The rule requiring that the discriminant denote a discriminant
+          of the type being defined seems to have been left implicit in
+          RM83.
+
+                   _Incompatibilities With Ada 2005_
+
+29.e/3
+          {AI05-0158-1AI05-0158-1} Membership tests are no longer
+          allowed as a discrete_choice, in order that those tests can be
+          expanded to allow multiple tests in a single expression
+          without ambiguity.  Since a membership test has a boolean
+          type, they are very unlikely to be used as a discrete_choice.
+
+                       _Extensions to Ada 2005_
+
+29.f/3
+          {AI05-0153-3AI05-0153-3} Subtypes with static predicates can
+          be used in discrete_choices, and the coverage rules are
+          modified to respect the predicates.
+
+29.g/3
+          {AI05-0188-1AI05-0188-1} Variants in generic specifications
+          are no longer rejected if the subtype of the actual type does
+          not include all of the case choices.  This probably isn't
+          useful, but it is consistent with the treatment of
+          case_expressions.
+
+                    _Wording Changes from Ada 2005_
+
+29.h/3
+          {AI05-0290-1AI05-0290-1} Added a test that some variant covers
+          the value of a discriminant that governs a variant_part.  This
+          is similar to the test that some case limb covers the value of
+          the Selecting_expression of a case_statement.  This test
+          cannot change the behavior of any nonerroneous Ada 2005
+          program, so it is not an inconsistency.
+
+
+File: aarm2012.info,  Node: 3.9,  Next: 3.10,  Prev: 3.8,  Up: 3
+
+3.9 Tagged Types and Type Extensions
+====================================
+
+1
+[ Tagged types and type extensions support object-oriented programming,
+based on inheritance with extension and run-time polymorphism via
+dispatching operations.  ]
+
+                     _Language Design Principles_
+
+1.a/2
+          {AI95-00251-01AI95-00251-01} The intended implementation model
+          is for the static portion of a tag to be represented as a
+          pointer to a statically allocated and link-time initialized
+          type descriptor.  The type descriptor contains the address of
+          the code for each primitive operation of the type.  It
+          probably also contains other information, such as might make
+          membership tests convenient and efficient.  Tags for nested
+          type extensions must also have a dynamic part that identifies
+          the particular elaboration of the type.
+
+1.b
+          The primitive operations of a tagged type are known at its
+          first freezing point; the type descriptor is laid out at that
+          point.  It contains linker symbols for each primitive
+          operation; the linker fills in the actual addresses.
+
+1.b.1/2
+          {AI95-00251-01AI95-00251-01} Primitive operations of type
+          extensions that are declared at a level deeper than the level
+          of the ultimate ancestor from which they are derived can be
+          represented by wrappers that use the dynamic part of the tag
+          to call the actual primitive operation.  The dynamic part
+          would generally be some way to represent the static link or
+          display necessary for making a nested call.  One
+          implementation strategy would be to store that information in
+          the extension part of such nested type extensions, and use the
+          dynamic part of the tag to point at it.  (That way, the
+          "dynamic" part of the tag could be static, at the cost of
+          indirect access.)
+
+1.b.2/2
+          {AI95-00251-01AI95-00251-01} If the tagged type is descended
+          from any interface types, it also will need to include
+          "subtags" (one for each interface) that describe the mapping
+          of the primitive operations of the interface to the primitives
+          of the type.  These subtags could directly reference the
+          primitive operations (for faster performance), or simply
+          provide the tag "slot" numbers for the primitive operations
+          (for easier derivation).  In either case, the subtags would be
+          used for calls that dispatch through a class-wide type of the
+          interface.
+
+1.c
+          Other implementation models are possible.
+
+1.d
+          The rules ensure that "dangling dispatching" is impossible;
+          that is, when a dispatching call is made, there is always a
+          body to execute.  This is different from some other
+          object-oriented languages, such as Smalltalk, where it is
+          possible to get a run-time error from a missing method.
+
+1.e/2
+          {AI95-00251-01AI95-00251-01} Dispatching calls should be
+          efficient, and should have a bounded worst-case execution
+          time.  This is important in a language intended for real-time
+          applications.  In the intended implementation model, a
+          dispatching call involves calling indirect through the
+          appropriate slot in the dispatch table.  No complicated
+          "method lookup" is involved although a call which is
+          dispatching on an interface may require a lookup of the
+          appropriate interface subtag.
+
+1.f
+          The programmer should have the choice at each call site of a
+          dispatching operation whether to do a dispatching call or a
+          statically determined call (i.e.  whether the body executed
+          should be determined at run time or at compile time).
+
+1.g
+          The same body should be executed for a call where the tag is
+          statically determined to be T'Tag as for a dispatching call
+          where the tag is found at run time to be T'Tag.  This allows
+          one to test a given tagged type with statically determined
+          calls, with some confidence that run-time dispatching will
+          produce the same behavior.
+
+1.h
+          All views of a type should share the same type descriptor and
+          the same tag.
+
+1.i
+          The visibility rules determine what is legal at compile time;
+          they have nothing to do with what bodies can be executed at
+          run time.  Thus, it is possible to dispatch to a subprogram
+          whose declaration is not visible at the call site.  In fact,
+          this is one of the primary facts that gives object-oriented
+          programming its power.  The subprogram that ends up being
+          dispatched to by a given call might even be designed long
+          after the call site has been coded and compiled.
+
+1.j
+          Given that Ada has overloading, determining whether a given
+          subprogram overrides another is based both on the names and
+          the type profiles of the operations.
+
+1.k/2
+          {AI95-00401-01AI95-00401-01} When a type extension is
+          declared, if there is any place within its immediate scope
+          where a certain subprogram of the parent or progenitor is
+          visible, then a matching subprogram should override.  If there
+          is no such place, then a matching subprogram should be totally
+          unrelated, and occupy a different slot in the type descriptor.
+          This is important to preserve the privacy of private parts;
+          when an operation declared in a private part is inherited, the
+          inherited version can be overridden only in that private part,
+          in the package body, and in any children of the package.
+
+1.l
+          If an implementation shares code for instances of generic
+          bodies, it should be allowed to share type descriptors of
+          tagged types declared in the generic body, so long as they are
+          not extensions of types declared in the specification of the
+          generic unit.
+
+                          _Static Semantics_
+
+2/2
+{AI95-00345-01AI95-00345-01} A record type or private type that has the
+reserved word tagged in its declaration is called a tagged type.  In
+addition, an interface type is a tagged type, as is a task or protected
+type derived from an interface (see *note 3.9.4::).  [When deriving from
+a tagged type, as for any derived type, additional primitive subprograms
+may be defined, and inherited primitive subprograms may be overridden.]  
+The derived type is called an extension of its ancestor types, or simply
+a type extension.
+
+2.1/2
+{AI95-00345-01AI95-00345-01} Every type extension is also a tagged type,
+and is a record extension or a private extension of some other tagged
+type, or a noninterface synchronized tagged type (see *note 3.9.4::).  A
+record extension is defined by a derived_type_definition with a
+record_extension_part (see *note 3.9.1::)[, which may include the
+definition of additional components].  A private extension, which is a
+partial view of a record extension or of a synchronized tagged type, can
+be declared in the visible part of a package (see *note 7.3::) or in a
+generic formal part (see *note 12.5.1::).
+
+2.a
+          Glossary entry: The objects of a tagged type have a run-time
+          type tag, which indicates the specific type with which the
+          object was originally created.  An operand of a class-wide
+          tagged type can be used in a dispatching call; the tag
+          indicates which subprogram body to invoke.  Nondispatching
+          calls, in which the subprogram body to invoke is determined at
+          compile time, are also allowed.  Tagged types may be extended
+          with additional components.
+
+2.b/2
+          Ramification: {AI95-00218-03AI95-00218-03} If a tagged type is
+          declared other than in a package_specification, it is
+          impossible to add new primitive subprograms for that type,
+          although it can inherit primitive subprograms, and those can
+          be overridden.  If the user incorrectly thinks a certain
+          subprogram is primitive when it is not, and tries to call it
+          with a dispatching call, an error message will be given at the
+          call site.  Similarly, by using an overriding_indicator (see
+          *note 6.1::), the user can declare that a subprogram is
+          intended to be overriding, and get an error message when they
+          made a mistake.  The use of overriding_indicators is highly
+          recommended in new code that does not need to be compatible
+          with Ada 95.
+
+3
+An object of a tagged type has an associated (run-time) tag that
+identifies the specific tagged type used to create the object
+originally.  [ The tag of an operand of a class-wide tagged type T'Class
+controls which subprogram body is to be executed when a primitive
+subprogram of type T is applied to the operand (see *note 3.9.2::);
+using a tag to control which body to execute is called dispatching.]  
+
+4/2
+{AI95-00344-01AI95-00344-01} The tag of a specific tagged type
+identifies the full_type_declaration of the type, and for a type
+extension, is sufficient to uniquely identify the type among all
+descendants of the same ancestor.  If a declaration for a tagged type
+occurs within a generic_package_declaration, then the corresponding type
+declarations in distinct instances of the generic package are associated
+with distinct tags.  For a tagged type that is local to a generic
+package body and with all of its ancestors (if any) also local to the
+generic body, the language does not specify whether repeated
+instantiations of the generic body result in distinct tags.
+
+4.a/2
+          This paragraph was deleted.{AI95-00344-01AI95-00344-01}
+
+4.a.1/2
+          Implementation Note: {AI95-00344-01AI95-00344-01} In most
+          cases, a tag need only identify a particular tagged type
+          declaration, and can therefore be a simple link-time-known
+          address.  However, for tag checks (see *note 3.9.2::) it is
+          essential that each descendant (that currently exists) of a
+          given type have a unique tag.  Hence, for types declared in
+          shared generic bodies where an ancestor comes from outside the
+          generic, or for types declared at a deeper level than an
+          ancestor, the tag needs to be augmented with some kind of
+          dynamic descriptor (which may be a static link, global
+          display, instance descriptor pointer, or combination).  This
+          implies that type Tag may need to be two words, the second of
+          which is normally null, but in these identified special cases
+          needs to include a static link or equivalent.  Within an
+          object of one of these types with a two-word tag, the two
+          parts of the tag would typically be separated, one part as the
+          first word of the object, the second placed in the first
+          extension part that corresponds to a type declared more nested
+          than its parent or declared in a shared generic body when the
+          parent is declared outside.  Alternatively, by using an extra
+          level of indirection, the type Tag could remain a single-word.
+
+4.b/2
+          {AI95-00344-01AI95-00344-01} For types that are not type
+          extensions (even for ones declared in nested scopes), we do
+          not require that repeated elaborations of the same
+          full_type_declaration correspond to distinct tags.  This was
+          done so that Ada 2005 implementations of tagged types could
+          maintain representation compatibility with Ada 95
+          implementations.  Only type extensions that were not allowed
+          in Ada 95 require additional information with the tag.
+
+4.c/2
+          To be honest: {AI95-00344-01AI95-00344-01} The wording "is
+          sufficient to uniquely identify the type among all descendants
+          of the same ancestor" only applies to types that currently
+          exist.  It is not necessary to distinguish between descendants
+          that currently exist, and descendants of the same type that no
+          longer exist.  For instance, the address of the stack frame of
+          the subprogram that created the tag is sufficient to meet the
+          requirements of this rule, even though it is possible, after
+          the subprogram returns, that a later call of the subprogram
+          could have the same stack frame and thus have an identical
+          tag.
+
+5
+The following language-defined library package exists:
+
+6/2
+     {AI95-00362-01AI95-00362-01} package Ada.Tags is
+         pragma Preelaborate(Tags);
+         type Tag is private;
+         pragma Preelaborable_Initialization(Tag);
+
+6.1/2
+     {AI95-00260-02AI95-00260-02}     No_Tag : constant Tag;
+
+7/2
+     {AI95-00400-01AI95-00400-01}     function Expanded_Name(T : Tag) return 
String;
+         function Wide_Expanded_Name(T : Tag) return Wide_String;
+         function Wide_Wide_Expanded_Name(T : Tag) return Wide_Wide_String;
+         function External_Tag(T : Tag) return String;
+         function Internal_Tag(External : String) return Tag;
+
+7.1/2
+     {AI95-00344-01AI95-00344-01}     function Descendant_Tag(External : 
String; Ancestor : Tag) return Tag;
+         function Is_Descendant_At_Same_Level(Descendant, Ancestor : Tag)
+             return Boolean;
+
+7.2/2
+     {AI95-00260-02AI95-00260-02}     function Parent_Tag (T : Tag) return Tag;
+
+7.3/2
+     {AI95-00405-01AI95-00405-01}     type Tag_Array is array (Positive range 
<>) of Tag;
+
+7.4/2
+     {AI95-00405-01AI95-00405-01}     function Interface_Ancestor_Tags (T : 
Tag) return Tag_Array;
+
+7.5/3
+     {AI05-0173-1AI05-0173-1}     function Is_Abstract (T : Tag) return 
Boolean;
+
+8
+         Tag_Error : exception;
+
+9
+     private
+        ... -- not specified by the language
+     end Ada.Tags;
+
+9.a
+          Reason: Tag is a nonlimited, definite subtype, because it
+          needs the equality operators, so that tag checking makes
+          sense.  Also, equality, assignment, and object declaration are
+          all useful capabilities for this subtype.
+
+9.b
+          For an object X and a type T, "X'Tag = T'Tag" is not needed,
+          because a membership test can be used.  However, comparing the
+          tags of two objects cannot be done via membership.  This is
+          one reason to allow equality for type Tag.
+
+9.1/2
+{AI95-00260-02AI95-00260-02} No_Tag is the default initial value of type
+Tag.
+
+9.c/2
+          Reason: {AI95-00260-02AI95-00260-02} This is similar to the
+          requirement that all access values be initialized to null.
+
+10/2
+{AI95-00400-01AI95-00400-01} The function Wide_Wide_Expanded_Name
+returns the full expanded name of the first subtype of the specific type
+identified by the tag, in upper case, starting with a root library unit.
+The result is implementation defined if the type is declared within an
+unnamed block_statement.
+
+10.a
+          To be honest: This name, as well as each prefix of it, does
+          not denote a renaming_declaration.
+
+10.b/2
+          Implementation defined: The result of
+          Tags.Wide_Wide_Expanded_Name for types declared within an
+          unnamed block_statement.
+
+10.1/2
+{AI95-00400-01AI95-00400-01} The function Expanded_Name (respectively,
+Wide_Expanded_Name) returns the same sequence of graphic characters as
+that defined for Wide_Wide_Expanded_Name, if all the graphic characters
+are defined in Character (respectively, Wide_Character); otherwise, the
+sequence of characters is implementation defined, but no shorter than
+that returned by Wide_Wide_Expanded_Name for the same value of the
+argument.
+
+10.c/2
+          Implementation defined: The sequence of characters of the
+          value returned by Tags.Expanded_Name (respectively,
+          Tags.Wide_Expanded_Name) when some of the graphic characters
+          of Tags.Wide_Wide_Expanded_Name are not defined in Character
+          (respectively, Wide_Character).
+
+11
+The function External_Tag returns a string to be used in an external
+representation for the given tag.  The call External_Tag(S'Tag) is
+equivalent to the attribute_reference S'External_Tag (see *note 13.3::).
+
+11.a
+          Reason: It might seem redundant to provide both the function
+          External_Tag and the attribute External_Tag.  The function is
+          needed because the attribute can't be applied to values of
+          type Tag.  The attribute is needed so that it can be specified
+          via an attribute_definition_clause.
+
+11.1/2
+{AI95-00417-01AI95-00417-01} The string returned by the functions
+Expanded_Name, Wide_Expanded_Name, Wide_Wide_Expanded_Name, and
+External_Tag has lower bound 1.
+
+12/2
+{AI95-00279-01AI95-00279-01} The function Internal_Tag returns a tag
+that corresponds to the given external tag, or raises Tag_Error if the
+given string is not the external tag for any specific type of the
+partition.  Tag_Error is also raised if the specific type identified is
+a library-level type whose tag has not yet been created (see *note
+13.14::).
+
+12.a/3
+          Reason: {AI95-00279-01AI95-00279-01} {AI05-0005-1AI05-0005-1}
+          The check for uncreated library-level types prevents a
+          reference to the type before execution reaches the freezing
+          point of the type.  This is important so that T'Class'Input or
+          an instance of Tags.Generic_Dispatching_Constructor do not try
+          to create an object of a type that hasn't been frozen (which
+          might not have yet elaborated its constraints).  We don't
+          require this behavior for non-library-level types as the tag
+          can be created multiple times and possibly multiple copies can
+          exist at the same time, making the check complex.
+
+12.1/3
+{AI95-00344-01AI95-00344-01} {AI05-0113-1AI05-0113-1} The function
+Descendant_Tag returns the (internal) tag for the type that corresponds
+to the given external tag and is both a descendant of the type
+identified by the Ancestor tag and has the same accessibility level as
+the identified ancestor.  Tag_Error is raised if External is not the
+external tag for such a type.  Tag_Error is also raised if the specific
+type identified is a library-level type whose tag has not yet been
+created, or if the given external tag identifies more than one type that
+has the appropriate Ancestor and accessibility level.
+
+12.b/2
+          Reason: Descendant_Tag is used by T'Class'Input to identify
+          the type identified by an external tag.  Because there can be
+          multiple elaborations of a given type declaration,
+          Internal_Tag does not have enough information to choose a
+          unique such type.  Descendant_Tag does not return the tag for
+          types declared at deeper accessibility levels than the
+          ancestor because there could be ambiguity in the presence of
+          recursion or multiple tasks.  Descendant_Tag can be used in
+          constructing a user-defined replacement for T'Class'Input.
+
+12.b.1/3
+          {AI05-0113-1AI05-0113-1} Rules for specifying external tags
+          will usually prevent an external tag from identifying more
+          than one type.  However, an external tag can identify multiple
+          types if a generic body contains a derivation of a tagged type
+          declared outside of the generic, and there are multiple
+          instances at the same accessibility level as the type.  (The
+          Standard allows default external tags to not be unique in this
+          case.)
+
+12.2/2
+{AI95-00344-01AI95-00344-01} The function Is_Descendant_At_Same_Level
+returns True if the Descendant tag identifies a type that is both a
+descendant of the type identified by Ancestor and at the same
+accessibility level.  If not, it returns False.
+
+12.c/2
+          Reason: Is_Descendant_At_Same_Level (or something similar to
+          it) is used by T'Class'Output to determine whether the item
+          being written is at the same accessibility level as T. It may
+          be used to determine prior to using T'Class'Output whether
+          Tag_Error will be raised, and also can be used in constructing
+          a user-defined replacement for T'Class'Output.
+
+12.3/3
+{AI05-0115-1AI05-0115-1} For the purposes of the dynamic semantics of
+functions Descendant_Tag and Is_Descendant_At_Same_Level, a tagged type
+T2 is a descendant of a type T1 if it is the same as T1, or if its
+parent type or one of its progenitor types is a descendant of type T1 by
+this rule[, even if at the point of the declaration of T2, one of the
+derivations in the chain is not visible].
+
+12.c.1/3
+          Discussion: In other contexts, "descendant" is dependent on
+          visibility, and the particular view a derived type has of its
+          parent type.  See *note 7.3.1::.
+
+12.4/3
+{AI95-00260-02AI95-00260-02} The function Parent_Tag returns the tag of
+the parent type of the type whose tag is T. If the type does not have a
+parent type (that is, it was not declared by a
+derived_type_declaration), then No_Tag is returned.
+
+12.d/2
+          Ramification: The parent type is always the parent of the full
+          type; a private extension appears to define a parent type, but
+          it does not (only the various forms of derivation do that).
+          As this is a run-time operation, ignoring privateness is OK.
+
+12.5/3
+{AI95-00405-01AI95-00405-01} The function Interface_Ancestor_Tags
+returns an array containing the tag of each interface ancestor type of
+the type whose tag is T, other than T itself.  The lower bound of the
+returned array is 1, and the order of the returned tags is unspecified.
+Each tag appears in the result exactly once.[ If the type whose tag is T
+has no interface ancestors, a null array is returned.]
+
+12.e/2
+          Ramification: The result of Interface_Ancestor_Tags includes
+          the tag of the parent type, if the parent is an interface.
+
+12.f/2
+          Indirect interface ancestors are included in the result of
+          Interface_Ancestor_Tags.  That's because where an interface
+          appears in the derivation tree has no effect on the semantics
+          of the type; the only interesting property is whether the type
+          has an interface as an ancestor.
+
+12.6/3
+{AI05-0173-1AI05-0173-1} The function Is_Abstract returns True if the
+type whose tag is T is abstract, and False otherwise.
+
+13
+For every subtype S of a tagged type T (specific or class-wide), the
+following attributes are defined:
+
+14
+S'Class
+               S'Class denotes a subtype of the class-wide type (called
+               T'Class in this International Standard) for the class
+               rooted at T (or if S already denotes a class-wide
+               subtype, then S'Class is the same as S).
+
+15
+               S'Class is unconstrained.  However, if S is constrained,
+               then the values of S'Class are only those that when
+               converted to the type T belong to S.
+
+15.a
+          Ramification: This attribute is defined for both specific and
+          class-wide subtypes.  The definition is such that
+          S'Class'Class is the same as S'Class.
+
+15.b
+          Note that if S is constrained, S'Class is only partially
+          constrained, since there might be additional discriminants
+          added in descendants of T which are not constrained.
+
+15.c/2
+          Reason: {AI95-00326-01AI95-00326-01} The Class attribute is
+          not defined for untagged subtypes (except for incomplete types
+          and private types whose full view is tagged -- see *note
+          J.11:: and *note 7.3.1::) so as to preclude implicit
+          conversion in the absence of run-time type information.  If it
+          were defined for untagged subtypes, it would correspond to the
+          concept of universal types provided for the predefined numeric
+          classes.
+
+16
+S'Tag
+               S'Tag denotes the tag of the type T (or if T is
+               class-wide, the tag of the root type of the corresponding
+               class).  The value of this attribute is of type Tag.
+
+16.a
+          Reason: S'Class'Tag equals S'Tag, to avoid generic contract
+          model problems when S'Class is the actual type associated with
+          a generic formal derived type.
+
+17
+Given a prefix X that is of a class-wide tagged type [(after any
+implicit dereference)], the following attribute is defined:
+
+18
+X'Tag
+               X'Tag denotes the tag of X. The value of this attribute
+               is of type Tag.
+
+18.a
+          Reason: X'Tag is not defined if X is of a specific type.  This
+          is primarily to avoid confusion that might result about
+          whether the Tag attribute should reflect the tag of the type
+          of X, or the tag of X. No such confusion is possible if X is
+          of a class-wide type.
+
+18.1/2
+{AI95-00260-02AI95-00260-02} {AI95-00441-01AI95-00441-01} The following
+language-defined generic function exists:
+
+18.2/3
+     {AI05-0229-1AI05-0229-1} generic
+         type T (<>) is abstract tagged limited private;
+         type Parameters (<>) is limited private;
+         with function Constructor (Params : not null access Parameters)
+             return T is abstract;
+     function Ada.Tags.Generic_Dispatching_Constructor
+        (The_Tag : Tag;
+         Params  : not null access Parameters) return T'Class
+        with Convention => Intrinsic;
+     pragma Preelaborate(Generic_Dispatching_Constructor);
+
+18.3/2
+{AI95-00260-02AI95-00260-02} Tags.Generic_Dispatching_Constructor
+provides a mechanism to create an object of an appropriate type from
+just a tag value.  The function Constructor is expected to create the
+object given a reference to an object of type Parameters.
+
+18.b/2
+          Discussion: This specification is designed to make it easy to
+          create dispatching constructors for streams; in particular,
+          this can be used to construct overridings for T'Class'Input.
+
+18.c/2
+          Note that any tagged type will match T (see *note 12.5.1::).
+
+                          _Dynamic Semantics_
+
+19
+The tag associated with an object of a tagged type is determined as
+follows:
+
+20
+   * The tag of a stand-alone object, a component, or an aggregate of a
+     specific tagged type T identifies T.
+
+20.a
+          Discussion: The tag of a formal parameter of type T is not
+          necessarily the tag of T, if, for example, the actual was a
+          type conversion.
+
+21
+   * The tag of an object created by an allocator for an access type
+     with a specific designated tagged type T, identifies T.
+
+21.a
+          Discussion: The tag of an object designated by a value of such
+          an access type might not be T, if, for example, the access
+          value is the result of a type conversion.
+
+22
+   * The tag of an object of a class-wide tagged type is that of its
+     initialization expression.
+
+22.a
+          Ramification: The tag of an object (even a class-wide one)
+          cannot be changed after it is initialized, since a
+          "class-wide" assignment_statement raises Constraint_Error if
+          the tags don't match, and a "specific" assignment_statement
+          does not affect the tag.
+
+23
+   * The tag of the result returned by a function whose result type is a
+     specific tagged type T identifies T.
+
+23.a/2
+          Implementation Note: {AI95-00318-02AI95-00318-02} For a
+          limited tagged type, the return object is "built in place" in
+          the ultimate result object with the appropriate tag.  For a
+          nonlimited type, a new anonymous object with the appropriate
+          tag is created as part of the function return.  See *note
+          6.5::, "*note 6.5:: Return Statements".
+
+24/2
+   * {AI95-00318-02AI95-00318-02} The tag of the result returned by a
+     function with a class-wide result type is that of the return
+     object.
+
+25
+The tag is preserved by type conversion and by parameter passing.  The
+tag of a value is the tag of the associated object (see *note 6.2::).
+
+25.1/3
+{AI95-00260-02AI95-00260-02} {AI95-00344-01AI95-00344-01}
+{AI95-00405-01AI95-00405-01} {AI05-0092-1AI05-0092-1}
+{AI05-0262-1AI05-0262-1} Tag_Error is raised by a call of
+Descendant_Tag, Expanded_Name, External_Tag, Interface_Ancestor_Tags,
+Is_Abstract, Is_Descendant_At_Same_Level, Parent_Tag,
+Wide_Expanded_Name, or Wide_Wide_Expanded_Name if any tag passed is
+No_Tag.
+
+25.2/2
+{AI95-00260-02AI95-00260-02} An instance of
+Tags.Generic_Dispatching_Constructor raises Tag_Error if The_Tag does
+not represent a concrete descendant of T or if the innermost master (see
+*note 7.6.1::) of this descendant is not also a master of the instance.
+Otherwise, it dispatches to the primitive function denoted by the formal
+Constructor for the type identified by The_Tag, passing Params, and
+returns the result.  Any exception raised by the function is propagated.
+
+25.a/2
+          Ramification: The tag check checks both that The_Tag is in
+          T'Class, and that it is not abstract.  These checks are
+          similar to the ones required by streams for T'Class'Input (see
+          *note 13.13.2::).  In addition, there is a check that the tag
+          identifies a type declared on the current dynamic call chain,
+          and not a more nested type or a type declared by another task.
+          This check is not necessary for streams, because the stream
+          attributes are declared at the same dynamic level as the type
+          used.
+
+                         _Erroneous Execution_
+
+25.3/2
+{AI95-00260-02AI95-00260-02} If an internal tag provided to an instance
+of Tags.Generic_Dispatching_Constructor or to any subprogram declared in
+package Tags identifies either a type that is not library-level and
+whose tag has not been created (see *note 13.14::), or a type that does
+not exist in the partition at the time of the call, then execution is
+erroneous.
+
+25.b/2
+          Ramification: One reason that a type might not exist in the
+          partition is that the tag refers to a type whose declaration
+          was elaborated as part of an execution of a subprogram_body
+          which has been left (see *note 7.6.1::).
+
+25.c/2
+          We exclude tags of library-level types from the current
+          execution of the partition, because misuse of such tags should
+          always be detected.  T'Tag freezes the type (and thus creates
+          the tag), and Internal_Tag and Descendant_Tag cannot return
+          the tag of a library-level type that has not been created.
+          All ancestors of a tagged type must be frozen no later than
+          the (full) declaration of a type that uses them, so Parent_Tag
+          and Interface_Ancestor_Tags cannot return a tag that has not
+          been created.  Finally, library-level types never c