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

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

[elpa] master 9014381: Release ada-mode 7.0.1, wisi 3.0.1


From: Stephen Leake
Subject: [elpa] master 9014381: Release ada-mode 7.0.1, wisi 3.0.1
Date: Thu, 30 Jan 2020 08:38:12 -0500 (EST)

branch: master
commit 90143815a5a8f44c5509f54617cdadb1ef810966
Author: Stephen Leake <address@hidden>
Commit: Stephen Leake <address@hidden>

    Release ada-mode 7.0.1, wisi 3.0.1
---
 packages/ada-mode/NEWS                             |    49 +-
 packages/ada-mode/README                           |    45 +-
 packages/ada-mode/ada-build.el                     |   223 +-
 .../{ada-gnat-compile.el => ada-compiler-gnat.el}  |   280 +-
 packages/ada-mode/ada-core.el                      |   762 +
 packages/ada-mode/ada-fix-error.el                 |   237 -
 packages/ada-mode/ada-gnat-xref.el                 |   210 +-
 packages/ada-mode/ada-imenu.el                     |     4 +-
 packages/ada-mode/ada-indent-user-options.el       |    69 +-
 packages/ada-mode/ada-mode-compat.el               |    27 -
 packages/ada-mode/ada-mode.el                      |  2827 +-
 packages/ada-mode/ada-mode.info                    |  1121 +-
 packages/ada-mode/ada-mode.texi                    |  1013 +-
 packages/ada-mode/ada-prj.el                       |     4 -
 packages/ada-mode/ada-process.el                   |     2 +
 packages/ada-mode/ada-project.el                   |   120 -
 packages/ada-mode/ada-skel.el                      |   143 +-
 packages/ada-mode/ada-stmt.el                      |     4 -
 packages/ada-mode/ada-wisi.el                      |   795 -
 packages/ada-mode/ada-xref.el                      |     5 -
 packages/ada-mode/ada.wy                           |   928 +-
 packages/ada-mode/ada_lr1_parse_table.txt.gz       |   Bin 3170831 -> 3555116 
bytes
 packages/ada-mode/ada_mode_wisi_parse.gpr.gp       |    23 +-
 packages/ada-mode/ada_process_actions.adb          |    76 +-
 packages/ada-mode/ada_process_actions.ads          |    28 +-
 packages/ada-mode/ada_process_lalr_main.adb        | 29496 ++++++++++---------
 packages/ada-mode/ada_process_lr1_main.adb         |   715 +-
 packages/ada-mode/ada_re2c.c                       |  3752 +--
 packages/ada-mode/build.sh                         |    15 +-
 packages/ada-mode/dir                              |     8 +-
 packages/ada-mode/gnat-core.el                     |   602 +-
 packages/ada-mode/gpr-indent-user-options.el       |     8 +-
 packages/ada-mode/gpr-mode.el                      |   328 +-
 packages/ada-mode/gpr-mode.info                    |    95 +-
 packages/ada-mode/gpr-mode.texi                    |    88 +-
 packages/ada-mode/gpr-process.el                   |     1 +
 packages/ada-mode/gpr-query.el                     |  1497 +-
 packages/ada-mode/gpr-skel.el                      |   154 +-
 packages/ada-mode/gpr-wisi.el                      |   133 -
 packages/ada-mode/gpr.wy                           |     8 +-
 packages/ada-mode/gpr_process_actions.adb          |    16 +-
 packages/ada-mode/gpr_query.adb                    |   429 +-
 packages/ada-mode/gpr_query.gpr.gp                 |    73 -
 packages/ada-mode/gpr_re2c.c                       |   198 +-
 packages/ada-mode/install.sh                       |    15 +
 packages/ada-mode/wisi-ada.adb                     |    75 +-
 packages/ada-mode/wisi-ada.ads                     |    11 +-
 packages/{wisi/wisi.gpr => ada-mode/wisi.gpr.gp}   |     7 +-
 .../wisitoken-parse-lr-mckenzie_recover-ada.adb    |    36 +-
 packages/ada-mode/xref-ada.el                      |    79 -
 packages/wisi/NEWS                                 |    28 +-
 packages/wisi/README                               |     9 +-
 packages/wisi/build-wisitoken-bnf-generate.sh      |     2 +-
 packages/wisi/emacs_wisi_common_parse.adb          |     8 +-
 packages/wisi/emacs_wisi_common_parse.ads          |     5 +-
 packages/wisi/recover_stats.adb                    |   277 +
 packages/wisi/run_wisi_common_parse.adb            |     8 +-
 packages/wisi/wisi-fringe.el                       |   302 +-
 packages/wisi/wisi-parse-common.el                 |     7 +-
 packages/wisi/wisi-prj.el                          |  1466 +
 packages/wisi/wisi-process-parse.el                |    18 +-
 packages/wisi/wisi-run-indent-test.el              |    67 +-
 packages/wisi/wisi-skel.el                         |   154 +
 packages/wisi/wisi.adb                             |    94 +-
 packages/wisi/wisi.ads                             |    65 +-
 packages/wisi/wisi.el                              |   456 +-
 packages/wisi/{wisi.gpr => wisi.gpr.gp}            |     7 +-
 packages/wisi/wisitoken-bnf-generate.adb           |     2 +-
 packages/wisi/wisitoken-bnf-output_ada_common.adb  |    32 +-
 ...wisitoken-parse-lr-mckenzie_recover-explore.adb |    12 +-
 .../wisi/wisitoken-parse-lr-mckenzie_recover.adb   |    43 +-
 .../wisi/wisitoken-parse-lr-mckenzie_recover.ads   |    15 +-
 packages/wisi/wisitoken-parse-lr-parser.adb        |    21 +-
 packages/wisi/wisitoken-parse-lr-parser.ads        |     2 +
 packages/wisi/wisitoken-parse-lr.ads               |     3 +-
 packages/wisi/wisitoken-parse.adb                  |     9 +-
 packages/wisi/wisitoken-parse.ads                  |    17 +-
 packages/wisi/wisitoken-semantic_checks.ads        |     3 +-
 packages/wisi/wisitoken_grammar_re2c.c             |   186 +-
 79 files changed, 25458 insertions(+), 24694 deletions(-)

diff --git a/packages/ada-mode/NEWS b/packages/ada-mode/NEWS
index 22a55ff..944a7dd 100644
--- a/packages/ada-mode/NEWS
+++ b/packages/ada-mode/NEWS
@@ -1,11 +1,58 @@
 GNU Emacs Ada mode NEWS -- history of user-visible changes.
 
-Copyright (C) 2019 Free Software Foundation, Inc.
+Copyright (C) 2014 - 2020 Free Software Foundation, Inc.
 
 Please send ada-mode bug reports to address@hidden, with
 'ada-mode' in the subject. If possible, use M-x report-emacs-bug.
 
 
+* Ada Mode 7.0.1
+30 Jan 2020
+
+** fix packaging bugs
+
+** build.sh is now split into build.sh and install.sh; the latter
+   takes --prefix and may need to be run as root.
+
+** improve xref integration
+
+* Ada Mode 7.0.0
+19 Dec 2019
+
+** parser Ada language protocol version 3
+
+** Added support for the Ada 2020 features
+   iterated_component_association (ai12-0061), target_name
+   (ai12-0125), delta_aggregate (ai12-0127); these are supported in
+   GNAT Community 2019.
+
+** Major restructuring of code, moving many functions from ada-mode to
+   wisi for use in other language modes, and using cl-defgeneric
+   dispatching instead of function variables. Normal users should see
+   no changes, except that some ada-mode functions will warn about
+   being obsolete. If you've written custom code that depends on
+   ada-mode functions, you may have to change it.
+
+** gpr-mode fully supports auto-casing; new user variables
+   gpr-auto-case, gpr-case-keyword, gpr-case-strict,
+   gpr-case-identifier, respects 'casing' project file settings.
+
+** New commands `wisi-goto-containing-statement-start',
+   `wisi-indent-containing-statement' are in the menu.
+   `wisi-indent-containing-statement' is bound to 'C-c S-i'.
+
+** `ada-goto-declarative-region-start' now goes to the containing
+   region, when the start point is before the 'is' in the current
+   declaration (previously, it went to the declarative region of the
+   current declaration). This is required for adding a use_clause for
+   an identifier/operator in a format_part or aspect_clause.
+
+** Delete not-upper-case setting for ada-auto-case; instead, set
+   ada-case-strict to nil.
+
+** wisi-prj-identifier-at-point (previously ada-identifier-at-point)
+   now handles non-ASCII characters.
+
 * Ada Mode 6.2.1
 17 Aug 2019
 
diff --git a/packages/ada-mode/README b/packages/ada-mode/README
index 7cec70d..ec8c774 100644
--- a/packages/ada-mode/README
+++ b/packages/ada-mode/README
@@ -1,15 +1,31 @@
-Emacs Ada mode version 6.2.1
+Emacs Ada mode version 7.0.1
 
 Ada mode provides auto-casing, fontification, navigation, and
 indentation for Ada source code files.
 
 Cross-reference information output by the compiler is used to provide
-powerful code navigation (jump to definition, find all uses, etc). By
-default, only the AdaCore GNAT compiler is supported; other compilers
-can be supported. Ada mode uses gpr_query to query compiler-generated
-cross reference information. gpr_query is provided as Ada source code
-that must be compiled and installed; see ada-mode.info section
-Installation for instructions.
+powerful code navigation (jump to definition, find all uses, show
+overriding, etc). By default, only the AdaCore GNAT compiler is
+supported; other compilers can be supported. Ada mode uses gpr_query
+to query compiler-generated cross reference information. 
+
+Ada mode uses a parser to provide fontification, navigation, and
+indentation. The parser is implemented in Ada, is fast enough even for very 
+large files (via partial parsing), and recovers from almost all syntax
+errors.
+
+gpr_query and the parser are provided as Ada source code that must be
+compiled and installed:
+
+cd ~/.emacs.d/elpa/ada-mode-i.j.k
+./build.sh
+./install.sh
+
+install.sh can take an option "--prefix=<dir>" to set the installation
+directory.
+
+See ada-mode.info section Installation for more information on
+installing; you may need additional packages.
 
 Ada mode will be automatically loaded when you open a file
 with a matching extension (default *.ads, *.adb).
@@ -17,18 +33,5 @@ with a matching extension (default *.ads, *.adb).
 Ada mode uses project files to define large (multi-directory)
 projects, and to define casing exceptions.
 
-Ada mode uses a parser to provide fontification, navigation, and
-indentation. There are two parsers provided:
-
-- elisp, which can be slow on large files, and does not recover from
-  syntax errors.
-
-- process, which is implemented in Ada, is fast enough for reasonably
-  large files, supports partial parse for very large files (see
-  wisi-partial-parse-threshold), and recovers from almost all syntax
-  errors. The 'process' parser must be compiled; see ada-mode.info
-  section "process parser".
-
-See ada-mode.info for help on using and customizing Ada mode, and
-notes for Ada mode developers.
+See ada-mode.info for help on using and customizing Ada mode.
 
diff --git a/packages/ada-mode/ada-build.el b/packages/ada-mode/ada-build.el
index b978040..7d12dbf 100644
--- a/packages/ada-mode/ada-build.el
+++ b/packages/ada-mode/ada-build.el
@@ -34,7 +34,8 @@
 ;; compiling and running capabilities in Ada mode 4.01, done in 2013 by
 ;; Stephen Leake <address@hidden>.
 
-(require 'ada-mode)
+(require 'ada-core)
+(require 'gnat-core)
 (require 'cl-lib)
 
 ;;;; User customization
@@ -44,10 +45,11 @@
   :group 'ada)
 
 (defcustom ada-build-prompt-prj 'default
-  "Policy for finding a project file when none is currently selected."
+  "Policy for finding a project file when none is currently selected.
+See `ada-build-require-project-file'."
   :type '(choice (const default)
-                (const prompt-default)
-                (const prompt-exist)
+                (const search-prompt)
+                (const prompt)
                 (const error))
   :safe  #'symbolp)
 
@@ -57,26 +59,25 @@
   :safe  #'booleanp)
 
 (defcustom ada-build-check-cmd
-  (concat "${cross_prefix}gnatmake -u -c -gnatc ${gnatmake_opt} 
${full_current} -cargs -I${src_dir} ${comp_opt}")
+  "${cross_prefix}gprbuild -P${gpr_file} -u -c -gnatc ${gprbuild_opt} 
${full_current}"
   "Default command to syntax check a single file.
 Overridden by project variable `check_cmd'."
   :type 'string)
 
 (defcustom ada-build-make-cmd
-  (concat "${cross_prefix}gnatmake -P${gpr_file} -o ${main} ${main} 
${gnatmake_opt} "
-         "-cargs -I${src_dir} ${comp_opt} -bargs ${bind_opt} -largs 
${link_opt}")
+  "${cross_prefix}gprbuild -P${gpr_file} ${main} ${gprbuild_opt} "
   "Default command and link to compile the application.
 Overridden by project variable `make_cmd'."
   :type 'string)
 
-(defcustom ada-build-run-cmd "./${main}"
+(defcustom ada-build-run-cmd "${main}"
   "Default command to run the application, in a spawned shell.
 Overridden by project variable `run_cmd'."
   :type 'string)
 
 ;;;; code
 
-(defun ada-build-replace-vars (cmd-string)
+(defun ada-build-replace-vars (project cmd-string)
   "Recursively expand variable references in CMD-STRING.
 ${var} is a project variable or environment variable, $var an
 environment variable.
@@ -95,11 +96,26 @@ buffer file name including the directory and extension."
          (name (match-string 2 cmd-string))
          value)
 
-      (when (string= name "full_current")
+      (cond
+       ((string= name "full_current")
        (setq value (buffer-file-name)))
 
+       ;; Handle names that are likely to occur in commands.
+       ((string= name "src_dir")
+       (setq value (ada-prj-source-path project)))
+
+       ((or (string= name "gpr_project_path")
+          (string= name "ada_project_path"))
+       (setq value (gnat-compiler-project-path (ada-prj-compiler project))))
+
+       ((string= name "gpr_file")
+       (when (gnat-compiler-gpr-file (ada-prj-compiler project))
+         (setq value (file-name-nondirectory (gnat-compiler-gpr-file 
(ada-prj-compiler project))))))
+
+       )
+
       (when (null value)
-       (setq value (ada-prj-get (intern name))))
+       (setq value (plist-get (ada-prj-plist project) (intern name))))
 
       (when (null value)
        (setq value (getenv name)))
@@ -120,64 +136,48 @@ buffer file name including the directory and extension."
   (substitute-in-file-name cmd-string))
 
 (defun ada-build-default-prj (project)
-  "Add to PROJECT the default properties list for Ada project variables used 
by ada-build."
-  (append
-   project
-   (list
-    'check_cmd       ada-build-check-cmd
-    'main            (when (buffer-file-name)
-                      (file-name-nondirectory
-                       (file-name-sans-extension (buffer-file-name))))
-    'make_cmd        ada-build-make-cmd
-    'run_cmd         ada-build-run-cmd
-    )))
-
-(defun ada-build-select-default-prj ()
-  "Create and select a new default project."
-  (let ((prj-file (expand-file-name "default.adp"))
-       project)
-
-    (when (null (assoc prj-file ada-prj-alist))
-      (setq project (ada-prj-default)) ;; ada-build-default-prj included via 
ada-prj-default-compiler-alist
-
-      (add-to-list 'ada-prj-alist (cons prj-file project))
-      )
-
-    (ada-select-prj-file prj-file)
-  ))
-
-(defun ada-build-find-select-prj-file ()
+  "Add to PROJECT the default project variables used by ada-build."
+  (setf (ada-prj-plist project)
+       (append
+        (ada-prj-plist project)
+        (list
+         'check_cmd       ada-build-check-cmd
+         'main            (when (buffer-file-name)
+                            (file-name-nondirectory
+                             (file-name-sans-extension (buffer-file-name))))
+         'make_cmd        ada-build-make-cmd
+         'run_cmd         ada-build-run-cmd
+         ))))
+
+(defun ada-build-find-select-prj-file (prj)
   "Search for a project file in the current directory, parse and select it.
 The file must have the same basename as the project variable
-`main' or the current buffer if `main' is nil, and extension from
-`ada-prj-file-extensions'.  Returns non-nil if a file is
+`main' in PRJ or the current buffer if `main' is nil, and extension from
+`wisi-prj-file-extensions'.  Returns the project if a file is
 selected, nil otherwise."
   (let* ((base-file-name (file-name-base
-                         (or (ada-prj-get 'main)
+                         (or (and (ada-prj-p prj)
+                                  (plist-get (ada-prj-plist prj) 'main))
                              (file-name-nondirectory (file-name-sans-extension 
(buffer-file-name))))))
         (filename
-         (or
-          (file-name-completion base-file-name
-                                ""
-                                (lambda (name) (member (file-name-extension 
name) ada-prj-file-extensions)))
-
-          (file-name-completion base-file-name
-                                ""
-                                (lambda (name) (member (file-name-extension 
name) ada-prj-file-ext-extra)))))
-       )
+         (file-name-completion base-file-name
+                               ""
+                               (lambda (name) (member (file-name-extension 
name) wisi-prj-file-extensions))))
+        )
     (when filename
-      (ada-parse-prj-file filename)
-      (ada-select-prj-file filename))
+      (let ((default-prj (ada-prj-default (file-name-nondirectory 
(file-name-sans-extension filename)))))
+       (wisi-prj-dtrt-parse-file filename default-prj filename 
default-directory)
+       default-prj))
     ))
 
+;;;###autoload
 (defun ada-build-prompt-select-prj-file ()
-  "Search for a project file, parse and select it.
-The file must have an extension from `ada-prj-file-extensions'.
-Returns non-nil if a file is selected, nil otherwise."
+  "Prompt for a project file, parse and select it.
+The file must have an extension from `wisi-prj-file-extensions'.
+Returns the project if a file is selected, nil otherwise."
   (interactive)
-  (let ((ext (append ada-prj-file-extensions ada-prj-file-ext-extra))
-       filename)
-    (condition-case nil
+  (let (filename)
+    (condition-case-unless-debug nil
        (setq filename
              (read-file-name
               "Project file: " ; prompt
@@ -190,19 +190,38 @@ Returns non-nil if a file is selected, nil otherwise."
                 ;; to the desired file. We just assume the user won't
                 ;; return a directory.
                 (or (file-accessible-directory-p name)
-                    (member (file-name-extension name) ext)))))
+                    (member (file-name-extension name) 
wisi-prj-file-extensions)))))
       (error
        (setq filename nil))
       )
 
-    (when (not (equal "" filename))
-      (ada-parse-prj-file filename)
-      (ada-select-prj-file filename)
-      t)
-    ))
+    (when (and filename
+              (not (equal "" filename)))
+
+      (unless (wisi-prj-find-function-set-p)
+       ;; See comment in ada-build-require-project-file. We also do
+       ;; this here because it may be the first project-related
+       ;; function the user runs.
+       (add-hook 'project-find-functions #'wisi-prj-find-dominating-cached)
+       (add-hook 'xref-backend-functions #'wisi-prj-xref-backend))
+
+      (let ((default-prj (ada-prj-default (file-name-nondirectory 
(file-name-sans-extension filename)))))
+       (wisi-prj-dtrt-parse-file filename default-prj filename 
(file-name-directory filename)))
+      )))
+
+(defun ada-build-create-select-default-prj ()
+  "Create a default project with source-path set current directory, select it."
+  (let* ((prj-file (expand-file-name "default_.adp" default-directory)) ;; we 
assume this does not exist
+        (ada-xref-tool 'gnat) ;; since we are not specifying a gpr file.
+        (project (ada-prj-default default-directory)))
+
+    ;; We use buffer-file-name as the dominating file (nominally the
+    ;; main program), since we assume it exists but the dummy project
+    ;; file does not.
+    (wisi-prj-dtrt-parse-file prj-file project (file-name-nondirectory 
(buffer-file-name)) default-directory)))
 
 (defun ada-build-require-project-file ()
-  "Ensure that a project file is selected.
+  "Ensure that a project file is selected, return the project.
 Action when no project file is currently selected is determined
 by `ada-build-prompt-prj':
 
@@ -211,31 +230,49 @@ the same name as the main file. If not found, use a 
default
 project; no gpr file, current directory only, current file as
 main.
 
-default-prompt - Search for a project file in the current
+search-prompt - Search for a project file in the current
 directory with the same name as the main file. If not found,
-prompt for a project file; error result does not change current
-project.
+prompt for a project file; thow error if user aborts
 
-prompt - Prompt for a project file; error result does not
-change current project.
+prompt - Prompt for a project file; thow error if user aborts.
 
-error - Throw an error (no prompt, no default project)."
-  (unless ada-prj-current-file
-    (cl-ecase ada-build-prompt-prj
-      (default
-       (or (ada-build-find-select-prj-file)
-           (ada-build-select-default-prj)))
+error - Throw an error (no prompt, no default project).
 
-      (default-prompt
-       (or (ada-build-find-select-prj-file)
-           (ada-build-prompt-select-prj-file)))
+'search' means look for a file with an extension in
+`wisi-prj-file-extensions'.
 
-      (prompt
-       (ada-build-prompt-select-prj-file))
+An error result does not change the current project."
+  (let ((prj (project-current)))
 
-      (error
-       (error "no project file selected"))
-      )))
+    (unless (wisi-prj-find-function-set-p)
+      ;; We set project-find-functions, xref-backend-functions here so
+      ;; the user doesn't have to for simple projects. We use
+      ;; 'dominating' to avoid the user actions required by select
+      ;; when switching directories/projects (especially in the
+      ;; ada-mode tutorial), and 'cached' to preserve the value of
+      ;; "main" in the project. An experienced user can change to
+      ;; select/cached as they need to.
+      (add-hook 'project-find-functions #'wisi-prj-find-dominating-cached)
+      (add-hook 'xref-backend-functions #'wisi-prj-xref-backend))
+
+    (unless (ada-prj-p prj)
+      (cl-ecase ada-build-prompt-prj
+       (default
+         (or (setq prj (ada-build-find-select-prj-file prj))
+             (setq prj (ada-build-create-select-default-prj))
+             ))
+
+       (search-prompt
+         (or (setq prj (ada-build-find-select-prj-file prj))
+             (setq prj (ada-build-prompt-select-prj-file))))
+
+       (prompt
+        (setq prj (ada-build-prompt-select-prj-file)))
+
+       (error
+        (user-error "no project file selected"))
+       ))
+    prj))
 
 ;;;; user functions
 
@@ -243,9 +280,12 @@ error - Throw an error (no prompt, no default project)."
   "Run the command in the PRJ-FIELD project variable.
 If CONFIRM or `ada-build-confirm-command' are non-nil, ask for
 user confirmation of the command, using PROMPT."
-  (ada-build-require-project-file)
-  (let ((cmd (ada-prj-get prj-field))
-       (process-environment (cl-copy-list (ada-prj-get 'proc_env))))
+  (let* ((project (ada-build-require-project-file))
+        (cmd (plist-get (ada-prj-plist project) prj-field))
+        (compilation-environment
+         (append
+          (wisi-prj-compile-env project)
+          (wisi-prj-file-env project))))
 
     (unless cmd
       (setq cmd '("")
@@ -254,7 +294,7 @@ user confirmation of the command, using PROMPT."
     (when (or ada-build-confirm-command confirm)
       (setq cmd (read-from-minibuffer (concat prompt ": ") cmd)))
 
-    (compile (ada-build-replace-vars cmd))))
+    (compile (ada-build-replace-vars project cmd))))
 
 ;;;###autoload
 (defun ada-build-check (&optional confirm)
@@ -278,7 +318,10 @@ If CONFIRM is non-nil, prompt for user confirmation of the 
command."
 By default, this compiles and links the new main program.
 If CONFIRM is non-nil, prompt for user confirmation of the command."
   (interactive "P")
-  (ada-prj-put 'main (file-name-nondirectory (file-name-sans-extension 
(buffer-file-name))))
+  (let ((prj (ada-build-require-project-file)))
+    (setf (ada-prj-plist prj)
+         (plist-put (ada-prj-plist prj)
+                    'main (file-name-nondirectory (file-name-sans-extension 
(buffer-file-name))))))
   (ada-build-run-cmd 'make_cmd confirm "make command"))
 
 ;;;###autoload
@@ -292,7 +335,7 @@ If CONFIRM is non-nil, prompt for user confirmation of the 
command."
 (defun ada-build-show-main ()
   "Show current project main program filename."
   (interactive)
-  (message "Ada mode main: %s"(ada-prj-get 'main)))
+  (message "Ada mode main: %s" (plist-get (ada-prj-plist 
(ada-prj-require-prj)) 'main)))
 
 ;;; setup
 (add-to-list 'ada-prj-default-list 'ada-build-default-prj)
diff --git a/packages/ada-mode/ada-gnat-compile.el 
b/packages/ada-mode/ada-compiler-gnat.el
similarity index 77%
rename from packages/ada-mode/ada-gnat-compile.el
rename to packages/ada-mode/ada-compiler-gnat.el
index eb895c3..5663f51 100644
--- a/packages/ada-mode/ada-gnat-compile.el
+++ b/packages/ada-mode/ada-compiler-gnat.el
@@ -1,12 +1,8 @@
-;; ada-gnat-compile.el --- Ada mode compiling functionality provided by 'gnat' 
 -*- lexical-binding:t -*-
-;; Includes related functions, such as gnatprep support.
-;;
-;; These tools are all Ada-specific; use Makefiles for multi-language
-;; GNAT compilation tools.
-;;
+;;; ada-compiler-gnat.el --- Ada mode compiling functionality provided by GNAT 
 -*- lexical-binding:t -*-
+;;;
 ;; GNAT is provided by AdaCore; see http://libre.adacore.com/
 ;;
-;;; Copyright (C) 2012 - 2019  Free Software Foundation, Inc.
+;;; Copyright (C) 2012 - 2020  Free Software Foundation, Inc.
 ;;
 ;; Author: Stephen Leake <address@hidden>
 ;; Maintainer: Stephen Leake <address@hidden>
@@ -32,17 +28,46 @@
 ;; file, based on the file extension.
 ;;
 ;; By default, ada-mode is configured to load this file, so nothing
-;; special needs to done to use it.
+;; special needs to be done to use it.
 
+(require 'ada-core)
 (require 'cl-lib)
 (require 'compile)
 (require 'gnat-core)
-(require 'ada-fix-error)
-
-;;;;; code
+(require 'wisi)
 
 ;;;; compiler message handling
 
+(defconst ada-gnat-predefined-package-alist
+  '(
+    ("a-calend" . "Ada.Calendar")
+    ("a-chahan" . "Ada.Characters.Handling")
+    ("a-comlin" . "Ada.Command_Line")
+    ("a-contai" . "Ada.Containers")
+    ("a-direct" . "Ada.Directories")
+    ("a-except" . "Ada.Exceptions")
+    ("a-ioexce" . "Ada.IO_Exceptions")
+    ("a-finali" . "Ada.Finalization")
+    ("a-numeri" . "Ada.Numerics")
+    ("a-nuflra" . "Ada.Numerics.Float_Random")
+    ("a-stream" . "Ada.Streams")
+    ("a-ststio" . "Ada.Streams.Stream_IO")
+    ("a-string" . "Ada.Strings")
+    ("a-strfix" . "Ada.Strings.Fixed")
+    ("a-strmap" . "Ada.Strings.Maps")
+    ("a-strunb" . "Ada.Strings.Unbounded")
+    ("a-stwiun" . "Ada.Strings.Wide_Unbounded")
+    ("a-textio" . "Ada.Text_IO")
+    ("g-comlin" . "GNAT.Command_Line")
+    ("g-dirope" . "GNAT.Directory_Operations")
+    ("g-socket" . "GNAT.Sockets")
+    ("i-c"      . "Interfaces.C")
+    ("i-cstrin" . "Interfaces.C.Strings")
+    ("interfac" . "Interfaces")
+    ("s-stoele" . "System.Storage_Elements")
+    )
+  "Alist (filename . package name) of GNAT file names for predefined Ada 
packages.")
+
 (defun ada-gnat-compilation-filter ()
   "Filter to add text properties to secondary file references.
 For `compilation-filter-hook'."
@@ -137,9 +162,6 @@ For `compilation-filter-hook'."
   "\"\\([,:;=()|]+\\)\""
   "regexp to extract quoted punctuation in error messages")
 
-(defvar ada-gnat-fix-error-hook nil
-  "For `ada-fix-error-alist'.")
-
 (defun ada-gnat-misspelling ()
   "Return correct spelling from current compiler error, if there are 
corrections offered.
 Prompt user if more than one."
@@ -150,12 +172,14 @@ Prompt user if more than one."
   ;;
   ;; column number can vary, so only check the line number
   (save-excursion
-    (let ((line (progn (beginning-of-line) (nth 1 (compilation--message->loc 
(ada-get-compilation-message)))))
-         done choices)
+    (let* ((start-msg (get-text-property (line-beginning-position) 
'compilation-message))
+          (start-line (nth 1 (compilation--message->loc start-msg)))
+          done choices)
       (while (not done)
        (forward-line 1)
-       (setq done (or (not (ada-get-compilation-message))
-                      (not (equal line (nth 1 (compilation--message->loc 
(ada-get-compilation-message)))))))
+       (let ((msg (get-text-property (line-beginning-position) 
'compilation-message)))
+         (setq done (or (not msg)
+                        (not (equal start-line (nth 1 
(compilation--message->loc msg)))))))
        (when (and (not done)
                   (progn
                     (skip-syntax-forward "^-")
@@ -184,8 +208,7 @@ Prompt user if more than one."
     (match-string 1)
     ))
 
-(defun ada-gnat-fix-error (_msg source-buffer _source-window)
-  "For `ada-gnat-fix-error-hook'."
+(cl-defmethod wisi-compiler-fix-error ((_compiler gnat-compiler) source-buffer)
   (let ((start-pos (point))
        message-column
        result)
@@ -222,9 +245,10 @@ Prompt user if more than one."
             t))
 
          ((looking-at (concat ada-gnat-quoted-name-regexp " is not visible"))
-          (let ((done nil)
-                (file-line-struct (progn (beginning-of-line) 
(ada-get-compilation-message)))
-                pos choices unit-name)
+          (let* ((done nil)
+                 (err-msg (get-text-property (line-beginning-position) 
'compilation-message))
+                 (file-line-struct err-msg)
+                 pos choices unit-name)
             ;; next line may contain a reference to where ident is
             ;; defined; if present, it will have been marked by
             ;; ada-gnat-compilation-filter:
@@ -247,13 +271,14 @@ Prompt user if more than one."
                 ;; 1- because next compilation error is at next line beginning
                 (setq done (not
                             (and
-                             (equal file-line-struct 
(ada-get-compilation-message))
+                             (equal file-line-struct err-msg)
                              (setq pos (next-single-property-change (point) 
'ada-secondary-error nil limit))
                              (< pos limit))))
                 (when (not done)
                   (let* ((item (get-text-property pos 'ada-secondary-error))
                          (unit-file (nth 0 item))
-                         (choice (ada-ada-name-from-file-name unit-file)))
+                         (prj (project-current))
+                         (choice (ada-compiler-ada-name-from-file-name 
(wisi-prj-compiler prj) prj unit-file)))
                     (unless (member choice choices) (push choice choices))
                     (goto-char (1+ pos))
                     (goto-char (1+ (next-single-property-change (point) 
'ada-secondary-error nil limit)))
@@ -461,9 +486,12 @@ Prompt user if more than one."
          ((looking-at (concat "operator for \\(private \\)?type " 
ada-gnat-quoted-name-regexp
                               "\\( defined at " ada-gnat-file-name-regexp 
"\\)?"))
           (let ((type (match-string 2))
-                (package-file (match-string 4)))
+                (package-file (match-string 4))
+                (prj (project-current)))
             (when package-file
-              (setq type (concat (ada-gnat-ada-name-from-file-name 
package-file) "." type)))
+              (setq type (concat
+                          (ada-compiler-ada-name-from-file-name 
(wisi-prj-compiler prj) prj package-file)
+                          "." type)))
             (pop-to-buffer source-buffer)
             (ada-fix-add-use-type type)
           t))
@@ -560,7 +588,7 @@ 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) ;; leaves point before semicolon
+            (wisi-goto-statement-end) ;; leaves point before semicolon
             (forward-char 1)
             (newline-and-indent)
             (insert "pragma Unreferenced (" param ");"))
@@ -590,7 +618,7 @@ Prompt user if more than one."
          ((looking-at "(style) bad capitalization, mixed case required")
           (set-buffer source-buffer)
           (forward-word)
-          (ada-case-adjust-identifier)
+          (wisi-case-adjust-identifier)
           t)
 
          ((looking-at (concat "(style) bad casing of " 
ada-gnat-quoted-name-regexp))
@@ -658,108 +686,110 @@ Prompt user if more than one."
       nil)
     ))
 
-;;;;; setup
-
-(defun ada-gnat-compile-select-prj ()
-  (add-to-list 'ada-fix-error-hook #'ada-gnat-fix-error)
-  (setq ada-prj-show-prj-path 'gnat-prj-show-prj-path)
-  (add-to-list 'completion-ignored-extensions ".ali") ;; gnat library files
-  (add-hook 'ada-syntax-propertize-hook 'ada-gnat-syntax-propertize)
-  (add-hook 'ada-syntax-propertize-hook 'gnatprep-syntax-propertize)
-  (syntax-ppss-flush-cache (point-min));; force re-evaluate with hook.
-
-  ;; There is no common convention for a file extension for gnatprep files.
-  ;;
-  ;; find error locations in .gpr files
-  (setq compilation-search-path (append compilation-search-path (ada-prj-get 
'prj_dir)))
-
-  ;; ‘compilation-environment’ is buffer-local, but the user might
-  ;; delete that buffer. So set both global and local.
-  (let* ((process-environment (ada-prj-get 'proc_env))
-        (gpr-path (getenv "GPR_PROJECT_PATH"))
-        (comp-env (list (concat "GPR_PROJECT_PATH=" gpr-path)))
-        (comp-buf (get-buffer "*compilation*")))
-    (when (buffer-live-p comp-buf)
-      (with-current-buffer comp-buf
-       (setq compilation-environment comp-env)))
-    (set-default 'compilation-environment comp-env)
-    )
-
-  (when (getenv "GPR_PROJECT_PATH")
-    ;; We get here when this is called from
-    ;; ‘compilation-process-setup-function’; ‘process-environment’ is
-    ;; already bound to ‘compilation-environment’. Or when the user
-    ;; has set GPR_PROJECT_PATH in top level ‘process-environment’,
-    ;; which is a mistake on their part.
-    (setenv "GPR_PROJECT_PATH"
-           (mapconcat 'identity
-                      (ada-prj-get 'prj_dir)
-                      (ada-prj-get 'path_sep))))
-
-  ;; must be after indentation engine setup, because that resets the
-  ;; indent function list.
-  (add-hook 'ada-mode-hook 'gnatprep-setup t)
+;;;; generic methods
 
+(cl-defmethod ada-prj-select-compiler ((_compiler gnat-compiler) _project)
+  ;; These can't be in wisi-compiler-select-prj (gnat-compiler),
+  ;; because that is shared with gpr-mode (and maybe others).
   (add-hook 'compilation-filter-hook 'ada-gnat-compilation-filter)
+  (add-hook 'ada-syntax-propertize-hook #'ada-gnat-syntax-propertize)
 
-  ;; ada-mode.el project file parser sets this to other compilers used
-  ;; in the project, so we only add here.
-  (add-to-list 'compilation-error-regexp-alist 'gnat)
+  ;; We should call `syntax-ppss-flush-cache' here, to force ppss with
+  ;; the new hook function. But that must be done in all ada-mode
+  ;; buffers, which is tedious. So we're ignoring it until it becomes
+  ;; a problem; normally, the compiler is selected before any Ada
+  ;; files are visited, so it's not an issue.
   )
 
-(defun ada-gnat-compile-deselect-prj ()
-  (setq ada-fix-error-hook (delete #'ada-gnat-fix-error ada-fix-error-hook))
-  (setq completion-ignored-extensions (delete ".ali" 
completion-ignored-extensions))
-  (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))
-  (syntax-ppss-flush-cache (point-min));; force re-evaluate with hook.
+(cl-defmethod ada-prj-deselect-compiler ((_compiler gnat-compiler) _project)
+  (remove-hook 'ada-syntax-propertize-hook #'ada-gnat-syntax-propertize)
+  (remove-hook 'compilation-filter-hook #'ada-gnat-compilation-filter)
+  )
 
-  ;; Don't need to delete from compilation-search-path; completely
-  ;; rewritten in ada-gnat-compile-select-prj.
-  (setq compilation-environment nil)
+(cl-defmethod ada-compiler-file-name-from-ada-name ((compiler gnat-compiler) 
project ada-name)
+  (let ((result nil))
 
-  (setq ada-mode-hook (delq 'gnatprep-setup ada-mode-hook))
+    (while (string-match "\\." ada-name)
+      (setq ada-name (replace-match "-" t t ada-name)))
 
-  (setq compilation-filter-hook (delete 'ada-gnat-compilation-filter 
compilation-filter-hook))
-  (setq compilation-error-regexp-alist (delete 'gnat 
compilation-error-regexp-alist))
-  )
+    (setq ada-name (downcase ada-name))
 
-(defun ada-gnat-compile ()
-  "Set Ada mode global vars to use `gnat' for compiling."
-  (add-to-list 'ada-prj-file-ext-extra     "gpr")
-  (add-to-list 'ada-prj-parser-alist       '("gpr" . gnat-parse-gpr))
-  (add-to-list 'ada-select-prj-compiler    '(gnat  . 
ada-gnat-compile-select-prj))
-  (add-to-list 'ada-deselect-prj-compiler  '(gnat  . 
ada-gnat-compile-deselect-prj))
-
-  (add-to-list 'ada-prj-parse-one-compiler   (cons 'gnat 
'gnat-prj-parse-emacs-one))
-  (add-to-list 'ada-prj-parse-final-compiler (cons 'gnat 
'gnat-prj-parse-emacs-final))
-
-  (font-lock-add-keywords 'ada-mode
-   ;; gnatprep preprocessor line
-   (list (list "^[ \t]*\\(#.*\n\\)"  '(1 font-lock-preprocessor-face t)))))
-
-(provide 'ada-gnat-compile)
-(provide 'ada-compiler)
-
-(ada-gnat-compile)
-
-(add-to-list
- 'compilation-error-regexp-alist-alist
- '(gnat
-   ;; typical:
-   ;;   cards_package.adb:45:32: expected private type "System.Address"
-   ;;
-   ;; with full path Source_Reference pragma :
-   ;;   d:/maphds/version_x/1773/sbs-abi-dll_lib.ads.gp:39:06: file 
"interfaces_c.ads" not found
-   ;;
-   ;; gnu cc1: (gnatmake can invoke the C compiler)
-   ;;   foo.c:2: `TRUE' undeclared here (not in a function)
-   ;;   foo.c:2 : `TRUE' undeclared here (not in a function)
-   ;;
-   ;; we can't handle secondary errors here, because a regexp can't 
distinquish "message" from "filename"
-   "^\\(\\(.:\\)?[^ :\n]+\\):\\([0-9]+\\)\\s-?:?\\([0-9]+\\)?" 1 3 4))
-
-(unless (default-value 'ada-compiler)
-    (set-default 'ada-compiler 'gnat))
-
-;; end of file
+    (with-current-buffer (gnat-run-buffer project 
(gnat-compiler-run-buffer-name compiler))
+      (gnat-run-no-prj
+       (list
+       "krunch"
+       ada-name
+       ;; "0" means only krunch GNAT library names
+       "0"))
+
+      (goto-char (point-min))
+      (when ada-gnat-debug-run (forward-line 1)); skip  cmd
+      (setq result (buffer-substring-no-properties (line-beginning-position) 
(line-end-position)))
+      )
+    result))
+
+(cl-defmethod ada-compiler-ada-name-from-file-name ((_compiler gnat-compiler) 
_project file-name)
+  (let* ((ada-name (file-name-sans-extension (file-name-nondirectory 
file-name)))
+        (predefined (cdr (assoc ada-name ada-gnat-predefined-package-alist))))
+
+    (if predefined
+        predefined
+      (while (string-match "-" ada-name)
+       (setq ada-name (replace-match "." t t ada-name)))
+      ada-name)))
+
+(cl-defmethod ada-compiler-make-package-body ((compiler gnat-compiler) project 
body-file-name)
+  ;; gnatstub always creates the body in the current directory (in the
+  ;; process where gnatstub is running); the -o parameter may not
+  ;; contain path info. So we bind default-directory here.
+  (let ((start-file (buffer-file-name))
+       (opts (when (gnat-compiler-gnat-stub-opts compiler)
+               (split-string (gnat-compiler-gnat-stub-opts compiler))))
+       (cargs (when (gnat-compiler-gnat-stub-cargs compiler)
+               (append (list "-cargs") (split-string 
(gnat-compiler-gnat-stub-cargs compiler)))))
+       (process-environment
+        (append
+          (wisi-prj-compile-env project)
+          (wisi-prj-file-env project)
+          (copy-sequence process-environment)))
+       )
+
+    ;; Make sure all relevant files are saved to disk.
+    (save-some-buffers t)
+
+    (with-current-buffer (gnat-run-buffer compiler 
(gnat-compiler-run-buffer-name compiler))
+      (let ((default-directory (file-name-directory body-file-name)))
+       (gnat-run-gnat
+        project
+        "stub"
+        (append opts (list start-file) cargs))
+
+       (find-file body-file-name)
+       (indent-region (point-min) (point-max))
+       (save-buffer)))
+    nil))
+
+(defun ada-gnat-syntax-propertize (start end)
+  (goto-char start)
+  (save-match-data
+    (while (re-search-forward
+           (concat
+            "[^a-zA-Z0-9)]\\('\\)\\[[\"a-fA-F0-9]+\"\\]\\('\\)"; 1, 2: 
non-ascii character literal, not attributes
+            "\\|\\(\\[\"[a-fA-F0-9]+\"\\]\\)"; 3: non-ascii character in 
identifier
+            )
+           end t)
+      (cond
+       ((match-beginning 1)
+       (put-text-property
+        (match-beginning 1) (match-end 1) 'syntax-table '(7 . ?'))
+       (put-text-property
+        (match-beginning 2) (match-end 2) 'syntax-table '(7 . ?')))
+
+       ((match-beginning 3)
+       (put-text-property
+        (match-beginning 3) (match-end 3) 'syntax-table '(2 . nil)))
+       )
+      )))
+
+(provide 'ada-compiler-gnat)
+;; ada-compiler-gnat.el ends here
diff --git a/packages/ada-mode/ada-core.el b/packages/ada-mode/ada-core.el
new file mode 100644
index 0000000..4157664
--- /dev/null
+++ b/packages/ada-mode/ada-core.el
@@ -0,0 +1,762 @@
+;;; ada-core.el --- core facilities for ada-mode -*- lexical-binding:t -*-
+
+;; Copyright (C) 1994, 1995, 1997 - 2017, 2019 - 2020  Free Software 
Foundation, Inc.
+;;
+;; Author: Stephen Leake <address@hidden>
+;; Maintainer: Stephen Leake <address@hidden>
+;;
+;; This file is part of GNU Emacs.
+;;
+;; GNU Emacs is free software: you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation, either version 3 of the License, or
+;; (at your option) any later version.
+;;
+;; GNU Emacs is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;; GNU General Public License for more details.
+;;
+;; You should have received a copy of the GNU General Public License
+;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
+
+(require 'compile)
+(require 'find-file)
+(require 'uniquify-files)
+(require 'wisi)
+(require 'wisi-prj)
+
+;;;; misc
+
+(defgroup ada nil
+  "Major mode for editing Ada source code in Emacs."
+  :group 'languages)
+
+(defcustom ada-fix-sort-context-clause t
+  "*If non-nil, sort context clause when inserting `with'"
+  :type 'boolean
+  :group 'ada)
+
+(defconst ada-operator-re
+  
"\\+\\|-\\|/\\|\\*\\*\\|\\*\\|=\\|&\\|\\_<\\(abs\\|mod\\|rem\\|and\\|not\\|or\\|xor\\)\\_>\\|<=\\|<\\|>=\\|>"
+  "Regexp matching Ada operator_symbol.")
+
+(defconst ada-name-regexp
+  "\\(\\(?:\\sw\\|[_.]\\)+\\)")
+
+(defvar ada-compiler 'gnat
+  "Default Ada compiler; can be overridden in project files.
+Values defined by compiler packages.")
+
+(defvar ada-syntax-propertize-hook nil
+  "Hook run from `ada-syntax-propertize'.
+Called by `syntax-propertize', which is called by font-lock in
+`after-change-functions'.")
+
+(defun ada-declarative-region-start-p (cache)
+  "Return t if cache is a keyword starting a declarative region."
+  (memq (wisi-cache-token cache) '(DECLARE IS PRIVATE))
+  ;; IS has a cache only if start of declarative region
+  )
+
+(defun ada-goto-declarative-region-start ()
+  "Goto start of declarative region containing point."
+  (interactive)
+  (wisi-validate-cache (point-min) (point-max) t 'navigate)
+
+  (let ((done nil)
+       (start-pos (point))
+       (outermost nil)
+       (cache (or (wisi-get-cache (point))
+                  (wisi-backward-cache))))
+
+    ;; We use backward-cache, not forward-cache, to handle the case
+    ;; where point is in the whitespace or comment before a block; we
+    ;; want the containing block, not the next block.
+    ;;
+    ;; The typical use case for calling this fuction is to add a
+    ;; use_clause for an identifier/operator at start-pos.
+
+    (when cache ;; nil at bob
+      (while (not done)
+       (unless (wisi-cache-containing cache)
+         (setq outermost t))
+
+       (if (ada-declarative-region-start-p cache)
+           (if (< (point) start-pos)
+               (progn
+                 (forward-word);; past 'is'
+                 (setq done t))
+
+             ;; test/ada_mode-nominal.adb function F2
+             ;;
+             ;; start-point is in a formal_part or aspect_clause; we
+             ;; want the next level up.
+             (if outermost
+                 ;; there is no next level up; add the use_clause in the 
context_clause.
+                 (progn
+                   (setq cache (wisi-goto-containing cache))
+                   (setq done t))
+
+             (setq cache (wisi-goto-containing cache))
+             (setq cache (wisi-goto-containing cache))))
+
+         (cl-case (wisi-cache-class cache)
+           (motion
+            (setq cache (wisi-goto-containing cache)));; statement-start
+
+           (statement-end
+            (setq cache (wisi-goto-containing cache)) ;; statement-start
+            (cl-case (wisi-cache-nonterm cache)
+              ((generic_package_declaration
+                package_declaration
+                entry_body package_body package_declaration protected_body 
subprogram_body task_body
+                protected_type_declaration single_protected_declaration 
single_task_declaration task_type_declaration)
+               ;; This is a block scope before the starting point; we want the 
containing scope
+               (setq cache (wisi-goto-containing cache)))
+
+              (t
+               nil)
+              ))
+
+           (statement-start
+            (cl-case (wisi-cache-nonterm cache)
+              (generic_package_declaration
+               (setq cache (wisi-next-statement-cache cache)) ;; 'package'
+               (setq cache (wisi-next-statement-cache cache))) ;; 'is'
+
+              (package_declaration
+               (setq cache (wisi-next-statement-cache cache))) ;; 'is'
+
+              ((entry_body package_body protected_body subprogram_body 
task_body)
+               (while (not (eq 'IS (wisi-cache-token cache)))
+                 (setq cache (wisi-next-statement-cache cache))))
+
+              ((protected_type_declaration single_protected_declaration 
single_task_declaration task_type_declaration)
+               (while (not (eq 'IS (wisi-cache-token cache)))
+                 (setq cache (wisi-next-statement-cache cache)))
+               (when (looking-at "\<new\>")
+                 (while (not (eq 'WITH (wisi-cache-token cache)))
+                   (setq cache (wisi-next-statement-cache cache)))))
+
+              (t
+               (setq cache (wisi-goto-containing cache t)))
+              ))
+
+           (t
+            (setq cache (wisi-goto-containing cache t)))
+           )))
+      )))
+
+;;;; additional ada-compiler generic interfaces
+
+(cl-defgeneric ada-compiler-file-name-from-ada-name (compiler project ada-name)
+  "Return the filename that would contain the library level ADA-NAME.")
+
+(defun ada-file-name-from-ada-name (ada-name)
+  "Return the filename in which ADA-NAME is found."
+  (let ((project (ada-prj-require-prj)))
+    (ada-compiler-file-name-from-ada-name (ada-prj-compiler project) project 
ada-name)))
+
+(cl-defgeneric ada-compiler-ada-name-from-file-name (compiler project 
file-name)
+  "Return the Ada library unit name that should be found in FILE-NAME.")
+
+(cl-defgeneric ada-compiler-make-package-body (compiler project body-file-name)
+  "Create a package body skeleton from a package spec.
+BODY-FILE-NAME is the file name of the body file. Current buffer
+is the package spec.")
+
+(defun ada-make-package-body (body-file-name)
+  (let ((prj (ada-prj-require-prj)))
+    (ada-compiler-make-package-body (ada-prj-compiler prj)
+                                   prj
+                                   (expand-file-name body-file-name))))
+
+;;;; refactor
+
+;; Refactor actions; must match wisi-ada.adb Refactor
+(defconst ada-refactor-method-object-to-object-method 1)
+(defconst ada-refactor-object-method-to-method-object 2)
+
+(defconst ada-refactor-element-object-to-object-index 3)
+(defconst ada-refactor-object-index-to-element-object 4)
+
+(defconst ada-refactor-format-paramlist 5)
+
+(defun ada-refactor (action)
+  (wisi-validate-cache (line-end-position -7) (line-end-position 7) t 
'navigate)
+  (save-excursion
+    (skip-syntax-backward "w_.\"")
+    (let* ((edit-begin (point))
+          (cache (wisi-goto-statement-start))
+          (parse-begin (point))
+          (parse-end (wisi-cache-end cache)))
+      (if parse-end
+         (setq parse-end (+ parse-end (wisi-cache-last (wisi-get-cache 
(wisi-cache-end cache)))))
+       ;; else there is a syntax error; missing end of statement
+       (setq parse-end (point-max)))
+      (wisi-refactor wisi--parser action parse-begin parse-end edit-begin)
+      )))
+
+(defun ada-refactor-1 ()
+  "Refactor Method (Object) => Object.Method.
+Point must be in Method."
+  (interactive)
+  (ada-refactor ada-refactor-method-object-to-object-method))
+
+(defun ada-refactor-2 ()
+  "Refactor Object.Method => Method (Object).
+Point must be in Object.Method."
+  (interactive)
+  (ada-refactor ada-refactor-object-method-to-method-object))
+
+(defun ada-refactor-3 ()
+  "Refactor Element (Object, Index) => Object (Index).
+Point must be in Element"
+  (interactive)
+  (ada-refactor ada-refactor-element-object-to-object-index))
+
+(defun ada-refactor-4 ()
+  "Refactor Object (Index) => Element (Object, Index).
+Point must be in Object"
+  (interactive)
+  (ada-refactor ada-refactor-object-index-to-element-object))
+
+;; refactor-5 in ada-format-paramlist below
+
+(defcustom ada-language-version 'ada2012
+  ;; ada-fix-error.el needs this.
+  "Ada language version; one of `ada83', `ada95', `ada2005', `ada2012'.
+Only affects the keywords to highlight, not which version the
+parser accepts; the parser always accepts a superset of ada2012."
+  :type '(choice (const ada83)
+                (const ada95)
+                (const ada2005)
+                (const ada2012))
+  :safe  #'symbolp)
+(make-variable-buffer-local 'ada-language-version)
+
+(defun ada-in-case-expression ()
+  "Return non-nil if point is in a case expression."
+  (save-excursion
+    ;; Used by ada-align; we know we are in a paren.
+    (wisi-goto-open-paren 1)
+    (while (forward-comment 1))
+    (looking-at "case")))
+
+(defun ada-align ()
+  "If region is active, apply `align'. If not, attempt to align
+current construct."
+  (interactive)
+  (if (use-region-p)
+      (progn
+        (align (region-beginning) (region-end))
+        (deactivate-mark))
+
+    ;; else see if we are in a construct we know how to align
+    (let ((parse-result (syntax-ppss)))
+      (cond
+       ((ada-in-paramlist-p parse-result)
+        (ada-format-paramlist))
+
+       ((and
+        (wisi-in-paren-p parse-result)
+        (ada-in-case-expression))
+       ;; align '=>'
+       (let* ((begin (nth 1 parse-result))
+              (end   (scan-lists begin 1 0)))
+         (align begin end 'entire)))
+
+       (t
+       (align-current))
+       ))))
+
+(defun ada-in-paramlist-p (parse-result)
+  "Return t if point is inside the parameter-list of a subprogram declaration.
+PARSE-RESULT must be the result of `syntax-ppss'."
+  (wisi-validate-cache (point-min) (point-max) nil 'navigate)
+  ;; (info "(elisp)Parser State" "*syntax-ppss*")
+  (let (cache)
+    (and (> (nth 0 parse-result) 0)
+        ;; cache is nil if the parse failed
+        (setq cache (wisi-get-cache (nth 1 parse-result)))
+        (eq 'formal_part (wisi-cache-nonterm cache)))
+    ))
+
+(defun ada-format-paramlist ()
+  "Reformat the parameter list point is in."
+  (interactive)
+  (condition-case nil
+      (wisi-goto-open-paren)
+    (error
+     (user-error "Not in parameter list")))
+  (funcall indent-line-function); so new list is indented properly
+  (when (not (looking-back "^[ \t]*" (line-beginning-position)))
+    (delete-horizontal-space)
+    (insert " "))
+  (ada-refactor ada-refactor-format-paramlist))
+
+;;;; fix compiler errors
+(defun ada-fix-context-clause ()
+  "Return the region containing the context clause for the current buffer,
+excluding leading pragmas."
+  (wisi-validate-cache (point-min) (point-max) t 'navigate)
+  (save-excursion
+    (goto-char (point-min))
+    (let ((begin nil)
+         (end nil)
+         cache)
+
+      (while (not end)
+       (setq cache (wisi-forward-cache))
+       (cl-case (wisi-cache-nonterm cache)
+         (pragma_g (wisi-goto-end-1 cache))
+         (use_clause (wisi-goto-end-1 cache))
+         (with_clause
+          (when (not begin)
+            (setq begin (line-beginning-position)))
+          (wisi-goto-end-1 cache))
+         (t
+          ;; start of compilation unit
+          (setq end (line-beginning-position))
+          (unless begin
+            (setq begin end)))
+         ))
+      (cons begin end)
+    )))
+
+(defun ada-fix-sort-context-pred (a b)
+  "Predicate for `sort-subr'; sorts \"limited with\", \"private with\" last.
+Returns non-nil if a should preceed b in buffer."
+  ;; a, b are buffer ranges in the current buffer
+  (cl-flet
+      ((starts-with
+       (pat reg)
+       (string= pat (buffer-substring-no-properties (car reg)
+                                                    (min (point-max)
+                                                         (+(car reg) (length 
pat)))))))
+    (cond
+     ((and
+       (starts-with "limited with" a)
+       (starts-with "private with" b))
+      t)
+
+     ((and
+       (starts-with "limited with" a)
+       (not (starts-with "limited with" b)))
+      nil)
+
+     ((and
+       (not (starts-with "limited with" a))
+       (starts-with "limited with" b))
+      t)
+
+     ((and
+       (starts-with "private with" a)
+       (not (starts-with "private with" b)))
+      nil)
+
+     ((and
+       (not (starts-with "private with" a))
+       (starts-with "private with" b))
+      t)
+
+     (t
+      (> 0 (compare-buffer-substrings
+           nil (car a) (cdr a)
+           nil (car b) (cdr b))) )
+     )))
+
+(defun ada-fix-sort-context-clause (beg end)
+  "Sort context clauses in range BEG END."
+  (save-excursion
+    (save-restriction
+      (narrow-to-region beg end)
+      (goto-char (point-min))
+      (sort-subr nil 'forward-line 'end-of-line nil nil 
'ada-fix-sort-context-pred)
+      )))
+
+(defun ada-fix-add-with-clause (package-name)
+  "Add a with_clause for PACKAGE_NAME.
+If ada-fix-sort-context-clause, sort the context clauses using
+sort-lines."
+  (let ((context-clause (ada-fix-context-clause)))
+    (when (not context-clause)
+      (error "no compilation unit found"))
+
+    (goto-char (cdr context-clause))
+    (insert "with ")
+    (ada-fix-insert-unit-name package-name)
+    (insert ";\n")
+
+    (when (and (< (car context-clause) (cdr context-clause))
+              ada-fix-sort-context-clause)
+      (ada-fix-sort-context-clause (car context-clause) (point)))
+    ))
+
+(defun ada-fix-extend-with-clause (child-name)
+  "Assuming point is in a selected name, just before CHILD-NAME, add or
+extend a with_clause to include CHILD-NAME  .  "
+  (let ((parent-name-end (point)))
+    ;; Find the full parent name; skip back to whitespace, then match
+    ;; the name forward.
+    (skip-syntax-backward "w_.")
+    (search-forward-regexp ada-name-regexp parent-name-end)
+    (let ((parent-name (match-string 0))
+         (context-clause (ada-fix-context-clause)))
+      (goto-char (car context-clause))
+      (if (search-forward-regexp (concat "^with " parent-name ";") (cdr 
context-clause) t)
+         ;; found exisiting 'with' for parent; extend it
+         (progn
+           (forward-char -1) ; skip back over semicolon
+           (insert "." child-name))
+
+       ;; not found; we are in a package body, with_clause for parent is in 
spec.
+       ;; insert a new one
+       (ada-fix-add-with-clause (concat parent-name "." child-name)))
+      )))
+
+(defun ada-fix-insert-unit-name (unit-name)
+  "Insert UNIT-NAME at point and capitalize it."
+  ;; unit-name is normally gotten from a file-name, and is thus all lower-case.
+  (let ((start-point (point))
+        search-bound)
+    (insert unit-name)
+    (setq search-bound (point))
+    (insert " ") ; separate from following words, if any, for 
wisi-case-adjust-identifier
+    (goto-char start-point)
+    (while (search-forward "." search-bound t)
+      (forward-char -1)
+      (wisi-case-adjust-identifier)
+      (forward-char 1))
+    (goto-char search-bound)
+    (wisi-case-adjust-identifier)
+    (delete-char 1)))
+
+(defun ada-fix-add-use-type (type)
+  "Insert `use type' clause for TYPE at start of declarative part for current 
construct."
+  (ada-goto-declarative-region-start); leaves point after 'is'
+  (newline-and-indent)
+  (cl-ecase ada-language-version
+    (ada2012
+     (insert "use all type "))
+    ((ada83 ada95 ada2005)
+     (insert "use type ")))
+  (let ((begin (point))
+       end)
+    (insert type ";")
+    (setq end (point))
+    (goto-char begin)
+    (while (< (point) end)
+      (wisi-case-adjust-at-point)
+      (forward-char 1))
+    ))
+
+(defun ada-fix-add-use (package)
+  "Insert `use' clause for PACKAGE at start of declarative part for current 
construct."
+  (ada-goto-declarative-region-start); leaves point after 'is'
+  (newline-and-indent)
+  (insert "use " package ";"))
+
+;;;; xref
+
+(defvar ada-xref-tool (if (locate-file "gpr_query" exec-path '("" ".exe")) 
'gpr_query 'gnat)
+  "Default Ada cross reference tool; can be overridden in project files.")
+
+(defconst ada-xref-known-tools '(gpr_query gnat)
+  "Supported xref tools")
+
+(defun ada-make-subprogram-body ()
+  "Convert subprogram specification after point into a subprogram body stub."
+  (interactive)
+  (wisi-goto-statement-start)
+  ;; point is at start of subprogram specification;
+  ;; wisi-parse-expand-region will find the terminal semicolon.
+  (wisi-validate-cache (point-min) (point-max) t 'navigate)
+
+  (let* ((begin (point))
+        (end (wisi-cache-end (wisi-get-cache (point))))
+        (name (wisi-next-name)))
+    (goto-char end)
+    (newline)
+    (insert " is begin\n\nend ");; legal syntax; parse does not fail
+    (insert name)
+    (forward-char 1)
+
+    ;; newline after body to separate from next body
+    (newline-and-indent)
+    (indent-region begin (point))
+    (forward-line -2)
+    (back-to-indentation)
+    ))
+
+(defun ada-ff-create-body ()
+  ;; ff-find-other-file calls this with point in an empty buffer for
+  ;; the body file; ada-make-package-body expects to be in the
+  ;; spec. So go back to the spec, and delete the body buffer so it
+  ;; does not get written to disk.
+  (let ((body-buffer (current-buffer))
+       (body-file-name (buffer-file-name))
+       (prj (ada-prj-require-prj)))
+
+    (set-buffer-modified-p nil);; may have a skeleton; allow silent delete
+
+    (ff-find-the-other-file);; back to spec
+
+    (kill-buffer body-buffer)
+
+    (ada-compiler-make-package-body (ada-prj-compiler prj) prj body-file-name)
+
+    ;; back to the new body file, read in from the disk.
+    (ff-find-the-other-file)
+    (revert-buffer t t))
+  )
+
+;;;; project files
+
+(cl-defstruct
+    (ada-prj
+     (:include wisi-prj)
+     (:copier nil)
+     (:constructor nil)
+     (:constructor make-ada-prj
+                  (&key
+                   name
+                   compile-env
+                   (compiler-label ada-compiler)
+                   (xref-label ada-xref-tool)
+                   source-path
+                   plist
+                   file-pred
+                   &aux
+                   (compiler (ada-prj-make-compiler compiler-label))
+                   (xref (ada-prj-make-xref xref-label))
+                   (compile-env (ada-prj-check-env compile-env))
+                   )))
+  compiler-label
+  xref-label
+  ;; save labels for wisi-prj-default
+
+  plist    ;; user-declared project variables; also obj_dir, mostly as an 
example.
+  )
+
+;;;###autoload
+(cl-defun create-ada-prj
+    (&key
+     name
+     compile-env
+     (compiler-label ada-compiler)
+     (xref-label ada-xref-tool)
+     source-path
+     plist
+     file-pred)
+  ;; We declare and autoload this because we can't autoload
+  ;; make-ada-prj in emacs < 27. We can't use '(defalias
+  ;; 'create-ada-prj 'make-ada-prj); then make-ada-prj is not defined
+  ;; by autoload.
+  (make-ada-prj
+   :name name
+   :compile-env compile-env
+   :compiler-label compiler-label
+   :xref-label xref-label
+   :source-path source-path
+   :plist plist
+   :file-pred file-pred))
+
+(defun ada-prj-check-env (env)
+  "Check that ENV has the proper structure; list of \"NAME=VALUE\".
+Return ENV."
+  ;; Previous versions used ("NAME" . "VALUE"), which screws up.
+  (let ((err-msg "env is not list of \"NAME=VALUE\"."))
+    (unless (listp env)
+      (error err-msg))
+    (dolist (item env)
+      (unless (stringp item)
+       (error err-msg))))
+  env)
+
+(defvar ada-prj-default-list nil
+  ;; This is used by ada-build.el; we keep it to allow other similar
+  ;; uses.
+  "List of functions to add default project variables. Called
+with one argument; the project. `default-directory' is set to the
+directory containing the project file. Function should update the
+project.")
+
+;;;###autoload
+(defun ada-prj-default (&optional name src-dir)
+  "Return the default `ada-prj' object.
+If SRC-DIR is non-nil, use it as the default for project.source-path."
+  (let ((project
+        (make-ada-prj
+         :name (or name "_default_")
+         :compiler-label  ada-compiler
+         :xref-label      ada-xref-tool
+         :source-path    (cond
+                          ((null src-dir) nil)
+                          ((listp src-dir) src-dir)
+                          (t (list src-dir)))
+         )))
+
+    (cl-dolist (func ada-prj-default-list)
+      (funcall func project))
+
+    project))
+
+(cl-defmethod wisi-prj-default ((prj ada-prj))
+  (let ((project
+        (make-ada-prj
+         :name           (wisi-prj-name prj)
+         :compile-env    (wisi-prj-compile-env prj)
+         :compiler-label (ada-prj-compiler-label prj)
+         :xref-label     (ada-prj-xref-label prj)
+         )))
+
+    (cl-dolist (func ada-prj-default-list)
+      (funcall func project))
+
+    project))
+
+;;;###autoload
+(defun ada-prj-make-compiler (label)
+  ;; We use the autoloaded constructor here
+  (require (intern (format "ada-compiler-%s" (symbol-name label))))
+  (funcall (intern (format "create-%s-compiler" (symbol-name label)))))
+
+(defun ada-prj-make-xref (label)
+  ;; We use the autoloaded constructor here
+  (funcall (intern (format "create-%s-xref" (symbol-name label))))
+  ;; So far the only ada xref we have is gpr_query, which uses a
+  ;; gnat-compiler object, so no new require here.
+  )
+
+(defun ada-prj-require-prj ()
+  "Return current `ada-prj' object.
+Throw an error if current project is not an ada-prj."
+  (let ((prj (project-current)))
+    (if (ada-prj-p prj)
+       prj
+      (error "current project is not an ada project."))))
+
+(cl-defmethod wisi-prj-parse-one :after (project name value)
+  (cond
+   ;; variable name alphabetical order
+   ((string= name "ada_compiler")
+    (let ((comp (intern value)))
+      (setf (ada-prj-compiler project) (ada-prj-make-compiler comp))))
+
+   ((string= name "obj_dir")
+    (let ((obj-dir (plist-get (ada-prj-plist project) 'obj_dir)))
+      (cl-pushnew (file-name-as-directory (expand-file-name value))
+                 obj-dir :test #'equal)
+      (setf (ada-prj-plist project) (plist-put (ada-prj-plist project) 
'obj_dir obj-dir))
+      ))
+
+   ((string= name "xref_tool")
+    ;; This is defined here, rather than in wisi, because the list of
+    ;; xref tools is likely to be language-specific (but not always;
+    ;; for example Gnu global supports many languages).
+    (let ((xref-label (intern value)))
+      (if (memq xref-label ada-xref-known-tools)
+         (progn
+           (setf (ada-prj-xref-label project) xref-label)
+           (setf (ada-prj-xref project) (ada-prj-make-xref xref-label)))
+
+       (user-error "'%s' is not a recognized xref tool (must be one of %s)"
+                   xref-label ada-xref-known-tools))
+      ))
+   ))
+
+(defun ada-prj-parse-undefined (project name value)
+  "For `wisi-prj-parse-undefined-function'."
+  ;; Otherwise undefined names are set as a project file variable.
+  ;; eg "comp_opt"
+  ;;
+  ;; This is defined here, rather than in wisi, because we only
+  ;; maintain it for compatibility with previous ada-mode versions.
+  ;;
+  ;; We assume any repeated names are lists
+  (let ((prev (plist-get (ada-prj-plist project) (intern name))))
+    (if prev
+       (setf (ada-prj-plist project)
+             (plist-put (ada-prj-plist project)
+                        (intern name)
+                        (append (if (listp prev) prev (list prev))
+                                (list value))))
+
+      (setf (ada-prj-plist project)
+           (plist-put
+            (ada-prj-plist project)
+            (intern name)
+            value)))
+    ))
+
+;; This is autoloaded because it is often used in Makefiles, and thus
+;; will be the first ada-mode function executed.
+;;;###autoload
+(defun ada-select-prj-file (prj-file)
+  ;; not ada-prj-select-file for backward compatibility
+  "Select PRJ-FILE as the current project file, parsing it if necessary.
+Deselects the current project first."
+  (wisi-prj-select-cache prj-file (ada-prj-default "")))
+(make-obsolete 'ada-select-prj-file 'wisi-prj-select-cache "ada-mode 7.0")
+
+(cl-defgeneric ada-prj-select-compiler (compiler project)
+  "PROJECT has been selected; set any project options that are both Ada and 
compiler specific.")
+
+(cl-defgeneric ada-prj-deselect-compiler (compiler project)
+  "PROJECT has been deselected; unset any project options that are both Ada 
and compiler specific.")
+
+(cl-defmethod wisi-prj-select :after ((project ada-prj))
+  (ada-prj-select-compiler (ada-prj-compiler project) project))
+
+(cl-defmethod wisi-prj-deselect :before ((project ada-prj))
+  (ada-prj-deselect-compiler (ada-prj-compiler project) project))
+
+(cl-defmethod wisi-prj-identifier-at-point ((_project ada-prj))
+  ;; Handle adjacent operator/identifer like:
+  ;; test/ada_mode-slices.adb
+  ;;   D1, D2 : Day := +Sun;
+  ;;
+  ;; For operators, return quoted operator, for gpr_query or gnatfind.
+
+  (cond
+   ((wisi-in-comment-p)
+    (error "Inside comment"))
+
+   ((wisi-in-string-p)
+    ;; In an operator, or a string literal
+    (skip-chars-backward "+*/&<>=-")
+    (cond
+     ((and (= (char-before) ?\")
+          (progn
+            (forward-char -1)
+            (looking-at (concat "\"\\(" ada-operator-re "\\)\""))))
+      (concat "\"" (match-string-no-properties 1) "\""))
+
+     (t
+      (error "Inside string or character constant"))
+     ))
+
+   ((looking-at (concat "\"\\(" ada-operator-re "\\)\""))
+    (match-string-no-properties 0))
+
+   ((looking-at ada-operator-re)
+    (concat "\"" (match-string-no-properties 0) "\""))
+
+   ((memq (syntax-class (syntax-after (point))) '(2 3))
+    ;; word or symbol syntax.
+    (skip-syntax-backward "w_")
+    (buffer-substring-no-properties (point) (save-excursion 
(skip-syntax-forward "w_") (point))))
+
+   (t
+    (error "No identifier around"))
+   ))
+
+;;;; initialization
+(push (cons "adp" #'wisi-prj-parse-file-1) wisi-prj-parser-alist)
+
+(add-to-list 'wisi-prj-file-extensions "adp")
+
+(provide 'ada-core)
+;; ada-core.el ends here
diff --git a/packages/ada-mode/ada-fix-error.el 
b/packages/ada-mode/ada-fix-error.el
deleted file mode 100644
index cf90a59..0000000
--- a/packages/ada-mode/ada-fix-error.el
+++ /dev/null
@@ -1,237 +0,0 @@
-;;; ada-fix-error.el --- utilities for automatically fixing  -*- 
lexical-binding:t -*-
-;; errors reported by the compiler.
-
-;; Copyright (C) 1999-2009, 2012-2015, 2017-2019 Free Software Foundation, Inc.
-
-;; Author     : Stephen Leake      <address@hidden>
-;; Maintainer : Stephen Leake      <address@hidden>
-;; Web site   : http://www.stephe-leake.org/
-;; Keywords   : languages ada error
-
-;; This file is part of GNU Emacs
-
-;; This program is free software; you can redistribute it and/or modify
-;; it under the terms of the GNU General Public License as published by
-;; the Free Software Foundation; either version 3, or (at your option)
-;; any later version.
-
-;; This program is distributed in the hope that it will be useful,
-;; but WITHOUT ANY WARRANTY; without even the implied warranty of
-;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-;; GNU General Public License for more details.
-
-;; You should have received a copy of the GNU General Public License
-;; along with GNU Emacs; see the file COPYING.  If not, write to
-;; the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
-
-;;;; code
-
-(require 'ada-mode)
-(require 'cl-lib)
-(require 'compile)
-
-(defcustom ada-fix-sort-context-clause t
-  "*If non-nil, sort context clause when inserting `with'"
-  :type 'boolean
-  :group 'ada)
-
-(defvar ada-fix-context-clause nil
-  "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
-    (funcall ada-fix-context-clause)))
-
-(defun ada-fix-insert-unit-name (unit-name)
-  "Insert UNIT-NAME at point and capitalize it."
-  ;; unit-name is normally gotten from a file-name, and is thus all lower-case.
-  (let ((start-point (point))
-        search-bound)
-    (insert unit-name)
-    (setq search-bound (point))
-    (insert " ") ; separate from following words, if any, for 
ada-case-adjust-identifier
-    (goto-char start-point)
-    (while (search-forward "." search-bound t)
-      (forward-char -1)
-      (ada-case-adjust-identifier)
-      (forward-char 1))
-    (goto-char search-bound)
-    (ada-case-adjust-identifier)
-    (delete-char 1)))
-
-(defun ada-fix-sort-context-pred (a b)
-  "Predicate for `sort-subr'; sorts \"limited with\", \"private with\" last.
-Returns non-nil if a should preceed b in buffer."
-  ;; a, b are buffer ranges in the current buffer
-  (cl-flet
-      ((starts-with
-       (pat reg)
-       (string= pat (buffer-substring-no-properties (car reg)
-                                                    (min (point-max)
-                                                         (+(car reg) (length 
pat)))))))
-    (cond
-     ((and
-       (starts-with "limited with" a)
-       (starts-with "private with" b))
-      t)
-
-     ((and
-       (starts-with "limited with" a)
-       (not (starts-with "limited with" b)))
-      nil)
-
-     ((and
-       (not (starts-with "limited with" a))
-       (starts-with "limited with" b))
-      t)
-
-     ((and
-       (starts-with "private with" a)
-       (not (starts-with "private with" b)))
-      nil)
-
-     ((and
-       (not (starts-with "private with" a))
-       (starts-with "private with" b))
-      t)
-
-     (t
-      (> 0 (compare-buffer-substrings
-           nil (car a) (cdr a)
-           nil (car b) (cdr b))) )
-     )))
-
-(defun ada-fix-sort-context-clause (beg end)
-  "Sort context clauses in range BEG END."
-  (save-excursion
-    (save-restriction
-      (narrow-to-region beg end)
-      (goto-char (point-min))
-      (sort-subr nil 'forward-line 'end-of-line nil nil 
'ada-fix-sort-context-pred)
-      )))
-
-(defun ada-fix-add-with-clause (package-name)
-  "Add a with_clause for PACKAGE_NAME.
-If ada-fix-sort-context-clause, sort the context clauses using
-sort-lines."
-  (let ((context-clause (ada-fix-context-clause)))
-    (when (not context-clause)
-      (error "no compilation unit found"))
-
-    (goto-char (cdr context-clause))
-    (insert "with ")
-    (ada-fix-insert-unit-name package-name)
-    (insert ";\n")
-
-    (when (and (< (car context-clause) (cdr context-clause))
-              ada-fix-sort-context-clause)
-      (ada-fix-sort-context-clause (car context-clause) (point)))
-    ))
-
-(defun ada-fix-extend-with-clause (child-name)
-  "Assuming point is in a selected name, just before CHILD-NAME, add or
-extend a with_clause to include CHILD-NAME  .  "
-  (let ((parent-name-end (point)))
-    ;; Find the full parent name; skip back to whitespace, then match
-    ;; the name forward.
-    (skip-syntax-backward "w_.")
-    (search-forward-regexp ada-name-regexp parent-name-end)
-    (let ((parent-name (match-string 0))
-         (context-clause (ada-fix-context-clause)))
-      (goto-char (car context-clause))
-      (if (search-forward-regexp (concat "^with " parent-name ";") (cdr 
context-clause) t)
-         ;; found exisiting 'with' for parent; extend it
-         (progn
-           (forward-char -1) ; skip back over semicolon
-           (insert "." child-name))
-
-       ;; not found; we are in a package body, with_clause for parent is in 
spec.
-       ;; insert a new one
-       (ada-fix-add-with-clause (concat parent-name "." child-name)))
-      )))
-
-(defun ada-fix-add-use-type (type)
-  "Insert `use type' clause for TYPE at start of declarative part for current 
construct."
-  (ada-goto-declarative-region-start); leaves point after 'is'
-  (newline-and-indent)
-  (cl-ecase ada-language-version
-    (ada2012
-     (insert "use all type "))
-    ((ada83 ada95 ada2005)
-     (insert "use type ")))
-  (let ((begin (point))
-       end)
-    (insert type ";")
-    (setq end (point))
-    (goto-char begin)
-    (while (< (point) end)
-      (ada-case-adjust-at-point)
-      (forward-char 1))
-    ))
-
-(defun ada-fix-add-use (package)
-  "Insert `use' clause for PACKAGE at start of declarative part for current 
construct."
-  (ada-goto-declarative-region-start); leaves point after 'is'
-  (newline-and-indent)
-  (insert "use " package ";"))
-
-(defvar ada-fix-error-hook nil
-  ;; determined by ada_compiler, set by *-select-prj-compiler
-  "Hook to recognize and fix errors.
-Hook functions are called with three args:
-
-MSG, the `compilation--message' struct for the current error
-
-SOURCE-BUFFER, the buffer containing the source to be fixed
-
-SOURCE-WINDOW, the window displaying SOURCE-BUFFER.
-
-Point in SOURCE-BUFFER is at error location; point in
-`compilation-last-buffer' is at MSG location. Focus is in
-compilation buffer.
-
-Hook functions should return t if the error is recognized and
-fixed, leaving point at fix. Otherwise, they should preserve
-point and return nil.")
-
-(defun ada-get-compilation-message ()
-  "Get compilation message at line beginning."
-  (get-text-property (line-beginning-position) 'compilation-message))
-
-;;;###autoload
-(defun ada-fix-compiler-error ()
-  "Attempt to fix the current compiler error. Leave point at fixed code."
-  (interactive)
-
-  (let ((source-buffer (current-buffer))
-        (source-window (selected-window))
-        (line-move-visual nil)); screws up next-line otherwise
-
-    (with-current-buffer compilation-last-buffer
-      (when (not (ada-get-compilation-message))
-       (beep)
-       (message "ada-fix-compiler-error")
-       ;; not clear why this can happen, but it has
-       (compilation-next-error 1))
-      (let ((comp-buf-pt (point))
-           (success
-            (run-hook-with-args-until-success
-             'ada-fix-error-hook
-             (compilation-next-error 0)
-             source-buffer
-             source-window)))
-       ;; restore compilation buffer point
-       (set-buffer compilation-last-buffer)
-       (goto-char comp-buf-pt)
-
-       (unless success
-         ;; none of the hooks handled the error
-         (error "error not recognized"))
-       ))))
-
-(provide 'ada-fix-error)
-;; end of file
diff --git a/packages/ada-mode/ada-gnat-xref.el 
b/packages/ada-mode/ada-gnat-xref.el
index f95789d..80ba7ce 100644
--- a/packages/ada-mode/ada-gnat-xref.el
+++ b/packages/ada-mode/ada-gnat-xref.el
@@ -5,7 +5,7 @@
 ;;
 ;; GNAT is provided by AdaCore; see http://libre.adacore.com/
 ;;
-;;; Copyright (C) 2012 - 2018  Free Software Foundation, Inc.
+;;; Copyright (C) 2012 - 2020  Free Software Foundation, Inc.
 ;;
 ;; Author: Stephen Leake <address@hidden>
 ;; Maintainer: Stephen Leake <address@hidden>
@@ -33,17 +33,52 @@
 ;; By default, ada-mode is configured to load this file, so nothing
 ;; special needs to done to use it.
 
-(require 'ada-fix-error)
 (require 'compile)
 (require 'gnat-core)
-(defvar ada-gnat-debug-run);; gnat-core requires ada-mode, which requires 
ada-gnat-xref
 
 ;;;;; code
 
 ;;;; uses of gnat tools
 
+(defconst gnatxref-buffer-name-prefix "*gnatxref-")
+
 (defconst ada-gnat-file-line-col-regexp "\\(.*\\):\\([0-9]+\\):\\([0-9]+\\)")
 
+(defconst ada-gnat-file-line-col-type-regexp
+  (concat ada-gnat-file-line-col-regexp ": +\\(?:(\\(.*\\))\\)?")
+  "Regexp matching <file>:<line>:<column> (<type>)")
+
+(cl-defstruct (gnatxref-xref (:include gnat-compiler))
+  ;; no new slots
+  )
+
+;;;###autoload
+(cl-defun create-gnat-xref
+    (&key
+     gpr-file
+     run-buffer-name
+     project-path
+     target
+     runtime
+     gnat-stub-opts
+     gnat-stub-cargs)
+  ;; See note on `create-ada-prj' for why this is not a defalias.
+  (make-gnatxref-xref
+   :gpr-file gpr-file
+   :run-buffer-name run-buffer-name
+   :project-path project-path
+   :target target
+   :runtime runtime
+   :gnat-stub-opts gnat-stub-opts
+   :gnat-stub-cargs gnat-stub-cargs
+   ))
+
+(cl-defmethod wisi-xref-parse-one ((xref gnatxref-xref) project name value)
+  (wisi-compiler-parse-one xref project name value))
+
+(cl-defmethod wisi-xref-parse-final ((xref gnatxref-xref) _project 
prj-file-name)
+  (setf (gnat-compiler-run-buffer-name xref) (gnat-run-buffer-name 
prj-file-name gnatxref-buffer-name-prefix)))
+
 (defun ada-gnat-xref-adj-col (identifier col)
   "Return COL adjusted for 1-index, quoted operators."
   (cond
@@ -73,33 +108,75 @@
     (+ 1 col))
    ))
 
-(defun ada-gnat-xref-common-cmd ()
+(defun ada-gnat-xref-common-cmd (project)
   "Returns the gnatfind command to run to find cross-references."
-  (format "%sgnatfind" (or (ada-prj-get 'target) "")))
+  (format "%sgnatfind" (or (gnat-compiler-target (wisi-prj-xref project)) "")))
 
-(defun ada-gnat-xref-common-args (identifier file line col)
-  "Returns a list of arguments to pass to gnatfind.  The caller
-may add more args to the result before calling gnatfind.  Some
+(defun ada-gnat-xref-common-args (project identifier file line col)
+  "Returns a list of arguments to pass to gnatfind.  Some
 elements of the result may be nil."
   (list "-a"
-        (when ada-xref-full-path "-f")
-       ;; src_dir contains Source_Dirs from gpr_file, Similarly for
-       ;; obj_dir. So we don't need to pass the gpr file.
-        (when (ada-prj-get 'src_dir)
-          (concat "-aI" (mapconcat 'identity (ada-prj-get 'src_dir) (if (eq 
system-type 'windows-nt) ";" ":"))))
-        (when (ada-prj-get 'obj_dir)
-          (concat "-aO" (mapconcat 'identity (ada-prj-get 'obj_dir) (if (eq 
system-type 'windows-nt) ";" ":"))))
+        (when wisi-xref-full-path "-f")
+       ;; 'gnatfind' does not take a gnat project file argument. We
+       ;; assue you are not using gnatxref if you are using a gnat
+       ;; project file; use gpr_query.
+        (when (wisi-prj-source-path project)
+          (concat "-aI" (mapconcat 'identity (wisi-prj-source-path project) " 
-aI")))
+        (when (plist-get (ada-prj-plist project) 'obj_dir)
+          (concat "-aO" (mapconcat 'identity (plist-get (ada-prj-plist 
project) 'obj_dir) " -aO")))
         (format "%s:%s:%d:%d"
                 identifier
                 (file-name-nondirectory file)
                 line
                 (ada-gnat-xref-adj-col identifier col))))
 
-(defun ada-gnat-xref-other (identifier file line col)
-  "For `ada-xref-other-function', using `gnatfind', which is Ada-specific."
-  (let* ((result nil))
-    (with-current-buffer (gnat-run-buffer)
-      (gnat-run (ada-gnat-xref-common-cmd) (ada-gnat-xref-common-args 
identifier file line col))
+(defun ada-gnat-xref-refs (project item all)
+  (with-slots (summary location) item
+    (with-slots (file line column) location
+      (let* ((wisi-xref-full-path t)
+            (args (cons "-r" (ada-gnat-xref-common-args project summary file 
line column)))
+            (result nil))
+       (with-current-buffer (gnat-run-buffer project 
(gnat-compiler-run-buffer-name (wisi-prj-xref project)))
+         (gnat-run project (ada-gnat-xref-common-cmd project) args)
+
+         (goto-char (point-min))
+         (when ada-gnat-debug-run (forward-line 2)); skip ADA_PROJECT_PATH, 
'gnat find'
+
+         (while (not (eobp))
+           (cond
+            ((looking-at ada-gnat-file-line-col-type-regexp)
+             ;; process line
+             (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)))
+               (when (or all found-type)
+                 (push (xref-make (if found-type
+                                      (concat summary " " found-type)
+                                    summary)
+                                  (xref-make-file-location found-file 
found-line found-col))
+                       result))
+               ))
+            (t
+             ;; ignore line
+             ))
+           (forward-line 1)))
+       (nreverse result) ;; specs first.
+       ))))
+
+(cl-defmethod wisi-xref-definitions (_xref project item)
+  (ada-gnat-xref-refs project item nil))
+
+(cl-defmethod wisi-xref-references (_xref project item)
+  (ada-gnat-xref-refs project item t))
+
+(cl-defmethod wisi-xref-other ((_xref gnatxref-xref) project &key identifier 
filename line column)
+  (let* ((wisi-xref-full-path t)
+        (cmd (ada-gnat-xref-common-cmd project))
+        (args (ada-gnat-xref-common-args project identifier filename line 
column))
+        (result nil))
+    (with-current-buffer (gnat-run-buffer project 
(gnat-compiler-run-buffer-name (wisi-prj-xref project)))
+      (gnat-run project cmd args)
 
       (goto-char (point-min))
       (when ada-gnat-debug-run (forward-line 2)); skip ADA_PROJECT_PATH, 'gnat 
find'
@@ -118,14 +195,19 @@ elements of the result may be nil."
          (let ((found-file (match-string 1))
                (found-line (string-to-number (match-string 2)))
                (found-col  (string-to-number (match-string 3))))
+           ;; Sometimes gnatfind does not respect "-f" (test/ada_mode.ads 
Separate_Procedure full body)
+           (unless (file-name-absolute-p found-file)
+             (setq found-file (locate-file found-file 
compilation-search-path)))
+
            (if (not
                 (and
                  ;; due to symbolic links, only the non-dir filename is 
comparable.
-                 (equal (file-name-nondirectory file) (file-name-nondirectory 
found-file))
+                 (equal (file-name-nondirectory filename) 
(file-name-nondirectory found-file))
                  (= line found-line)
-                 (= (ada-gnat-xref-adj-col identifier col) found-col)))
-               ;; found other item
+                 (= (ada-gnat-xref-adj-col identifier column) found-col)))
+               ;; Found other item.
                (setq result (list found-file found-line (1- found-col)))
+             ;; else keep searching
              (forward-line 1))
            ))
 
@@ -134,13 +216,11 @@ elements of the result may be nil."
        ))
     result))
 
-(defun ada-gnat-xref-parents (identifier file line col)
-  "For `ada-xref-parents-function', using `gnatfind', which is Ada-specific."
-
-  (let* ((arg (ada-gnat-xref-common-args identifier file line col))
+(cl-defmethod wisi-xref-parents ((_xref gnatxref-xref) project &key identifier 
filename line column)
+  (let* ((arg (ada-gnat-xref-common-args project identifier filename line 
column))
         (result nil))
-    (with-current-buffer (gnat-run-buffer)
-      (gnat-run (ada-gnat-xref-common-cmd) (cons "-d" arg))
+    (with-current-buffer (gnat-run-buffer project 
(gnat-compiler-run-buffer-name (wisi-prj-xref project)))
+      (gnat-run project (ada-gnat-xref-common-cmd project) (cons "-d" arg))
 
       (goto-char (point-min))
       (when ada-gnat-debug-run (forward-line 2)); skip GPR_PROJECT_PATH, 'gnat 
find'
@@ -169,33 +249,32 @@ elements of the result may be nil."
          (error "gnat find did not return parent types"))
        ))
 
-    (ada-goto-source (nth 0 result)
-                    (nth 1 result)
-                    (nth 2 result))
+    (wisi-goto-source (nth 0 result)
+                     (nth 1 result)
+                     (nth 2 result))
     ))
 
-(defun ada-gnat-xref-all (identifier file line col local-only append)
-  "For `ada-xref-all-function'."
+(cl-defmethod wisi-xref-all ((_xref gnatxref-xref) project &key identifier 
filename line column local-only append)
   ;; we use `compilation-start' to run gnat, not `gnat-run', so it
   ;; is asynchronous, and automatically runs the compilation error
   ;; filter.
 
-  (let* ((arg (ada-gnat-xref-common-args identifier file line col)))
+  (let* ((arg (ada-gnat-xref-common-args project identifier filename line 
column)))
     (setq arg (cons "-r" arg))
-    (when local-only (setq arg (append arg (list file))))
+    (when local-only (setq arg (append arg (list filename))))
 
-    (with-current-buffer (gnat-run-buffer); for default-directory
+    (with-current-buffer (gnat-run-buffer project 
(gnat-compiler-run-buffer-name (wisi-prj-xref project)))
       (let ((compilation-buffer-name "*gnatfind*")
             (compilation-error "reference")
             (command-and-args (mapconcat (lambda (a) (or a ""))
-                                         (cons (ada-gnat-xref-common-cmd) arg)
+                                         (cons (ada-gnat-xref-common-cmd 
project) arg)
                                          " "))
            ;; gnat find uses standard gnu format for output, so don't
            ;; need to set compilation-error-regexp-alist
            prev-pos
            prev-content)
-       ;; compilation-environment is buffer-local; don't set in 'let'
-       (setq compilation-environment (ada-prj-get 'proc_env))
+
+       ;; compilation-environment is set in `wisi-prj-select'
 
        ;; WORKAROUND: the 'compilation' API doesn't let us specify "append", 
so we use this.
        (with-current-buffer (get-buffer-create compilation-buffer-name)
@@ -208,7 +287,7 @@ elements of the result may be nil."
            (setq command-and-args
                  (propertize command-and-args
                              'display
-                             (format "References to %s at %s:%d:%d" identifier 
file line col))))
+                             (format "References to %s at %s:%d:%d" identifier 
filename line column))))
          (compilation-start command-and-args
                             'compilation-mode
                             (lambda (_name) compilation-buffer-name))
@@ -219,52 +298,11 @@ elements of the result may be nil."
                (goto-char prev-pos))))
        ))))
 
-;;;;; setup
-
-(defun ada-gnat-xref-select-prj ()
-  (setq ada-file-name-from-ada-name 'ada-gnat-file-name-from-ada-name)
-  (setq ada-ada-name-from-file-name 'ada-gnat-ada-name-from-file-name)
-  (setq ada-make-package-body       'ada-gnat-make-package-body)
-
-  (setq ada-xref-other-function  'ada-gnat-xref-other)
-  (setq ada-xref-parent-function 'ada-gnat-xref-parents)
-  (setq ada-xref-all-function    'ada-gnat-xref-all)
-  (setq ada-show-xref-tool-buffer 'ada-gnat-show-run-buffer)
-
-  ;; gnatmake -gnatD generates files with .dg extensions. But we don't
-  ;; need to navigate between them.
-
-  (add-to-list 'completion-ignored-extensions ".ali") ;; gnat library files, 
used for cross reference
-  (add-to-list 'compilation-error-regexp-alist 'gnat)
-  )
-
-(defun ada-gnat-xref-deselect-prj ()
-  (setq ada-file-name-from-ada-name nil)
-  (setq ada-ada-name-from-file-name nil)
-  (setq ada-make-package-body       nil)
+(cl-defmethod wisi-xref-overriding ((_xref gnatxref-xref) _project &key 
_identifier _filename _line _column)
+  (error "gnatxref does not support 'show overriding' - use gpr_query?"))
 
-  (setq ada-xref-other-function  nil)
-  (setq ada-xref-parent-function nil)
-  (setq ada-xref-all-function    nil)
-  (setq ada-show-xref-tool-buffer nil)
-
-  (setq completion-ignored-extensions (delete ".ali" 
completion-ignored-extensions))
-  (setq compilation-error-regexp-alist (delete 'gnat 
compilation-error-regexp-alist))
-  )
-
-(defun ada-gnat-xref ()
-  "Set Ada mode global vars to use 'gnat xref'"
-  (add-to-list 'ada-prj-file-ext-extra     "gpr")
-  (add-to-list 'ada-prj-parser-alist       '("gpr" . gnat-parse-gpr))
-  (add-to-list 'ada-select-prj-xref-tool   '(gnat  . ada-gnat-xref-select-prj))
-  (add-to-list 'ada-deselect-prj-xref-tool '(gnat  . 
ada-gnat-xref-deselect-prj))
-
-  ;; no parse-*-xref yet
-
-  (add-hook 'ada-gnat-fix-error-hook 'ada-gnat-fix-error))
-
-(ada-gnat-xref)
+(cl-defmethod wisi-xref-overridden ((_xref gnatxref-xref) _project &key 
_identifier _filename _line _column)
+  (error "gnatxref does not support 'show overridden' - use gpr_query?"))
 
 (provide 'ada-gnat-xref)
-
 ;; end of file
diff --git a/packages/ada-mode/ada-imenu.el b/packages/ada-mode/ada-imenu.el
index f5af9e1..06d9595 100644
--- a/packages/ada-mode/ada-imenu.el
+++ b/packages/ada-mode/ada-imenu.el
@@ -1,6 +1,6 @@
 ;;; ada-imenu.el - Ada mode interface to imenu for Ada Mode  -*- 
lexical-binding:t -*-
 
-;; Copyright (C) 2012, 2013, 2015  Free Software Foundation, Inc.
+;; Copyright (C) 2012, 2013, 2015, 2019  Free Software Foundation, Inc.
 ;;
 ;; Author: Simon Wright <address@hidden>
 ;; Contributors: see ada-mode.el, and specifically Christian Egli
@@ -24,7 +24,7 @@
 ;;; History: see ada_mode.el
 ;;
 
-(require 'ada-mode)
+(require 'ada-core)
 (require 'imenu)
 
 (defconst ada--imenu-comment-re "\\([ \t]*--.*\\)?")
diff --git a/packages/ada-mode/ada-indent-user-options.el 
b/packages/ada-mode/ada-indent-user-options.el
index b4d309c..3f58573 100644
--- a/packages/ada-mode/ada-indent-user-options.el
+++ b/packages/ada-mode/ada-indent-user-options.el
@@ -39,18 +39,7 @@ begin
   :safe #'integerp)
 (make-variable-buffer-local 'ada-indent)
 
-(defvar ada-broken-indent nil)
-(make-obsolete-variable
- 'ada-broken-indent
- 'ada-indent-broken
- "Emacs 24.4, Ada mode 5.0")
-
-(defcustom ada-indent-broken
-  (if ada-broken-indent
-      (progn
-       (message "WARNING: setting `ada-indent-broken' to obsolete 
`ada-broken-indent'")
-       ada-broken-indent)
-    2)
+(defcustom ada-indent-broken 2
   "Indentation for the continuation of a broken line.
 
 Example :
@@ -80,22 +69,7 @@ Otherwise, they are indented as a with previous comments or 
code."
   :safe  #'booleanp)
 (make-variable-buffer-local 'ada-indent-comment-gnat)
 
-(defvar ada-label-indent nil)
-(make-obsolete-variable
- 'ada-label-indent
- 'ada-indent-label
- "Emacs 24.4, Ada mode 5.0")
-
-(defcustom ada-indent-label
-    (if ada-label-indent
-      (progn
-       (message "WARNING: setting `ada-indent-label' to obsolete 
`ada-label-indent'")
-       ada-label-indent)
-      -3)
-  ;; Ada mode 4.01 and earlier default this to -4. But that is
-  ;; incompatible with the default gnat indentation style check, which
-  ;; wants all indentations to be a multiple of 3 (with some
-  ;; exceptions). So we default this to -3.
+(defcustom ada-indent-label -3
   "Indentation for a loop, block, or statement label, relative to the item it 
labels.
 
 Example :
@@ -164,18 +138,7 @@ An example is:
   :safe #'integerp)
 (make-variable-buffer-local 'ada-indent-return)
 
-(defvar ada-use-indent nil)
-(make-obsolete-variable
- 'ada-use-indent
- 'ada-indent-use
- "Emacs 24.4, Ada mode 5.0")
-
-(defcustom ada-indent-use
-    (if ada-use-indent
-      (progn
-       (message "WARNING: setting `ada-indent-use' to obsolete 
`ada-use-indent'")
-       ada-use-indent)
-      ada-indent-broken)
+(defcustom ada-indent-use ada-indent-broken
   "Indentation for the lines in a `use' statement.
 
 An example is:
@@ -185,18 +148,7 @@ An example is:
   :safe #'integerp)
 (make-variable-buffer-local 'ada-indent-use)
 
-(defvar ada-when-indent nil)
-(make-obsolete-variable
- 'ada-when-indent
- 'ada-indent-when
- "Emacs 24.4, Ada mode 5.0")
-
-(defcustom ada-indent-when
-    (if ada-when-indent
-      (progn
-       (message "WARNING: setting `ada-indent-when' to obsolete 
`ada-when-indent'")
-       ada-when-indent)
-      3)
+(defcustom ada-indent-when 3
   "Indentation for `when' relative to `exception', `case', `or' in select.
 
 An example is:
@@ -206,18 +158,7 @@ An example is:
   :safe  #'integerp)
 (make-variable-buffer-local 'ada-indent-when)
 
-(defvar ada-with-indent nil)
-(make-obsolete-variable
- 'ada-with-indent
- 'ada-indent-with
- "Emacs 24.4, Ada mode 5.0")
-
-(defcustom ada-indent-with
-    (if ada-with-indent
-      (progn
-       (message "WARNING: setting `ada-indent-with' to obsolete 
`ada-with-indent'")
-       ada-with-indent)
-      ada-indent-broken)
+(defcustom ada-indent-with ada-indent-broken
   "Indentation for the lines in a `with' context clause.
 
 An example is:
diff --git a/packages/ada-mode/ada-mode-compat.el 
b/packages/ada-mode/ada-mode-compat.el
deleted file mode 100644
index f244d86..0000000
--- a/packages/ada-mode/ada-mode-compat.el
+++ /dev/null
@@ -1,27 +0,0 @@
-;; ada-mode-compat.el --- Implement current Emacs features not present earlier 
versions  -*- lexical-binding:t -*-
-
-;; Copyright (C) 2014-2017 Free Software Foundation, Inc.
-
-;; This file is part of GNU Emacs.
-
-;; GNU Emacs is free software: you can redistribute it and/or modify
-;; it under the terms of the GNU General Public License as published by
-;; the Free Software Foundation, either version 3 of the License, or
-;; (at your option) any later version.
-
-;; GNU Emacs is distributed in the hope that it will be useful,
-;; but WITHOUT ANY WARRANTY; without even the implied warranty of
-;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-;; GNU General Public License for more details.
-
-;; You should have received a copy of the GNU General Public License
-;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
-
-(when (not (functionp 'font-lock-ensure))
-  ;; not in 24.3, 24.4, 24.5; in 25.1
-  (defun font-lock-ensure (&optional beg end)
-    (font-lock-fontify-region (or beg (point-min)) (or end (point-max)))))
-
-(provide 'ada-mode-compat)
-
-;; end of file
diff --git a/packages/ada-mode/ada-mode.el b/packages/ada-mode/ada-mode.el
index 3995491..1de8194 100644
--- a/packages/ada-mode/ada-mode.el
+++ b/packages/ada-mode/ada-mode.el
@@ -1,13 +1,13 @@
 ;;; ada-mode.el --- major-mode for editing Ada sources  -*- lexical-binding:t 
-*-
 ;;
-;; Copyright (C) 1994, 1995, 1997 - 2019  Free Software Foundation, Inc.
+;; Copyright (C) 1994, 1995, 1997 - 2020  Free Software Foundation, Inc.
 ;;
 ;; Author: Stephen Leake <address@hidden>
 ;; Maintainer: Stephen Leake <address@hidden>
 ;; Keywords: languages
 ;;  ada
-;; Version: 6.2.1
-;; package-requires: ((uniquify-files "1.0.1") (wisi "2.2.1") (emacs "25.0"))
+;; Version: 7.0.1
+;; package-requires: ((uniquify-files "1.0.1") (wisi "3.0.1") (emacs "25.0"))
 ;; url: http://www.nongnu.org/ada-mode/
 ;;
 ;; This file is part of GNU Emacs.
@@ -34,86 +34,29 @@
 ;;
 ;; By default, ada-mode is configured to take full advantage of the
 ;; GNAT compiler.  If you are using another compiler, you
-;; should load that compiler's ada-* file first; that will define
-;; ada-compiler as a feature, so ada-gnat.el will not be loaded.
+;; should load that compiler's ada-* file first.
 ;;
 ;; See the user guide (info "ada-mode"), built from ada-mode.texi.
 
 ;;; Design:
 ;;
-;; In order to support multiple compilers, we use indirect function
-;; calls for all operations that depend on the compiler.
+;; In order to support multiple compilers, and different compilers for
+;; different projects, we use cl-defgeneric function calls for all
+;; operations that depend on the compiler.  The user variable
+;; `ada-compiler' selects which compiler to use; it can be overridden
+;; by the "ada_compiler" setting in project files.
 ;;
 ;; We also support a cross reference tool (also called xref tool) that
 ;; is different from the compiler. For example, you can use a local
 ;; GNAT compiler to generate and access cross-reference information,
-;; while using a cross-compiler for compiling the final executable.
+;; while using a cross-compiler for compiling the final
+;; executable. The user variable `ada-xref-tool' selects the xref
+;; tool; it can be overridden by the "xref_tool" setting in project
+;; files.
 ;;
-;; Other functions are lumped with the choice of xref tool; mapping
-;; Ada names to file names, creating package bodies; any tool function
-;; that does not create executable code.
+;; The indentation engine and skeleton tools are from the wisi
+;; package.
 ;;
-;; The indentation engine and skeleton tools are also called
-;; indirectly, to allow parallel development of new versions of these
-;; tools (inspired by experience with ada-smie and ada-wisi).
-;;
-;; We also support using different compilers for different projects;
-;; `ada-compiler' can be set in Ada mode project files.  Note that
-;; there is only one project active at a time; the most recently
-;; selected one. All Ada files are assumed to belong to this project
-;; (which is not correct, but works well in practice; the user is
-;; typically only concerned about files that belong to the current
-;; project).
-;;
-;; There are several styles of indirect calls:
-;;
-;; - scalar global variable set during load
-;;
-;;   Appropriate when the choice of implementation is fixed at load
-;;   time; it does not depend on the current Ada project. Used for
-;;   indentation and skeleton functions.
-;;
-;; - scalar global variable set during project select
-;;
-;;   Appropriate when the choice of implementation is determined by
-;;   the choice of compiler or xref tool, which is per-project.  The
-;;   user sets the compiler choice in the project file, but not the
-;;   lower-level redirect choice.
-;;
-;;   For example, `ada-file-name-from-ada-name' depends on the naming
-;;   convention used by the compiler. If the project file sets
-;;   ada_compiler to 'gnat (either directly or by default),
-;;   ada-gnat-select-prj sets `ada-file-name-from-ada-name' to
-;;   `ada-gnat-file-name-from-ada-name'.
-;;
-;; - scalar buffer-local variable set during project select or file open
-;;
-;;   Appropriate when choice of implementation is normally
-;;   per-project, but can be per-buffer.
-;;
-;;   For example, `ada-case-strict' will normally be set by the
-;;   project, but some files may deviate from the project standard (if
-;;   they are generated by -fdumpspec, for example). Those files set
-;;   `ada-case-strict' in a file local variable comment.
-;;
-;; - scalar buffer-local variable set by ada-mode or ada-mode-hook
-;;   function
-;;
-;;   Appropriate when the variable is a non-Ada mode variable, also
-;;   used by other modes, and choice should not affect those modes.
-;;
-;;   `indent-line-function', `comment-indent-function' use this style
-;;
-;; - alist global variable indexed by ada-compiler
-;;
-;;   Appropriate when the choice of implementation is determined by
-;;   the compiler, but the function is invoked during project parse,
-;;   so we can't depend on a value set by project select.
-;;
-;;   alist entries are set during load by the implementation elisp files.
-;;
-;;   `ada-prj-default-compiler-alist' uses this style.
-
 ;;; History:
 ;;
 ;; The first Ada mode for GNU Emacs was written by V. Broman in
@@ -141,6 +84,9 @@
 ;; A complete rewrite, to restructure the code more orthogonally, and
 ;; to use wisi for the indentation engine, was done in 2012 - 2013 by
 ;; Stephen Leake <address@hidden>.
+;;
+;; Another major refactoring, to use cl-defgeneric dispatching, was
+;; done in 2019 by Stephen Leake.
 
 ;;; Credits:
 ;;
@@ -158,253 +104,114 @@
 ;;     address@hidden
 ;;    and others for their valuable hints.
 
+(require 'ada-core)
+(require 'ada-indent-user-options)
+(require 'ada-process)
+(require 'ada-skel)
 (require 'align)
 (require 'cl-lib)
 (require 'compile)
 (require 'find-file)
-(require 'wisi) ;; FIXME: rewrite to assume wisi
+(require 'wisi)
 
 (defun ada-mode-version ()
   "Return Ada mode version."
   (interactive)
-  (let ((version-string "6.2.1"))
-    ;; must match:
-    ;; ada-mode.texi
-    ;; README-ada-mode
-    ;; Version: above
+  (let ((version-string "7.0.1"))
     (if (called-interactively-p 'interactive)
        (message version-string)
       version-string)))
 
 ;;;;; User variables
 
-(defvar ada-mode-hook nil
-  "List of functions to call when Ada mode is invoked.
-This hook is executed after `ada-mode' is fully loaded, but
-before file local variables are processed.")
-
-(defgroup ada nil
-  "Major mode for editing Ada source code in Emacs."
-  :group 'languages)
-
-(defcustom ada-auto-case t
-  "Buffer-local value that may override project variable `auto_case'.
-Global value is default for project variable `auto_case'.
-t means automatically change case of preceding word while typing.
-not-upper-case means only change case if typed word is not all upper-case.
-Casing of Ada keywords is done according to `ada-case-keyword',
-identifiers are Mixed_Case."
-  :type  '(choice (const nil)
-                 (const t)
-                 (const not-upper-case))
-  :safe  (lambda (val) (memq val '(nil t not-upper-case))))
-(make-variable-buffer-local 'ada-auto-case)
-
-(defcustom ada-case-exception-file nil
-  "Default list of special casing exceptions dictionaries for identifiers.
-Override with `casing' project variable.
-
-New exceptions may be added interactively via `ada-case-create-exception'.
-If an exception is defined in multiple files, the first occurence is used.
-
-The file format is one word per line, that gives the casing to be
-used for that word in Ada source code.  If the line starts with
-the character *, then the exception will be used for partial
-words that either start at the beginning of a word or after a _
-character, and end either at the end of the word or at a _
-character.  Characters after the first word are ignored, and not
-preserved when the list is written back to the file."
-  :type  '(repeat (file))
-  :safe  #'listp)
-
-(defcustom ada-case-keyword 'lower-case
-  "Buffer-local value that may override project variable `case_keyword'.
-Global value is default for project variable `case_keyword'.
-Indicates how to adjust the case of Ada keywords."
-  :type '(choice (const lower-case)
-                (const upper-case))
-  ;; We'd like to specify that the value must be a function that takes
-  ;; one arg, but custom doesn't support that. ':safe' is supposed
-  ;; to be used to prevent user-provided functions from compromising
-  ;; security, so ":safe #'functionp" is not appropriate. So we
-  ;; use a symbol, and a cl-ecase in ada-case-keyword.
-  :safe (lambda (val) (memq val '(lower-case upper-case)))
-  )
-(make-variable-buffer-local 'ada-case-keyword)
-
-(defcustom ada-case-identifier 'mixed-case
-  "Buffer-local value that may override project variable `case_keyword'.
-Global value is default for project variable `case_keyword'.
-Indicates how to adjust the case of Ada keywords.
-Called with three args;
-start      - buffer pos of start of identifier
-end        - end of identifier
-force-case - if t, treat `ada-case-strict' as t"
-  :type '(choice (const mixed-case)
-                (const lower-case)
-                (const upper-case))
-  ;; see comment on :safe at ada-case-keyword
-  :safe (lambda (val) (memq val '(mixed-case lower-case upper-case)))
-  )
-;; we'd like to check that there are 3 args, since the previous
-;; release required 2 here. But there doesn't seem to be a way to
-;; access the arg count, which is only available for byte-compiled
-;; functions
-(make-variable-buffer-local 'ada-case-identifier)
-
-(defcustom ada-case-strict t
-  "Buffer-local value that may override project variable `case_strict'.
-Global value is default for project variable `case_strict'.
-If non-nil, force Mixed_Case for identifiers.
-Otherwise, allow UPPERCASE for identifiers."
-  :type 'boolean
-  :safe  #'booleanp)
-(make-variable-buffer-local 'ada-case-strict)
-
-(defcustom ada-language-version 'ada2012
-  "Ada language version; one of `ada83', `ada95', `ada2005', `ada2012'.
-Only affects the keywords to highlight, not which version the
-indentation parser accepts."
-  :type '(choice (const ada83)
-                (const ada95)
-                (const ada2005)
-                (const ada2012))
-  :safe  #'symbolp)
-(make-variable-buffer-local 'ada-language-version)
-
 (defcustom ada-fill-comment-prefix "-- "
   "Comment fill prefix."
+  :group 'ada
   :type 'string)
 (make-variable-buffer-local 'ada-fill-comment-prefix)
 
 (defcustom ada-fill-comment-postfix " --"
   "Comment fill postfix."
+  :group 'ada
   :type 'string)
 (make-variable-buffer-local 'ada-fill-comment-postfix)
 
 (defcustom ada-fill-comment-adaptive nil
   "If non-nil, comments are filled to the same width (not including 
indentation),
 rather than to the same column."
+  :group 'ada
   :type 'boolean
   :safe #'booleanp)
 
-(defcustom ada-prj-file-extensions '("adp" "prj")
-  "List of Emacs Ada mode project file extensions.
-Used when searching for a project file.
-Any file with one of these extensions will be parsed by 
`ada-prj-parse-file-1'."
-  :type 'list)
-
-(defcustom ada-prj-file-ext-extra nil
-  "List of secondary project file extensions.
-Used when searching for a project file that can be a primary or
-secondary project file (referenced from a primary).  The user
-must provide a parser for a file with one of these extensions."
-  :type 'list)
-
-(defcustom ada-prj-parse-hook nil
-  "Hook run at start of `ada-parse-prj-file'.
-Useful for setting `ada-xref-tool' and similar vars."
-  :type 'function
-  :group 'ada)
-
-(defcustom ada-xref-full-path nil
-  "If t, cross-references show the full path to source files; if
-nil, only the file name."
-  :type 'boolean
-  :safe #'booleanp)
+(defcustom ada-which-func-parse-size 30000
+  "Minimum size of the region surrounding point that is parsed for 
`which-function-mode'."
+  :group 'ada
+  :type 'integer
+  :safe #'integerp)
 
-(defcustom ada-process-parse-exec "ada_mode_wisi_lr1_parse.exe"
-  ;; We use .exe even on Linux to simplify the Makefile
+(defcustom ada-process-parse-exec "ada_mode_wisi_lr1_parse"
   "Name of executable to use for external process Ada parser.
-There are two standard choices; ada_mode_wisi_lalr_parse.exe and
-ada_mode_wisi_lr1_parse.exe. The LR1 version (the default) is
+There are two standard choices; ada_mode_wisi_lalr_parse and
+ada_mode_wisi_lr1_parse. The LR1 version (the default) is
 slower to load on first use, but gives better error recovery."
   :type 'string
-  :group 'ada-indentation)
+  :group 'ada)
 
 (defcustom ada-process-parse-exec-opts nil
   "List of process start options for `ada-process-parse-exec'."
   :type 'string
-  :group 'ada-indentation)
-
-(defcustom ada-which-func-parse-size 30000
-  "Minimum size of the region surrounding point that is parsed for 
`which-function-mode'."
-  :type 'integer
-  :safe #'integerp)
-
-;;;;; end of user variables
-
-(defconst ada-symbol-end
-  ;; we can't just add \> here; that might match _ in a user modified 
ada-mode-syntax-table
-  "\\([ \t]+\\|$\\)"
-  "Regexp to add to symbol name in `ada-which-function'.")
-
-(defvar ada-compiler nil
-  "Default Ada compiler; can be overridden in project files.
-Values defined by compiler packages.")
+  :group 'ada)
 
-(defvar ada-xref-tool nil
-  "Default Ada cross reference tool; can be overridden in project files.
-Values defined by cross reference packages.")
+(defcustom ada-xref-full-path nil
+  "If t, cross-references show the full path to source files; if
+nil, only the file name."
+  :group 'ada
+  :type 'boolean
+  :safe #'booleanp)
 
 ;;;; keymap and menus
 
-(defvar ada-ret-binding 'ada-indent-newline-indent)
-(defvar ada-lfd-binding 'newline-and-indent)
-
-(defun ada-case-activate-keys (map)
-  "Modify the key bindings for all the keys that should adjust casing."
-  ;; we could just put these in the keymap below, but this is easier.
-  (mapc (function
-        (lambda(key)
-          (define-key
-            map
-            (char-to-string key)
-            'ada-case-adjust-interactive)))
-       '( ?_ ?% ?& ?* ?\( ?\) ?- ?= ?+
-             ?| ?\; ?: ?' ?\" ?< ?, ?. ?> ?/ ?\n 32 ?\r ))
-  )
-
 (defvar ada-mode-map
   (let ((map (make-sparse-keymap)))
     ;; C-c <letter> are reserved for users
 
     ;; global-map has C-x ` 'next-error
-    (define-key map [return]    'ada-case-adjust-interactive)
+    (define-key map [return]    'wisi-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)
     (define-key map "\C-c>"     'ada-goto-declaration-end)
-    (define-key map "\C-c\M-`"          'ada-fix-compiler-error)
+    (define-key map "\C-c\M-`"          'wisi-fix-compiler-error)
     (define-key map "\C-c\C-a"          'ada-align)
     (define-key map "\C-c\C-b"          'ada-make-subprogram-body)
     (define-key map "\C-c\C-c"   'ada-build-make)
-    (define-key map "\C-c\C-d"          'ada-goto-declaration)
-    (define-key map "\C-c\M-d"          'ada-show-declaration-parents)
-    (define-key map "\C-c\C-e"          'ada-expand)
-    (define-key map "\C-c\C-f"          'ada-show-parse-error)
-    (define-key map "\C-c\C-i"          'ada-indent-statement)
-    (define-key map "\C-c\C-l"          'ada-show-local-references)
+    (define-key map "\C-c\C-d"          'wisi-goto-spec/body)
+    (define-key map "\C-c\M-d"          'wisi-show-declaration-parents)
+    (define-key map "\C-c\C-e"          'wisi-skel-expand)
+    (define-key map "\C-c\C-f"          'wisi-show-parse-error)
+    (define-key map "\C-c\C-i"          'wisi-indent-statement)
+    (define-key map [3 backtab] 'wisi-indent-containing-statement);; C-c 
backtab, translated from C-c S-tab
+    (define-key map "\C-c\C-l"          'wisi-show-local-references)
     (define-key map "\C-c\C-m"   'ada-build-set-make)
     (define-key map "\C-c\C-n"          'forward-sexp)
-    (define-key map "\C-c\M-n"          'ada-next-placeholder)
+    (define-key map "\C-c\M-n"          'wisi-skel-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"          'backward-sexp)
-    (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-p"          'wisi-skel-prev-placeholder)
+    (define-key map "\C-c\C-q"          'wisi-refresh-prj-cache)
+    (define-key map "\C-c\C-r"          'wisi-show-references)
     (define-key map "\C-c\M-r"          'ada-build-run)
-    (define-key map "\C-c\C-s"   'ada-goto-previous-pos)
+    (define-key map "\C-c\C-s"   'pop-global-mark)
+    (define-key map "\C-c\C-t"          'ada-find-file)
     (define-key map "\C-c\C-v"   'ada-build-check)
-    (define-key map "\C-c\C-w"          'ada-case-adjust-at-point)
-    (define-key map "\C-c\C-x"   'ada-show-overriding)
-    (define-key map "\C-c\M-x"   'ada-show-overridden)
-    (define-key map "\C-c\C-y"          'ada-case-create-exception)
-    (define-key map "\C-c\C-\M-y" 'ada-case-create-partial-exception)
+    (define-key map "\C-c\C-w"          'wisi-case-adjust-at-point)
+    (define-key map "\C-c\C-x"   'wisi-show-overriding)
+    (define-key map "\C-c\M-x"   'wisi-show-overridden)
+    (define-key map "\C-c\C-y"          'wisi-case-create-exception)
+    (define-key map "\C-c\C-\M-y" 'wisi-case-create-partial-exception)
     (define-key map [C-down-mouse-3] 'ada-popup-menu)
 
-    (ada-case-activate-keys map)
+    (wisi-case-activate-keys map)
 
     map
   )  "Local keymap used for Ada mode.")
@@ -420,17 +227,16 @@ Values defined by cross reference packages.")
     ["Customize"                  (customize-group 'ada)    t]
     ("Project files"
      ["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 file search path" ada-prj-show-prj-path            t]
-     ["Show source file search path"  ada-prj-show-src-path            t]
-     ["Delete project ..."            ada-prj-delete                   t]
+     ["Show project"                  wisi-prj-show                    t]
+     ["Show project file search path" wisi-prj-show-prj-path           t]
+     ["Show source file search path"  wisi-prj-show-src-path           t]
+     ["Clear current project"         wisi-prj-clear-current           t]
     )
     ("Build"
      ["Next compilation error"     next-error                t]
      ["Show secondary error"       ada-show-secondary-error  t]
-     ["Fix compilation error"      ada-fix-compiler-error    t]
-     ["Show last parse error"      ada-show-parse-error      t]
+     ["Fix compilation error"      wisi-fix-compiler-error   t]
+     ["Show last parse error"      wisi-show-parse-error     t]
      ["Check syntax"               ada-build-check       t]
      ["Show main"                  ada-build-show-main   t]
      ["Build"                      ada-build-make        t]
@@ -439,28 +245,31 @@ Values defined by cross reference packages.")
      )
     ("Navigate"
      ["Other file"                    ada-find-other-file          t]
-     ["Other file don't find decl"    ada-find-other-file-noset    t]
-     ["Find file in project"          ada-find-file                t]
-     ["Goto declaration/body"         ada-goto-declaration         t]
+     ["Find file in project"          project-find-file            t]
+     ["Goto declaration/body"         wisi-goto-spec/body          t]
      ["Goto next statement keyword"   forward-sexp   t]
      ["Goto prev statement keyword"   backward-sexp   t]
+     ["Goto subprogram/package start" ada-goto-declaration-start   t]
+     ["Goto subprogram/package end"   ada-goto-declaration-end     t]
      ["Goto declarative region start" ada-goto-declarative-region-start   t]
-     ["Goto declaration start"        ada-goto-declaration-start   t]
-     ["Goto declaration end"          ada-goto-declaration-end     t]
-     ["Show parent declarations"      ada-show-declaration-parents t]
-     ["Show references"               ada-show-references          t]
-     ["Show overriding"               ada-show-overriding          t]
-     ["Show overridden"               ada-show-overridden          t]
-     ["Goto secondary error"          ada-show-secondary-error     t]
-     ["Goto prev position"            ada-goto-previous-pos        t]
-     ["Next placeholder"              ada-next-placeholder    t]
-     ["Previous placeholder"          ada-prev-placeholder    t]
+     ["Goto containing statement start" wisi-goto-containing-statement-start t]
+     ["Show parent declarations"        wisi-show-declaration-parents        t]
+     ["Show all references (classwide)" xref-find-references                 t]
+     ["Show all direct references"      wisi-show-references                 t]
+     ["Show local references"         wisi-show-local-references    t]
+     ["Show overriding"               wisi-show-overriding          t]
+     ["Show overridden"               wisi-show-overridden          t]
+     ["Goto prev position current buffer" pop-to-mark-command  t]
+     ["Goto prev position other buffer"   pop-global-mark      t]
+     ["Next placeholder"              wisi-skel-next-placeholder    t]
+     ["Previous placeholder"          wisi-skel-prev-placeholder    t]
      )
     ("Edit"
-     ["Expand skeleton"             ada-expand              t]
+     ["Expand skeleton"             wisi-skel-expand        t]
      ["Indent line or selection"    indent-for-tab-command  t]
-     ["Indent current statement"    ada-indent-statement    t]
-     ["Indent lines in file"        (indent-region (point-min) (point-max))  t]
+     ["Indent current statement"    wisi-indent-statement   t]
+     ["Indent containing statement" wisi-indent-containing-statement    t]
+     ["Indent file"            (indent-region (point-min) (point-max))  t]
      ["Align"                       ada-align               t]
      ["Comment/uncomment selection" comment-dwim            t]
      ["Fill comment paragraph"         ada-fill-comment-paragraph           t]
@@ -469,87 +278,54 @@ Values defined by cross reference packages.")
      ["Make body for subprogram"    ada-make-subprogram-body     t]
      )
     ("Refactor"
-     ["Method (Object) => Object.Method"   ada-wisi-refactor-1 t]
-     ["Object.Method   => Method (Object)" ada-wisi-refactor-2 t]
-     ["Element (Object, Index) => Object (Index)" ada-wisi-refactor-3 t]
-     ["Object (Index) => Element (Object, Index)" ada-wisi-refactor-4 t]
+     ["Method (Object) => Object.Method"   ada-refactor-1 t]
+     ["Object.Method   => Method (Object)" ada-refactor-2 t]
+     ["Element (Object, Index) => Object (Index)" ada-refactor-3 t]
+     ["Object (Index) => Element (Object, Index)" ada-refactor-4 t]
      )
     ("Casing"
-     ["Create full exception"       ada-case-create-exception t]
-     ["Create partial exception"    ada-case-create-partial-exception t]
-     ["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]
+     ["Create full exception"       wisi-case-create-exception t]
+     ["Create partial exception"    wisi-case-create-partial-exception t]
+     ["Adjust case at point"        wisi-case-adjust-at-point  t]
+     ["Adjust case region"          wisi-case-adjust-region    t]
+     ["Adjust case buffer"          wisi-case-adjust-buffer    t]
+     ["Show casing files list"      wisi-case-show-files       t]
      )
     ("Misc"
-     ["Show last parse error"         ada-show-parse-error         t]
-     ["Show xref tool buffer"         ada-show-xref-tool-buffer    t]
-     ["Refresh cross reference cache" ada-xref-refresh             t]
-     ["Reset parser"                  ada-reset-parser             t]
+     ["Show last parse error"         wisi-show-parse-error       t]
+     ["Refresh cross reference cache" ada-xref-refresh            t]
+     ["Restart parser"                wisi-kill-parser            t]
      )))
 
-(defun ada-project-menu-compute ()
-  "Return an easy-menu menu for `ada-project-menu-install'.
-Menu displays currently parsed Ada mode projects."
-  (let (menu)
-    (dolist (item ada-prj-alist)
-      (push
-       (vector
-       (if (equal (car item) ada-prj-current-file)
-           ;; current project
-           (concat (car item) "  *")
-         (car item))
-       `(lambda () (interactive) (ada-select-prj-file ,(car item)))
-       t)
-       menu)
-      )
-    (nreverse menu)))
-
-(defun ada-project-menu-install ()
-  "Install the Ada project menu as a submenu."
-  (when (eq major-mode 'ada-mode)
-    (lookup-key ada-mode-map [menu-bar Ada]) ;; map to put menu in
-    [ada-prj-select]          ;; key to insert (a menu entry)
-    (easy-menu-binding
-     (easy-menu-create-menu
-      "Select Project"
-      (ada-project-menu-compute)));; binding
-    nil;; after
-
-    ;; IMPROVEME: this doesn’t work for ’after’; "Select Project" is at end
-    ;; (lookup-key ada-mode-map [menu-bar Ada Build])
-    ))
-
 (easy-menu-define ada-context-menu nil
   "Context menu keymap for Ada mode"
   '("Ada"
-    ["Goto declaration/body"         ada-goto-declaration         t]
-    ["Show parent declarations"      ada-show-declaration-parents t]
-    ["Goto declarative region start" ada-goto-declarative-region-start   t]
-    ["Goto declaration start"        ada-goto-declaration-start   t]
-    ["Goto declaration end"          ada-goto-declaration-end     t]
-    ["Show parent declarations"      ada-show-declaration-parents t]
-    ["Show references"               ada-show-references          t]
-    ["Show overriding"               ada-show-overriding          t]
-    ["Show overridden"               ada-show-overridden          t]
+    ["Goto declaration/body"         wisi-goto-spec-body         t]
     ["Goto next statement keyword"   forward-sexp   t]
     ["Goto prev statement keyword"   backward-sexp   t]
+    ["Goto declarative region start" ada-goto-declarative-region-start   t]
+    ["Goto containing statement start" wisi-goto-containing-statement-start t]
+    ["Goto subprogram/package start" ada-goto-declaration-start    t]
+    ["Goto subprogram/package end"   ada-goto-declaration-end      t]
+    ["Show parent declarations"      wisi-show-declaration-parents t]
+    ["Show references"               wisi-show-references          t]
+    ["Show overriding"               wisi-show-overriding          t]
+    ["Show overridden"               wisi-show-overridden          t]
 
     ["-"                nil nil]
 
-    ["Align"                       ada-align                  t]
-    ["Comment/uncomment selection" comment-dwim               t]
-    ["Fill comment paragraph"         ada-fill-comment-paragraph           
(ada-in-comment-p)]
-    ["Fill comment paragraph justify" (ada-fill-comment-paragraph 'full)   
(ada-in-comment-p)]
-    ["Fill comment paragraph postfix" (ada-fill-comment-paragraph 'full t) 
(ada-in-comment-p)]
-    ["Adjust case at point"        ada-case-adjust-at-point   (not 
(use-region-p))]
-    ["Adjust case region"          ada-case-adjust-region     (use-region-p)]
-    ["Create full case exception"    ada-case-create-exception         t]
-    ["Create partial case exception" ada-case-create-partial-exception t]
-    ["Indent current statement"    ada-indent-statement       t]
-    ["Expand skeleton"               ada-expand                        t]
-    ["Make body for subprogram"    ada-make-subprogram-body   t]
+    ["Align"                         ada-align                  t]
+    ["Comment/uncomment selection"    comment-dwim               t]
+    ["Fill comment paragraph"        ada-fill-comment-paragraph           
(wisi-in-comment-p)]
+    ["Fill comment paragraph justify" (ada-fill-comment-paragraph 'full)   
(wisi-in-comment-p)]
+    ["Fill comment paragraph postfix" (ada-fill-comment-paragraph 'full t) 
(wisi-in-comment-p)]
+    ["Adjust case at point"          wisi-case-adjust-at-point             
(not (use-region-p))]
+    ["Adjust case region"            wisi-case-adjust-region               
(use-region-p)]
+    ["Create full case exception"     wisi-case-create-exception         t]
+    ["Create partial case exception"  wisi-case-create-partial-exception t]
+    ["Indent current statement"              wisi-indent-statement             
t]
+    ["Expand skeleton"               wisi-skel-expand                  t]
+    ["Make body for subprogram"              ada-make-subprogram-body          
t]
     ))
 
 (defun ada-popup-menu ()
@@ -564,10 +340,10 @@ button was clicked."
 (easy-menu-define ada-refactor-menu nil
   "Context menu keymap for Ada mode refactor commands."
   '("Ada refactor"
-    ["Method (Object) => Object.Method"   ada-wisi-refactor-1 t]
-    ["Object.Method   => Method (Object)" ada-wisi-refactor-2 t]
-    ["Element (Object, Index) => Object (Index)" ada-wisi-refactor-3 t]
-    ["Object (Index) => Element (Object, Index)" ada-wisi-refactor-4 t]
+    ["Method (Object) => Object.Method"   ada-refactor-1 t]
+    ["Object.Method   => Method (Object)" ada-refactor-2 t]
+    ["Element (Object, Index) => Object (Index)" ada-refactor-3 t]
+    ["Object (Index) => Element (Object, Index)" ada-refactor-4 t]
     ))
 
 (defun ada-refactor-menu-popup ()
@@ -576,66 +352,6 @@ button was clicked."
   (mouse-set-point last-input-event)
   (popup-menu ada-refactor-menu))
 
-(defun ada-indent-newline-indent ()
-  "insert a newline, indent the old and new lines."
-  (interactive "*")
-  ;; point may be in the middle of a word, so insert newline first,
-  ;; then go back and indent.
-  (insert "\n")
-  (unless (and (wisi-partial-parse-p (line-beginning-position) 
(line-end-position))
-              (save-excursion (progn (forward-char -1)(looking-back 
"begin\\|else" (line-beginning-position)))))
-    ;; Partial parse may think 'begin' is just the start of a
-    ;; statement, when it's actually part of a larger declaration. So
-    ;; don't indent 'begin'. Similarly for 'else'; error recovery will
-    ;; probably insert 'if then' immediately before it
-    (forward-char -1)
-    (funcall indent-line-function)
-    (forward-char 1))
-  (funcall indent-line-function))
-
-(defvar ada-indent-statement nil
-  ;; indentation function
-  "Function to indent the statement/declaration point is in or after.
-Function is called with no arguments.")
-
-(defun ada-indent-statement ()
-  "Indent current statement."
-  (interactive)
-  (when ada-indent-statement
-    (funcall ada-indent-statement)))
-
-(defvar ada-expand nil
-  ;; skeleton function
-  "Function to call to expand tokens (ie insert skeletons).")
-
-(defun ada-expand ()
-  "Expand previous word into a statement skeleton."
-  (interactive)
-  (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
@@ -671,7 +387,7 @@ Placeholders are defined by the skeleton backend."
     ;; we don't put "when (match-beginning n)" here; missing a match
     ;; is a bug in the regexp.
     (goto-char (or (match-beginning 2) (match-beginning 1)))
-    (not (ada-in-string-or-comment-p))))
+    (not (wisi-in-string-or-comment-p))))
 
 (defconst ada-align-region-separate
   (eval-when-compile
@@ -686,991 +402,22 @@ Placeholders are defined by the skeleton backend."
      "function\\|"
      "generic\\|"
      "if\\|"
-     "is\\|"
-     "procedure\\|"
-     "private\\|"
-     "record\\|"
-     "return\\|"
-     "type\\|"
-     "when"
-     "\\)\\_>\\)"))
-  "See the variable `align-region-separate' for more information.")
-
-(defun ada-align ()
-  "If region is active, apply `align'. If not, attempt to align
-current construct."
-  (interactive)
-  (if (use-region-p)
-      (progn
-        (align (region-beginning) (region-end))
-        (deactivate-mark))
-
-    ;; else see if we are in a construct we know how to align
-    (let ((parse-result (syntax-ppss)))
-      (cond
-       ((ada-in-paramlist-p parse-result)
-        (ada-format-paramlist))
-
-       ((and
-        (ada-in-paren-p parse-result)
-        (ada-in-case-expression))
-       ;; align '=>'
-       (let ((begin (nth 1 parse-result))
-             (end   (scan-lists (point) 1 1)))
-         (align begin end 'entire)))
-
-       (t
-       (align-current))
-       ))))
-
-(defvar ada-in-paramlist-p nil
-  ;; Supplied by indentation engine parser
-  "Function to return t if point is inside the parameter-list of a subprogram 
declaration.
-Function is called with one optional argument; syntax-ppss result.")
-
-(defun ada-in-paramlist-p (&optional parse-result)
-  "Return t if point is inside the parameter-list of a subprogram declaration."
-  (when ada-in-paramlist-p
-    (funcall ada-in-paramlist-p parse-result)))
-
-(defvar ada-refactor-format-paramlist nil) ;; ada-wisi.el
-(declare-function ada-wisi-refactor "ada-wisi.el" (action))
-
-(defun ada-format-paramlist ()
-  "Reformat the parameter list point is in."
-  (interactive)
-  (condition-case nil
-      (ada-goto-open-paren)
-    (error
-     (user-error "Not in parameter list")))
-  (funcall indent-line-function); so new list is indented properly
-  (when (not (looking-back "^[ \t]*" (line-beginning-position)))
-    (delete-horizontal-space)
-    (insert " "))
-  (ada-wisi-refactor ada-refactor-format-paramlist))
-
-(defvar ada-reset-parser nil
-  ;; Supplied by indentation engine parser
-  "Function to reset parser, to clear confused state."
-  )
-
-(defun ada-reset-parser ()
-  "See variable ’ada-reset-parser’."
-  (interactive)
-  (when ada-reset-parser
-    (funcall ada-reset-parser)))
-
-(defvar ada-show-parse-error nil
-  ;; Supplied by indentation engine parser
-  "Function to show last error reported by indentation parser."
-  )
-
-(defun ada-show-parse-error ()
-  (interactive)
-  (when ada-show-parse-error
-    (funcall ada-show-parse-error)))
-
-;;;; auto-casing
-
-(defvar ada-case-full-exceptions '()
-  "Alist of words (entities) that have special casing, built from
-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
-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)
-    (mapc (lambda (x) (insert (car x) "\n"))
-         (sort (copy-sequence full-exceptions)
-               (lambda(a b) (string< (car a) (car b)))))
-    (mapc (lambda (x) (insert "*" (car x) "\n"))
-         (sort (copy-sequence partial-exceptions)
-               (lambda(a b) (string< (car a) (car b)))))
-    ))
-
-(defun ada-case-read-exceptions (file-name)
-  "Read the content of the casing exception file FILE-NAME.
-Return (cons full-exceptions partial-exceptions)."
-  (setq file-name (expand-file-name (substitute-in-file-name file-name)))
-  (if (file-readable-p file-name)
-      (let (full-exceptions partial-exceptions word)
-       (with-temp-buffer
-         (insert-file-contents file-name)
-         (while (not (eobp))
-
-           (setq word (buffer-substring-no-properties
-                       (point) (save-excursion (skip-syntax-forward "w_") 
(point))))
-
-           (if (char-equal (string-to-char word) ?*)
-               ;; partial word exception
-               (progn
-                 (setq word (substring word 1))
-                 (unless (assoc-string word partial-exceptions t)
-                   (push (cons word t) partial-exceptions)))
-
-             ;; full word exception
-             (unless (assoc-string word full-exceptions t)
-               (push (cons word t) full-exceptions)))
-
-           (forward-line 1))
-         )
-       (cons full-exceptions partial-exceptions))
-
-    ;; else file not readable; might be a new project with no
-    ;; exceptions yet, so just return empty pair
-    (message "'%s' is not a readable file." file-name)
-    '(nil . nil)
-    ))
-
-(defun ada-case-merge-exceptions (result new)
-  "Merge NEW exeptions into RESULT.
-An item in both lists has the RESULT value."
-  (dolist (item new)
-    (unless (assoc-string (car item) result t)
-      (push item result)))
-  result)
-
-(defun ada-case-merge-all-exceptions (exceptions)
-  "Merge EXCEPTIONS into `ada-case-full-exceptions', 
`ada-case-partial-exceptions'."
-  (setq ada-case-full-exceptions (ada-case-merge-exceptions 
ada-case-full-exceptions (car exceptions)))
-  (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 project casing files,
-replacing current values of `ada-case-full-exceptions', 
`ada-case-partial-exceptions'."
-  (interactive)
-  (setq ada-case-full-exceptions '()
-       ada-case-partial-exceptions '())
-
-  (when (ada-prj-get 'casing)
-    (dolist (file (ada-prj-get 'casing))
-      (ada-case-merge-all-exceptions (ada-case-read-exceptions file))))
-  )
-
-(defun ada-case-add-exception (word exceptions)
-  "Add case exception WORD to EXCEPTIONS, replacing current entry, if any."
-  (if (assoc-string word exceptions t)
-      (setcar (assoc-string word exceptions t) word)
-    (push (cons word t) exceptions))
-  exceptions)
-
-(defun ada-case-create-exception (&optional word file-name partial)
-  "Define WORD as an exception for the casing system, save it in FILE-NAME.
-If PARTIAL is non-nil, create a partial word exception.  WORD
-defaults to the active region, or the word at point.  User is
-prompted to choose a file from project variable casing if it is a
-list."
-  (interactive)
-  (let ((casing (ada-prj-get 'casing)))
-    (setq file-name
-         (cond
-          (file-name file-name)
-
-          ((< 1 (length casing))
-           (completing-read "case exception file: " casing
-                            nil ;; predicate
-                            t   ;; require-match
-                            nil ;; initial-input
-                            nil ;; hist
-                            (car casing) ;; default
-                            ))
-          ((= 1 (length casing))
-           (car casing))
-
-          (t
-           (if ada-prj-current-file
-               (error "No exception file specified; set `casing' in project 
file.")
-             ;; IMPROVEME: could prompt, but then need to write to actual 
project file
-             ;;        (let ((temp
-             ;;               (read-file-name
-             ;;                "No exception file specified; adding to 
project. file: ")))
-             ;;          (message "remember to add %s to project file" temp)
-             ;;          (ada-prj-put 'casing temp)
-             ;;          temp)
-             (error "No exception file specified, and no project active. See 
variable `ada-case-exception-file'.")))
-          )))
-
-  (unless word
-    (if (use-region-p)
-       (progn
-         (setq word (buffer-substring-no-properties (region-beginning) 
(region-end)))
-         (deactivate-mark))
-      (save-excursion
-       (let ((syntax (if partial "w" "w_")))
-         (skip-syntax-backward syntax)
-         (setq word
-               (buffer-substring-no-properties
-                (point)
-                (progn (skip-syntax-forward syntax) (point))
-                ))))))
-
-  (let* ((exceptions (ada-case-read-exceptions file-name))
-        (full-exceptions (car exceptions))
-        (partial-exceptions (cdr exceptions)))
-
-    (cond
-     ((null partial)
-      (setq ada-case-full-exceptions (ada-case-add-exception word 
ada-case-full-exceptions))
-      (setq full-exceptions (ada-case-add-exception word full-exceptions)))
-
-     (t
-      (setq ada-case-partial-exceptions (ada-case-add-exception word 
ada-case-partial-exceptions))
-      (setq partial-exceptions (ada-case-add-exception word 
partial-exceptions)))
-     )
-    (ada-case-save-exceptions full-exceptions partial-exceptions file-name)
-    (message "created %s case exception '%s' in file '%s'"
-            (if partial "partial" "full")
-            word
-            file-name)
-    ))
-
-(defun ada-case-create-partial-exception ()
-  "Define active region or word at point as a partial word exception.
-User is prompted to choose a file from project variable casing if it is a 
list."
-  (interactive)
-  (ada-case-create-exception nil nil t))
-
-(defun ada-in-based-numeric-literal-p ()
-  "Return t if point is after a prefix of a based numeric literal."
-  (looking-back "\\([0-9]+#[0-9a-fA-F_]+\\)" (line-beginning-position)))
-
-(defvar ada-keywords nil
-  "List of Ada keywords for current `ada-language-version'.")
-
-(defun ada-after-keyword-p ()
-  "Return non-nil if point is after an element of `ada-keywords'."
-  (let ((word (buffer-substring-no-properties
-              (save-excursion (skip-syntax-backward "w_") (point))
-              (point))))
-    (member (downcase word) ada-keywords)))
-
-(defun ada-case-keyword (beg end)
-  (cl-ecase ada-case-keyword
-    (lower-case (downcase-region beg end))
-    (upper-case (upcase-region beg end))
-    ))
-
-(defun ada-case-identifier (start end force-case-strict)
-  (cl-ecase ada-case-identifier
-    (mixed-case (ada-mixed-case start end force-case-strict))
-    (lower-case (downcase-region start end))
-    (upper-case (upcase-region start end))
-    ))
-
-(defun ada-mixed-case (start end force-case-strict)
-  "Adjust case of region START END to Mixed_Case."
-  (let ((done nil)
-       next)
-    (if (or force-case-strict ada-case-strict)
-       (downcase-region start end))
-    (goto-char start)
-    (while (not done)
-      (setq next
-           (or
-            (save-excursion (when (search-forward "_" end t) (point-marker)))
-            (copy-marker (1+ end))))
-
-      ;; upcase first char
-      (upcase-region (point) (1+ (point)))
-
-      (goto-char next)
-      (if (< (point) end)
-         (setq start (point))
-       (setq done t))
-      )))
-
-(defun ada-case-adjust-identifier (&optional force-case)
-  "Adjust case of the previous word as an identifier.
-Uses `ada-case-identifier', with exceptions defined in
-`ada-case-full-exceptions', `ada-case-partial-exceptions'."
-  (interactive)
-  (save-excursion
-    (let ((end   (point-marker))
-         (start (progn (skip-syntax-backward "w_") (point)))
-         match
-         next
-         (done nil))
-
-      (if (setq match (assoc-string (buffer-substring-no-properties start end) 
ada-case-full-exceptions t))
-         ;; full word exception
-         (progn
-           ;; 'save-excursion' puts a marker at 'end'; if we do
-           ;; 'delete-region' first, it moves that marker to 'start',
-           ;; then 'insert' inserts replacement text after the
-           ;; marker, defeating 'save-excursion'. So we do 'insert' first.
-           (insert (car match))
-           (delete-region (point) end))
-
-       ;; else apply ada-case-identifier
-       (ada-case-identifier start end force-case)
-
-       ;; apply partial-exceptions
-       (goto-char start)
-       (while (not done)
-         (setq next
-               (or
-                (save-excursion (when (search-forward "_" end t) 
(point-marker)))
-                (copy-marker (1+ end))))
-
-         (when (setq match (assoc-string (buffer-substring-no-properties start 
(1- next))
-                                       ada-case-partial-exceptions t))
-           ;; see comment above at 'full word exception' for why
-           ;; we do insert first.
-           (insert (car match))
-           (delete-region (point) (1- next)))
-
-         (goto-char next)
-         (if (< (point) end)
-             (setq start (point))
-           (setq done t))
-          )))))
-
-(defun ada-case-adjust-keyword ()
-  "Adjust the case of the previous word as a keyword.
-`word' here is allowed to be underscore-separated (GPR external_as_list)."
-  (save-excursion
-    (let ((end   (point-marker))
-         (start (progn (skip-syntax-backward "w_") (point))))
-      (ada-case-keyword start end)
-    )))
-
-(defun ada-case-adjust (&optional typed-char in-comment)
-  "Adjust the case of the word before point.
-When invoked interactively, TYPED-CHAR must be
-`last-command-event', and it must not have been inserted yet.
-If IN-COMMENT is non-nil, adjust case of words in comments and strings as code,
-and treat `ada-case-strict' as t in code.."
-  (when (not (bobp))
-    (when (save-excursion
-           (forward-char -1); back to last character in word
-           (and (not (bobp))
-                (eq (char-syntax (char-after)) ?w); it can be capitalized
-
-                (not (and (eq typed-char ?')
-                          (eq (char-before (point)) ?'))); character literal
-
-                (or in-comment
-                    (not (ada-in-string-or-comment-p)))
-                ;; we sometimes want to capitialize an Ada identifier
-                ;; referenced in a comment, via
-                ;; ada-case-adjust-at-point.
-
-                (not (ada-in-based-numeric-literal-p))
-                ;; don't adjust case on hex digits
-                ))
-
-      ;; The indentation engine may trigger a reparse on
-      ;; non-whitespace changes, but we know we don't need to reparse
-      ;; for this change (assuming the user has not abused case
-      ;; exceptions!).
-      (let ((inhibit-modification-hooks t))
-       (cond
-        ;; Some attributes are also keywords, but captialized as
-        ;; attributes. So check for attribute first.
-        ((and
-          (not in-comment)
-          (save-excursion
-            (skip-syntax-backward "w_")
-            (eq (char-before) ?')))
-         (ada-case-adjust-identifier in-comment))
-
-        ((and
-          (not in-comment)
-          (not (eq typed-char ?_))
-          (ada-after-keyword-p))
-         (ada-case-adjust-keyword))
-
-        (t (ada-case-adjust-identifier in-comment))
-        ))
-      )))
-
-(defun ada-case-adjust-at-point (&optional in-comment)
-  "If ’ada-auto-case’ is non-nil, adjust case of word at point, move to end of 
word.
-With prefix arg, adjust case as code even if in comment or string;
-otherwise, capitalize words in comments and strings.
-If ’ada-auto-case’ is nil, capitalize current word."
-  (interactive "P")
-  (cond
-   ((or (null ada-auto-case)
-       (and (not in-comment)
-            (ada-in-string-or-comment-p)))
-    (skip-syntax-backward "w_")
-    (capitalize-word 1))
-
-   (t
-    (when
-       (and (not (eobp))
-            ;; we use '(syntax-after (point))' here, not '(char-syntax
-            ;; (char-after))', because the latter does not respect
-            ;; ada-syntax-propertize.
-            (memq (syntax-class (syntax-after (point))) '(2 3)))
-      (skip-syntax-forward "w_"))
-    (ada-case-adjust nil in-comment))
-   ))
-
-(defun ada-case-adjust-region (begin end)
-  "Adjust case of all words in region BEGIN END."
-  (interactive "r")
-  (narrow-to-region begin end)
-  (save-excursion
-    (goto-char begin)
-    (while (not (eobp))
-      (forward-comment (point-max))
-      (skip-syntax-forward "^w_")
-      (skip-syntax-forward "w_")
-      (ada-case-adjust)))
-  (widen))
-
-(defun ada-case-adjust-buffer ()
-  "Adjust case of current buffer."
-  (interactive)
-  (ada-case-adjust-region (point-min) (point-max)))
-
-(defun ada-case-adjust-interactive (arg)
-  "If `ada-auto-case' is non-nil, adjust the case of the previous word, and 
process the character just typed.
-To be bound to keys that should cause auto-casing.
-ARG is the prefix the user entered with \\[universal-argument]."
-  (interactive "P")
-
-  ;; character typed has not been inserted yet
-  (let ((lastk last-command-event)
-       (do-adjust nil))
-    (cond
-     ((null ada-auto-case))
-     ((eq ada-auto-case 'not-upper-case)
-      (save-excursion
-       (let* ((begin (progn (skip-syntax-backward "w_") (point)))
-              (end  (progn (skip-syntax-forward "w_") (point)))
-              (word (buffer-substring-no-properties begin end)))
-         (setq do-adjust (not (string-equal word (upcase word)))))))
-     (t
-      (setq do-adjust t)))
-
-    (cond
-     ((eq lastk ?\n)
-        (when do-adjust
-         (ada-case-adjust lastk))
-       (funcall ada-lfd-binding))
-
-     ((memq lastk '(?\r return))
-      (when do-adjust
-       (ada-case-adjust lastk))
-      (funcall ada-ret-binding))
-
-     (t
-      (when do-adjust
-       (ada-case-adjust lastk))
-      (self-insert-command (prefix-numeric-value arg)))
-     )))
-
-;;;; project files
-
-;; An Emacs Ada mode project file can specify several things:
-;;
-;; - a compiler-specific project file
-;;
-;; - compiler-specific environment variables
-;;
-;; - other compiler-specific things (see the compiler support elisp code)
-;;
-;; - a list of source directories (in addition to those specified in the 
compiler project file)
-;;
-;; - a casing exception file
-;;
-;; All of the data used by Emacs Ada mode functions specified in a
-;; project file is stored in a property list. The property list is
-;; stored in an alist indexed by the project file name, so multiple
-;; project files can be selected without re-parsing them (some
-;; compiler project files can take a long time to parse).
-
-(defvar ada-prj-alist nil
-  "Alist holding currently parsed Emacs Ada project files. Indexed by absolute 
project file name.")
-
-(defvar ada-prj-current-file nil
-  "Current Emacs Ada project file.")
-
-(defvar ada-prj-current-project nil
-  "Current Emacs Ada mode project; a plist.")
-
-(defun ada-prj-get (prop &optional plist)
-  "Return value of PROP in PLIST.
-Optional PLIST defaults to `ada-prj-current-project'."
-  (let ((prj (or plist ada-prj-current-project)))
-    (if prj
-       (plist-get prj prop)
-
-      ;; no project, just use default vars
-      ;; must match code in ada-prj-default, except for src_dir.
-      (cl-case prop
-       (ada_compiler    ada-compiler)
-       (auto_case       ada-auto-case)
-       (case_keyword    ada-case-keyword)
-       (case_identifier ada-case-identifier)
-       (case_strict     ada-case-strict)
-       (casing          (if (listp ada-case-exception-file)
-                            ada-case-exception-file
-                          (list ada-case-exception-file)))
-       (path_sep        path-separator)
-       (proc_env        (cl-copy-list process-environment))
-       (src_dir         (list (directory-file-name default-directory)))
-        (obj_dir         (list (directory-file-name default-directory)))
-       (xref_tool       ada-xref-tool)
-       ))))
-
-(defun ada-prj-put (prop val &optional plist)
-  "Set value of PROP in PLIST to VAL.
-Optional PLIST defaults to `ada-prj-current-project'."
-  (plist-put (or plist ada-prj-current-project) prop val))
-
-(defun ada-require-project-file ()
-  (unless ada-prj-current-file
-    (error "no Emacs Ada project file specified")))
-
-(defvar ada-prj-default-list nil
-  ;; project file parse
-  "List of functions to add default project variables. Called
-with one argument; the default project properties
-list. `default-directory' is set to the directory containing the
-project file. Function should add to the properties list and
-return it.")
-
-(defvar ada-prj-default-compiler-alist nil
-  ;; project file parse
-  "Compiler-specific function to set default project variables.
-Indexed by ada-compiler.  Called with one argument; the default
-project properties list. Function should add to the properties
-list and return it.")
-
-(defvar ada-prj-default-xref-alist nil
-  ;; project file parse
-  "Xref-tool-specific function to set default project variables.
-Indexed by ada-xref-tool.  Called with one argument; the default
-project properties list. Function should add to the properties
-list and return it.")
-
-(defun ada-prj-default (&optional src-dir)
-  "Return the default project properties list.
-If SRC-DIR is non-nil, use it as the default for src_dir.
-Include properties set via `ada-prj-default-compiler-alist',
-`ada-prj-default-xref-alist'."
-
-  (let (project func)
-    (setq
-     project
-     (list
-      ;; variable name alphabetical order
-      'ada_compiler    ada-compiler
-      'auto_case       ada-auto-case
-      'case_keyword    ada-case-keyword
-      'case_identifier ada-case-identifier
-      'case_strict     ada-case-strict
-      'casing          (if (listp ada-case-exception-file)
-                          ada-case-exception-file
-                        (list ada-case-exception-file))
-      'path_sep        path-separator;; prj variable so users can override it 
for their compiler
-      'proc_env        (cl-copy-list process-environment)
-      'src_dir         (if src-dir (list src-dir) nil)
-      'xref_tool       ada-xref-tool
-      ))
-
-    (cl-dolist (func ada-prj-default-list)
-      (setq project (funcall func project)))
-
-    (setq func (cdr (assq ada-compiler ada-prj-default-compiler-alist)))
-    (when func (setq project (funcall func project)))
-    (setq func (cdr (assq ada-xref-tool ada-prj-default-xref-alist)))
-    (when func (setq project (funcall func project)))
-    project))
-
-(defvar ada-prj-parser-alist
-  (mapcar
-   (lambda (ext) (cons ext #'ada-prj-parse-file-1))
-   ada-prj-file-extensions)
-  ;; project file parse
-  "Alist of parsers for project files, indexed by file extension.
-Default provides the minimal Ada mode parser; compiler support
-code may add other parsers.  Parser is called with two arguments;
-the project file name and the current project property
-list. Parser must modify or add to the property list and return it.")
-
-;; This autoloaded because it is often used in Makefiles, and thus
-;; will be the first ada-mode function executed.
-;;;###autoload
-(defun ada-parse-prj-file (prj-file)
-  "Read Emacs Ada or compiler-specific project file PRJ-FILE, set project 
properties in `ada-prj-alist'."
-  ;; Not called ada-prj-parse-file for Ada mode 4.01 compatibility
-  (setq prj-file (expand-file-name prj-file))
-
-  (unless (file-readable-p prj-file)
-    (error "Project file '%s' is not readable" prj-file))
-
-  (run-hooks `ada-prj-parse-hook)
-
-  (let* ((default-directory (file-name-directory prj-file))
-        (project (ada-prj-default))
-        (parser (cdr (assoc (file-name-extension prj-file) 
ada-prj-parser-alist))))
-
-    (if parser
-       ;; parser may reference the "current project", so bind that now.
-       (let ((ada-prj-current-project project)
-             (ada-prj-current-file prj-file))
-         (setq project (funcall parser prj-file project)))
-      (error "no project file parser defined for '%s'" prj-file))
-
-    ;; Store the project properties
-    (if (assoc prj-file ada-prj-alist)
-       (setcdr (assoc prj-file ada-prj-alist) project)
-      (add-to-list 'ada-prj-alist (cons prj-file project)))
-
-    ;; return t for interactive use
-    t))
-
-(defun ada-prj-reparse-select-current ()
-  "Reparse the current project file, re-select it.
-Useful when the project file has been edited."
-  (interactive)
-  (ada-parse-prj-file ada-prj-current-file)
-  (ada-select-prj-file ada-prj-current-file))
-
-(defun ada-reset-comp-prj ()
-  "Reset compilation and project vars affected by a change in compiler version.
-Useful when experimenting with an upgraded compiler."
-  (interactive)
-  (when (buffer-live-p "*compilation*")
-    (with-current-buffer "*compilation*"
-      (setq compilation-environment nil)))
-  (setq ada-prj-alist nil)
-  (setq ada-prj-current-project nil)
-  )
-
-(defvar ada-prj-parse-one-compiler nil
-  ;; project file parse
-  "Compiler-specific function to process one Ada project property.
-Indexed by project variable ada_compiler.
-Called with three arguments; the property name, property value,
-and project properties list. Function should add to or modify the
-properties list and return it, or return nil if the name is not
-recognized.")
-
-(defvar ada-prj-parse-one-xref nil
-  ;; project file parse
-  "Xref-tool-specific function to process one Ada project property.
-Indexed by project variable xref_tool.
-Called with three arguments; the property name, property value,
-and project properties list. Function should add to or modify the
-properties list and return it, or return nil if the name is not
-recognized.")
-
-(defvar ada-prj-parse-final-compiler nil
-  ;; project file parse
-  "Alist of compiler-specific functions to finish processing Ada project 
properties.
-Indexed by project variable ada_compiler.
-Called with one argument; the project properties list. Function
-should add to or modify the list and return it.")
-
-(defvar ada-prj-parse-final-xref nil
-  ;; project file parse
-  "Alist of xref-tool-specific functions to finish processing Ada project 
properties.
-Indexed by project variable xref_tool.
-Called with one argument; the project properties list. Function
-should add to or modify the list and return it.")
-
-(defun ada-prj-parse-file-1 (prj-file project)
-  "Parse the Ada mode project file PRJ-FILE, set project properties in PROJECT.
-Return new value of PROJECT."
-  (let (;; fields that are lists or that otherwise require special processing
-       casing src_dir obj_dir
-       tmp-prj
-       (parse-one-compiler (cdr (assoc ada-compiler 
ada-prj-parse-one-compiler)))
-       (parse-final-compiler (cdr (assoc ada-compiler 
ada-prj-parse-final-compiler)))
-       (parse-one-xref (cdr (assoc ada-xref-tool ada-prj-parse-one-xref)))
-       (parse-final-xref (cdr (assoc ada-xref-tool ada-prj-parse-final-xref))))
-
-    (with-current-buffer (find-file-noselect prj-file)
-      (goto-char (point-min))
-
-      ;; process each line
-      (while (not (eobp))
-
-       ;; ignore lines that don't have the format "name=value", put
-       ;; 'name', 'value' in match-string.
-       (when (looking-at "^\\([^=\n]+\\)=\\(.*\\)")
-         (cond
-          ;; variable name alphabetical order
-
-          ((string= (match-string 1) "ada_compiler")
-           (let ((comp (intern (match-string 2))))
-             (setq project (plist-put project 'ada_compiler comp))
-             (setq parse-one-compiler (cdr (assq comp 
ada-prj-parse-one-compiler)))
-             (setq parse-final-compiler (cdr (assq comp 
ada-prj-parse-final-compiler)))))
-
-          ((string= (match-string 1) "auto_case")
-           (setq project (plist-put project 'auto_case (intern (match-string 
2)))))
-
-          ((string= (match-string 1) "case_keyword")
-           (setq project (plist-put project 'case_keyword (intern 
(match-string 2)))))
-
-          ((string= (match-string 1) "case_identifier")
-           (setq project (plist-put project 'case_identifier (intern 
(match-string 2)))))
-
-          ((string= (match-string 1) "case_strict")
-           (setq project (plist-put project 'case_strict (intern (match-string 
2)))))
-
-          ((string= (match-string 1) "casing")
-            (cl-pushnew (expand-file-name
-                         (substitute-in-file-name (match-string 2)))
-                        casing :test #'equal))
-
-          ((string= (match-string 1) "el_file")
-           (let ((file (expand-file-name (substitute-in-file-name 
(match-string 2)))))
-             (setq project (plist-put project 'el_file file))
-             ;; eval now as well as in select, since it might affect parsing
-             (load-file file)))
-
-          ((string= (match-string 1) "src_dir")
-            (cl-pushnew (file-name-as-directory
-                         (expand-file-name (match-string 2)))
-                        src_dir :test #'equal))
-
-          ((string= (match-string 1) "obj_dir")
-           (cl-pushnew (file-name-as-directory
-                        (expand-file-name (match-string 2)))
-                       obj_dir :test #'equal))
-
-          ((string= (match-string 1) "xref_tool")
-           (let ((xref (intern (match-string 2))))
-             (setq project (plist-put project 'xref_tool xref))
-             (setq parse-one-xref (cdr (assq xref ada-prj-parse-one-xref)))
-             (setq parse-final-xref (cdr (assq xref 
ada-prj-parse-final-xref)))))
-
-          (t
-           (if (or
-                (and parse-one-compiler
-                     (setq tmp-prj (funcall parse-one-compiler (match-string 
1) (match-string 2) project)))
-                (and parse-one-xref
-                     (setq tmp-prj (funcall parse-one-xref (match-string 1) 
(match-string 2) project))))
-
-               (setq project tmp-prj)
-
-             ;; Any other field in the file is set as an environment
-             ;; variable or a project file variable.
-             (if (= ?$ (elt (match-string 1) 0))
-                 ;; process env var. We don't do expand-file-name
-                 ;; here because the application may be expecting a
-                 ;; simple string.
-                 (let ((process-environment (cl-copy-list (plist-get project 
'proc_env))))
-                   (setenv (substring (match-string 1) 1)
-                           (substitute-in-file-name (match-string 2)))
-                   (setq project
-                         (plist-put project 'proc_env (cl-copy-list 
process-environment))))
-
-               ;; not recognized; assume it is a user-defined variable like 
"comp_opt"
-               (setq project (plist-put project (intern (match-string 1)) 
(match-string 2)))
-             )))
-          ))
-
-       (forward-line 1))
-
-      );; done reading file
-
-    ;; process accumulated lists
-    (if casing (setq project (plist-put project 'casing (reverse casing))))
-    (if src_dir (setq project (plist-put project 'src_dir (reverse src_dir))))
-    (if obj_dir (setq project (plist-put project 'obj_dir (reverse obj_dir))))
-
-    (when parse-final-compiler
-      ;; parse-final-compiler may reference the "current project", so
-      ;; bind that now, to include the properties set above.
-      (let ((ada-prj-current-project project)
-           (ada-prj-current-file prj-file))
-       (setq project (funcall parse-final-compiler project))))
-
-    (when parse-final-xref
-      (let ((ada-prj-current-project project)
-           (ada-prj-current-file prj-file))
-       (setq project (funcall parse-final-xref project))))
-
-    project
-    ))
-
-(defvar ada-select-prj-compiler nil
-  "Alist of functions to call for compiler specific project file selection.
-Indexed by project variable ada_compiler.")
-
-(defvar ada-deselect-prj-compiler nil
-  "Alist of functions to call for compiler specific project file deselection.
-Indexed by project variable ada_compiler.")
-
-(defvar ada-select-prj-xref-tool nil
-  "Alist of functions to call for xref-tool specific project file selection.
-Indexed by project variable xref_tool.")
-
-(defvar ada-deselect-prj-xref-tool nil
-  "Alist of functions to call for xref-tool specific project file deselection.
-Indexed by project variable xref_tool.")
-
-(defun ada-refresh-prj-file ()
-  "Reparse, reselect current project file.
-Useful when project has been edited."
-  (interactive)
-  (let* ((prj-file ada-prj-current-file)
-        (parsed (assoc prj-file ada-prj-alist)))
-    (setq ada-prj-current-file nil)
-    (setq ada-prj-current-project nil)
-    (when parsed
-      (setq ada-prj-alist (delq parsed ada-prj-alist)))
-    (ada-select-prj-file prj-file nil)))
-
-;; This is autoloaded because it is often used in Makefiles, and thus
-;; will be the first ada-mode function executed.
-;;;###autoload
-(defun ada-select-prj-file (prj-file &optional no-force)
-  "Select PRJ-FILE as the current project file, parsing it if necessary.
-Deselects the current project first."
-  (interactive)
-  (setq prj-file (expand-file-name prj-file))
-
-  (when (or (not no-force)
-           (not (string-equal prj-file ada-prj-current-project)))
-    (setq ada-prj-current-project (cdr (assoc prj-file ada-prj-alist)))
-
-    (when (null ada-prj-current-project)
-      (setq ada-prj-current-file nil)
-      (ada-parse-prj-file prj-file)
-      (setq ada-prj-current-project (cdr (assoc prj-file ada-prj-alist)))
-      (when (null ada-prj-current-project)
-       (error "Project file '%s' parse failed." prj-file)))
-
-    (let ((func (cdr (assq (ada-prj-get 'ada_compiler) 
ada-deselect-prj-compiler))))
-      (when func (funcall func)))
-
-    (let ((func (cdr (assq (ada-prj-get 'xref_tool) 
ada-deselect-prj-xref-tool))))
-      (when func (funcall func)))
-
-    (setq ada-prj-current-file prj-file)
-
-    ;; Project file should fully specify what compilers are used,
-    ;; including what compilation filters they need. There may be more
-    ;; than just an Ada compiler.
-    (setq compilation-error-regexp-alist nil)
-    (setq compilation-filter-hook nil)
-
-    (when (ada-prj-get 'el_file)
-      (load-file (ada-prj-get 'el_file)))
-
-    (ada-case-read-all-exceptions)
-
-    (setq compilation-search-path (ada-prj-get 'src_dir))
-
-    (let ((func (cdr (assq (ada-prj-get 'ada_compiler) 
ada-select-prj-compiler))))
-      (when func (funcall func)))
-
-    (let ((func (cdr (assq (ada-prj-get 'xref_tool) 
ada-select-prj-xref-tool))))
-      (when func (funcall func)))
-
-    ;; return 't', for decent display in message buffer when called 
interactively
-    t))
-
-(defun ada-deselect-prj (prj)
-  "Deselect the project file PRJ, if current."
-  ;; For use as ’project-deselect’ (experimental). Duplicates part of
-  ;; ’ada-select-prj-file’; should delete that, use this.
-  (when (string-equal prj ada-prj-current-file)
-    (let ((func (cdr (assq (ada-prj-get 'ada_compiler) 
ada-deselect-prj-compiler))))
-      (when func (funcall func)))
-
-    (let ((func (cdr (assq (ada-prj-get 'xref_tool) 
ada-deselect-prj-xref-tool))))
-      (when func (funcall func)))
-
-    (setq ada-prj-current-project nil)
-    ))
-
-(defun ada-create-select-default-prj (&optional directory)
-  "Create a default project with src_dir set to DIRECTORY (default current 
directory), select it."
-  (let* ((dir (or directory default-directory))
-        (prj-file (expand-file-name "default_.adp" dir))
-        (project (ada-prj-default dir)))
-
-    (if (assoc prj-file ada-prj-alist)
-       (setcdr (assoc prj-file ada-prj-alist) project)
-      (add-to-list 'ada-prj-alist (cons prj-file project)))
-
-    (ada-select-prj-file prj-file)
-    ))
-
-(defun ada-prj-select ()
-  "Select the current project file from the list of currently available 
project files."
-  (interactive)
-  (ada-select-prj-file (completing-read "project: " ada-prj-alist nil t))
-  )
-
-(defun ada-prj-delete ()
-  "Delete a project file from the list of currently available project files."
-  (interactive)
-  (let* ((prj-file (completing-read "project: " ada-prj-alist nil t))
-        (prj-entry (assoc prj-file ada-prj-alist)))
-    (setq ada-prj-alist (delete prj-entry ada-prj-alist))
-    ))
-
-(defun ada-prj-show ()
-  "Show current Emacs Ada mode project file."
-  (interactive)
-  (message "current Emacs Ada mode project file: %s" ada-prj-current-file))
-
-(defvar ada-prj-show-prj-path nil
-  ;; Supplied by compiler
-  "Function to show project file search path used by compiler (and possibly 
xref tool)."
-  )
-
-(defun ada-prj-show-prj-path ()
-  (interactive)
-  (when ada-prj-show-prj-path
-    (funcall ada-prj-show-prj-path)))
-
-(defun ada-prj-show-src-path ()
-  "Show the project source file search path."
-  (interactive)
-  (if compilation-search-path
-      (progn
-       (pop-to-buffer (get-buffer-create "*Ada project source file search 
path*"))
-       (erase-buffer)
-       (dolist (file compilation-search-path)
-         (insert (format "%s\n" file))))
-    (message "no project source file search path set")
-    ))
-
-(defvar ada-show-xref-tool-buffer nil
-  ;; Supplied by xref tool
-  "Function to show process buffer used by xref tool."
-  )
-
-(defun ada-show-xref-tool-buffer ()
-  (interactive)
-  (when ada-show-xref-tool-buffer
-    (funcall ada-show-xref-tool-buffer)))
+     "is\\|"
+     "procedure\\|"
+     "private\\|"
+     "record\\|"
+     "return\\|"
+     "type\\|"
+     "when"
+     "\\)\\_>\\)"))
+  "See the variable `align-region-separate' for more information.")
 
 ;;;; syntax properties
 
 (defvar ada-mode-syntax-table
   (let ((table (make-syntax-table)))
     ;; (info "(elisp)Syntax Class Table" "*info syntax class table*")
+    ;; (info "(elisp) Syntax Flags") for comment start/end
     ;; make-syntax-table sets all alphanumeric to w, etc; so we only
     ;; have to add ada-specific things.
 
@@ -1686,23 +433,22 @@ Deselects the current project first."
     (modify-syntax-entry ?&  "." table)
     (modify-syntax-entry ?*  "." table)
     (modify-syntax-entry ?+  "." table)
-    (modify-syntax-entry ?-  "." table); operator; see ada-syntax-propertize 
for double hyphen as comment
+    (modify-syntax-entry ?-  ". 124" table); operator, double hyphen as comment
     (modify-syntax-entry ?. "." table)
     (modify-syntax-entry ?/  "." table)
     (modify-syntax-entry ?:  "." table)
     (modify-syntax-entry ?<  "." table)
     (modify-syntax-entry ?=  "." table)
     (modify-syntax-entry ?>  "." table)
+    (modify-syntax-entry ?@  "." table)
     (modify-syntax-entry ?\' "." table); attribute; see ada-syntax-propertize 
for character literal
     (modify-syntax-entry ?\; "." table)
     (modify-syntax-entry ?\\ "." table); default is escape; not correct for 
Ada strings
     (modify-syntax-entry ?\|  "." table)
 
     ;; \f and \n end a comment.
-    ;; comment start set in ada-syntax-propertize.
-    ;; flag ’s’ experimental; end unterminated string at newline.
-    (modify-syntax-entry ?\f  "> s" table)
-    (modify-syntax-entry ?\n  "> s" table)
+    (modify-syntax-entry ?\f  ">" table)
+    (modify-syntax-entry ?\n  ">" table)
 
     (modify-syntax-entry ?_ "_" table); symbol constituents, not word.
 
@@ -1719,13 +465,6 @@ Deselects the current project first."
     )
   "Syntax table to be used for editing Ada source code.")
 
-(defvar ada-syntax-propertize-hook nil
-  ;; provided by preprocessor, lumped with xref-tool
-  "Hook run from `ada-syntax-propertize'.
-Called by `syntax-propertize', which is called by font-lock in
-`after-change-functions'. Therefore, care must be taken to avoid
-race conditions with the grammar parser.")
-
 (defun ada-syntax-propertize (start end)
   "For `syntax-propertize-function'.
 Assign `syntax-table' properties in region START .. END.
@@ -1742,7 +481,6 @@ Runs `ada-syntax-propertize-hook'."
              (concat
               "[^a-zA-Z0-9)]\\('\\)[^'\n]\\('\\)"; 1, 2: character literal, 
not attribute
               "\\|[^a-zA-Z0-9)]\\('''\\)"; 3: character literal '''
-              "\\|\\(--\\)"; 4: comment start
               )
              end t)
        ;; syntax-propertize-extend-region-functions is set to
@@ -1760,49 +498,10 @@ Runs `ada-syntax-propertize-hook'."
           (match-beginning 3) (1+ (match-beginning 3)) 'syntax-table '(7 . ?'))
          (put-text-property
           (1- (match-end 3)) (match-end 3) 'syntax-table '(7 . ?')))
-        ((match-beginning 4)
-         (put-text-property
-          (match-beginning 4) (match-end 4) 'syntax-table '(11 . nil)))
         )))
     (run-hook-with-args 'ada-syntax-propertize-hook start end))
   )
 
-(defun ada-in-comment-p (&optional parse-result)
-  "Return t if inside a comment.
-If PARSE-RESULT is non-nil, use it instead of calling `syntax-ppss'."
-  (nth 4 (or parse-result (syntax-ppss))))
-
-(defun ada-in-string-p (&optional parse-result)
-  "Return t if point is inside a string.
-If PARSE-RESULT is non-nil, use it instead of calling `syntax-ppss'."
-  (nth 3 (or parse-result (syntax-ppss))))
-
-(defun ada-in-string-or-comment-p (&optional parse-result)
-  "Return t if inside a comment or string.
-If PARSE-RESULT is non-nil, use it instead of calling `syntax-ppss'."
-  (setq parse-result (or parse-result (syntax-ppss)))
-  (or (ada-in-string-p parse-result) (ada-in-comment-p parse-result)))
-
-(defun ada-in-paren-p (&optional parse-result)
-  "Return t if point is inside a pair of parentheses.
-If PARSE-RESULT is non-nil, use it instead of calling `syntax-ppss'."
-  (> (nth 0 (or parse-result (syntax-ppss))) 0))
-
-(defun ada-pos-in-paren-p (pos)
-  "Return t if POS is inside a pair of parentheses."
-  (save-excursion
-    (> (nth 0 (syntax-ppss pos)) 0)))
-
-(defun ada-same-paren-depth-p (pos1 pos2)
-  "Return t if POS1 is at same parentheses depth as POS2."
-  (= (nth 0 (syntax-ppss pos1)) (nth 0 (syntax-ppss pos2))))
-
-(defun ada-goto-open-paren (&optional offset parse-result)
-  "Move point to innermost opening paren surrounding current point, plus 
OFFSET.
-Throw error if not in paren.  If PARSE-RESULT is non-nil, use it
-instead of calling `syntax-ppss'."
-  (goto-char (+ (or offset 0) (nth 1 (or parse-result (syntax-ppss))))))
-
 ;;;; navigation within and between files
 
 (defvar ada-body-suffixes '(".adb")
@@ -1819,34 +518,10 @@ The extensions should include a `.' if needed.")
   "Alist used by `find-file' to find the name of the other package.
 See `ff-other-file-alist'.")
 
-(defconst ada-name-regexp
-  "\\(\\(?:\\sw\\|[_.]\\)+\\)")
-
 (defconst ada-parent-name-regexp
   "\\([a-zA-Z0-9_\\.]+\\)\\.[a-zA-Z0-9_]+"
   "Regexp for extracting the parent name from fully-qualified name.")
 
-(defvar ada-file-name-from-ada-name nil
-  ;; determined by ada-xref-tool, set by *-select-prj
-  "Function called with one parameter ADA-NAME, which is a library
-unit name; it should return the filename in which ADA-NAME is
-found.")
-
-(defun ada-file-name-from-ada-name (ada-name)
-  "Return the filename in which ADA-NAME is found."
-  (ada-require-project-file)
-  (funcall ada-file-name-from-ada-name ada-name))
-
-(defvar ada-ada-name-from-file-name nil
-  ;; 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.")
-
-(defun ada-ada-name-from-file-name (file-name)
-  "Return the ada-name that should be found in FILE-NAME."
-  (ada-require-project-file)
-  (funcall ada-ada-name-from-file-name file-name))
-
 (defun ada-ff-special-extract-parent ()
   (setq ff-function-name (match-string 1))
   (file-name-nondirectory
@@ -1889,62 +564,91 @@ unit name; it should return the Ada name that should be 
found in FILE-NAME.")
               'ada-ff-special-with)
         )))
 
-(defvar ada-which-function nil
-  ;; supplied by indentation engine
-  ;;
-  ;; This is run from ff-pre-load-hook, so ff-function-name may have
-  ;; been set by ff-treat-special; don't reset it.
-  "Function called with one parameter (INCLUDE-TYPE); it should
-return the name of the package, protected type, subprogram,
-entry, or task type whose definition/declaration point is in, or
-for declarations that don't have declarative regions, just after;
-or nil.
-
-If INCLUDE-TYPE is non-nil, include type names.
-
-In addition, if `ff-function-name' is non-nil, store in
-`ff-function-name' a regexp that will find the function in the
-other file.")
+(defun ada-which-function-1 (keyword add-body)
+  "Used in `ada-which-function'."
+  (let* ((result (wisi-next-name)))
+
+    ;; See comment in ada-which-function on why we don't
+    ;; overwrite ff-function-name.
+    (when (not ff-function-name)
+      (setq ff-function-name
+           (concat
+            keyword
+            (when add-body "\\s-+body")
+            "\\s-+"
+            result
+            "\\_>")))
+    result))
 
 (defun ada-which-function (&optional include-type)
-  "See `ada-which-function' variable."
-  (when ada-which-function
-    (funcall ada-which-function include-type)))
-
-(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-in-case-expression nil
-  ;; supplied by indentation engine
-  "Function called with no parameters; it should return non-nil
-  if point is in a case expression.")
-
-(defun ada-in-case-expression ()
-  "See `ada-in-case-expression' variable."
-  (interactive)
-  (when ada-in-case-expression
-    (funcall ada-in-case-expression)))
-
-(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)))
+  "Return name of subprogram/task/package containing point.
+Also sets ff-function-name for ff-pre-load-hook."
+  ;; Fail gracefully and silently, since this could be called from
+  ;; which-function-mode.
+  (let ((parse-begin (max (point-min) (- (point) (/ ada-which-func-parse-size 
2))))
+       (parse-end   (min (point-max) (+ (point) (/ ada-which-func-parse-size 
2)))))
+    (save-excursion
+      (condition-case nil
+         (progn
+           (wisi-validate-cache parse-begin parse-end nil 'navigate)
+           (when (wisi-cache-covers-region parse-begin parse-end 'navigate)
+             (let ((result nil)
+                   (cache (ada-goto-declaration-start-1 include-type)))
+               (if (null cache)
+                   ;; bob or failed parse
+                   (setq result "")
+
+                 (when (memq (wisi-cache-nonterm cache)
+                             '(generic_package_declaration 
generic_subprogram_declaration))
+                   ;; name is after next statement keyword
+                   (setq cache (wisi-next-statement-cache cache)))
+
+                 ;; add or delete 'body' as needed
+                 (cl-ecase (wisi-cache-nonterm cache)
+                   ((entry_body entry_declaration)
+                    (setq result (ada-which-function-1 "entry" nil)))
+
+                   (full_type_declaration
+                    (setq result (ada-which-function-1 "type" nil)))
+
+                   (package_body
+                    (setq result (ada-which-function-1 "package" nil)))
+
+                   ((package_declaration
+                     package_specification) ;; after 'generic'
+                    (setq result (ada-which-function-1 "package" t)))
+
+                   (protected_body
+                    (setq result (ada-which-function-1 "protected" nil)))
+
+                   ((protected_type_declaration single_protected_declaration)
+                    (setq result (ada-which-function-1 "protected" t)))
+
+                   ((abstract_subprogram_declaration
+                     expression_function_declaration
+                     subprogram_declaration
+                     subprogram_renaming_declaration
+                     generic_subprogram_declaration ;; after 'generic'
+                     null_procedure_declaration)
+                    (setq result (ada-which-function-1
+                                  (progn (search-forward-regexp 
"function\\|procedure")(match-string 0))
+                                  nil))) ;; no 'body' keyword in subprogram 
bodies
+
+                   (subprogram_body
+                    (setq result (ada-which-function-1
+                                  (progn (search-forward-regexp 
"function\\|procedure")(match-string 0))
+                                  nil)))
+
+                   ((single_task_declaration task_type_declaration)
+                    (setq result (ada-which-function-1 "task" t)))
+
+
+                   (task_body
+                    (setq result (ada-which-function-1 "task" nil)))
+                   ))
+               result)))
+       (error "")))
+    ))
 
 (defun ada-add-log-current-function ()
   "For `add-log-current-defun-function'."
@@ -1956,6 +660,39 @@ other file.")
     (back-to-indentation)
     (ada-which-function t)))
 
+(defun ada-on-context-clause ()
+  "Return non-nil if point is on a context clause."
+  (interactive)
+  (let (cache)
+    (save-excursion
+      ;; Don't require parse of large file just for ada-find-other-file
+      (and (< (point-max) wisi-size-threshold)
+          (setq cache (wisi-goto-statement-start))
+          (memq (wisi-cache-nonterm cache) '(use_clause with_clause))
+          ))))
+
+(defun ada-goto-subunit-name ()
+  "Return non-nil if the current buffer contains a subunit.
+Also move point to the subunit name. If no subunit, leave point
+alone, return nil."
+  (interactive)
+  (wisi-validate-cache (point-min) (point-max) t 'navigate)
+
+  (let (cache
+       (name-pos nil))
+    (save-excursion
+      ;; move to top declaration
+      (goto-char (point-min))
+      (setq cache (or (wisi-get-cache (point))
+                     (wisi-forward-cache)))
+
+      (when (eq (wisi-cache-nonterm cache) 'subunit)
+       (setq name-pos (car (wisi-next-name-region))))
+      )
+    (when name-pos
+      (goto-char name-pos))
+    ))
+
 (defun ada-set-point-accordingly ()
   "Move to the string specified in `ff-function-name', which may be a regexp,
 previously set by a file navigation command."
@@ -1972,7 +709,7 @@ previously set by a file navigation command."
            (setq found (match-beginning 0))
          ;; not in remainder of buffer
          (setq done t))
-       (if (ada-in-string-or-comment-p)
+       (if (wisi-in-string-or-comment-p)
            (setq found nil)
          (setq done t)))
       (when found
@@ -1981,30 +718,6 @@ previously set by a file navigation command."
        (back-to-indentation))
       (setq ff-function-name nil))))
 
-(defun ada-check-current-project (file-name)
-  "Throw error if FILE-NAME (must be absolute) is not found in
-the current project source directories, or if no project has been
-set."
-  (when (null (car compilation-search-path))
-    (error "no file search path defined; set project file?"))
-
-  ;; file-truename handles symbolic links
-  (let* ((visited-file (file-truename file-name))
-         (found-file (locate-file (file-name-nondirectory visited-file)
-                                 compilation-search-path)))
-    (unless found-file
-      (error "current file not part of current project; wrong project?"))
-
-    (setq found-file (file-truename found-file))
-
-    ;; (nth 10 (file-attributes ...)) is the inode; required when hard
-    ;; links are present.
-    (let* ((visited-file-inode (nth 10 (file-attributes visited-file)))
-           (found-file-inode (nth 10 (file-attributes found-file))))
-      (unless (equal visited-file-inode found-file-inode)
-        (error "%s (opened) and %s (found in project) are two different files"
-               file-name found-file)))))
-
 (defun ada-find-other-file ()
   "Move to the corresponding declaration in another file.
 
@@ -2035,7 +748,7 @@ set."
   ;;                       information
 
   (interactive)
-  (ada-check-current-project (buffer-file-name))
+  (wisi-check-current-project (buffer-file-name) #'ada-prj-default)
 
   ;; clear ff-function-name, so either ff-special-constructs or
   ;; ada-which-function will set it.
@@ -2053,312 +766,13 @@ set."
 
    ((and (not (ada-on-context-clause))
         (ada-goto-subunit-name))
-    (ada-goto-declaration))
+    (call-interactively 'wisi-goto-spec/body))
 
    (t
     (ff-find-other-file)))
   )
 
-(defun ada-find-file (filename)
-  ;; we assume compliation-search-path is set, either by an
-  ;; ada-mode project, or by some other means.
-  (interactive (list (completing-read "File: "
-                                     (apply-partially
-                                      'locate-file-completion-table
-                                      compilation-search-path nil))))
-  (find-file (locate-file filename compilation-search-path))
-  )
-
-(defvar ada-operator-re
-  
"\\+\\|-\\|/\\|\\*\\*\\|\\*\\|=\\|&\\|\\_<\\(abs\\|mod\\|rem\\|and\\|not\\|or\\|xor\\)\\_>\\|<=\\|<\\|>=\\|>"
-  "Regexp matching Ada operator_symbol.")
-
-(defun ada-identifier-at-point ()
-  "Return the identifier around point, move point to start of
-identifier.  May be an Ada identifier or operator."
-
-  (when (ada-in-comment-p)
-    (error "Inside comment"))
-
-  ;; Handle adjacent operator/identifer like:
-  ;; test/ada_mode-slices.adb
-  ;;   D1, D2 : Day := +Sun;
-
-  ;; Move to the beginning of the identifier or operator
-  (if (looking-at "[a-zA-Z0-9_]")
-      ;; In an identifier
-      (skip-chars-backward "a-zA-Z0-9_")
-    ;; In an operator
-    (skip-chars-backward "+\\-\\*/&<>="))
-
-  ;; Just in front of, or inside, a string => we could have an
-  ;; operator function declaration.
-  (cond
-   ((ada-in-string-p)
-    (cond
-
-     ((and (= (char-before) ?\")
-          (progn
-            (forward-char -1)
-            (looking-at (concat "\"\\(" ada-operator-re "\\)\""))))
-      (concat "\"" (match-string-no-properties 1) "\""))
-
-     (t
-      (error "Inside string or character constant"))
-     ))
-
-   ((and (= (char-after) ?\")
-        (looking-at (concat "\"\\(" ada-operator-re "\\)\"")))
-    (concat "\"" (match-string-no-properties 1) "\""))
-
-   ((looking-at ada-operator-re)
-    ;; Return quoted operator, as this is what the back end expects.
-    (concat "\"" (match-string-no-properties 0) "\""))
-
-   ((looking-at "[a-zA-Z0-9_]+")
-    (match-string-no-properties 0))
-
-   (t
-    (error "No identifier around"))
-   ))
-
-;; IMPROVEME (for emacs >= 25): use find-tag-marker-ring, ring-insert, 
pop-tag-mark (see xref.el)
-(defvar ada-goto-pos-ring '()
-  "List of positions selected by navigation functions. Used
-to go back to these positions.")
-
-(defconst ada-goto-pos-ring-max 16
-  "Number of positions kept in the list `ada-goto-pos-ring'.")
-
-(defun ada-goto-push-pos ()
-  "Push current filename, position on `ada-goto-pos-ring'. See 
`ada-goto-previous-pos'."
-  (setq ada-goto-pos-ring (cons (list (point) (buffer-file-name)) 
ada-goto-pos-ring))
-  (if (> (length ada-goto-pos-ring) ada-goto-pos-ring-max)
-      (setcdr (nthcdr (1- ada-goto-pos-ring-max) ada-goto-pos-ring) nil)))
-
-(defun ada-goto-previous-pos ()
-  "Go to the first position in `ada-goto-pos-ring', pop `ada-goto-pos-ring'."
-  (interactive)
-  (when ada-goto-pos-ring
-    (let ((pos (pop ada-goto-pos-ring)))
-      (find-file (cadr pos))
-      (goto-char (car pos)))))
-
-(defun ada-goto-source (file line column)
-  "Find and select FILE, at LINE and COLUMN.
-FILE may be absolute, or on `compilation-search-path'.
-LINE, COLUMN are Emacs origin."
-  (let ((file-1
-        (if (file-name-absolute-p file) file
-          (ff-get-file-name compilation-search-path file))))
-    (if file-1
-       (setq file file-1)
-      (error "File %s not found; installed library, or set project?" file))
-    )
-
-  (ada-goto-push-pos)
-
-  (let ((buffer (get-file-buffer file)))
-    (cond
-     ((bufferp buffer)
-      ;; use pop-to-buffer, so package other-frame-window works.
-      (pop-to-buffer buffer (list #'display-buffer-same-window)))
-
-     ((file-exists-p file)
-      (find-file file))
-
-     (t
-      (error "'%s' not found" file))))
-
-  ;; move the cursor to the correct position
-  (push-mark nil t)
-  (goto-char (point-min))
-  (forward-line (1- line))
-  (forward-char column)
-  )
-
-(defvar ada-xref-refresh-function nil
-  ;; determined by xref_tool, set by *-select-prj-xref
-  "Function that refreshes cross reference information cache.")
-
-(defun ada-xref-refresh (delete-files)
-  "Refresh cross reference information cache, if any.
-With non-nil prefix arg, delete cross reference files, which may
-be needed when a compiler is upgraded, or some configuration is
-changed."
-  (interactive "P")
-
-  (when (null ada-xref-refresh-function)
-    (error "no cross reference information available"))
-
-  (funcall ada-xref-refresh-function delete-files)
-  )
-
-(defvar ada-xref-other-function nil
-  ;; determined by xref_tool, set by *-select-prj-xref
-  "Function that returns cross reference information.
-Function is called with four arguments:
-- an Ada identifier or operator_symbol
-- filename containing the identifier (full path)
-- line number containing the identifier
-- Emacs column of the start of the identifier
-Point is on the start of the identifier.
-Returns a list (FILE LINE COLUMN) giving the corresponding location.
-FILE may be absolute, or on `compilation-search-path'.  If point is
-at the specification, the corresponding location is the body, and vice
-versa.")
-
-(defun ada-goto-declaration ()
-  "Move to the declaration or body of the identifier around point.
-If at the declaration, go to the body, and vice versa."
-  (interactive)
-  (ada-check-current-project (buffer-file-name))
-
-  (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)
-                 (current-column)
-                 )))
-
-    (ada-goto-source (nth 0 target)
-                    (nth 1 target)
-                    (nth 2 target))
-    ))
-
-(defvar ada-xref-parent-function nil
-  ;; determined by xref_tool, set by *-select-prj-xref
-  "Function that returns cross reference information.
-Function is called with four arguments:
-- an Ada identifier or operator_symbol
-- filename containing the identifier
-- line number containing the identifier
-- Emacs column of the start of the identifier
-Displays a buffer in compilation-mode giving locations of the parent type 
declarations.")
-
-(defun ada-show-declaration-parents ()
-  "Display the locations of the parent type declarations of the type 
identifier around point."
-  (interactive)
-  (ada-check-current-project (buffer-file-name))
-
-  (when (null ada-xref-parent-function)
-    (error "no cross reference information available"))
-
-  (funcall ada-xref-parent-function
-          (ada-identifier-at-point)
-          (file-name-nondirectory (buffer-file-name))
-          (line-number-at-pos)
-          (current-column))
-  )
-
-(defvar ada-xref-all-function nil
-  ;; determined by xref_tool, set by *-select-prj-xref
-  "Function that displays cross reference information.
-Called with four arguments:
-- an Ada identifier or operator_symbol
-- filename containing the identifier
-- line number containing the identifier
-- Emacs column of the start of the identifier
-- local-only; if t, show references in current file only
-- append; if t, keep previous output in result buffer
-Displays a buffer in compilation-mode giving locations where the
-identifier is declared or referenced.")
-
-(defun ada-show-references (&optional append)
-  "Show all references of identifier at point.
-With prefix, keep previous references in output buffer."
-  (interactive "P")
-  (ada-check-current-project (buffer-file-name))
-
-  (when (null ada-xref-all-function)
-    (error "no cross reference information available"))
-
-  (funcall ada-xref-all-function
-          (ada-identifier-at-point)
-          (file-name-nondirectory (buffer-file-name))
-          (line-number-at-pos)
-          (current-column)
-          nil ;; local-only
-          append)
-  )
-
-(defun ada-show-local-references (&optional append)
-  "Show all references of identifier at point.
-With prefix, keep previous references in output buffer."
-  (interactive "P")
-  (ada-check-current-project (buffer-file-name))
-
-  (when (null ada-xref-all-function)
-    (error "no cross reference information available"))
-
-  (funcall ada-xref-all-function
-          (ada-identifier-at-point)
-          (file-name-nondirectory (buffer-file-name))
-          (line-number-at-pos)
-          (current-column)
-          t ;; local-only
-          append)
-  )
-
-(defvar ada-xref-overriding-function nil
-  ;; determined by ada-xref-tool, set by *-select-prj
-  "Function that displays cross reference information for overriding 
subprograms.
-Called with four arguments:
-- an Ada identifier or operator_symbol
-- filename containing the identifier
-- line number containing the identifier
-- Emacs column of the start of the identifier
-Displays a buffer in compilation-mode giving locations of the overriding 
declarations.")
-
-(defun ada-show-overriding ()
-  "Show all overridings of identifier at point."
-  (interactive)
-  (ada-check-current-project (buffer-file-name))
-
-  (when (null ada-xref-overriding-function)
-    (error "no cross reference information available"))
-
-  (funcall ada-xref-overriding-function
-          (ada-identifier-at-point)
-          (file-name-nondirectory (buffer-file-name))
-          (line-number-at-pos)
-          (current-column))
-  )
-
-(defvar ada-xref-overridden-function nil
-  ;; determined by ada-xref-tool, set by *-select-prj
-  "Function that displays cross reference information for overridden 
subprogram.
-Called with four arguments:
-- an Ada identifier or operator_symbol
-- filename containing the identifier
-- line number containing the identifier
-- Emacs column of the start of the identifier
-Returns a list (FILE LINE COLUMN) giving the corresponding location.
-FILE may be absolute, or on `compilation-search-path'.")
-
-(defun ada-show-overridden ()
-  "Show the overridden declaration of identifier at point."
-  (interactive)
-  (ada-check-current-project (buffer-file-name))
-
-  (when (null ada-xref-overridden-function)
-    (error "'show overridden' not supported, or no cross reference information 
available"))
-
-  (let ((target
-        (funcall ada-xref-overridden-function
-                 (ada-identifier-at-point)
-                 (file-name-nondirectory (buffer-file-name))
-                 (line-number-at-pos)
-                 (current-column))))
-
-    (ada-goto-source (nth 0 target)
-                    (nth 1 target)
-                    (nth 2 target))
-  ))
+;;;; Misc
 
 ;; This is autoloaded because it may be used in ~/.emacs
 ;;;###autoload
@@ -2424,124 +838,89 @@ compiler-specific compilation filters."
       (pop-to-buffer start-buffer nil t);; for windowing history
       )
     (when item
-      (ada-goto-source
+      (wisi-goto-source
        file
        (nth 1 item); line
        (nth 2 item); column
        ))
     ))
 
-(defvar ada-goto-declaration-start nil
-  ;; Supplied by indentation engine.
-  ;;
-  "For `beginning-of-defun-function'. Function to move point to
-start of the generic, package, protected, subprogram, or task
-declaration point is currently in or just after.  Called with no
-parameters.")
+(defun ada-goto-declaration-start-1 (include-type)
+  "Subroutine of `ada-goto-declaration-start'."
+  (let ((start (point))
+       (cache (wisi-get-cache (point)))
+       (done nil))
+    (unless cache
+      (setq cache (wisi-backward-cache)))
+    ;; cache is null at bob
+    (while (not done)
+      (if cache
+         (progn
+           (setq done
+                 (cl-case (wisi-cache-nonterm cache)
+                   ((entry_body entry_declaration)
+                    (eq (wisi-cache-token cache) 'ENTRY))
+
+                   (full_type_declaration
+                    (when include-type
+                      (eq (wisi-cache-token cache) 'TYPE)))
+
+                   ((generic_package_declaration 
generic_subprogram_declaration)
+                    (eq (wisi-cache-token cache) 'GENERIC))
+
+                   ((package_body package_declaration)
+                    (eq (wisi-cache-token cache) 'PACKAGE))
+
+                   ((protected_body protected_type_declaration 
single_protected_declaration)
+                    (eq (wisi-cache-token cache) 'PROTECTED))
+
+                   ((abstract_subprogram_declaration
+                     expression_function_declaration
+                     subprogram_body
+                     subprogram_declaration
+                     subprogram_renaming_declaration
+                     null_procedure_declaration)
+                    (memq (wisi-cache-token cache) '(NOT OVERRIDING FUNCTION 
PROCEDURE)))
+
+                   ((single_task_declaration task_body task_type_declaration)
+                    (eq (wisi-cache-token cache) 'TASK))
+
+                   ))
+           (unless (< start (wisi-cache-end cache))
+             ;; found declaration does not include start; find containing one.
+             (setq done nil))
+           (unless done
+             (setq cache (wisi-goto-containing cache nil))))
+       (setq done t))
+       )
+    cache))
 
-(defun ada-goto-declaration-start ()
-  "Call `ada-goto-declaration-start'."
+(defun ada-goto-declaration-start (&optional include-type)
+  "Move point to start of the generic, package, protected,
+subprogram, or task declaration point is currently in or just
+after.  For `beginning-of-defun-function'."
   (interactive)
-  (when ada-goto-declaration-start
-    (funcall ada-goto-declaration-start)))
-
-(defvar ada-goto-declaration-end nil
-  ;; supplied by indentation engine
-  "For `end-of-defun-function'. Function to move point to end of
-current declaration.")
+  (wisi-validate-cache (point-min) (point-max) t 'navigate)
+  (ada-goto-declaration-start-1 include-type))
 
 (defun ada-goto-declaration-end ()
-  "See `ada-goto-declaration-end' variable."
+  "Move point to end of current declaration.
+For `end-of-defun-function'."
   (interactive)
-  (when ada-goto-declaration-end
-    (funcall ada-goto-declaration-end)))
-
-(defvar ada-goto-declarative-region-start nil
-  ;; Supplied by indentation engine
-  "Function to move point to start of the declarative region of
-the subprogram, package, task, or declare block point
-is currently in.  Called with no parameters.")
-
-(defun ada-goto-declarative-region-start ()
-  "Call `ada-goto-declarative-region-start'."
-  (interactive)
-  (when ada-goto-declarative-region-start
-    (funcall ada-goto-declarative-region-start)))
-
-(defvar ada-goto-end nil
-  ;; Supplied by indentation engine
-  "Function to move point to end of the declaration or statement point is in 
or before.
-Called with no parameters.")
-
-(defun ada-goto-end ()
-  "Call `ada-goto-end'."
-  (when ada-goto-end
-    (funcall ada-goto-end)))
-
-;;;; code creation
-
-(defvar ada-make-subprogram-body nil
-  ;; Supplied by indentation engine
-  "Function to convert subprogram specification after point into a subprogram 
body stub.
-Called with no args, point at declaration start. Leave point in
-subprogram body, for user to add code.")
-
-(defun ada-make-subprogram-body ()
-  "If point is in or after a subprogram specification, convert it
-into a subprogram body stub, by calling `ada-make-subprogram-body'."
-  (interactive)
-  (wisi-goto-statement-start)
-  (if ada-make-subprogram-body
-      (funcall ada-make-subprogram-body)
-    (error "`ada-make-subprogram-body' not set")))
-
-(defvar ada-make-package-body nil
-  ;; Supplied by xref tool
-  "Function to create a package body from a package spec.
-Called with one argument; the absolute path to the body
-file. Current buffer is the package spec.  Should create the
-package body file, containing skeleton code that will compile.")
-
-(defun ada-make-package-body (body-file-name)
-  ;; no error if not set; let ada-skel do its thing.
-  (when ada-make-package-body
-      (funcall ada-make-package-body body-file-name)))
-
-(defun ada-ff-create-body ()
-  ;; no error if not set; let ada-skel do its thing.
-  (when ada-make-package-body
-    ;; ff-find-other-file calls us with point in an empty buffer for
-    ;; the body file; ada-make-package-body expects to be in the
-    ;; spec. So go back to the spec, and delete the body buffer so it
-    ;; does not get written to disk.
-    (let ((body-buffer (current-buffer))
-         (body-file-name (buffer-file-name)))
-
-      (set-buffer-modified-p nil);; may have a skeleton; allow silent delete
-
-      (ff-find-the-other-file);; back to spec
-
-      (kill-buffer body-buffer)
-
-      (ada-make-package-body body-file-name)
-
-      ;; back to the new body file, read in from the disk.
-      (ff-find-the-other-file)
-      (revert-buffer t t))
-    ))
+  ;; First goto-declaration-start, so we get the right end, not just
+  ;; the current statement end.
+  (wisi-goto-end-1 (ada-goto-declaration-start)))
 
 ;;;; fill-comment
 
-(defvar wisi-inhibit-parse nil);; in wisi.el; so far that's the only parser we 
use.
-
 (defun ada-fill-comment-paragraph (&optional justify postfix)
   "Fill the current comment paragraph.
 If JUSTIFY is non-nil, each line is justified as well.
 If POSTFIX and JUSTIFY are non-nil, `ada-fill-comment-postfix' is appended
 to each line filled and justified.
-The paragraph is indented on the first line."
+The ident for the paragraph is taken from the first line."
   (interactive "P")
-  (if (not (or (ada-in-comment-p)
+  (if (not (or (wisi-in-comment-p)
                (looking-at "[ \t]*--")))
       (error "Not inside comment"))
 
@@ -2647,6 +1026,9 @@ The paragraph is indented on the first line."
   '("some")
   "List of keywords new in Ada 2012.")
 
+(defvar ada-keywords nil
+  "List of Ada keywords for current `ada-language-version'.")
+
 (defun ada-font-lock-keywords ()
   "Return Ada mode value for `font-lock-keywords', depending on 
`ada-language-version'."
    ;; Grammar actions set `font-lock-face' property for all
@@ -2655,41 +1037,459 @@ The paragraph is indented on the first line."
    (list (concat "\\_<" (regexp-opt ada-keywords t) "\\_>") '(0 
font-lock-keyword-face))
    ))
 
-(defvar which-func-functions nil) ;; which-func.el
-(defvar which-func-non-auto-modes nil) ;; ""
+;;;; auto-case
 
-;;;; ada-mode
+(defcustom ada-auto-case t
+  "When non-nil, automatically change case of preceding word while
+typing.  Casing of Ada keywords is done according to `ada-case-keyword',
+identifiers according to `ada-case-identifier'."
+  :group 'ada
+  :type  '(choice (const nil)
+                 (const t))
+  :safe  (lambda (val) (memq val '(nil t))))
+(make-variable-buffer-local 'ada-auto-case)
 
-;; ada-mode does not derive from prog-mode, because we need to call
-;; ada-mode-post-local-vars, and prog-mode does not provide a way to
-;; do that (at least before emacs 26).
-;;
-;; autoload required by automatic mode setting
-;;;###autoload
-(defun ada-mode ()
-  "The major mode for editing Ada code."
-  ;; the other ada-*.el files add to ada-mode-hook for their setup
+(defcustom ada-case-keyword 'lower-case
+  "Indicate how to adjust case for language keywords.
+Value is one of lower-case, upper-case."
+  :group 'ada
+  :type '(choice (const lower-case)
+                (const upper-case))
+  :safe #'symbolp)
+(make-variable-buffer-local 'ada-case-keyword)
+
+(defcustom ada-case-strict t
+  "If non-nil, force Mixed_Case for identifiers.
+Otherwise, allow UPPERCASE for identifiers."
+  :group 'ada
+  :type 'boolean
+  :safe  #'booleanp)
+(make-variable-buffer-local 'ada-case-strict)
+
+(defcustom ada-case-identifier 'mixed-case
+  "Indicates how to adjust the case of Ada keywords."
+  :group 'ada
+  :type '(choice (const mixed-case)
+                (const lower-case)
+                (const upper-case))
+  :safe (lambda (val) (memq val '(mixed-case lower-case upper-case))))
+(make-variable-buffer-local 'ada-case-identifier)
+
+(defun ada-in-based-numeric-literal-p ()
+  "Return t if point is after a prefix of a based numeric literal."
+  (looking-back "\\([0-9]+#[0-9a-fA-F_]+\\)" (line-beginning-position)))
+
+(defun ada-case-adjust-p (typed-char)
+  "For `wisi-case-adjust-p-function'."
+  (and
+   ;; hex digits
+   (not (ada-in-based-numeric-literal-p))
+
+   ;; character literal
+   (not (and (eq typed-char ?')
+            (eq (char-before (point)) ?')))
+  ))
+
+;;;; wisi integration
+
+(defconst ada-wisi-language-protocol-version "3"
+  "Defines language-specific parser parameters.
+Must match wisi-ada.ads Language_Protocol_Version.")
+
+(cl-defstruct (ada-wisi-parser (:include wisi-process--parser))
+  ;; no new slots
+  )
+
+(cl-defmethod wisi-parse-format-language-options ((_parser ada-wisi-parser))
+  (format "%d %d %d %d %d %d %d %d %d %d %d %d %d"
+         ada-indent
+         ada-indent-broken
+         (if ada-indent-comment-col-0 1 0)
+         (if ada-indent-comment-gnat 1 0)
+         ada-indent-label
+         ada-indent-record-rel-type
+         ada-indent-renames
+         ada-indent-return
+         ada-indent-use
+         ada-indent-when
+         ada-indent-with
+         (if ada-indent-hanging-rel-exp 1 0)
+         (if ada-end-name-optional 1 0)
+         ))
+
+(defconst ada-wisi-named-begin-regexp
+  "\\bfunction\\b\\|\\bpackage\\b\\|\\bprocedure\\b\\|\\btask\\b"
+  )
+
+(defconst ada-wisi-partial-begin-regexp
+  (concat "\\bbegin\\b\\|\\bdeclare\\b\\|"
+         ada-wisi-named-begin-regexp
+         "\\|\\bend;\\|\\bend " ada-name-regexp ";"))
+
+(defconst ada-wisi-partial-end-regexp
+  (concat ada-wisi-partial-begin-regexp
+         "\\|;"))
+
+(defun ada-wisi-find-begin ()
+  "Starting at current point, search backward for a parse start point."
+
+  ;; There is a trade-off in deciding where to start parsing for indent. If we 
have:
+  ;;
+  ;; procedure ...
+  ;; is
+  ;;
+  ;; and are inserting a new line after 'is', we need to include
+  ;; 'is' in the parse to see the indent. On the other hand, if we
+  ;; have:
+  ;;
+  ;;    ...
+  ;;    end;
+  ;; begin
+  ;;    Foo;
+  ;;
+  ;; Inserting new line after 'Foo;'; if we include 'begin', there
+  ;; is no error (begin starts a statement), and the indent is
+  ;; computed incorrectly.
+  ;;
+  ;; This is handled by the set of keywords in
+  ;; ada-wisi-partial-begin-regexp.
+  (cond
+   ((wisi-search-backward-skip
+     ada-wisi-partial-begin-regexp
+     (lambda () (or (wisi-in-string-or-comment-p)
+                   (looking-back "access " (line-beginning-position)))))
+     ;; "access" rejects subprobram access parameters; 
test/ada_mode-recover_partial_20.adb
+
+    (let ((found (match-string 0))
+         cache)
+      (cond
+       ((and (>= (length found) 3)
+            (string-equal "end" (substring found 0 3)))
+       (match-end 0))
+
+       (t
+       (setq cache (wisi-get-cache (point)))
+       (when cache
+         ;; This distinguishes 'begin' as a statement start from
+         ;; 'begin' following 'declare', 'procedure' etc.  We don't
+         ;; force a parse to get this; the user may choose to do so.
+         (wisi-goto-start cache))
+       (point))
+       )))
+
+   (t
+    (point-min))
+   ))
+
+(defun ada-wisi-find-end ()
+  "Starting at current point, search forward for a reasonable parse end point."
+  (forward-comment (point-max)) ;; get past any current comments
+  (forward-line 1) ;; contain at least some code (see 
ada_mode-partial_parse.adb 'blank line before "end"')
+
+  (let ((start (point))
+       match
+       (end-cand nil))
+
+    (while (not end-cand)
+      (if (search-forward-regexp ada-wisi-partial-end-regexp nil 1) ;; moves 
to eob if not found
+         (unless (or (wisi-in-string-or-comment-p)
+                     (wisi-in-paren-p))
+           (setq match t)
+           (setq end-cand (point)))
+
+       ;; No reasonable end point found (maybe a missing right
+       ;; paren); return line after start for minimal parse, compute
+       ;; indent for line containing start.
+       (setq match nil)
+       (goto-char start)
+       (setq end-cand (line-end-position 2)))
+      )
+
+    (when (and match
+              (not (string-equal ";" (match-string 0))))
+      (setq end-cand (match-beginning 0)))
+
+    end-cand))
+
+(defun ada-wisi-find-matching-end ()
+  "Starting at current point, search forward for a matching end.
+Point must have been set by `ada-wisi-find-begin'."
+  (let (end-regexp)
+    ;; Point is at bol
+    (back-to-indentation)
+    (when (looking-at ada-wisi-named-begin-regexp)
+      (skip-syntax-forward "ws")
+      (skip-syntax-forward " ")
+      (when (looking-at "body\\|type")
+       (goto-char (match-end 0))
+       (skip-syntax-forward " "))
+      (setq end-regexp
+           (concat "end +"
+                   (buffer-substring-no-properties
+                    (point)
+                    (progn
+                      (skip-syntax-forward "ws._")
+                      (point)))
+                   ";"))
+      (if (search-forward-regexp end-regexp nil t)
+         (progn
+           (while (and (wisi-in-string-or-comment-p)
+                       (search-forward-regexp end-regexp nil t)))
+           (point))
+
+       ;; matching end not found
+       nil)
+      )))
+
+(cl-defmethod wisi-parse-expand-region ((_parser ada-wisi-parser) begin end)
+  (let (begin-cand end-cand result)
+    (save-excursion
+      (goto-char begin)
+
+      (setq begin-cand (ada-wisi-find-begin))
+      (if (= begin-cand (point-min)) ;; No code between BEGIN and bob
+         (progn
+           (goto-char end)
+           (setq result (cons begin-cand (ada-wisi-find-end))))
+
+       (setq end-cand (ada-wisi-find-matching-end))
+       (if (and end-cand
+                (>= end-cand end))
+           (setq result (cons begin-cand end-cand))
+         (goto-char end)
+         (setq result (cons begin-cand (ada-wisi-find-end))))
+
+       ))
+    result))
+
+(cl-defmethod wisi-parse-adjust-indent ((_parser ada-wisi-parser) indent 
repair)
+  (cond
+   ((or (wisi-list-memq (wisi--parse-error-repair-inserted repair) '(BEGIN IF 
LOOP))
+       (wisi-list-memq (wisi--parse-error-repair-deleted repair) '(END)))
+    ;; Error token terminates the block containing the start token
+    (- indent ada-indent))
+
+   ((equal '(CASE IS) (wisi--parse-error-repair-inserted repair))
+        (- indent (+ ada-indent ada-indent-when)))
+
+   ((equal '(END CASE SEMICOLON) (wisi--parse-error-repair-inserted repair))
+        (+ indent (+ ada-indent ada-indent-when)))
+
+   (t indent)
+   ))
+
+(defun ada-wisi-comment-gnat (indent after)
+  "Modify INDENT to match gnat rules. Return new indent.
+INDENT must be indent computed by the normal indentation
+algorithm.  AFTER indicates what is on the previous line; one of:
+
+code:         blank line, or code with no trailing comment
+code-comment: code with trailing comment
+comment:      comment"
+  (let (prev-indent next-indent)
+    ;; the gnat comment indent style check; comments must
+    ;; be aligned to one of:
+    ;;
+    ;; - multiple of ada-indent
+    ;; - next non-blank line
+    ;; - previous non-blank line
+    ;;
+    ;; Note that we must indent the prev and next lines, in case
+    ;; they are not currently correct.
+    (cond
+     ((and (not (eq after 'comment))
+          (= 0 (% indent ada-indent)))
+      ;; this will handle comments at bob and eob, so we don't
+      ;; need to worry about those positions in the next checks.
+      indent)
+
+     ((and (setq prev-indent
+                (if (eq after 'comment)
+                    (progn (forward-comment -1) (current-column))
+                  (save-excursion (forward-line -1)(current-indentation))))
+          (= indent prev-indent))
+      indent)
+
+     ((and (setq next-indent
+                ;; we use forward-comment here, instead of
+                ;; forward-line, because consecutive comment
+                ;; lines are indented to the current one, which
+                ;; we don't know yet.
+                (save-excursion (forward-comment 
(point-max))(current-indentation)))
+          (= indent next-indent))
+      indent)
 
+     (t
+      (cl-ecase after
+       (code-comment
+        ;; After comment that follows code on the same line
+        ;; test/ada_mode-conditional_expressions.adb
+        ;;
+        ;; then 44     -- comment matching GNAT
+        ;;             -- second line
+        ;;
+        ;; else 45)); -- comment _not_ matching GNAT style check
+        ;;             -- comment matching GNAT
+        ;;
+        (+ indent (- ada-indent (% indent ada-indent))))
+
+       ((code comment)
+        ;; After code with no trailing comment, or after comment
+        ;; test/ada_mode-conditional_expressions.adb
+        ;; (if J > 42
+        ;; -- comment indent matching GNAT style check
+        ;; -- second line of comment
+        prev-indent)
+
+       ))
+     )))
+
+(defun ada-wisi-comment ()
+  "Modify indentation of a comment:
+For `wisi-indent-calculate-functions'.
+- align to previous comment after code.
+- respect `ada-indent-comment-gnat'."
+  ;; We know we are at the first token on a line.
+  ;;
+  ;; The normal indentation algorithm has already indented the
+  ;; comment.
+  (when (and (not (eobp))
+            (string= comment-start (buffer-substring-no-properties (point) 
(min (point-max) (+ 2 (point))))))
+
+    ;; We are looking at a comment; check for preceding comments, code
+    (let (after
+         (indent (current-column)))
+      (if (save-excursion (forward-line -1) (looking-at "\\s *$"))
+         ;; after blank line
+         (setq after 'code)
+
+       (save-excursion
+         (forward-comment -1)
+         (if (or (not ada-indent-after-trailing-comment) ;; ignore comment on 
previous line
+                 (looking-at "\\s *$"))                  ;; no comment on 
previous line
+             (setq after 'code)
+
+           (setq indent (current-column))
+           (if (not (= indent (progn (back-to-indentation) (current-column))))
+               ;; previous line has comment following code
+               (setq after 'code-comment)
+             ;; previous line has plain comment
+             (setq indent (current-column))
+             (setq after 'comment)
+             )))
+       )
+
+      (cl-ecase after
+       (code
+        (if ada-indent-comment-gnat
+            (ada-wisi-comment-gnat indent 'code)
+          indent))
+
+       (comment
+        indent)
+
+       (code-comment
+        (if ada-indent-comment-gnat
+            (ada-wisi-comment-gnat indent 'code-comment)
+
+          ;; After comment that follows code on the same line
+          ;; test/ada_mode-nominal.adb
+          ;;
+          ;; begin -- 2
+          ;;       --EMACSCMD:(progn 
(ada-goto-declarative-region-start)(looking-at "Bad_Thing"))
+          (save-excursion (forward-comment -1)(current-column)))
+        ))
+      )))
+
+(defun ada-wisi-post-parse-fail ()
+  "For `wisi-post-parse-fail-hook'."
+  ;; Parse indent succeeded, so we assume parse navigate will as well
+  (wisi-validate-cache (point-min) (line-end-position) nil 'navigate)
+  (save-excursion
+    (let ((start-cache (wisi-goto-start (or (wisi-get-cache (point)) 
(wisi-backward-cache)))))
+      (when start-cache
+       ;; nil when in a comment at point-min
+       (indent-region (point) (wisi-cache-end start-cache)))
+      ))
+  (back-to-indentation))
+
+(defun ada-find-file ()
+  "Find a file in the current project.
+Prompts with completion, defaults to filename at point."
+  (interactive)
+  ;; In emacs 27, we can just call 'project-find-file;
+  ;; project-read-file-name-function handles the uniquify-files alist
+  ;; completion table. In emacs 26, we must do that ourselves.
+  (cl-ecase emacs-major-version
+    (27
+     (project-find-file))
+
+    (26
+     (let* ((def (thing-at-point 'filename))
+           (project (project-current))
+           (all-files (project-files project nil))
+           (alist (uniq-file-uniquify all-files))
+           (table (apply-partially #'uniq-file-completion-table alist))
+            (file (project--completing-read-strict
+                   "Find file" table nil nil def)))
+       (if (string= file "")
+           (user-error "You didn't specify the file")
+        (find-file (cdr (assoc file alist))))))
+    ))
+
+;;;; compatibility with previous ada-mode versions
+
+;;;###autoload
+(defun ada-fix-compiler-error ()
   (interactive)
-  (kill-all-local-variables)
-  (setq major-mode 'ada-mode)
-  (setq mode-name "Ada")
-  (use-local-map ada-mode-map)
+  (wisi-fix-compiler-error))
+(make-obsolete 'ada-fix-compiler-error 'wisi-fix-compiler-error "ada-mode 
7.0.0")
+
+(defun ada-select-prj-file-1 (prj-file)
+;; avoid byte compiler warning about obsolete ada-select-prj-file
+  (wisi-prj-select-cache
+   prj-file
+   (ada-prj-default
+    (file-name-sans-extension (file-name-nondirectory prj-file))
+    (file-name-directory prj-file)))
+
+  ;; We set project-find-functions, xref-backend-functions here for
+  ;; compatibility with ada-mode 6.x.
+  (unless (wisi-prj-find-function-set-p)
+    (add-hook 'project-find-functions #'wisi-prj-current-cached)
+    (add-hook 'xref-backend-functions #'wisi-prj-xref-backend)))
 
-  (set-syntax-table ada-mode-syntax-table)
-  (define-abbrev-table 'ada-mode-abbrev-table ())
-  (setq local-abbrev-table ada-mode-abbrev-table)
+;;;###autoload
+(defun ada-parse-prj-file (prj-file)
+  (ada-select-prj-file-1 prj-file))
+(make-obsolete 'ada-parse-prj-file 'wisi-prj-select-cache "ada-mode 7.0.0")
+
+;;;###autoload
+(defun ada-select-prj-file (prj-file)
+  (ada-select-prj-file-1 prj-file))
+(make-obsolete 'ada-select-prj-file #'wisi-prj-select-cache "ada-mode 7.0.0")
+
+;;;###autoload
+(defalias 'ada-project-current #'wisi-prj-current-cached)
+(make-obsolete 'ada-project-current #'wisi-prj-current-cached "ada-mode 7.0.0")
+
+;;;; ada-mode
+
+(defvar which-func-functions nil) ;; which-func.el
+(defvar which-func-non-auto-modes nil) ;; ""
+
+;;;###autoload
+(define-derived-mode ada-mode prog-mode "Ada"
+  "The major mode for editing Ada code."
+  :group 'ada
 
   (set (make-local-variable 'syntax-propertize-function) 
'ada-syntax-propertize)
   (syntax-ppss-flush-cache (point-min));; reparse with new function
 
-  (when (boundp 'syntax-begin-function)
-    ;; default ‘beginning-of-defun’ in emacs-24.2; we need it nil
-    ;; obsolete in 25.1
-    (set (make-local-variable 'syntax-begin-function) nil))
   (set (make-local-variable 'parse-sexp-ignore-comments) t)
   (set (make-local-variable 'parse-sexp-lookup-properties) t)
   (set 'case-fold-search t); Ada is case insensitive; the syntax parsing 
requires this setting
+  (set 'completion-ignore-case t)
   (set (make-local-variable 'comment-start) "--")
   (set (make-local-variable 'comment-end) "")
   (set (make-local-variable 'comment-start-skip) "---*[ \t]*")
@@ -2716,7 +1516,7 @@ The paragraph is indented on the first line."
        'ada-other-file-alist)
   (setq ff-post-load-hook    #'ada-set-point-accordingly
        ff-file-created-hook #'ada-ff-create-body)
-  (add-hook 'ff-pre-load-hook #'ada-goto-push-pos)
+  (add-hook 'ff-pre-load-hook #'push-mark)
   (add-hook 'ff-pre-load-hook #'ada-which-function)
   (setq ff-search-directories 'compilation-search-path)
   (when (null (car compilation-search-path))
@@ -2741,6 +1541,9 @@ The paragraph is indented on the first line."
   (set (make-local-variable 'align-region-separate) ada-align-region-separate)
   (set (make-local-variable 'align-indent-before-aligning) t)
 
+  (set (make-local-variable 'beginning-of-defun-function) 
#'ada-goto-declaration-start)
+  (set (make-local-variable 'end-of-defun-function) #'ada-goto-declaration-end)
+
   ;; Exclude comments alone on line from alignment.
   (add-to-list 'align-exclude-rules-list
               '(ada-solo-comment
@@ -2755,17 +1558,24 @@ 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)
-
-  (when (< emacs-major-version 25) (syntax-propertize (point-max)))
-
-  (if (<= emacs-major-version 25)
-      ;; run-mode-hooks does _not_ call hack-local-variables
-      (add-hook 'hack-local-variables-hook 'ada-mode-post-local-vars nil t)
-    ;; >= 26; run-mode-hooks _does_ call hack-local-variables, after the hook 
functions
-    (ada-mode-post-local-vars))
+  (wisi-setup
+   :indent-calculate '(ada-wisi-comment)
+   :post-indent-fail 'ada-wisi-post-parse-fail
+   :parser
+   (wisi-process-parse-get
+    (make-ada-wisi-parser
+     :label "Ada"
+     :language-protocol-version ada-wisi-language-protocol-version
+     :exec-file ada-process-parse-exec
+     :exec-opts ada-process-parse-exec-opts
+     :face-table ada-process-face-table
+     :token-table ada-process-token-table
+     :repair-image ada-process-repair-image)))
+
+  (setq wisi-prj-parse-undefined-function #'ada-prj-parse-undefined)
+  (setq wisi-xref-full-path ada-xref-full-path)
+
+  (add-hook 'hack-local-variables-hook #'ada-mode-post-local-vars nil t)
   )
 
 (defun ada-mode-post-local-vars ()
@@ -2776,12 +1586,12 @@ The paragraph is indented on the first line."
   ;; This means to fully set ada-mode interactively, user must
   ;; do M-x ada-mode M-; (hack-local-variables)
 
-  (setq hack-local-variables-hook (delq 'ada-mode-post-local-vars 
hack-local-variables-hook))
+  (remove-hook 'hack-local-variables-hook #'ada-mode-post-local-vars)
 
   ;; fill-region-as-paragraph in ada-fill-comment-paragraph does not
   ;; call syntax-propertize, so set comment syntax on
   ;; ada-fill-comment-prefix. In post-local because user may want to
-  ;; set it per-file. IMPROVEME: only in emacs < 25?
+  ;; set it per-file.
   (put-text-property 0 2 'syntax-table '(11 . nil) ada-fill-comment-prefix)
 
   (cl-case ada-language-version
@@ -2810,57 +1620,22 @@ The paragraph is indented on the first line."
     ;; ada-keywords
     (font-lock-refresh-defaults))
 
-  (when ada-goto-declaration-start
-    (set (make-local-variable 'beginning-of-defun-function) 
ada-goto-declaration-start))
+  (setq wisi-indent-comment-col-0 ada-indent-comment-col-0)
 
-  (when ada-goto-declaration-end
-    (set (make-local-variable 'end-of-defun-function) 
ada-goto-declaration-end))
+  (setq wisi-auto-case ada-auto-case)
+  (setq wisi-case-identifier ada-case-identifier)
+  (setq wisi-case-strict ada-case-strict)
+  (setq wisi-language-keywords ada-keywords)
+  (setq wisi-case-keyword ada-case-keyword)
+  (setq wisi-case-adjust-p-function #'ada-case-adjust-p)
   )
 
 (put 'ada-mode 'custom-mode-group 'ada)
 
-(defvar ada-parser 'process
-  "Indicate parser and lexer to use for Ada buffers:
-
-process : external process lexer and parser specified
-  by ‘ada-process-parse-exec ’.
-"
-  ;; As of ada-mode version 6.2, we no longer support the elisp
-  ;; parser. We may add a module implementation at some point.
-  )
-
-(defvar ada-fallback 'simple
-  "Indicate fallback indentation engine for Ada buffers.
-
-simple: indent to previous line.")
-
-(provide 'ada-mode)
-
 ;;;;; Global initializations
 
-(add-hook 'menu-bar-update-hook #'ada-project-menu-install)
-
-(require 'ada-wisi)
-
-(cl-case ada-xref-tool
-  (gnat (require 'ada-gnat-xref))
-  (gpr_query (require 'gpr-query))
-  (t
-   (if (locate-file "gpr_query" exec-path '("" ".exe"))
-       (progn
-         (require 'gpr-query)
-         (setq ada-xref-tool 'gpr_query))
-     (require 'ada-gnat-xref)
-     (setq ada-xref-tool 'gnat)))
-  )
-
-(unless (featurep 'ada-compiler)
-  (require 'ada-gnat-compile))
-
-(unless (featurep 'ada-skeletons)
-  (require 'ada-skel))
-
 (when (featurep 'imenu)
   (require 'ada-imenu))
 
+(provide 'ada-mode)
 ;;; ada-mode.el ends here
diff --git a/packages/ada-mode/ada-mode.info b/packages/ada-mode/ada-mode.info
index 375f960..746829a 100644
--- a/packages/ada-mode/ada-mode.info
+++ b/packages/ada-mode/ada-mode.info
@@ -1,7 +1,7 @@
 This is ada-mode.info, produced by makeinfo version 6.3 from
 ada-mode.texi.
 
-Copyright (C) 1999 - 2019 Free Software Foundation, Inc.
+Copyright (C) 1999 - 2020 Free Software Foundation, Inc.
 
      Permission is granted to copy, distribute and/or modify this
      document under the terms of the GNU Free Documentation License,
@@ -25,7 +25,7 @@ File: ada-mode.info,  Node: Top,  Next: Overview,  Prev: 
(dir),  Up: (dir)
 Top
 ***
 
-Ada Mode Version 6.2.1
+Ada Mode Version 7.0.1
 
 * Menu:
 
@@ -44,7 +44,6 @@ Ada Mode Version 6.2.1
 * Key summary::
 * Developer overview::
 * GNU Free Documentation License::
-* Index::
 
  -- The Detailed Node Listing --
 
@@ -55,13 +54,12 @@ Overview
 Installation
 
 * Ada Reference Manual::
-* gpr_query::
-* process parser::
+* Ada executables::
 
-gpr_query
+Ada executables
 
 * Building GNATCOLL 2019::
-* Building gpr_query::
+* Building the executables::
 
 Customizing Ada mode
 
@@ -82,7 +80,7 @@ Compiling Examples
 * No project files::            Just menus
 * Set compiler options::        A basic Ada mode project file
 * Set source search path::      Source in multiple directories
-* Use GNAT project file::
+* Use wisi project file::
 * Use multiple GNAT project files::
 * Use a Makefile::
 
@@ -94,18 +92,10 @@ Project files
 Developer overview
 
 * Directory structure::
-* Package organization::
 * ELPA::
 * Savannah::
 * ada-france::
 
-Package organization
-
-* Ada mode::
-* gpr mode::
-* GNAT core::
-* Wisi::
-
 
 
 File: ada-mode.info,  Node: Overview,  Next: Installation,  Prev: Top,  Up: Top
@@ -152,8 +142,16 @@ File: ada-mode.info,  Node: Why not LSP?,  Up: Overview
 
 The Language Server Protocol (LSP, <https://langserver.org>) supports an
 external language parser, as Ada mode does, and it is supported by the
-GNU ELPA package eglot.  We do not use LSP, because it does not support
-indentation and fontification.
+GNU ELPA package eglot.  Ada mode does not use LSP mostly for historical
+reasons; the Ada mode parser was first developed before LSP was started.
+In addition, LSP does not support some of the navigation information
+provided by the Ada mode parser (although that could be provided as a
+custom command).
+
+   We may investigate supporting an LSP parser in the future.  In
+particular, the AdaCore Gnat Studio editor uses an LSP parser for
+several functions; Emacs Ada mode could use that as a backend if it
+supports LSP.
 
 
 File: ada-mode.info,  Node: Installation,  Next: Customization,  Prev: 
Overview,  Up: Top
@@ -163,35 +161,30 @@ File: ada-mode.info,  Node: Installation,  Next: 
Customization,  Prev: Overview,
 
 Ada mode requires Emacs 25.0 or greater.  Compiling the Ada code for the
 external process parser requires GNAT GPL 2017 or later; tested with
-GNAT Community Edition 2018 and GNAT Pro 19.
+GNAT Community Edition 2019 and GNAT Pro 19.
 
    Ada mode is distributed in the Gnu ELPA package archive; it can be
-installed via 'M-x list-packages' (*note (emacs)Packages::).  In Emacs <
-27 you must first enable packages in your '~/.emacs', _after_
-customizing 'Info-default-directory-list' (if you do that):
+installed via 'M-x list-packages' (*note (emacs)Packages::).  Note that
+it requires the 'wisi' and 'uniquify-files' packages as dependencies.
 
-     (package-initialize)
-
-   Ada mode is also available as a separate distribution, from the Emacs
-Ada mode website
-<http://stephe-leake.org/emacs/ada-mode/emacs-ada-mode.html>.
+   In Emacs < 27 you must first enable packages in your '~/.emacs',
+_after_ customizing 'Info-default-directory-list' (if you do that):
 
-   For installing the separate distribution, see the 'README' file in
-the distribution.
+     (package-initialize)
 
    To see what version of Ada mode you have installed, invoke 'M-x
 ada-mode-version'.
 
-   You may also want to install additional utilities:
+   You must also install the associated Ada executables (for the
+language parser).  You may want to install the Ada Reference Manual.
 
 * Menu:
 
 * Ada Reference Manual::
-* gpr_query::
-* process parser::
+* Ada executables::
 
 
-File: ada-mode.info,  Node: Ada Reference Manual,  Next: gpr_query,  Prev: 
Installation,  Up: Installation
+File: ada-mode.info,  Node: Ada Reference Manual,  Next: Ada executables,  Up: 
Installation
 
 2.1 Ada Reference Manual
 ========================
@@ -200,27 +193,42 @@ The ELPA package ada-ref-man includes the Ada Reference 
Manual and
 Annotated Ada Reference Manual in info format.
 
 
-File: ada-mode.info,  Node: gpr_query,  Prev: Ada Reference Manual,  Up: 
Installation
+File: ada-mode.info,  Node: Ada executables,  Prev: Ada Reference Manual,  Up: 
Installation
 
-2.2 gpr_query
-=============
+2.2 Ada executables
+===================
+
+Ada mode requires the external parser, which must be compiled.
 
-Ada mode has support for an external cross reference tool 'gpr_query',
-which uses compiler-generated information.  In the case of Ada, the
-necessary '.ali' files are automatically generated by the standard
-compilation process.  For other languages, e.g.  C, C++, '.gli' files
-can be generated using the compiler switch '-fdump-xref'.  '-fdump-xref'
-is an AdaCore extension, not available in FSF GCC.
+   Ada mode has support for an external cross reference tool
+'gpr_query', which uses compiler-generated information.  In the case of
+Ada, the necessary '.ali' files are automatically generated by the
+standard compilation process.  For other languages, e.g.  C, C++, '.gli'
+files can be generated using the compiler switch '-fdump-xref'.
+'-fdump-xref' is an AdaCore extension, not available in FSF GCC.
 
    'gpr_query' is an Ada program, which is distributed as source and
 must be built.  Its source code is in the 'ada-mode' Gnu ELPA package.
 
-   'gpr_query' requires the 'GNATCOLL' library provided by AdaCore,
-distributed with GNAT GPL 2017 or later, and also available at Github
-(<https://github.com/AdaCore/gnatcoll>).  The notes below assume that
-the compiler is installed at '$prefix', e.g.  '/usr/local/gnat-2019',
-and that '$prefix/bin' is first on the 'PATH'.  If you are running
-Windows, use mingw64 'bash' to run these commands.
+   'gpr_query' is similar to the AdaCore utility 'gnatxref', but
+supports additional queries.
+
+   Both the parser and 'gpr_query' require the 'GNATCOLL' library
+provided by AdaCore, distributed with GNAT GPL 2017 or later, and also
+available at Github (<https://github.com/AdaCore/gnatcoll>).  The notes
+below assume that the compiler is installed at '$prefix', e.g.
+'/usr/local/gnat-2019', and that '$prefix/bin' is first on the 'PATH'.
+If you are running Windows, use mingw64 'bash' to run these commands.
+
+   On linux, some versions of the 'GNATCOLL.iconv' package (used by
+'gpr_query', but not the parser) explicity require the 'libiconv.so'
+library.  GNAT provides the 'libiconv.so' library in
+'<gnat>/lib64/libiconv.so'.  On Debian, that directory is not in the
+standard load path, and iconv is provided by glibc, so 'libiconv.so' is
+not found on the standard load path.  So you must set LD_LIBRARY_PATH,
+but only when running 'gpr-query':
+
+     (setq gpr-query-env '("LD_LIBRARY_PATH=/Projects/gnat/pro_19.2/lib64")
 
    In general, 'gpr_query' should be compiled with the compiler version
 that is used to generate the user project '.ali' files; the 'ali' file
@@ -235,10 +243,10 @@ build gnatcoll xref from sources.
 * Menu:
 
 * Building GNATCOLL 2019::
-* Building gpr_query::
+* Building the executables::
 
 
-File: ada-mode.info,  Node: Building GNATCOLL 2019,  Next: Building gpr_query, 
 Up: gpr_query
+File: ada-mode.info,  Node: Building GNATCOLL 2019,  Next: Building the 
executables,  Up: Ada executables
 
 2.2.1 Building GNATCOLL 2019
 ----------------------------
@@ -259,32 +267,29 @@ download" button, select "Download ZIP".
      make -C xref install
 
 
-File: ada-mode.info,  Node: Building gpr_query,  Prev: Building GNATCOLL 2019, 
 Up: gpr_query
+File: ada-mode.info,  Node: Building the executables,  Prev: Building GNATCOLL 
2019,  Up: Ada executables
 
-2.2.2 Building 'gpr_query'
---------------------------
+2.2.2 Building the executables
+------------------------------
+
+'gpr_query' requires the 'pthread' library.  On Windows, this is
+available in Mingw64 as package
+'mingw64/mingw-w64-x86_64-winpthreads-git'.
 
-To build and install 'gpr_query', assuming the 'ada-mode-6.0.xx' GNU
-ELPA package is installed:
+   To build and install 'gpr_query' and the parser, assuming the
+'ada-mode-6.0.xx' GNU ELPA package is installed:
 
      cd ~/.emacs.d/elpa/ada-mode-6.0.xx
      ./build.sh
+     ./install.sh
 
-   'ada-mode' will use 'gpr_query' for cross reference functions if
-'gpr_query' is found in 'PATH'.
-
-
-File: ada-mode.info,  Node: process parser
-
-2.3 process parser
-==================
+   By default, 'install.sh' installs the executables in the same
+directory as the GNAT executable (using 'gprinstall').  If you don't
+have write privileges there, or if you want to install somewhere else,
+use 'install.sh --prefix=<dir>'.
 
-The process parser is built and installed by the same 'build.sh' script
-as *Note gpr_query::.  ada-mode will automatically use it if it is
-available.
-
-   To override the automatic choice of parser, set ADA-PARSER to either
-''elisp' or ''parser'.
+   'ada-mode' will use 'gpr_query' and the parser if they are found in
+'PATH'.
 
 
 File: ada-mode.info,  Node: Customization,  Next: Compiling Executing,  Prev: 
Installation,  Up: Top
@@ -311,13 +316,13 @@ File: ada-mode.info,  Node: Slow response,  Next: 
Non-standard file names,  Up:
 3.1 Slow response
 =================
 
-In large files, parsing is slow, so it gets in the way of interactive
-typing due to immediate fontification triggering a parse.
+In large files, parsing takes a noticable amount of time, so it gets in
+the way of interactive typing due to immediate fontification triggering
+a parse.
 
    There are three ways to deal with this:
 
-  1. Install the process parser (*Note process parser::), and set
-     'wisi-partial-parse-threshold' appropriately in your '~./emacs':
+  1. Set 'wisi-partial-parse-threshold' In your '~./emacs':
 
           (setq wisi-partial-parse-threshold 100001)
 
@@ -325,17 +330,16 @@ typing due to immediate fontification triggering a parse.
      on how fast your machine is, and what your tolerance for slow
      response is.
 
-     Files larger than 'wisi-partial-parse-threshold' will be parsed
-     partially; only the part of the buffer needed for the current task
-     will be parsed.  For fontification, that is the visible part.  For
-     indent, it is approximately the current subprogram or package.  For
-     navigation, it is always the entire file, which will still be slow;
-     that is the only way to ensure useful results.
+     Files larger than 'wisi-partial-parse-threshold' (in characters)
+     will be parsed partially; only the part of the buffer needed for
+     the current task will be parsed.  For fontification, that is the
+     visible part.  For indent, it is approximately the current
+     subprogram or package.  For navigation, it is always the entire
+     file, which will still be slow; that is the only way to ensure
+     useful results.
 
      With this setting, indentation may not be correct; the Ada menu
-     entry "Edit | Indent lines in file" (or "Edit | Indent current
-     statement", if point is on a keyword of a large enough enclosing
-     statement) will parse the entire file and indent correctly.
+     entry "Edit | Indent containing statement" will indent correctly.
 
   2. Delay fontification by setting 'jit-lock-defer-time' in your
      '~./emacs':
@@ -371,7 +375,8 @@ spec and back.
 
    Emacs and Ada mode support ways to use alternative file extensions
 for specs and bodies.  Note that you must also tell the compiler about
-these extensions; doing that is beyond the scope of this manual.
+these extensions in a GNAT project file Naming package; doing that is
+beyond the scope of this manual.
 
    For instance, if your spec and bodies files are called 'UNIT_s.ada'
 and 'UNIT_b.ada', respectively, you can add the following to your
@@ -407,15 +412,15 @@ File: ada-mode.info,  Node: Other compiler,  Next: Other 
cross-reference,  Prev:
 3.3 Other compiler
 ==================
 
-The project variable 'ada_compiler' (default elisp variable
-'ada-compiler') is used to index several variables that point to the
+The wisi project variable 'ada_compoiler' (default elisp variable
+'ada-compiler') (default ''gnat') controls dispatching in
 compiler-specific functions for corresponding Ada mode operations.
 
    To use a compiler other than GNAT, you must write Emacs lisp code
 that provides the interface to the compiler, and set 'ada-compiler' and
 the indirection variables.
 
-   See 'ada-gnat-compile.el' for an example.
+   See 'ada-compiler-gnat.el' for an example.
 
 
 File: ada-mode.info,  Node: Other cross-reference,  Next: Other customization, 
 Prev: Other compiler,  Up: Customization
@@ -423,8 +428,8 @@ File: ada-mode.info,  Node: Other cross-reference,  Next: 
Other customization,
 3.4 Other cross-reference
 =========================
 
-The project variable 'ada_xref' (default elisp variable 'ada-xref-tool')
-is used to index several variables that point to the
+The wisi project variable 'xref_tool' (default elisp variable
+'ada-xref-tool') controls dispatching in the
 cross-reference-tool-specific functions for corresponding Ada mode
 operations.
 
@@ -444,8 +449,8 @@ File: ada-mode.info,  Node: Other customization,  Prev: 
Other cross-reference,
 =======================
 
 All user-settable Ada mode variables can be set via the menu 'Ada |
-Customize'.  Click on the 'Help' button there for help on using
-customize.
+Customize'; some can also be set in wisi project files (*note Project
+files::).
 
    To modify a specific variable, you can directly call the function
 'customize-variable'; just type 'M-x customize-variable <RET>
@@ -454,9 +459,11 @@ VARIABLE-NAME <RET>'.
    Alternately, you can specify variable settings in the Emacs
 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 Ada files:
+
 'context menu'
      By default, the context menu is bound to <C-down-mouse-3>, i.e.
      control-right-click.  <down-mouse-3> is already bound in the global
@@ -468,6 +475,17 @@ the syntax to set a variable is the following:
      Gnu ELPA package 'other-frame-window'.
 'delete-trailing-whitespace'
      Deletes space, tab at end of line and blank lines at end of buffer.
+'xref configuration'
+     'xref-prompt-for-identifier'
+          Set to 'nil' to be prompted less when finding definitions or
+          references.
+     'xref-show-xrefs-function'
+          Determine placement of the window where references are shown.
+     'xref-show-definitions-function'
+          Determine placement of the window where definitions are shown.
+     'xref--transient-buffer-mode-map'
+          keymap used in some xref windows; you may want to disable the
+          <RET> binding there.
 'untabify'
      Deletes tab characters that have crept into the file.
 'indent-tabs-mode'
@@ -481,9 +499,8 @@ the syntax to set a variable is the following:
      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
-     'ada-skel-hippie-try' to that list.  Note that 'ada-expand', which
-     defaults to 'ada-skel-expand', is bound to <C-c C-e> (*note
-     Statement skeletons::).
+     'wisi-skel-hippie-try' to that list.  Note that 'wisi-skel-expand'
+     is bound to <C-c C-e> (*note Statement skeletons::).
 'imenu'
      Navigate to subprograms and types by name, from a minibuffer menu.
 'speedbar'
@@ -499,10 +516,15 @@ ada-mode does not set up the Ada-specific features of 
imenu and speedbar
 unless imenu is loaded first.
 
      (setq-default indent-tabs-mode nil)
+     (define-key xref--transient-buffer-mode-map (kbd "RET") 'xref-goto-xref)
+     (setq xref-prompt-for-identifier nil) ;; only prompt on C-u
+     (setq xref-show-xrefs-function #'xref--show-defs-buffer-at-bottom)
+     (setq xref-show-definitions-function #'xref--show-defs-buffer-at-bottom)
+
      (electric-pair-mode 1)
      (require 'imenu) ;; also enables speedbar
      (require 'ada-mode)
-     (add-to-list 'hippie-expand-try-functions-list 'ada-skel-hippie-try)
+     (add-to-list 'hippie-expand-try-functions-list 'wisi-skel-hippie-try)
      (define-key ada-mode-map "\C-e"     'hippie-expand)
      (define-key ada-mode-map [down-mouse-3] 'ada-popup-menu)
      (add-hook 'ada-mode-hook
@@ -526,8 +548,8 @@ GNAT compiler for simple projects (single files, or several 
files in a
 single directory).
 
    For complex projects, you will want to use 'make' or some other build
-tool; in that case, you will need an Emacs Ada mode project file to tell
-Emacs about the project directory tree and other settings.
+tool; in that case, you may need a wisi project file to tell Emacs about
+the project directory tree and other settings.
 
 * Menu:
 
@@ -542,7 +564,7 @@ File: ada-mode.info,  Node: Compile commands,  Next: 
Compiling Examples,  Prev:
 ====================
 
 Here are the commands for building an Ada project and running the main
-program.
+program; they are all on the 'Ada | Build' menu.
 
    In multi-file projects, there must be one file that is the main
 program.  That is given by the 'main' project file variable; it defaults
@@ -567,7 +589,7 @@ build" command.
      Sets 'main' to the current file, then executes the Build command.
 
 'Show main'
-     Display 'main' in the message buffer.
+     Displays 'main' in the message buffer.
 
 'Build'
      Compiles all obsolete units of the current 'main', and links
@@ -588,7 +610,7 @@ build" command.
    It is important when using these commands to understand how 'main' is
 used and changed.
 
-   Build runs 'gnatmake' on the main unit.  During a typical
+   Build runs 'gprbuild' on the main unit.  During a typical
 edit/compile session, this is the only command you need to invoke, which
 is why it is bound to 'C-c C-c'.  It will compile all files needed by
 the main unit, and display compilation errors in any of them.
@@ -631,7 +653,7 @@ website mentioned in *Note Installation::.
 * No project files::            Just menus
 * Set compiler options::        A basic Ada mode project file
 * Set source search path::      Source in multiple directories
-* Use GNAT project file::
+* Use wisi project file::
 * Use multiple GNAT project files::
 * Use a Makefile::
 
@@ -647,13 +669,13 @@ This example uses no project files.
 
    'hello.adb':
 
-     with Ada.Text_IO;
+     with Ada.Text_Io;
      procedure Hello
      is begin
         Put_Line("Hello from hello.adb");
      end Hello;
 
-   Yes, this is missing "use Ada.Text_IO;" - we want to demonstrate
+   Yes, this is missing "use Ada.Text_Io;" - we want to demonstrate
 compiler error handling.
 
    'hello_2.adb' has no errors:
@@ -672,18 +694,17 @@ compiler error handling.
 
    'hello_pkg.adb':
 
-     with Ada.Text_IO;
+     with Ada.Text_Io;
      package Hello_Pkg is
         procedure Say_Hello
         is begin
-           Ada.Text_IO.Put_Line ("Hello from hello_pkg.adb");
+           Ada.Text_Io.Put_Line ("Hello from hello_pkg.adb");
         end Say_Hello;
      end Hello_Pkg;
 
    Yes, this is missing the keyword 'body'; another compiler error
 example.  However, note that the indentation engine parser accepts this
-code with no errors, making it easier to indent slightly illegal Ada
-code.
+code, making it possible to indent illegal Ada code.
 
    In buffer 'hello.adb', invoke the menu entry 'Ada | Build | Check
 syntax'.  You should get a '*compilation*' buffer containing something
@@ -692,12 +713,14 @@ like (the directory paths will be different):
      -*- mode: compilation; default-directory: 
"c:/Projects/org.emacs.ada-mode.stephe-1/test/Example_1/" -*-
      Compilation started at Fri Oct 18 04:23:54
 
-     gnatmake -u -c -gnatc  
c:/Projects/org.emacs.ada-mode.stephe-1/test/Example_1/hello.adb -cargs
-     gcc -c -Ic:/Projects/org.emacs.ada-mode.stephe-1/test/Example_1/ -gnatc 
-I- c:/Projects/org.emacs.ada-mode.stephe-1/test/Example_1/hello.adb
+     gprbuild  -u -c -gnatc  
c:/Projects/org.emacs.ada-mode/test/Example_1/hello.adb
+     using project file D:\Apps\GNAT-gpl_2019\share\gpr\_default.gpr
+     Compile
+        [Ada]          hello.adb
      hello.adb:4:04: "Put_Line" is not visible
      hello.adb:4:04: non-visible declaration at a-textio.ads:263
      hello.adb:4:04: non-visible declaration at a-textio.ads:259
-     gnatmake: 
"c:/Projects/org.emacs.ada-mode.stephe-1/test/Example_1/hello.adb" compilation 
error
+     gprbuild: *** compilation phase failed
 
      Compilation exited abnormally with code 4 at Fri Oct 18 04:23:54
 
@@ -706,9 +729,9 @@ highlighted, with the file name in red.
 
    Now invoke 'Ada | Build | Next compilation error'.  Or you can click
 the middle mouse button on the first error line, or use the key binding
-shown on the menu.  The compilation buffer scrolls to put the first
-error on the top line, and point is put at the place of the error in the
-'hello.adb' buffer.
+shown on the menu.  In the compilation buffer, a triangle is placed in
+the left fringe on the first error line, and point is put at the place
+of the error in the 'hello.adb' buffer.
 
    To fix the error, invoke 'Ada | Build | Fix compilation error'; this
 adds "Ada.Text_Io."  to the line:
@@ -725,10 +748,15 @@ compilation buffer is displayed again, containing:
      -*- mode: compilation; default-directory: 
"c:/Projects/org.emacs.ada-mode.stephe-1/test/Example_1/" -*-
      Compilation started at Fri Oct 18 20:39:33
 
-     gnatmake -o hello hello  -cargs  -bargs  -largs
-     gcc -c hello.adb
-     gnatbind -x hello.ali
-     gnatlink hello.ali -o hello.exe
+     gprbuild  hello
+     using project file D:\Apps\GNAT-gpl_2019\share\gpr\_default.gpr
+     Compile
+        [Ada]          hello.adb
+     Bind
+        [gprbind]      hello.bexch
+        [Ada]          hello.ali
+     Link
+        [link]         hello.adb
 
      Compilation finished at Fri Oct 18 20:39:34
 
@@ -754,11 +782,10 @@ error in 'hello_pkg.adb':
 
      hello_pkg.adb:2:08: keyword "body" expected here [see file name]
 
-   This demonstrates that gnatmake finds the files needed by the main
+   This demonstrates that gprbuild finds the files needed by the main
 program.  However, it cannot find files in a different directory, unless
-you use an Emacs Ada mode project file or a GNAT project file to specify
-the other directories; *Note Set source search path::, *note Use GNAT
-project file::.
+you use a GNAT project file to specify the other directories; *note Set
+source search path::.
 
    Invoke 'Ada | Build | Show main'; this displays 'Ada mode main:
 hello_2'.
@@ -768,7 +795,7 @@ hello_2'.
      package body Hello_Pkg is
 
    Now, while still in 'hello_pkg.adb', invoke 'Ada | Build | Build'.
-gnatmake successfully builds 'hello_2'.  This demonstrates that Emacs
+gprbuild successfully builds 'hello_2'.  This demonstrates that Emacs
 has remembered the main file, in the project variable 'main', and used
 it for the Build command.
 
@@ -794,8 +821,8 @@ File: ada-mode.info,  Node: Set compiler options,  Next: 
Set source search path,
 4.2.2 Set compiler options
 --------------------------
 
-This example illustrates using an Emacs Ada mode project file to set a
-compiler option.
+This example illustrates using a gnat project file to set a compiler
+option.
 
    If you have files from 'Example_1' open in Emacs, you should close
 them so you don't get confused.  Use menu 'File | Close (current
@@ -805,54 +832,58 @@ buffer)'.
 
    'hello.adb':
 
-     with Ada.Text_IO;
+     with Ada.Text_Io;
      procedure Hello
      is begin
         Put_Line("Hello from hello.adb");
      end Hello;
 
    This is the same as 'hello.adb' from 'Example_1'.  It has two errors;
-missing "use Ada.Text_IO;", and no space between 'Put_Line' and its
+missing "use Ada.Text_Io;", and no space between 'Put_Line' and its
 argument list.
 
-   'hello.adp':
+   'hello.gpr':
 
-     comp_opt=-gnatyt
+     project Hello is
+        package Compiler is
+           for Default_Switches ("Ada") use ("-gnatyt");
+        end Compiler;
+     end Hello;
 
    This tells the GNAT compiler to check for token spacing; in
 particular, there must be a space preceding a parenthesis.
 
    In buffer 'hello.adb', invoke 'Ada | Build | Set main and Build'.
-This finds the project file 'hello.adp', uses it to set the compiler
+This finds the project file 'hello.gpr', uses it to set the compiler
 options, and builds the project.  You should get a '*compilation*'
 buffer containing something like (the directory paths will be
 different):
 
-     cd c:/Examples/Example_2/
-     gnatmake -o hello hello -g -cargs -gnatyt  -bargs  -largs
-     gcc -c -g -gnatyt hello.adb
+     gprbuild -Phello.gpr hello
+     Compile
+        [Ada]          hello.adb
      hello.adb:4:04: "Put_Line" is not visible
-     hello.adb:4:04: non-visible declaration at a-textio.ads:264
-     hello.adb:4:04: non-visible declaration at a-textio.ads:260
+     hello.adb:4:04: non-visible declaration at a-textio.ads:508
+     hello.adb:4:04: non-visible declaration at a-textio.ads:498
      hello.adb:4:12: (style) space required
-     gnatmake: "hello.adb" compilation error
+     gprbuild: *** compilation phase failed
 
    Compare this to the compiler output in *note No project files::; the
-gnatmake option '-cargs' has been replaced by '-cargs -gnaty', and an
-additional error is reported in 'hello.adb' on line 4.  This shows that
-'hello.adp' is being used to set the compiler options.
+compiler-provided default gpr file has been replaced by 'hello.gpr', and
+an additional error is reported in 'hello.adb' on line 4.  This shows
+that 'hello.gpr' is being used to set the compiler options.
 
-   Fixing the error, linking and running the code proceed as in *note No
-project files::.
+   Use 'C-x`', 'C-c M-`' to fix the errors, then 'Ada | Build | Build'
+and 'Ada | Build | Run' to build and run.
 
 
-File: ada-mode.info,  Node: Set source search path,  Next: Use GNAT project 
file,  Prev: Set compiler options,  Up: Compiling Examples
+File: ada-mode.info,  Node: Set source search path,  Next: Use wisi project 
file,  Prev: Set compiler options,  Up: Compiling Examples
 
 4.2.3 Set source search path
 ----------------------------
 
 In this example, we show how to deal with files in more than one
-directory, using an Emacs Ada mode project file to set the search path.
+directory, setting the source search path in the gpr file.
 
    Create the directory 'Example_3', containing:
 
@@ -864,24 +895,30 @@ directory, using an Emacs Ada mode project file to set 
the search path.
 
    'hello_pkg.adb':
 
-     with Ada.Text_IO;
+     with Ada.Text_Io;
      package Hello_Pkg is
         procedure Say_Hello
         is begin
-           Ada.Text_IO.Put_Line ("Hello from hello_pkg.adb");
+           Ada.Text_Io.Put_Line ("Hello from hello_pkg.adb");
         end Say_Hello;
      end Hello_Pkg;
 
    These are the same files from example 1; 'hello_pkg.adb' has an error
 on line 2.
 
-   In addition, create a directory 'Example_3/Other', containing these
-files:
+   'other.gpr':
+
+     project Other is
+        for Source_Dirs use (".", "Other");
+     end Other;
+
+   In addition, create a directory 'Example_3/Other', containing this
+file:
 
    'Other/hello_3.adb':
 
      with Hello_Pkg;
-     with Ada.Text_IO; use Ada.Text_IO;
+     with Ada.Text_Io; use Ada.Text_Io;
      procedure Hello_3
      is begin
         Hello_Pkg.Say_Hello;
@@ -890,48 +927,44 @@ files:
 
    There are no errors in this file.
 
-   'Other/other.adp':
-
-     src_dir=..
-
-   Note that there must be no trailing spaces.
-
-   In buffer 'hello_3.adb', invoke 'Ada | Project files | Find and set
-project...', and select 'Example_3/Other/other.adp'.  This tells Emacs
+   In buffer 'hello_3.adb', invoke 'Ada | Project files | Find and
+select project...', and select 'Example_3/other.gpr'.  This tells Emacs
 Ada mode to stop using the project file from 'Example_2', and use the
 one for 'Example_3'.  Also note that since this project file is not
-named 'hello_3.adp', it would not be found by default.
+named 'hello_3.gpr', it would not be found by default.
 
    Then, again in 'hello_3.adb', invoke 'Ada | Set main and Build'.  You
 should get a '*compilation*' buffer containing something like (the
 directory paths will be different):
 
-     cd c:/Examples/Example_3/Other/
-     gnatmake -o hello_3 hello_3 -g -cargs -I.. -bargs  -largs
-     gcc -c -g -I.. hello_3.adb
-     gcc -c -I./ -g -I.. -I- C:\Examples\Example_3\hello_pkg.adb
+     gprbuild -Pother.gpr hello_3
+     Compile
+        [Ada]          hello_3.adb
+        [Ada]          hello_pkg.adb
      hello_pkg.adb:2:08: keyword "body" expected here [see file name]
-     gnatmake: "C:\Examples\Example_3\hello_pkg.adb" compilation error
-
-   Compare the '-cargs' option to the compiler output in *note Set
-compiler options::; this shows that 'other.adp' is being used to set the
-compiler options.
+     gprbuild: "C:\Examples\Example_3\hello_pkg.adb" compilation error
 
    Move to the error with 'C-x `'.  Ada mode searches the list of
-directories given by 'src_dir' for the file mentioned in the compiler
-error message.
+directories given by 'Source_Dirs' for the file mentioned in the
+compiler error message.
 
-   Fixing the error, linking and running the code proceed as in *note No
-project files::.
+   Use 'C-x`', 'C-c M-`' to fix the errors, then 'Ada | Build | Build'
+and 'Ada | Build | Run' to build and run.
 
 
-File: ada-mode.info,  Node: Use GNAT project file,  Next: Use multiple GNAT 
project files,  Prev: Set source search path,  Up: Compiling Examples
+File: ada-mode.info,  Node: Use wisi project file,  Next: Use multiple GNAT 
project files,  Prev: Set source search path,  Up: Compiling Examples
 
-4.2.4 Use GNAT project file
+4.2.4 Use wisi project file
 ---------------------------
 
-In this example, we show how to use a GNAT project file, with no Ada
-mode project file.
+In this example, we show how to use a wisi project file to set some
+options that cannot be set in a gpr project file.  In addition, we
+change a setting so you are prompted for a project file, rather than
+using a default one.
+
+   Change the setting:
+
+     M-x set-variable ada-build-prompt-prj search-prompt
 
    Create the directory 'Example_4', containing:
 
@@ -943,73 +976,113 @@ mode project file.
 
    'hello_pkg.adb':
 
-     with Ada.Text_IO;
-     package Hello_Pkg is
+     with Ada.Text_Io;
+     package body Hello_Pkg is
         procedure Say_Hello
         is begin
-           Ada.Text_IO.Put_Line ("Hello from hello_pkg.adb");
+           Put_Line ("Hello from hello_pkg.adb");
         end Say_Hello;
      end Hello_Pkg;
 
-   These are the same files from example 1; 'hello_pkg.adb' has an error
-on line 2.
+   These two files are the similar to files from example 1;
+'hello_pkg.adb' has an error on line 5 (missing "Ada.Text_IO.").
+
+   'example_4.prj':
 
-   In addition, create a directory 'Example_4/Gnat_Project', containing
-these files:
+     -- Wisi project file
 
-   'Gnat_Project/hello_4.adb':
+     gpr_project_path=More
+
+     gpr_file=example_4.gpr
+
+     casing=example_4.casing
+
+   'example_4.prj' is a wisi project file; it specifies the
+'gpr_project_path', telling 'gprbuild' where to search for gpr files,
+and specifies the gpr file to use.  Finally it specifies a casing
+exception file:
+
+   'example_4.casing':
+
+     Text_IO
+
+   The default auto casing rules in ada-mode state that the Ada package
+"Ada.Text_IO" should be capitalized as "Ada.Text_Io", which does not
+match the Ada Reference Manual.  'example_4.casing' specifies that
+instead "Text_IO" should be capitalized as shown.
+
+   You can create a casing exception by editing the file directly, or
+via the 'Ada | Casing' menu.
+
+   'gpr_project_path' and 'casing' are list variables; each occurence in
+a wisi project file adds an entry to the list.
+
+   In addition, create a directory 'Example_4/More', containing these
+files:
+
+   'more/hello_4.adb':
 
      with Hello_Pkg;
-     with Ada.Text_IO; use Ada.Text_IO;
+     with Ada.Text_Io; use Ada.Text_Io;
      procedure Hello_4
      is begin
         Hello_Pkg.Say_Hello;
         Put_Line ("From hello_4");
      end Hello_4;
 
-   There are no errors in this file.
+   There are no errors in this file, except for the casing in
+"Ada.Text_Io".
 
-   'Gnat_Project/hello_4.gpr':
+   'More/example_4.gpr':
 
-     project Hello_4 is
+     project Example_4 is
         for Source_Dirs use (".", "..");
-     end Hello_4;
-
-   In buffer 'hello_4.adb', invoke 'Ada | Project | Load...', and select
-'Example_4/Gnat_Project/hello_4.gpr'.
-
-   Then, again in 'hello_4.adb', invoke 'Ada | Set main and Build'.  You
-should get a '*compilation*' buffer containing something like (the
-directory paths will be different):
-
-     -*- mode: compilation; default-directory: 
"c:/Projects/org.emacs.ada-mode.stephe-1/test/Example_4/Gnat_Project/" -*-
-     Compilation started at Mon Oct 21 11:28:31
-
-     gnatmake 
-Pc:/Projects/org.emacs.ada-mode.stephe-1/test/Example_4/Gnat_Project/hello_4.gpr
 -o hello_4 hello_4  -cargs -I. 
-Ic:/Projects/org.emacs.ada-mode.stephe-1/test/Example_4/Gnat_Project 
-Ic:/Projects/org.emacs.ada-mode.stephe-1/test/Example_4 
-Ic:/Apps/GNAT-7.1.2/lib/gcc/i686-pc-mingw32/4.7.3/adainclude  -bargs  -largs
-     gcc -c -I. 
-Ic:/Projects/org.emacs.ada-mode.stephe-1/test/Example_4/Gnat_Project 
-Ic:/Projects/org.emacs.ada-mode.stephe-1/test/Example_4 
-Ic:/Apps/GNAT-7.1.2/lib/gcc/i686-pc-mingw32/4.7.3/adainclude -I- -gnatA 
C:\Projects\org.emacs.ada-mode.stephe-1\test\Example_4\hello_pkg.adb
-     hello_pkg.adb:2:08: keyword "body" expected here [see file name]
-     gnatmake: 
"C:\Projects\org.emacs.ada-mode.stephe-1\test\Example_4\hello_pkg.adb" 
compilation error
 
-     Compilation exited abnormally with code 4 at Mon Oct 21 11:28:31
-
-   Compare the 'gcc' options to the compiler output in *note Set
-compiler options::; this shows that 'hello_4.gpr' is being used to set
-the compiler options.
-
-   Fixing the error, linking and running the code proceed as in *note No
-project files::.
+        package Compiler is
+           for Default_Switches ("Ada") use ("-gnatyknpr");
+        end Compiler;
+     end Example_4;
+
+   The compiler switch checks all casing; we will get errors for
+"Ada.Text_Io".
+
+   Then, in 'hello_4.adb', invoke 'Ada | Set main and Build'.  ada-mode
+looks for a project file 'hello_4.prj' or 'hello_4.gpr'; since neither
+is found, you are prompted to find a project file.  Select
+'Example_4/example_4.prj'; that is parsed and selected, and the build
+continues.
+
+   You should get a '*compilation*' buffer containing something like
+(the directory paths will be different):
+
+     gprbuild -Pexample_4.gpr hello_4
+     Compile
+        [Ada]          hello_pkg.adb
+     hello_pkg.adb:1:16: (style) bad casing of "Text_IO" declared at 
a-textio.ads:57
+     hello_pkg.adb:5:07: "Put_Line" is not visible
+     hello_pkg.adb:5:07: non-visible declaration at a-textio.ads:508
+     hello_pkg.adb:5:07: non-visible declaration at a-textio.ads:498
+     gprbuild: *** compilation phase failed
+
+   When you fix the errors, note that 'C-c M-`' inserts the correct case
+for "Ada.Text_IO", and corrects the case where it is incorrect.  The
+case is also corrected as you type; you can type "ada.text_io."  and the
+case will be corrected when you type each "."  or "_".
 
 
-File: ada-mode.info,  Node: Use multiple GNAT project files,  Next: Use a 
Makefile,  Prev: Use GNAT project file,  Up: Compiling Examples
+File: ada-mode.info,  Node: Use multiple GNAT project files,  Next: Use a 
Makefile,  Prev: Use wisi project file,  Up: Compiling Examples
 
 4.2.5 Use multiple GNAT project files
 -------------------------------------
 
 In this example, we show how to use multiple GNAT project files,
 specifying the GNAT project search path in an Ada mode project file.
+This also requires explicitly setting 'project-find-functions'.
 
-   Create the directory 'Example_4' as specified in *note Use GNAT
-project file::.
+   If you haven't already, create the directory 'Example_4' as specified
+in *note Use wisi project file::.  If you've already created it and run
+the tutorial, restore the compilation error in hello_pkg.adb; delete
+'Ada.Text_IO.' in front of 'Put_Line'.
 
    Create the directory 'Example_5', containing:
 
@@ -1025,43 +1098,96 @@ project file::.
 
    There are no errors in this file.
 
-   'hello_5.adp':
+   'hello_5.prj':
 
-     ada_project_path=../Example_4/Gnat_Project
+     gpr_project_path=../Example_4/More
      gpr_file=hello_5.gpr
 
+     casing=../Example_4/example_4.casing
+
    'hello_5.gpr':
 
-     with "hello_4";
+     with "example_4";
      project Hello_5 is
         for Source_Dirs use (".");
         package Compiler is
-           for Default_Switches ("Ada") use ("-g", "-gnatyt");
+           for Default_Switches ("Ada") use ("-g", "-gnatyknprt");
         end Compiler;
      end Hello_5;
 
    In buffer 'hello_5.adb', invoke 'Ada | Project | Find and select
-project...', and select 'Example_5/hello_5.adp'.  This would also be
-found by default if no previous project file had been selected.
+project...', and select 'Example_5/hello_5.prj'.  This would also be
+found by default if no previous project file had been selected.  Note
+that if 'example_5.gpr' were named 'hello_5.gpr', the project file
+search would find more than one match, causing an error.
 
    Then, again in 'hello_5.adb', invoke 'Ada | Build | Set main and
 Build'.  You should get a '*compilation*' buffer containing something
 like (the directory paths will be different):
 
-     -*- mode: compilation; default-directory: 
"c:/Projects/org.emacs.ada-mode.stephe-1/test/Example_5/" -*-
+     -*- mode: compilation; default-directory: 
"c:/Projects/org.emacs.ada-mode/test/Example_5/" -*-
      Compilation started at Mon Oct 21 11:32:05
 
-     gnatmake 
-Pc:/Projects/org.emacs.ada-mode.stephe-1/test/Example_5/hello_5.gpr -o hello_5 
hello_5  -cargs -I. -Ic:/Projects/org.emacs.ada-mode.stephe-1/test/Example_5 
-Ic:/Projects/org.emacs.ada-mode.stephe-1/test/Example_4/Gnat_Project 
-Ic:/Projects/org.emacs.ada-mode.stephe-1/test/Example_4 
-Ic:/Apps/GNAT-7.1.2/lib/gcc/i686-pc-mingw32/4.7.3/adainclude  -bargs  -largs
-     gcc -c -I. -Ic:/Projects/org.emacs.ada-mode.stephe-1/test/Example_5 
-Ic:/Projects/org.emacs.ada-mode.stephe-1/test/Example_4/Gnat_Project 
-Ic:/Projects/org.emacs.ada-mode.stephe-1/test/Example_4 
-Ic:/Apps/GNAT-7.1.2/lib/gcc/i686-pc-mingw32/4.7.3/adainclude -I- -gnatA 
C:\Projects\org.emacs.ada-mode.stephe-1\test\Example_4\hello_pkg.adb
-     hello_pkg.adb:2:08: keyword "body" expected here [see file name]
-     gnatmake: 
"C:\Projects\org.emacs.ada-mode.stephe-1\test\Example_4\hello_pkg.adb" 
compilation error
-
-     Compilation exited abnormally with code 4 at Mon Oct 21 11:32:05
+     gprbuild -Pexample_5.gpr hello_5
+     Compile
+        [Ada]          hello_5.adb
+        [Ada]          hello_pkg.adb
+     hello_pkg.adb:5:07: "Put_Line" is not visible
+     hello_pkg.adb:5:07: non-visible declaration at a-textio.ads:508
+     hello_pkg.adb:5:07: non-visible declaration at a-textio.ads:498
+     gprbuild: *** compilation phase failed
 
-   Now type 'C-x `'.  'Example_4/hello_pkg.adb' is shown, demonstrating
+   Now type 'C-x `'; 'Example_4/hello_pkg.adb' is shown, demonstrating
 that 'hello_5.gpr' and 'hello_4.gpr' are being used to set the
 compilation search path.
 
+   Now, in buffer 'hello_pkg.adb' invoke the menu 'Ada | Navigate | Find
+file in project' (which calls 'ada-find-file') to get back to the
+'hello_5.adb' buffer.  If you have not selected any project files
+previously in this emacs session, this gives an unexpected prompt for a
+"project directory".  Kill that with 'C-g'.  Otherwise, enter 'hel <tab>
+5 <tab>'; it will say "no match".
+
+   The problem here the way Emacs projects work.  To find the current
+project, the functions in 'project-find-functions' are run; one should
+return a project.  The ada-mode build functions add
+'wisi-prj-find-dominating-cached' to 'project-find-functions'; that
+looks in the current directory tree for a project file with the same
+name as one that was previously selected.
+
+   If 'Example_5' is the only project in the current emacs session,
+'wisi-prj-find-dominating-cached' finds no project file (because
+'Example_4' is not a child directory of 'Example_5', so the default
+strategy of "ask the user" is used, giving the prompt for a directory.
+
+   If 'Example_4' is also a project in the current emacs session,
+'wisi-prj-find-dominating-cached' finds that; since it does not contain
+'hello_5.adb', 'ada-find-file' cannot find it.
+
+   Any time you have a main project that depends on other projects that
+are not in the same directory tree, you will have this problem.
+
+   The fix is to use a different function in 'project-find-functions';
+'wisi-prj-current-cached'.  This uses a global variable to indicate what
+the current project is.  wisi provides four different functions for
+'project-find-functions'.  *Note Selecting projects: (wisi)Selecting
+projects.
+
+   To change 'project-find-functions', execute:
+
+     M-: (remove-hook 'project-find-functions 'wisi-prj-find-dominating-cached)
+     M-: (add-hook 'project-find-functions 'wisi-prj-current-cached)
+
+   Normally, you must set 'project-find-functions' in your '~/.emacs',
+using the 'add-hook' function.  The ada-mode Build menu functions set it
+for you to make things simpler for novices, but they do not change it if
+you have put one of the wisi functions on it.
+
+   Now set the current project; invoke 'Ada | Project | Find and select
+project...', and select 'Example_5/hello_5.prj'.  Then in
+'hello_pkg.adb', invoke 'Ada | Navigate | Find file in project'; now we
+can find 'hello_5.adb'.
+
 
 File: ada-mode.info,  Node: Use a Makefile,  Prev: Use multiple GNAT project 
files,  Up: Compiling Examples
 
@@ -1072,7 +1198,7 @@ In this example, we show how to use a Makefile to build 
an Ada project
 with GNAT, run the result, and clean the build directories.
 
    Create the directories 'Example_4, Example_5' as specified in *note
-Use GNAT project file::, *note Use multiple GNAT project files::.
+Use wisi project file::, *note Use multiple GNAT project files::.
 
    In 'Example_5', add the file:
 
@@ -1085,29 +1211,34 @@ Use GNAT project file::, *note Use multiple GNAT 
project files::.
      .PHONY : force
 
      build : force
-             gprbuild -Phello_5.gpr hello_5
+             gprbuild -PExample_5.gpr hello_5
 
      run :
              ./hello_5
 
      clean :
-             gnatclean -r -Phello_5
-
-     export GPR_PROJECT_PATH = ../Example_4/Gnat_Project
+             gnatclean -r -PExample_5
 
      # Local Variables:
-     # eval:(ada-parse-prj-file "hello_5.adp")
-     # eval:(ada-select-prj-file "hello_5.adp")
+     # eval:(unless (wisi-prj-find-function-set-p)(add-hook 
'project-find-functions 'wisi-prj-current-cached))
+     # eval:(wisi-prj-dtrt-parse-file "hello_5.prj" (ada-prj-default "hello_5 
# main") "Makefile")
      # End:
 
+   Tell Emacs to allow 'eval' in 'Local Variables':
+     M-: (setq enable-local-eval t)
+
    Close and re-open 'Makefile'; the 'Local Variables' section sets the
-project file to 'hello_5.adp' when the 'Makefile' is opened.  You can
-also use <C-x C-e> to execute the select line after the 'Makefile' is
-opened, to change the project file back to 'hello_5.adp'.
+project file to 'hello_5.prj' when the 'Makefile' is opened.
+
+   If you have set 'project-find-functions' in your '~/.emacs', you can
+leave out the first 'eval' line.  Note that 'wisi-prj-dtrt-parse-file'
+does the right thing depending on which wisi function is in
+'project-find-functions'.
 
    In 'Makefile', invoke 'Tools | Compile...', and accept the default
 make command.  This runs the 'all' target, which builds 'hello_5' and
-runs it.
+runs it (you may have to fix source errors first, depending on how fresh
+the Example_4 directory is).
 
 
 File: ada-mode.info,  Node: Compiler errors,  Prev: Compiling Examples,  Up: 
Compiling Executing
@@ -1136,23 +1267,24 @@ File: ada-mode.info,  Node: Project files,  Next: 
Moving Through Ada Code,  Prev
 5 Project files
 ***************
 
-An Emacs Ada mode project file specifies what directories hold sources
-for your project, and allows you to customize the compilation commands
-and other things on a per-project basis.
+Ada mode uses wisi project files; *note Project files: (wisi)wisi.
+
+   A wisi project file specifies what directories hold sources for your
+project, and allows you to customize the compilation commands and other
+things on a per-project basis.
 
-   The default file extension for Ada mode project files is '*.adp' or
+   The default file extension for wisi project files is '*.adp' or
 '*.prj'.  You can use a different extension by adding it to
 'ada-prj-file-extensions', and a different syntax by adding a parser
 function to 'ada-prj-parser-alist'.
 
-   Note that Ada mode project files '*.adp' are different than GNAT
-compiler project files '*.gpr'.  However, Emacs Ada mode can use a GNAT
-project file to specify the project directories.  If no other
-customization is needed, a GNAT project file can be used without an
-Emacs Ada mode project file.
+   Note that wisi project files are different than GNAT compiler project
+files ('*.gpr').  However, Emacs Ada mode can use a GNAT project file to
+specify the project directories.  If no other customization is needed, a
+GNAT project file can be used without a wisi project file.
 
-   If no Emacs Ada mode project file is specified, some Ada mode
-functions are not available.
+   If no wisi project file is specified, some Ada mode functions are not
+available.
 
 * Menu:
 
@@ -1165,40 +1297,15 @@ File: ada-mode.info,  Node: Project file overview,  
Next: Project file variables
 5.1 Project file overview
 =========================
 
-Project files have a simple syntax; they may be edited directly.  Each
-line specifies a project variable name and its value, separated by "="
-(spaces not allowed):
-     src_dir=/Projects/my_project/src_1
-     src_dir=/Projects/my_project/src_2
-
-   Any line that does not have an "=" is a comment.
-
-   Some variables (like 'src_dir') are lists; multiple occurrences are
-concatenated.
+The current project file is shown by the menu command <Ada | Project
+Files | Show project>.
 
-   There must be no space between the variable name and "=", and no
-trailing spaces after the value.
-
-   The current project file is given by the lisp variable
-'ada-prj-default-project-file', and shown by the menu command <Ada |
-Project Files | Show project>.
-
-   To set the project file, use the menu command 'Ada | Set Project
-...', or the elisp functions 'ada-parse-prj-file, ada-select-prj-file'.
-The latter can be added to a Makefile:
-
-     # Local Variables:
-     # eval: (ada-parse-prj-file "ada-mode.prj")
-     # eval: (ada-select-prj-file ada-mode.prj")
-     # End:
+   To set the project file, use the menu command <Ada | Project Files |
+Find and select Project ...>, or one of the elisp functions described in
+*note Selecting Projects: (wisi)wisi.
 
-   You specify either a GNAT project file or an Emacs Ada mode project
-file; if the file extension is '.gpr', the file is treated as a GNAT
-project file.  Extensions given by 'ada-prj-file-extensions' (default
-'.adp, .prj') are treated as an Emacs Ada mode project file.
-
-   After a project file is parsed, you can make it current again with
-just 'ada-select-prj-file', or by selecting it from the menu.
+   The project file may also be a GNAT project file (with file extension
+is '.gpr').
 
 
 File: ada-mode.info,  Node: Project file variables,  Prev: Project file 
overview,  Up: Project files
@@ -1206,110 +1313,80 @@ File: ada-mode.info,  Node: Project file variables,  
Prev: Project file overview
 5.2 Project file variables
 ==========================
 
-To set a project variable that is a list, specify each element of the
-list on a separate line in the project file.  The value on the last line
-is the last element in the list.
-
-   A variable name that starts with '$' is set as a process environment
-variable, for processes launched from Emacs for the project.
-
-   In variable values, process environment variables can be referenced
-using the normal '$var' syntax.
-
-   Most project variables have defaults that can be changed by setting
+Some project variables have defaults that can be changed by setting
 elisp variables; the table below identifies the elisp variable for each
 project variable.  Elisp variables corresponding to project variables
 that are lists are elisp lists.
 
-   In general, project variables are evaluated when referenced in Emacs
-Ada mode commands.  Relative file paths are expanded relative to the
-directory containing the project file.
-
-   Ada mode defines some project variables; others are defined by the
-compiler.
+   wisi defines some project variables, Ada mode defines some, others
+are defined by the compiler and the cross reference tool.
 
-   Here is the list of variables valid for all compilers.  In the
-default values, the current directory '"."' is the directory containing
-the project file.
+   Here is the list of variables valid defined by wisi and Ada mode.  In
+the default values, the current directory '"."' is the directory
+containing the project file.
 
 'ada_compiler' [default: 'ada-compiler, gnat']
-     Ada compiler for this project.  It must occur in the project file
-     before any compiler-specific project variable.
-
-'auto_case' [default: 'ada-auto-case, t']
-     Non-nil means automatically change case of preceding word while
-     typing.
+     Ada compiler for this project.
 
-'case_identifier' [default: 'ada-case-identifier, mixed-case']
-     Indicates how to adjust the case of an Ada identifier.
+     Setting this in the project file reinitializes all options for the
+     xref tool, so it must occur before any compiler-specific project
+     variable.
 
-'case_keyword' [default: 'ada-case-keyword, lower-case']
-     Indicates how to adjust the case of an Ada keyword.
-
-'case_strict' [default: 'ada-case-strict, t']
-     If non-nil, 'ada-mixed-case' forces 'Mixed_Case' for identifiers.
-     Otherwise, 'ada-mixed-case' allows 'UPPERCASE' for identifiers.
-
-'casing' [default: 'ada-case-exception-file, nil']
+'casing'
      List of files containing casing exceptions.  *Note Automatic
-     casing::.
+     casing: Automatic casing.
+
+'gnat-stub-args'
+     List of strings passed to 'gnat stub' when it is run.
 
-'el_file' [default: ]
-     The value is a file name, which is loaded as an elisp file when the
-     project file is parsed or selected.  This allows setting Ada mode
-     indentation variables, and any arbitrary elisp code used to
-     customize the project.
+'gnat-stub-cargs'
+     List of strings passed to 'gnat stub' after '-cargs'.
 
-'obj_dir' [default: '"."']
+'obj_dir'
      A list of directories to search for object and cross-reference
      files.  Only needed if you are not using GPR files.
 
-'path_sep' [default: 'path-separator']
-     Separator character used in compiler search paths.
-
-'src_dir' [default: '"."']
+'src_dir'
      A list of directories to search for source files.  Added to the
-     source directories from a GPR file.
+     source directories from a gpr file (if any).
 
 'xref_tool' [default: 'ada-xref-tool']
      Cross reference tool for this project.
 
+     Setting this in the project file reinitializes all options for the
+     xref tool, so it must occur in the project file before any other
+     settings that affect the xref tool.
+
      If 'gpr_query' is found in 'PATH', 'ada-xref-tool' defaults to
      ''gpr_query'.  Otherwise, it defaults to ''gnat', which uses 'gnat
      find'.
 
-   The following variables are valid with the GNAT compiler:
+   The following project file variables are defined by the GNAT
+compiler:
 
-'ada_project_path' [default: '""']
-     A list of directories to search for GNAT project files.
+'ada_project_path' [default: ]
+     Same as 'gpr_project_path'; see below.
 
-     If set, the 'GPR_PROJECT_PATH' process environment variable is set
-     to this value in the child process that runs GNAT tools.  If not
-     set, 'GPR_PROJECT_PATH' in the child process is inherited from the
-     Emacs process.
-
-     If you have the 'GPR_PROJECT_PATH' or 'ADA_PROJECT_PATH'
-     environment variable set in the Emacs process correctly for all of
-     your projects, you do not need to set this project variable.
-
-     The project search path can also be set in GNAT aggregate projects.
-     However, the gnat tools do not make that path available to Emacs,
-     so you must duplicate it in an Emacs Ada project file.
-
-'gpr_file' [default: '""']
-     The GNAT project file.
+'gpr_file' [default: ]
+     The GNAT project file for the project.
 
      If set, the source and project directories specified in the GNAT
-     project file are appended to 'src_dir' and 'ada_project_path'.
+     project file are appended to 'src_dir' and 'gpr_project_path'.
      This allows specifying Ada source directories with a GNAT project
      file, and other source directories with the Emacs project file.
 
-'gpr_project_path' [default: '""']
-     Same as 'ada_project_path'.
+'gpr_project_path' [default: ]
+     A list of directories to search for GNAT project files.  The list
+     is passed to tools via the 'GPR_PROJECT_PATH' process environment
+     variable in the process used to run the 'gnat' and 'gpr_query'
+     tools.
 
-'runtime' [default: 'nil']
+     If not set, 'GPR_PROJECT_PATH' in the child process is inherited
+     from the Emacs process.
+
+'runtime' [default: ]
      If set, the name of the runtime, used as the value of the 'RTS'
-     command line option.
+     command line option for tools.
 
 'target' [default: 'nil']
      If set, the name of the cross-compilation target, prepended to the
@@ -1347,6 +1424,9 @@ compiler, but others can be added (*note Other 
cross-reference::).
      Move from any use of an identifier to its declaration, for from a
      declaration to its body (if there is one).
 
+     This runs 'xref-find-definitions', which has a default global
+     binding of <M-.>
+
 'C-c M-d'
      Move from a child type declaration to the parent type declaration;
      display a list of references if there is more than one parent.
@@ -1356,11 +1436,17 @@ compiler, but others can be added (*note Other 
cross-reference::).
 
      For example, if point is on 'if', move to 'then'.
 
+     This runs 'forward-sexp', which has a default global binding of
+     'C-M-f'.
+
 'C-c C-p'
      Move to the previous keyword in the current statement.
 
      For example, if point is on 'then', move to 'if'.
 
+     This runs 'backward-sexp', which has a default global binding of
+     'C-M-b'.
+
 'C-c C-o'
      Switch between corresponding spec and body.  There are several
      special cases:
@@ -1402,7 +1488,8 @@ compiler, but others can be added (*note Other 
cross-reference::).
 
 'Ada | Misc | Refresh cross reference cache'
      Cross reference information is loaded from the compiler output when
-     the first cross reference command is issued.  If the code is
+     the first cross reference command is issued (or when the project
+     file is parsed, if useing cached project files).  If the code is
      recompiled after that, the cross reference information is reloaded
      by invoking this menu command.
 
@@ -1417,6 +1504,8 @@ Emacs provides a general way of completing identifiers: 
'M-/' (bound to
 type the first few letters of an identifier, and then loop through all
 the possible completions.
 
+   If you have bound 'hippie-expand', that also uses 'dabbrev-expand'.
+
    'M-/' works by parsing all open Ada files for possible completions.
 
    For instance, if the words 'my_identifier' and 'my_subprogram' are
@@ -1507,8 +1596,8 @@ can also configure the indentation, via the following 
variables:
      Indentation for the lines in a 'with' context clause.
 
    The indentation variables are buffer local; the global value may be
-overridden in an elisp file invoked by an 'el_file' Emacs Ada mode
-project file statement, or in a file local variable section.
+overridden in an elisp function on 'ada-mode-hook', or in a file local
+variable section.
 
    The following keys indent portions of the text:
 
@@ -1521,43 +1610,15 @@ project file statement, or in a file local variable 
section.
 'C-c TAB'
      Indent the current statement or 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
-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
-text has been entered to make the code acceptable to the parser, the
-statement or declaration is properly indented.
+'C-c S-TAB'
+     Indent the statement or declaration containing the current
+     statement or declaration.
 
-   For example, if you are entering this code:
-
-     if A then
-        B;
-     end if;
-
-   when you type 'RET B', 'B' is indented to the same column as 'if',
-because the parser does not find 'end if;'.  Then when you type the
-final ';' followed by <TAB>, all three lines are indented, putting 'B'
-where it belongs.
-
-   To be more user friendly, the parser accepts a superset of the Ada
-grammer.  For example, the parser accepts this code for an 'if'
-statement:
-
-     if then
-     end if;
-
-   In general, any sequence of statements, and many expressions, may be
-omitted.
-
-   One way to easily insert empty statements like this is using *note
-Statement skeletons::.
+   The indentation algorithm relies on a grammar parser to identify the
+syntactic role for keywords and other words in the code.
 
    In rare cases, the parser gets confused; it can be reset by invoking
-menu <Ada | Misc | Reset parser>.  Please report such cases as a bug.
+menu <Ada | Misc | Restart parser>.  Please report such cases as a bug.
 
 
 File: ada-mode.info,  Node: Statement skeletons,  Next: Aligning code,  Prev: 
Indentation,  Up: Top
@@ -1565,7 +1626,7 @@ File: ada-mode.info,  Node: Statement skeletons,  Next: 
Aligning code,  Prev: In
 9 Statement skeletons
 *********************
 
-'C-c C-e' expands the previous one or two words into a statment
+'C-c C-e' expands the previous one or two words into a statement
 skeleton.  For example, 'i f C-c C-e' expands to:
 
      if  then
@@ -1573,9 +1634,6 @@ skeleton.  For example, 'i f C-c C-e' expands to:
      else
      end if;
 
-   All skeleton expansions are accepted by the indentation parser, so
-this is a convenient way to insert statements with correct indentation.
-
    For named statements (packages, loops, etc), the name is taken from
 the word before point, and the name of the statement from the word
 before that.
@@ -1679,35 +1737,21 @@ automatically cased.
      exception.
 
    You can define exceptions to these rules, in files specified by the
-variable 'ada-case-exception-file'.  Each line in a case exception file
-specifies the casing of one word or word fragment.  If an exception is
-defined in multiple files, the first occurrence is used.
+'casing' project variable; *note Casing exception files: (wisi)Casing
+exception files.
 
-   If the word starts with an asterisk ('*'), it defines the casing of a
-word fragment (or "substring"); part of a word between two underscores
-or word boundary.
-
-   For example:
-
-     DOD
-     *IO
-     GNAT
-
-   The word fragment '*IO' applies to any word containing "_io";
-'Text_IO', 'Hardware_IO', etc.
-
-   There are two ways to add new items to this file: you can simply edit
-it as you would edit any text file.  Or you can position point on the
-word you want to add, and select menu 'Ada | Casing | Create full
-exception' or 'Ada | Casing | Create partial exception'.  The word will
-be added to the current list of exceptions and to the file.
+   There are two ways to add new items to a casing exception file: you
+can simply edit it as you would edit any text file, or you can position
+point on the word you want to add, and select menu 'Ada | Casing |
+Create full exception' or 'Ada | Casing | Create partial exception'.
+The word will be added to the current list of exceptions and to the
+file.
 
    It is sometimes useful to have multiple exception files.  For
 example, one could be the standard Ada acronyms, the second some company
 specific exceptions, and the last one some project specific exceptions.
-If you set up the variable 'ada-case-exception-file' as a list of files,
-each of them will be parsed and used in your emacs session.  When you
-create a new exception, you are prompted for the file to save it in.
+When you create a new exception, you are prompted for the file to save
+it in.
 
    Other keys and menu entries are defined:
 
@@ -1773,6 +1817,10 @@ displays keys bound to menu operations.
 'C-c TAB'
      *Note Indentation::.  Indent the current statement or declaration.
 
+'C-c S-TAB'
+     *Note Indentation::.  Indent the containing statement or
+     declaration.
+
 'C-c `'
      *Note Compiler errors::.  Move to the location of the secondary
      reference in the current compilation error.
@@ -1848,13 +1896,12 @@ here's an overview.
 * Menu:
 
 * Directory structure::
-* Package organization::
 * ELPA::
 * Savannah::
 * ada-france::
 
 
-File: ada-mode.info,  Node: Directory structure,  Next: Package organization,  
Prev: Developer overview,  Up: Developer overview
+File: ada-mode.info,  Node: Directory structure,  Next: ELPA,  Up: Developer 
overview
 
 14.1 Directory structure
 ========================
@@ -1942,122 +1989,9 @@ File: ada-mode.info,  Node: Directory structure,  Next: 
Package organization,  P
      More tests; allows testing path search features.
 
 
-File: ada-mode.info,  Node: Package organization,  Next: ELPA,  Prev: 
Directory structure,  Up: Developer overview
-
-14.2 Package organization
-=========================
-
-* Menu:
-
-* Ada mode::
-* gpr mode::
-* GNAT core::
-* Wisi::
+File: ada-mode.info,  Node: ELPA,  Next: Savannah,  Prev: Directory structure, 
 Up: Developer overview
 
-
-File: ada-mode.info,  Node: Ada mode,  Next: gpr mode,  Prev: Package 
organization,  Up: Package organization
-
-14.2.1 Ada mode
----------------
-
-Ada mode consists of all files with 'ada-' prefix in the file name.
-
-'ada-mode.el'
-     The main file, implementing the keymap, menu, and top level
-     functionality.
-
-     It allows for different backend implementations for compiling,
-     cross-referencing, and indenting.  The functions for each of these
-     backends dispatch thru global variables that are set by Emacs Ada
-     mode project files.  They default to the GNAT compiler, the
-     gnatxref cross reference tool, and the ada-wisi indentation engine.
-
-'ada-build.el'
-     Provides functions for compiling Ada files without a Makefile (or
-     similar tool).
-
-'ada-fix-error.el'
-     Provides an interface to utilities for automatically fixing errors
-     reported by the compiler.  It dispatches to a compiler-specific
-     backend.
-
-'ada-gnat-compile.el'
-     Implements the Ada mode compiler functions for the GNAT compiler.
-
-'ada-gnat-xref.el'
-     Implements the Ada mode cross reference functions for the GNAT
-     compiler.
-
-'ada.wy'
-     The Ada language grammar.
-
-'ada-indent-user-options.el'
-     All user-settable options for the Ada indentation engine.
-
-'ada-mode-compat.el'
-     Defines functions used by Ada mode that are not in older versions
-     of Emacs.
-
-'ada-mode.texi'
-     This Ada mode user guide source.
-
-'ada-skel.el'
-     Skeletons for expansion of Ada syntax (*note Statement
-     skeletons::).  Extends the Emacs skeleton functions with "tokens",
-     inspired by the lamented Else package (which was inspired by DEC
-     LSE).
-
-'ada-wisi.el'
-     Implements the Ada mode indentation functions for the wisi
-     indentation engine backend.
-
-
-File: ada-mode.info,  Node: gpr mode,  Next: GNAT core,  Prev: Ada mode,  Up: 
Package organization
-
-14.2.2 gpr mode
----------------
-
-gpr mode consists of all files with 'gpr-' prefix in the file name.  The
-functions in each file are similar to the similarly-named Ada mode
-files.
-
-
-File: ada-mode.info,  Node: GNAT core,  Next: Wisi,  Prev: gpr mode,  Up: 
Package organization
-
-14.2.3 GNAT core
-----------------
-
-'gnat-core.el'
-     GNAT is actually a multi-language tool; it builds on top of the
-     multi-language gcc.
-
-     'gnat-core.el' is a start at a language-agnostic interface to the
-     GNAT tools.  It was first factored out from 'ada-gnat.el' and
-     'ada-mode.el' to support the multi-language 'gpr_query.el'.
-
-     More code currently in 'ada-mode.el' could be migrated to
-     'gnat-core.el', in particular the project file support.
-
-'gpr-query.el'
-     Provides an interface to the external multi-language
-     cross-reference tool 'gpr_query'.
-
-     Implements the Ada mode cross-reference functions for the
-     'gpr_query' backend, and a minor mode providing similar functions
-     for C++.
-
-
-File: ada-mode.info,  Node: Wisi,  Prev: GNAT core,  Up: Package organization
-
-14.2.4 Wisi
------------
-
-The "wisi" parser.  *Note Overview: (wisi)Overview.
-
-
-File: ada-mode.info,  Node: ELPA,  Next: Savannah,  Prev: Package 
organization,  Up: Developer overview
-
-14.3 ELPA
+14.2 ELPA
 =========
 
 Ada mode is published via the Gnu ELPA archive.  To test a new version
@@ -2078,7 +2012,7 @@ elpa workspace, and for building the elpa archive there.
 
 File: ada-mode.info,  Node: Savannah,  Next: ada-france,  Prev: ELPA,  Up: 
Developer overview
 
-14.4 Savannah
+14.3 Savannah
 =============
 
 The ada-mode web page, mailing list, and tarball download are hosted on
@@ -2089,14 +2023,14 @@ admin page there for more information.
 
 File: ada-mode.info,  Node: ada-france,  Prev: Savannah,  Up: Developer 
overview
 
-14.5 ada-france
+14.4 ada-france
 ===============
 
 The source code for ada-mode is maintained in a monotone repository in
 the ada-france server <mtn://www.ada-france.org>.
 
 
-File: ada-mode.info,  Node: GNU Free Documentation License,  Next: Index,  
Prev: Developer overview,  Up: Top
+File: ada-mode.info,  Node: GNU Free Documentation License,  Prev: Developer 
overview,  Up: Top
 
 Appendix A GNU Free Documentation License
 *****************************************
@@ -2577,86 +2511,49 @@ 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: ada-mode.info,  Node: Index,  Prev: GNU Free Documentation License,  Up: 
Top
-
-Index
-*****
-
-[index]
-* Menu:
-
-* ada-case-adjust-at-point:              Automatic casing.     (line 64)
-* ada-case-create-exception:             Automatic casing.     (line 48)
-* ada-find-other-file:                   Moving Through Ada Code.
-                                                               (line 32)
-* ada-goto-declaration:                  Moving Through Ada Code.
-                                                               (line 14)
-* ada-goto-declaration-parent:           Moving Through Ada Code.
-                                                               (line 18)
-* ada-next-statement-keyword:            Moving Through Ada Code.
-                                                               (line 22)
-* ada-prev-statement-keyword:            Moving Through Ada Code.
-                                                               (line 27)
-* ada-show-overridden:                   Moving Through Ada Code.
-                                                               (line 65)
-* ada-show-overriding:                   Moving Through Ada Code.
-                                                               (line 60)
-* ada-show-references:                   Moving Through Ada Code.
-                                                               (line 55)
-* comment-dwim:                          Comment Handling.     (line 10)
-* fill-paragraph:                        Comment Handling.     (line 18)
-
 
 
 Tag Table:
 Node: Top931
-Node: Overview2824
-Node: Why not LSP?4061
-Node: Installation4403
-Node: Ada Reference Manual5460
-Node: gpr_query5736
-Node: Building GNATCOLL 20197377
-Node: Building gpr_query7950
-Node: process parser8357
-Node: Customization8689
-Node: Slow response9189
-Node: Non-standard file names11077
-Node: Other compiler12918
-Node: Other cross-reference13497
-Node: Other customization14239
-Node: Compiling Executing17459
-Node: Compile commands18194
-Node: Compiling Examples20845
-Node: No project files21677
-Node: Set compiler options27043
-Node: Set source search path29005
-Node: Use GNAT project file31458
-Node: Use multiple GNAT project files34232
-Node: Use a Makefile36952
-Node: Compiler errors38267
-Node: Project files39084
-Node: Project file overview40111
-Node: Project file variables41655
-Node: Moving Through Ada Code46530
-Node: Identifier completion49229
-Node: Indentation50191
-Node: Statement skeletons54761
-Node: Aligning code56546
-Node: Automatic casing57491
-Node: Comment Handling60219
-Node: Key summary60738
-Node: Developer overview63375
-Node: Directory structure63729
-Node: Package organization66459
-Node: Ada mode66689
-Node: gpr mode68470
-Node: GNAT core68753
-Node: Wisi69587
-Node: ELPA69746
-Node: Savannah70384
-Node: ada-france70736
-Node: GNU Free Documentation License70975
-Node: Index96136
+Node: Overview2716
+Node: Why not LSP?3953
+Node: Installation4709
+Node: Ada Reference Manual5675
+Node: Ada executables5936
+Node: Building GNATCOLL 20198294
+Node: Building the executables8879
+Node: Customization9702
+Node: Slow response10202
+Node: Non-standard file names11928
+Node: Other compiler13807
+Node: Other cross-reference14382
+Node: Other customization15105
+Node: Compiling Executing19096
+Node: Compile commands19819
+Node: Compiling Examples22511
+Node: No project files23343
+Node: Set compiler options28659
+Node: Set source search path30712
+Node: Use wisi project file32949
+Node: Use multiple GNAT project files36556
+Node: Use a Makefile41400
+Node: Compiler errors43051
+Node: Project files43868
+Node: Project file overview44920
+Node: Project file variables45462
+Node: Moving Through Ada Code48902
+Node: Identifier completion51934
+Node: Indentation52968
+Node: Statement skeletons56497
+Node: Aligning code58140
+Node: Automatic casing59085
+Node: Comment Handling61272
+Node: Key summary61791
+Node: Developer overview64521
+Node: Directory structure64850
+Node: ELPA67537
+Node: Savannah68174
+Node: ada-france68526
+Node: GNU Free Documentation License68765
 
 End Tag Table
diff --git a/packages/ada-mode/ada-mode.texi b/packages/ada-mode/ada-mode.texi
index 718abbd..042236b 100644
--- a/packages/ada-mode/ada-mode.texi
+++ b/packages/ada-mode/ada-mode.texi
@@ -2,7 +2,7 @@
 @settitle Ada Mode
 
 @copying
-Copyright @copyright{} 1999 - 2019  Free Software Foundation, Inc.
+Copyright @copyright{} 1999 - 2020  Free Software Foundation, Inc.
 
 @quotation
 Permission is granted to copy, distribute and/or modify this document
@@ -25,7 +25,7 @@ developing GNU and promoting software freedom.''
 
 @titlepage
 @sp 10
-@title Ada Mode Version 6.2.1
+@title Ada Mode Version 7.0.1
 @page
 @vskip 0pt plus 1filll
 @insertcopying
@@ -37,7 +37,7 @@ developing GNU and promoting software freedom.''
 @node Top, Overview, (dir), (dir)
 @top Top
 
-Ada Mode Version 6.2.1
+Ada Mode Version 7.0.1
 @end ifnottex
 
 @menu
@@ -56,7 +56,6 @@ Ada Mode Version 6.2.1
 * Key summary::
 * Developer overview::
 * GNU Free Documentation License::
-* Index::
 
 @detailmenu
  --- The Detailed Node Listing ---
@@ -68,13 +67,12 @@ Overview
 Installation
 
 * Ada Reference Manual::
-* gpr_query::
-* process parser::
+* Ada executables::
 
-gpr_query
+Ada executables
 
 * Building GNATCOLL 2019::
-* Building @file{gpr_query}::
+* Building the executables::
 
 Customizing Ada mode
 
@@ -95,7 +93,7 @@ Compiling Examples
 * No project files::            Just menus
 * Set compiler options::        A basic Ada mode project file
 * Set source search path::      Source in multiple directories
-* Use GNAT project file::
+* Use wisi project file::
 * Use multiple GNAT project files::
 * Use a Makefile::
 
@@ -107,18 +105,10 @@ Project files
 Developer overview
 
 * Directory structure::
-* Package organization::
 * ELPA::
 * Savannah::
 * ada-france::
 
-Package organization
-
-* Ada mode::
-* gpr mode::
-* GNAT core::
-* Wisi::
-
 @end detailmenu
 @end menu
 
@@ -162,19 +152,30 @@ information on debugging.
 @section Why not LSP?
 The Language Server Protocol (LSP, @url{https://langserver.org})
 supports an external language parser, as Ada mode does, and it is
-supported by the GNU ELPA package eglot. We do not use LSP, because it
-does not support indentation and fontification.
+supported by the GNU ELPA package eglot. Ada mode does not use LSP mostly for
+historical reasons; the Ada mode parser was first developed before LSP
+was started. In addition, LSP does not support some of the navigation
+information provided by the Ada mode parser (although that could be
+provided as a custom command).
+
+We may investigate supporting an LSP parser in the future. In
+particular, the AdaCore Gnat Studio editor uses an LSP parser for
+several functions; Emacs Ada mode could use that as a backend if it
+supports LSP.
 
 @node Installation, Customization, Overview, Top
 @chapter Installation
 
 Ada mode requires Emacs 25.0 or greater. Compiling the Ada code for
 the external process parser requires GNAT GPL 2017 or later; tested
-with GNAT Community Edition 2018 and GNAT Pro 19.
+with GNAT Community Edition 2019 and GNAT Pro 19.
 
 Ada mode is distributed in the Gnu ELPA package archive; it can be
 installed via @code{M-x list-packages} (@pxref{Packages,,,emacs,Emacs
-User Guide}). In Emacs < 27 you must first enable packages in your
+User Guide}). Note that it requires the @code{wisi} and
+@code{uniquify-files} packages as dependencies.
+
+In Emacs < 27 you must first enable packages in your
 @file{~/.emacs}, @emph{after} customizing
 @code{Info-default-directory-list} (if you do that):
 
@@ -182,31 +183,26 @@ User Guide}). In Emacs < 27 you must first enable 
packages in your
 (package-initialize)
 @end example
 
-Ada mode is also available as a separate distribution, from the Emacs
-Ada mode website
-@uref{http://stephe-leake.org/emacs/ada-mode/emacs-ada-mode.html}.
-
-For installing the separate distribution, see the @file{README} file
-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:
+You must also install the associated Ada executables (for the language
+parser). You may want to install the Ada Reference Manual.
 
 @menu
 * Ada Reference Manual::
-* gpr_query::
-* process parser::
+* Ada executables::
 @end menu
 
-@node Ada Reference Manual, gpr_query, Installation, Installation
+@node Ada Reference Manual
 @section Ada Reference Manual
 The ELPA package ada-ref-man includes the Ada Reference Manual and
 Annotated Ada Reference Manual in info format.
 
-@node gpr_query, , Ada Reference Manual, Installation
-@section gpr_query
+@node Ada executables
+@section Ada executables
+
+Ada mode requires the external parser, which must be compiled.
 
 Ada mode has support for an external cross reference tool
 @file{gpr_query}, which uses compiler-generated information. In the
@@ -219,14 +215,31 @@ not available in FSF GCC.
 @file{gpr_query} is an Ada program, which is distributed as source and
 must be built. Its source code is in the @code{ada-mode} Gnu ELPA package.
 
-@file{gpr_query} requires the @code{GNATCOLL} library provided by
-AdaCore, distributed with GNAT GPL 2017 or later, and also available
-at Github (@url{https://github.com/AdaCore/gnatcoll}). The notes below
-assume that the compiler is installed at @file{$prefix},
+@file{gpr_query} is similar to the AdaCore utility @code{gnatxref},
+but supports additional queries.
+
+Both the parser and @file{gpr_query} require the @code{GNATCOLL}
+library provided by AdaCore, distributed with GNAT GPL 2017 or later,
+and also available at Github
+(@url{https://github.com/AdaCore/gnatcoll}). The notes below assume
+that the compiler is installed at @file{$prefix},
 e.g. @file{/usr/local/gnat-2019}, and that @file{$prefix/bin} is first
 on the @code{PATH}. If you are running Windows, use mingw64
 @code{bash} to run these commands.
 
+On linux, some versions of the @code{GNATCOLL.iconv} package (used by
+@code{gpr_query}, but not the parser) explicity
+require the @file{libiconv.so} library. GNAT provides the
+@file{libiconv.so} library in @file{<gnat>/lib64/libiconv.so}. On
+Debian, that directory is not in the standard load path, and iconv is
+provided by glibc, so @file{libiconv.so} is not found on the standard
+load path. So you must set @var{LD_LIBRARY_PATH}, but only when
+running @code{gpr-query}:
+
+@example
+(setq gpr-query-env '("LD_LIBRARY_PATH=/Projects/gnat/pro_19.2/lib64")
+@end example
+
 In general, @file{gpr_query} should be compiled with the compiler
 version that is used to generate the user project @file{.ali} files;
 the @file{ali} file format can change with each compiler
@@ -240,7 +253,7 @@ does not include the xref package, which is required by
 
 @menu
 * Building GNATCOLL 2019::
-* Building @file{gpr_query}::
+* Building the executables::
 @end menu
 
 @node Building GNATCOLL 2019
@@ -263,28 +276,29 @@ make -C xref
 make -C xref install
 @end example
 
-@node Building @file{gpr_query}
-@subsection Building @file{gpr_query}
+@node Building the executables
+@subsection Building the executables
 
-To build and install @file{gpr_query}, assuming the
+@file{gpr_query} requires the @code{pthread} library. On Windows, this
+is available in Mingw64 as package
+@code{mingw64/mingw-w64-x86_64-winpthreads-git}.
+
+To build and install @file{gpr_query} and the parser, assuming the
 @code{ada-mode-6.0.xx} GNU ELPA package is installed:
 
 @example
 cd ~/.emacs.d/elpa/ada-mode-6.0.xx
 ./build.sh
+./install.sh
 @end example
 
-@code{ada-mode} will use @file{gpr_query} for cross reference
-functions if @file{gpr_query} is found in @code{PATH}.
-
-@node process parser, , ,
-@section process parser
-The process parser is built and installed by the same @code{build.sh}
-script as @xref{gpr_query}. ada-mode will automatically use it if it
-is available.
+By default, @file{install.sh} installs the executables in the same
+directory as the GNAT executable (using @file{gprinstall}). If you
+don't have write privileges there, or if you want to install somewhere
+else, use @code{install.sh --prefix=<dir>}.
 
-To override the automatic choice of parser, set @var{ada-parser} to
-either @code{'elisp} or @code{'parser}.
+@code{ada-mode} will use @file{gpr_query} and the parser if they are
+found in @code{PATH}.
 
 @node Customization, Compiling Executing, Installation, Top
 @chapter Customizing Ada mode
@@ -305,15 +319,15 @@ the tutorial (@kbd{C-h t}).
 @node Slow response
 @section Slow response
 
-In large files, parsing is slow, so it gets in the way of interactive
-typing due to immediate fontification triggering a parse.
+In large files, parsing takes a noticable amount of time, so it gets
+in the way of interactive typing due to immediate fontification
+triggering a parse.
 
 There are three ways to deal with this:
 
 @enumerate
-@item Install the process parser (@xref{process parser}), and set
-@code{wisi-partial-parse-threshold} appropriately in your
-@file{~./emacs}:
+@item Set @code{wisi-partial-parse-threshold}
+In your @file{~./emacs}:
 
 @example
 (setq wisi-partial-parse-threshold 100001)
@@ -323,17 +337,15 @@ The default value (100001) may already be appropriate; it 
depends on
 how fast your machine is, and what your tolerance for slow response
 is.
 
-Files larger than @code{wisi-partial-parse-threshold} will be parsed
-partially; only the part of the buffer needed for the current task
-will be parsed. For fontification, that is the visible part. For indent,
-it is approximately the current subprogram or package. For navigation,
-it is always the entire file, which will still be slow; that is the
-only way to ensure useful results.
+Files larger than @code{wisi-partial-parse-threshold} (in characters)
+will be parsed partially; only the part of the buffer needed for the
+current task will be parsed. For fontification, that is the visible
+part. For indent, it is approximately the current subprogram or
+package. For navigation, it is always the entire file, which will
+still be slow; that is the only way to ensure useful results.
 
 With this setting, indentation may not be correct; the Ada menu entry
-``Edit | Indent lines in file'' (or ``Edit | Indent current
-statement'', if point is on a keyword of a large enough enclosing
-statement) will parse the entire file and indent correctly.
+``Edit | Indent containing statement'' will indent correctly.
 
 @item Delay fontification by setting @code{jit-lock-defer-time} in your
 @file{~./emacs}:
@@ -371,7 +383,8 @@ corresponding spec and back.
 
 Emacs and Ada mode support ways to use alternative file extensions for
 specs and bodies. Note that you must also tell the compiler about
-these extensions; doing that is beyond the scope of this manual.
+these extensions in a GNAT project file Naming package; doing that is
+beyond the scope of this manual.
 
 For instance, if your spec and bodies files are called
 @file{@var{unit}_s.ada} and @file{@var{unit}_b.ada}, respectively, you
@@ -408,20 +421,20 @@ the scope of this manual; see the current definitions in
 
 @node Other compiler, Other cross-reference, Non-standard file names, 
Customization
 @section Other compiler
-The project variable @code{ada_compiler} (default elisp variable
-@code{ada-compiler}) is used to index several variables that point to
-the compiler-specific functions for corresponding Ada mode operations.
+The wisi project variable @code{ada_compoiler} (default elisp variable
+@code{ada-compiler}) (default @code{'gnat}) controls dispatching in
+compiler-specific functions for corresponding Ada mode operations.
 
 To use a compiler other than GNAT, you must write Emacs lisp code that
 provides the interface to the compiler, and set @code{ada-compiler} and
 the indirection variables.
 
-See @file{ada-gnat-compile.el} for an example.
+See @file{ada-compiler-gnat.el} for an example.
 
 @node Other cross-reference, Other customization, Other compiler, Customization
 @section Other cross-reference
-The project variable @code{ada_xref} (default elisp variable
-@code{ada-xref-tool}) is used to index several variables that point to
+The wisi project variable @code{xref_tool} (default elisp variable
+@code{ada-xref-tool}) controls dispatching in
 the cross-reference-tool-specific functions for corresponding Ada mode
 operations.
 
@@ -438,9 +451,9 @@ See @file{ada-gnat-xref.el} and @file{gpr-query.el} for 
examples.
 @node Other customization,  , Other cross-reference, Customization
 @section Other customization
 
-All user-settable Ada mode variables can be set via the menu
-@samp{Ada | Customize}.  Click on the @samp{Help} button there for help
-on using customize.
+All user-settable Ada mode variables can be set via the menu @samp{Ada
+| Customize}; some can also be set in wisi project files
+(@pxref{Project files}).
 
 To modify a specific variable, you can directly call the function
 @code{customize-variable}; just type @kbd{M-x customize-variable
@@ -449,11 +462,13 @@ To modify a specific variable, you can directly call the 
function
 Alternately, you can specify variable settings in the Emacs
 configuration file, @file{~/.emacs}. This file is coded in Emacs lisp,
 and the syntax to set a variable is the following:
+
 @example
 (setq variable-name value)
 @end example
 
 Some general Emacs settings that are useful for Ada files:
+
 @table @code
 @item context menu
 By default, the context menu is bound to @key{C-down-mouse-3},
@@ -466,6 +481,19 @@ Ada mode does not provide any @code{other-frame} or
 recommended to use the Gnu ELPA package @code{other-frame-window}.
 @item delete-trailing-whitespace
 Deletes space, tab at end of line and blank lines at end of buffer.
+@item xref configuration
+@table @code
+@item xref-prompt-for-identifier
+Set to @code{nil} to be prompted less when finding definitions or
+references.
+@item xref-show-xrefs-function
+Determine placement of the window where references are shown.
+@item xref-show-definitions-function
+Determine placement of the window where definitions are shown.
+@item xref--transient-buffer-mode-map
+keymap used in some xref windows; you may want to disable the
+@key{RET} binding there.
+@end table
 @item untabify
 Deletes tab characters that have crept into the file.
 @item indent-tabs-mode
@@ -476,12 +504,12 @@ year.
 @item electric-pair-mode
 Insert a matching right paren when you type a left paren.
 @item hippie-expand
-Bind @code{hippie-expand} to a key; it expands the word before point, using
-words from current buffer, other buffers, file names, etc; see
+Bind @code{hippie-expand} to a key; it expands the word before point,
+using words from current buffer, other buffers, file names, etc; see
 @code{hippie-expand-try-functions-list}. You can also add
-@code{ada-skel-hippie-try} to that list. Note that @code{ada-expand},
-which defaults to @code{ada-skel-expand}, is bound to @key{C-c C-e}
-(@pxref{Statement skeletons}).
+@code{wisi-skel-hippie-try} to that list. Note that
+@code{wisi-skel-expand} is bound to @key{C-c C-e} (@pxref{Statement
+skeletons}).
 @item imenu
 Navigate to subprograms and types by name, from a minibuffer menu.
 @item speedbar
@@ -499,10 +527,15 @@ first.
 
 @example
 (setq-default indent-tabs-mode nil)
+(define-key xref--transient-buffer-mode-map (kbd "RET") 'xref-goto-xref)
+(setq xref-prompt-for-identifier nil) ;; only prompt on C-u
+(setq xref-show-xrefs-function #'xref--show-defs-buffer-at-bottom)
+(setq xref-show-definitions-function #'xref--show-defs-buffer-at-bottom)
+
 (electric-pair-mode 1)
 (require 'imenu) ;; also enables speedbar
 (require 'ada-mode)
-(add-to-list 'hippie-expand-try-functions-list 'ada-skel-hippie-try)
+(add-to-list 'hippie-expand-try-functions-list 'wisi-skel-hippie-try)
 (define-key ada-mode-map "\C-e"     'hippie-expand)
 (define-key ada-mode-map [down-mouse-3] 'ada-popup-menu)
 (add-hook 'ada-mode-hook
@@ -524,8 +557,8 @@ the GNAT compiler for simple projects (single files, or 
several files
 in a single directory).
 
 For complex projects, you will want to use @code{make} or some other
-build tool; in that case, you will need an Emacs Ada mode project file
-to tell Emacs about the project directory tree and other settings.
+build tool; in that case, you may need a wisi project file to tell
+Emacs about the project directory tree and other settings.
 
 @menu
 * Compile commands::
@@ -537,7 +570,7 @@ to tell Emacs about the project directory tree and other 
settings.
 @section Compile commands
 
 Here are the commands for building an Ada project and running the main
-program.
+program; they are all on the @code{Ada | Build} menu.
 
 In multi-file projects, there must be one file that is the main
 program. That is given by the @code{main} project file variable;
@@ -565,7 +598,7 @@ Sets @code{main} to the current file, then executes the 
Build
 command.
 
 @item Show main
-Display @code{main} in the message buffer.
+Displays @code{main} in the message buffer.
 
 @item Build
 Compiles all obsolete units of the current @code{main}, and links
@@ -587,7 +620,7 @@ This command is not available for a cross-compilation 
toolchain.
 It is important when using these commands to understand how
 @code{main} is used and changed.
 
-Build runs 'gnatmake' on the main unit. During a typical edit/compile
+Build runs 'gprbuild' on the main unit. During a typical edit/compile
 session, this is the only command you need to invoke, which is why it
 is bound to @kbd{C-c C-c}. It will compile all files needed by the
 main unit, and display compilation errors in any of them.
@@ -630,7 +663,7 @@ website mentioned in @xref{Installation}.
 * No project files::            Just menus
 * Set compiler options::        A basic Ada mode project file
 * Set source search path::      Source in multiple directories
-* Use GNAT project file::
+* Use wisi project file::
 * Use multiple GNAT project files::
 * Use a Makefile::
 @end menu
@@ -644,14 +677,14 @@ First, create a directory @file{Example_1}, containing:
 @file{hello.adb}:
 
 @example
-with Ada.Text_IO;
+with Ada.Text_Io;
 procedure Hello
 is begin
    Put_Line("Hello from hello.adb");
 end Hello;
 @end example
 
-Yes, this is missing ``use Ada.Text_IO;'' - we want to demonstrate
+Yes, this is missing ``use Ada.Text_Io;'' - we want to demonstrate
 compiler error handling.
 
 @file{hello_2.adb} has no errors:
@@ -675,19 +708,18 @@ end Hello_Pkg;
 @file{hello_pkg.adb}:
 
 @example
-with Ada.Text_IO;
+with Ada.Text_Io;
 package Hello_Pkg is
    procedure Say_Hello
    is begin
-      Ada.Text_IO.Put_Line ("Hello from hello_pkg.adb");
+      Ada.Text_Io.Put_Line ("Hello from hello_pkg.adb");
    end Say_Hello;
 end Hello_Pkg;
 @end example
 
 Yes, this is missing the keyword @code{body}; another compiler error
 example. However, note that the indentation engine parser accepts this
-code with no errors, making it easier to indent slightly illegal Ada
-code.
+code, making it possible to indent illegal Ada code.
 
 In buffer @file{hello.adb}, invoke the menu entry @samp{Ada | Build |
 Check syntax}. You should get a @code{*compilation*} buffer containing
@@ -697,12 +729,14 @@ something like (the directory paths will be different):
 -*- mode: compilation; default-directory: 
"c:/Projects/org.emacs.ada-mode.stephe-1/test/Example_1/" -*-
 Compilation started at Fri Oct 18 04:23:54
 
-gnatmake -u -c -gnatc  
c:/Projects/org.emacs.ada-mode.stephe-1/test/Example_1/hello.adb -cargs
-gcc -c -Ic:/Projects/org.emacs.ada-mode.stephe-1/test/Example_1/ -gnatc -I- 
c:/Projects/org.emacs.ada-mode.stephe-1/test/Example_1/hello.adb
+gprbuild  -u -c -gnatc  c:/Projects/org.emacs.ada-mode/test/Example_1/hello.adb
+using project file D:\Apps\GNAT-gpl_2019\share\gpr\_default.gpr
+Compile
+   [Ada]          hello.adb
 hello.adb:4:04: "Put_Line" is not visible
 hello.adb:4:04: non-visible declaration at a-textio.ads:263
 hello.adb:4:04: non-visible declaration at a-textio.ads:259
-gnatmake: "c:/Projects/org.emacs.ada-mode.stephe-1/test/Example_1/hello.adb" 
compilation error
+gprbuild: *** compilation phase failed
 
 Compilation exited abnormally with code 4 at Fri Oct 18 04:23:54
 @end example
@@ -712,9 +746,9 @@ highlighted, with the file name in red.
 
 Now invoke @samp{Ada | Build | Next compilation error}.  Or you can
 click the middle mouse button on the first error line, or use the key
-binding shown on the menu.  The compilation buffer scrolls to put the
-first error on the top line, and point is put at the place of the
-error in the @file{hello.adb} buffer.
+binding shown on the menu.  In the compilation buffer, a triangle is
+placed in the left fringe on the first error line, and point is put at
+the place of the error in the @file{hello.adb} buffer.
 
 To fix the error, invoke @samp{Ada | Build | Fix compilation error};
 this adds ``Ada.Text_Io.'' to the line:
@@ -733,10 +767,15 @@ compilation buffer is displayed again, containing:
 -*- mode: compilation; default-directory: 
"c:/Projects/org.emacs.ada-mode.stephe-1/test/Example_1/" -*-
 Compilation started at Fri Oct 18 20:39:33
 
-gnatmake -o hello hello  -cargs  -bargs  -largs
-gcc -c hello.adb
-gnatbind -x hello.ali
-gnatlink hello.ali -o hello.exe
+gprbuild  hello
+using project file D:\Apps\GNAT-gpl_2019\share\gpr\_default.gpr
+Compile
+   [Ada]          hello.adb
+Bind
+   [gprbind]      hello.bexch
+   [Ada]          hello.ali
+Link
+   [link]         hello.adb
 
 Compilation finished at Fri Oct 18 20:39:34
 @end example
@@ -767,11 +806,10 @@ Build}. This finds an error in @file{hello_pkg.adb}:
 hello_pkg.adb:2:08: keyword "body" expected here [see file name]
 @end example
 
-This demonstrates that gnatmake finds the files needed by the main
+This demonstrates that gprbuild finds the files needed by the main
 program. However, it cannot find files in a different directory,
-unless you use an Emacs Ada mode project file or a GNAT project file
-to specify the other directories; @xref{Set source search path},
-@ref{Use GNAT project file}.
+unless you use a GNAT project file to specify the other directories;
+@ref{Set source search path}.
 
 Invoke @samp{Ada | Build | Show main}; this displays @file{Ada mode
 main: hello_2}.
@@ -783,7 +821,7 @@ package body Hello_Pkg is
 @end example
 
 Now, while still in @file{hello_pkg.adb}, invoke @samp{Ada | Build |
-Build}.  gnatmake successfully builds @file{hello_2}. This
+Build}.  gprbuild successfully builds @file{hello_2}. This
 demonstrates that Emacs has remembered the main file, in the project
 variable @code{main}, and used it for the Build command.
 
@@ -812,7 +850,7 @@ specifies @code{main}.
 @node Set compiler options, Set source search path, No project files, 
Compiling Examples
 @subsection Set compiler options
 
-This example illustrates using an Emacs Ada mode project file to set a
+This example illustrates using a gnat project file to set a
 compiler option.
 
 If you have files from @file{Example_1} open in Emacs, you should
@@ -824,7 +862,7 @@ In directory @file{Example_2}, create these files:
 @file{hello.adb}:
 
 @example
-with Ada.Text_IO;
+with Ada.Text_Io;
 procedure Hello
 is begin
    Put_Line("Hello from hello.adb");
@@ -832,50 +870,53 @@ end Hello;
 @end example
 
 This is the same as @file{hello.adb} from @file{Example_1}. It has two
-errors; missing ``use Ada.Text_IO;'', and no space between
+errors; missing ``use Ada.Text_Io;'', and no space between
 @code{Put_Line} and its argument list.
 
-@file{hello.adp}:
+@file{hello.gpr}:
 
 @example
-comp_opt=-gnatyt
+project Hello is
+   package Compiler is
+      for Default_Switches ("Ada") use ("-gnatyt");
+   end Compiler;
+end Hello;
 @end example
 
 This tells the GNAT compiler to check for token spacing; in
 particular, there must be a space preceding a parenthesis.
 
 In buffer @file{hello.adb}, invoke @samp{Ada | Build | Set main and
-Build}. This finds the project file @file{hello.adp}, uses it to set
+Build}. This finds the project file @file{hello.gpr}, uses it to set
 the compiler options, and builds the project. You should get a
 @code{*compilation*} buffer containing something like (the directory
 paths will be different):
 
 @example
-cd c:/Examples/Example_2/
-gnatmake -o hello hello -g -cargs -gnatyt  -bargs  -largs
-gcc -c -g -gnatyt hello.adb
+gprbuild -Phello.gpr hello
+Compile
+   [Ada]          hello.adb
 hello.adb:4:04: "Put_Line" is not visible
-hello.adb:4:04: non-visible declaration at a-textio.ads:264
-hello.adb:4:04: non-visible declaration at a-textio.ads:260
+hello.adb:4:04: non-visible declaration at a-textio.ads:508
+hello.adb:4:04: non-visible declaration at a-textio.ads:498
 hello.adb:4:12: (style) space required
-gnatmake: "hello.adb" compilation error
+gprbuild: *** compilation phase failed
 @end example
 
 Compare this to the compiler output in @ref{No project files}; the
-gnatmake option @code{-cargs} has been replaced by @code{-cargs
--gnaty}, and an additional error is reported in @file{hello.adb} on
-line 4. This shows that @file{hello.adp} is being used to set the
-compiler options.
+compiler-provided default gpr file has been replaced by
+@code{hello.gpr}, and an additional error is reported in
+@file{hello.adb} on line 4. This shows that @file{hello.gpr} is being
+used to set the compiler options.
 
-Fixing the error, linking and running the code proceed as in @ref{No
-project files}.
+Use @kbd{C-x`}, @kbd{C-c M-`} to fix the errors, then @samp{Ada |
+Build | Build} and @samp{Ada | Build | Run} to build and run.
 
-@node Set source search path, Use GNAT project file, Set compiler options, 
Compiling Examples
+@node Set source search path
 @subsection Set source search path
 
 In this example, we show how to deal with files in more than one
-directory, using an Emacs Ada mode project file to set the search
-path.
+directory, setting the source search path in the gpr file.
 
 Create the directory @file{Example_3}, containing:
 
@@ -890,11 +931,11 @@ end Hello_Pkg;
 @file{hello_pkg.adb}:
 
 @example
-with Ada.Text_IO;
+with Ada.Text_Io;
 package Hello_Pkg is
    procedure Say_Hello
    is begin
-      Ada.Text_IO.Put_Line ("Hello from hello_pkg.adb");
+      Ada.Text_Io.Put_Line ("Hello from hello_pkg.adb");
    end Say_Hello;
 end Hello_Pkg;
 @end example
@@ -902,13 +943,21 @@ end Hello_Pkg;
 These are the same files from example 1; @file{hello_pkg.adb} has an
 error on line 2.
 
-In addition, create a directory @file{Example_3/Other}, containing these files:
+@file{other.gpr}:
+
+@example
+project Other is
+   for Source_Dirs use (".", "Other");
+end Other;
+@end example
+
+In addition, create a directory @file{Example_3/Other}, containing this file:
 
 @file{Other/hello_3.adb}:
 
 @example
 with Hello_Pkg;
-with Ada.Text_IO; use Ada.Text_IO;
+with Ada.Text_Io; use Ada.Text_Io;
 procedure Hello_3
 is begin
    Hello_Pkg.Say_Hello;
@@ -918,19 +967,11 @@ end Hello_3;
 
 There are no errors in this file.
 
-@file{Other/other.adp}:
-
-@example
-src_dir=..
-@end example
-
-Note that there must be no trailing spaces.
-
 In buffer @file{hello_3.adb}, invoke @samp{Ada | Project files | Find and
-set project...}, and select @file{Example_3/Other/other.adp}. This
+select project...}, and select @file{Example_3/other.gpr}. This
 tells Emacs Ada mode to stop using the project file from
 @file{Example_2}, and use the one for @file{Example_3}. Also note that
-since this project file is not named @file{hello_3.adp}, it would not
+since this project file is not named @file{hello_3.gpr}, it would not
 be found by default.
 
 Then, again in @file{hello_3.adb}, invoke @samp{Ada | Set main and
@@ -938,30 +979,34 @@ Build}. You should get a @code{*compilation*} buffer 
containing
 something like (the directory paths will be different):
 
 @example
-cd c:/Examples/Example_3/Other/
-gnatmake -o hello_3 hello_3 -g -cargs -I.. -bargs  -largs
-gcc -c -g -I.. hello_3.adb
-gcc -c -I./ -g -I.. -I- C:\Examples\Example_3\hello_pkg.adb
+gprbuild -Pother.gpr hello_3
+Compile
+   [Ada]          hello_3.adb
+   [Ada]          hello_pkg.adb
 hello_pkg.adb:2:08: keyword "body" expected here [see file name]
-gnatmake: "C:\Examples\Example_3\hello_pkg.adb" compilation error
+gprbuild: "C:\Examples\Example_3\hello_pkg.adb" compilation error
 @end example
 
-Compare the @code{-cargs} option to the compiler output in @ref{Set
-compiler options}; this shows that @file{other.adp} is being used to
-set the compiler options.
-
 Move to the error with @kbd{C-x `}. Ada mode searches the list of
-directories given by @code{src_dir} for the file mentioned in the
+directories given by @code{Source_Dirs} for the file mentioned in the
 compiler error message.
 
-Fixing the error, linking and running the code proceed as in @ref{No
-project files}.
+Use @kbd{C-x`}, @kbd{C-c M-`} to fix the errors, then @samp{Ada |
+Build | Build} and @samp{Ada | Build | Run} to build and run.
 
-@node Use GNAT project file, Use multiple GNAT project files, Set source 
search path, Compiling Examples
-@subsection Use GNAT project file
+@node Use wisi project file, Use multiple GNAT project files, Set source 
search path, Compiling Examples
+@subsection Use wisi project file
 
-In this example, we show how to use a GNAT project file, with no Ada
-mode project file.
+In this example, we show how to use a wisi project file to set some
+options that cannot be set in a gpr project file. In addition, we
+change a setting so you are prompted for a project file, rather than
+using a default one.
+
+Change the setting:
+
+@example
+M-x set-variable ada-build-prompt-prj search-prompt
+@end example
 
 Create the directory @file{Example_4}, containing:
 
@@ -976,26 +1021,61 @@ end Hello_Pkg;
 @file{hello_pkg.adb}:
 
 @example
-with Ada.Text_IO;
-package Hello_Pkg is
+with Ada.Text_Io;
+package body Hello_Pkg is
    procedure Say_Hello
    is begin
-      Ada.Text_IO.Put_Line ("Hello from hello_pkg.adb");
+      Put_Line ("Hello from hello_pkg.adb");
    end Say_Hello;
 end Hello_Pkg;
 @end example
 
-These are the same files from example 1; @file{hello_pkg.adb} has an
-error on line 2.
+These two files are the similar to files from example 1;
+@file{hello_pkg.adb} has an error on line 5 (missing
+``Ada.Text_IO.'').
+
+@file{example_4.prj}:
+
+@example
+-- Wisi project file
 
-In addition, create a directory @file{Example_4/Gnat_Project},
+gpr_project_path=More
+
+gpr_file=example_4.gpr
+
+casing=example_4.casing
+@end example
+
+@file{example_4.prj} is a wisi project file; it specifies the
+@code{gpr_project_path}, telling @code{gprbuild} where to search for
+gpr files, and specifies the gpr file to use. Finally it specifies a
+casing exception file:
+
+@file{example_4.casing}:
+
+@example
+Text_IO
+@end example
+
+The default auto casing rules in ada-mode state that the Ada package
+``Ada.Text_IO'' should be capitalized as ``Ada.Text_Io'', which does
+not match the Ada Reference Manual.  @file{example_4.casing} specifies
+that instead ``Text_IO'' should be capitalized as shown.
+
+You can create a casing exception by editing the file directly, or via
+the @code{Ada | Casing} menu.
+
+@code{gpr_project_path} and @code{casing} are list variables; each
+occurence in a wisi project file adds an entry to the list.
+
+In addition, create a directory @file{Example_4/More},
 containing these files:
 
-@file{Gnat_Project/hello_4.adb}:
+@file{more/hello_4.adb}:
 
 @example
 with Hello_Pkg;
-with Ada.Text_IO; use Ada.Text_IO;
+with Ada.Text_Io; use Ada.Text_Io;
 procedure Hello_4
 is begin
    Hello_Pkg.Say_Hello;
@@ -1003,50 +1083,60 @@ is begin
 end Hello_4;
 @end example
 
-There are no errors in this file.
+There are no errors in this file, except for the casing in ``Ada.Text_Io''.
 
-@file{Gnat_Project/hello_4.gpr}:
+@file{More/example_4.gpr}:
 
 @example
-project Hello_4 is
+project Example_4 is
    for Source_Dirs use (".", "..");
-end Hello_4;
+
+   package Compiler is
+      for Default_Switches ("Ada") use ("-gnatyknpr");
+   end Compiler;
+end Example_4;
 @end example
 
-In buffer @file{hello_4.adb}, invoke @samp{Ada | Project | Load...}, and
-select @file{Example_4/Gnat_Project/hello_4.gpr}.
+The compiler switch checks all casing; we will get errors for ``Ada.Text_Io''.
 
-Then, again in @file{hello_4.adb}, invoke @samp{Ada | Set main and
-Build}. You should get a @code{*compilation*} buffer containing
+Then, in @file{hello_4.adb}, invoke @samp{Ada | Set main and
+Build}. ada-mode looks for a project file @file{hello_4.prj} or
+@file{hello_4.gpr}; since neither is found, you are prompted to find a
+project file.  Select @file{Example_4/example_4.prj}; that is parsed
+and selected, and the build continues.
+
+You should get a @code{*compilation*} buffer containing
 something like (the directory paths will be different):
 
 @example
--*- mode: compilation; default-directory: 
"c:/Projects/org.emacs.ada-mode.stephe-1/test/Example_4/Gnat_Project/" -*-
-Compilation started at Mon Oct 21 11:28:31
-
-gnatmake 
-Pc:/Projects/org.emacs.ada-mode.stephe-1/test/Example_4/Gnat_Project/hello_4.gpr
 -o hello_4 hello_4  -cargs -I. 
-Ic:/Projects/org.emacs.ada-mode.stephe-1/test/Example_4/Gnat_Project 
-Ic:/Projects/org.emacs.ada-mode.stephe-1/test/Example_4 
-Ic:/Apps/GNAT-7.1.2/lib/gcc/i686-pc-mingw32/4.7.3/adainclude  -bargs  -largs
-gcc -c -I. 
-Ic:/Projects/org.emacs.ada-mode.stephe-1/test/Example_4/Gnat_Project 
-Ic:/Projects/org.emacs.ada-mode.stephe-1/test/Example_4 
-Ic:/Apps/GNAT-7.1.2/lib/gcc/i686-pc-mingw32/4.7.3/adainclude -I- -gnatA 
C:\Projects\org.emacs.ada-mode.stephe-1\test\Example_4\hello_pkg.adb
-hello_pkg.adb:2:08: keyword "body" expected here [see file name]
-gnatmake: 
"C:\Projects\org.emacs.ada-mode.stephe-1\test\Example_4\hello_pkg.adb" 
compilation error
-
-Compilation exited abnormally with code 4 at Mon Oct 21 11:28:31
+gprbuild -Pexample_4.gpr hello_4
+Compile
+   [Ada]          hello_pkg.adb
+hello_pkg.adb:1:16: (style) bad casing of "Text_IO" declared at a-textio.ads:57
+hello_pkg.adb:5:07: "Put_Line" is not visible
+hello_pkg.adb:5:07: non-visible declaration at a-textio.ads:508
+hello_pkg.adb:5:07: non-visible declaration at a-textio.ads:498
+gprbuild: *** compilation phase failed
 @end example
 
-Compare the @code{gcc} options to the compiler output in @ref{Set
-compiler options}; this shows that @file{hello_4.gpr} is being used to
-set the compiler options.
+When you fix the errors, note that @kbd{C-c M-`} inserts the correct
+case for ``Ada.Text_IO'', and corrects the case where it is
+incorrect. The case is also corrected as you type; you can type
+``ada.text_io.'' and the case will be corrected when you type each
+``.'' or ``_''.
 
-Fixing the error, linking and running the code proceed as in @ref{No
-project files}.
-
-@node Use multiple GNAT project files, Use a Makefile, Use GNAT project file, 
Compiling Examples
+@node Use multiple GNAT project files
 @subsection Use multiple GNAT project files
 
 In this example, we show how to use multiple GNAT project files,
-specifying the GNAT project search path in an Ada mode project file.
+specifying the GNAT project search path in an Ada mode project
+file. This also requires explicitly setting
+@code{project-find-functions}.
 
-Create the directory @file{Example_4} as specified in @ref{Use GNAT
-project file}.
+If you haven't already, create the directory @file{Example_4} as
+specified in @ref{Use wisi project file}. If you've already created it
+and run the tutorial, restore the compilation error in hello_pkg.adb;
+delete @code{Ada.Text_IO.} in front of @code{Put_Line}.
 
 Create the directory @file{Example_5}, containing:
 
@@ -1064,58 +1154,116 @@ end Hello_5;
 
 There are no errors in this file.
 
-@file{hello_5.adp}:
+@file{hello_5.prj}:
 
 @example
-ada_project_path=../Example_4/Gnat_Project
+gpr_project_path=../Example_4/More
 gpr_file=hello_5.gpr
+
+casing=../Example_4/example_4.casing
 @end example
 
 @file{hello_5.gpr}:
 
 @example
-with "hello_4";
+with "example_4";
 project Hello_5 is
    for Source_Dirs use (".");
    package Compiler is
-      for Default_Switches ("Ada") use ("-g", "-gnatyt");
+      for Default_Switches ("Ada") use ("-g", "-gnatyknprt");
    end Compiler;
 end Hello_5;
 @end example
 
 In buffer @file{hello_5.adb}, invoke @samp{Ada | Project | Find and
-select project...}, and select @file{Example_5/hello_5.adp}. This
+select project...}, and select @file{Example_5/hello_5.prj}. This
 would also be found by default if no previous project file had been
-selected.
+selected. Note that if @file{example_5.gpr} were named
+@file{hello_5.gpr}, the project file search would find more than one
+match, causing an error.
 
 Then, again in @file{hello_5.adb}, invoke @samp{Ada | Build | Set main
 and Build}. You should get a @code{*compilation*} buffer containing
 something like (the directory paths will be different):
 
 @example
--*- mode: compilation; default-directory: 
"c:/Projects/org.emacs.ada-mode.stephe-1/test/Example_5/" -*-
+-*- mode: compilation; default-directory: 
"c:/Projects/org.emacs.ada-mode/test/Example_5/" -*-
 Compilation started at Mon Oct 21 11:32:05
 
-gnatmake -Pc:/Projects/org.emacs.ada-mode.stephe-1/test/Example_5/hello_5.gpr 
-o hello_5 hello_5  -cargs -I. 
-Ic:/Projects/org.emacs.ada-mode.stephe-1/test/Example_5 
-Ic:/Projects/org.emacs.ada-mode.stephe-1/test/Example_4/Gnat_Project 
-Ic:/Projects/org.emacs.ada-mode.stephe-1/test/Example_4 
-Ic:/Apps/GNAT-7.1.2/lib/gcc/i686-pc-mingw32/4.7.3/adainclude  -bargs  -largs
-gcc -c -I. -Ic:/Projects/org.emacs.ada-mode.stephe-1/test/Example_5 
-Ic:/Projects/org.emacs.ada-mode.stephe-1/test/Example_4/Gnat_Project 
-Ic:/Projects/org.emacs.ada-mode.stephe-1/test/Example_4 
-Ic:/Apps/GNAT-7.1.2/lib/gcc/i686-pc-mingw32/4.7.3/adainclude -I- -gnatA 
C:\Projects\org.emacs.ada-mode.stephe-1\test\Example_4\hello_pkg.adb
-hello_pkg.adb:2:08: keyword "body" expected here [see file name]
-gnatmake: 
"C:\Projects\org.emacs.ada-mode.stephe-1\test\Example_4\hello_pkg.adb" 
compilation error
-
-Compilation exited abnormally with code 4 at Mon Oct 21 11:32:05
+gprbuild -Pexample_5.gpr hello_5
+Compile
+   [Ada]          hello_5.adb
+   [Ada]          hello_pkg.adb
+hello_pkg.adb:5:07: "Put_Line" is not visible
+hello_pkg.adb:5:07: non-visible declaration at a-textio.ads:508
+hello_pkg.adb:5:07: non-visible declaration at a-textio.ads:498
+gprbuild: *** compilation phase failed
 @end example
 
-Now type @kbd{C-x `}. @file{Example_4/hello_pkg.adb} is shown,
+Now type @kbd{C-x `}; @file{Example_4/hello_pkg.adb} is shown,
 demonstrating that @file{hello_5.gpr} and @file{hello_4.gpr} are being
 used to set the compilation search path.
 
+Now, in buffer @file{hello_pkg.adb} invoke the menu @code{Ada |
+Navigate | Find file in project} (which calls
+@code{ada-find-file}) to get back to the @file{hello_5.adb}
+buffer. If you have not selected any project files previously in this
+emacs session, this gives an unexpected prompt for a ``project
+directory''. Kill that with @kbd{C-g}. Otherwise, enter @kbd{hel <tab>
+5 <tab>}; it will say ``no match''.
+
+The problem here the way Emacs projects work. To find the current
+project, the functions in @code{project-find-functions} are run; one
+should return a project. The ada-mode build functions add
+@code{wisi-prj-find-dominating-cached} to
+@code{project-find-functions}; that looks in the current directory
+tree for a project file with the same name as one that was previously
+selected.
+
+If @file{Example_5} is the only project in the current emacs session,
+@code{wisi-prj-find-dominating-cached} finds no project file (because
+@file{Example_4} is not a child directory of @file{Example_5}, so the
+default strategy of ``ask the user'' is used, giving the prompt for a
+directory.
+
+If @file{Example_4} is also a project in the current emacs session,
+@code{wisi-prj-find-dominating-cached} finds that; since it does not
+contain @file{hello_5.adb}, @code{ada-find-file} cannot find it.
+
+Any time you have a main project that depends on other projects that
+are not in the same directory tree, you will have this problem.
+
+The fix is to use a different function in
+@code{project-find-functions}; @code{wisi-prj-current-cached}. This
+uses a global variable to indicate what the current project is. wisi
+provides four different functions for @code{project-find-functions}. 
@xref{Selecting projects, Selecting projects, Selecting projects, wisi}.
+
+To change @code{project-find-functions}, execute:
+
+@example
+M-: (remove-hook 'project-find-functions 'wisi-prj-find-dominating-cached)
+M-: (add-hook 'project-find-functions 'wisi-prj-current-cached)
+@end example
+
+Normally, you must set @code{project-find-functions} in your
+@file{~/.emacs}, using the @code{add-hook} function. The ada-mode
+Build menu functions set it for you to make things simpler for
+novices, but they do not change it if you have put one of the wisi
+functions on it.
+
+Now set the current project; invoke @samp{Ada | Project | Find and
+select project...}, and select @file{Example_5/hello_5.prj}. Then in
+@file{hello_pkg.adb}, invoke @code{Ada |
+Navigate | Find file in project}; now we can find @file{hello_5.adb}.
+
 @node Use a Makefile,  , Use multiple GNAT project files, Compiling Examples
 @subsection Use a Makefile
 
 In this example, we show how to use a Makefile to build an Ada project
 with GNAT, run the result, and clean the build directories.
 
-Create the directories @file{Example_4, Example_5} as specified in @ref{Use 
GNAT
-project file},  @ref{Use multiple GNAT project files}.
+Create the directories @file{Example_4, Example_5} as specified in
+@ref{Use wisi project file}, @ref{Use multiple GNAT project files}.
 
 In @file{Example_5}, add the file:
 
@@ -1129,31 +1277,38 @@ all : build run
 .PHONY : force
 
 build : force
-        gprbuild -Phello_5.gpr hello_5
+        gprbuild -PExample_5.gpr hello_5
 
 run :
         ./hello_5
 
 clean :
-        gnatclean -r -Phello_5
-
-export GPR_PROJECT_PATH = ../Example_4/Gnat_Project
+        gnatclean -r -PExample_5
 
 # Local Variables:
-# eval:(ada-parse-prj-file "hello_5.adp")
-# eval:(ada-select-prj-file "hello_5.adp")
+# eval:(unless (wisi-prj-find-function-set-p)(add-hook 'project-find-functions 
'wisi-prj-current-cached))
+# eval:(wisi-prj-dtrt-parse-file "hello_5.prj" (ada-prj-default "hello_5 # 
main") "Makefile")
 # End:
 @end example
 
+Tell Emacs to allow @code{eval} in @code{Local Variables}:
+@example
+M-: (setq enable-local-eval t)
+@end example
+
 Close and re-open @file{Makefile}; the @samp{Local Variables} section
-sets the project file to @file{hello_5.adp} when the @file{Makefile}
-is opened. You can also use @key{C-x C-e} to execute the select line
-after the @file{Makefile} is opened, to change the project file back
-to @file{hello_5.adp}.
+sets the project file to @file{hello_5.prj} when the @file{Makefile}
+is opened.
+
+If you have set @code{project-find-functions} in your @file{~/.emacs},
+you can leave out the first @code{eval} line. Note that
+@code{wisi-prj-dtrt-parse-file} does the right thing depending on
+which wisi function is in @code{project-find-functions}.
 
 In @file{Makefile}, invoke @samp{Tools | Compile...}, and accept the
 default make command. This runs the @samp{all} target, which builds
-@file{hello_5} and runs it.
+@file{hello_5} and runs it (you may have to fix source errors first,
+depending on how fresh the Example_4 directory is).
 
 @node Compiler errors,  , Compiling Examples, Compiling Executing
 @section Compiler errors
@@ -1177,23 +1332,25 @@ references are accessed via @kbd{C-c `}.
 @node Project files, Moving Through Ada Code, Compiling Executing, Top
 @chapter Project files
 
-An Emacs Ada mode project file specifies what directories hold sources
-for your project, and allows you to customize the compilation commands
-and other things on a per-project basis.
+Ada mode uses wisi project files; @ref{wisi, Project files, Project files, 
wisi}.
 
-The default file extension for Ada mode project files is @file{*.adp}
+A wisi project file specifies what directories hold sources for your
+project, and allows you to customize the compilation commands and
+other things on a per-project basis.
+
+The default file extension for wisi project files is @file{*.adp}
 or @file{*.prj}. You can use a different extension by adding it to
 @code{ada-prj-file-extensions}, and a different syntax by adding a
 parser function to @code{ada-prj-parser-alist}.
 
-Note that Ada mode project files @file{*.adp} are different than GNAT
-compiler project files @samp{*.gpr}. However, Emacs Ada mode can use a
+Note that wisi project files are different than GNAT
+compiler project files (@samp{*.gpr}). However, Emacs Ada mode can use a
 GNAT project file to specify the project directories. If no
 other customization is needed, a GNAT project file can be used without
-an Emacs Ada mode project file.
+a wisi project file.
 
-If no Emacs Ada mode project file is specified, some Ada mode
-functions are not available.
+If no wisi project file is specified, some Ada mode functions are not
+available.
 
 @menu
 * Project file overview::
@@ -1203,171 +1360,110 @@ functions are not available.
 @node Project file overview, Project file variables, Project files, Project 
files
 @section Project file overview
 
-Project files have a simple syntax; they may be edited directly. Each
-line specifies a project variable name and its value, separated by
-``='' (spaces not allowed):
-@example
-src_dir=/Projects/my_project/src_1
-src_dir=/Projects/my_project/src_2
-@end example
-
-Any line that does not have an ``='' is a comment.
-
-Some variables (like @code{src_dir}) are lists; multiple occurrences
-are concatenated.
-
-There must be no space between the variable name and ``='', and no
-trailing spaces after the value.
-
-The current project file is given by the lisp variable
-@code{ada-prj-default-project-file}, and shown by the menu command
+The current project file is shown by the menu command
 @key{Ada | Project Files | Show project}.
 
-To set the project file, use the menu command @samp{Ada | Set Project
-...}, or the elisp functions @code{ada-parse-prj-file,
-ada-select-prj-file}. The latter can be added to a Makefile:
+To set the project file, use the menu command @key{Ada | Project Files | Find 
and
+select Project ...}, or one of the elisp functions described in
+@ref{wisi, Selecting Projects, Selecting Projects, wisi}.
 
-@example
-# Local Variables:
-# eval: (ada-parse-prj-file "ada-mode.prj")
-# eval: (ada-select-prj-file ada-mode.prj")
-# End:
-@end example
-
-You specify either a GNAT project file or an Emacs Ada mode project
-file; if the file extension is @code{.gpr}, the file is treated as a
-GNAT project file. Extensions given by @code{ada-prj-file-extensions}
-(default @file{.adp, .prj}) are treated as an Emacs Ada mode
-project file.
-
-After a project file is parsed, you can make it current again with
-just @code{ada-select-prj-file}, or by selecting it from the menu.
+The project file may also be a GNAT project file (with file extension
+is @code{.gpr}).
 
 @node Project file variables,  , Project file overview, Project files
 @section Project file variables
 
-To set a project variable that is a list, specify each element of the
-list on a separate line in the project file. The value on the last
-line is the last element in the list.
-
-A variable name that starts with @code{$} is set as a process
-environment variable, for processes launched from Emacs for the
-project.
-
-In variable values, process environment variables can be referenced
-using the normal @code{$var} syntax.
-
-Most project variables have defaults that can be changed by setting
+Some project variables have defaults that can be changed by setting
 elisp variables; the table below identifies the elisp variable for each
 project variable. Elisp variables corresponding to project variables
 that are lists are elisp lists.
 
-In general, project variables are evaluated when referenced in Emacs
-Ada mode commands. Relative file paths are expanded relative to the
-directory containing the project file.
-
-Ada mode defines some project variables; others are defined by the
-compiler.
+wisi defines some project variables, Ada mode defines some, others are
+defined by the compiler and the cross reference tool.
 
-Here is the list of variables valid for all compilers. In the default
-values, the current directory @code{"."} is the directory containing
-the project file.
+Here is the list of variables valid defined by wisi and Ada mode. In
+the default values, the current directory @code{"."} is the directory
+containing the project file.
 
 @table @asis
-@c These are the names that appear in the .adp file, which are the
-@c same as the symbols used with ada-prj-get
+@c These are the names that appear in the .prj file.
 @c
-@c defined in ada-mode.el ada-prj-parse-file-1; alphabetical order
+@c defined in wisi-prj.el and ada-mode.el wisi-prj-parse-one.
 @c defaults defined in ada-mode.el ada-prj-default
 
 @item @code{ada_compiler}   [default: @code{ada-compiler, gnat}]
-Ada compiler for this project. It must occur in the project file
-before any compiler-specific project variable.
+Ada compiler for this project.
 
-@item @code{auto_case}      [default: @code{ada-auto-case, t}]
-Non-nil means automatically change case of preceding word while typing.
+Setting this in the project file reinitializes all options for the
+xref tool, so it must occur before any compiler-specific project
+variable.
 
-@item @code{case_identifier}   [default: @code{ada-case-identifier, 
mixed-case}]
-Indicates how to adjust the case of an Ada identifier.
+@item @code{casing}
+List of files containing casing exceptions. @xref{Automatic casing,
+Automatic casing, wisi.info}.
 
-@item @code{case_keyword}   [default: @code{ada-case-keyword, lower-case}]
-Indicates how to adjust the case of an Ada keyword.
+@item @code{gnat-stub-args}
+List of strings passed to @code{gnat stub} when it is run.
 
-@item @code{case_strict}    [default: @code{ada-case-strict, t}]
-If non-nil, @code{ada-mixed-case} forces @code{Mixed_Case} for identifiers.
-Otherwise, @code{ada-mixed-case} allows @code{UPPERCASE} for identifiers.
+@item @code{gnat-stub-cargs}
+List of strings passed to @code{gnat stub} after @code{-cargs}.
 
-@item @code{casing}         [default: @code{ada-case-exception-file, nil}]
-List of files containing casing exceptions. @xref{Automatic casing}.
-
-@item @code{el_file}        [default: ]
-The value is a file name, which is loaded as an elisp file when the
-project file is parsed or selected. This allows setting Ada mode indentation
-variables, and any arbitrary elisp code used to customize the project.
-
-@item @code{obj_dir}        [default: @code{"."}]
+@item @code{obj_dir}
 A list of directories to search for object and cross-reference
 files. Only needed if you are not using GPR files.
 
-@item @code{path_sep}       [default: @code{path-separator}]
-Separator character used in compiler search paths.
-
-@item @code{src_dir}        [default: @code{"."}]
+@item @code{src_dir}
 A list of directories to search for source files. Added to the source
-directories from a GPR file.
+directories from a gpr file (if any).
 
 @item @code{xref_tool}      [default: @code{ada-xref-tool}]
 Cross reference tool for this project.
 
+Setting this in the project file reinitializes all options for the
+xref tool, so it must occur in the project file before any other
+settings that affect the xref tool.
+
 If @file{gpr_query} is found in @code{PATH}, @code{ada-xref-tool}
 defaults to @code{'gpr_query}. Otherwise, it defaults to @code{'gnat},
 which uses @code{gnat find}.
 
 @end table
 
-The following variables are valid with the GNAT compiler:
+The following project file variables are defined by the GNAT compiler:
 
 @table @asis
-@item @code{ada_project_path}   [default: @code{""}]
-@c ada-prj-get 'prj_dir, 'proc_env
-A list of directories to search for GNAT project files.
-
-If set, the @code{GPR_PROJECT_PATH} process environment variable is
-set to this value in the child process that runs GNAT tools. If not
-set, @code{GPR_PROJECT_PATH} in the child process is inherited from
-the Emacs process.
+@c defined in gnat-core.el wisi-compiler-parse-one.
+@item @code{ada_project_path}   [default: ]
+Same as @code{gpr_project_path}; see below.
 
-If you have the @code{GPR_PROJECT_PATH} or @code{ADA_PROJECT_PATH}
-environment variable set in the Emacs process correctly for all of
-your projects, you do not need to set this project variable.
-
-The project search path can also be set in GNAT aggregate
-projects. However, the gnat tools do not make that path available to
-Emacs, so you must duplicate it in an Emacs Ada project file.
-
-@item @code{gpr_file}   [default: @code{""}]
-The GNAT project file.
+@item @code{gpr_file}   [default: ]
+The GNAT project file for the project.
 
 If set, the source and project directories specified in the GNAT
 project file are appended to @code{src_dir} and
-@code{ada_project_path}. This allows specifying Ada source directories
+@code{gpr_project_path}. This allows specifying Ada source directories
 with a GNAT project file, and other source directories with the Emacs
 project file.
 
-@item @code{gpr_project_path}   [default: @code{""}]
-Same as @code{ada_project_path}.
+@item @code{gpr_project_path}   [default: ]
+A list of directories to
+search for GNAT project files. The list is passed to tools via the
+@code{GPR_PROJECT_PATH} process environment variable in the process
+used to run the @code{gnat} and @code{gpr_query} tools.
+
+If not set, @code{GPR_PROJECT_PATH} in the child process is inherited
+from the Emacs process.
 
-@item @code{runtime} [default: @code{nil}]
-@c used in gnat-run-gnat
+@item @code{runtime} [default: ]
+@c slot gnat-compiler-runtime
 If set, the name of the runtime, used as the value of the @code{RTS}
-command line option.
+command line option for tools.
 
 @item @code{target} [default: @code{nil}]
-@c used in gnat-run-gnat, ada-gnat-xref-all
+@c slot gnat-compiler-target
 If set, the name of the cross-compilation target, prepended to the
 @code{gnat} executable name.
 
-
 @end table
 
 The following project variables are used by the @code{Ada | Build}
@@ -1400,29 +1496,33 @@ compiler, but others can be added (@pxref{Other 
cross-reference}).
 
 @table @kbd
 @item C-c C-d
-@findex ada-goto-declaration
 Move from any use of an identifier to its declaration, for from a declaration 
to
 its body (if there is one).
 
+This runs @code{xref-find-definitions}, which has a default global
+binding of @key{M-.}
+
 @item C-c M-d
-@findex ada-goto-declaration-parent
 Move from a child type declaration to the parent type declaration;
 display a list of references if there is more than one parent.
 
 @item C-c C-n
-@findex ada-next-statement-keyword
 Move to the next keyword in the current statement.
 
 For example, if point is on @samp{if}, move to @samp{then}.
 
+This runs @code{forward-sexp}, which has a default global binding of
+@kbd{C-M-f}.
+
 @item C-c C-p
-@findex ada-prev-statement-keyword
 Move to the previous keyword in the current statement.
 
 For example, if point is on @samp{then}, move to @samp{if}.
 
+This runs @code{backward-sexp}, which has a default global binding of
+@kbd{C-M-b}.
+
 @item C-c C-o
-@findex ada-find-other-file
 Switch between corresponding spec and body. There are several special
 cases:
 
@@ -1452,19 +1552,16 @@ corresponding declaration.
 @end itemize
 
 @item C-c C-r
-@findex ada-show-references
 Show all references to the identifier surrounding point. Use
 @kbd{C-x `} (@code{next-error}) to visit each reference (as for
 compilation errors).
 
 @item C-c C-x
-@findex ada-show-overriding
 Show all declarations that override the primitive procedure at
 point. Use @kbd{C-x `} (@code{next-error}) to visit each reference (as
 for compilation errors).
 
 @item C-c M-x
-@findex ada-show-overridden
 Show the declaration that the declaration at point overrides.
 
 @item C-u SPACE
@@ -1472,7 +1569,8 @@ Jump back to the previous location.
 
 @item Ada | Misc | Refresh cross reference cache
 Cross reference information is loaded from the compiler output when
-the first cross reference command is issued. If the code is recompiled
+the first cross reference command is issued (or when the project file
+is parsed, if useing cached project files). If the code is recompiled
 after that, the cross reference information is reloaded by invoking
 this menu command.
 
@@ -1486,6 +1584,9 @@ Emacs provides a general way of completing identifiers: 
@kbd{M-/}
 you just have to type the first few letters of an identifier, and then
 loop through all the possible completions.
 
+If you have bound @code{hippie-expand}, that also uses
+@code{dabbrev-expand}.
+
 @kbd{M-/} works by parsing all open Ada files for possible
 completions.
 
@@ -1585,8 +1686,8 @@ Indentation for the lines in a @code{with} context clause.
 @end table
 
 The indentation variables are buffer local; the global value may be
-overridden in an elisp file invoked by an @code{el_file} Emacs Ada
-mode project file statement, or in a file local variable section.
+overridden in an elisp function on @code{ada-mode-hook}, or in a file
+local variable section.
 
 The following keys indent portions of the text:
 @table @kbd
@@ -1600,55 +1701,23 @@ Indent the current line, or the current region.
 @item C-c TAB
 Indent the current statement or declaration.
 
+@item C-c S-TAB
+Indent the statement or declaration containing the current statement
+or declaration.
+
 @end table
 
 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 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 text has been entered to make the code acceptable to the parser,
-the statement or declaration is properly indented.
-
-For example, if you are entering this code:
-
-@example
-if A then
-   B;
-end if;
-@end example
-
-when you type @kbd{RET B}, @code{B} is indented to the same column as
-@code{if}, because the parser does not find @code{end if;}. Then when
-you type the final @code{;} followed by @key{TAB}, all three lines are
-indented, putting @code{B} where it belongs.
-
-To be more user friendly, the parser accepts a superset of the Ada
-grammer. For example, the parser accepts this code for an @code{if}
-statement:
-
-@example
-if then
-end if;
-@end example
-
-In general, any sequence of statements, and many expressions, may be
-omitted.
-
-One way to easily insert empty statements like this is using
-@ref{Statement skeletons}.
+syntactic role for keywords and other words in the code.
 
 In rare cases, the parser gets confused; it can be reset by invoking
-menu @key{Ada | Misc | Reset parser}. Please report such cases as a
+menu @key{Ada | Misc | Restart parser}. Please report such cases as a
 bug.
 
 @node Statement skeletons, Aligning code, Indentation, Top
 @chapter Statement skeletons
 
-@kbd{C-c C-e} expands the previous one or two words into a statment
+@kbd{C-c C-e} expands the previous one or two words into a statement
 skeleton. For example, @kbd{i f C-c C-e} expands to:
 
 @example
@@ -1658,10 +1727,6 @@ else
 end if;
 @end example
 
-All skeleton expansions are accepted by the indentation parser, so
-this is a convenient way to insert statements with correct
-indentation.
-
 For named statements (packages, loops, etc), the name is taken from
 the word before point, and the name of the statement from the word
 before that.
@@ -1776,45 +1841,26 @@ all uppercase identifiers without defining a casing 
exception.
 @end table
 
 You can define exceptions to these rules, in files specified by the
-variable @code{ada-case-exception-file}. Each line in a case exception
-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 fragment (or ``substring''); part of a word between two
-underscores or word boundary.
-
-For example:
-
-@example
-DOD
-*IO
-GNAT
-@end example
-
-The word fragment @code{*IO} applies to any word containing ``_io'';
-@code{Text_IO}, @code{Hardware_IO}, etc.
+@code{casing} project variable; @ref{Casing exception files, Casing
+exception files, Casing exception files, wisi}.
 
-@findex ada-case-create-exception
-There are two ways to add new items to this file: you can simply edit
-it as you would edit any text file. Or you can position point on the
-word you want to add, and select menu @samp{Ada | Casing | Create full
-exception} or @samp{Ada | Casing | Create partial exception}.  The
-word will be added to the current list of exceptions and to the file.
+There are two ways to add new items to a casing exception file: you
+can simply edit it as you would edit any text file, or you can
+position point on the word you want to add, and select menu @samp{Ada
+| Casing | Create full exception} or @samp{Ada | Casing | Create
+partial exception}.  The word will be added to the current list of
+exceptions and to the file.
 
 It is sometimes useful to have multiple exception files. For
 example, one could be the standard Ada acronyms, the second some
 company specific exceptions, and the last one some project specific
-exceptions. If you set up the variable @code{ada-case-exception-file}
-as a list of files, each of them will be parsed and used in your emacs
-session. When you create a new exception, you are prompted for the
+exceptions. When you create a new exception, you are prompted for the
 file to save it in.
 
 Other keys and menu entries are defined:
 
 @table @kbd
 @item C-c C-w
-@findex ada-case-adjust-at-point
 Adjust case of the word at point. With prefix arg, adjust case even if
 in a comment or string. Normally, comments and strings are not
 affected by case adjust.
@@ -1835,7 +1881,6 @@ additional functions to handle comments:
 
 @table @kbd
 @item M-;
-@findex comment-dwim
 If the region is active, comment or uncomment it.
 
 If the current line is empty, start a comment.
@@ -1844,7 +1889,6 @@ Otherwise, add a comment at the end of the line, in a 
column given by
 @code{comment-column}.
 
 @item M-q
-@findex fill-paragraph
 Fill the current comment paragraph.
 @end table
 
@@ -1882,6 +1926,10 @@ Indent the current line, or the current region.
 @xref{Indentation}.
 Indent the current statement or declaration.
 
+@item C-c S-TAB
+@xref{Indentation}.
+Indent the containing statement or declaration.
+
 @item C-c `
 @xref{Compiler errors}.
 Move to the location of the secondary reference in the current compilation 
error.
@@ -1962,13 +2010,12 @@ sources, here's an overview.
 
 @menu
 * Directory structure::
-* Package organization::
 * ELPA::
 * Savannah::
 * ada-france::
 @end menu
 
-@node Directory structure, Package organization, Developer overview, Developer 
overview
+@node Directory structure
 @section Directory structure
 @table @file
 @item org.emacs.ada-mode
@@ -2057,107 +2104,6 @@ More tests; allows testing path search features.
 
 @end table
 
-@node Package organization
-@section Package organization
-
-@menu
-* Ada mode::
-* gpr mode::
-* GNAT core::
-* Wisi::
-@end menu
-
-@node Ada mode, gpr mode, Package organization, Package organization
-@subsection Ada mode
-Ada mode consists of all files with @file{ada-} prefix in the file
-name.
-
-@table @file
-@item ada-mode.el
-The main file, implementing the keymap, menu, and top level
-functionality.
-
-It allows for different backend implementations for compiling,
-cross-referencing, and indenting. The functions for each of these
-backends dispatch thru global variables that are set by Emacs Ada mode
-project files. They default to the GNAT compiler, the gnatxref cross
-reference tool, and the ada-wisi indentation engine.
-
-@item ada-build.el
-Provides functions for compiling Ada files without a Makefile (or
-similar tool).
-
-@item ada-fix-error.el
-Provides an interface to utilities for automatically fixing errors
-reported by the compiler. It dispatches to a compiler-specific
-backend.
-
-@item ada-gnat-compile.el
-Implements the Ada mode compiler functions for the GNAT compiler.
-
-@item ada-gnat-xref.el
-Implements the Ada mode cross reference functions for the GNAT compiler.
-
-@item ada.wy
-The Ada language grammar.
-
-@item ada-indent-user-options.el
-All user-settable options for the Ada indentation engine.
-
-@item ada-mode-compat.el
-Defines functions used by Ada mode that are not in older versions of Emacs.
-
-@item ada-mode.texi
-This Ada mode user guide source.
-
-@item ada-skel.el
-Skeletons for expansion of Ada syntax (@pxref{Statement
-skeletons}). Extends the Emacs skeleton functions with ``tokens'',
-inspired by the lamented Else package (which was inspired by DEC LSE).
-
-@item ada-wisi.el
-Implements the Ada mode indentation functions for the wisi indentation
-engine backend.
-
-@end table
-
-@node gpr mode, GNAT core, Ada mode, Package organization
-@subsection gpr mode
-
-gpr mode consists of all files with @file{gpr-} prefix in the file
-name. The functions in each file are similar to the similarly-named
-Ada mode files.
-
-@node GNAT core, Wisi, gpr mode, Package organization
-@subsection GNAT core
-@table @file
-
-@item gnat-core.el
-GNAT is actually a multi-language tool; it builds on top of the
-multi-language gcc.
-
-@file{gnat-core.el} is a start at a language-agnostic interface to the
-GNAT tools. It was first factored out from @file{ada-gnat.el} and
-@file{ada-mode.el} to support the multi-language @file{gpr_query.el}.
-
-More code currently in @file{ada-mode.el} could be migrated to
-@file{gnat-core.el}, in particular the project file support.
-
-@item gpr-query.el
-Provides an interface to the external multi-language cross-reference
-tool @file{gpr_query}.
-
-Implements the Ada mode cross-reference functions for the
-@file{gpr_query} backend, and a minor mode providing similar
-functions for C++.
-
-@end table
-
-@node Wisi,  , GNAT core, Package organization
-@subsection Wisi
-
-The ``wisi'' parser. @xref{Overview, Overview, Overview, wisi}.
-
 @node ELPA
 @section ELPA
 Ada mode is published via the Gnu ELPA archive. To test a new version
@@ -2193,13 +2139,8 @@ project admin page there for more information.
 The source code for ada-mode is maintained in a monotone repository in
 the ada-france server @url{mtn://www.ada-france.org}.
 
-@node GNU Free Documentation License, Index, Developer overview, Top
+@node GNU Free Documentation License
 @appendix GNU Free Documentation License
 @include doclicense.texi
 
-@node Index,  , GNU Free Documentation License, Top
-@unnumbered Index
-
-@printindex fn
-
 @bye
diff --git a/packages/ada-mode/ada-prj.el b/packages/ada-mode/ada-prj.el
deleted file mode 100644
index 819c970..0000000
--- a/packages/ada-mode/ada-prj.el
+++ /dev/null
@@ -1,4 +0,0 @@
-;;; ada-prj.el --- Dummy file to hide obsolete bundled version  -*- 
lexical-binding:t -*-
-(require 'ada-mode)
-(provide 'ada-prj)
-(message "'ada-prj' is obsolete; use 'ada-mode' instead")
diff --git a/packages/ada-mode/ada-process.el b/packages/ada-mode/ada-process.el
index 7c4ec40..73d3efa 100644
--- a/packages/ada-mode/ada-process.el
+++ b/packages/ada-mode/ada-process.el
@@ -98,6 +98,7 @@
    LEFT_PAREN
    RIGHT_PAREN
    AMPERSAND
+   AT_SIGN
    BAR
    BOX
    COLON
@@ -440,6 +441,7 @@
    (LEFT_PAREN . "(")
    (RIGHT_PAREN . ")")
    (AMPERSAND . "&")
+   (AT_SIGN . "@")
    (BAR . "|")
    (BOX . "<>")
    (COLON . ":")
diff --git a/packages/ada-mode/ada-project.el b/packages/ada-mode/ada-project.el
deleted file mode 100644
index ae5b3a4..0000000
--- a/packages/ada-mode/ada-project.el
+++ /dev/null
@@ -1,120 +0,0 @@
-;; ada-project.el - project.el backend for ada-mode projects -*- 
lexical-binding: t -*-
-;;
-;; Copyright (C) 2017 - 2019  Free Software Foundation, Inc.
-;;
-;; Author: Stephen Leake <address@hidden>
-;;
-;; This file is part of GNU Emacs.
-;;
-;; GNU Emacs is free software: you can redistribute it and/or modify
-;; it under the terms of the GNU General Public License as published by
-;; the Free Software Foundation, either version 3 of the License, or
-;; (at your option) any later version.
-;;
-;; GNU Emacs is distributed in the hope that it will be useful,
-;; but WITHOUT ANY WARRANTY; without even the implied warranty of
-;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-;; GNU General Public License for more details.
-;;
-;; You should have received a copy of the GNU General Public License
-;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
-
-(require 'ada-mode)
-(require 'cl-lib)
-(require 'cl-generic)
-(require 'project)
-(require 'uniquify-files)
-
-(cl-defgeneric project-refresh (prj full)
-  "Refresh all cached data in PRJ.
-If FULL is non-nil, very slow refresh operations may be skipped.")
-
-(defun refresh-project (full)
-  "Refresh all cached data in the current project.
-With prefix arg, very slow refresh operations may be skipped."
-  (interactive "P")
-  (project-refresh (project-current) full))
-
-(cl-defgeneric project-select (prj)
-  "User has selected PRJ as the active project; take actions to make that so."
-  (setq compilation-search-path
-       (append (project-roots prj)
-               (project-external-roots prj)))
-  )
-
-(cl-defgeneric project-deselect (_prj)
-  "PRJ is the current project; user has selected another project.
-Undo actions done in `project-select'."
-  (setq compilation-search-path nil)
-  )
-
-(cl-defstruct (ada-project
-              (:constructor nil) ;; no default
-              (:constructor make-ada-project
-                            (&key
-                             env-vars
-                             ada-prj-file
-                             file-pred
-                             &aux
-                             (ada-prj (expand-file-name ada-prj-file))))
-              )
-  env-vars ;; a list of (NAME . VALUE)
-  ada-prj ;; The ada-mode project file name (absolute).
-
-  file-pred ;; Function taking an absolute file name, returns non-nil
-           ;; if the file should be included in `project-files'.
-  )
-
-(defvar ada-project-current nil
-  "The current Ada project; an `ada-project' object.")
-
-;;;###autoload
-(defun ada-project-current (_dir)
-  "Return the project the user has set in `ada-project-current'.
-For `project-find-functions'."
-   ada-project-current)
-
-(cl-defmethod project-id ((prj ada-project))
-  ;; project-id is experimental
-  (ada-project-ada-prj prj))
-
-(cl-defmethod project-roots ((_prj ada-project))
-  ;; Not meaningful
-  nil)
-
-(cl-defmethod project-files ((prj ada-project) &optional dirs)
-  (let (result)
-    (dolist (dir (or dirs (ada-prj-get 'src_dir)))
-      (mapc
-       (lambda (absfile)
-        (when (and (not (string-equal "." (substring absfile -1)))
-                   (not (string-equal ".." (substring absfile -2)))
-                   (not (file-directory-p absfile))
-                    (or (null (ada-project-file-pred prj))
-                       (funcall (ada-project-file-pred prj) absfile)))
-          (push absfile result)))
-       (directory-files dir t)))
-    result))
-
-(when (not (fboundp 'project--read-file-cpd-relative)) ;; emacs < 27
-  (cl-defmethod project-file-completion-table ((prj ada-project) &optional 
dirs)
-    (apply-partially #'uniq-file-completion-table (uniq-file-uniquify 
(project-files prj dirs)))))
-
-(cl-defmethod project-select ((prj ada-project))
-  (dolist (pair (ada-project-env-vars prj))
-    (setenv (car pair) (cdr pair)))
-  (ada-select-prj-file (ada-project-ada-prj prj)))
-
-(cl-defmethod project-deselect :before ((prj ada-project))
-  (ada-deselect-prj (ada-project-ada-prj prj))
-  (dolist (pair (ada-project-env-vars prj))
-    (setenv (car pair) nil)))
-
-(cl-defmethod project-refresh ((_prj ada-project) full)
-  ;; assume prj is current
-  (ada-refresh-prj-file)
-  (ada-xref-refresh full))
-
-(provide 'ada-project)
-
-;; end of file
diff --git a/packages/ada-mode/ada-skel.el b/packages/ada-mode/ada-skel.el
index c5218fa..3e54bdf 100644
--- a/packages/ada-mode/ada-skel.el
+++ b/packages/ada-mode/ada-skel.el
@@ -21,7 +21,7 @@
 
 ;;; Design:
 ;;
-;; The primary user command is `ada-skel-expand', which inserts the
+;; The primary user command is `wisi-skel-expand', which inserts the
 ;; skeleton associated with the previous word (possibly skipping a
 ;; name).
 ;;
@@ -29,8 +29,8 @@
 ;; is easier just to type in the buffer.
 ;;
 ;; These skeletons are not intended to teach a novice the language,
-;; just to make it easier to write code that the ada-wisi parser
-;; likes, and handle repeated names nicely.
+;; just to make it easier to write code that the wisi parser
+;; handles without error, and handle repeated names nicely.
 
 ;;; History:
 
@@ -63,7 +63,8 @@
 ;; skeletons; just make it easier to work with the ada-wisi parser,
 ;; don't try to teach syntax.
 
-(require 'skeleton nil t)
+(require 'skeleton)
+(require 'wisi-skel)
 
 ;;;;; user variables, example skeletons intended to be overwritten
 
@@ -123,10 +124,6 @@ This could end in a token recognized by `ada-skel-expand'."
 
 )
 
-;; override ada-mode 4.01 autoloaded functions
-(define-obsolete-function-alias 'ada-header 'ada-skel-header "24.4"
-  "Insert a descriptive header at the top of the file.")
-
 ;;;;; Ada skeletons (alphabetical)
 
 (define-skeleton ada-skel-accept
@@ -309,7 +306,7 @@ See `ada-find-other-file' to create library level package 
body from spec."
   ()
   "with " str "; use " str ";")
 
-;;;;; token alist, other functions
+;;;;; token alist
 
 (defconst ada-skel-token-alist
   '(("accept" . ada-skel-accept)
@@ -351,138 +348,18 @@ See `ada-find-other-file' to create library level 
package body from spec."
      ("spec" . ada-skel-task-spec))
     ("while" . ada-skel-while)
     ("with" . ada-skel-with-use))
-  "alist of elements (STRING ELEMENT). See `ada-skel-expand'.
-STRING must be a symbol in the current syntax, and is normally
-the first Ada keyword in the skeleton. All strings must be
-lowercase; `ada-skel-expand' converts user inputs.
-
-ELEMENT may be:
-- a skeleton, which is inserted
-- an alist of (string . skeleton). User is prompted with `completing-read', 
selected skeleton is inserted. ")
-
-(defvar ada-skel-test-input nil
-  "When non-nil, bypasses prompt in alist token expansions - used for unit 
testing.")
-
-(defun ada-skel-build-prompt (alist count)
-  "Build a prompt from the keys of the ALIST.
-The prompt consists of the first COUNT keys from the alist, separated by `|', 
with
-trailing `...' if there are more keys."
-  (if (>= count (length alist))
-      (concat (mapconcat 'car alist " | ") " : ")
-    (let ((alist-1 (butlast alist (- (length alist) count))))
-      (concat (mapconcat 'car alist-1 " | ") " | ... : "))
-  ))
-
-(defun ada-skel-expand (&optional name)
-  "Expand the token or placeholder before point to a skeleton, as defined by 
`ada-skel-token-alist'.
-A token is a symbol in the current syntax.
-A placeholder is a symbol enclosed in generic comment delimiters.
-If the word before point is not in `ada-skel-token-alist', assume
-it is a name, and use the word before that as the token."
-  (interactive "*")
-
-  ;; Skip trailing space, newline, and placeholder delimiter.
-  ;; Standard comment end included for languages where that is newline.
-  (skip-syntax-backward " !>")
-
-  ;; include punctuation here, in case is is an identifier, to allow 
Ada.Text_IO
-  (let* ((end (prog1 (point) (skip-syntax-backward "w_.")))
-        (token (downcase (buffer-substring-no-properties (point) end)))
-        (skel (assoc-string token ada-skel-token-alist))
-        (handled nil))
-
-    (if skel
-       (progn
-         (when (listp (cdr skel))
-           (let* ((alist (cdr skel))
-                  (prompt (ada-skel-build-prompt alist 4)))
-             (setq skel (assoc-string
-                         (or ada-skel-test-input
-                             (completing-read prompt alist))
-                         alist))
-             (setq ada-skel-test-input nil) ;; don't reuse input on recursive 
call
-             ))
-
-         ;; delete placeholder delimiters around token, token, and
-         ;; name. point is currently before token.
-         (skip-syntax-backward "!")
-         (delete-region
-          (point)
-          (progn
-            (skip-syntax-forward "!w_")
-            (when name
-              (skip-syntax-forward " ")
-              (skip-syntax-forward "w_."))
-            (point)))
-         (funcall (cdr skel) name)
-         (setq handled t))
-
-      ;; word in point .. end is not a token; assume it is a name
-      (when (not name)
-       ;; avoid infinite recursion
-
-       ;; Do this now, because skeleton insert won't.
-       ;;
-       ;; We didn't do it above, because we don't want to adjust case
-       ;; on tokens and placeholders.
-       (save-excursion (ada-case-adjust-region (point) end))
-       (setq token (buffer-substring-no-properties (point) end))
-
-       (ada-skel-expand token)
-       (setq handled t)))
-
-    (when (not handled)
-      (error "undefined skeleton token: %s" name))
-    ))
-
-(defun ada-skel-hippie-try (old)
-  "For `hippie-expand-try-functions-list'. OLD is ignored."
-  (if old
-      ;; hippie is asking us to try the "next" completion; we don't have one
-      nil
-    (let ((pos (point))
-         (undo-len (if (eq 't pending-undo-list)
-                       0
-                     (length pending-undo-list))))
-      (undo-boundary)
-      (condition-case nil
-         (progn
-           (ada-skel-expand)
-           t)
-       (error
-        ;; undo hook action if any
-        (unless (or (eq 't pending-undo-list)
-                    (= undo-len (length pending-undo-list)))
-          (undo))
-
-        ;; undo motion
-        (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 "^!"))
+  "Ada tokens for `wisi-skel-token-alist', used by `wisi-skel-expand'.")
 
 (defun ada-skel-setup ()
   "Setup a buffer for ada-skel."
-  (add-hook 'skeleton-end-hook 'ada-indent-statement nil t)
+  (setq wisi-skel-token-alist ada-skel-token-alist)
+  (add-hook 'skeleton-end-hook 'wisi-indent-statement nil t)
   (when (and ada-skel-initial-string
             (= (buffer-size) 0))
     (insert ada-skel-initial-string))
   )
 
-(provide 'ada-skeletons)
-(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)
 
+(provide 'ada-skel)
 ;;; ada-skel.el ends here
diff --git a/packages/ada-mode/ada-stmt.el b/packages/ada-mode/ada-stmt.el
deleted file mode 100644
index 3f5ed24..0000000
--- a/packages/ada-mode/ada-stmt.el
+++ /dev/null
@@ -1,4 +0,0 @@
-;;; ada-stmt.el --- Dummy file to hide obsolete bundled version  -*- 
lexical-binding:t -*-
-(require 'ada-mode)
-(provide 'ada-stmt)
-(message "'ada-stmt' is obsolete; use 'ada-mode' instead")
diff --git a/packages/ada-mode/ada-wisi.el b/packages/ada-mode/ada-wisi.el
deleted file mode 100644
index e257af2..0000000
--- a/packages/ada-mode/ada-wisi.el
+++ /dev/null
@@ -1,795 +0,0 @@
-;;; ada-wisi.el --- Indentation engine for Ada mode, using the wisi 
generalized LALR parser  -*- lexical-binding:t -*-
-;;
-;; [1] ISO/IEC 8652:2012(E); Ada 2012 reference manual
-;;
-;; Copyright (C) 2012 - 2019  Free Software Foundation, Inc.
-;;
-;; Author: Stephen Leake <address@hidden>
-;;
-;; This file is part of GNU Emacs.
-;;
-;; GNU Emacs is free software: you can redistribute it and/or modify
-;; it under the terms of the GNU General Public License as published by
-;; the Free Software Foundation, either version 3 of the License, or
-;; (at your option) any later version.
-;;
-;; GNU Emacs is distributed in the hope that it will be useful,
-;; but WITHOUT ANY WARRANTY; without even the implied warranty of
-;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-;; GNU General Public License for more details.
-;;
-;; You should have received a copy of the GNU General Public License
-;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
-;;
-;;;;
-
-(require 'ada-fix-error)
-(require 'ada-indent-user-options)
-(require 'ada-process)
-(require 'cl-lib)
-(require 'wisi)
-(require 'wisi-process-parse)
-
-(defconst ada-wisi-language-protocol-version "2"
-  "Defines language-specific parser parameters.
-Must match wisi-ada.ads Language_Protocol_Version.")
-
-;; Refactor actions; must match wisi-ada.adb Refactor
-(defconst ada-refactor-method-object-to-object-method 1)
-(defconst ada-refactor-object-method-to-method-object 2)
-
-(defconst ada-refactor-element-object-to-object-index 3)
-(defconst ada-refactor-object-index-to-element-object 4)
-
-(defconst ada-refactor-format-paramlist 5)
-
-(defun ada-wisi-comment-gnat (indent after)
-  "Modify INDENT to match gnat rules. Return new indent.
-INDENT must be indent computed by the normal indentation
-algorithm.  AFTER indicates what is on the previous line; one of:
-
-code:         blank line, or code with no trailing comment
-code-comment: code with trailing comment
-comment:      comment"
-  (let (prev-indent next-indent)
-    ;; the gnat comment indent style check; comments must
-    ;; be aligned to one of:
-    ;;
-    ;; - multiple of ada-indent
-    ;; - next non-blank line
-    ;; - previous non-blank line
-    ;;
-    ;; Note that we must indent the prev and next lines, in case
-    ;; they are not currently correct.
-    (cond
-     ((and (not (eq after 'comment))
-          (= 0 (% indent ada-indent)))
-      ;; this will handle comments at bob and eob, so we don't
-      ;; need to worry about those positions in the next checks.
-      indent)
-
-     ((and (setq prev-indent
-                (if (eq after 'comment)
-                    (progn (forward-comment -1) (current-column))
-                  (save-excursion (forward-line -1)(current-indentation))))
-          (= indent prev-indent))
-      indent)
-
-     ((and (setq next-indent
-                ;; we use forward-comment here, instead of
-                ;; forward-line, because consecutive comment
-                ;; lines are indented to the current one, which
-                ;; we don't know yet.
-                (save-excursion (forward-comment 
(point-max))(current-indentation)))
-          (= indent next-indent))
-      indent)
-
-     (t
-      (cl-ecase after
-       (code-comment
-        ;; After comment that follows code on the same line
-        ;; test/ada_mode-conditional_expressions.adb
-        ;;
-        ;; then 44     -- comment matching GNAT
-        ;;             -- second line
-        ;;
-        ;; else 45)); -- comment _not_ matching GNAT style check
-        ;;             -- comment matching GNAT
-        ;;
-        (+ indent (- ada-indent (% indent ada-indent))))
-
-       ((code comment)
-        ;; After code with no trailing comment, or after comment
-        ;; test/ada_mode-conditional_expressions.adb
-        ;; (if J > 42
-        ;; -- comment indent matching GNAT style check
-        ;; -- second line of comment
-        prev-indent)
-
-       ))
-     )))
-
-(defun ada-wisi-comment ()
-  "Modify indentation of a comment:
-For `wisi-indent-calculate-functions'.
-- align to previous comment after code.
-- respect `ada-indent-comment-gnat'."
-  ;; We know we are at the first token on a line. We check for comment
-  ;; syntax, not comment-start, to accomodate gnatprep, skeleton
-  ;; placeholders, etc.
-  ;;
-  ;; The normal indentation algorithm has already indented the
-  ;; comment.
-  (when (and (not (eobp))
-            (= 11 (syntax-class (syntax-after (point)))))
-
-    ;; We are looking at a comment; check for preceding comments, code
-    (let (after
-         (indent (current-column)))
-      (if (save-excursion (forward-line -1) (looking-at "\\s *$"))
-         ;; after blank line
-         (setq after 'code)
-
-       (save-excursion
-         (forward-comment -1)
-         (if (or (not ada-indent-after-trailing-comment) ;; ignore comment on 
previous line
-                 (looking-at "\\s *$"))                  ;; no comment on 
previous line
-             (setq after 'code)
-
-           (setq indent (current-column))
-           (if (not (= indent (progn (back-to-indentation) (current-column))))
-               ;; previous line has comment following code
-               (setq after 'code-comment)
-             ;; previous line has plain comment
-             (setq indent (current-column))
-             (setq after 'comment)
-             )))
-       )
-
-      (cl-ecase after
-       (code
-        (if ada-indent-comment-gnat
-            (ada-wisi-comment-gnat indent 'code)
-          indent))
-
-       (comment
-        indent)
-
-       (code-comment
-        (if ada-indent-comment-gnat
-            (ada-wisi-comment-gnat indent 'code-comment)
-
-          ;; After comment that follows code on the same line
-          ;; test/ada_mode-nominal.adb
-          ;;
-          ;; begin -- 2
-          ;;       --EMACSCMD:(progn 
(ada-goto-declarative-region-start)(looking-at "Bad_Thing"))
-          (save-excursion (forward-comment -1)(current-column)))
-        ))
-      )))
-
-(defun ada-wisi-post-parse-fail ()
-  "For `wisi-post-parse-fail-hook'."
-  ;; Parse indent succeeded, so we assume parse navigate will as well
-  (wisi-validate-cache (point-min) (line-end-position) nil 'navigate)
-  (save-excursion
-    (let ((start-cache (wisi-goto-start (or (wisi-get-cache (point)) 
(wisi-backward-cache)))))
-      (when start-cache
-       ;; nil when in a comment at point-min
-       (indent-region (point) (wisi-cache-end start-cache)))
-      ))
-  (back-to-indentation))
-
-;;;; ada-mode functions (alphabetical)
-
-(defun ada-wisi-declarative-region-start-p (cache)
-  "Return t if cache is a keyword starting a declarative region."
-  (memq (wisi-cache-token cache) '(DECLARE IS PRIVATE))
-  ;; IS has a cache only if start of declarative region
-  )
-
-(defun ada-wisi-context-clause ()
-  "For `ada-fix-context-clause'."
-  (wisi-validate-cache (point-min) (point-max) t 'navigate)
-  (save-excursion
-    (goto-char (point-min))
-    (let ((begin nil)
-         (end nil)
-         cache)
-
-      (while (not end)
-       (setq cache (wisi-forward-cache))
-       (cl-case (wisi-cache-nonterm cache)
-         (pragma_g (wisi-goto-end-1 cache))
-         (use_clause (wisi-goto-end-1 cache))
-         (with_clause
-          (when (not begin)
-            (setq begin (line-beginning-position)))
-          (wisi-goto-end-1 cache))
-         (t
-          ;; start of compilation unit
-          (setq end (line-beginning-position))
-          (unless begin
-            (setq begin end)))
-         ))
-      (cons begin end)
-    )))
-
-(defun ada-wisi-fix-error (_msg source-buffer _source-window)
-  "For ’ada-fix-error-hook’. Calls ’wisi-repair-error’ if appropriate."
-  (when (equal compilation-last-buffer wisi-error-buffer)
-    (set-buffer source-buffer)
-    (wisi-repair-error)
-    t))
-
-(defun ada-wisi-on-context-clause ()
-  "For `ada-on-context-clause'."
-  (let (cache)
-    (save-excursion
-      ;; Don't require parse of large file just for ada-find-other-file
-      (and (< (point-max) wisi-size-threshold)
-          (setq cache (wisi-goto-statement-start))
-          (memq (wisi-cache-nonterm cache) '(use_clause with_clause))
-          ))))
-
-(defun ada-wisi-in-case-expression ()
-  "For `ada-in-case-expression'."
-  (save-excursion
-    ;; Used by ada-align; we know we are in a paren.
-    (ada-goto-open-paren 1)
-    (while (forward-comment 1))
-    (looking-at "case")))
-
-(defun ada-wisi-goto-subunit-name ()
-  "For `ada-goto-subunit-name'."
-  (wisi-validate-cache (point-min) (point-max) t 'navigate)
-
-  (let (cache
-       (name-pos nil))
-    (save-excursion
-      ;; move to top declaration
-      (goto-char (point-min))
-      (setq cache (or (wisi-get-cache (point))
-                     (wisi-forward-cache)))
-
-      (when (eq (wisi-cache-nonterm cache) 'subunit)
-       (setq name-pos (car (wisi-next-name-region))))
-      )
-    (when name-pos
-      (goto-char name-pos))
-    ))
-
-(defun ada-wisi-goto-declaration-start (&optional include-type)
-  "For `ada-goto-declaration-start', which see.
-Also return cache at start."
-  (wisi-validate-cache (point-min) (point-max) t 'navigate)
-  (ada-wisi-goto-declaration-start-1 include-type))
-
-(defun ada-wisi-goto-declaration-start-1 (include-type)
-  "Subroutine of `ada-wisi-goto-declaration-start'."
-  (let ((start (point))
-       (cache (wisi-get-cache (point)))
-       (done nil))
-    (unless cache
-      (setq cache (wisi-backward-cache)))
-    ;; cache is null at bob
-    (while (not done)
-      (if cache
-         (progn
-           (setq done
-                 (cl-case (wisi-cache-nonterm cache)
-                   ((entry_body entry_declaration)
-                    (eq (wisi-cache-token cache) 'ENTRY))
-
-                   (full_type_declaration
-                    (when include-type
-                      (eq (wisi-cache-token cache) 'TYPE)))
-
-                   ((generic_package_declaration 
generic_subprogram_declaration)
-                    (eq (wisi-cache-token cache) 'GENERIC))
-
-                   ((package_body package_declaration)
-                    (eq (wisi-cache-token cache) 'PACKAGE))
-
-                   ((protected_body protected_type_declaration 
single_protected_declaration)
-                    (eq (wisi-cache-token cache) 'PROTECTED))
-
-                   ((abstract_subprogram_declaration
-                     expression_function_declaration
-                     subprogram_body
-                     subprogram_declaration
-                     subprogram_renaming_declaration
-                     null_procedure_declaration)
-                    (memq (wisi-cache-token cache) '(NOT OVERRIDING FUNCTION 
PROCEDURE)))
-
-                   ((single_task_declaration task_body task_type_declaration)
-                    (eq (wisi-cache-token cache) 'TASK))
-
-                   ))
-           (unless (< start (wisi-cache-end cache))
-             ;; found declaration does not include start; find containing one.
-             (setq done nil))
-           (unless done
-             (setq cache (wisi-goto-containing cache nil))))
-       (setq done t))
-       )
-    cache))
-
-(defun ada-wisi-goto-declaration-end ()
-  "For `ada-goto-declaration-end', which see."
-  ;; first goto-declaration-start, so we get the right end, not just
-  ;; the current statement end.
-  (wisi-goto-end-1 (ada-wisi-goto-declaration-start)))
-
-(defun ada-wisi-goto-declarative-region-start ()
-  "For `ada-goto-declarative-region-start', which see."
-  (wisi-validate-cache (point-min) (point-max) t 'navigate)
-
-  (let ((done nil)
-       start-pos
-       (in-package-spec nil)
-       (cache (or (wisi-get-cache (point))
-                  (wisi-backward-cache))))
-
-    ;; We use backward-cache, not forward-cache, to handle the case
-    ;; where point is in the whitespace or comment before a block; we
-    ;; want the containing block, not the next block.
-
-    (when cache ;; nil at bob
-      ;; If this is called with point in a comment after 'is', then the
-      ;; declarative region starts after the comment; don't hang in a
-      ;; package spec.
-      (setq start-pos (point))
-      (while (not done)
-       (if (and (or (not in-package-spec)
-                    (< (point) start-pos))
-                (ada-wisi-declarative-region-start-p cache))
-           (progn
-             (forward-word);; past 'is'
-             (setq done t))
-         (cl-case (wisi-cache-class cache)
-           (motion
-            (setq cache (wisi-goto-containing cache)));; statement-start
-
-           (statement-end
-            (setq cache (wisi-goto-containing cache)) ;; statement-start
-            (cl-case (wisi-cache-nonterm cache)
-              ((generic_package_declaration
-                package_declaration
-                entry_body package_body package_declaration protected_body 
subprogram_body task_body
-                protected_type_declaration single_protected_declaration 
single_task_declaration task_type_declaration)
-               ;; This is a block scope before the starting point; we want the 
containing scope
-               (setq cache (wisi-goto-containing cache)))
-
-              (t
-               nil)
-              ))
-
-           (statement-start
-            (cl-case (wisi-cache-nonterm cache)
-              (generic_package_declaration
-               (setq in-package-spec t)
-               (setq cache (wisi-next-statement-cache cache)) ;; 'package'
-               (setq cache (wisi-next-statement-cache cache))) ;; 'is'
-
-              (package_declaration
-               (setq in-package-spec t)
-               (setq cache (wisi-next-statement-cache cache))) ;; 'is'
-
-              ((entry_body package_body package_declaration protected_body 
subprogram_body task_body)
-               (while (not (eq 'IS (wisi-cache-token cache)))
-                 (setq cache (wisi-next-statement-cache cache))))
-
-              ((protected_type_declaration single_protected_declaration 
single_task_declaration task_type_declaration)
-               (while (not (eq 'IS (wisi-cache-token cache)))
-                 (setq cache (wisi-next-statement-cache cache)))
-               (when (looking-at "\<new\>")
-                 (while (not (eq 'WITH (wisi-cache-token cache)))
-                   (setq cache (wisi-next-statement-cache cache)))))
-
-              (t
-               (setq cache (wisi-goto-containing cache t)))
-              ))
-
-           (t
-            (setq cache (wisi-goto-containing cache t)))
-           )))
-
-      ;; point is at start of first code statement after
-      ;; declaration-start keyword and comment; move back to end of
-      ;; keyword.
-      (while (forward-comment -1))
-      )))
-
-(defun ada-wisi-in-paramlist-p (&optional parse-result)
-  "For `ada-in-paramlist-p'."
-  (wisi-validate-cache (point-min) (point-max) nil 'navigate)
-  ;; (info "(elisp)Parser State" "*syntax-ppss*")
-  (let ((parse-result (or parse-result (syntax-ppss)))
-        cache)
-    (and (> (nth 0 parse-result) 0)
-        ;; cache is nil if the parse failed
-        (setq cache (wisi-get-cache (nth 1 parse-result)))
-        (eq 'formal_part (wisi-cache-nonterm cache)))
-    ))
-
-(defun ada-wisi-refactor (action)
-  (wisi-validate-cache (line-end-position -7) (line-end-position 7) t 
'navigate)
-  (save-excursion
-    (skip-syntax-backward "w_.\"")
-    (let* ((edit-begin (point))
-          (cache (wisi-goto-statement-start))
-          (parse-begin (point))
-          (parse-end (wisi-cache-end cache)))
-      (if parse-end
-         (setq parse-end (+ parse-end (wisi-cache-last (wisi-get-cache 
(wisi-cache-end cache)))))
-       ;; else there is a syntax error; missing end of statement
-       (setq parse-end (point-max)))
-      (wisi-refactor wisi--parser action parse-begin parse-end edit-begin)
-      )))
-
-(defun ada-wisi-refactor-1 ()
-  "Refactor Method (Object) => Object.Method.
-Point must be in Method."
-  (interactive)
-  (ada-wisi-refactor ada-refactor-method-object-to-object-method))
-
-(defun ada-wisi-refactor-2 ()
-  "Refactor Object.Method => Method (Object).
-Point must be in Object.Method."
-  (interactive)
-  (ada-wisi-refactor ada-refactor-object-method-to-method-object))
-
-(defun ada-wisi-refactor-3 ()
-  "Refactor Element (Object, Index) => Object (Index).
-Point must be in Element"
-  (interactive)
-  (ada-wisi-refactor ada-refactor-element-object-to-object-index))
-
-(defun ada-wisi-refactor-4 ()
-  "Refactor Object (Index) => Element (Object, Index).
-Point must be in Object"
-  (interactive)
-  (ada-wisi-refactor ada-refactor-object-index-to-element-object))
-
-(defun ada-wisi-make-subprogram-body ()
-  "For `ada-make-subprogram-body'."
-  ;; point is at start of subprogram specification;
-  ;; ada-wisi-expand-region will find the terminal semicolon.
-  (wisi-validate-cache (point-min) (point-max) t 'navigate)
-
-  (let* ((begin (point))
-        (end (wisi-cache-end (wisi-get-cache (point))))
-        (name (wisi-next-name)))
-    (goto-char end)
-    (newline)
-    (insert " is begin\n\nend ");; legal syntax; parse does not fail
-    (insert name)
-    (forward-char 1)
-
-    ;; newline after body to separate from next body
-    (newline-and-indent)
-    (indent-region begin (point))
-    (forward-line -2)
-    (back-to-indentation)
-    ))
-
-(defun ada-wisi-which-function-1 (keyword add-body)
-  "Used in `ada-wisi-which-function'."
-  (let* ((result (wisi-next-name)))
-
-    ;; See comment in ada-mode.el ada-which-function on why we don't
-    ;; overwrite ff-function-name.
-    (when (not ff-function-name)
-      (setq ff-function-name
-           (concat
-            keyword
-            (when add-body "\\s-+body")
-            "\\s-+"
-            result
-            ada-symbol-end)))
-    result))
-
-(defun ada-wisi-which-function (include-type)
-  "For `ada-which-function'."
-  ;; Fail gracefully and silently, since this could be called from
-  ;; which-function-mode.
-  (let ((parse-begin (max (point-min) (- (point) (/ ada-which-func-parse-size 
2))))
-       (parse-end   (min (point-max) (+ (point) (/ ada-which-func-parse-size 
2)))))
-    (save-excursion
-      (condition-case nil
-         ;; Throwing an error here disables which-function-mode, so don't do 
it.
-         (progn
-           (wisi-validate-cache parse-begin parse-end nil 'navigate)
-           (when (wisi-cache-covers-region parse-begin parse-end 'navigate)
-             (let ((result nil)
-                   (cache (ada-wisi-goto-declaration-start-1 include-type)))
-               (if (null cache)
-                   ;; bob or failed parse
-                   (setq result "")
-
-                 (when (memq (wisi-cache-nonterm cache)
-                             '(generic_package_declaration 
generic_subprogram_declaration))
-                   ;; name is after next statement keyword
-                   (setq cache (wisi-next-statement-cache cache)))
-
-                 ;; add or delete 'body' as needed
-                 (cl-ecase (wisi-cache-nonterm cache)
-                   ((entry_body entry_declaration)
-                    (setq result (ada-wisi-which-function-1 "entry" nil)))
-
-                   (full_type_declaration
-                    (setq result (ada-wisi-which-function-1 "type" nil)))
-
-                   (package_body
-                    (setq result (ada-wisi-which-function-1 "package" nil)))
-
-                   ((package_declaration
-                     package_specification) ;; after 'generic'
-                    (setq result (ada-wisi-which-function-1 "package" t)))
-
-                   (protected_body
-                    (setq result (ada-wisi-which-function-1 "protected" nil)))
-
-                   ((protected_type_declaration single_protected_declaration)
-                    (setq result (ada-wisi-which-function-1 "protected" t)))
-
-                   ((abstract_subprogram_declaration
-                     expression_function_declaration
-                     subprogram_declaration
-                     subprogram_renaming_declaration
-                     generic_subprogram_declaration ;; after 'generic'
-                     null_procedure_declaration)
-                    (setq result (ada-wisi-which-function-1
-                                  (progn (search-forward-regexp 
"function\\|procedure")(match-string 0))
-                                  nil))) ;; no 'body' keyword in subprogram 
bodies
-
-                   (subprogram_body
-                    (setq result (ada-wisi-which-function-1
-                                  (progn (search-forward-regexp 
"function\\|procedure")(match-string 0))
-                                  nil)))
-
-                   ((single_task_declaration task_type_declaration)
-                    (setq result (ada-wisi-which-function-1 "task" t)))
-
-
-                   (task_body
-                    (setq result (ada-wisi-which-function-1 "task" nil)))
-                   ))
-               result)))
-       (error "")))
-    ))
-
-(cl-defstruct (ada-wisi-parser (:include wisi-process--parser))
-  ;; no new slots
-  )
-
-(cl-defmethod wisi-parse-format-language-options ((_parser ada-wisi-parser))
-  (format "%d %d %d %d %d %d %d %d %d %d %d %d %d"
-         ada-indent
-         ada-indent-broken
-         (if ada-indent-comment-col-0 1 0)
-         (if ada-indent-comment-gnat 1 0)
-         ada-indent-label
-         ada-indent-record-rel-type
-         ada-indent-renames
-         ada-indent-return
-         ada-indent-use
-         ada-indent-when
-         ada-indent-with
-         (if ada-indent-hanging-rel-exp 1 0)
-         (if ada-end-name-optional 1 0)
-         ))
-
-(defconst ada-wisi-named-begin-regexp
-  "\\bfunction\\b\\|\\bpackage\\b\\|\\bprocedure\\b\\|\\btask\\b"
-  )
-
-(defconst ada-wisi-partial-begin-regexp
-  (concat "\\bbegin\\b\\|\\bdeclare\\b\\|"
-         ada-wisi-named-begin-regexp
-         "\\|\\bend;\\|\\bend " ada-name-regexp ";"))
-
-(defconst ada-wisi-partial-end-regexp
-  (concat ada-wisi-partial-begin-regexp
-         "\\|;"))
-
-(defun ada-wisi-find-begin ()
-  "Starting at current point, search backward for a parse start point."
-
-  ;; There is a trade-off in deciding where to start parsing for indent. If we 
have:
-  ;;
-  ;; procedure ...
-  ;; is
-  ;;
-  ;; and are inserting a new line after 'is', we need to include
-  ;; 'is' in the parse to see the indent. On the other hand, if we
-  ;; have:
-  ;;
-  ;;    ...
-  ;;    end;
-  ;; begin
-  ;;    Foo;
-  ;;
-  ;; Inserting new line after 'Foo;'; if we include 'begin', there
-  ;; is no error (begin starts a statement), and the indent is
-  ;; computed incorrectly.
-  ;;
-  ;; This is handled by the set of keywords in
-  ;; ada-wisi-partial-begin-regexp.
-  (cond
-   ((wisi-search-backward-skip
-     ada-wisi-partial-begin-regexp
-     (lambda () (or (ada-in-string-or-comment-p)
-                   (looking-back "access " (line-beginning-position)))))
-     ;; "access" rejects subprobram access parameters; 
test/ada_mode-recover_partial_20.adb
-
-    (let ((found (match-string 0))
-         cache)
-      (cond
-       ((and (>= (length found) 3)
-            (string-equal "end" (substring found 0 3)))
-       (match-end 0))
-
-       (t
-       (setq cache (wisi-get-cache (point)))
-       (when cache
-         ;; This distinguishes 'begin' as a statement start from
-         ;; 'begin' following 'declare', 'procedure' etc.  We don't
-         ;; force a parse to get this; the user may choose to do so.
-         (wisi-goto-start cache))
-       (point))
-       )))
-
-   (t
-    (point-min))
-   ))
-
-(defun ada-wisi-find-end ()
-  "Starting at current point, search forward for a reasonable parse end point."
-  (forward-comment (point-max)) ;; get past any current comments
-  (forward-line 1) ;; contain at least some code (see 
ada_mode-partial_parse.adb 'blank line before "end"')
-
-  (let ((start (point))
-       match
-       (end-cand nil))
-
-    (while (not end-cand)
-      (if (search-forward-regexp ada-wisi-partial-end-regexp nil 1) ;; moves 
to eob if not found
-         (unless (or (ada-in-string-or-comment-p)
-                     (ada-in-paren-p))
-           (setq match t)
-           (setq end-cand (point)))
-
-       ;; No reasonable end point found (maybe a missing right
-       ;; paren); return line after start for minimal parse, compute
-       ;; indent for line containing start.
-       (setq match nil)
-       (goto-char start)
-       (setq end-cand (line-end-position 2)))
-      )
-
-    (when (and match
-              (not (string-equal ";" (match-string 0))))
-      (setq end-cand (match-beginning 0)))
-
-    end-cand))
-
-(defun ada-wisi-find-matching-end ()
-  "Starting at current point, search forward for a matching end.
-Point must have been set by `ada-wisi-find-begin'."
-  (let (end-regexp)
-    ;; Point is at bol
-    (back-to-indentation)
-    (when (looking-at ada-wisi-named-begin-regexp)
-      (skip-syntax-forward "ws")
-      (skip-syntax-forward " ")
-      (when (looking-at "body\\|type")
-       (goto-char (match-end 0))
-       (skip-syntax-forward " "))
-      (setq end-regexp
-           (concat "end +"
-                   (buffer-substring-no-properties
-                    (point)
-                    (progn
-                      (skip-syntax-forward "ws._")
-                      (point)))
-                   ";"))
-      (if (search-forward-regexp end-regexp nil t)
-         (progn
-           (while (and (ada-in-string-or-comment-p)
-                       (search-forward-regexp end-regexp nil t)))
-           (point))
-
-       ;; matching end not found
-       nil)
-      )))
-
-(cl-defmethod wisi-parse-expand-region ((_parser ada-wisi-parser) begin end)
-  (let (begin-cand end-cand result)
-    (save-excursion
-      (goto-char begin)
-
-      (setq begin-cand (ada-wisi-find-begin))
-      (if (= begin-cand (point-min)) ;; No code between BEGIN and bob
-         (progn
-           (goto-char end)
-           (setq result (cons begin-cand (ada-wisi-find-end))))
-
-       (setq end-cand (ada-wisi-find-matching-end))
-       (if (and end-cand
-                (>= end-cand end))
-           (setq result (cons begin-cand end-cand))
-         (goto-char end)
-         (setq result (cons begin-cand (ada-wisi-find-end))))
-
-       ))
-    result))
-
-(cl-defmethod wisi-parse-adjust-indent ((_parser ada-wisi-parser) indent 
repair)
-  (cond
-   ((or (wisi-list-memq (wisi--parse-error-repair-inserted repair) '(BEGIN IF 
LOOP))
-       (wisi-list-memq (wisi--parse-error-repair-deleted repair) '(END)))
-    ;; Error token terminates the block containing the start token
-    (- indent ada-indent))
-
-   ((equal '(CASE IS) (wisi--parse-error-repair-inserted repair))
-        (- indent (+ ada-indent ada-indent-when)))
-
-   ((equal '(END CASE SEMICOLON) (wisi--parse-error-repair-inserted repair))
-        (+ indent (+ ada-indent ada-indent-when)))
-
-   (t indent)
-   ))
-
-(defvar ada-parser nil) ;; declared, set in ada-mode.el for parser detection
-
-(defun ada-wisi-setup ()
-  "Set up a buffer for parsing Ada files with wisi."
-  (add-hook 'ada-fix-error-hook #'ada-wisi-fix-error)
-
-  (wisi-setup
-   :indent-calculate '(ada-wisi-comment)
-   :post-indent-fail 'ada-wisi-post-parse-fail
-   :parser
-   (wisi-process-parse-get
-    (make-ada-wisi-parser
-     :label "Ada"
-     :language-protocol-version ada-wisi-language-protocol-version
-     :exec-file ada-process-parse-exec
-     :exec-opts ada-process-parse-exec-opts
-     :face-table ada-process-face-table
-     :token-table ada-process-token-table
-     :repair-image ada-process-repair-image)))
-
-  (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-post-local-vars ()
-  "See wisi-setup."
-  (setq hack-local-variables-hook (delq 'ada-wisi-post-local-vars 
hack-local-variables-hook))
-
-  (setq wisi-indent-comment-col-0 ada-indent-comment-col-0)
-  )
-
-(add-hook 'ada-mode-hook 'ada-wisi-setup)
-
-(setq ada-fix-context-clause 'ada-wisi-context-clause)
-(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-statement-end)
-(setq ada-goto-subunit-name 'ada-wisi-goto-subunit-name)
-(setq ada-in-case-expression 'ada-wisi-in-case-expression)
-(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-on-context-clause 'ada-wisi-on-context-clause)
-(setq ada-reset-parser 'wisi-reset-parser)
-(setq ada-show-parse-error 'wisi-show-parse-error)
-(setq ada-which-function 'ada-wisi-which-function)
-
-(provide 'ada-wisi)
-;; end of file
diff --git a/packages/ada-mode/ada-xref.el b/packages/ada-mode/ada-xref.el
deleted file mode 100644
index 6816d8a..0000000
--- a/packages/ada-mode/ada-xref.el
+++ /dev/null
@@ -1,5 +0,0 @@
-;;; ada-xref.el --- Dummy file to hide obsolete bundled version  -*- 
lexical-binding:t -*-
-;;; see xref-ada.el for Emacs 25 xref minor mode for ada-mode
-(require 'ada-mode)
-(provide 'ada-xref)
-(message "'ada-xref' is obsolete; use 'ada-mode' instead")
diff --git a/packages/ada-mode/ada.wy b/packages/ada-mode/ada.wy
index dcdd709..415d727 100644
--- a/packages/ada-mode/ada.wy
+++ b/packages/ada-mode/ada.wy
@@ -121,6 +121,7 @@
 %token <right-paren> RIGHT_PAREN ")"
 
 %token <punctuation> AMPERSAND "&"
+%token <punctuation> AT_SIGN "@"
 %token <punctuation> BAR "|"
 %token <punctuation> BOX "<>"
 %token <punctuation> COLON ":"
@@ -258,7 +259,7 @@
 ;; Error recovery will insert 'end if;', after push_back or
 ;; undo_reduce of the handled_sequence_of_statements including
 ;; 'statement'. If it uses push_back, then 'end if;' is before
-;; 'statement'; if undo_reduce, after, which is the desired result.;;
+;; 'statement'; if undo_reduce, after, which is the desired result.
 %mckenzie_cost_undo_reduce handled_sequence_of_statements 0
 %mckenzie_cost_undo_reduce sequence_of_statements 0
 %mckenzie_cost_undo_reduce sequence_of_statements_opt 0
@@ -283,21 +284,19 @@
 ;; known conflicts that are resolved by generalized LALR parser
 %conflict REDUCE/REDUCE in state abstract_limited_opt, 
abstract_limited_synchronized_opt on token NEW
 %conflict REDUCE/REDUCE in state actual_parameter_part, actual_parameter_part  
on token RIGHT_PAREN
-%conflict REDUCE/REDUCE in state aggregate, aggregate on token RIGHT_PAREN ( 
580)
+%conflict REDUCE/REDUCE in state aggregate, aggregate on token RIGHT_PAREN
 %conflict REDUCE/REDUCE in state association_opt, expression_opt on token 
RIGHT_PAREN
 %conflict REDUCE/REDUCE in state derived_type_definition, 
derived_type_definition  on token WITH
 %conflict REDUCE/REDUCE in state full_type_declaration, full_type_declaration  
on token NEW
 %conflict REDUCE/REDUCE in state identifier_list, name on token COMMA
 %conflict REDUCE/REDUCE in state name, direct_name on token USE
 %conflict REDUCE/REDUCE in state primary, subtype_indication on token COMMA
-%if parser = LALR
-%conflict REDUCE/REDUCE in state primary, subtype_indication on token 
EQUAL_GREATER
-%end if
 %conflict REDUCE/REDUCE in state primary, subtype_indication on token 
RIGHT_PAREN
 %conflict REDUCE/REDUCE in state range_list, discrete_subtype_definition on 
token COMMA
 %conflict REDUCE/REDUCE in state range_list, discrete_subtype_definition on 
token RIGHT_PAREN
 %conflict SHIFT/REDUCE in state abstract_subprogram_declaration, 
abstract_subprogram_declaration  on token IS
 %conflict SHIFT/REDUCE in state accept_statement, accept_statement  on token 
LEFT_PAREN
+%conflict SHIFT/REDUCE in state aggregate, expression_opt on token WITH
 %conflict SHIFT/REDUCE in state aspect_clause, name on token USE
 %conflict SHIFT/REDUCE in state association_opt, name on token EQUAL_GREATER
 %conflict SHIFT/REDUCE in state attribute_designator, attribute_designator  on 
token LEFT_PAREN
@@ -325,6 +324,10 @@
 %conflict SHIFT/REDUCE in state task_body, task_body  on token IS
 %conflict SHIFT/REDUCE in state wisitoken_accept, wisitoken_accept  on token 
FOR
 
+%if parser = LALR
+%conflict REDUCE/REDUCE in state primary, subtype_indication on token 
EQUAL_GREATER
+%end if
+
 ;;;; grammar rules
 ;;
 ;; The actions cache information in keywords that are significant for
@@ -377,25 +380,22 @@ abstract_tagged_limited_opt
 
 abstract_subprogram_declaration
   : overriding_indicator_opt subprogram_specification IS ABSTRACT 
aspect_specification_opt SEMICOLON
-    %((progn
-      (wisi-statement-action [1 statement-start 2 statement-override 6 
statement-end])
-      (wisi-indent-action [nil nil ada-indent-broken ada-indent-broken nil 
nil])))%
+    %((wisi-statement-action [1 statement-start 2 statement-override 6 
statement-end])
+      (wisi-indent-action [nil nil ada-indent-broken ada-indent-broken nil 
nil]))%
   ;
 
 accept_statement
   : ACCEPT IDENTIFIER actual_parameter_part_opt parameter_profile_opt DO 
handled_sequence_of_statements END identifier_opt SEMICOLON
-    %((progn
-      (wisi-statement-action [1 statement-start 5 motion 9 statement-end])
+    %((wisi-statement-action [1 statement-start 5 motion 9 statement-end])
       (wisi-motion-action [1 5 [6 WHEN] 9])
       (wisi-face-apply-action [2 nil font-lock-function-name-face 8 nil 
font-lock-function-name-face])
-      (wisi-indent-action [nil ada-indent-broken ada-indent-broken 
ada-indent-broken [nil ada-indent] [ada-indent ada-indent] nil nil nil])))%
+      (wisi-indent-action [nil ada-indent-broken ada-indent-broken 
ada-indent-broken [nil ada-indent] [ada-indent ada-indent] nil nil nil]))%
     %((wisi-match-names 2 8))%
 
   | ACCEPT IDENTIFIER actual_parameter_part_opt parameter_profile_opt SEMICOLON
-    %((progn
-      (wisi-statement-action [1 statement-start 5 statement-end])
+    %((wisi-statement-action [1 statement-start 5 statement-end])
       (wisi-face-apply-action [2 nil font-lock-function-name-face])
-      (wisi-indent-action [nil ada-indent-broken ada-indent-broken 
ada-indent-broken nil])))%
+      (wisi-indent-action [nil ada-indent-broken ada-indent-broken 
ada-indent-broken nil]))%
   ;
 
 ;; same as access_type_definition for our purposes
@@ -442,6 +442,10 @@ aggregate
     %((wisi-indent-action [nil (wisi-anchored 1 1) (wisi-anchored 1 1) 
[(wisi-anchored 1 1) (wisi-anchored 1 1)]
                          (wisi-anchored 1 0)]))%
   | LEFT_PAREN NULL RECORD RIGHT_PAREN
+  | LEFT_PAREN expression WITH DELTA association_list RIGHT_PAREN ;; 
record_delta_aggregate, array_delta_aggregate
+    %((wisi-indent-action [nil (wisi-anchored 1 1) (wisi-anchored 1 1) 
(wisi-anchored 1 1)  
+                               [(wisi-anchored 1 1) (wisi-anchored 1 1)]
+                               (wisi-anchored 1 0)]))%
 
  ;; ARM 4.5.7(7), ARM 4.5.8(4) allow ( conditional|quantified_expression ) 
instead of (( ... ))
   | LEFT_PAREN conditional_quantified_expression RIGHT_PAREN
@@ -472,7 +476,8 @@ array_type_definition
 
 aspect_clause
   : FOR attribute_reference USE expression_opt SEMICOLON ;; 
attribute_definition_clause
-    %((wisi-statement-action [1 statement-start 5 statement-end]))%
+    %((wisi-statement-action [1 statement-start 5 statement-end])
+        (wisi-indent-action [nil ada-indent-broken ada-indent-broken 
ada-indent-broken nil]))%
   | enumeration_representation_clause
   | record_representation_clause
   | at_clause
@@ -491,14 +496,13 @@ aspect_specification_opt
 
 assignment_statement
   : name COLON_EQUAL expression_opt SEMICOLON
-    %((progn
-      (wisi-statement-action [1 statement-start 4 statement-end])
+    %((wisi-statement-action [1 statement-start 4 statement-end])
       (wisi-indent-action [nil
                            ada-indent-broken
                            (wisi-hanging
                             (wisi-anchored% 2 ada-indent-broken)
                             (wisi-anchored% 3 ada-indent-broken))
-                           nil])))%
+                           nil]))%
   ;
 
 association_opt
@@ -530,6 +534,9 @@ association_opt
                                             (wisi-anchored% 2 (* 2 
ada-indent-broken)))]]))%
   | discrete_choice_list EQUAL_GREATER BOX
     %((wisi-indent-action [(wisi-hanging nil ada-indent-broken) 
ada-indent-broken nil]))%
+  | FOR IDENTIFIER IN discrete_choice_list EQUAL_GREATER expression ;; 
iterated_component_association
+    %((wisi-indent-action [nil nil nil (wisi-hanging nil ada-indent-broken) 
ada-indent-broken
+                               [(wisi-hanging nil ada-indent-broken) 
(wisi-hanging nil ada-indent-broken)]]))%
   | expression
  ;; test/ada_mode-parens.adb Hello
     %((wisi-indent-action [[(wisi-hanging nil ada-indent-broken) (wisi-hanging 
nil ada-indent-broken)]]))%
@@ -543,11 +550,10 @@ association_list
 
 asynchronous_select
   : SELECT triggering_alternative THEN ABORT sequence_of_statements_opt END 
SELECT SEMICOLON
-    %((progn
-        (wisi-statement-action [1 statement-start 3 motion 8 statement-end])
+    %((wisi-statement-action [1 statement-start 3 motion 8 statement-end])
         (wisi-motion-action [1 3 8])
         (wisi-indent-action [nil [ada-indent ada-indent] [nil 
ada-indent-broken] ada-indent-broken
-                                 [ada-indent ada-indent] nil nil nil])))%
+                                 [ada-indent ada-indent] nil nil nil]))%
   ;
 
 at_clause
@@ -586,16 +592,14 @@ block_label_opt
 
 block_statement
   : block_label_opt DECLARE declarative_part_opt BEGIN 
handled_sequence_of_statements END identifier_opt SEMICOLON
-    %((progn
-      (wisi-statement-action [1 statement-start 2 motion 4 motion 8 
statement-end])
+    %((wisi-statement-action [1 statement-start 2 motion 4 motion 8 
statement-end])
       (wisi-motion-action [2 4 [5 WHEN] 8])
-      (wisi-indent-action [nil nil [ada-indent ada-indent] nil [ada-indent 
ada-indent] nil nil nil])))%
+      (wisi-indent-action [nil nil [ada-indent ada-indent] nil [ada-indent 
ada-indent] nil nil nil]))%
     %((wisi-match-names 1 7))%
   | block_label_opt BEGIN handled_sequence_of_statements END identifier_opt 
SEMICOLON
-    %((progn
-      (wisi-statement-action [1 statement-start 2 motion 6 statement-end])
+    %((wisi-statement-action [1 statement-start 2 motion 6 statement-end])
       (wisi-motion-action [2 [3 WHEN] 6])
-      (wisi-indent-action [nil nil [ada-indent ada-indent] nil nil nil])))%
+      (wisi-indent-action [nil nil [ada-indent ada-indent] nil nil nil]))%
     %((wisi-match-names 1 5))%
   ;
 
@@ -606,10 +610,9 @@ body_stub
 
 case_expression
   : CASE expression_opt IS case_expression_alternative_list
-    %((progn
-      (wisi-statement-action [1 motion])
+    %((wisi-statement-action [1 motion])
       (wisi-motion-action [1 4])
-      (wisi-indent-action [nil ada-indent-broken nil ada-indent-when])))%
+      (wisi-indent-action [nil ada-indent-broken nil ada-indent-when]))%
   ;
 
 case_expression_alternative
@@ -618,35 +621,30 @@ case_expression_alternative
  ;; when A =>
  ;;    J = 4
  ;;      or else M, --  test case from Piotr Trojanek
-    %((progn
-      (wisi-statement-action [1 motion])
+    %((wisi-statement-action [1 motion])
       (wisi-indent-action [nil ada-indent-broken ada-indent-broken
                            (wisi-hanging (wisi-anchored% 1 ada-indent)
-                                         (wisi-anchored% 1 (+ ada-indent 
ada-indent-broken)))])))%
+                                         (wisi-anchored% 1 (+ ada-indent 
ada-indent-broken)))]))%
   ;
 
 case_expression_alternative_list
   : case_expression_alternative_list COMMA case_expression_alternative
-    %((progn
-        (wisi-motion-action [1 3])
-        (wisi-indent-action [nil [nil ada-indent-when] nil])))%
+    %((wisi-motion-action [1 3]))%
   | case_expression_alternative
   ;
 
 case_statement
   : CASE expression_opt IS case_statement_alternative_list END CASE SEMICOLON
-    %((progn
-      (wisi-statement-action [1 statement-start 7 statement-end])
+    %((wisi-statement-action [1 statement-start 7 statement-end])
       (wisi-motion-action [1 4 7])
-      (wisi-indent-action [nil ada-indent-broken nil [ada-indent-when 
ada-indent-when] nil nil nil])))%
+      (wisi-indent-action [nil ada-indent-broken nil [ada-indent-when 
ada-indent-when] nil nil nil]))%
   ;
 
 case_statement_alternative
   : WHEN discrete_choice_list EQUAL_GREATER sequence_of_statements_opt
-    %((progn
-      (wisi-statement-action [1 motion])
+    %((wisi-statement-action [1 motion])
       ;; ada-indent-when added in case_statement
-      (wisi-indent-action [nil ada-indent-broken ada-indent-broken [ada-indent 
ada-indent]])))%
+      (wisi-indent-action [nil ada-indent-broken ada-indent-broken [ada-indent 
ada-indent]]))%
   ;
 
 ;; We don't allow an empty list here; that leads to parallel parser
@@ -690,9 +688,8 @@ compilation_unit_list
 
 component_clause
   : IDENTIFIER AT simple_expression RANGE simple_expression DOT_DOT 
simple_expression SEMICOLON
-    %((progn
-      (wisi-statement-action [1 statement-start 8 statement-end])
-      (wisi-indent-action [nil nil ada-indent-broken ada-indent-broken 
ada-indent-broken ada-indent-broken ada-indent-broken nil])))%
+    %((wisi-statement-action [1 statement-start 8 statement-end])
+      (wisi-indent-action [nil nil ada-indent-broken ada-indent-broken 
ada-indent-broken ada-indent-broken ada-indent-broken nil]))%
   ;
 
 component_clause_list
@@ -702,15 +699,13 @@ component_clause_list
 
 component_declaration
   : identifier_list COLON component_definition COLON_EQUAL expression_opt 
aspect_specification_opt SEMICOLON
-    %((progn
-      (wisi-statement-action [1 statement-start 7 statement-end])
+    %((wisi-statement-action [1 statement-start 7 statement-end])
       (wisi-indent-action [nil ada-indent-broken ada-indent-broken 
ada-indent-broken
                                (wisi-anchored% 4 ada-indent-broken)
-                               ada-indent-broken nil])))%
+                               ada-indent-broken nil]))%
   | identifier_list COLON component_definition aspect_specification_opt 
SEMICOLON
-    %((progn
-      (wisi-statement-action [1 statement-start 5 statement-end])
-      (wisi-indent-action [nil ada-indent-broken ada-indent-broken 
ada-indent-broken nil])))%
+    %((wisi-statement-action [1 statement-start 5 statement-end])
+      (wisi-indent-action [nil ada-indent-broken ada-indent-broken 
ada-indent-broken nil]))%
   ;
 
 component_definition
@@ -751,10 +746,9 @@ compound_statement
 
 conditional_entry_call
   : SELECT entry_call_alternative ELSE sequence_of_statements_opt END SELECT 
SEMICOLON
-    %((progn
-        (wisi-statement-action [1 statement-start 3 motion 7 statement-end])
+    %((wisi-statement-action [1 statement-start 3 motion 7 statement-end])
         (wisi-motion-action [1 3 7])
-        (wisi-indent-action [nil [ada-indent ada-indent] nil [ada-indent 
ada-indent] nil nil nil])))%
+        (wisi-indent-action [nil [ada-indent ada-indent] nil [ada-indent 
ada-indent] nil nil nil]))%
   ;
 
 conditional_quantified_expression
@@ -794,10 +788,9 @@ declaration
   | generic_instantiation
   | null_procedure_declaration
   | identifier_list COLON CONSTANT COLON_EQUAL expression_opt SEMICOLON ;; 
number_declaration
-    %((progn
-      (wisi-statement-action [1 statement-start 6 statement-end])
+    %((wisi-statement-action [1 statement-start 6 statement-end])
       (wisi-indent-action [(wisi-hanging nil ada-indent-broken) 
ada-indent-broken ada-indent-broken ada-indent-broken
-                           (wisi-anchored% 4 ada-indent-broken) nil])))%
+                           (wisi-anchored% 4 ada-indent-broken) nil]))%
   | object_declaration
   | package_declaration
   | renaming_declaration
@@ -830,18 +823,18 @@ delay_alternative
 
 delay_statement
   : DELAY UNTIL expression_opt SEMICOLON
-    %((progn
-      (wisi-statement-action [1 statement-start 4 statement-end])
-      (wisi-indent-action [nil ada-indent-broken ada-indent-broken nil])))%
+    %((wisi-statement-action [1 statement-start 4 statement-end])
+      (wisi-indent-action [nil ada-indent-broken ada-indent-broken nil]))%
   | DELAY expression_opt SEMICOLON
-    %((progn
-      (wisi-statement-action [1 statement-start 3 statement-end])
-      (wisi-indent-action [nil ada-indent-broken nil])))%
+    %((wisi-statement-action [1 statement-start 3 statement-end])
+      (wisi-indent-action [nil ada-indent-broken nil]))%
   ;
 
 derived_type_definition
   : abstract_limited_opt NEW name and_interface_list_opt WITH record_definition
-    %((wisi-face-apply-action [3 font-lock-function-name-face 
font-lock-type-face]))%
+    %((wisi-face-apply-action [3 font-lock-function-name-face 
font-lock-type-face])
+      ;; comment after 'with' same as 'record'
+      (wisi-indent-action [nil nil nil nil [nil (ada-indent-record* 'TYPE 6 
0)] nil]))%
   | abstract_limited_opt NEW name constraint_opt
     %((wisi-face-apply-action [3 font-lock-function-name-face 
font-lock-type-face]))%
   ;
@@ -902,10 +895,9 @@ discriminant_specification_list
 
 elsif_expression_item
   : ELSIF expression_opt THEN expression_opt
-    %((progn
-        (wisi-statement-action [1 motion 3 motion])
+    %((wisi-statement-action [1 motion 3 motion])
         (wisi-motion-action [1 3])
-        (wisi-indent-action [nil [ada-indent-broken ada-indent-broken] nil 
ada-indent])))%
+        (wisi-indent-action [nil [ada-indent-broken ada-indent-broken] nil 
ada-indent]))%
   ;
 
 elsif_expression_list
@@ -916,10 +908,9 @@ elsif_expression_list
 
 elsif_statement_item
   : ELSIF expression_opt THEN sequence_of_statements_opt
-    %((progn
-      (wisi-statement-action [1 motion 3 motion])
+    %((wisi-statement-action [1 motion 3 motion])
       (wisi-motion-action [1 3])
-      (wisi-indent-action [nil [ada-indent-broken ada-indent-broken] nil 
[ada-indent ada-indent]])))%
+      (wisi-indent-action [nil [ada-indent-broken ada-indent-broken] nil 
[ada-indent ada-indent]]))%
   ;
 
 elsif_statement_list
@@ -931,8 +922,7 @@ elsif_statement_list
 entry_body
   : ENTRY IDENTIFIER entry_body_formal_part WHEN expression_opt
     IS declarative_part_opt BEGIN handled_sequence_of_statements END 
identifier_opt SEMICOLON
-    %((progn
-        (wisi-statement-action [1 statement-start 4 motion 6 motion 8 motion 
12 statement-end])
+    %((wisi-statement-action [1 statement-start 4 motion 6 motion 8 motion 12 
statement-end])
         (wisi-name-action 2)
         (wisi-motion-action [1 4 6 8 [9 WHEN] 12])
         (wisi-face-apply-action [2 nil font-lock-function-name-face 11 nil 
font-lock-function-name-face])
@@ -948,7 +938,7 @@ entry_body
         ;;     (Local_2 = 1)
         (wisi-indent-action [nil ada-indent-broken ada-indent-broken 
ada-indent-broken
                                  (wisi-anchored% 4 ada-indent-broken)
-                                 nil [ada-indent ada-indent] nil [ada-indent 
ada-indent] nil nil nil])))%
+                                 nil [ada-indent ada-indent] nil [ada-indent 
ada-indent] nil nil nil]))%
     %((wisi-match-names 2 11))%
   ;
 
@@ -967,18 +957,16 @@ entry_call_alternative
 entry_declaration
   : overriding_indicator_opt ENTRY IDENTIFIER LEFT_PAREN 
discrete_subtype_definition RIGHT_PAREN
     parameter_profile_opt aspect_specification_opt SEMICOLON
-    %((progn
-        (wisi-statement-action [1 statement-start 2 statement-override 8 
statement-end])
+    %((wisi-statement-action [1 statement-start 2 statement-override 8 
statement-end])
         (wisi-name-action 3)
         (wisi-face-apply-action [3 nil font-lock-function-name-face])
         (wisi-indent-action [nil nil ada-indent-broken ada-indent-broken 
(wisi-anchored 4 1) (wisi-anchored 4 0)
-                               ada-indent-broken nil nil])))%
+                               ada-indent-broken nil nil]))%
   | overriding_indicator_opt ENTRY IDENTIFIER parameter_profile_opt 
aspect_specification_opt SEMICOLON
-    %((progn
-        (wisi-statement-action [1 statement-start 2 statement-override 6 
statement-end])
+    %((wisi-statement-action [1 statement-start 2 statement-override 6 
statement-end])
         (wisi-name-action 3)
         (wisi-face-apply-action [3 nil font-lock-function-name-face])
-        (wisi-indent-action [nil nil ada-indent-broken ada-indent-broken 
ada-indent-broken nil])))%
+        (wisi-indent-action [nil nil ada-indent-broken ada-indent-broken 
ada-indent-broken nil]))%
   ;
 
 enumeration_literal ;; enumeration_literal_specification
@@ -993,10 +981,9 @@ enumeration_literal_list
 
 enumeration_representation_clause
   : FOR name USE aggregate SEMICOLON
-    %((progn
-      (wisi-statement-action [1 statement-start 5 statement-end])
+    %((wisi-statement-action [1 statement-start 5 statement-end])
       (wisi-face-apply-action [2 font-lock-function-name-face 
font-lock-type-face])
-      (wisi-indent-action [nil ada-indent-broken ada-indent-broken 
ada-indent-broken nil])))%
+      (wisi-indent-action [nil ada-indent-broken ada-indent-broken 
ada-indent-broken nil]))%
   ;
 
 enumeration_type_definition
@@ -1020,14 +1007,12 @@ exception_declaration
 exception_handler
   : WHEN IDENTIFIER COLON exception_choice_list EQUAL_GREATER
     sequence_of_statements_opt
-    %((progn
-      (wisi-statement-action [1 motion])
+    %((wisi-statement-action [1 motion])
       (wisi-indent-action [nil ada-indent-broken ada-indent-broken 
ada-indent-broken ada-indent-broken
-                             [ada-indent ada-indent]])))%
+                             [ada-indent ada-indent]]))%
   | WHEN exception_choice_list EQUAL_GREATER sequence_of_statements_opt
-    %((progn
-      (wisi-statement-action [1 motion])
-      (wisi-indent-action [nil ada-indent-broken ada-indent-broken [ada-indent 
ada-indent]])))%
+    %((wisi-statement-action [1 motion])
+      (wisi-indent-action [nil ada-indent-broken ada-indent-broken [ada-indent 
ada-indent]]))%
   ;
 
 exception_handler_list
@@ -1044,9 +1029,8 @@ exception_handler_list_opt
 
 exit_statement
   : EXIT identifier_opt WHEN expression_opt SEMICOLON
-    %((progn
-      (wisi-statement-action [1 statement-start 5 statement-end])
-      (wisi-indent-action [nil nil nil ada-indent-broken nil])))%
+    %((wisi-statement-action [1 statement-start 5 statement-end])
+      (wisi-indent-action [nil nil nil ada-indent-broken nil]))%
   | EXIT identifier_opt SEMICOLON
     %((wisi-statement-action [1 statement-start 3 statement-end]))%
   ;
@@ -1069,9 +1053,8 @@ expression_function_declaration
   : overriding_indicator_opt function_specification IS paren_expression 
aspect_specification_opt SEMICOLON
  ;; IS does not start a block, so it is not "motion".
  ;;
-    %((progn
-      (wisi-statement-action [1 statement-start 2 statement-override 6 
statement-end])
-      (wisi-indent-action [nil nil ada-indent-broken ada-indent-broken 
ada-indent-broken nil])))%
+    %((wisi-statement-action [1 statement-start 2 statement-override 6 
statement-end])
+      (wisi-indent-action [nil nil ada-indent-broken ada-indent-broken 
ada-indent-broken nil]))%
   ;
 
 extended_return_object_declaration
@@ -1089,13 +1072,11 @@ extended_return_object_declaration_opt
 
 extended_return_statement
   : RETURN extended_return_object_declaration_opt DO 
handled_sequence_of_statements END RETURN SEMICOLON
-    %((progn
-      (wisi-statement-action [1 statement-start 3 motion 7 statement-end])
+    %((wisi-statement-action [1 statement-start 3 motion 7 statement-end])
       (wisi-motion-action [1 3 [4 WHEN] 7])
-      (wisi-indent-action [[nil ada-indent] ada-indent-broken nil [ada-indent 
ada-indent] nil nil nil])))%
+      (wisi-indent-action [[nil ada-indent] ada-indent-broken nil [ada-indent 
ada-indent] nil nil nil]))%
   | RETURN extended_return_object_declaration SEMICOLON
-    %((progn
-      (wisi-statement-action [1 statement-start 3 statement-end])))%
+    %((wisi-statement-action [1 statement-start 3 statement-end]))%
       ;; indent the same as a simple return statment
       ;; test/ada_mode-nominal.adb
       ;; return B : Integer :=
@@ -1115,78 +1096,66 @@ factor
 formal_object_declaration
   : identifier_list COLON mode_opt null_exclusion_opt name COLON_EQUAL
     expression_opt aspect_specification_opt SEMICOLON
-    %((progn
-      (wisi-statement-action [1 statement-start 9 statement-end])
+    %((wisi-statement-action [1 statement-start 9 statement-end])
       (wisi-face-apply-action [5 font-lock-function-name-face 
font-lock-type-face])
       (wisi-indent-action [nil ada-indent-broken ada-indent-broken 
ada-indent-broken ada-indent-broken ada-indent-broken
-                             (wisi-anchored% 6 ada-indent-broken) 
ada-indent-broken nil])))%
+                             (wisi-anchored% 6 ada-indent-broken) 
ada-indent-broken nil]))%
   | identifier_list COLON mode_opt access_definition COLON_EQUAL
     expression_opt aspect_specification_opt SEMICOLON
-    %((progn
-      (wisi-statement-action [1 statement-start 8 statement-end])
+    %((wisi-statement-action [1 statement-start 8 statement-end])
       (wisi-indent-action [nil ada-indent-broken ada-indent-broken 
ada-indent-broken ada-indent-broken
-                             (wisi-anchored% 5 ada-indent-broken) 
ada-indent-broken nil])))%
+                             (wisi-anchored% 5 ada-indent-broken) 
ada-indent-broken nil]))%
   | identifier_list COLON mode_opt null_exclusion_opt name 
aspect_specification_opt SEMICOLON
-    %((progn
-      (wisi-statement-action [1 statement-start 7 statement-end])
+    %((wisi-statement-action [1 statement-start 7 statement-end])
       (wisi-face-apply-action [5 font-lock-function-name-face 
font-lock-type-face])
       (wisi-indent-action [nil ada-indent-broken ada-indent-broken 
ada-indent-broken ada-indent-broken
-                               ada-indent-broken nil])))%
+                               ada-indent-broken nil]))%
   | identifier_list COLON mode_opt access_definition aspect_specification_opt 
SEMICOLON
-    %((progn
-      (wisi-statement-action [1 statement-start 6 statement-end])
-      (wisi-indent-action [nil ada-indent-broken ada-indent-broken 
ada-indent-broken ada-indent-broken nil])))%
+    %((wisi-statement-action [1 statement-start 6 statement-end])
+      (wisi-indent-action [nil ada-indent-broken ada-indent-broken 
ada-indent-broken ada-indent-broken nil]))%
   ;
 
 formal_part
   : LEFT_PAREN parameter_specification_list RIGHT_PAREN
-    %((progn
-      (wisi-statement-action [1 misc]) ;; for ada-wisi-in-paramlist-p
-      (wisi-indent-action [nil (wisi-anchored 1 1) (wisi-anchored 1 0)])))%
+    %((wisi-statement-action [1 misc]) ;; for ada-wisi-in-paramlist-p, 
ada-goto-declarative-region-start
+      (wisi-indent-action [nil (wisi-anchored 1 1) (wisi-anchored 1 0)]))%
   ;
 
 formal_subprogram_declaration
   : WITH subprogram_specification IS ABSTRACT subprogram_default 
aspect_specification_opt SEMICOLON
  ;; formal_abstract_subprogram_declaration
-    %((progn
-      (wisi-statement-action [1 statement-start 7 statement-end])
-      (wisi-indent-action [nil nil ada-indent-broken ada-indent-broken 
ada-indent-broken ada-indent-broken nil])))%
+    %((wisi-statement-action [1 statement-start 7 statement-end])
+      (wisi-indent-action [nil nil ada-indent-broken ada-indent-broken 
ada-indent-broken ada-indent-broken nil]))%
   | WITH subprogram_specification IS subprogram_default 
aspect_specification_opt SEMICOLON
  ;; formal_concrete_subprogram_declaration
-    %((progn
-      (wisi-statement-action [1 statement-start 6 statement-end])
-      (wisi-indent-action [nil nil ada-indent-broken ada-indent-broken 
ada-indent-broken nil])))%
+    %((wisi-statement-action [1 statement-start 6 statement-end])
+      (wisi-indent-action [nil nil ada-indent-broken ada-indent-broken 
ada-indent-broken nil]))%
   | WITH subprogram_specification IS ABSTRACT aspect_specification_opt 
SEMICOLON
  ;; formal_abstract_subprogram_declaration
-    %((progn
-      (wisi-statement-action [1 statement-start 6 statement-end])
-      (wisi-indent-action [nil ada-indent-broken ada-indent-broken 
ada-indent-broken ada-indent-broken nil])))%
+    %((wisi-statement-action [1 statement-start 6 statement-end])
+      (wisi-indent-action [nil ada-indent-broken ada-indent-broken 
ada-indent-broken ada-indent-broken nil]))%
   | WITH subprogram_specification aspect_specification_opt SEMICOLON ;; 
formal_concrete_subprogram_declaration
-    %((progn
-      (wisi-statement-action [1 statement-start 4 statement-end])
-      (wisi-indent-action [nil nil ada-indent-broken nil])))%
+    %((wisi-statement-action [1 statement-start 4 statement-end])
+      (wisi-indent-action [nil nil ada-indent-broken nil]))%
   ;
 
 formal_type_declaration
   : TYPE IDENTIFIER discriminant_part_opt IS formal_type_definition 
aspect_specification_opt SEMICOLON
  ;; formal_complete_type_declaration
-    %((progn
-      (wisi-statement-action [1 statement-start 7 statement-end])
+    %((wisi-statement-action [1 statement-start 7 statement-end])
       (wisi-face-apply-action [2 nil font-lock-type-face])
       (wisi-indent-action [nil ada-indent-broken ada-indent-broken 
ada-indent-broken
-                             ada-indent-broken ada-indent-broken nil])))%
+                             ada-indent-broken ada-indent-broken nil]))%
   | TYPE IDENTIFIER discriminant_part_opt IS TAGGED aspect_specification_opt 
SEMICOLON
  ;; formal_incomplete_type_declaration
-    %((progn
-      (wisi-statement-action [1 statement-start 7 statement-end])
+    %((wisi-statement-action [1 statement-start 7 statement-end])
       (wisi-face-apply-action [2 nil font-lock-type-face])
       (wisi-indent-action [nil ada-indent-broken ada-indent-broken 
ada-indent-broken ada-indent-broken
-                               ada-indent-broken nil])))%
+                               ada-indent-broken nil]))%
   | TYPE IDENTIFIER discriminant_part_opt aspect_specification_opt SEMICOLON
-    %((progn
-      (wisi-statement-action [1 statement-start 5 statement-end])
+    %((wisi-statement-action [1 statement-start 5 statement-end])
       (wisi-face-apply-action [2 nil font-lock-type-face])
-      (wisi-indent-action [nil ada-indent-broken ada-indent-broken 
ada-indent-broken nil])))%
+      (wisi-indent-action [nil ada-indent-broken ada-indent-broken 
ada-indent-broken nil]))%
   ;
 
 formal_type_definition
@@ -1214,11 +1183,10 @@ formal_derived_type_definition
 
 formal_package_declaration
   : WITH PACKAGE name IS NEW name formal_package_actual_part 
aspect_specification_opt SEMICOLON
-    %((progn
-      (wisi-statement-action [1 statement-start 9 statement-end])
+    %((wisi-statement-action [1 statement-start 9 statement-end])
       (wisi-face-apply-action [3 font-lock-function-name-face 
font-lock-function-name-face
                                  6 font-lock-function-name-face 
font-lock-function-name-face])
-      (wisi-indent-action [nil ada-indent-broken ada-indent-broken 
ada-indent-broken ada-indent-broken ada-indent-broken ada-indent-broken 
ada-indent-broken nil])))%
+      (wisi-indent-action [nil ada-indent-broken ada-indent-broken 
ada-indent-broken ada-indent-broken ada-indent-broken ada-indent-broken 
ada-indent-broken nil]))%
   ;
 
 formal_package_actual_part
@@ -1234,27 +1202,25 @@ formal_package_actual_part
 
 full_type_declaration
   : TYPE IDENTIFIER discriminant_part_opt IS type_definition 
aspect_specification_opt SEMICOLON
-    %((progn
-        (wisi-statement-action [1 statement-start 7 statement-end])
+    %((wisi-statement-action [1 statement-start 7 statement-end])
         (wisi-name-action 2)
         (wisi-face-apply-action [2 nil font-lock-type-face])
 
-        ;; FIXME: indentation of comment after 'is' (and 'with' in
-        ;; derived_type_definition) should be ada-indent-record-rel-type
-        ;; if type_definition is a record. Worse if
-        ;; ada-indent-comment-gnat is t. Need 'anchor to next line'.
-        (wisi-indent-action [nil ada-indent-broken ada-indent-broken 
ada-indent-broken ada-indent-broken nil nil])))%
+        ;; Indentation of comment after 'is' is
+        ;; ada-indent-record-rel-type if type_definition is a record.
+        (wisi-indent-action [nil ada-indent-broken ada-indent-broken
+                                 [ada-indent-broken (ada-indent-record* 'TYPE 
5 ada-indent-broken)]
+                                 ada-indent-broken nil nil]))%
   | task_type_declaration
   | protected_type_declaration
   ;
 
 function_specification
   : FUNCTION name parameter_and_result_profile
-    %((progn
-        (wisi-statement-action [1 statement-start])
+    %((wisi-statement-action [1 statement-start])
         (wisi-name-action 2)
         (wisi-face-apply-action [2 font-lock-function-name-face 
font-lock-function-name-face])
-        (wisi-indent-action [nil ada-indent-broken ada-indent-broken])))%
+        (wisi-indent-action [nil ada-indent-broken ada-indent-broken]))%
     %((wisi-propagate-name 2))%
   ;
 
@@ -1275,9 +1241,8 @@ generic_declaration
 
 generic_formal_part
   : GENERIC generic_formal_parameter_declarations
-    %((progn
-      (wisi-statement-action [1 statement-start])
-      (wisi-indent-action [nil ada-indent])))%
+    %((wisi-statement-action [1 statement-start])
+      (wisi-indent-action [nil ada-indent]))%
   | GENERIC
     %((wisi-statement-action [1 statement-start]))%
   ;
@@ -1299,91 +1264,80 @@ generic_formal_parameter_declaration
 generic_instantiation
  ;; name generic_actual_part is included in name as a function call
   : PACKAGE name IS NEW name aspect_specification_opt SEMICOLON
-    %((progn
-        (wisi-statement-action [1 statement-start 7 statement-end])
+    %((wisi-statement-action [1 statement-start 7 statement-end])
         (wisi-name-action 2)
         (wisi-face-apply-action [2 font-lock-function-name-face 
font-lock-function-name-face
                                    5 font-lock-function-name-face 
font-lock-function-name-face])
-        (wisi-indent-action [nil ada-indent-broken nil ada-indent-broken 
ada-indent-broken ada-indent-broken nil])))%
+        (wisi-indent-action [nil ada-indent-broken nil ada-indent-broken 
ada-indent-broken ada-indent-broken nil]))%
   | overriding_indicator_opt PROCEDURE name IS NEW name 
aspect_specification_opt SEMICOLON
-    %((progn
-        (wisi-statement-action [1 statement-start 2 statement-override 8 
statement-end])
+    %((wisi-statement-action [1 statement-start 2 statement-override 8 
statement-end])
         (wisi-name-action 3)
         (wisi-face-apply-action [3 font-lock-function-name-face 
font-lock-function-name-face
                                    6 font-lock-function-name-face 
font-lock-function-name-face])
-        (wisi-indent-action [nil nil ada-indent-broken ada-indent-broken 
ada-indent-broken ada-indent-broken ada-indent-broken nil])))%
+        (wisi-indent-action [nil nil ada-indent-broken ada-indent-broken 
ada-indent-broken ada-indent-broken ada-indent-broken nil]))%
   | overriding_indicator_opt FUNCTION name IS NEW name 
aspect_specification_opt SEMICOLON
-    %((progn
-        (wisi-statement-action [1 statement-start 2 statement-override 8 
statement-end])
+    %((wisi-statement-action [1 statement-start 2 statement-override 8 
statement-end])
         (wisi-name-action 3)
         (wisi-face-apply-action [3 font-lock-function-name-face 
font-lock-function-name-face
                                    6 font-lock-function-name-face 
font-lock-function-name-face])
         (wisi-indent-action [nil nil ada-indent-broken nil ada-indent-broken 
ada-indent-broken ada-indent-broken
-                                 nil])))%
+                                 nil]))%
   ;
 
 generic_package_declaration
   : generic_formal_part package_specification SEMICOLON
-    %((progn
-      (wisi-statement-action [1 statement-start 3 statement-end])
+    %((wisi-statement-action [1 statement-start 3 statement-end])
       (wisi-motion-action [1 2 3])
-      (wisi-indent-action [[nil ada-indent] nil nil])))%
+      (wisi-indent-action [[nil ada-indent] nil nil]))%
   ;
 
 generic_renaming_declaration
   : GENERIC PACKAGE name RENAMES name aspect_specification_opt SEMICOLON
-    %((progn
-        (wisi-statement-action [1 statement-start 7 statement-end])
+    %((wisi-statement-action [1 statement-start 7 statement-end])
         (wisi-name-action 3)
         (wisi-face-apply-action [3 font-lock-function-name-face 
font-lock-function-name-face
                                    5 font-lock-function-name-face 
font-lock-function-name-face])
-        (wisi-indent-action [nil nil ada-indent-broken ada-indent-broken 
ada-indent-broken ada-indent-broken nil])))%
+        (wisi-indent-action [nil nil ada-indent-broken ada-indent-broken 
ada-indent-broken ada-indent-broken nil]))%
   | GENERIC PROCEDURE name RENAMES name aspect_specification_opt SEMICOLON
-    %((progn
-        (wisi-statement-action [1 statement-start 7 statement-end])
+    %((wisi-statement-action [1 statement-start 7 statement-end])
         (wisi-name-action 3)
         (wisi-face-apply-action [3 font-lock-function-name-face 
font-lock-function-name-face
                                    5 font-lock-function-name-face 
font-lock-function-name-face])
         (wisi-indent-action [nil nil ada-indent-broken (ada-indent-renames 3) 
ada-indent-broken ada-indent-broken
-                                 nil])))%
+                                 nil]))%
   | GENERIC FUNCTION name RENAMES name aspect_specification_opt SEMICOLON
-    %((progn
-        (wisi-statement-action [1 statement-start 7 statement-end])
+    %((wisi-statement-action [1 statement-start 7 statement-end])
         (wisi-name-action 3)
         (wisi-face-apply-action [3 font-lock-function-name-face 
font-lock-function-name-face
                                    5 font-lock-function-name-face 
font-lock-function-name-face])
         (wisi-indent-action [nil nil ada-indent-broken (ada-indent-renames 3) 
ada-indent-broken ada-indent-broken
-                                 nil])))%
+                                 nil]))%
   ;
 
 generic_subprogram_declaration
   : generic_formal_part subprogram_specification aspect_specification_opt 
SEMICOLON
-    %((progn
-      (wisi-statement-action [1 statement-start 2 statement-override 4 
statement-end])
-      (wisi-motion-action [1 2 4])))%
+    %((wisi-statement-action [1 statement-start 2 statement-override 4 
statement-end])
+      (wisi-motion-action [1 2 4]))%
   ;
 
 goto_label
   : LESS_LESS IDENTIFIER GREATER_GREATER
-    %((progn
-      (wisi-face-apply-action [2 nil font-lock-constant-face])
-      (wisi-indent-action [ada-indent-label nil nil])))%
+    %((wisi-face-apply-action [2 nil font-lock-constant-face])
+      (wisi-indent-action [ada-indent-label nil nil]))%
   ;
 
 handled_sequence_of_statements
   : sequence_of_statements_opt EXCEPTION exception_handler_list_opt
-    %((progn
-        (wisi-indent-action [[nil nil]
+    %((wisi-indent-action [[nil nil]
                              (- ada-indent)
-                             [(- ada-indent-when ada-indent) (- 
ada-indent-when ada-indent)]])))%
+                             [(- ada-indent-when ada-indent) (- 
ada-indent-when ada-indent)]]))%
   | sequence_of_statements_opt
   ;
 
 identifier_list
   : identifier_list COMMA IDENTIFIER
-    %((progn
-        (wisi-name-action 3)
-        (wisi-indent-action [nil nil ada-indent-broken])))%
+    %((wisi-name-action 3)
+        (wisi-indent-action [nil nil ada-indent-broken]))%
   | IDENTIFIER
     %((wisi-name-action 1))%
   ;
@@ -1397,79 +1351,69 @@ identifier_opt
 
 if_expression
   : IF expression_opt THEN expression_opt elsif_expression_list ELSE 
expression_opt
-    %((progn
-      (wisi-statement-action [1 motion 3 motion 6 motion])
+    %((wisi-statement-action [1 motion 3 motion 6 motion])
       (wisi-motion-action [1 3 5 6])
-      (wisi-indent-action [nil [ada-indent-broken ada-indent-broken] nil 
ada-indent nil nil ada-indent])))%
+      (wisi-indent-action [nil [ada-indent-broken ada-indent-broken] nil 
ada-indent nil nil ada-indent]))%
   | IF expression_opt THEN expression_opt ELSE expression_opt
-    %((progn
-      (wisi-statement-action [1 motion 3 motion 5 motion])
+    %((wisi-statement-action [1 motion 3 motion 5 motion])
       (wisi-motion-action [1 3 5])
-      (wisi-indent-action [nil [ada-indent-broken ada-indent-broken] nil 
ada-indent nil ada-indent])))%
+      (wisi-indent-action [nil [ada-indent-broken ada-indent-broken] nil 
ada-indent nil ada-indent]))%
   | IF expression_opt THEN expression_opt elsif_expression_list
-    %((progn
-      (wisi-statement-action [1 motion 3 motion])
+    %((wisi-statement-action [1 motion 3 motion])
       (wisi-motion-action [1 3 5])
-      (wisi-indent-action [nil [ada-indent-broken ada-indent-broken] nil 
ada-indent nil])))%
+      (wisi-indent-action [nil [ada-indent-broken ada-indent-broken] nil 
ada-indent nil]))%
   | IF expression_opt THEN expression_opt
-    %((progn
-      (wisi-statement-action [1 motion 3 motion])
+    %((wisi-statement-action [1 motion 3 motion])
       (wisi-motion-action [1 3])
-      (wisi-indent-action [nil [ada-indent-broken ada-indent-broken] nil 
ada-indent])))%
+      (wisi-indent-action [nil [ada-indent-broken ada-indent-broken] nil 
ada-indent]))%
   ;
 
 if_statement
   : IF expression_opt THEN sequence_of_statements_opt elsif_statement_list ELSE
     sequence_of_statements_opt END IF SEMICOLON
-    %((progn
-      (wisi-statement-action [1 statement-start 3 motion 6 motion 10 
statement-end])
+    %((wisi-statement-action [1 statement-start 3 motion 6 motion 10 
statement-end])
       (wisi-motion-action [1 3 5 6 10])
       (wisi-indent-action [nil
                            [(wisi-hanging% ada-indent-broken (* 2 
ada-indent-broken))
                             ada-indent-broken]
                            nil
                            [ada-indent ada-indent] nil nil
-                           [ada-indent ada-indent] nil nil nil])))%
+                           [ada-indent ada-indent] nil nil nil]))%
   | IF expression_opt THEN sequence_of_statements_opt ELSE 
sequence_of_statements_opt END IF SEMICOLON
-    %((progn
-      (wisi-statement-action [1 statement-start 3 motion 5 motion 9 
statement-end])
+    %((wisi-statement-action [1 statement-start 3 motion 5 motion 9 
statement-end])
       (wisi-motion-action [1 3 5 9])
       (wisi-indent-action [nil [(wisi-hanging% ada-indent-broken (* 2 
ada-indent-broken))
                               ada-indent-broken]
                              nil
                              [ada-indent ada-indent] nil
-                             [ada-indent ada-indent] nil nil nil])))%
+                             [ada-indent ada-indent] nil nil nil]))%
   | IF expression_opt THEN sequence_of_statements_opt elsif_statement_list END 
IF SEMICOLON
-    %((progn
-      (wisi-statement-action [1 statement-start 3 motion 8 statement-end])
+    %((wisi-statement-action [1 statement-start 3 motion 8 statement-end])
       (wisi-motion-action [1 3 5 8])
       (wisi-indent-action [nil [(wisi-hanging% ada-indent-broken (* 2 
ada-indent-broken))
                               ada-indent-broken]
                              nil
-                             [ada-indent ada-indent] nil nil nil nil])))%
+                             [ada-indent ada-indent] nil nil nil nil]))%
   | IF expression_opt THEN sequence_of_statements_opt END IF SEMICOLON
-    %((progn
-      (wisi-statement-action [1 statement-start 3 motion 7 statement-end])
+    %((wisi-statement-action [1 statement-start 3 motion 7 statement-end])
       (wisi-motion-action [1 3 7])
       (wisi-indent-action [nil [(wisi-hanging% ada-indent-broken (* 2 
ada-indent-broken))
                               ada-indent-broken]
                              nil
-                             [ada-indent ada-indent] nil nil nil])))%
+                             [ada-indent ada-indent] nil nil nil]))%
   ;
 
 incomplete_type_declaration
   : TYPE IDENTIFIER discriminant_part_opt IS TAGGED SEMICOLON
-    %((progn
-        (wisi-statement-action [1 statement-start 6 statement-end])
+    %((wisi-statement-action [1 statement-start 6 statement-end])
         (wisi-name-action 2)
         (wisi-face-apply-action [2 nil font-lock-type-face])
-        (wisi-indent-action [nil ada-indent-broken ada-indent-broken 
ada-indent-broken ada-indent-broken nil])))%
+        (wisi-indent-action [nil ada-indent-broken ada-indent-broken 
ada-indent-broken ada-indent-broken nil]))%
   | TYPE IDENTIFIER discriminant_part_opt SEMICOLON
-    %((progn
-        (wisi-statement-action [1 statement-start 3 statement-end])
+    %((wisi-statement-action [1 statement-start 3 statement-end])
         (wisi-name-action 2)
         (wisi-face-apply-action [2 nil font-lock-type-face])
-        (wisi-indent-action [nil ada-indent-broken ada-indent-broken nil])))%
+        (wisi-indent-action [nil ada-indent-broken ada-indent-broken nil]))%
   ;
 
 index_constraint
@@ -1548,16 +1492,14 @@ iterator_specification_opt
 
 loop_statement
   : block_label_opt iteration_scheme LOOP sequence_of_statements_opt END LOOP 
identifier_opt SEMICOLON
-    %((progn
-      (wisi-statement-action [1 statement-start 2 statement-override 3 motion 
8 statement-end])
+    %((wisi-statement-action [1 statement-start 2 statement-override 3 motion 
8 statement-end])
       (wisi-motion-action [2 3 8])
-      (wisi-indent-action [nil nil nil [ada-indent ada-indent] nil nil nil 
nil])))%
+      (wisi-indent-action [nil nil nil [ada-indent ada-indent] nil nil nil 
nil]))%
     %((wisi-match-names 1 7))%
   | block_label_opt LOOP sequence_of_statements_opt END LOOP identifier_opt 
SEMICOLON
-    %((progn
-      (wisi-statement-action [1 statement-start 2 statement-override 4 motion 
7 statement-end])
+    %((wisi-statement-action [1 statement-start 2 statement-override 4 motion 
7 statement-end])
       (wisi-motion-action [2 4 7])
-      (wisi-indent-action [nil nil [ada-indent ada-indent] nil nil nil nil])))%
+      (wisi-indent-action [nil nil [ada-indent ada-indent] nil nil nil nil]))%
     %((wisi-match-names 1 6))%
   ;
 
@@ -1637,10 +1579,9 @@ name
  ;;   := F_Long_Name
  ;;        (A => True,
  ;;         B => True);
-    %((progn
-      (wisi-indent-action [nil (if ada-indent-hanging-rel-exp
+    %((wisi-indent-action [nil (if ada-indent-hanging-rel-exp
                                  (wisi-anchored 1 ada-indent-broken)
-                               (wisi-anchored% 1 ada-indent-broken))])))%
+                               (wisi-anchored% 1 ada-indent-broken))]))%
 
   | selected_component ;; starts with name
     %()%
@@ -1663,6 +1604,8 @@ name
     %()%
     %((wisi-propagate-name 1))%
 
+  | AT_SIGN ;; target_name
+  
   ;; | explicit_dereference in selected_component
   ;; | indexed_component same as 'name actual_parameter_part' above
   ;; | generalized_reference same as 'name'
@@ -1695,70 +1638,60 @@ null_exclusion_opt_name_type
 
 null_procedure_declaration
   : overriding_indicator_opt procedure_specification IS NULL 
aspect_specification_opt SEMICOLON
-    %((progn
-      (wisi-statement-action [1 statement-start 2 statement-override 6 
statement-end])
-      (wisi-indent-action [nil nil ada-indent-broken ada-indent-broken 
ada-indent-broken nil])))%
+    %((wisi-statement-action [1 statement-start 2 statement-override 6 
statement-end])
+      (wisi-indent-action [nil nil ada-indent-broken ada-indent-broken 
ada-indent-broken nil]))%
   ;
 
 object_declaration
   : identifier_list COLON aliased_opt constant_opt subtype_indication 
COLON_EQUAL
     expression_opt aspect_specification_opt SEMICOLON
-    %((progn
-      (wisi-statement-action [1 statement-start 9 statement-end])
+    %((wisi-statement-action [1 statement-start 9 statement-end])
       (wisi-indent-action [nil ada-indent-broken ada-indent-broken 
ada-indent-broken ada-indent-broken ada-indent-broken
-                             (wisi-anchored%- 6 ada-indent-broken) 
ada-indent-broken nil])))%
+                             (wisi-anchored%- 6 ada-indent-broken) 
ada-indent-broken nil]))%
   | identifier_list COLON aliased_opt constant_opt access_definition 
COLON_EQUAL
     expression_opt aspect_specification_opt SEMICOLON
-    %((progn
-      (wisi-statement-action [1 statement-start 9 statement-end])
+    %((wisi-statement-action [1 statement-start 9 statement-end])
       (wisi-indent-action [nil ada-indent-broken ada-indent-broken 
ada-indent-broken ada-indent-broken ada-indent-broken
-                             (wisi-anchored% 6 ada-indent-broken) 
ada-indent-broken nil])))%
+                             (wisi-anchored% 6 ada-indent-broken) 
ada-indent-broken nil]))%
   | identifier_list COLON aliased_opt constant_opt array_type_definition 
COLON_EQUAL
     expression_opt aspect_specification_opt SEMICOLON
-    %((progn
-      (wisi-statement-action [1 statement-start 9 statement-end])
+    %((wisi-statement-action [1 statement-start 9 statement-end])
       (wisi-indent-action [nil ada-indent-broken ada-indent-broken 
ada-indent-broken ada-indent-broken ada-indent-broken
-                             (wisi-anchored% 6 ada-indent-broken) 
ada-indent-broken nil])))%
+                             (wisi-anchored% 6 ada-indent-broken) 
ada-indent-broken nil]))%
   | identifier_list COLON aliased_opt constant_opt subtype_indication 
aspect_specification_opt SEMICOLON
-    %((progn
-      (wisi-statement-action [1 statement-start 7 statement-end])
+    %((wisi-statement-action [1 statement-start 7 statement-end])
       (wisi-indent-action [nil ada-indent-broken ada-indent-broken 
ada-indent-broken ada-indent-broken
-                               ada-indent-broken nil])))%
+                               ada-indent-broken nil]))%
   | identifier_list COLON aliased_opt constant_opt access_definition 
aspect_specification_opt SEMICOLON
-    %((progn
-      (wisi-statement-action [1 statement-start 7 statement-end])
+    %((wisi-statement-action [1 statement-start 7 statement-end])
       (wisi-indent-action [nil ada-indent-broken ada-indent-broken 
ada-indent-broken ada-indent-broken
-                               ada-indent-broken nil])))%
+                               ada-indent-broken nil]))%
   | identifier_list COLON aliased_opt constant_opt array_type_definition 
aspect_specification_opt SEMICOLON
-    %((progn
-      (wisi-statement-action [1 statement-start 7 statement-end])
+    %((wisi-statement-action [1 statement-start 7 statement-end])
       (wisi-indent-action [nil ada-indent-broken ada-indent-broken 
ada-indent-broken ada-indent-broken
-                               ada-indent-broken nil])))%
+                               ada-indent-broken nil]))%
   | single_task_declaration
   | single_protected_declaration
   ;
 
 object_renaming_declaration
   : IDENTIFIER COLON null_exclusion_opt name RENAMES name 
aspect_specification_opt SEMICOLON
-    %((progn
-        (wisi-statement-action [1 statement-start 8 statement-end])
-        (wisi-name-action 1)
-        (wisi-face-apply-action [4 font-lock-function-name-face 
font-lock-type-face])
-        (wisi-indent-action [nil ada-indent-broken ada-indent-broken 
ada-indent-broken ada-indent-broken
-                                 ada-indent-broken ada-indent-broken nil])))%
+    %((wisi-statement-action [1 statement-start 8 statement-end])
+      (wisi-name-action 1)
+      (wisi-face-apply-action [4 font-lock-function-name-face 
font-lock-type-face])
+      (wisi-indent-action [nil ada-indent-broken ada-indent-broken 
ada-indent-broken ada-indent-broken
+                                 ada-indent-broken ada-indent-broken nil]))%
   | IDENTIFIER COLON access_definition RENAMES name aspect_specification_opt 
SEMICOLON
-    %((progn
-        (wisi-statement-action [1 statement-start 7 statement-end])
-        (wisi-name-action 1)
-        (wisi-indent-action [nil ada-indent-broken ada-indent-broken 
ada-indent-broken ada-indent-broken
-                                 ada-indent-broken nil])))%
+    %((wisi-statement-action [1 statement-start 7 statement-end])
+      (wisi-name-action 1)
+      (wisi-indent-action [nil ada-indent-broken ada-indent-broken 
ada-indent-broken ada-indent-broken
+                                 ada-indent-broken nil]))%
   | IDENTIFIER COLON EXCEPTION RENAMES name aspect_specification_opt SEMICOLON 
;; exception_renaming_declaration
-    %((progn
-        (wisi-statement-action [1 statement-start 7 statement-end])
-        (wisi-name-action 1)
-        (wisi-face-apply-action [5 font-lock-function-name-face nil])
-        (wisi-indent-action [nil ada-indent-broken ada-indent-broken 
ada-indent-broken ada-indent-broken
-                                 ada-indent-broken nil])))%
+    %((wisi-statement-action [1 statement-start 7 statement-end])
+      (wisi-name-action 1)
+      (wisi-face-apply-action [5 font-lock-function-name-face nil])
+      (wisi-indent-action [nil ada-indent-broken ada-indent-broken 
ada-indent-broken ada-indent-broken
+                                 ada-indent-broken nil]))%
   ;
 
 ;; operator_symbol is STRING_LITERAL, in name
@@ -1774,73 +1707,66 @@ overriding_indicator_opt
 package_body
   : PACKAGE BODY name aspect_specification_opt IS declarative_part_opt
     BEGIN handled_sequence_of_statements END name_opt SEMICOLON
-    %((progn
-        (wisi-statement-action [1 statement-start 5 motion 7 motion 11 
statement-end])
-        (wisi-name-action 3)
-        (wisi-motion-action [1 5 7 [8 WHEN] 11])
-        (wisi-face-apply-action [3 font-lock-function-name-face 
font-lock-function-name-face
-                                   10 font-lock-function-name-face 
font-lock-function-name-face])
-        (wisi-indent-action [nil ada-indent-broken ada-indent-broken nil nil 
[ada-indent ada-indent]
-                             nil [ada-indent ada-indent] nil ada-indent-broken 
nil])))%
+    %((wisi-statement-action [1 statement-start 5 motion 7 motion 11 
statement-end])
+      (wisi-name-action 3)
+      (wisi-motion-action [1 5 7 [8 WHEN] 11])
+      (wisi-face-apply-action [3 font-lock-function-name-face 
font-lock-function-name-face
+                                 10 font-lock-function-name-face 
font-lock-function-name-face])
+      (wisi-indent-action [nil ada-indent-broken ada-indent-broken nil nil 
[ada-indent ada-indent]
+                               nil [ada-indent ada-indent] nil 
ada-indent-broken nil]))%
     %((wisi-match-names 3 10))%
 
   | PACKAGE BODY name aspect_specification_opt IS declarative_part_opt END 
name_opt SEMICOLON
-    %((progn
-        (wisi-statement-action [1 statement-start 5 motion 9 statement-end])
-        (wisi-name-action 3)
-        (wisi-motion-action [1 5 9])
-        (wisi-face-apply-action [3 font-lock-function-name-face 
font-lock-function-name-face
-                                   8 font-lock-function-name-face 
font-lock-function-name-face])
-        (wisi-indent-action [nil ada-indent-broken ada-indent-broken 
ada-indent-broken nil [ada-indent ada-indent] nil
-                                 nil nil])))%
+    %((wisi-statement-action [1 statement-start 5 motion 9 statement-end])
+      (wisi-name-action 3)
+      (wisi-motion-action [1 5 9])
+      (wisi-face-apply-action [3 font-lock-function-name-face 
font-lock-function-name-face
+                                 8 font-lock-function-name-face 
font-lock-function-name-face])
+      (wisi-indent-action [nil ada-indent-broken ada-indent-broken 
ada-indent-broken nil [ada-indent ada-indent] nil
+                               nil nil]))%
     %((wisi-match-names 3 8))%
   ;
 
 package_body_stub
   : PACKAGE BODY name IS SEPARATE aspect_specification_opt SEMICOLON
-    %((progn
-        (wisi-statement-action [1 statement-start 7 statement-end])
-        (wisi-name-action 3)
-        (wisi-face-apply-action [3 font-lock-function-name-face 
font-lock-function-name-face])
-        (wisi-indent-action [nil ada-indent-broken ada-indent-broken nil 
ada-indent-broken ada-indent-broken nil])))%
+    %((wisi-statement-action [1 statement-start 7 statement-end])
+      (wisi-name-action 3)
+      (wisi-face-apply-action [3 font-lock-function-name-face 
font-lock-function-name-face])
+      (wisi-indent-action [nil ada-indent-broken ada-indent-broken nil 
ada-indent-broken ada-indent-broken nil]))%
   ;
 
 package_declaration
   : package_specification SEMICOLON
-    %((progn
-      (wisi-statement-action [1 statement-start 2 statement-end])
-      (wisi-motion-action [1 2])))%
+    %((wisi-statement-action [1 statement-start 2 statement-end])
+      (wisi-motion-action [1 2]))%
   ;
 
 package_renaming_declaration
   : PACKAGE name RENAMES name aspect_specification_opt SEMICOLON
-    %((progn
-        (wisi-statement-action [1 statement-start 6 statement-end])
-        (wisi-name-action 2)
-        (wisi-face-apply-action [2 font-lock-function-name-face 
font-lock-function-name-face
-                                   4 font-lock-function-name-face 
font-lock-function-name-face])
-        (wisi-indent-action [nil ada-indent-broken ada-indent-broken 
ada-indent-broken ada-indent-broken nil])))%
+    %((wisi-statement-action [1 statement-start 6 statement-end])
+      (wisi-name-action 2)
+      (wisi-face-apply-action [2 font-lock-function-name-face 
font-lock-function-name-face
+                                 4 font-lock-function-name-face 
font-lock-function-name-face])
+      (wisi-indent-action [nil ada-indent-broken ada-indent-broken 
ada-indent-broken ada-indent-broken nil]))%
   ;
 
 package_specification
   : PACKAGE name aspect_specification_opt IS declarative_part_opt PRIVATE 
declarative_part_opt END name_opt
-    %((progn
-        (wisi-statement-action [1 statement-start 4 motion 6 motion])
-        (wisi-name-action 2)
-        (wisi-motion-action [1 4 6])
-        (wisi-face-apply-action [2 font-lock-function-name-face 
font-lock-function-name-face
-                                   9 font-lock-function-name-face 
font-lock-function-name-face])
-        (wisi-indent-action [nil ada-indent-broken ada-indent-broken nil 
[ada-indent ada-indent] nil
-                             [ada-indent ada-indent] nil nil])))%
+    %((wisi-statement-action [1 statement-start 4 motion 6 motion])
+      (wisi-name-action 2)
+      (wisi-motion-action [1 4 6])
+      (wisi-face-apply-action [2 font-lock-function-name-face 
font-lock-function-name-face
+                                 9 font-lock-function-name-face 
font-lock-function-name-face])
+      (wisi-indent-action [nil ada-indent-broken ada-indent-broken nil 
[ada-indent ada-indent] nil
+                             [ada-indent ada-indent] nil nil]))%
     %((wisi-match-names 2 9))%
   | PACKAGE name aspect_specification_opt IS declarative_part_opt END name_opt
-    %((progn
-      (wisi-statement-action [1 statement-start 4 motion])
+    %((wisi-statement-action [1 statement-start 4 motion])
       (wisi-name-action 2)
       (wisi-motion-action [1 4])
       (wisi-face-apply-action [2 font-lock-function-name-face 
font-lock-function-name-face
                                  7 font-lock-function-name-face 
font-lock-function-name-face])
-      (wisi-indent-action [nil ada-indent-broken ada-indent-broken nil 
[ada-indent ada-indent] nil nil])))%
+      (wisi-indent-action [nil ada-indent-broken ada-indent-broken nil 
[ada-indent ada-indent] nil nil]))%
     %((wisi-match-names 2 7))%
   ;
 
@@ -1860,15 +1786,13 @@ parameter_profile_opt
 
 parameter_specification
   : identifier_list COLON aliased_opt mode_opt null_exclusion_opt name 
COLON_EQUAL expression_opt
-    %((progn
-      (wisi-face-apply-action [6 font-lock-function-name-face 
font-lock-type-face])
+    %((wisi-face-apply-action [6 font-lock-function-name-face 
font-lock-type-face])
       (wisi-indent-action [nil ada-indent-broken ada-indent-broken 
ada-indent-broken ada-indent-broken
-                             ada-indent-broken ada-indent-broken 
(wisi-anchored% 7 ada-indent-broken)])))%
+                             ada-indent-broken ada-indent-broken 
(wisi-anchored% 7 ada-indent-broken)]))%
   | identifier_list COLON aliased_opt mode_opt null_exclusion_opt name
-    %((progn
-      (wisi-face-apply-action [6 font-lock-function-name-face 
font-lock-type-face])
+    %((wisi-face-apply-action [6 font-lock-function-name-face 
font-lock-type-face])
       (wisi-indent-action [nil ada-indent-broken ada-indent-broken 
ada-indent-broken ada-indent-broken
-                             ada-indent-broken])))%
+                             ada-indent-broken]))%
   | identifier_list COLON aliased_opt access_definition COLON_EQUAL 
expression_opt
     %((wisi-indent-action [nil ada-indent-broken ada-indent-broken 
ada-indent-broken ada-indent-broken
                            (wisi-anchored% 5 ada-indent-broken)]))%
@@ -1900,21 +1824,18 @@ paren_expression
 pragma_g
   : PRAGMA IDENTIFIER LEFT_PAREN association_list RIGHT_PAREN SEMICOLON
  ;; ARM has 'pragma_argument_association'; this is a superset, and reduces 
redundancy
-    %((progn
-      (wisi-statement-action [1 statement-start 6 statement-end])
+    %((wisi-statement-action [1 statement-start 6 statement-end])
       (wisi-face-apply-action [2 nil font-lock-function-name-face])
-      (wisi-indent-action [nil ada-indent-broken ada-indent-broken 
(wisi-anchored 3 1) (wisi-anchored 3 0) nil])))%
+      (wisi-indent-action [nil ada-indent-broken ada-indent-broken 
(wisi-anchored 3 1) (wisi-anchored 3 0) nil]))%
  ;; ARM 4.5.7(7), ARM 4.5.8(4) allow ( conditional|quantified_expression ) 
instead of (( ... ))
   | PRAGMA IDENTIFIER LEFT_PAREN conditional_quantified_expression RIGHT_PAREN 
SEMICOLON
-    %((progn
-      (wisi-statement-action [1 statement-start 6 statement-end])
+    %((wisi-statement-action [1 statement-start 6 statement-end])
       (wisi-face-apply-action [2 nil font-lock-function-name-face])
-      (wisi-indent-action [nil ada-indent-broken ada-indent-broken 
(wisi-anchored 3 1) (wisi-anchored 3 0) nil])))%
+      (wisi-indent-action [nil ada-indent-broken ada-indent-broken 
(wisi-anchored 3 1) (wisi-anchored 3 0) nil]))%
   | PRAGMA IDENTIFIER SEMICOLON
-    %((progn
-      (wisi-statement-action [1 statement-start 3 statement-end])
+    %((wisi-statement-action [1 statement-start 3 statement-end])
       (wisi-face-apply-action [2 nil font-lock-function-name-face])
-      (wisi-indent-action [nil ada-indent-broken nil])))%
+      (wisi-indent-action [nil ada-indent-broken nil]))%
   ;
 
 ;; prefix is name
@@ -1937,38 +1858,34 @@ primary
 private_extension_declaration
   : TYPE IDENTIFIER discriminant_part_opt IS abstract_limited_synchronized_opt 
NEW
     subtype_indication and_interface_list_opt WITH PRIVATE 
aspect_specification_opt SEMICOLON
-    %((progn
-        (wisi-statement-action [1 statement-start 12 statement-end])
-        (wisi-name-action 2)
-        (wisi-face-apply-action [2 nil font-lock-type-face])
-        (wisi-indent-action [nil ada-indent-broken ada-indent-broken 
ada-indent-broken ada-indent-broken ada-indent-broken
-                               ada-indent-broken ada-indent-broken 
ada-indent-broken ada-indent-broken nil nil])))%
+    %((wisi-statement-action [1 statement-start 12 statement-end])
+      (wisi-name-action 2)
+      (wisi-face-apply-action [2 nil font-lock-type-face])
+      (wisi-indent-action [nil ada-indent-broken ada-indent-broken 
ada-indent-broken ada-indent-broken ada-indent-broken
+                               ada-indent-broken ada-indent-broken 
ada-indent-broken ada-indent-broken nil nil]))%
   ;
 
 private_type_declaration
   : TYPE IDENTIFIER discriminant_part_opt IS abstract_tagged_limited_opt 
PRIVATE aspect_specification_opt SEMICOLON
-    %((progn
-        (wisi-statement-action [1 statement-start 8 statement-end])
-        (wisi-name-action 2)
-        (wisi-face-apply-action [2 nil font-lock-type-face])
-        (wisi-indent-action [nil ada-indent-broken ada-indent-broken nil 
ada-indent-broken ada-indent-broken nil
-                                 nil])))%
+    %((wisi-statement-action [1 statement-start 8 statement-end])
+      (wisi-name-action 2)
+      (wisi-face-apply-action [2 nil font-lock-type-face])
+      (wisi-indent-action [nil ada-indent-broken ada-indent-broken nil 
ada-indent-broken ada-indent-broken nil
+                                 nil]))%
   ;
 
 procedure_call_statement
   : name SEMICOLON
-    %((progn
-      (wisi-statement-action [1 statement-start 2 statement-end])
-      (wisi-indent-action [(wisi-hanging nil ada-indent-broken) nil])))%
+    %((wisi-statement-action [1 statement-start 2 statement-end])
+      (wisi-indent-action [(wisi-hanging nil ada-indent-broken) nil]))%
   ;
 
 procedure_specification
   : PROCEDURE name parameter_profile_opt
-    %((progn
-        (wisi-statement-action [1 statement-start])
-        (wisi-name-action 2)
-        (wisi-face-apply-action [2 font-lock-function-name-face 
font-lock-function-name-face])
-        (wisi-indent-action [nil ada-indent-broken ada-indent-broken])))%
+    %((wisi-statement-action [1 statement-start])
+      (wisi-name-action 2)
+      (wisi-face-apply-action [2 font-lock-function-name-face 
font-lock-function-name-face])
+      (wisi-indent-action [nil ada-indent-broken ada-indent-broken]))%
     %((wisi-propagate-name 2))%
   ;
 
@@ -1981,36 +1898,32 @@ proper_body
 
 protected_body
   : PROTECTED BODY IDENTIFIER aspect_specification_opt IS 
protected_operation_item_list_opt END identifier_opt SEMICOLON
-    %((progn
-        (wisi-statement-action [1 statement-start 5 motion 9 statement-end])
-        (wisi-name-action 3)
-        (wisi-motion-action [1 5 9])
-        (wisi-face-apply-action [3 nil font-lock-type-face 8 nil 
font-lock-type-face])
-        (wisi-indent-action [nil ada-indent-broken ada-indent-broken nil nil 
ada-indent nil nil nil])))%
+    %((wisi-statement-action [1 statement-start 5 motion 9 statement-end])
+      (wisi-name-action 3)
+      (wisi-motion-action [1 5 9])
+      (wisi-face-apply-action [3 nil font-lock-type-face 8 nil 
font-lock-type-face])
+      (wisi-indent-action [nil ada-indent-broken ada-indent-broken nil nil 
ada-indent nil nil nil]))%
     %((wisi-match-names 3 8))%
   ;
 
 protected_body_stub
   : PROTECTED BODY IDENTIFIER IS SEPARATE aspect_specification_opt SEMICOLON
-    %((progn
-        (wisi-statement-action [1 statement-start 7 statement-end])
-        (wisi-name-action 3)
-        (wisi-face-apply-action [3 nil font-lock-type-face])
-        (wisi-indent-action [nil ada-indent-broken ada-indent-broken 
ada-indent-broken ada-indent-broken ada-indent-broken nil])))%
+    %((wisi-statement-action [1 statement-start 7 statement-end])
+      (wisi-name-action 3)
+      (wisi-face-apply-action [3 nil font-lock-type-face])
+      (wisi-indent-action [nil ada-indent-broken ada-indent-broken 
ada-indent-broken ada-indent-broken ada-indent-broken nil]))%
   ;
 
 protected_definition
   : declarative_part_opt PRIVATE declarative_part_opt END identifier_opt
-    %((progn
-      (wisi-statement-action [2 motion])
+    %((wisi-statement-action [2 motion])
       (wisi-face-apply-action [5 nil font-lock-type-face])
-      (wisi-indent-action [[ada-indent ada-indent] nil [ada-indent ada-indent] 
nil nil])))%
+      (wisi-indent-action [[ada-indent ada-indent] nil [ada-indent ada-indent] 
nil nil]))%
     %((wisi-propagate-name 5))%
 
   | declarative_part_opt END identifier_opt
-    %((progn
-      (wisi-face-apply-action [3 nil font-lock-type-face])
-      (wisi-indent-action [[ada-indent ada-indent] nil nil])))%
+    %((wisi-face-apply-action [3 nil font-lock-type-face])
+      (wisi-indent-action [[ada-indent ada-indent] nil nil]))%
     %((wisi-propagate-name 3))%
   ;
 
@@ -2041,21 +1954,19 @@ protected_opt
 protected_type_declaration
   : PROTECTED TYPE IDENTIFIER discriminant_part_opt aspect_specification_opt IS
     NEW interface_list WITH protected_definition SEMICOLON
-    %((progn
-        (wisi-statement-action [1 statement-start 6 motion 11 statement-end])
-        (wisi-name-action 3)
-        (wisi-motion-action [1 6 [10 PRIVATE] 11])
-        (wisi-face-apply-action [3 nil font-lock-type-face])
-        (wisi-indent-action [nil ada-indent-broken ada-indent-broken 
ada-indent-broken nil nil
-                               ada-indent-broken ada-indent-broken 
ada-indent-broken nil nil])))%
+    %((wisi-statement-action [1 statement-start 6 motion 11 statement-end])
+      (wisi-name-action 3)
+      (wisi-motion-action [1 6 [10 PRIVATE] 11])
+      (wisi-face-apply-action [3 nil font-lock-type-face])
+      (wisi-indent-action [nil ada-indent-broken ada-indent-broken 
ada-indent-broken nil nil
+                               ada-indent-broken ada-indent-broken 
ada-indent-broken nil nil]))%
     %((wisi-match-names 3 10))%
   | PROTECTED TYPE IDENTIFIER discriminant_part_opt aspect_specification_opt 
IS protected_definition SEMICOLON
-    %((progn
-        (wisi-statement-action [1 statement-start 6 motion 8 statement-end])
-        (wisi-name-action 3)
-        (wisi-motion-action [1 6 [7 PRIVATE] 8])
-        (wisi-face-apply-action [3 nil font-lock-type-face])
-        (wisi-indent-action [nil ada-indent-broken ada-indent-broken 
ada-indent-broken nil [nil ada-indent] nil nil])))%
+    %((wisi-statement-action [1 statement-start 6 motion 8 statement-end])
+      (wisi-name-action 3)
+      (wisi-motion-action [1 6 [7 PRIVATE] 8])
+      (wisi-face-apply-action [3 nil font-lock-type-face])
+      (wisi-indent-action [nil ada-indent-broken ada-indent-broken 
ada-indent-broken nil [nil ada-indent] nil nil]))%
     %((wisi-match-names 3 7))%
   ;
 
@@ -2063,11 +1974,10 @@ protected_type_declaration
 
 qualified_expression
   : name tick aggregate
-    %((progn
-      (wisi-face-apply-action [1 font-lock-function-name-face 
font-lock-type-face])
+    %((wisi-face-apply-action [1 font-lock-function-name-face 
font-lock-type-face])
       (wisi-indent-action [nil nil (if ada-indent-hanging-rel-exp
-                                   (wisi-anchored 1 ada-indent-broken)
-                                 (wisi-anchored% 1 ada-indent-broken))])))%
+                                       (wisi-anchored 1 ada-indent-broken)
+                                     (wisi-anchored% 1 ada-indent-broken))]))%
     ;
 
 quantified_expression
@@ -2085,8 +1995,7 @@ raise_expression
 
 raise_statement
   : RAISE name WITH expression_opt SEMICOLON
-    %((progn
-      (wisi-statement-action [1 statement-start 5 statement-end])
+    %((wisi-statement-action [1 statement-start 5 statement-end])
       ;; test/ada_mode-nominal.adb
       ;; raise Constraint_Error with
       ;;   "help " &
@@ -2095,11 +2004,10 @@ raise_statement
       ;; raise Constraint_Error
       ;;   with Integer'Image (1) &
       ;;   "help!";
-      (wisi-indent-action [nil ada-indent-broken ada-indent-broken 
(wisi-anchored% 3 ada-indent-broken) nil])))%
+      (wisi-indent-action [nil ada-indent-broken ada-indent-broken 
(wisi-anchored% 3 ada-indent-broken) nil]))%
   | RAISE name SEMICOLON
-    %((progn
-      (wisi-statement-action [1 statement-start 3 statement-end])
-      (wisi-indent-action [nil ada-indent-broken nil])))%
+    %((wisi-statement-action [1 statement-start 3 statement-end])
+      (wisi-indent-action [nil ada-indent-broken nil]))%
   | RAISE SEMICOLON
     %((wisi-statement-action [1 statement-start 2 statement-end]))%
   ;
@@ -2124,24 +2032,23 @@ real_range_specification_opt
 record_definition
   : RECORD component_list_opt END RECORD
     %((wisi-indent-action [[(ada-indent-record* 'TYPE 1 0) (ada-indent-record* 
'TYPE 1 ada-indent)]
-                         [(ada-indent-record* 'TYPE 1 ada-indent) 
(ada-indent-record* 'TYPE 1 ada-indent)]
-                         (ada-indent-record* 'TYPE 1 0)
-                         nil]))%
+                           [(ada-indent-record* 'TYPE 1 ada-indent) 
(ada-indent-record* 'TYPE 1 ada-indent)]
+                           (ada-indent-record* 'TYPE 1 0)
+                           nil]))%
  ;; ' terminate quote
   | NULL RECORD
   ;
 
 record_representation_clause
   : FOR name USE RECORD mod_clause_opt component_clause_list END RECORD 
SEMICOLON
-    %((progn
-      (wisi-statement-action [1 statement-start 5 statement-end])
+    %((wisi-statement-action [1 statement-start 5 statement-end])
       (wisi-face-apply-action [2 font-lock-function-name-face 
font-lock-type-face])
       (wisi-indent-action [nil ada-indent-broken ada-indent-broken
-                             (ada-indent-record 1 4 0)
-                             (ada-indent-record 1 4 ada-indent)
-                             (ada-indent-record 1 4 ada-indent)
-                             (ada-indent-record 1 4 0)
-                             nil nil])))%
+                               [(ada-indent-record* 'FOR 4 0) 
(ada-indent-record* 'FOR 4 ada-indent)]
+                               (ada-indent-record 1 4 ada-indent)
+                               [(ada-indent-record* 'FOR 4 ada-indent) 
(ada-indent-record* 'FOR 4 ada-indent)]
+                               (ada-indent-record* 'FOR 4 0)
+                               nil nil]))%
   ;
 
 relation_and_list
@@ -2200,12 +2107,11 @@ requeue_statement
 ;; not in LRM; used to implement consistent indentation
 result_profile
   : RETURN null_exclusion_opt name_opt
-    %((progn
-      (wisi-face-apply-action [3 font-lock-function-name-face 
font-lock-type-face])
+    %((wisi-face-apply-action [3 font-lock-function-name-face 
font-lock-type-face])
       (wisi-indent-action* 1
                            [nil
                             (wisi-anchored* 1 ada-indent-broken)
-                            (wisi-anchored* 1 ada-indent-broken)])))%
+                            (wisi-anchored* 1 ada-indent-broken)]))%
   | RETURN access_definition
  ;; test/ada_mode-nominal.adb
  ;; function Function_Access_1
@@ -2241,32 +2147,27 @@ selected_component
 
 selective_accept
   : SELECT select_alternative_list_opt ELSE sequence_of_statements_opt END 
SELECT SEMICOLON
-    %((progn
-      (wisi-statement-action [1 statement-start 3 motion 7 statement-end])
+    %((wisi-statement-action [1 statement-start 3 motion 7 statement-end])
       (wisi-motion-action [1 [2 OR] 3 7])
-      (wisi-indent-action [[nil ada-indent] [nil ada-indent] nil [ada-indent 
ada-indent] nil nil nil])))%
+      (wisi-indent-action [[nil ada-indent] [nil ada-indent] nil [ada-indent 
ada-indent] nil nil nil]))%
   | SELECT select_alternative_list_opt END SELECT SEMICOLON
-    %((progn
-      (wisi-statement-action [1 statement-start 5 statement-end])
+    %((wisi-statement-action [1 statement-start 5 statement-end])
       (wisi-motion-action [1 [2 OR] 5])
-      (wisi-indent-action [[nil ada-indent] [nil ada-indent] nil nil nil])))%
+      (wisi-indent-action [[nil ada-indent] [nil ada-indent] nil nil nil]))%
   ;
 
 select_alternative
  ;; we can't use guard_opt here because when present a guard is a
  ;; block-start, but when absent there is no block-start
   : WHEN expression_opt EQUAL_GREATER accept_statement 
sequence_of_statements_opt ;; guard accept_alternative
-    %((progn
-      (wisi-statement-action [1 motion])
-      (wisi-indent-action [nil ada-indent-broken ada-indent-broken ada-indent 
ada-indent])))%
+    %((wisi-statement-action [1 motion])
+      (wisi-indent-action [nil ada-indent-broken ada-indent-broken ada-indent 
ada-indent]))%
   | WHEN expression_opt EQUAL_GREATER TERMINATE SEMICOLON ;; 
terminate_alternative
-    %((progn
-      (wisi-statement-action [1 motion 4 statement-start 5 statement-end])
-      (wisi-indent-action [nil ada-indent-broken ada-indent-broken ada-indent 
nil])))%
+    %((wisi-statement-action [1 motion 4 statement-start 5 statement-end])
+      (wisi-indent-action [nil ada-indent-broken ada-indent-broken ada-indent 
nil]))%
   | WHEN expression_opt EQUAL_GREATER delay_alternative
-    %((progn
-      (wisi-statement-action [1 motion])
-      (wisi-indent-action [nil ada-indent-broken ada-indent-broken 
ada-indent])))%
+    %((wisi-statement-action [1 motion])
+      (wisi-indent-action [nil ada-indent-broken ada-indent-broken 
ada-indent]))%
   | accept_statement sequence_of_statements_opt ;; accept_alternative
   | TERMINATE SEMICOLON ;; terminate_alternative
     %((wisi-statement-action [1 statement-start 2 statement-end]))%
@@ -2275,10 +2176,9 @@ select_alternative
 
 select_alternative_list
   : select_alternative_list OR select_alternative
-    %((progn
-        (wisi-statement-action [2 motion])
+    %((wisi-statement-action [2 motion])
         (wisi-motion-action [[1 OR] 2])
-        (wisi-indent-action [nil nil ada-indent])))%
+        (wisi-indent-action [nil nil ada-indent]))%
   | select_alternative
     %((wisi-indent-action [ada-indent]))%
   ;
@@ -2319,9 +2219,8 @@ simple_return_statement
  ;; return
  ;;   1.0 +
  ;;   2.0;
-    %((progn
-      (wisi-statement-action [1 statement-start 3 statement-end])
-      (wisi-indent-action [nil ada-indent-broken nil])))%
+    %((wisi-statement-action [1 statement-start 3 statement-end])
+      (wisi-indent-action [nil ada-indent-broken nil]))%
   ;
 
 simple_statement
@@ -2330,9 +2229,8 @@ simple_statement
   | assignment_statement
   | exit_statement
   | GOTO IDENTIFIER SEMICOLON ;; goto_statement
-    %((progn
-      (wisi-statement-action [1 statement-start 3 statement-end])
-      (wisi-face-apply-action [2 nil font-lock-constant-face])))%
+    %((wisi-statement-action [1 statement-start 3 statement-end])
+      (wisi-face-apply-action [2 nil font-lock-constant-face]))%
   | procedure_call_statement
   | simple_return_statement
  ;; | entry_call_statement ; covered by procedure_call_statement
@@ -2347,51 +2245,46 @@ simple_statement
 
 single_protected_declaration
   : PROTECTED IDENTIFIER aspect_specification_opt IS NEW interface_list WITH 
protected_definition SEMICOLON
-    %((progn
-        (wisi-statement-action [1 statement-start 4 motion 7 motion 9 
statement-end])
-        (wisi-name-action 2)
-        (wisi-motion-action [1 4 7 [8 PRIVATE] 9])
-        (wisi-face-apply-action [2 nil font-lock-type-face])
-        (wisi-indent-action [nil ada-indent-broken nil nil ada-indent-broken 
ada-indent-broken ada-indent-broken nil
-                                 nil])))%
+    %((wisi-statement-action [1 statement-start 4 motion 7 motion 9 
statement-end])
+      (wisi-name-action 2)
+      (wisi-motion-action [1 4 7 [8 PRIVATE] 9])
+      (wisi-face-apply-action [2 nil font-lock-type-face])
+      (wisi-indent-action [nil ada-indent-broken nil nil ada-indent-broken 
ada-indent-broken ada-indent-broken nil
+                                 nil]))%
     %((wisi-match-names 2 8))%
 
   | PROTECTED IDENTIFIER aspect_specification_opt IS protected_definition 
SEMICOLON
-    %((progn
-        (wisi-statement-action [1 statement-start 4 motion 6 statement-end])
-        (wisi-name-action 2)
-        (wisi-motion-action [1 4 [5 PRIVATE] 6])
-        (wisi-face-apply-action [2 nil font-lock-type-face])
-        (wisi-indent-action [nil ada-indent-broken nil [nil ada-indent] nil 
nil])))%
+    %((wisi-statement-action [1 statement-start 4 motion 6 statement-end])
+      (wisi-name-action 2)
+      (wisi-motion-action [1 4 [5 PRIVATE] 6])
+      (wisi-face-apply-action [2 nil font-lock-type-face])
+      (wisi-indent-action [nil ada-indent-broken nil [nil ada-indent] nil 
nil]))%
     %((wisi-match-names 2 5))%
   ;
 
 single_task_declaration
   : TASK IDENTIFIER aspect_specification_opt IS NEW interface_list WITH 
task_definition END identifier_opt SEMICOLON
-    %((progn
-        (wisi-statement-action [1 statement-start 4 motion 11 statement-end])
-        (wisi-name-action 2)
-        (wisi-motion-action [1 4 [8 PRIVATE] 11])
-        (wisi-face-apply-action [2 nil font-lock-type-face 9 nil 
font-lock-type-face])
-        (wisi-indent-action [nil ada-indent-broken nil nil ada-indent-broken 
ada-indent-broken ada-indent-broken nil
-                                 nil nil nil])))%
+    %((wisi-statement-action [1 statement-start 4 motion 11 statement-end])
+      (wisi-name-action 2)
+      (wisi-motion-action [1 4 [8 PRIVATE] 11])
+      (wisi-face-apply-action [2 nil font-lock-type-face 9 nil 
font-lock-type-face])
+      (wisi-indent-action [nil ada-indent-broken nil nil ada-indent-broken 
ada-indent-broken ada-indent-broken nil
+                                 nil nil nil]))%
     %((wisi-match-names 2 10))%
 
   | TASK IDENTIFIER aspect_specification_opt IS task_definition END 
identifier_opt SEMICOLON
-    %((progn
-        (wisi-statement-action [1 statement-start 4 motion 8 statement-end])
-        (wisi-name-action 2)
-        (wisi-motion-action [1 4 [5 PRIVATE] 8])
-        (wisi-face-apply-action [2 nil font-lock-type-face 6 nil 
font-lock-type-face])
-        (wisi-indent-action [nil ada-indent-broken nil [nil ada-indent] nil 
nil nil nil])))%
+    %((wisi-statement-action [1 statement-start 4 motion 8 statement-end])
+      (wisi-name-action 2)
+      (wisi-motion-action [1 4 [5 PRIVATE] 8])
+      (wisi-face-apply-action [2 nil font-lock-type-face 6 nil 
font-lock-type-face])
+      (wisi-indent-action [nil ada-indent-broken nil [nil ada-indent] nil nil 
nil nil]))%
     %((wisi-match-names 2 7))%
 
   | TASK IDENTIFIER aspect_specification_opt SEMICOLON
-    %((progn
-        (wisi-statement-action [1 statement-start 4 statement-end])
-        (wisi-name-action 2)
-        (wisi-face-apply-action [2 nil font-lock-type-face])
-        (wisi-indent-action [nil ada-indent-broken nil nil])))%
+    %((wisi-statement-action [1 statement-start 4 statement-end])
+      (wisi-name-action 2)
+      (wisi-face-apply-action [2 nil font-lock-type-face])
+      (wisi-indent-action [nil ada-indent-broken nil nil]))%
   ;
 
 statement
@@ -2403,20 +2296,18 @@ statement
 subprogram_body
   : overriding_indicator_opt subprogram_specification aspect_specification_opt 
IS declarative_part_opt
     BEGIN handled_sequence_of_statements END name_opt SEMICOLON
-    %((progn
-      (wisi-statement-action [1 statement-start 2 statement-override 4 motion 
6 motion 10 statement-end])
+    %((wisi-statement-action [1 statement-start 2 statement-override 4 motion 
6 motion 10 statement-end])
       (wisi-motion-action [1 2 4 6 [7 WHEN] 10])
       (wisi-face-apply-action [9 font-lock-function-name-face 
font-lock-function-name-face])
       (wisi-indent-action [nil [nil ada-indent] nil nil [ada-indent ada-indent]
-                             nil [ada-indent ada-indent] nil ada-indent-broken 
nil])))%
+                             nil [ada-indent ada-indent] nil ada-indent-broken 
nil]))%
     %((wisi-match-names 2 9))%
   ;
 
 subprogram_body_stub
   : overriding_indicator_opt subprogram_specification IS SEPARATE 
aspect_specification_opt SEMICOLON
-    %((progn
-      (wisi-statement-action [1 statement-start 2 statement-override 6 
statement-end])
-      (wisi-indent-action [nil nil nil ada-indent-broken ada-indent-broken 
nil])))%
+    %((wisi-statement-action [1 statement-start 2 statement-override 6 
statement-end])
+      (wisi-indent-action [nil nil nil ada-indent-broken ada-indent-broken 
nil]))%
   ;
 
 subprogram_declaration
@@ -2432,10 +2323,9 @@ subprogram_default
 
 subprogram_renaming_declaration
   : overriding_indicator_opt subprogram_specification RENAMES name 
aspect_specification_opt SEMICOLON
-    %((progn
-      (wisi-statement-action [1 statement-start 2 statement-override 6 
statement-end])
+    %((wisi-statement-action [1 statement-start 2 statement-override 6 
statement-end])
       (wisi-face-apply-action [4 font-lock-function-name-face 
font-lock-function-name-face])
-      (wisi-indent-action [nil nil (ada-indent-renames 2) ada-indent-broken 
ada-indent-broken nil])))%
+      (wisi-indent-action [nil nil (ada-indent-renames 2) ada-indent-broken 
ada-indent-broken nil]))%
   ;
 
 subprogram_specification
@@ -2449,11 +2339,10 @@ subprogram_specification
 
 subtype_declaration
   : SUBTYPE IDENTIFIER IS subtype_indication aspect_specification_opt SEMICOLON
-    %((progn
-        (wisi-statement-action [1 statement-start 6 statement-end])
-        (wisi-name-action 2)
-        (wisi-face-apply-action [2 nil font-lock-type-face])
-        (wisi-indent-action [nil ada-indent-broken ada-indent-broken 
ada-indent-broken nil nil])))%
+    %((wisi-statement-action [1 statement-start 6 statement-end])
+      (wisi-name-action 2)
+      (wisi-face-apply-action [2 nil font-lock-type-face])
+      (wisi-indent-action [nil ada-indent-broken ada-indent-broken 
ada-indent-broken nil nil]))%
   ;
 
 subtype_indication
@@ -2474,31 +2363,28 @@ subtype_indication
 
 subunit
   : SEPARATE LEFT_PAREN name RIGHT_PAREN proper_body
-    %((progn
-      (wisi-statement-action [1 statement-start 5 statement-override])
-      (wisi-indent-action [nil ada-indent-broken (wisi-anchored 2 1) 
(wisi-anchored 2 0) nil])))%
+    %((wisi-statement-action [1 statement-start 5 statement-override])
+      (wisi-indent-action [nil ada-indent-broken (wisi-anchored 2 1) 
(wisi-anchored 2 0) nil]))%
   ;
 
 task_body
   : TASK BODY IDENTIFIER aspect_specification_opt IS declarative_part_opt
     BEGIN handled_sequence_of_statements END identifier_opt SEMICOLON
-    %((progn
-        (wisi-statement-action [1 statement-start 5 motion 7 motion 11 
statement-end])
-        (wisi-name-action 3)
-        (wisi-motion-action [1 5 7 [8 WHEN] 11])
-        (wisi-face-apply-action [3 nil font-lock-type-face 10 nil 
font-lock-type-face])
-        (wisi-indent-action [nil nil ada-indent-broken nil nil [ada-indent 
ada-indent]
-                               nil [ada-indent ada-indent] nil nil nil])))%
+    %((wisi-statement-action [1 statement-start 5 motion 7 motion 11 
statement-end])
+      (wisi-name-action 3)
+      (wisi-motion-action [1 5 7 [8 WHEN] 11])
+      (wisi-face-apply-action [3 nil font-lock-type-face 10 nil 
font-lock-type-face])
+      (wisi-indent-action [nil nil ada-indent-broken nil nil [ada-indent 
ada-indent]
+                               nil [ada-indent ada-indent] nil nil nil]))%
     %((wisi-match-names 3 10))%
   ;
 
 task_body_stub
   : TASK BODY IDENTIFIER IS SEPARATE aspect_specification_opt SEMICOLON
-    %((progn
-        (wisi-statement-action [1 statement-start 7 statement-end])
-        (wisi-name-action 3)
-        (wisi-face-apply-action [3 nil font-lock-type-face])
-        (wisi-indent-action [nil nil ada-indent-broken nil ada-indent-broken 
ada-indent-broken nil])))%
+    %((wisi-statement-action [1 statement-start 7 statement-end])
+      (wisi-name-action 3)
+      (wisi-face-apply-action [3 nil font-lock-type-face])
+      (wisi-indent-action [nil nil ada-indent-broken nil ada-indent-broken 
ada-indent-broken nil]))%
   ;
 
 ;; LRM includes 'end identifier' here; we put that in
@@ -2506,9 +2392,8 @@ task_body_stub
 ;; actions.
 task_definition
   : declarative_part_opt PRIVATE declarative_part_opt
-    %((progn
-      (wisi-statement-action [2 motion])
-      (wisi-indent-action [[ada-indent ada-indent] nil [ada-indent 
ada-indent]])))%
+    %((wisi-statement-action [2 motion])
+      (wisi-indent-action [[ada-indent ada-indent] nil [ada-indent 
ada-indent]]))%
   | declarative_part_opt
     %((wisi-indent-action [[ada-indent ada-indent]]))%
   ;
@@ -2518,30 +2403,27 @@ task_definition
 task_type_declaration
   : TASK TYPE IDENTIFIER discriminant_part_opt aspect_specification_opt IS
     NEW interface_list WITH task_definition END identifier_opt SEMICOLON
-    %((progn
-        (wisi-statement-action [1 statement-start 6 motion 9 motion 13 
statement-end])
-        (wisi-name-action 3)
-        (wisi-motion-action [1 6 9 [10 PRIVATE] 13])
-        (wisi-face-apply-action [3 nil font-lock-type-face 12 nil 
font-lock-type-face])
-        (wisi-indent-action [nil ada-indent-broken ada-indent-broken 
ada-indent-broken nil nil
-                               ada-indent-broken ada-indent-broken 
ada-indent-broken nil nil nil nil])))%
+    %((wisi-statement-action [1 statement-start 6 motion 9 motion 13 
statement-end])
+      (wisi-name-action 3)
+      (wisi-motion-action [1 6 9 [10 PRIVATE] 13])
+      (wisi-face-apply-action [3 nil font-lock-type-face 12 nil 
font-lock-type-face])
+      (wisi-indent-action [nil ada-indent-broken ada-indent-broken 
ada-indent-broken nil nil
+                               ada-indent-broken ada-indent-broken 
ada-indent-broken nil nil nil nil]))%
     %((wisi-match-names 3 12))%
   | TASK TYPE IDENTIFIER discriminant_part_opt aspect_specification_opt IS 
task_definition END identifier_opt SEMICOLON
-    %((progn
-        (wisi-statement-action [1 statement-start 6 motion 10 statement-end])
-        (wisi-name-action 3)
-        (wisi-face-apply-action [3 nil font-lock-type-face 9 nil 
font-lock-type-face])
-        (wisi-motion-action [1 6 [7 PRIVATE] 10])
-        (wisi-indent-action [nil ada-indent-broken ada-indent-broken 
ada-indent-broken nil [nil ada-indent] nil nil nil
-                                 nil])))%
+    %((wisi-statement-action [1 statement-start 6 motion 10 statement-end])
+      (wisi-name-action 3)
+      (wisi-face-apply-action [3 nil font-lock-type-face 9 nil 
font-lock-type-face])
+      (wisi-motion-action [1 6 [7 PRIVATE] 10])
+      (wisi-indent-action [nil ada-indent-broken ada-indent-broken 
ada-indent-broken nil [nil ada-indent] nil nil nil
+                                 nil]))%
     %((wisi-match-names 3 9))%
 
   | TASK TYPE IDENTIFIER discriminant_part_opt aspect_specification_opt 
SEMICOLON
-    %((progn
-        (wisi-statement-action [1 statement-start 6 statement-end])
-        (wisi-name-action 3)
-        (wisi-face-apply-action [3 nil font-lock-type-face])
-        (wisi-indent-action [nil ada-indent-broken ada-indent-broken 
ada-indent-broken nil nil])))%
+    %((wisi-statement-action [1 statement-start 6 statement-end])
+      (wisi-name-action 3)
+      (wisi-face-apply-action [3 nil font-lock-type-face])
+      (wisi-indent-action [nil ada-indent-broken ada-indent-broken 
ada-indent-broken nil nil]))%
   ;
 
 term
@@ -2561,10 +2443,9 @@ tick
 
 timed_entry_call
   : SELECT entry_call_alternative OR delay_alternative END SELECT SEMICOLON
-    %((progn
-        (wisi-statement-action [1 statement-start 3 motion 6 statement-end])
-        (wisi-motion-action [1 3 6])
-        (wisi-indent-action [nil [ada-indent ada-indent] nil [ada-indent 
ada-indent] nil nil nil])))%
+    %((wisi-statement-action [1 statement-start 3 motion 6 statement-end])
+      (wisi-motion-action [1 3 6])
+      (wisi-indent-action [nil [ada-indent ada-indent] nil [ada-indent 
ada-indent] nil nil nil]))%
   ;
 
 triggering_alternative
@@ -2596,10 +2477,9 @@ type_definition
 
 variant_part
   : CASE direct_name_opt IS variant_list END CASE SEMICOLON
-    %((progn
-        (wisi-statement-action [1 statement-start 7 statement-end])
-        (wisi-motion-action [1 4 7])
-        (wisi-indent-action [nil ada-indent-broken nil ada-indent-when nil nil 
nil])))%
+    %((wisi-statement-action [1 statement-start 7 statement-end])
+      (wisi-motion-action [1 4 7])
+      (wisi-indent-action [nil ada-indent-broken nil ada-indent-when nil nil 
nil]))%
   ;
 
 variant_list
@@ -2610,53 +2490,45 @@ variant_list
 
 variant
   : WHEN discrete_choice_list EQUAL_GREATER component_list_opt
-    %((progn
-      (wisi-statement-action [1 motion])
+    %((wisi-statement-action [1 motion])
       ;; ada-indent-when applied in variant_part
-      (wisi-indent-action [nil (wisi-hanging nil ada-indent-broken) ada-indent 
[ada-indent ada-indent]])))%
+      (wisi-indent-action [nil (wisi-hanging nil ada-indent-broken) ada-indent 
[ada-indent ada-indent]]))%
   ;
 
 unary_adding_operator : PLUS | MINUS ; ;; + | -
 
 use_clause
   : USE ALL TYPE name_list SEMICOLON
-    %((progn
-      (wisi-statement-action [1 statement-start 5 statement-end])
+    %((wisi-statement-action [1 statement-start 5 statement-end])
       (wisi-face-apply-list-action [4 font-lock-function-name-face 
font-lock-type-face])
-      (wisi-indent-action [nil ada-indent-broken ada-indent-broken 
ada-indent-use nil])))%
+      (wisi-indent-action [nil ada-indent-broken ada-indent-broken 
ada-indent-use nil]))%
   | USE TYPE name_list SEMICOLON
-    %((progn
-      (wisi-statement-action [1 statement-start 4 statement-end])
+    %((wisi-statement-action [1 statement-start 4 statement-end])
       (wisi-face-apply-list-action [3 font-lock-function-name-face 
font-lock-type-face])
-      (wisi-indent-action [nil ada-indent-broken ada-indent-use nil])))%
+      (wisi-indent-action [nil ada-indent-broken ada-indent-use nil]))%
   | USE name_list SEMICOLON
-    %((progn
-      (wisi-statement-action [1 statement-start 3 statement-end])
+    %((wisi-statement-action [1 statement-start 3 statement-end])
       (wisi-face-apply-list-action [2 font-lock-function-name-face 
font-lock-function-name-face])
-      (wisi-indent-action [nil ada-indent-use nil])))%
+      (wisi-indent-action [nil ada-indent-use nil]))%
   ;
 
 with_clause
   : LIMITED PRIVATE WITH name_list SEMICOLON
-    %((progn
-      (wisi-statement-action [1 statement-start 5 statement-end])
+    %((wisi-statement-action [1 statement-start 5 statement-end])
       (wisi-face-apply-list-action [4 font-lock-function-name-face 
font-lock-function-name-face])
-      (wisi-indent-action [nil ada-indent-broken ada-indent-broken 
ada-indent-with nil])))%
+      (wisi-indent-action [nil ada-indent-broken ada-indent-broken 
ada-indent-with nil]))%
   | LIMITED WITH name_list SEMICOLON
-    %((progn
-      (wisi-statement-action [1 statement-start 4 statement-end])
+    %((wisi-statement-action [1 statement-start 4 statement-end])
       (wisi-face-apply-list-action [3 font-lock-function-name-face 
font-lock-function-name-face])
-      (wisi-indent-action [nil ada-indent-broken ada-indent-with nil])))%
+      (wisi-indent-action [nil ada-indent-broken ada-indent-with nil]))%
   | PRIVATE WITH name_list SEMICOLON
-    %((progn
-      (wisi-statement-action [1 statement-start 4 statement-end])
+    %((wisi-statement-action [1 statement-start 4 statement-end])
       (wisi-face-apply-list-action [3 font-lock-function-name-face 
font-lock-function-name-face])
-      (wisi-indent-action [nil ada-indent-broken ada-indent-with nil])))%
+      (wisi-indent-action [nil ada-indent-broken ada-indent-with nil]))%
   | WITH name_list SEMICOLON
-    %((progn
-      (wisi-statement-action [1 statement-start 3 statement-end])
+    %((wisi-statement-action [1 statement-start 3 statement-end])
       (wisi-face-apply-list-action [2 font-lock-function-name-face 
font-lock-function-name-face])
-      (wisi-indent-action [nil ada-indent-with nil])))%
+      (wisi-indent-action [nil ada-indent-with nil]))%
   ;
 
 ;;; end of file
diff --git a/packages/ada-mode/ada_lr1_parse_table.txt.gz 
b/packages/ada-mode/ada_lr1_parse_table.txt.gz
index 4192eb5..4ea747c 100644
Binary files a/packages/ada-mode/ada_lr1_parse_table.txt.gz and 
b/packages/ada-mode/ada_lr1_parse_table.txt.gz differ
diff --git a/packages/ada-mode/ada_mode_wisi_parse.gpr.gp 
b/packages/ada-mode/ada_mode_wisi_parse.gpr.gp
index 52b6503..95b3e16 100644
--- a/packages/ada-mode/ada_mode_wisi_parse.gpr.gp
+++ b/packages/ada-mode/ada_mode_wisi_parse.gpr.gp
@@ -2,7 +2,7 @@
 --
 --  build ada_mode_wisi_parse and other executables
 --
---  Copyright (C) 2014, 2018 Free Software Foundation, Inc.
+--  Copyright (C) 2014, 2018, 2019 Free Software Foundation, Inc.
 --
 --  This program is free software; you can redistribute it and/or
 --  modify it under terms of the GNU General Public License as
@@ -22,9 +22,15 @@ with "wisi";
 with "wisitoken";
 #end if;
 with "standard_common";
-#if HAVE_LIBADALANG="yes"
-with "libadalang";
+with "gnatcoll";
+with "gnatcoll_sqlite";
+#if HAVE_GNATCOLL_XREF="yes"
+with "gnatcoll_xref";
 #end if;
+with "gnat_util";
+--  #if HAVE_LIBADALANG="yes"
+--  with "libadalang";
+--  #end if;
 project Ada_Mode_Wisi_Parse is
 
    for Main use
@@ -32,11 +38,12 @@ project Ada_Mode_Wisi_Parse is
       "ada_mode_wisi_lr1_parse.ads",
       "run_ada_lalr_parse.ads",
       "run_ada_lr1_parse.ads",
-#if HAVE_LIBADALANG="yes"
-      "run_ada_libadalang_parse.ads",
-#end if;
+--  #if HAVE_LIBADALANG="yes"
+--        "run_ada_libadalang_parse.ads",
+--  #end if;
       "gpr_mode_wisi_parse.ads",
-      "run_gpr_parse.ads"
+      "run_gpr_parse.ads",
+      "gpr_query.adb"
      );
 
    for Source_Dirs use (".");
@@ -122,8 +129,6 @@ project Ada_Mode_Wisi_Parse is
 
       for Global_Compilation_Switches ("Ada") use 
Standard_Common.Builder'Global_Compilation_Switches ("Ada");
 
-      --  We use ".exe" extension even on non-Windows, to simplify the 
makefiles.
-      for Executable_Suffix use ".exe";
    end Builder;
 
    package Binder is
diff --git a/packages/ada-mode/ada_process_actions.adb 
b/packages/ada-mode/ada_process_actions.adb
index e59620b..10a0128 100644
--- a/packages/ada-mode/ada_process_actions.adb
+++ b/packages/ada-mode/ada_process_actions.adb
@@ -251,8 +251,9 @@ package body Ada_Process_Actions is
       when Face =>
          null;
       when Indent =>
-         Indent_Action_0 (Parse_Data, Tree, Nonterm, Tokens, ((False, (Simple, 
(Label => None))), (True, (Simple,
-         (Anchored_0, 1, 1)), (Simple, (Anchored_0, 1, 1))), (False, (Simple, 
(Anchored_0, 1, 0)))));
+         Indent_Action_0 (Parse_Data, Tree, Nonterm, Tokens, ((False, (Simple, 
(Label => None))), (False, (Simple,
+         (Anchored_0, 1, 1))), (False, (Simple, (Anchored_0, 1, 1))), (False, 
(Simple, (Anchored_0, 1, 1))), (True,
+         (Simple, (Anchored_0, 1, 1)), (Simple, (Anchored_0, 1, 1))), (False, 
(Simple, (Anchored_0, 1, 0)))));
       end case;
    end aggregate_3;
 
@@ -275,6 +276,25 @@ package body Ada_Process_Actions is
       end case;
    end aggregate_4;
 
+   procedure aggregate_5
+    (User_Data : in out WisiToken.Syntax_Trees.User_Data_Type'Class;
+     Tree      : in out WisiToken.Syntax_Trees.Tree;
+     Nonterm   : in     WisiToken.Syntax_Trees.Valid_Node_Index;
+     Tokens    : in     WisiToken.Syntax_Trees.Valid_Node_Index_Array)
+   is
+      Parse_Data : Wisi.Parse_Data_Type renames Wisi.Parse_Data_Type 
(User_Data);
+   begin
+      case Parse_Data.Post_Parse_Action is
+      when Navigate =>
+         null;
+      when Face =>
+         null;
+      when Indent =>
+         Indent_Action_0 (Parse_Data, Tree, Nonterm, Tokens, ((False, (Simple, 
(Label => None))), (True, (Simple,
+         (Anchored_0, 1, 1)), (Simple, (Anchored_0, 1, 1))), (False, (Simple, 
(Anchored_0, 1, 0)))));
+      end case;
+   end aggregate_5;
+
    procedure array_type_definition_0
     (User_Data : in out WisiToken.Syntax_Trees.User_Data_Type'Class;
      Tree      : in out WisiToken.Syntax_Trees.Tree;
@@ -329,7 +349,9 @@ package body Ada_Process_Actions is
       when Face =>
          null;
       when Indent =>
-         null;
+         Indent_Action_0 (Parse_Data, Tree, Nonterm, Tokens, ((False, (Simple, 
(Label => None))), (False, (Simple,
+         (Int, Ada_Indent_Broken))), (False, (Simple, (Int, 
Ada_Indent_Broken))), (False, (Simple, (Int,
+         Ada_Indent_Broken))), (False, (Simple, (Label => None)))));
       end case;
    end aspect_clause_0;
 
@@ -446,11 +468,32 @@ package body Ada_Process_Actions is
       when Face =>
          null;
       when Indent =>
-         Indent_Action_0 (Parse_Data, Tree, Nonterm, Tokens, (1 => (True, 
(Hanging_0, (Label => None), (Int,
+         Indent_Action_0 (Parse_Data, Tree, Nonterm, Tokens, ((False, (Simple, 
(Label => None))), (False, (Simple,
+         (Label => None))), (False, (Simple, (Label => None))), (False, 
(Hanging_0, (Label => None), (Int,
+         Ada_Indent_Broken))), (False, (Simple, (Int, Ada_Indent_Broken))), 
(True, (Hanging_0, (Label => None), (Int,
          Ada_Indent_Broken)), (Hanging_0, (Label => None), (Int, 
Ada_Indent_Broken)))));
       end case;
    end association_opt_4;
 
+   procedure association_opt_5
+    (User_Data : in out WisiToken.Syntax_Trees.User_Data_Type'Class;
+     Tree      : in out WisiToken.Syntax_Trees.Tree;
+     Nonterm   : in     WisiToken.Syntax_Trees.Valid_Node_Index;
+     Tokens    : in     WisiToken.Syntax_Trees.Valid_Node_Index_Array)
+   is
+      Parse_Data : Wisi.Parse_Data_Type renames Wisi.Parse_Data_Type 
(User_Data);
+   begin
+      case Parse_Data.Post_Parse_Action is
+      when Navigate =>
+         null;
+      when Face =>
+         null;
+      when Indent =>
+         Indent_Action_0 (Parse_Data, Tree, Nonterm, Tokens, (1 => (True, 
(Hanging_0, (Label => None), (Int,
+         Ada_Indent_Broken)), (Hanging_0, (Label => None), (Int, 
Ada_Indent_Broken)))));
+      end case;
+   end association_opt_5;
+
    procedure asynchronous_select_0
     (User_Data : in out WisiToken.Syntax_Trees.User_Data_Type'Class;
      Tree      : in out WisiToken.Syntax_Trees.Tree;
@@ -659,8 +702,7 @@ package body Ada_Process_Actions is
       when Face =>
          null;
       when Indent =>
-         Indent_Action_0 (Parse_Data, Tree, Nonterm, Tokens, ((False, (Simple, 
(Label => None))), (True, (Simple,
-         (Label => None)), (Simple, (Int, Ada_Indent_When))), (False, (Simple, 
(Label => None)))));
+         null;
       end case;
    end case_expression_alternative_list_0;
 
@@ -969,7 +1011,10 @@ package body Ada_Process_Actions is
       when Face =>
          Face_Apply_Action (Parse_Data, Tree, Nonterm, Tokens, (1 => (3, 1, 
2)));
       when Indent =>
-         null;
+         Indent_Action_0 (Parse_Data, Tree, Nonterm, Tokens, ((False, (Simple, 
(Label => None))), (False, (Simple,
+         (Label => None))), (False, (Simple, (Label => None))), (False, 
(Simple, (Label => None))), (True, (Simple,
+         (Label => None)), (Simple, (Language, Ada_Indent_Record_1'Access, 69 
& 6 & 0))), (False, (Simple, (Label =>
+         None)))));
       end case;
    end derived_type_definition_0;
 
@@ -1769,9 +1814,9 @@ package body Ada_Process_Actions is
          Face_Apply_Action (Parse_Data, Tree, Nonterm, Tokens, (1 => (2, 3, 
2)));
       when Indent =>
          Indent_Action_0 (Parse_Data, Tree, Nonterm, Tokens, ((False, (Simple, 
(Label => None))), (False, (Simple,
-         (Int, Ada_Indent_Broken))), (False, (Simple, (Int, 
Ada_Indent_Broken))), (False, (Simple, (Int,
-         Ada_Indent_Broken))), (False, (Simple, (Int, Ada_Indent_Broken))), 
(False, (Simple, (Label => None))), (False,
-         (Simple, (Label => None)))));
+         (Int, Ada_Indent_Broken))), (False, (Simple, (Int, 
Ada_Indent_Broken))), (True, (Simple, (Int,
+         Ada_Indent_Broken)), (Simple, (Language, Ada_Indent_Record_1'Access, 
69 & 5 & Ada_Indent_Broken))), (False,
+         (Simple, (Int, Ada_Indent_Broken))), (False, (Simple, (Label => 
None))), (False, (Simple, (Label => None)))));
       end case;
    end full_type_declaration_0;
 
@@ -3877,11 +3922,12 @@ package body Ada_Process_Actions is
          Face_Apply_Action (Parse_Data, Tree, Nonterm, Tokens, (1 => (2, 1, 
2)));
       when Indent =>
          Indent_Action_0 (Parse_Data, Tree, Nonterm, Tokens, ((False, (Simple, 
(Label => None))), (False, (Simple,
-         (Int, Ada_Indent_Broken))), (False, (Simple, (Int, 
Ada_Indent_Broken))), (False, (Simple, (Language,
-         Ada_Indent_Record_0'Access, 1 & 4 & 0))), (False, (Simple, (Language, 
Ada_Indent_Record_0'Access, 1 & 4 &
-         Ada_Indent))), (False, (Simple, (Language, 
Ada_Indent_Record_0'Access, 1 & 4 & Ada_Indent))), (False, (Simple,
-         (Language, Ada_Indent_Record_0'Access, 1 & 4 & 0))), (False, (Simple, 
(Label => None))), (False, (Simple,
-         (Label => None)))));
+         (Int, Ada_Indent_Broken))), (False, (Simple, (Int, 
Ada_Indent_Broken))), (True, (Simple, (Language,
+         Ada_Indent_Record_1'Access, 28 & 4 & 0)), (Simple, (Language, 
Ada_Indent_Record_1'Access, 28 & 4 &
+         Ada_Indent))), (False, (Simple, (Language, 
Ada_Indent_Record_0'Access, 1 & 4 & Ada_Indent))), (True, (Simple,
+         (Language, Ada_Indent_Record_1'Access, 28 & 4 & Ada_Indent)), 
(Simple, (Language, Ada_Indent_Record_1'Access,
+         28 & 4 & Ada_Indent))), (False, (Simple, (Language, 
Ada_Indent_Record_1'Access, 28 & 4 & 0))), (False,
+         (Simple, (Label => None))), (False, (Simple, (Label => None)))));
       end case;
    end record_representation_clause_0;
 
diff --git a/packages/ada-mode/ada_process_actions.ads 
b/packages/ada-mode/ada_process_actions.ads
index bb8a6bf..ab2ace3 100644
--- a/packages/ada-mode/ada_process_actions.ads
+++ b/packages/ada-mode/ada_process_actions.ads
@@ -24,15 +24,15 @@ package Ada_Process_Actions is
 
    Descriptor : aliased WisiToken.Descriptor :=
      (First_Terminal    => 3,
-      Last_Terminal     => 107,
-      First_Nonterminal => 108,
-      Last_Nonterminal  => 332,
-      EOI_ID            => 107,
-      Accept_ID         => 108,
+      Last_Terminal     => 108,
+      First_Nonterminal => 109,
+      Last_Nonterminal  => 333,
+      EOI_ID            => 108,
+      Accept_ID         => 109,
       Case_Insensitive  => True,
       New_Line_ID       => 1,
-      String_1_ID       => 106,
-      String_2_ID       => 105,
+      String_1_ID       => 107,
+      String_2_ID       => 106,
       Image             =>
         (new String'("WHITESPACE"),
          new String'("NEW_LINE"),
@@ -113,6 +113,7 @@ package Ada_Process_Actions is
          new String'("LEFT_PAREN"),
          new String'("RIGHT_PAREN"),
          new String'("AMPERSAND"),
+         new String'("AT_SIGN"),
          new String'("BAR"),
          new String'("BOX"),
          new String'("COLON"),
@@ -369,7 +370,7 @@ package Ada_Process_Actions is
          new String'("with_clause")),
       Terminal_Image_Width => 17,
       Image_Width          => 38,
-      Last_Lookahead       => 107);
+      Last_Lookahead       => 108);
 
    type Token_Enum_ID is
      (WHITESPACE_ID,
@@ -451,6 +452,7 @@ package Ada_Process_Actions is
       LEFT_PAREN_ID,
       RIGHT_PAREN_ID,
       AMPERSAND_ID,
+      AT_SIGN_ID,
       BAR_ID,
       BOX_ID,
       COLON_ID,
@@ -774,6 +776,11 @@ package Ada_Process_Actions is
      Tree      : in out WisiToken.Syntax_Trees.Tree;
      Nonterm   : in     WisiToken.Syntax_Trees.Valid_Node_Index;
      Tokens    : in     WisiToken.Syntax_Trees.Valid_Node_Index_Array);
+   procedure aggregate_5
+    (User_Data : in out WisiToken.Syntax_Trees.User_Data_Type'Class;
+     Tree      : in out WisiToken.Syntax_Trees.Tree;
+     Nonterm   : in     WisiToken.Syntax_Trees.Valid_Node_Index;
+     Tokens    : in     WisiToken.Syntax_Trees.Valid_Node_Index_Array);
    procedure array_type_definition_0
     (User_Data : in out WisiToken.Syntax_Trees.User_Data_Type'Class;
      Tree      : in out WisiToken.Syntax_Trees.Tree;
@@ -819,6 +826,11 @@ package Ada_Process_Actions is
      Tree      : in out WisiToken.Syntax_Trees.Tree;
      Nonterm   : in     WisiToken.Syntax_Trees.Valid_Node_Index;
      Tokens    : in     WisiToken.Syntax_Trees.Valid_Node_Index_Array);
+   procedure association_opt_5
+    (User_Data : in out WisiToken.Syntax_Trees.User_Data_Type'Class;
+     Tree      : in out WisiToken.Syntax_Trees.Tree;
+     Nonterm   : in     WisiToken.Syntax_Trees.Valid_Node_Index;
+     Tokens    : in     WisiToken.Syntax_Trees.Valid_Node_Index_Array);
    procedure asynchronous_select_0
     (User_Data : in out WisiToken.Syntax_Trees.User_Data_Type'Class;
      Tree      : in out WisiToken.Syntax_Trees.Tree;
diff --git a/packages/ada-mode/ada_process_lalr_main.adb 
b/packages/ada-mode/ada_process_lalr_main.adb
index 9d686df..9af10b0 100644
--- a/packages/ada-mode/ada_process_lalr_main.adb
+++ b/packages/ada-mode/ada_process_lalr_main.adb
@@ -39,17 +39,17 @@ package body Ada_Process_LALR_Main is
       use WisiToken.Parse.LR;
       McKenzie_Param : constant McKenzie_Param_Type :=
         (First_Terminal    => 3,
-         Last_Terminal     => 107,
-         First_Nonterminal => 108,
-         Last_Nonterminal  => 332,
+         Last_Terminal     => 108,
+         First_Nonterminal => 109,
+         Last_Nonterminal  => 333,
          Insert =>
            (4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 2, 4, 4, 4, 4, 4, 4, 4, 4, 3, 
4, 4, 4, 4, 4, 4, 4, 2, 4, 4, 4, 4, 4, 4,
             4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
-            4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4),
+            4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4),
          Delete =>
            (4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
             4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
-            4, 4, 1, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4),
+            4, 4, 1, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 
4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4),
          Push_Back =>
            (2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
             2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
@@ -60,7 +60,7 @@ package body Ada_Process_LALR_Main is
             2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
             2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
             2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
-            2, 2, 2, 2, 2, 2),
+            2, 2, 2, 2, 2, 2, 2),
          Undo_Reduce =>
            (2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
             2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 2, 2, 2, 2, 2, 2, 
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
@@ -80,40 +80,40 @@ package body Ada_Process_LALR_Main is
 
       Table : constant Parse_Table_Ptr := new Parse_Table
         (State_First       => 0,
-         State_Last        => 1281,
+         State_Last        => 1292,
          First_Terminal    => 3,
-         Last_Terminal     => 107,
-         First_Nonterminal => 108,
-         Last_Nonterminal  => 332);
+         Last_Terminal     => 108,
+         First_Nonterminal => 109,
+         Last_Nonterminal  => 333);
    begin
       Table.McKenzie_Param := McKenzie_Param;
       declare
          procedure Subr_1
          is begin
-            Table.States (0).Action_List.Set_Capacity (38);
+            Table.States (0).Action_List.Set_Capacity (39);
             Add_Action (Table.States (0), 4, 1);
             Add_Action (Table.States (0), 5, 2);
-            Add_Action (Table.States (0), 13, Reduce, (132, 1), 0, null, null);
+            Add_Action (Table.States (0), 13, Reduce, (133, 1), 0, null, null);
             Add_Action (Table.States (0), 15, 3);
-            Add_Action (Table.States (0), 17, Reduce, (132, 1), 0, null, null);
+            Add_Action (Table.States (0), 17, Reduce, (133, 1), 0, null, null);
             Add_Action (Table.States (0), 18, 4);
-            Add_Action (Table.States (0), 25, Reduce, (246, 2), 0, null, null);
+            Add_Action (Table.States (0), 25, Reduce, (247, 2), 0, null, null);
             Add_Action (Table.States (0), 27, 5);
             Add_Action (Table.States (0), 28, 6);
-            Add_Conflict (Table.States (0), 28, (132, 1), 0, null, null);
-            Add_Action (Table.States (0), 29, Reduce, (246, 2), 0, null, null);
+            Add_Conflict (Table.States (0), 28, (133, 1), 0, null, null);
+            Add_Action (Table.States (0), 29, Reduce, (247, 2), 0, null, null);
             Add_Action (Table.States (0), 30, 8);
             Add_Action (Table.States (0), 31, 9);
             Add_Action (Table.States (0), 32, 10);
             Add_Action (Table.States (0), 36, 11);
-            Add_Action (Table.States (0), 37, Reduce, (132, 1), 0, null, null);
+            Add_Action (Table.States (0), 37, Reduce, (133, 1), 0, null, null);
             Add_Action (Table.States (0), 40, 12);
             Add_Action (Table.States (0), 41, 13);
             Add_Action (Table.States (0), 46, 14);
             Add_Action (Table.States (0), 47, 15);
             Add_Action (Table.States (0), 48, 16);
             Add_Action (Table.States (0), 49, 17);
-            Add_Action (Table.States (0), 50, Reduce, (246, 2), 0, null, null);
+            Add_Action (Table.States (0), 50, Reduce, (247, 2), 0, null, null);
             Add_Action (Table.States (0), 51, 19);
             Add_Action (Table.States (0), 52, 20);
             Add_Action (Table.States (0), 57, 21);
@@ -124,53 +124,53 @@ package body Ada_Process_LALR_Main is
             Add_Action (Table.States (0), 66, 26);
             Add_Action (Table.States (0), 69, 27);
             Add_Action (Table.States (0), 71, 28);
-            Add_Action (Table.States (0), 73, Reduce, (132, 1), 0, null, null);
+            Add_Action (Table.States (0), 73, Reduce, (133, 1), 0, null, null);
             Add_Action (Table.States (0), 74, 30);
-            Add_Action (Table.States (0), 93, 31);
-            Add_Action (Table.States (0), 104, 32);
+            Add_Action (Table.States (0), 79, 31);
+            Add_Action (Table.States (0), 94, 32);
             Add_Action (Table.States (0), 105, 33);
             Add_Action (Table.States (0), 106, 34);
+            Add_Action (Table.States (0), 107, 35);
             Table.States (0).Goto_List.Set_Capacity (83);
-            Add_Goto (Table.States (0), 112, 35);
             Add_Goto (Table.States (0), 113, 36);
-            Add_Goto (Table.States (0), 121, 37);
-            Add_Goto (Table.States (0), 123, 38);
-            Add_Goto (Table.States (0), 126, 39);
+            Add_Goto (Table.States (0), 114, 37);
+            Add_Goto (Table.States (0), 122, 38);
+            Add_Goto (Table.States (0), 124, 39);
             Add_Goto (Table.States (0), 127, 40);
             Add_Goto (Table.States (0), 128, 41);
-            Add_Goto (Table.States (0), 131, 42);
+            Add_Goto (Table.States (0), 129, 42);
             Add_Goto (Table.States (0), 132, 43);
             Add_Goto (Table.States (0), 133, 44);
             Add_Goto (Table.States (0), 134, 45);
             Add_Goto (Table.States (0), 135, 46);
-            Add_Goto (Table.States (0), 139, 47);
-            Add_Goto (Table.States (0), 142, 48);
+            Add_Goto (Table.States (0), 136, 47);
+            Add_Goto (Table.States (0), 140, 48);
             Add_Goto (Table.States (0), 143, 49);
-            Add_Goto (Table.States (0), 151, 50);
+            Add_Goto (Table.States (0), 144, 50);
             Add_Goto (Table.States (0), 152, 51);
-            Add_Goto (Table.States (0), 157, 52);
-            Add_Goto (Table.States (0), 161, 53);
-            Add_Goto (Table.States (0), 179, 54);
-            Add_Goto (Table.States (0), 182, 55);
-            Add_Goto (Table.States (0), 186, 56);
-            Add_Goto (Table.States (0), 190, 57);
-            Add_Goto (Table.States (0), 193, 58);
-            Add_Goto (Table.States (0), 196, 59);
-            Add_Goto (Table.States (0), 206, 60);
+            Add_Goto (Table.States (0), 153, 52);
+            Add_Goto (Table.States (0), 158, 53);
+            Add_Goto (Table.States (0), 162, 54);
+            Add_Goto (Table.States (0), 180, 55);
+            Add_Goto (Table.States (0), 183, 56);
+            Add_Goto (Table.States (0), 187, 57);
+            Add_Goto (Table.States (0), 191, 58);
+            Add_Goto (Table.States (0), 194, 59);
+            Add_Goto (Table.States (0), 197, 60);
             Add_Goto (Table.States (0), 207, 61);
-            Add_Goto (Table.States (0), 209, 62);
+            Add_Goto (Table.States (0), 208, 62);
             Add_Goto (Table.States (0), 210, 63);
-            Add_Goto (Table.States (0), 213, 64);
+            Add_Goto (Table.States (0), 211, 64);
             Add_Goto (Table.States (0), 214, 65);
             Add_Goto (Table.States (0), 215, 66);
             Add_Goto (Table.States (0), 216, 67);
             Add_Goto (Table.States (0), 217, 68);
-            Add_Goto (Table.States (0), 219, 69);
-            Add_Goto (Table.States (0), 222, 70);
+            Add_Goto (Table.States (0), 218, 69);
+            Add_Goto (Table.States (0), 220, 70);
             Add_Goto (Table.States (0), 223, 71);
-            Add_Goto (Table.States (0), 232, 72);
-            Add_Goto (Table.States (0), 239, 73);
-            Add_Goto (Table.States (0), 243, 74);
+            Add_Goto (Table.States (0), 224, 72);
+            Add_Goto (Table.States (0), 233, 73);
+            Add_Goto (Table.States (0), 240, 74);
             Add_Goto (Table.States (0), 244, 75);
             Add_Goto (Table.States (0), 245, 76);
             Add_Goto (Table.States (0), 246, 77);
@@ -179,24 +179,24 @@ package body Ada_Process_LALR_Main is
             Add_Goto (Table.States (0), 249, 80);
             Add_Goto (Table.States (0), 250, 81);
             Add_Goto (Table.States (0), 251, 82);
-            Add_Goto (Table.States (0), 257, 83);
-            Add_Goto (Table.States (0), 259, 84);
+            Add_Goto (Table.States (0), 252, 83);
+            Add_Goto (Table.States (0), 258, 84);
             Add_Goto (Table.States (0), 260, 85);
             Add_Goto (Table.States (0), 261, 86);
             Add_Goto (Table.States (0), 262, 87);
             Add_Goto (Table.States (0), 263, 88);
             Add_Goto (Table.States (0), 264, 89);
             Add_Goto (Table.States (0), 265, 90);
-            Add_Goto (Table.States (0), 271, 91);
+            Add_Goto (Table.States (0), 266, 91);
             Add_Goto (Table.States (0), 272, 92);
-            Add_Goto (Table.States (0), 276, 93);
-            Add_Goto (Table.States (0), 281, 94);
-            Add_Goto (Table.States (0), 289, 95);
+            Add_Goto (Table.States (0), 273, 93);
+            Add_Goto (Table.States (0), 277, 94);
+            Add_Goto (Table.States (0), 282, 95);
             Add_Goto (Table.States (0), 290, 96);
-            Add_Goto (Table.States (0), 293, 97);
+            Add_Goto (Table.States (0), 291, 97);
             Add_Goto (Table.States (0), 294, 98);
-            Add_Goto (Table.States (0), 298, 99);
-            Add_Goto (Table.States (0), 302, 100);
+            Add_Goto (Table.States (0), 295, 99);
+            Add_Goto (Table.States (0), 299, 100);
             Add_Goto (Table.States (0), 303, 101);
             Add_Goto (Table.States (0), 304, 102);
             Add_Goto (Table.States (0), 305, 103);
@@ -204,280 +204,287 @@ package body Ada_Process_LALR_Main is
             Add_Goto (Table.States (0), 307, 105);
             Add_Goto (Table.States (0), 308, 106);
             Add_Goto (Table.States (0), 309, 107);
-            Add_Goto (Table.States (0), 311, 108);
-            Add_Goto (Table.States (0), 313, 109);
-            Add_Goto (Table.States (0), 315, 110);
+            Add_Goto (Table.States (0), 310, 108);
+            Add_Goto (Table.States (0), 312, 109);
+            Add_Goto (Table.States (0), 314, 110);
             Add_Goto (Table.States (0), 316, 111);
             Add_Goto (Table.States (0), 317, 112);
-            Add_Goto (Table.States (0), 319, 113);
-            Add_Goto (Table.States (0), 323, 114);
-            Add_Goto (Table.States (0), 325, 115);
-            Add_Goto (Table.States (0), 331, 116);
+            Add_Goto (Table.States (0), 318, 113);
+            Add_Goto (Table.States (0), 320, 114);
+            Add_Goto (Table.States (0), 324, 115);
+            Add_Goto (Table.States (0), 326, 116);
             Add_Goto (Table.States (0), 332, 117);
+            Add_Goto (Table.States (0), 333, 118);
             Table.States (0).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 41, 13)));
             Table.States (1).Action_List.Set_Capacity (1);
-            Add_Action (Table.States (1), 104, 118);
-            Table.States (1).Kernel := To_Vector (((113, 4, 4, False), (113, 
4, 2, False)));
-            Table.States (1).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 104, 118)));
-            Table.States (2).Action_List.Set_Capacity (3);
-            Add_Action (Table.States (2), 104, 119);
-            Add_Action (Table.States (2), 105, 33);
+            Add_Action (Table.States (1), 105, 119);
+            Table.States (1).Kernel := To_Vector (((114, 4, 4, False), (114, 
4, 2, False)));
+            Table.States (1).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 105, 119)));
+            Table.States (2).Action_List.Set_Capacity (4);
+            Add_Action (Table.States (2), 79, 31);
+            Add_Action (Table.States (2), 105, 120);
             Add_Action (Table.States (2), 106, 34);
+            Add_Action (Table.States (2), 107, 35);
             Table.States (2).Goto_List.Set_Capacity (4);
-            Add_Goto (Table.States (2), 128, 41);
-            Add_Goto (Table.States (2), 239, 120);
-            Add_Goto (Table.States (2), 272, 92);
-            Add_Goto (Table.States (2), 293, 97);
-            Table.States (2).Kernel := To_Vector ((0 => (303, 5, 2, False)));
-            Table.States (2).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 104, 119)));
-            Table.States (3).Action_List.Set_Capacity (13);
-            Add_Action (Table.States (3), 3, 121);
-            Add_Action (Table.States (3), 35, Reduce, (192, 1), 0, null, null);
-            Add_Action (Table.States (3), 39, 122);
-            Add_Action (Table.States (3), 40, 123);
-            Add_Action (Table.States (3), 41, 124);
-            Add_Action (Table.States (3), 52, 125);
-            Add_Action (Table.States (3), 76, 126);
-            Add_Action (Table.States (3), 94, 127);
+            Add_Goto (Table.States (2), 129, 42);
+            Add_Goto (Table.States (2), 240, 121);
+            Add_Goto (Table.States (2), 273, 93);
+            Add_Goto (Table.States (2), 294, 98);
+            Table.States (2).Kernel := To_Vector ((0 => (304, 5, 2, False)));
+            Table.States (2).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 105, 120)));
+            Table.States (3).Action_List.Set_Capacity (14);
+            Add_Action (Table.States (3), 3, 122);
+            Add_Action (Table.States (3), 35, Reduce, (193, 1), 0, null, null);
+            Add_Action (Table.States (3), 39, 123);
+            Add_Action (Table.States (3), 40, 124);
+            Add_Action (Table.States (3), 41, 125);
+            Add_Action (Table.States (3), 52, 126);
+            Add_Action (Table.States (3), 76, 127);
+            Add_Action (Table.States (3), 79, 31);
             Add_Action (Table.States (3), 95, 128);
-            Add_Action (Table.States (3), 103, 129);
-            Add_Action (Table.States (3), 104, 119);
-            Add_Action (Table.States (3), 105, 33);
+            Add_Action (Table.States (3), 96, 129);
+            Add_Action (Table.States (3), 104, 130);
+            Add_Action (Table.States (3), 105, 120);
             Add_Action (Table.States (3), 106, 34);
+            Add_Action (Table.States (3), 107, 35);
             Table.States (3).Goto_List.Set_Capacity (20);
-            Add_Goto (Table.States (3), 117, 130);
-            Add_Goto (Table.States (3), 128, 41);
-            Add_Goto (Table.States (3), 191, 131);
+            Add_Goto (Table.States (3), 118, 131);
+            Add_Goto (Table.States (3), 129, 42);
             Add_Goto (Table.States (3), 192, 132);
-            Add_Goto (Table.States (3), 197, 133);
-            Add_Goto (Table.States (3), 239, 134);
-            Add_Goto (Table.States (3), 258, 135);
-            Add_Goto (Table.States (3), 272, 92);
-            Add_Goto (Table.States (3), 275, 136);
-            Add_Goto (Table.States (3), 282, 137);
+            Add_Goto (Table.States (3), 193, 133);
+            Add_Goto (Table.States (3), 198, 134);
+            Add_Goto (Table.States (3), 240, 135);
+            Add_Goto (Table.States (3), 259, 136);
+            Add_Goto (Table.States (3), 273, 93);
+            Add_Goto (Table.States (3), 276, 137);
             Add_Goto (Table.States (3), 283, 138);
             Add_Goto (Table.States (3), 284, 139);
             Add_Goto (Table.States (3), 285, 140);
             Add_Goto (Table.States (3), 286, 141);
             Add_Goto (Table.States (3), 287, 142);
-            Add_Goto (Table.States (3), 293, 97);
-            Add_Goto (Table.States (3), 301, 143);
-            Add_Goto (Table.States (3), 320, 144);
+            Add_Goto (Table.States (3), 288, 143);
+            Add_Goto (Table.States (3), 294, 98);
+            Add_Goto (Table.States (3), 302, 144);
             Add_Goto (Table.States (3), 321, 145);
-            Add_Goto (Table.States (3), 330, 146);
-            Table.States (3).Kernel := To_Vector ((0 => (139, 15, 6, False)));
-            Table.States (3).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 192, 0)));
-            Table.States (4).Action_List.Set_Capacity (14);
-            Add_Action (Table.States (4), 3, 121);
-            Add_Action (Table.States (4), 39, 122);
-            Add_Action (Table.States (4), 40, 123);
-            Add_Action (Table.States (4), 41, 124);
-            Add_Action (Table.States (4), 52, 125);
-            Add_Action (Table.States (4), 70, 147);
-            Add_Action (Table.States (4), 76, 126);
-            Add_Action (Table.States (4), 94, 127);
+            Add_Goto (Table.States (3), 322, 146);
+            Add_Goto (Table.States (3), 331, 147);
+            Table.States (3).Kernel := To_Vector ((0 => (140, 15, 6, False)));
+            Table.States (3).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 193, 0)));
+            Table.States (4).Action_List.Set_Capacity (15);
+            Add_Action (Table.States (4), 3, 122);
+            Add_Action (Table.States (4), 39, 123);
+            Add_Action (Table.States (4), 40, 124);
+            Add_Action (Table.States (4), 41, 125);
+            Add_Action (Table.States (4), 52, 126);
+            Add_Action (Table.States (4), 70, 148);
+            Add_Action (Table.States (4), 76, 127);
+            Add_Action (Table.States (4), 79, 31);
             Add_Action (Table.States (4), 95, 128);
-            Add_Action (Table.States (4), 96, Reduce, (192, 1), 0, null, null);
-            Add_Action (Table.States (4), 103, 129);
-            Add_Action (Table.States (4), 104, 119);
-            Add_Action (Table.States (4), 105, 33);
+            Add_Action (Table.States (4), 96, 129);
+            Add_Action (Table.States (4), 97, Reduce, (193, 1), 0, null, null);
+            Add_Action (Table.States (4), 104, 130);
+            Add_Action (Table.States (4), 105, 120);
             Add_Action (Table.States (4), 106, 34);
+            Add_Action (Table.States (4), 107, 35);
             Table.States (4).Goto_List.Set_Capacity (20);
-            Add_Goto (Table.States (4), 117, 130);
-            Add_Goto (Table.States (4), 128, 41);
-            Add_Goto (Table.States (4), 191, 131);
-            Add_Goto (Table.States (4), 192, 148);
-            Add_Goto (Table.States (4), 197, 133);
-            Add_Goto (Table.States (4), 239, 134);
-            Add_Goto (Table.States (4), 258, 135);
-            Add_Goto (Table.States (4), 272, 92);
-            Add_Goto (Table.States (4), 275, 136);
-            Add_Goto (Table.States (4), 282, 137);
+            Add_Goto (Table.States (4), 118, 131);
+            Add_Goto (Table.States (4), 129, 42);
+            Add_Goto (Table.States (4), 192, 132);
+            Add_Goto (Table.States (4), 193, 149);
+            Add_Goto (Table.States (4), 198, 134);
+            Add_Goto (Table.States (4), 240, 135);
+            Add_Goto (Table.States (4), 259, 136);
+            Add_Goto (Table.States (4), 273, 93);
+            Add_Goto (Table.States (4), 276, 137);
             Add_Goto (Table.States (4), 283, 138);
             Add_Goto (Table.States (4), 284, 139);
             Add_Goto (Table.States (4), 285, 140);
             Add_Goto (Table.States (4), 286, 141);
             Add_Goto (Table.States (4), 287, 142);
-            Add_Goto (Table.States (4), 293, 97);
-            Add_Goto (Table.States (4), 301, 143);
-            Add_Goto (Table.States (4), 320, 144);
+            Add_Goto (Table.States (4), 288, 143);
+            Add_Goto (Table.States (4), 294, 98);
+            Add_Goto (Table.States (4), 302, 144);
             Add_Goto (Table.States (4), 321, 145);
-            Add_Goto (Table.States (4), 330, 146);
-            Table.States (4).Kernel := To_Vector (((161, 18, 2, False), (161, 
18, 1, False)));
-            Table.States (4).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 192, 0)));
+            Add_Goto (Table.States (4), 322, 146);
+            Add_Goto (Table.States (4), 331, 147);
+            Table.States (4).Kernel := To_Vector (((162, 18, 2, False), (162, 
18, 1, False)));
+            Table.States (4).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 193, 0)));
             Table.States (5).Action_List.Set_Capacity (3);
-            Add_Action (Table.States (5), 72, Reduce, (220, 1), 0, null, null);
-            Add_Action (Table.States (5), 96, Reduce, (220, 1), 0, null, null);
-            Add_Action (Table.States (5), 104, 149);
+            Add_Action (Table.States (5), 72, Reduce, (221, 1), 0, null, null);
+            Add_Action (Table.States (5), 97, Reduce, (221, 1), 0, null, null);
+            Add_Action (Table.States (5), 105, 150);
             Table.States (5).Goto_List.Set_Capacity (1);
-            Add_Goto (Table.States (5), 220, 150);
-            Table.States (5).Kernel := To_Vector (((190, 27, 2, False), (190, 
27, 1, False)));
-            Table.States (5).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 220, 0)));
-            Table.States (6).Action_List.Set_Capacity (3);
-            Add_Action (Table.States (6), 104, 151);
+            Add_Goto (Table.States (5), 221, 151);
+            Table.States (5).Kernel := To_Vector (((191, 27, 2, False), (191, 
27, 1, False)));
+            Table.States (5).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 221, 0)));
+            Table.States (6).Action_List.Set_Capacity (4);
+            Add_Action (Table.States (6), 79, 31);
             Add_Action (Table.States (6), 105, 152);
-            Add_Action (Table.States (6), 106, 34);
+            Add_Action (Table.States (6), 106, 153);
+            Add_Action (Table.States (6), 107, 35);
             Table.States (6).Goto_List.Set_Capacity (7);
-            Add_Goto (Table.States (6), 128, 153);
-            Add_Goto (Table.States (6), 163, 154);
-            Add_Goto (Table.States (6), 230, 155);
+            Add_Goto (Table.States (6), 129, 154);
+            Add_Goto (Table.States (6), 164, 155);
             Add_Goto (Table.States (6), 231, 156);
-            Add_Goto (Table.States (6), 239, 157);
-            Add_Goto (Table.States (6), 272, 92);
-            Add_Goto (Table.States (6), 293, 97);
-            Table.States (6).Kernel := To_Vector (((121, 28, 5, False), (127, 
28, 4, False), (182, 28, 5, False), (229,
-            28, 0, False), (281, 28, 14, False)));
-            Table.States (6).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 231, 0)));
-            Table.States (7).Action_List.Set_Capacity (3);
-            Add_Action (Table.States (7), 104, 119);
-            Add_Action (Table.States (7), 105, 33);
+            Add_Goto (Table.States (6), 232, 157);
+            Add_Goto (Table.States (6), 240, 158);
+            Add_Goto (Table.States (6), 273, 93);
+            Add_Goto (Table.States (6), 294, 98);
+            Table.States (6).Kernel := To_Vector (((122, 28, 5, False), (128, 
28, 4, False), (183, 28, 5, False), (230,
+            28, 0, False), (282, 28, 14, False)));
+            Table.States (6).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 232, 0)));
+            Table.States (7).Action_List.Set_Capacity (4);
+            Add_Action (Table.States (7), 79, 31);
+            Add_Action (Table.States (7), 105, 120);
             Add_Action (Table.States (7), 106, 34);
+            Add_Action (Table.States (7), 107, 35);
             Table.States (7).Goto_List.Set_Capacity (4);
-            Add_Goto (Table.States (7), 128, 41);
-            Add_Goto (Table.States (7), 239, 158);
-            Add_Goto (Table.States (7), 272, 92);
-            Add_Goto (Table.States (7), 293, 97);
-            Table.States (7).Kernel := To_Vector ((0 => (207, 29, 2, False)));
-            Table.States (7).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 104, 119)));
+            Add_Goto (Table.States (7), 129, 42);
+            Add_Goto (Table.States (7), 240, 159);
+            Add_Goto (Table.States (7), 273, 93);
+            Add_Goto (Table.States (7), 294, 98);
+            Table.States (7).Kernel := To_Vector ((0 => (208, 29, 2, False)));
+            Table.States (7).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 105, 120)));
             Table.States (8).Action_List.Set_Capacity (8);
-            Add_Action (Table.States (8), 29, 159);
-            Add_Conflict (Table.States (8), 29, (210, 1), 1, 
generic_formal_part_1'Access, null);
-            Add_Action (Table.States (8), 47, 160);
-            Add_Conflict (Table.States (8), 47, (210, 1), 1, 
generic_formal_part_1'Access, null);
+            Add_Action (Table.States (8), 29, 160);
+            Add_Conflict (Table.States (8), 29, (211, 1), 1, 
generic_formal_part_1'Access, null);
+            Add_Action (Table.States (8), 47, 161);
+            Add_Conflict (Table.States (8), 47, (211, 1), 1, 
generic_formal_part_1'Access, null);
             Add_Action (Table.States (8), 48, 16);
-            Add_Action (Table.States (8), 50, 161);
-            Add_Conflict (Table.States (8), 50, (210, 1), 1, 
generic_formal_part_1'Access, null);
-            Add_Action (Table.States (8), 69, 162);
+            Add_Action (Table.States (8), 50, 162);
+            Add_Conflict (Table.States (8), 50, (211, 1), 1, 
generic_formal_part_1'Access, null);
+            Add_Action (Table.States (8), 69, 163);
             Add_Action (Table.States (8), 71, 28);
-            Add_Action (Table.States (8), 74, 163);
-            Add_Action (Table.States (8), 104, 164);
+            Add_Action (Table.States (8), 74, 164);
+            Add_Action (Table.States (8), 105, 165);
             Table.States (8).Goto_List.Set_Capacity (9);
-            Add_Goto (Table.States (8), 198, 165);
-            Add_Goto (Table.States (8), 200, 166);
+            Add_Goto (Table.States (8), 199, 166);
             Add_Goto (Table.States (8), 201, 167);
-            Add_Goto (Table.States (8), 204, 168);
-            Add_Goto (Table.States (8), 211, 169);
+            Add_Goto (Table.States (8), 202, 168);
+            Add_Goto (Table.States (8), 205, 169);
             Add_Goto (Table.States (8), 212, 170);
-            Add_Goto (Table.States (8), 219, 171);
-            Add_Goto (Table.States (8), 257, 172);
-            Add_Goto (Table.States (8), 331, 173);
-            Table.States (8).Kernel := To_Vector (((210, 30, 3, False), (210, 
30, 0, False), (215, 30, 5, False), (215,
-            30, 5, False), (215, 30, 5, False)));
-            Table.States (8).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 210, 1)));
+            Add_Goto (Table.States (8), 213, 171);
+            Add_Goto (Table.States (8), 220, 172);
+            Add_Goto (Table.States (8), 258, 173);
+            Add_Goto (Table.States (8), 332, 174);
+            Table.States (8).Kernel := To_Vector (((211, 30, 3, False), (211, 
30, 0, False), (216, 30, 5, False), (216,
+            30, 5, False), (216, 30, 5, False)));
+            Table.States (8).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 211, 1)));
             Table.States (9).Action_List.Set_Capacity (1);
-            Add_Action (Table.States (9), 104, 174);
-            Table.States (9).Kernel := To_Vector ((0 => (303, 31, 2, False)));
-            Table.States (9).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 104, 174)));
-            Table.States (10).Action_List.Set_Capacity (13);
-            Add_Action (Table.States (10), 3, 121);
-            Add_Action (Table.States (10), 39, 122);
-            Add_Action (Table.States (10), 40, 123);
-            Add_Action (Table.States (10), 41, 124);
-            Add_Action (Table.States (10), 52, 125);
-            Add_Action (Table.States (10), 68, Reduce, (192, 1), 0, null, 
null);
-            Add_Action (Table.States (10), 76, 126);
-            Add_Action (Table.States (10), 94, 127);
+            Add_Action (Table.States (9), 105, 175);
+            Table.States (9).Kernel := To_Vector ((0 => (304, 31, 2, False)));
+            Table.States (9).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 105, 175)));
+            Table.States (10).Action_List.Set_Capacity (14);
+            Add_Action (Table.States (10), 3, 122);
+            Add_Action (Table.States (10), 39, 123);
+            Add_Action (Table.States (10), 40, 124);
+            Add_Action (Table.States (10), 41, 125);
+            Add_Action (Table.States (10), 52, 126);
+            Add_Action (Table.States (10), 68, Reduce, (193, 1), 0, null, 
null);
+            Add_Action (Table.States (10), 76, 127);
+            Add_Action (Table.States (10), 79, 31);
             Add_Action (Table.States (10), 95, 128);
-            Add_Action (Table.States (10), 103, 129);
-            Add_Action (Table.States (10), 104, 119);
-            Add_Action (Table.States (10), 105, 33);
+            Add_Action (Table.States (10), 96, 129);
+            Add_Action (Table.States (10), 104, 130);
+            Add_Action (Table.States (10), 105, 120);
             Add_Action (Table.States (10), 106, 34);
+            Add_Action (Table.States (10), 107, 35);
             Table.States (10).Goto_List.Set_Capacity (20);
-            Add_Goto (Table.States (10), 117, 130);
-            Add_Goto (Table.States (10), 128, 41);
-            Add_Goto (Table.States (10), 191, 131);
-            Add_Goto (Table.States (10), 192, 175);
-            Add_Goto (Table.States (10), 197, 133);
-            Add_Goto (Table.States (10), 239, 134);
-            Add_Goto (Table.States (10), 258, 135);
-            Add_Goto (Table.States (10), 272, 92);
-            Add_Goto (Table.States (10), 275, 136);
-            Add_Goto (Table.States (10), 282, 137);
+            Add_Goto (Table.States (10), 118, 131);
+            Add_Goto (Table.States (10), 129, 42);
+            Add_Goto (Table.States (10), 192, 132);
+            Add_Goto (Table.States (10), 193, 176);
+            Add_Goto (Table.States (10), 198, 134);
+            Add_Goto (Table.States (10), 240, 135);
+            Add_Goto (Table.States (10), 259, 136);
+            Add_Goto (Table.States (10), 273, 93);
+            Add_Goto (Table.States (10), 276, 137);
             Add_Goto (Table.States (10), 283, 138);
             Add_Goto (Table.States (10), 284, 139);
             Add_Goto (Table.States (10), 285, 140);
             Add_Goto (Table.States (10), 286, 141);
             Add_Goto (Table.States (10), 287, 142);
-            Add_Goto (Table.States (10), 293, 97);
-            Add_Goto (Table.States (10), 301, 143);
-            Add_Goto (Table.States (10), 320, 144);
+            Add_Goto (Table.States (10), 288, 143);
+            Add_Goto (Table.States (10), 294, 98);
+            Add_Goto (Table.States (10), 302, 144);
             Add_Goto (Table.States (10), 321, 145);
-            Add_Goto (Table.States (10), 330, 146);
-            Table.States (10).Kernel := To_Vector (((222, 32, 7, False), (222, 
32, 5, False), (222, 32, 6, False),
-            (222, 32, 4, False)));
-            Table.States (10).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 192, 0)));
+            Add_Goto (Table.States (10), 322, 146);
+            Add_Goto (Table.States (10), 331, 147);
+            Table.States (10).Kernel := To_Vector (((223, 32, 7, False), (223, 
32, 5, False), (223, 32, 6, False),
+            (223, 32, 4, False)));
+            Table.States (10).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 193, 0)));
             Table.States (11).Action_List.Set_Capacity (2);
-            Add_Action (Table.States (11), 49, 176);
-            Add_Action (Table.States (11), 74, 177);
-            Table.States (11).Kernel := To_Vector (((332, 36, 4, False), (332, 
36, 3, False)));
-            Table.States (11).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 74, 177)));
+            Add_Action (Table.States (11), 49, 177);
+            Add_Action (Table.States (11), 74, 178);
+            Table.States (11).Kernel := To_Vector (((333, 36, 4, False), (333, 
36, 3, False)));
+            Table.States (11).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 74, 178)));
             Table.States (12).Action_List.Set_Capacity (1);
-            Add_Action (Table.States (12), 46, 178);
-            Table.States (12).Kernel := To_Vector ((0 => (246, 40, 1, False)));
-            Table.States (12).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 46, 178)));
+            Add_Action (Table.States (12), 46, 179);
+            Table.States (12).Kernel := To_Vector ((0 => (247, 40, 1, False)));
+            Table.States (12).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 46, 179)));
             Table.States (13).Action_List.Set_Capacity (1);
-            Add_Action (Table.States (13), 96, 179);
-            Table.States (13).Kernel := To_Vector ((0 => (303, 41, 1, False)));
-            Table.States (13).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 96, 179)));
+            Add_Action (Table.States (13), 97, 180);
+            Table.States (13).Kernel := To_Vector ((0 => (304, 41, 1, False)));
+            Table.States (13).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 97, 180)));
             Table.States (14).Action_List.Set_Capacity (3);
-            Add_Action (Table.States (14), (25, 29, 50), (246, 1), 1, 
overriding_indicator_opt_1'Access, null);
-            Table.States (14).Kernel := To_Vector ((0 => (246, 46, 0, False)));
-            Table.States (14).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 246, 1)));
-            Table.States (15).Action_List.Set_Capacity (4);
-            Add_Action (Table.States (15), 14, 180);
-            Add_Action (Table.States (15), 104, 119);
-            Add_Action (Table.States (15), 105, 33);
+            Add_Action (Table.States (14), (25, 29, 50), (247, 1), 1, 
overriding_indicator_opt_1'Access, null);
+            Table.States (14).Kernel := To_Vector ((0 => (247, 46, 0, False)));
+            Table.States (14).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 247, 1)));
+            Table.States (15).Action_List.Set_Capacity (5);
+            Add_Action (Table.States (15), 14, 181);
+            Add_Action (Table.States (15), 79, 31);
+            Add_Action (Table.States (15), 105, 120);
             Add_Action (Table.States (15), 106, 34);
+            Add_Action (Table.States (15), 107, 35);
             Table.States (15).Goto_List.Set_Capacity (4);
-            Add_Goto (Table.States (15), 128, 41);
-            Add_Goto (Table.States (15), 239, 181);
-            Add_Goto (Table.States (15), 272, 92);
-            Add_Goto (Table.States (15), 293, 97);
-            Table.States (15).Kernel := To_Vector (((213, 47, 5, False), (247, 
47, 6, False), (247, 47, 5, False),
-            (248, 47, 5, False), (250, 47, 4, False), (251, 47, 4, False), 
(251, 47, 3, False)));
-            Table.States (15).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 104, 119)));
+            Add_Goto (Table.States (15), 129, 42);
+            Add_Goto (Table.States (15), 240, 182);
+            Add_Goto (Table.States (15), 273, 93);
+            Add_Goto (Table.States (15), 294, 98);
+            Table.States (15).Kernel := To_Vector (((214, 47, 5, False), (248, 
47, 6, False), (248, 47, 5, False),
+            (249, 47, 5, False), (251, 47, 4, False), (252, 47, 4, False), 
(252, 47, 3, False)));
+            Table.States (15).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 105, 120)));
             Table.States (16).Action_List.Set_Capacity (1);
-            Add_Action (Table.States (16), 104, 182);
-            Table.States (16).Kernel := To_Vector (((257, 48, 4, False), (257, 
48, 6, False), (257, 48, 2, False)));
-            Table.States (16).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 104, 182)));
+            Add_Action (Table.States (16), 105, 183);
+            Table.States (16).Kernel := To_Vector (((258, 48, 4, False), (258, 
48, 6, False), (258, 48, 2, False)));
+            Table.States (16).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 105, 183)));
             Table.States (17).Action_List.Set_Capacity (15);
-            Add_Action (Table.States (17), 25, Reduce, (246, 2), 0, null, 
null);
-            Add_Action (Table.States (17), 28, 183);
-            Add_Action (Table.States (17), 29, Reduce, (246, 2), 0, null, 
null);
+            Add_Action (Table.States (17), 25, Reduce, (247, 2), 0, null, 
null);
+            Add_Action (Table.States (17), 28, 184);
+            Add_Action (Table.States (17), 29, Reduce, (247, 2), 0, null, 
null);
             Add_Action (Table.States (17), 30, 8);
             Add_Action (Table.States (17), 40, 12);
             Add_Action (Table.States (17), 46, 14);
             Add_Action (Table.States (17), 47, 15);
-            Add_Action (Table.States (17), 50, Reduce, (246, 2), 0, null, 
null);
+            Add_Action (Table.States (17), 50, Reduce, (247, 2), 0, null, 
null);
             Add_Action (Table.States (17), 51, 19);
             Add_Action (Table.States (17), 63, 25);
             Add_Action (Table.States (17), 66, 26);
             Add_Action (Table.States (17), 69, 27);
             Add_Action (Table.States (17), 71, 28);
-            Add_Action (Table.States (17), 74, 184);
-            Add_Action (Table.States (17), 104, 185);
+            Add_Action (Table.States (17), 74, 185);
+            Add_Action (Table.States (17), 105, 186);
             Table.States (17).Goto_List.Set_Capacity (50);
-            Add_Goto (Table.States (17), 112, 35);
-            Add_Goto (Table.States (17), 121, 37);
-            Add_Goto (Table.States (17), 127, 40);
-            Add_Goto (Table.States (17), 134, 45);
+            Add_Goto (Table.States (17), 113, 36);
+            Add_Goto (Table.States (17), 122, 38);
+            Add_Goto (Table.States (17), 128, 41);
             Add_Goto (Table.States (17), 135, 46);
-            Add_Goto (Table.States (17), 157, 186);
-            Add_Goto (Table.States (17), 179, 54);
-            Add_Goto (Table.States (17), 182, 55);
-            Add_Goto (Table.States (17), 186, 56);
-            Add_Goto (Table.States (17), 193, 58);
-            Add_Goto (Table.States (17), 206, 60);
+            Add_Goto (Table.States (17), 136, 47);
+            Add_Goto (Table.States (17), 158, 187);
+            Add_Goto (Table.States (17), 180, 55);
+            Add_Goto (Table.States (17), 183, 56);
+            Add_Goto (Table.States (17), 187, 57);
+            Add_Goto (Table.States (17), 194, 59);
             Add_Goto (Table.States (17), 207, 61);
-            Add_Goto (Table.States (17), 209, 62);
+            Add_Goto (Table.States (17), 208, 62);
             Add_Goto (Table.States (17), 210, 63);
-            Add_Goto (Table.States (17), 213, 64);
+            Add_Goto (Table.States (17), 211, 64);
             Add_Goto (Table.States (17), 214, 65);
             Add_Goto (Table.States (17), 215, 66);
             Add_Goto (Table.States (17), 216, 67);
-            Add_Goto (Table.States (17), 219, 69);
-            Add_Goto (Table.States (17), 223, 71);
-            Add_Goto (Table.States (17), 243, 74);
+            Add_Goto (Table.States (17), 217, 68);
+            Add_Goto (Table.States (17), 220, 70);
+            Add_Goto (Table.States (17), 224, 72);
             Add_Goto (Table.States (17), 244, 75);
             Add_Goto (Table.States (17), 245, 76);
             Add_Goto (Table.States (17), 246, 77);
@@ -486,14877 +493,15280 @@ package body Ada_Process_LALR_Main is
             Add_Goto (Table.States (17), 249, 80);
             Add_Goto (Table.States (17), 250, 81);
             Add_Goto (Table.States (17), 251, 82);
-            Add_Goto (Table.States (17), 259, 84);
+            Add_Goto (Table.States (17), 252, 83);
             Add_Goto (Table.States (17), 260, 85);
-            Add_Goto (Table.States (17), 262, 87);
+            Add_Goto (Table.States (17), 261, 86);
             Add_Goto (Table.States (17), 263, 88);
             Add_Goto (Table.States (17), 264, 89);
             Add_Goto (Table.States (17), 265, 90);
-            Add_Goto (Table.States (17), 271, 91);
-            Add_Goto (Table.States (17), 281, 94);
-            Add_Goto (Table.States (17), 289, 95);
-            Add_Goto (Table.States (17), 304, 102);
+            Add_Goto (Table.States (17), 266, 91);
+            Add_Goto (Table.States (17), 272, 92);
+            Add_Goto (Table.States (17), 282, 95);
+            Add_Goto (Table.States (17), 290, 96);
             Add_Goto (Table.States (17), 305, 103);
-            Add_Goto (Table.States (17), 307, 105);
+            Add_Goto (Table.States (17), 306, 104);
             Add_Goto (Table.States (17), 308, 106);
             Add_Goto (Table.States (17), 309, 107);
-            Add_Goto (Table.States (17), 311, 108);
-            Add_Goto (Table.States (17), 313, 109);
-            Add_Goto (Table.States (17), 316, 111);
+            Add_Goto (Table.States (17), 310, 108);
+            Add_Goto (Table.States (17), 312, 109);
+            Add_Goto (Table.States (17), 314, 110);
             Add_Goto (Table.States (17), 317, 112);
-            Add_Goto (Table.States (17), 319, 113);
-            Add_Goto (Table.States (17), 325, 115);
-            Add_Goto (Table.States (17), 331, 116);
-            Table.States (17).Kernel := To_Vector (((142, 49, 3, False), (332, 
49, 3, False)));
-            Table.States (17).Minimal_Complete_Actions := To_Vector (((Reduce, 
246, 0), (Shift, 74, 184)));
-            Table.States (18).Action_List.Set_Capacity (3);
-            Add_Action (Table.States (18), 104, 119);
-            Add_Action (Table.States (18), 105, 33);
+            Add_Goto (Table.States (17), 318, 113);
+            Add_Goto (Table.States (17), 320, 114);
+            Add_Goto (Table.States (17), 326, 116);
+            Add_Goto (Table.States (17), 332, 117);
+            Table.States (17).Kernel := To_Vector (((143, 49, 3, False), (333, 
49, 3, False)));
+            Table.States (17).Minimal_Complete_Actions := To_Vector (((Reduce, 
247, 0), (Shift, 74, 185)));
+            Table.States (18).Action_List.Set_Capacity (4);
+            Add_Action (Table.States (18), 79, 31);
+            Add_Action (Table.States (18), 105, 120);
             Add_Action (Table.States (18), 106, 34);
+            Add_Action (Table.States (18), 107, 35);
             Table.States (18).Goto_List.Set_Capacity (4);
-            Add_Goto (Table.States (18), 128, 41);
-            Add_Goto (Table.States (18), 239, 187);
-            Add_Goto (Table.States (18), 272, 92);
-            Add_Goto (Table.States (18), 293, 97);
-            Table.States (18).Kernel := To_Vector ((0 => (262, 50, 1, False)));
-            Table.States (18).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 104, 119)));
+            Add_Goto (Table.States (18), 129, 42);
+            Add_Goto (Table.States (18), 240, 188);
+            Add_Goto (Table.States (18), 273, 93);
+            Add_Goto (Table.States (18), 294, 98);
+            Table.States (18).Kernel := To_Vector ((0 => (263, 50, 1, False)));
+            Table.States (18).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 105, 120)));
             Table.States (19).Action_List.Set_Capacity (3);
-            Add_Action (Table.States (19), 14, 188);
-            Add_Action (Table.States (19), 69, 189);
-            Add_Action (Table.States (19), 104, 190);
-            Table.States (19).Kernel := To_Vector (((264, 51, 5, False), (265, 
51, 5, False), (271, 51, 8, False),
-            (271, 51, 5, False), (304, 51, 7, False), (304, 51, 4, False)));
-            Table.States (19).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 104, 190)));
-            Table.States (20).Action_List.Set_Capacity (4);
-            Add_Action (Table.States (20), 96, 191);
-            Add_Action (Table.States (20), 104, 119);
-            Add_Action (Table.States (20), 105, 33);
+            Add_Action (Table.States (19), 14, 189);
+            Add_Action (Table.States (19), 69, 190);
+            Add_Action (Table.States (19), 105, 191);
+            Table.States (19).Kernel := To_Vector (((265, 51, 5, False), (266, 
51, 5, False), (272, 51, 8, False),
+            (272, 51, 5, False), (305, 51, 7, False), (305, 51, 4, False)));
+            Table.States (19).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 105, 191)));
+            Table.States (20).Action_List.Set_Capacity (5);
+            Add_Action (Table.States (20), 79, 31);
+            Add_Action (Table.States (20), 97, 192);
+            Add_Action (Table.States (20), 105, 120);
             Add_Action (Table.States (20), 106, 34);
+            Add_Action (Table.States (20), 107, 35);
             Table.States (20).Goto_List.Set_Capacity (4);
-            Add_Goto (Table.States (20), 128, 41);
-            Add_Goto (Table.States (20), 239, 192);
-            Add_Goto (Table.States (20), 272, 92);
-            Add_Goto (Table.States (20), 293, 97);
-            Table.States (20).Kernel := To_Vector (((276, 52, 3, False), (276, 
52, 2, False), (276, 52, 1, False)));
-            Table.States (20).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 96, 191)));
-            Table.States (21).Action_List.Set_Capacity (3);
-            Add_Action (Table.States (21), 104, 119);
-            Add_Action (Table.States (21), 105, 33);
+            Add_Goto (Table.States (20), 129, 42);
+            Add_Goto (Table.States (20), 240, 193);
+            Add_Goto (Table.States (20), 273, 93);
+            Add_Goto (Table.States (20), 294, 98);
+            Table.States (20).Kernel := To_Vector (((277, 52, 3, False), (277, 
52, 2, False), (277, 52, 1, False)));
+            Table.States (20).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 97, 192)));
+            Table.States (21).Action_List.Set_Capacity (4);
+            Add_Action (Table.States (21), 79, 31);
+            Add_Action (Table.States (21), 105, 120);
             Add_Action (Table.States (21), 106, 34);
+            Add_Action (Table.States (21), 107, 35);
             Table.States (21).Goto_List.Set_Capacity (4);
-            Add_Goto (Table.States (21), 128, 41);
-            Add_Goto (Table.States (21), 239, 193);
-            Add_Goto (Table.States (21), 272, 92);
-            Add_Goto (Table.States (21), 293, 97);
-            Table.States (21).Kernel := To_Vector (((290, 57, 4, False), (290, 
57, 2, False)));
-            Table.States (21).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 104, 119)));
-            Table.States (22).Action_List.Set_Capacity (14);
-            Add_Action (Table.States (22), 3, 121);
-            Add_Action (Table.States (22), 21, Reduce, (195, 1), 0, null, 
null);
-            Add_Action (Table.States (22), 39, 122);
-            Add_Action (Table.States (22), 40, 123);
-            Add_Action (Table.States (22), 41, 124);
-            Add_Action (Table.States (22), 52, 125);
-            Add_Action (Table.States (22), 76, 126);
-            Add_Action (Table.States (22), 94, 127);
+            Add_Goto (Table.States (21), 129, 42);
+            Add_Goto (Table.States (21), 240, 194);
+            Add_Goto (Table.States (21), 273, 93);
+            Add_Goto (Table.States (21), 294, 98);
+            Table.States (21).Kernel := To_Vector (((291, 57, 4, False), (291, 
57, 2, False)));
+            Table.States (21).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 105, 120)));
+            Table.States (22).Action_List.Set_Capacity (15);
+            Add_Action (Table.States (22), 3, 122);
+            Add_Action (Table.States (22), 21, Reduce, (196, 1), 0, null, 
null);
+            Add_Action (Table.States (22), 39, 123);
+            Add_Action (Table.States (22), 40, 124);
+            Add_Action (Table.States (22), 41, 125);
+            Add_Action (Table.States (22), 52, 126);
+            Add_Action (Table.States (22), 76, 127);
+            Add_Action (Table.States (22), 79, 31);
             Add_Action (Table.States (22), 95, 128);
-            Add_Action (Table.States (22), 96, Reduce, (192, 1), 0, null, 
null);
-            Add_Action (Table.States (22), 103, 129);
-            Add_Action (Table.States (22), 104, 194);
-            Add_Action (Table.States (22), 105, 33);
+            Add_Action (Table.States (22), 96, 129);
+            Add_Action (Table.States (22), 97, Reduce, (193, 1), 0, null, 
null);
+            Add_Action (Table.States (22), 104, 130);
+            Add_Action (Table.States (22), 105, 195);
             Add_Action (Table.States (22), 106, 34);
+            Add_Action (Table.States (22), 107, 35);
             Table.States (22).Goto_List.Set_Capacity (22);
-            Add_Goto (Table.States (22), 117, 130);
-            Add_Goto (Table.States (22), 128, 41);
-            Add_Goto (Table.States (22), 191, 131);
-            Add_Goto (Table.States (22), 192, 195);
-            Add_Goto (Table.States (22), 194, 196);
+            Add_Goto (Table.States (22), 118, 131);
+            Add_Goto (Table.States (22), 129, 42);
+            Add_Goto (Table.States (22), 192, 132);
+            Add_Goto (Table.States (22), 193, 196);
             Add_Goto (Table.States (22), 195, 197);
-            Add_Goto (Table.States (22), 197, 133);
-            Add_Goto (Table.States (22), 239, 134);
-            Add_Goto (Table.States (22), 258, 135);
-            Add_Goto (Table.States (22), 272, 92);
-            Add_Goto (Table.States (22), 275, 136);
-            Add_Goto (Table.States (22), 282, 137);
+            Add_Goto (Table.States (22), 196, 198);
+            Add_Goto (Table.States (22), 198, 134);
+            Add_Goto (Table.States (22), 240, 135);
+            Add_Goto (Table.States (22), 259, 136);
+            Add_Goto (Table.States (22), 273, 93);
+            Add_Goto (Table.States (22), 276, 137);
             Add_Goto (Table.States (22), 283, 138);
             Add_Goto (Table.States (22), 284, 139);
             Add_Goto (Table.States (22), 285, 140);
             Add_Goto (Table.States (22), 286, 141);
             Add_Goto (Table.States (22), 287, 142);
-            Add_Goto (Table.States (22), 293, 97);
-            Add_Goto (Table.States (22), 301, 143);
-            Add_Goto (Table.States (22), 320, 144);
+            Add_Goto (Table.States (22), 288, 143);
+            Add_Goto (Table.States (22), 294, 98);
+            Add_Goto (Table.States (22), 302, 144);
             Add_Goto (Table.States (22), 321, 145);
-            Add_Goto (Table.States (22), 330, 146);
-            Table.States (22).Kernel := To_Vector (((196, 58, 4, False), (196, 
58, 4, False), (302, 58, 1, False)));
-            Table.States (22).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 192, 0)));
+            Add_Goto (Table.States (22), 322, 146);
+            Add_Goto (Table.States (22), 331, 147);
+            Table.States (22).Kernel := To_Vector (((197, 58, 4, False), (197, 
58, 4, False), (303, 58, 1, False)));
+            Table.States (22).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 193, 0)));
             Table.States (23).Action_List.Set_Capacity (1);
-            Add_Action (Table.States (23), 76, 198);
-            Table.States (23).Kernel := To_Vector ((0 => (315, 60, 9, False)));
-            Table.States (23).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 76, 198)));
-            Table.States (24).Action_List.Set_Capacity (9);
+            Add_Action (Table.States (23), 76, 199);
+            Table.States (23).Kernel := To_Vector ((0 => (316, 60, 9, False)));
+            Table.States (23).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 76, 199)));
+            Table.States (24).Action_List.Set_Capacity (10);
             Add_Action (Table.States (24), 4, 1);
             Add_Action (Table.States (24), 18, 4);
-            Add_Action (Table.States (24), 22, Reduce, (297, 1), 0, null, 
null);
-            Add_Action (Table.States (24), 24, Reduce, (297, 1), 0, null, 
null);
-            Add_Action (Table.States (24), 67, 199);
-            Add_Action (Table.States (24), 72, 200);
-            Add_Action (Table.States (24), 104, 119);
-            Add_Action (Table.States (24), 105, 33);
+            Add_Action (Table.States (24), 22, Reduce, (298, 1), 0, null, 
null);
+            Add_Action (Table.States (24), 24, Reduce, (298, 1), 0, null, 
null);
+            Add_Action (Table.States (24), 67, 200);
+            Add_Action (Table.States (24), 72, 201);
+            Add_Action (Table.States (24), 79, 31);
+            Add_Action (Table.States (24), 105, 120);
             Add_Action (Table.States (24), 106, 34);
+            Add_Action (Table.States (24), 107, 35);
             Table.States (24).Goto_List.Set_Capacity (13);
-            Add_Goto (Table.States (24), 113, 201);
-            Add_Goto (Table.States (24), 128, 41);
-            Add_Goto (Table.States (24), 160, 202);
+            Add_Goto (Table.States (24), 114, 202);
+            Add_Goto (Table.States (24), 129, 42);
             Add_Goto (Table.States (24), 161, 203);
-            Add_Goto (Table.States (24), 178, 204);
-            Add_Goto (Table.States (24), 239, 205);
-            Add_Goto (Table.States (24), 261, 206);
-            Add_Goto (Table.States (24), 272, 92);
-            Add_Goto (Table.States (24), 293, 97);
-            Add_Goto (Table.States (24), 295, 207);
+            Add_Goto (Table.States (24), 162, 204);
+            Add_Goto (Table.States (24), 179, 205);
+            Add_Goto (Table.States (24), 240, 206);
+            Add_Goto (Table.States (24), 262, 207);
+            Add_Goto (Table.States (24), 273, 93);
+            Add_Goto (Table.States (24), 294, 98);
             Add_Goto (Table.States (24), 296, 208);
             Add_Goto (Table.States (24), 297, 209);
-            Add_Goto (Table.States (24), 324, 210);
-            Table.States (24).Kernel := To_Vector (((126, 61, 6, False), (152, 
61, 5, False), (294, 61, 4, False),
-            (294, 61, 3, False), (323, 61, 7, False)));
-            Table.States (24).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 297, 0)));
+            Add_Goto (Table.States (24), 298, 210);
+            Add_Goto (Table.States (24), 325, 211);
+            Table.States (24).Kernel := To_Vector (((127, 61, 6, False), (153, 
61, 5, False), (295, 61, 4, False),
+            (295, 61, 3, False), (324, 61, 7, False)));
+            Table.States (24).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 298, 0)));
             Table.States (25).Action_List.Set_Capacity (1);
-            Add_Action (Table.States (25), 104, 211);
-            Table.States (25).Kernel := To_Vector ((0 => (313, 63, 4, False)));
-            Table.States (25).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 104, 211)));
+            Add_Action (Table.States (25), 105, 212);
+            Table.States (25).Kernel := To_Vector ((0 => (314, 63, 4, False)));
+            Table.States (25).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 105, 212)));
             Table.States (26).Action_List.Set_Capacity (3);
-            Add_Action (Table.States (26), 14, 212);
-            Add_Action (Table.States (26), 69, 213);
-            Add_Action (Table.States (26), 104, 214);
-            Table.States (26).Kernel := To_Vector (((305, 66, 7, False), (305, 
66, 4, False), (305, 66, 2, False),
-            (316, 66, 6, False), (317, 66, 5, False), (319, 66, 8, False), 
(319, 66, 5, False), (319, 66, 3, False)));
-            Table.States (26).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 104, 214)));
+            Add_Action (Table.States (26), 14, 213);
+            Add_Action (Table.States (26), 69, 214);
+            Add_Action (Table.States (26), 105, 215);
+            Table.States (26).Kernel := To_Vector (((306, 66, 7, False), (306, 
66, 4, False), (306, 66, 2, False),
+            (317, 66, 6, False), (318, 66, 5, False), (320, 66, 8, False), 
(320, 66, 5, False), (320, 66, 3, False)));
+            Table.States (26).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 105, 215)));
             Table.States (27).Action_List.Set_Capacity (1);
-            Add_Action (Table.States (27), 104, 215);
-            Table.States (27).Kernel := To_Vector (((206, 69, 4, False), (223, 
69, 4, False), (223, 69, 2, False),
-            (259, 69, 7, False), (260, 69, 4, False)));
-            Table.States (27).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 104, 215)));
-            Table.States (28).Action_List.Set_Capacity (5);
-            Add_Action (Table.States (28), 9, 216);
-            Add_Action (Table.States (28), 69, 217);
-            Add_Action (Table.States (28), 104, 119);
-            Add_Action (Table.States (28), 105, 33);
+            Add_Action (Table.States (27), 105, 216);
+            Table.States (27).Kernel := To_Vector (((207, 69, 4, False), (224, 
69, 4, False), (224, 69, 2, False),
+            (260, 69, 7, False), (261, 69, 4, False)));
+            Table.States (27).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 105, 216)));
+            Table.States (28).Action_List.Set_Capacity (6);
+            Add_Action (Table.States (28), 9, 217);
+            Add_Action (Table.States (28), 69, 218);
+            Add_Action (Table.States (28), 79, 31);
+            Add_Action (Table.States (28), 105, 120);
             Add_Action (Table.States (28), 106, 34);
+            Add_Action (Table.States (28), 107, 35);
             Table.States (28).Goto_List.Set_Capacity (5);
-            Add_Goto (Table.States (28), 128, 41);
-            Add_Goto (Table.States (28), 238, 218);
+            Add_Goto (Table.States (28), 129, 42);
             Add_Goto (Table.States (28), 239, 219);
-            Add_Goto (Table.States (28), 272, 92);
-            Add_Goto (Table.States (28), 293, 97);
-            Table.States (28).Kernel := To_Vector (((331, 71, 4, False), (331, 
71, 3, False), (331, 71, 2, False)));
-            Table.States (28).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 104, 119)));
-            Table.States (29).Action_List.Set_Capacity (13);
-            Add_Action (Table.States (29), 3, 121);
-            Add_Action (Table.States (29), 37, Reduce, (192, 1), 0, null, 
null);
-            Add_Action (Table.States (29), 39, 122);
-            Add_Action (Table.States (29), 40, 123);
-            Add_Action (Table.States (29), 41, 124);
-            Add_Action (Table.States (29), 52, 125);
-            Add_Action (Table.States (29), 76, 126);
-            Add_Action (Table.States (29), 94, 127);
+            Add_Goto (Table.States (28), 240, 220);
+            Add_Goto (Table.States (28), 273, 93);
+            Add_Goto (Table.States (28), 294, 98);
+            Table.States (28).Kernel := To_Vector (((332, 71, 4, False), (332, 
71, 3, False), (332, 71, 2, False)));
+            Table.States (28).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 105, 120)));
+            Table.States (29).Action_List.Set_Capacity (14);
+            Add_Action (Table.States (29), 3, 122);
+            Add_Action (Table.States (29), 37, Reduce, (193, 1), 0, null, 
null);
+            Add_Action (Table.States (29), 39, 123);
+            Add_Action (Table.States (29), 40, 124);
+            Add_Action (Table.States (29), 41, 125);
+            Add_Action (Table.States (29), 52, 126);
+            Add_Action (Table.States (29), 76, 127);
+            Add_Action (Table.States (29), 79, 31);
             Add_Action (Table.States (29), 95, 128);
-            Add_Action (Table.States (29), 103, 129);
-            Add_Action (Table.States (29), 104, 119);
-            Add_Action (Table.States (29), 105, 33);
+            Add_Action (Table.States (29), 96, 129);
+            Add_Action (Table.States (29), 104, 130);
+            Add_Action (Table.States (29), 105, 120);
             Add_Action (Table.States (29), 106, 34);
+            Add_Action (Table.States (29), 107, 35);
             Table.States (29).Goto_List.Set_Capacity (20);
-            Add_Goto (Table.States (29), 117, 130);
-            Add_Goto (Table.States (29), 128, 41);
-            Add_Goto (Table.States (29), 191, 131);
-            Add_Goto (Table.States (29), 192, 220);
-            Add_Goto (Table.States (29), 197, 133);
-            Add_Goto (Table.States (29), 239, 134);
-            Add_Goto (Table.States (29), 258, 135);
-            Add_Goto (Table.States (29), 272, 92);
-            Add_Goto (Table.States (29), 275, 136);
-            Add_Goto (Table.States (29), 282, 137);
+            Add_Goto (Table.States (29), 118, 131);
+            Add_Goto (Table.States (29), 129, 42);
+            Add_Goto (Table.States (29), 192, 132);
+            Add_Goto (Table.States (29), 193, 221);
+            Add_Goto (Table.States (29), 198, 134);
+            Add_Goto (Table.States (29), 240, 135);
+            Add_Goto (Table.States (29), 259, 136);
+            Add_Goto (Table.States (29), 273, 93);
+            Add_Goto (Table.States (29), 276, 137);
             Add_Goto (Table.States (29), 283, 138);
             Add_Goto (Table.States (29), 284, 139);
             Add_Goto (Table.States (29), 285, 140);
             Add_Goto (Table.States (29), 286, 141);
             Add_Goto (Table.States (29), 287, 142);
-            Add_Goto (Table.States (29), 293, 97);
-            Add_Goto (Table.States (29), 301, 143);
-            Add_Goto (Table.States (29), 320, 144);
+            Add_Goto (Table.States (29), 288, 143);
+            Add_Goto (Table.States (29), 294, 98);
+            Add_Goto (Table.States (29), 302, 144);
             Add_Goto (Table.States (29), 321, 145);
-            Add_Goto (Table.States (29), 330, 146);
-            Table.States (29).Kernel := To_Vector ((0 => (229, 73, 0, False)));
-            Table.States (29).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 192, 0)));
-            Table.States (30).Action_List.Set_Capacity (3);
-            Add_Action (Table.States (30), 104, 119);
-            Add_Action (Table.States (30), 105, 33);
+            Add_Goto (Table.States (29), 322, 146);
+            Add_Goto (Table.States (29), 331, 147);
+            Table.States (29).Kernel := To_Vector ((0 => (230, 73, 0, False)));
+            Table.States (29).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 193, 0)));
+            Table.States (30).Action_List.Set_Capacity (4);
+            Add_Action (Table.States (30), 79, 31);
+            Add_Action (Table.States (30), 105, 120);
             Add_Action (Table.States (30), 106, 34);
+            Add_Action (Table.States (30), 107, 35);
             Table.States (30).Goto_List.Set_Capacity (5);
-            Add_Goto (Table.States (30), 128, 41);
-            Add_Goto (Table.States (30), 238, 221);
-            Add_Goto (Table.States (30), 239, 219);
-            Add_Goto (Table.States (30), 272, 92);
-            Add_Goto (Table.States (30), 293, 97);
-            Table.States (30).Kernel := To_Vector ((0 => (332, 74, 2, False)));
-            Table.States (30).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 104, 119)));
-            Table.States (31).Action_List.Set_Capacity (1);
-            Add_Action (Table.States (31), 104, 222);
-            Table.States (31).Kernel := To_Vector ((0 => (217, 93, 2, False)));
-            Table.States (31).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 104, 222)));
-            Table.States (32).Action_List.Set_Capacity (8);
-            Add_Action (Table.States (32), 76, Reduce, (239, 5), 1, 
name_5'Access, name_5_check'Access);
-            Add_Action (Table.States (32), 81, 223);
-            Add_Conflict (Table.States (32), 81, (219, 1), 1, 
identifier_list_1'Access, null);
-            Add_Action (Table.States (32), 82, Reduce, (239, 5), 1, 
name_5'Access, name_5_check'Access);
-            Add_Action (Table.States (32), 83, Reduce, (219, 1), 1, 
identifier_list_1'Access, null);
-            Add_Action (Table.States (32), 84, Reduce, (239, 5), 1, 
name_5'Access, name_5_check'Access);
-            Add_Action (Table.States (32), 96, Reduce, (239, 5), 1, 
name_5'Access, name_5_check'Access);
-            Add_Action (Table.States (32), 101, Reduce, (239, 5), 1, 
name_5'Access, name_5_check'Access);
-            Add_Action (Table.States (32), 102, Reduce, (239, 5), 1, 
name_5'Access, name_5_check'Access);
-            Table.States (32).Kernel := To_Vector (((131, 104, 1, False), 
(219, 104, 0, False), (239, 104, 0, False),
-            (245, 104, 5, False), (245, 104, 6, False), (245, 104, 5, False)));
-            Table.States (32).Minimal_Complete_Actions := To_Vector (((Reduce, 
219, 1), (Reduce, 239, 1)));
-            Table.States (33).Action_List.Set_Capacity (62);
-            Add_Action (Table.States (33), (4, 5, 10, 13, 15, 17, 18, 20, 21, 
22, 23, 27, 28, 31, 32, 33, 35, 37, 38,
-            40, 41, 42, 43, 48, 52, 53, 55, 56, 57, 58, 61, 68, 73, 74, 75, 
76, 77, 78, 79, 82, 83, 84, 85, 86, 87, 88,
-            89, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 104, 105, 
106), (239, 7), 1, null,
-            name_7_check'Access);
-            Table.States (33).Kernel := To_Vector ((0 => (239, 105, 0, 
False)));
-            Table.States (33).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 239, 1)));
+            Add_Goto (Table.States (30), 129, 42);
+            Add_Goto (Table.States (30), 239, 222);
+            Add_Goto (Table.States (30), 240, 220);
+            Add_Goto (Table.States (30), 273, 93);
+            Add_Goto (Table.States (30), 294, 98);
+            Table.States (30).Kernel := To_Vector ((0 => (333, 74, 2, False)));
+            Table.States (30).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 105, 120)));
+            Table.States (31).Action_List.Set_Capacity (64);
+            Add_Action (Table.States (31), (4, 5, 10, 13, 15, 17, 18, 20, 21, 
22, 23, 27, 28, 31, 32, 33, 35, 37, 38,
+            40, 41, 42, 43, 48, 52, 53, 55, 56, 57, 58, 61, 68, 71, 73, 74, 
75, 76, 77, 78, 79, 80, 83, 84, 85, 86, 87,
+            88, 89, 90, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 
105, 106, 107), (240, 8), 1, null, null);
+            Table.States (31).Kernel := To_Vector ((0 => (240, 79, 0, False)));
+            Table.States (31).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 240, 1)));
+            Table.States (32).Action_List.Set_Capacity (1);
+            Add_Action (Table.States (32), 105, 223);
+            Table.States (32).Kernel := To_Vector ((0 => (218, 94, 2, False)));
+            Table.States (32).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 105, 223)));
+            Table.States (33).Action_List.Set_Capacity (8);
+            Add_Action (Table.States (33), 76, Reduce, (240, 5), 1, 
name_5'Access, name_5_check'Access);
+            Add_Action (Table.States (33), 82, 224);
+            Add_Conflict (Table.States (33), 82, (220, 1), 1, 
identifier_list_1'Access, null);
+            Add_Action (Table.States (33), 83, Reduce, (240, 5), 1, 
name_5'Access, name_5_check'Access);
+            Add_Action (Table.States (33), 84, Reduce, (220, 1), 1, 
identifier_list_1'Access, null);
+            Add_Action (Table.States (33), 85, Reduce, (240, 5), 1, 
name_5'Access, name_5_check'Access);
+            Add_Action (Table.States (33), 97, Reduce, (240, 5), 1, 
name_5'Access, name_5_check'Access);
+            Add_Action (Table.States (33), 102, Reduce, (240, 5), 1, 
name_5'Access, name_5_check'Access);
+            Add_Action (Table.States (33), 103, Reduce, (240, 5), 1, 
name_5'Access, name_5_check'Access);
+            Table.States (33).Kernel := To_Vector (((132, 105, 1, False), 
(220, 105, 0, False), (240, 105, 0, False),
+            (246, 105, 5, False), (246, 105, 6, False), (246, 105, 5, False)));
+            Table.States (33).Minimal_Complete_Actions := To_Vector (((Reduce, 
220, 1), (Reduce, 240, 1)));
             Table.States (34).Action_List.Set_Capacity (63);
             Add_Action (Table.States (34), (4, 5, 10, 13, 15, 17, 18, 20, 21, 
22, 23, 27, 28, 31, 32, 33, 35, 37, 38,
-            40, 41, 42, 43, 48, 52, 53, 55, 56, 57, 58, 61, 68, 71, 73, 74, 
75, 76, 77, 78, 79, 82, 83, 84, 85, 86, 87,
-            88, 89, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 104, 
105, 106), (239, 6), 1, null, null);
-            Table.States (34).Kernel := To_Vector ((0 => (239, 106, 0, 
False)));
-            Table.States (34).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 239, 1)));
-            Table.States (35).Action_List.Set_Capacity (40);
-            Add_Action (Table.States (35), (4, 5, 13, 15, 17, 18, 24, 25, 27, 
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
-            47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 
93, 104, 105, 106, 107), (157, 0), 1, null,
-            null);
-            Table.States (35).Kernel := To_Vector ((0 => (157, 112, 0, 
False)));
-            Table.States (35).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 157, 1)));
-            Table.States (36).Action_List.Set_Capacity (46);
-            Add_Action (Table.States (36), (4, 5, 13, 15, 17, 18, 22, 23, 24, 
25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
-            40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 
68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
-            107), (151, 5), 1, null, null);
-            Table.States (36).Kernel := To_Vector ((0 => (151, 113, 0, 
False)));
-            Table.States (36).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 151, 1)));
-            Table.States (37).Action_List.Set_Capacity (40);
-            Add_Action (Table.States (37), (4, 5, 13, 15, 17, 18, 24, 25, 27, 
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
-            47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 
93, 104, 105, 106, 107), (157, 1), 1, null,
-            null);
-            Table.States (37).Kernel := To_Vector ((0 => (157, 121, 0, 
False)));
-            Table.States (37).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 157, 1)));
-            Table.States (38).Action_List.Set_Capacity (46);
-            Add_Action (Table.States (38), (4, 5, 13, 15, 17, 18, 22, 23, 24, 
25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
-            40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 
68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
-            107), (303, 1), 1, null, null);
-            Table.States (38).Kernel := To_Vector ((0 => (303, 123, 0, 
False)));
-            Table.States (38).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 303, 1)));
-            Table.States (39).Action_List.Set_Capacity (46);
-            Add_Action (Table.States (39), (4, 5, 13, 15, 17, 18, 22, 23, 24, 
25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
-            40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 
68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
-            107), (298, 3), 1, null, null);
-            Table.States (39).Kernel := To_Vector ((0 => (298, 126, 0, 
False)));
-            Table.States (39).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 298, 1)));
-            Table.States (40).Action_List.Set_Capacity (41);
-            Add_Action (Table.States (40), (4, 5, 13, 15, 17, 18, 24, 25, 27, 
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
-            47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 72, 73, 
74, 93, 104, 105, 106, 107), (121, 3), 1,
+            40, 41, 42, 43, 48, 52, 53, 55, 56, 57, 58, 61, 68, 73, 74, 75, 
76, 77, 78, 79, 80, 83, 84, 85, 86, 87, 88,
+            89, 90, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 105, 
106, 107), (240, 7), 1, null,
+            name_7_check'Access);
+            Table.States (34).Kernel := To_Vector ((0 => (240, 106, 0, 
False)));
+            Table.States (34).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 240, 1)));
+            Table.States (35).Action_List.Set_Capacity (64);
+            Add_Action (Table.States (35), (4, 5, 10, 13, 15, 17, 18, 20, 21, 
22, 23, 27, 28, 31, 32, 33, 35, 37, 38,
+            40, 41, 42, 43, 48, 52, 53, 55, 56, 57, 58, 61, 68, 71, 73, 74, 
75, 76, 77, 78, 79, 80, 83, 84, 85, 86, 87,
+            88, 89, 90, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 
105, 106, 107), (240, 6), 1, null, null);
+            Table.States (35).Kernel := To_Vector ((0 => (240, 107, 0, 
False)));
+            Table.States (35).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 240, 1)));
+            Table.States (36).Action_List.Set_Capacity (41);
+            Add_Action (Table.States (36), (4, 5, 13, 15, 17, 18, 24, 25, 27, 
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
+            47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 
79, 94, 105, 106, 107, 108), (158, 0), 1,
             null, null);
-            Table.States (40).Kernel := To_Vector ((0 => (121, 127, 0, 
False)));
-            Table.States (40).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 121, 1)));
-            Table.States (41).Action_List.Set_Capacity (62);
-            Add_Action (Table.States (41), (4, 5, 10, 13, 15, 17, 18, 20, 21, 
22, 23, 27, 28, 31, 32, 33, 35, 37, 38,
-            40, 41, 42, 43, 48, 52, 53, 55, 56, 57, 58, 61, 68, 73, 74, 75, 
76, 77, 78, 79, 82, 83, 84, 85, 86, 87, 88,
-            89, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 104, 105, 
106), (239, 3), 1, null, null);
-            Table.States (41).Kernel := To_Vector ((0 => (239, 128, 0, True)));
-            Table.States (41).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 239, 1)));
-            Table.States (41).Minimal_Complete_Actions_Recursive := True;
-            Table.States (42).Action_List.Set_Capacity (5);
-            Add_Action (Table.States (42), (13, 17, 28, 37, 73), (132, 0), 1, 
null, block_label_opt_0_check'Access);
-            Table.States (42).Kernel := To_Vector ((0 => (132, 131, 0, 
False)));
-            Table.States (42).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 132, 1)));
+            Table.States (36).Kernel := To_Vector ((0 => (158, 113, 0, 
False)));
+            Table.States (36).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 158, 1)));
+            Table.States (37).Action_List.Set_Capacity (47);
+            Add_Action (Table.States (37), (4, 5, 13, 15, 17, 18, 22, 23, 24, 
25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
+            40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 
68, 69, 71, 72, 73, 74, 79, 94, 105, 106,
+            107, 108), (152, 5), 1, null, null);
+            Table.States (37).Kernel := To_Vector ((0 => (152, 114, 0, 
False)));
+            Table.States (37).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 152, 1)));
+            Table.States (38).Action_List.Set_Capacity (41);
+            Add_Action (Table.States (38), (4, 5, 13, 15, 17, 18, 24, 25, 27, 
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
+            47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 
79, 94, 105, 106, 107, 108), (158, 1), 1,
+            null, null);
+            Table.States (38).Kernel := To_Vector ((0 => (158, 122, 0, 
False)));
+            Table.States (38).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 158, 1)));
+            Table.States (39).Action_List.Set_Capacity (47);
+            Add_Action (Table.States (39), (4, 5, 13, 15, 17, 18, 22, 23, 24, 
25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
+            40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 
68, 69, 71, 72, 73, 74, 79, 94, 105, 106,
+            107, 108), (304, 1), 1, null, null);
+            Table.States (39).Kernel := To_Vector ((0 => (304, 124, 0, 
False)));
+            Table.States (39).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 304, 1)));
+            Table.States (40).Action_List.Set_Capacity (47);
+            Add_Action (Table.States (40), (4, 5, 13, 15, 17, 18, 22, 23, 24, 
25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
+            40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 
68, 69, 71, 72, 73, 74, 79, 94, 105, 106,
+            107, 108), (299, 3), 1, null, null);
+            Table.States (40).Kernel := To_Vector ((0 => (299, 127, 0, 
False)));
+            Table.States (40).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 299, 1)));
+            Table.States (41).Action_List.Set_Capacity (42);
+            Add_Action (Table.States (41), (4, 5, 13, 15, 17, 18, 24, 25, 27, 
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
+            47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 72, 73, 
74, 79, 94, 105, 106, 107, 108), (122, 3),
+            1, null, null);
+            Table.States (41).Kernel := To_Vector ((0 => (122, 128, 0, 
False)));
+            Table.States (41).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 122, 1)));
+            Table.States (42).Action_List.Set_Capacity (63);
+            Add_Action (Table.States (42), (4, 5, 10, 13, 15, 17, 18, 20, 21, 
22, 23, 27, 28, 31, 32, 33, 35, 37, 38,
+            40, 41, 42, 43, 48, 52, 53, 55, 56, 57, 58, 61, 68, 73, 74, 75, 
76, 77, 78, 79, 80, 83, 84, 85, 86, 87, 88,
+            89, 90, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 105, 
106, 107), (240, 3), 1, null, null);
+            Table.States (42).Kernel := To_Vector ((0 => (240, 129, 0, True)));
+            Table.States (42).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 240, 1)));
+            Table.States (42).Minimal_Complete_Actions_Recursive := True;
             Table.States (43).Action_List.Set_Capacity (5);
-            Add_Action (Table.States (43), 13, 224);
-            Add_Action (Table.States (43), 17, 225);
-            Add_Action (Table.States (43), 28, 226);
-            Add_Action (Table.States (43), 37, 227);
-            Add_Action (Table.States (43), 73, 29);
-            Table.States (43).Goto_List.Set_Capacity (1);
-            Add_Goto (Table.States (43), 229, 228);
-            Table.States (43).Kernel := To_Vector (((133, 132, 4, False), 
(133, 132, 3, False), (232, 132, 5, False),
-            (232, 132, 4, False)));
-            Table.States (43).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 13, 224)));
-            Table.States (44).Action_List.Set_Capacity (46);
-            Add_Action (Table.States (44), (4, 5, 13, 15, 17, 18, 22, 23, 24, 
25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
-            40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 
68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
-            107), (151, 3), 1, null, null);
-            Table.States (44).Kernel := To_Vector ((0 => (151, 133, 0, 
False)));
-            Table.States (44).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 151, 1)));
-            Table.States (45).Action_List.Set_Capacity (40);
-            Add_Action (Table.States (45), (4, 5, 13, 15, 17, 18, 24, 25, 27, 
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
-            47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 
93, 104, 105, 106, 107), (157, 2), 1, null,
-            null);
-            Table.States (45).Kernel := To_Vector ((0 => (157, 134, 0, 
False)));
-            Table.States (45).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 157, 1)));
-            Table.States (46).Action_List.Set_Capacity (40);
+            Add_Action (Table.States (43), (13, 17, 28, 37, 73), (133, 0), 1, 
null, block_label_opt_0_check'Access);
+            Table.States (43).Kernel := To_Vector ((0 => (133, 132, 0, 
False)));
+            Table.States (43).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 133, 1)));
+            Table.States (44).Action_List.Set_Capacity (5);
+            Add_Action (Table.States (44), 13, 225);
+            Add_Action (Table.States (44), 17, 226);
+            Add_Action (Table.States (44), 28, 227);
+            Add_Action (Table.States (44), 37, 228);
+            Add_Action (Table.States (44), 73, 29);
+            Table.States (44).Goto_List.Set_Capacity (1);
+            Add_Goto (Table.States (44), 230, 229);
+            Table.States (44).Kernel := To_Vector (((134, 133, 4, False), 
(134, 133, 3, False), (233, 133, 5, False),
+            (233, 133, 4, False)));
+            Table.States (44).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 13, 225)));
+            Table.States (45).Action_List.Set_Capacity (47);
+            Add_Action (Table.States (45), (4, 5, 13, 15, 17, 18, 22, 23, 24, 
25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
+            40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 
68, 69, 71, 72, 73, 74, 79, 94, 105, 106,
+            107, 108), (152, 3), 1, null, null);
+            Table.States (45).Kernel := To_Vector ((0 => (152, 134, 0, 
False)));
+            Table.States (45).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 152, 1)));
+            Table.States (46).Action_List.Set_Capacity (41);
             Add_Action (Table.States (46), (4, 5, 13, 15, 17, 18, 24, 25, 27, 
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
-            47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 
93, 104, 105, 106, 107), (134, 1), 1, null,
-            null);
-            Table.States (46).Kernel := To_Vector ((0 => (134, 135, 0, 
False)));
-            Table.States (46).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 134, 1)));
-            Table.States (47).Action_List.Set_Capacity (46);
-            Add_Action (Table.States (47), (4, 5, 13, 15, 17, 18, 22, 23, 24, 
25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
-            40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 
68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
-            107), (151, 1), 1, null, null);
-            Table.States (47).Kernel := To_Vector ((0 => (151, 139, 0, 
False)));
-            Table.States (47).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 151, 1)));
-            Table.States (48).Action_List.Set_Capacity (39);
-            Add_Action (Table.States (48), (4, 5, 13, 15, 17, 18, 25, 27, 28, 
29, 30, 31, 32, 36, 37, 40, 41, 46, 47,
-            48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 93, 
104, 105, 106, 107), (143, 1), 1,
+            47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 
79, 94, 105, 106, 107, 108), (158, 2), 1,
+            null, null);
+            Table.States (46).Kernel := To_Vector ((0 => (158, 135, 0, 
False)));
+            Table.States (46).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 158, 1)));
+            Table.States (47).Action_List.Set_Capacity (41);
+            Add_Action (Table.States (47), (4, 5, 13, 15, 17, 18, 24, 25, 27, 
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
+            47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 
79, 94, 105, 106, 107, 108), (135, 1), 1,
+            null, null);
+            Table.States (47).Kernel := To_Vector ((0 => (135, 136, 0, 
False)));
+            Table.States (47).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 135, 1)));
+            Table.States (48).Action_List.Set_Capacity (47);
+            Add_Action (Table.States (48), (4, 5, 13, 15, 17, 18, 22, 23, 24, 
25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
+            40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 
68, 69, 71, 72, 73, 74, 79, 94, 105, 106,
+            107, 108), (152, 1), 1, null, null);
+            Table.States (48).Kernel := To_Vector ((0 => (152, 140, 0, 
False)));
+            Table.States (48).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 152, 1)));
+            Table.States (49).Action_List.Set_Capacity (40);
+            Add_Action (Table.States (49), (4, 5, 13, 15, 17, 18, 25, 27, 28, 
29, 30, 31, 32, 36, 37, 40, 41, 46, 47,
+            48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 79, 
94, 105, 106, 107, 108), (144, 1), 1,
             compilation_unit_list_1'Access, 
compilation_unit_list_1_check'Access);
-            Table.States (48).Kernel := To_Vector ((0 => (143, 142, 0, 
False)));
-            Table.States (48).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 143, 1)));
-            Table.States (49).Action_List.Set_Capacity (39);
-            Add_Action (Table.States (49), 4, 1);
-            Add_Action (Table.States (49), 5, 2);
-            Add_Action (Table.States (49), 13, Reduce, (132, 1), 0, null, 
null);
-            Add_Action (Table.States (49), 15, 3);
-            Add_Action (Table.States (49), 17, Reduce, (132, 1), 0, null, 
null);
-            Add_Action (Table.States (49), 18, 4);
-            Add_Action (Table.States (49), 25, Reduce, (246, 2), 0, null, 
null);
-            Add_Action (Table.States (49), 27, 5);
-            Add_Action (Table.States (49), 28, 6);
-            Add_Conflict (Table.States (49), 28, (132, 1), 0, null, null);
-            Add_Action (Table.States (49), 29, Reduce, (246, 2), 0, null, 
null);
-            Add_Action (Table.States (49), 30, 8);
-            Add_Action (Table.States (49), 31, 9);
-            Add_Action (Table.States (49), 32, 10);
-            Add_Action (Table.States (49), 36, 11);
-            Add_Action (Table.States (49), 37, Reduce, (132, 1), 0, null, 
null);
-            Add_Action (Table.States (49), 40, 12);
-            Add_Action (Table.States (49), 41, 13);
-            Add_Action (Table.States (49), 46, 14);
-            Add_Action (Table.States (49), 47, 15);
-            Add_Action (Table.States (49), 48, 16);
-            Add_Action (Table.States (49), 49, 17);
-            Add_Action (Table.States (49), 50, Reduce, (246, 2), 0, null, 
null);
-            Add_Action (Table.States (49), 51, 19);
-            Add_Action (Table.States (49), 52, 20);
-            Add_Action (Table.States (49), 57, 21);
-            Add_Action (Table.States (49), 58, 22);
-            Add_Action (Table.States (49), 60, 23);
-            Add_Action (Table.States (49), 61, 24);
-            Add_Action (Table.States (49), 63, 25);
-            Add_Action (Table.States (49), 66, 26);
-            Add_Action (Table.States (49), 69, 27);
-            Add_Action (Table.States (49), 71, 28);
-            Add_Action (Table.States (49), 73, Reduce, (132, 1), 0, null, 
null);
-            Add_Action (Table.States (49), 74, 30);
-            Add_Action (Table.States (49), 93, 31);
-            Add_Action (Table.States (49), 104, 32);
-            Add_Action (Table.States (49), 105, 33);
-            Add_Action (Table.States (49), 106, 34);
-            Add_Action (Table.States (49), 107, Accept_It, (108, 0), 1, null, 
null);
-            Table.States (49).Goto_List.Set_Capacity (82);
-            Add_Goto (Table.States (49), 112, 35);
-            Add_Goto (Table.States (49), 113, 36);
-            Add_Goto (Table.States (49), 121, 37);
-            Add_Goto (Table.States (49), 123, 38);
-            Add_Goto (Table.States (49), 126, 39);
-            Add_Goto (Table.States (49), 127, 40);
-            Add_Goto (Table.States (49), 128, 41);
-            Add_Goto (Table.States (49), 131, 42);
-            Add_Goto (Table.States (49), 132, 43);
-            Add_Goto (Table.States (49), 133, 44);
-            Add_Goto (Table.States (49), 134, 45);
-            Add_Goto (Table.States (49), 135, 46);
-            Add_Goto (Table.States (49), 139, 47);
-            Add_Goto (Table.States (49), 142, 229);
-            Add_Goto (Table.States (49), 151, 50);
-            Add_Goto (Table.States (49), 152, 51);
-            Add_Goto (Table.States (49), 157, 52);
-            Add_Goto (Table.States (49), 161, 53);
-            Add_Goto (Table.States (49), 179, 54);
-            Add_Goto (Table.States (49), 182, 55);
-            Add_Goto (Table.States (49), 186, 56);
-            Add_Goto (Table.States (49), 190, 57);
-            Add_Goto (Table.States (49), 193, 58);
-            Add_Goto (Table.States (49), 196, 59);
-            Add_Goto (Table.States (49), 206, 60);
-            Add_Goto (Table.States (49), 207, 61);
-            Add_Goto (Table.States (49), 209, 62);
-            Add_Goto (Table.States (49), 210, 63);
-            Add_Goto (Table.States (49), 213, 64);
-            Add_Goto (Table.States (49), 214, 65);
-            Add_Goto (Table.States (49), 215, 66);
-            Add_Goto (Table.States (49), 216, 67);
-            Add_Goto (Table.States (49), 217, 68);
-            Add_Goto (Table.States (49), 219, 69);
-            Add_Goto (Table.States (49), 222, 70);
-            Add_Goto (Table.States (49), 223, 71);
-            Add_Goto (Table.States (49), 232, 72);
-            Add_Goto (Table.States (49), 239, 73);
-            Add_Goto (Table.States (49), 243, 74);
-            Add_Goto (Table.States (49), 244, 75);
-            Add_Goto (Table.States (49), 245, 76);
-            Add_Goto (Table.States (49), 246, 77);
-            Add_Goto (Table.States (49), 247, 78);
-            Add_Goto (Table.States (49), 248, 79);
-            Add_Goto (Table.States (49), 249, 80);
-            Add_Goto (Table.States (49), 250, 81);
-            Add_Goto (Table.States (49), 251, 82);
-            Add_Goto (Table.States (49), 257, 83);
-            Add_Goto (Table.States (49), 259, 84);
-            Add_Goto (Table.States (49), 260, 85);
-            Add_Goto (Table.States (49), 261, 86);
-            Add_Goto (Table.States (49), 262, 87);
-            Add_Goto (Table.States (49), 263, 88);
-            Add_Goto (Table.States (49), 264, 89);
-            Add_Goto (Table.States (49), 265, 90);
-            Add_Goto (Table.States (49), 271, 91);
-            Add_Goto (Table.States (49), 272, 92);
-            Add_Goto (Table.States (49), 276, 93);
-            Add_Goto (Table.States (49), 281, 94);
-            Add_Goto (Table.States (49), 289, 95);
-            Add_Goto (Table.States (49), 290, 96);
-            Add_Goto (Table.States (49), 293, 97);
-            Add_Goto (Table.States (49), 294, 98);
-            Add_Goto (Table.States (49), 298, 99);
-            Add_Goto (Table.States (49), 302, 100);
-            Add_Goto (Table.States (49), 303, 101);
-            Add_Goto (Table.States (49), 304, 102);
-            Add_Goto (Table.States (49), 305, 103);
-            Add_Goto (Table.States (49), 306, 104);
-            Add_Goto (Table.States (49), 307, 105);
-            Add_Goto (Table.States (49), 308, 106);
-            Add_Goto (Table.States (49), 309, 107);
-            Add_Goto (Table.States (49), 311, 108);
-            Add_Goto (Table.States (49), 313, 109);
-            Add_Goto (Table.States (49), 315, 110);
-            Add_Goto (Table.States (49), 316, 111);
-            Add_Goto (Table.States (49), 317, 112);
-            Add_Goto (Table.States (49), 319, 113);
-            Add_Goto (Table.States (49), 323, 114);
-            Add_Goto (Table.States (49), 325, 115);
-            Add_Goto (Table.States (49), 331, 116);
-            Add_Goto (Table.States (49), 332, 117);
-            Table.States (49).Kernel := To_Vector (((108, 143, 1, False), 
(143, 143, 2, True)));
+            Table.States (49).Kernel := To_Vector ((0 => (144, 143, 0, 
False)));
+            Table.States (49).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 144, 1)));
+            Table.States (50).Action_List.Set_Capacity (40);
+            Add_Action (Table.States (50), 4, 1);
+            Add_Action (Table.States (50), 5, 2);
+            Add_Action (Table.States (50), 13, Reduce, (133, 1), 0, null, 
null);
+            Add_Action (Table.States (50), 15, 3);
+            Add_Action (Table.States (50), 17, Reduce, (133, 1), 0, null, 
null);
+            Add_Action (Table.States (50), 18, 4);
+            Add_Action (Table.States (50), 25, Reduce, (247, 2), 0, null, 
null);
+            Add_Action (Table.States (50), 27, 5);
+            Add_Action (Table.States (50), 28, 6);
+            Add_Conflict (Table.States (50), 28, (133, 1), 0, null, null);
+            Add_Action (Table.States (50), 29, Reduce, (247, 2), 0, null, 
null);
+            Add_Action (Table.States (50), 30, 8);
+            Add_Action (Table.States (50), 31, 9);
+            Add_Action (Table.States (50), 32, 10);
+            Add_Action (Table.States (50), 36, 11);
+            Add_Action (Table.States (50), 37, Reduce, (133, 1), 0, null, 
null);
+            Add_Action (Table.States (50), 40, 12);
+            Add_Action (Table.States (50), 41, 13);
+            Add_Action (Table.States (50), 46, 14);
+            Add_Action (Table.States (50), 47, 15);
+            Add_Action (Table.States (50), 48, 16);
+            Add_Action (Table.States (50), 49, 17);
+            Add_Action (Table.States (50), 50, Reduce, (247, 2), 0, null, 
null);
+            Add_Action (Table.States (50), 51, 19);
+            Add_Action (Table.States (50), 52, 20);
+            Add_Action (Table.States (50), 57, 21);
+            Add_Action (Table.States (50), 58, 22);
+            Add_Action (Table.States (50), 60, 23);
+            Add_Action (Table.States (50), 61, 24);
+            Add_Action (Table.States (50), 63, 25);
+            Add_Action (Table.States (50), 66, 26);
+            Add_Action (Table.States (50), 69, 27);
+            Add_Action (Table.States (50), 71, 28);
+            Add_Action (Table.States (50), 73, Reduce, (133, 1), 0, null, 
null);
+            Add_Action (Table.States (50), 74, 30);
+            Add_Action (Table.States (50), 79, 31);
+            Add_Action (Table.States (50), 94, 32);
+            Add_Action (Table.States (50), 105, 33);
+            Add_Action (Table.States (50), 106, 34);
+            Add_Action (Table.States (50), 107, 35);
+            Add_Action (Table.States (50), 108, Accept_It, (109, 0), 1, null, 
null);
+            Table.States (50).Goto_List.Set_Capacity (82);
+            Add_Goto (Table.States (50), 113, 36);
+            Add_Goto (Table.States (50), 114, 37);
+            Add_Goto (Table.States (50), 122, 38);
+            Add_Goto (Table.States (50), 124, 39);
+            Add_Goto (Table.States (50), 127, 40);
+            Add_Goto (Table.States (50), 128, 41);
+            Add_Goto (Table.States (50), 129, 42);
+            Add_Goto (Table.States (50), 132, 43);
+            Add_Goto (Table.States (50), 133, 44);
+            Add_Goto (Table.States (50), 134, 45);
+            Add_Goto (Table.States (50), 135, 46);
+            Add_Goto (Table.States (50), 136, 47);
+            Add_Goto (Table.States (50), 140, 48);
+            Add_Goto (Table.States (50), 143, 230);
+            Add_Goto (Table.States (50), 152, 51);
+            Add_Goto (Table.States (50), 153, 52);
+            Add_Goto (Table.States (50), 158, 53);
+            Add_Goto (Table.States (50), 162, 54);
+            Add_Goto (Table.States (50), 180, 55);
+            Add_Goto (Table.States (50), 183, 56);
+            Add_Goto (Table.States (50), 187, 57);
+            Add_Goto (Table.States (50), 191, 58);
+            Add_Goto (Table.States (50), 194, 59);
+            Add_Goto (Table.States (50), 197, 60);
+            Add_Goto (Table.States (50), 207, 61);
+            Add_Goto (Table.States (50), 208, 62);
+            Add_Goto (Table.States (50), 210, 63);
+            Add_Goto (Table.States (50), 211, 64);
+            Add_Goto (Table.States (50), 214, 65);
+            Add_Goto (Table.States (50), 215, 66);
+            Add_Goto (Table.States (50), 216, 67);
+            Add_Goto (Table.States (50), 217, 68);
+            Add_Goto (Table.States (50), 218, 69);
+            Add_Goto (Table.States (50), 220, 70);
+            Add_Goto (Table.States (50), 223, 71);
+            Add_Goto (Table.States (50), 224, 72);
+            Add_Goto (Table.States (50), 233, 73);
+            Add_Goto (Table.States (50), 240, 74);
+            Add_Goto (Table.States (50), 244, 75);
+            Add_Goto (Table.States (50), 245, 76);
+            Add_Goto (Table.States (50), 246, 77);
+            Add_Goto (Table.States (50), 247, 78);
+            Add_Goto (Table.States (50), 248, 79);
+            Add_Goto (Table.States (50), 249, 80);
+            Add_Goto (Table.States (50), 250, 81);
+            Add_Goto (Table.States (50), 251, 82);
+            Add_Goto (Table.States (50), 252, 83);
+            Add_Goto (Table.States (50), 258, 84);
+            Add_Goto (Table.States (50), 260, 85);
+            Add_Goto (Table.States (50), 261, 86);
+            Add_Goto (Table.States (50), 262, 87);
+            Add_Goto (Table.States (50), 263, 88);
+            Add_Goto (Table.States (50), 264, 89);
+            Add_Goto (Table.States (50), 265, 90);
+            Add_Goto (Table.States (50), 266, 91);
+            Add_Goto (Table.States (50), 272, 92);
+            Add_Goto (Table.States (50), 273, 93);
+            Add_Goto (Table.States (50), 277, 94);
+            Add_Goto (Table.States (50), 282, 95);
+            Add_Goto (Table.States (50), 290, 96);
+            Add_Goto (Table.States (50), 291, 97);
+            Add_Goto (Table.States (50), 294, 98);
+            Add_Goto (Table.States (50), 295, 99);
+            Add_Goto (Table.States (50), 299, 100);
+            Add_Goto (Table.States (50), 303, 101);
+            Add_Goto (Table.States (50), 304, 102);
+            Add_Goto (Table.States (50), 305, 103);
+            Add_Goto (Table.States (50), 306, 104);
+            Add_Goto (Table.States (50), 307, 105);
+            Add_Goto (Table.States (50), 308, 106);
+            Add_Goto (Table.States (50), 309, 107);
+            Add_Goto (Table.States (50), 310, 108);
+            Add_Goto (Table.States (50), 312, 109);
+            Add_Goto (Table.States (50), 314, 110);
+            Add_Goto (Table.States (50), 316, 111);
+            Add_Goto (Table.States (50), 317, 112);
+            Add_Goto (Table.States (50), 318, 113);
+            Add_Goto (Table.States (50), 320, 114);
+            Add_Goto (Table.States (50), 324, 115);
+            Add_Goto (Table.States (50), 326, 116);
+            Add_Goto (Table.States (50), 332, 117);
+            Add_Goto (Table.States (50), 333, 118);
+            Table.States (50).Kernel := To_Vector (((109, 144, 1, False), 
(144, 144, 2, True)));
          end Subr_1;
          procedure Subr_2
          is begin
-            Table.States (50).Action_List.Set_Capacity (46);
-            Add_Action (Table.States (50), (4, 5, 13, 15, 17, 18, 22, 23, 24, 
25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
-            40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 
68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
-            107), (306, 2), 1, null, null);
-            Table.States (50).Kernel := To_Vector ((0 => (306, 151, 0, 
False)));
-            Table.States (50).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 306, 1)));
-            Table.States (51).Action_List.Set_Capacity (46);
+            Table.States (51).Action_List.Set_Capacity (47);
             Add_Action (Table.States (51), (4, 5, 13, 15, 17, 18, 22, 23, 24, 
25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
-            40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 
68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
-            107), (298, 2), 1, null, null);
-            Table.States (51).Kernel := To_Vector ((0 => (298, 152, 0, 
False)));
-            Table.States (51).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 298, 1)));
-            Table.States (52).Action_List.Set_Capacity (39);
-            Add_Action (Table.States (52), (4, 5, 13, 15, 17, 18, 25, 27, 28, 
29, 30, 31, 32, 36, 37, 40, 41, 46, 47,
-            48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 93, 
104, 105, 106, 107), (142, 3), 1, null,
-            null);
-            Table.States (52).Kernel := To_Vector ((0 => (142, 157, 0, 
False)));
-            Table.States (52).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 142, 1)));
-            Table.States (53).Action_List.Set_Capacity (46);
-            Add_Action (Table.States (53), (4, 5, 13, 15, 17, 18, 22, 23, 24, 
25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
-            40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 
68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
-            107), (303, 7), 1, null, null);
-            Table.States (53).Kernel := To_Vector ((0 => (303, 161, 0, 
False)));
-            Table.States (53).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 303, 1)));
-            Table.States (54).Action_List.Set_Capacity (40);
-            Add_Action (Table.States (54), (4, 5, 13, 15, 17, 18, 24, 25, 27, 
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
-            47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 
93, 104, 105, 106, 107), (157, 3), 1, null,
+            40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 
68, 69, 71, 72, 73, 74, 79, 94, 105, 106,
+            107, 108), (307, 2), 1, null, null);
+            Table.States (51).Kernel := To_Vector ((0 => (307, 152, 0, 
False)));
+            Table.States (51).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 307, 1)));
+            Table.States (52).Action_List.Set_Capacity (47);
+            Add_Action (Table.States (52), (4, 5, 13, 15, 17, 18, 22, 23, 24, 
25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
+            40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 
68, 69, 71, 72, 73, 74, 79, 94, 105, 106,
+            107, 108), (299, 2), 1, null, null);
+            Table.States (52).Kernel := To_Vector ((0 => (299, 153, 0, 
False)));
+            Table.States (52).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 299, 1)));
+            Table.States (53).Action_List.Set_Capacity (40);
+            Add_Action (Table.States (53), (4, 5, 13, 15, 17, 18, 25, 27, 28, 
29, 30, 31, 32, 36, 37, 40, 41, 46, 47,
+            48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 79, 
94, 105, 106, 107, 108), (143, 3), 1, null,
             null);
-            Table.States (54).Kernel := To_Vector ((0 => (157, 179, 0, 
False)));
-            Table.States (54).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 157, 1)));
+            Table.States (53).Kernel := To_Vector ((0 => (143, 158, 0, 
False)));
+            Table.States (53).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 143, 1)));
+            Table.States (54).Action_List.Set_Capacity (47);
+            Add_Action (Table.States (54), (4, 5, 13, 15, 17, 18, 22, 23, 24, 
25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
+            40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 
68, 69, 71, 72, 73, 74, 79, 94, 105, 106,
+            107, 108), (304, 7), 1, null, null);
+            Table.States (54).Kernel := To_Vector ((0 => (304, 162, 0, 
False)));
+            Table.States (54).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 304, 1)));
             Table.States (55).Action_List.Set_Capacity (41);
             Add_Action (Table.States (55), (4, 5, 13, 15, 17, 18, 24, 25, 27, 
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
-            47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 72, 73, 
74, 93, 104, 105, 106, 107), (121, 1), 1,
+            47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 
79, 94, 105, 106, 107, 108), (158, 3), 1,
             null, null);
-            Table.States (55).Kernel := To_Vector ((0 => (121, 182, 0, 
False)));
-            Table.States (55).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 121, 1)));
-            Table.States (56).Action_List.Set_Capacity (40);
+            Table.States (55).Kernel := To_Vector ((0 => (158, 180, 0, 
False)));
+            Table.States (55).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 158, 1)));
+            Table.States (56).Action_List.Set_Capacity (42);
             Add_Action (Table.States (56), (4, 5, 13, 15, 17, 18, 24, 25, 27, 
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
-            47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 
93, 104, 105, 106, 107), (157, 4), 1, null,
-            null);
-            Table.States (56).Kernel := To_Vector ((0 => (157, 186, 0, 
False)));
-            Table.States (56).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 157, 1)));
-            Table.States (57).Action_List.Set_Capacity (46);
-            Add_Action (Table.States (57), (4, 5, 13, 15, 17, 18, 22, 23, 24, 
25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
-            40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 
68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
-            107), (303, 2), 1, null, null);
-            Table.States (57).Kernel := To_Vector ((0 => (303, 190, 0, 
False)));
-            Table.States (57).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 303, 1)));
-            Table.States (58).Action_List.Set_Capacity (40);
-            Add_Action (Table.States (58), (4, 5, 13, 15, 17, 18, 24, 25, 27, 
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
-            47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 
93, 104, 105, 106, 107), (157, 5), 1, null,
-            null);
-            Table.States (58).Kernel := To_Vector ((0 => (157, 193, 0, 
False)));
-            Table.States (58).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 157, 1)));
-            Table.States (59).Action_List.Set_Capacity (46);
-            Add_Action (Table.States (59), (4, 5, 13, 15, 17, 18, 22, 23, 24, 
25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
-            40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 
68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
-            107), (151, 4), 1, null, null);
-            Table.States (59).Kernel := To_Vector ((0 => (151, 196, 0, 
False)));
-            Table.States (59).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 151, 1)));
-            Table.States (60).Action_List.Set_Capacity (40);
-            Add_Action (Table.States (60), (4, 5, 13, 15, 17, 18, 24, 25, 27, 
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
-            47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 
93, 104, 105, 106, 107), (325, 0), 1, null,
-            null);
-            Table.States (60).Kernel := To_Vector ((0 => (325, 206, 0, 
False)));
-            Table.States (60).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 325, 1)));
-            Table.States (61).Action_List.Set_Capacity (3);
-            Add_Action (Table.States (61), (35, 74, 96), (312, 1), 1, null, 
subprogram_specification_1_check'Access);
-            Table.States (61).Kernel := To_Vector ((0 => (312, 207, 0, 
False)));
-            Table.States (61).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 312, 1)));
-            Table.States (62).Action_List.Set_Capacity (40);
-            Add_Action (Table.States (62), (4, 5, 13, 15, 17, 18, 24, 25, 27, 
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
-            47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 
93, 104, 105, 106, 107), (157, 6), 1, null,
-            null);
-            Table.States (62).Kernel := To_Vector ((0 => (157, 209, 0, 
False)));
-            Table.States (62).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 157, 1)));
-            Table.States (63).Action_List.Set_Capacity (3);
-            Add_Action (Table.States (63), 29, 7);
-            Add_Action (Table.States (63), 47, 230);
-            Add_Action (Table.States (63), 50, 18);
-            Table.States (63).Goto_List.Set_Capacity (4);
-            Add_Goto (Table.States (63), 207, 61);
-            Add_Goto (Table.States (63), 251, 231);
-            Add_Goto (Table.States (63), 262, 87);
-            Add_Goto (Table.States (63), 312, 232);
-            Table.States (63).Kernel := To_Vector (((214, 210, 5, False), 
(216, 210, 3, False)));
-            Table.States (63).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 50, 18)));
-            Table.States (64).Action_List.Set_Capacity (40);
-            Add_Action (Table.States (64), (4, 5, 13, 15, 17, 18, 24, 25, 27, 
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
-            47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 
93, 104, 105, 106, 107), (157, 7), 1, null,
-            null);
-            Table.States (64).Kernel := To_Vector ((0 => (157, 213, 0, 
False)));
-            Table.States (64).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 157, 1)));
-            Table.States (65).Action_List.Set_Capacity (40);
+            47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 72, 73, 
74, 79, 94, 105, 106, 107, 108), (122, 1),
+            1, null, null);
+            Table.States (56).Kernel := To_Vector ((0 => (122, 183, 0, 
False)));
+            Table.States (56).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 122, 1)));
+            Table.States (57).Action_List.Set_Capacity (41);
+            Add_Action (Table.States (57), (4, 5, 13, 15, 17, 18, 24, 25, 27, 
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
+            47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 
79, 94, 105, 106, 107, 108), (158, 4), 1,
+            null, null);
+            Table.States (57).Kernel := To_Vector ((0 => (158, 187, 0, 
False)));
+            Table.States (57).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 158, 1)));
+            Table.States (58).Action_List.Set_Capacity (47);
+            Add_Action (Table.States (58), (4, 5, 13, 15, 17, 18, 22, 23, 24, 
25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
+            40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 
68, 69, 71, 72, 73, 74, 79, 94, 105, 106,
+            107, 108), (304, 2), 1, null, null);
+            Table.States (58).Kernel := To_Vector ((0 => (304, 191, 0, 
False)));
+            Table.States (58).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 304, 1)));
+            Table.States (59).Action_List.Set_Capacity (41);
+            Add_Action (Table.States (59), (4, 5, 13, 15, 17, 18, 24, 25, 27, 
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
+            47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 
79, 94, 105, 106, 107, 108), (158, 5), 1,
+            null, null);
+            Table.States (59).Kernel := To_Vector ((0 => (158, 194, 0, 
False)));
+            Table.States (59).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 158, 1)));
+            Table.States (60).Action_List.Set_Capacity (47);
+            Add_Action (Table.States (60), (4, 5, 13, 15, 17, 18, 22, 23, 24, 
25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
+            40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 
68, 69, 71, 72, 73, 74, 79, 94, 105, 106,
+            107, 108), (152, 4), 1, null, null);
+            Table.States (60).Kernel := To_Vector ((0 => (152, 197, 0, 
False)));
+            Table.States (60).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 152, 1)));
+            Table.States (61).Action_List.Set_Capacity (41);
+            Add_Action (Table.States (61), (4, 5, 13, 15, 17, 18, 24, 25, 27, 
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
+            47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 
79, 94, 105, 106, 107, 108), (326, 0), 1,
+            null, null);
+            Table.States (61).Kernel := To_Vector ((0 => (326, 207, 0, 
False)));
+            Table.States (61).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 326, 1)));
+            Table.States (62).Action_List.Set_Capacity (3);
+            Add_Action (Table.States (62), (35, 74, 97), (313, 1), 1, null, 
subprogram_specification_1_check'Access);
+            Table.States (62).Kernel := To_Vector ((0 => (313, 208, 0, 
False)));
+            Table.States (62).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 313, 1)));
+            Table.States (63).Action_List.Set_Capacity (41);
+            Add_Action (Table.States (63), (4, 5, 13, 15, 17, 18, 24, 25, 27, 
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
+            47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 
79, 94, 105, 106, 107, 108), (158, 6), 1,
+            null, null);
+            Table.States (63).Kernel := To_Vector ((0 => (158, 210, 0, 
False)));
+            Table.States (63).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 158, 1)));
+            Table.States (64).Action_List.Set_Capacity (3);
+            Add_Action (Table.States (64), 29, 7);
+            Add_Action (Table.States (64), 47, 231);
+            Add_Action (Table.States (64), 50, 18);
+            Table.States (64).Goto_List.Set_Capacity (4);
+            Add_Goto (Table.States (64), 208, 62);
+            Add_Goto (Table.States (64), 252, 232);
+            Add_Goto (Table.States (64), 263, 88);
+            Add_Goto (Table.States (64), 313, 233);
+            Table.States (64).Kernel := To_Vector (((215, 211, 5, False), 
(217, 211, 3, False)));
+            Table.States (64).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 50, 18)));
+            Table.States (65).Action_List.Set_Capacity (41);
             Add_Action (Table.States (65), (4, 5, 13, 15, 17, 18, 24, 25, 27, 
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
-            47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 
93, 104, 105, 106, 107), (209, 1), 1, null,
-            null);
-            Table.States (65).Kernel := To_Vector ((0 => (209, 214, 0, 
False)));
-            Table.States (65).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 209, 1)));
-            Table.States (66).Action_List.Set_Capacity (40);
+            47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 
79, 94, 105, 106, 107, 108), (158, 7), 1,
+            null, null);
+            Table.States (65).Kernel := To_Vector ((0 => (158, 214, 0, 
False)));
+            Table.States (65).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 158, 1)));
+            Table.States (66).Action_List.Set_Capacity (41);
             Add_Action (Table.States (66), (4, 5, 13, 15, 17, 18, 24, 25, 27, 
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
-            47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 
93, 104, 105, 106, 107), (289, 3), 1, null,
-            null);
-            Table.States (66).Kernel := To_Vector ((0 => (289, 215, 0, 
False)));
-            Table.States (66).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 289, 1)));
-            Table.States (67).Action_List.Set_Capacity (40);
+            47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 
79, 94, 105, 106, 107, 108), (210, 1), 1,
+            null, null);
+            Table.States (66).Kernel := To_Vector ((0 => (210, 215, 0, 
False)));
+            Table.States (66).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 210, 1)));
+            Table.States (67).Action_List.Set_Capacity (41);
             Add_Action (Table.States (67), (4, 5, 13, 15, 17, 18, 24, 25, 27, 
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
-            47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 
93, 104, 105, 106, 107), (209, 0), 1, null,
-            null);
-            Table.States (67).Kernel := To_Vector ((0 => (209, 216, 0, 
False)));
-            Table.States (67).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 209, 1)));
-            Table.States (68).Action_List.Set_Capacity (46);
-            Add_Action (Table.States (68), (4, 5, 13, 15, 17, 18, 22, 23, 24, 
25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
-            40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 
68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
-            107), (306, 0), 1, null, null);
-            Table.States (68).Kernel := To_Vector ((0 => (306, 217, 0, 
False)));
-            Table.States (68).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 306, 1)));
-            Table.States (69).Action_List.Set_Capacity (2);
-            Add_Action (Table.States (69), 81, 233);
-            Add_Action (Table.States (69), 83, 234);
-            Table.States (69).Kernel := To_Vector (((157, 219, 4, False), 
(186, 219, 3, False), (219, 219, 2, True),
-            (244, 219, 4, False), (244, 219, 5, False), (244, 219, 11, False), 
(244, 219, 3, False), (244, 219, 4,
-            False), (244, 219, 10, False)));
-            Table.States (69).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 81, 233)));
-            Table.States (70).Action_List.Set_Capacity (46);
-            Add_Action (Table.States (70), (4, 5, 13, 15, 17, 18, 22, 23, 24, 
25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
-            40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 
68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
-            107), (151, 0), 1, null, null);
-            Table.States (70).Kernel := To_Vector ((0 => (151, 222, 0, 
False)));
-            Table.States (70).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 151, 1)));
-            Table.States (71).Action_List.Set_Capacity (40);
-            Add_Action (Table.States (71), (4, 5, 13, 15, 17, 18, 24, 25, 27, 
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
-            47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 
93, 104, 105, 106, 107), (325, 1), 1, null,
-            null);
-            Table.States (71).Kernel := To_Vector ((0 => (325, 223, 0, 
False)));
-            Table.States (71).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 325, 1)));
-            Table.States (72).Action_List.Set_Capacity (46);
-            Add_Action (Table.States (72), (4, 5, 13, 15, 17, 18, 22, 23, 24, 
25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
-            40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 
68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
-            107), (151, 2), 1, null, null);
-            Table.States (72).Kernel := To_Vector ((0 => (151, 232, 0, 
False)));
-            Table.States (72).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 151, 1)));
-            Table.States (73).Action_List.Set_Capacity (6);
-            Add_Action (Table.States (73), 76, 235);
-            Add_Action (Table.States (73), 82, 236);
-            Add_Action (Table.States (73), 84, 237);
-            Add_Action (Table.States (73), 96, 238);
-            Add_Action (Table.States (73), 101, 239);
-            Add_Action (Table.States (73), 102, 240);
-            Table.States (73).Goto_List.Set_Capacity (2);
-            Add_Goto (Table.States (73), 115, 241);
-            Add_Goto (Table.States (73), 322, 242);
-            Table.States (73).Kernel := To_Vector (((123, 239, 2, False), 
(128, 239, 2, True), (239, 239, 5, True),
-            (239, 239, 2, True), (261, 239, 1, False), (272, 239, 3, True), 
(293, 239, 2, True), (293, 239, 2, True),
-            (293, 239, 2, True), (293, 239, 2, True)));
-            Table.States (73).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 96, 238)));
-            Table.States (74).Action_List.Set_Capacity (40);
-            Add_Action (Table.States (74), (4, 5, 13, 15, 17, 18, 24, 25, 27, 
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
-            47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 
93, 104, 105, 106, 107), (157, 8), 1, null,
-            null);
-            Table.States (74).Kernel := To_Vector ((0 => (157, 243, 0, 
False)));
-            Table.States (74).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 157, 1)));
-            Table.States (75).Action_List.Set_Capacity (40);
+            47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 
79, 94, 105, 106, 107, 108), (290, 3), 1,
+            null, null);
+            Table.States (67).Kernel := To_Vector ((0 => (290, 216, 0, 
False)));
+            Table.States (67).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 290, 1)));
+            Table.States (68).Action_List.Set_Capacity (41);
+            Add_Action (Table.States (68), (4, 5, 13, 15, 17, 18, 24, 25, 27, 
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
+            47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 
79, 94, 105, 106, 107, 108), (210, 0), 1,
+            null, null);
+            Table.States (68).Kernel := To_Vector ((0 => (210, 217, 0, 
False)));
+            Table.States (68).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 210, 1)));
+            Table.States (69).Action_List.Set_Capacity (47);
+            Add_Action (Table.States (69), (4, 5, 13, 15, 17, 18, 22, 23, 24, 
25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
+            40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 
68, 69, 71, 72, 73, 74, 79, 94, 105, 106,
+            107, 108), (307, 0), 1, null, null);
+            Table.States (69).Kernel := To_Vector ((0 => (307, 218, 0, 
False)));
+            Table.States (69).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 307, 1)));
+            Table.States (70).Action_List.Set_Capacity (2);
+            Add_Action (Table.States (70), 82, 234);
+            Add_Action (Table.States (70), 84, 235);
+            Table.States (70).Kernel := To_Vector (((158, 220, 4, False), 
(187, 220, 3, False), (220, 220, 2, True),
+            (245, 220, 4, False), (245, 220, 5, False), (245, 220, 11, False), 
(245, 220, 3, False), (245, 220, 4,
+            False), (245, 220, 10, False)));
+            Table.States (70).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 82, 234)));
+            Table.States (71).Action_List.Set_Capacity (47);
+            Add_Action (Table.States (71), (4, 5, 13, 15, 17, 18, 22, 23, 24, 
25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
+            40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 
68, 69, 71, 72, 73, 74, 79, 94, 105, 106,
+            107, 108), (152, 0), 1, null, null);
+            Table.States (71).Kernel := To_Vector ((0 => (152, 223, 0, 
False)));
+            Table.States (71).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 152, 1)));
+            Table.States (72).Action_List.Set_Capacity (41);
+            Add_Action (Table.States (72), (4, 5, 13, 15, 17, 18, 24, 25, 27, 
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
+            47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 
79, 94, 105, 106, 107, 108), (326, 1), 1,
+            null, null);
+            Table.States (72).Kernel := To_Vector ((0 => (326, 224, 0, 
False)));
+            Table.States (72).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 326, 1)));
+            Table.States (73).Action_List.Set_Capacity (47);
+            Add_Action (Table.States (73), (4, 5, 13, 15, 17, 18, 22, 23, 24, 
25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
+            40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 
68, 69, 71, 72, 73, 74, 79, 94, 105, 106,
+            107, 108), (152, 2), 1, null, null);
+            Table.States (73).Kernel := To_Vector ((0 => (152, 233, 0, 
False)));
+            Table.States (73).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 152, 1)));
+            Table.States (74).Action_List.Set_Capacity (6);
+            Add_Action (Table.States (74), 76, 236);
+            Add_Action (Table.States (74), 83, 237);
+            Add_Action (Table.States (74), 85, 238);
+            Add_Action (Table.States (74), 97, 239);
+            Add_Action (Table.States (74), 102, 240);
+            Add_Action (Table.States (74), 103, 241);
+            Table.States (74).Goto_List.Set_Capacity (2);
+            Add_Goto (Table.States (74), 116, 242);
+            Add_Goto (Table.States (74), 323, 243);
+            Table.States (74).Kernel := To_Vector (((124, 240, 2, False), 
(129, 240, 2, True), (240, 240, 5, True),
+            (240, 240, 2, True), (262, 240, 1, False), (273, 240, 3, True), 
(294, 240, 2, True), (294, 240, 2, True),
+            (294, 240, 2, True), (294, 240, 2, True)));
+            Table.States (74).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 97, 239)));
+            Table.States (75).Action_List.Set_Capacity (41);
             Add_Action (Table.States (75), (4, 5, 13, 15, 17, 18, 24, 25, 27, 
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
-            47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 
93, 104, 105, 106, 107), (157, 10), 1,
+            47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 
79, 94, 105, 106, 107, 108), (158, 8), 1,
             null, null);
-            Table.States (75).Kernel := To_Vector ((0 => (157, 244, 0, 
False)));
-            Table.States (75).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 157, 1)));
-            Table.States (76).Action_List.Set_Capacity (40);
+            Table.States (75).Kernel := To_Vector ((0 => (158, 244, 0, 
False)));
+            Table.States (75).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 158, 1)));
+            Table.States (76).Action_List.Set_Capacity (41);
             Add_Action (Table.States (76), (4, 5, 13, 15, 17, 18, 24, 25, 27, 
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
-            47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 
93, 104, 105, 106, 107), (289, 0), 1, null,
-            null);
-            Table.States (76).Kernel := To_Vector ((0 => (289, 245, 0, 
False)));
-            Table.States (76).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 289, 1)));
-            Table.States (77).Action_List.Set_Capacity (3);
-            Add_Action (Table.States (77), 25, 243);
-            Add_Action (Table.States (77), 29, 244);
-            Add_Action (Table.States (77), 50, 245);
-            Table.States (77).Goto_List.Set_Capacity (3);
-            Add_Goto (Table.States (77), 207, 246);
-            Add_Goto (Table.States (77), 262, 247);
-            Add_Goto (Table.States (77), 312, 248);
-            Table.States (77).Kernel := To_Vector (((112, 246, 5, False), 
(179, 246, 6, False), (179, 246, 3, False),
-            (193, 246, 7, False), (213, 246, 6, False), (213, 246, 6, False), 
(243, 246, 5, False), (307, 246, 6,
-            False), (308, 246, 5, False), (309, 246, 3, False), (311, 246, 5, 
False)));
-            Table.States (77).Minimal_Complete_Actions := To_Vector (((Shift, 
25, 243), (Shift, 50, 245)));
-            Table.States (78).Action_List.Set_Capacity (40);
-            Add_Action (Table.States (78), (4, 5, 13, 15, 17, 18, 24, 25, 27, 
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
-            47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 
93, 104, 105, 106, 107), (263, 1), 1, null,
-            null);
-            Table.States (78).Kernel := To_Vector ((0 => (263, 247, 0, 
False)));
-            Table.States (78).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 263, 1)));
-            Table.States (79).Action_List.Set_Capacity (40);
+            47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 
79, 94, 105, 106, 107, 108), (158, 10), 1,
+            null, null);
+            Table.States (76).Kernel := To_Vector ((0 => (158, 245, 0, 
False)));
+            Table.States (76).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 158, 1)));
+            Table.States (77).Action_List.Set_Capacity (41);
+            Add_Action (Table.States (77), (4, 5, 13, 15, 17, 18, 24, 25, 27, 
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
+            47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 
79, 94, 105, 106, 107, 108), (290, 0), 1,
+            null, null);
+            Table.States (77).Kernel := To_Vector ((0 => (290, 246, 0, 
False)));
+            Table.States (77).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 290, 1)));
+            Table.States (78).Action_List.Set_Capacity (3);
+            Add_Action (Table.States (78), 25, 244);
+            Add_Action (Table.States (78), 29, 245);
+            Add_Action (Table.States (78), 50, 246);
+            Table.States (78).Goto_List.Set_Capacity (3);
+            Add_Goto (Table.States (78), 208, 247);
+            Add_Goto (Table.States (78), 263, 248);
+            Add_Goto (Table.States (78), 313, 249);
+            Table.States (78).Kernel := To_Vector (((113, 247, 5, False), 
(180, 247, 6, False), (180, 247, 3, False),
+            (194, 247, 7, False), (214, 247, 6, False), (214, 247, 6, False), 
(244, 247, 5, False), (308, 247, 6,
+            False), (309, 247, 5, False), (310, 247, 3, False), (312, 247, 5, 
False)));
+            Table.States (78).Minimal_Complete_Actions := To_Vector (((Shift, 
25, 244), (Shift, 50, 246)));
+            Table.States (79).Action_List.Set_Capacity (41);
             Add_Action (Table.States (79), (4, 5, 13, 15, 17, 18, 24, 25, 27, 
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
-            47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 
93, 104, 105, 106, 107), (135, 1), 1, null,
-            null);
-            Table.States (79).Kernel := To_Vector ((0 => (135, 248, 0, 
False)));
-            Table.States (79).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 135, 1)));
-            Table.States (80).Action_List.Set_Capacity (40);
+            47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 
79, 94, 105, 106, 107, 108), (264, 1), 1,
+            null, null);
+            Table.States (79).Kernel := To_Vector ((0 => (264, 248, 0, 
False)));
+            Table.States (79).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 264, 1)));
+            Table.States (80).Action_List.Set_Capacity (41);
             Add_Action (Table.States (80), (4, 5, 13, 15, 17, 18, 24, 25, 27, 
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
-            47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 
93, 104, 105, 106, 107), (157, 11), 1,
+            47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 
79, 94, 105, 106, 107, 108), (136, 1), 1,
             null, null);
-            Table.States (80).Kernel := To_Vector ((0 => (157, 249, 0, 
False)));
-            Table.States (80).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 157, 1)));
-            Table.States (81).Action_List.Set_Capacity (40);
+            Table.States (80).Kernel := To_Vector ((0 => (136, 249, 0, 
False)));
+            Table.States (80).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 136, 1)));
+            Table.States (81).Action_List.Set_Capacity (41);
             Add_Action (Table.States (81), (4, 5, 13, 15, 17, 18, 24, 25, 27, 
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
-            47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 
93, 104, 105, 106, 107), (289, 1), 1, null,
-            null);
-            Table.States (81).Kernel := To_Vector ((0 => (289, 250, 0, 
False)));
-            Table.States (81).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 289, 1)));
-            Table.States (82).Action_List.Set_Capacity (1);
-            Add_Action (Table.States (82), 96, 249);
-            Table.States (82).Kernel := To_Vector ((0 => (249, 251, 1, 
False)));
-            Table.States (82).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 96, 249)));
-            Table.States (83).Action_List.Set_Capacity (46);
-            Add_Action (Table.States (83), (4, 5, 13, 15, 17, 18, 22, 23, 24, 
25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
-            40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 
68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
-            107), (303, 10), 1, null, null);
-            Table.States (83).Kernel := To_Vector ((0 => (303, 257, 0, 
False)));
-            Table.States (83).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 303, 1)));
-            Table.States (84).Action_List.Set_Capacity (40);
-            Add_Action (Table.States (84), (4, 5, 13, 15, 17, 18, 24, 25, 27, 
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
-            47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 
93, 104, 105, 106, 107), (325, 3), 1, null,
-            null);
-            Table.States (84).Kernel := To_Vector ((0 => (325, 259, 0, 
False)));
-            Table.States (84).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 325, 1)));
-            Table.States (85).Action_List.Set_Capacity (40);
+            47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 
79, 94, 105, 106, 107, 108), (158, 11), 1,
+            null, null);
+            Table.States (81).Kernel := To_Vector ((0 => (158, 250, 0, 
False)));
+            Table.States (81).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 158, 1)));
+            Table.States (82).Action_List.Set_Capacity (41);
+            Add_Action (Table.States (82), (4, 5, 13, 15, 17, 18, 24, 25, 27, 
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
+            47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 
79, 94, 105, 106, 107, 108), (290, 1), 1,
+            null, null);
+            Table.States (82).Kernel := To_Vector ((0 => (290, 251, 0, 
False)));
+            Table.States (82).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 290, 1)));
+            Table.States (83).Action_List.Set_Capacity (1);
+            Add_Action (Table.States (83), 97, 250);
+            Table.States (83).Kernel := To_Vector ((0 => (250, 252, 1, 
False)));
+            Table.States (83).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 97, 250)));
+            Table.States (84).Action_List.Set_Capacity (47);
+            Add_Action (Table.States (84), (4, 5, 13, 15, 17, 18, 22, 23, 24, 
25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
+            40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 
68, 69, 71, 72, 73, 74, 79, 94, 105, 106,
+            107, 108), (304, 10), 1, null, null);
+            Table.States (84).Kernel := To_Vector ((0 => (304, 258, 0, 
False)));
+            Table.States (84).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 304, 1)));
+            Table.States (85).Action_List.Set_Capacity (41);
             Add_Action (Table.States (85), (4, 5, 13, 15, 17, 18, 24, 25, 27, 
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
-            47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 
93, 104, 105, 106, 107), (325, 2), 1, null,
-            null);
-            Table.States (85).Kernel := To_Vector ((0 => (325, 260, 0, 
False)));
-            Table.States (85).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 325, 1)));
-            Table.States (86).Action_List.Set_Capacity (46);
-            Add_Action (Table.States (86), (4, 5, 13, 15, 17, 18, 22, 23, 24, 
25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
-            40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 
68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
-            107), (303, 4), 1, null, null);
-            Table.States (86).Kernel := To_Vector ((0 => (303, 261, 0, 
False)));
-            Table.States (86).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 303, 1)));
-            Table.States (87).Action_List.Set_Capacity (3);
-            Add_Action (Table.States (87), (35, 74, 96), (312, 0), 1, null, 
subprogram_specification_0_check'Access);
-            Table.States (87).Kernel := To_Vector ((0 => (312, 262, 0, 
False)));
-            Table.States (87).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 312, 1)));
-            Table.States (88).Action_List.Set_Capacity (40);
-            Add_Action (Table.States (88), (4, 5, 13, 15, 17, 18, 24, 25, 27, 
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
-            47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 
93, 104, 105, 106, 107), (134, 0), 1, null,
-            null);
-            Table.States (88).Kernel := To_Vector ((0 => (134, 263, 0, 
False)));
-            Table.States (88).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 134, 1)));
-            Table.States (89).Action_List.Set_Capacity (40);
+            47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 
79, 94, 105, 106, 107, 108), (326, 3), 1,
+            null, null);
+            Table.States (85).Kernel := To_Vector ((0 => (326, 260, 0, 
False)));
+            Table.States (85).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 326, 1)));
+            Table.States (86).Action_List.Set_Capacity (41);
+            Add_Action (Table.States (86), (4, 5, 13, 15, 17, 18, 24, 25, 27, 
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
+            47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 
79, 94, 105, 106, 107, 108), (326, 2), 1,
+            null, null);
+            Table.States (86).Kernel := To_Vector ((0 => (326, 261, 0, 
False)));
+            Table.States (86).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 326, 1)));
+            Table.States (87).Action_List.Set_Capacity (47);
+            Add_Action (Table.States (87), (4, 5, 13, 15, 17, 18, 22, 23, 24, 
25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
+            40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 
68, 69, 71, 72, 73, 74, 79, 94, 105, 106,
+            107, 108), (304, 4), 1, null, null);
+            Table.States (87).Kernel := To_Vector ((0 => (304, 262, 0, 
False)));
+            Table.States (87).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 304, 1)));
+            Table.States (88).Action_List.Set_Capacity (3);
+            Add_Action (Table.States (88), (35, 74, 97), (313, 0), 1, null, 
subprogram_specification_0_check'Access);
+            Table.States (88).Kernel := To_Vector ((0 => (313, 263, 0, 
False)));
+            Table.States (88).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 313, 1)));
+            Table.States (89).Action_List.Set_Capacity (41);
             Add_Action (Table.States (89), (4, 5, 13, 15, 17, 18, 24, 25, 27, 
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
-            47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 
93, 104, 105, 106, 107), (263, 3), 1, null,
-            null);
-            Table.States (89).Kernel := To_Vector ((0 => (263, 264, 0, 
False)));
-            Table.States (89).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 263, 1)));
-            Table.States (90).Action_List.Set_Capacity (40);
+            47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 
79, 94, 105, 106, 107, 108), (135, 0), 1,
+            null, null);
+            Table.States (89).Kernel := To_Vector ((0 => (135, 264, 0, 
False)));
+            Table.States (89).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 135, 1)));
+            Table.States (90).Action_List.Set_Capacity (41);
             Add_Action (Table.States (90), (4, 5, 13, 15, 17, 18, 24, 25, 27, 
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
-            47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 
93, 104, 105, 106, 107), (135, 3), 1, null,
-            null);
-            Table.States (90).Kernel := To_Vector ((0 => (135, 265, 0, 
False)));
-            Table.States (90).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 135, 1)));
-            Table.States (91).Action_List.Set_Capacity (40);
+            47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 
79, 94, 105, 106, 107, 108), (264, 3), 1,
+            null, null);
+            Table.States (90).Kernel := To_Vector ((0 => (264, 265, 0, 
False)));
+            Table.States (90).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 264, 1)));
+            Table.States (91).Action_List.Set_Capacity (41);
             Add_Action (Table.States (91), (4, 5, 13, 15, 17, 18, 24, 25, 27, 
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
-            47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 
93, 104, 105, 106, 107), (206, 2), 1, null,
-            null);
-            Table.States (91).Kernel := To_Vector ((0 => (206, 271, 0, 
False)));
-            Table.States (91).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 206, 1)));
-            Table.States (92).Action_List.Set_Capacity (63);
-            Add_Action (Table.States (92), (4, 5, 10, 13, 15, 17, 18, 20, 21, 
22, 23, 27, 28, 31, 32, 33, 35, 37, 38,
-            40, 41, 42, 43, 48, 52, 53, 55, 56, 57, 58, 61, 68, 71, 73, 74, 
75, 76, 77, 78, 79, 82, 83, 84, 85, 86, 87,
-            88, 89, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 104, 
105, 106), (239, 4), 1, null, null);
-            Table.States (92).Kernel := To_Vector ((0 => (239, 272, 0, True)));
-            Table.States (92).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 239, 1)));
-            Table.States (92).Minimal_Complete_Actions_Recursive := True;
-            Table.States (93).Action_List.Set_Capacity (46);
-            Add_Action (Table.States (93), (4, 5, 13, 15, 17, 18, 22, 23, 24, 
25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
-            40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 
68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
-            107), (303, 9), 1, null, null);
-            Table.States (93).Kernel := To_Vector ((0 => (303, 276, 0, 
False)));
-            Table.States (93).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 303, 1)));
-            Table.States (94).Action_List.Set_Capacity (41);
-            Add_Action (Table.States (94), (4, 5, 13, 15, 17, 18, 24, 25, 27, 
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
-            47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 72, 73, 
74, 93, 104, 105, 106, 107), (121, 2), 1,
+            47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 
79, 94, 105, 106, 107, 108), (136, 3), 1,
             null, null);
-            Table.States (94).Kernel := To_Vector ((0 => (121, 281, 0, 
False)));
-            Table.States (94).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 121, 1)));
-            Table.States (95).Action_List.Set_Capacity (40);
+            Table.States (91).Kernel := To_Vector ((0 => (136, 266, 0, 
False)));
+            Table.States (91).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 136, 1)));
+            Table.States (92).Action_List.Set_Capacity (41);
+            Add_Action (Table.States (92), (4, 5, 13, 15, 17, 18, 24, 25, 27, 
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
+            47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 
79, 94, 105, 106, 107, 108), (207, 2), 1,
+            null, null);
+            Table.States (92).Kernel := To_Vector ((0 => (207, 272, 0, 
False)));
+            Table.States (92).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 207, 1)));
+            Table.States (93).Action_List.Set_Capacity (64);
+            Add_Action (Table.States (93), (4, 5, 10, 13, 15, 17, 18, 20, 21, 
22, 23, 27, 28, 31, 32, 33, 35, 37, 38,
+            40, 41, 42, 43, 48, 52, 53, 55, 56, 57, 58, 61, 68, 71, 73, 74, 
75, 76, 77, 78, 79, 80, 83, 84, 85, 86, 87,
+            88, 89, 90, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 
105, 106, 107), (240, 4), 1, null, null);
+            Table.States (93).Kernel := To_Vector ((0 => (240, 273, 0, True)));
+            Table.States (93).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 240, 1)));
+            Table.States (93).Minimal_Complete_Actions_Recursive := True;
+            Table.States (94).Action_List.Set_Capacity (47);
+            Add_Action (Table.States (94), (4, 5, 13, 15, 17, 18, 22, 23, 24, 
25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
+            40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 
68, 69, 71, 72, 73, 74, 79, 94, 105, 106,
+            107, 108), (304, 9), 1, null, null);
+            Table.States (94).Kernel := To_Vector ((0 => (304, 277, 0, 
False)));
+            Table.States (94).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 304, 1)));
+            Table.States (95).Action_List.Set_Capacity (42);
             Add_Action (Table.States (95), (4, 5, 13, 15, 17, 18, 24, 25, 27, 
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
-            47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 
93, 104, 105, 106, 107), (157, 12), 1,
+            47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 72, 73, 
74, 79, 94, 105, 106, 107, 108), (122, 2),
+            1, null, null);
+            Table.States (95).Kernel := To_Vector ((0 => (122, 282, 0, 
False)));
+            Table.States (95).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 122, 1)));
+            Table.States (96).Action_List.Set_Capacity (41);
+            Add_Action (Table.States (96), (4, 5, 13, 15, 17, 18, 24, 25, 27, 
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
+            47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 
79, 94, 105, 106, 107, 108), (158, 12), 1,
             null, null);
-            Table.States (95).Kernel := To_Vector ((0 => (157, 289, 0, 
False)));
-            Table.States (95).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 157, 1)));
-            Table.States (96).Action_List.Set_Capacity (46);
-            Add_Action (Table.States (96), (4, 5, 13, 15, 17, 18, 22, 23, 24, 
25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
-            40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 
68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
-            107), (303, 6), 1, null, null);
-            Table.States (96).Kernel := To_Vector ((0 => (303, 290, 0, 
False)));
-            Table.States (96).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 303, 1)));
-            Table.States (97).Action_List.Set_Capacity (63);
-            Add_Action (Table.States (97), (4, 5, 10, 13, 15, 17, 18, 20, 21, 
22, 23, 27, 28, 31, 32, 33, 35, 37, 38,
-            40, 41, 42, 43, 48, 52, 53, 55, 56, 57, 58, 61, 68, 71, 73, 74, 
75, 76, 77, 78, 79, 82, 83, 84, 85, 86, 87,
-            88, 89, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 104, 
105, 106), (239, 2), 1, null,
+            Table.States (96).Kernel := To_Vector ((0 => (158, 290, 0, 
False)));
+            Table.States (96).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 158, 1)));
+            Table.States (97).Action_List.Set_Capacity (47);
+            Add_Action (Table.States (97), (4, 5, 13, 15, 17, 18, 22, 23, 24, 
25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
+            40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 
68, 69, 71, 72, 73, 74, 79, 94, 105, 106,
+            107, 108), (304, 6), 1, null, null);
+            Table.States (97).Kernel := To_Vector ((0 => (304, 291, 0, 
False)));
+            Table.States (97).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 304, 1)));
+            Table.States (98).Action_List.Set_Capacity (64);
+            Add_Action (Table.States (98), (4, 5, 10, 13, 15, 17, 18, 20, 21, 
22, 23, 27, 28, 31, 32, 33, 35, 37, 38,
+            40, 41, 42, 43, 48, 52, 53, 55, 56, 57, 58, 61, 68, 71, 73, 74, 
75, 76, 77, 78, 79, 80, 83, 84, 85, 86, 87,
+            88, 89, 90, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 
105, 106, 107), (240, 2), 1, null,
             name_2_check'Access);
-            Table.States (97).Kernel := To_Vector ((0 => (239, 293, 0, True)));
-            Table.States (97).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 239, 1)));
-            Table.States (97).Minimal_Complete_Actions_Recursive := True;
-            Table.States (98).Action_List.Set_Capacity (46);
-            Add_Action (Table.States (98), (4, 5, 13, 15, 17, 18, 22, 23, 24, 
25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
-            40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 
68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
-            107), (298, 0), 1, null, null);
-            Table.States (98).Kernel := To_Vector ((0 => (298, 294, 0, 
False)));
-            Table.States (98).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 298, 1)));
-            Table.States (99).Action_List.Set_Capacity (46);
+            Table.States (98).Kernel := To_Vector ((0 => (240, 294, 0, True)));
+            Table.States (98).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 240, 1)));
+            Table.States (98).Minimal_Complete_Actions_Recursive := True;
+            Table.States (99).Action_List.Set_Capacity (47);
             Add_Action (Table.States (99), (4, 5, 13, 15, 17, 18, 22, 23, 24, 
25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
-            40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 
68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
-            107), (151, 6), 1, null, null);
-            Table.States (99).Kernel := To_Vector ((0 => (151, 298, 0, 
False)));
-            Table.States (99).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 151, 1)));
-            Table.States (100).Action_List.Set_Capacity (46);
+            40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 
68, 69, 71, 72, 73, 74, 79, 94, 105, 106,
+            107, 108), (299, 0), 1, null, null);
+            Table.States (99).Kernel := To_Vector ((0 => (299, 295, 0, 
False)));
+            Table.States (99).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 299, 1)));
+            Table.States (100).Action_List.Set_Capacity (47);
             Add_Action (Table.States (100), (4, 5, 13, 15, 17, 18, 22, 23, 24, 
25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
-            40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 
68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
-            107), (303, 5), 1, null, null);
-            Table.States (100).Kernel := To_Vector ((0 => (303, 302, 0, 
False)));
-            Table.States (100).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 303, 1)));
-            Table.States (101).Action_List.Set_Capacity (46);
+            40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 
68, 69, 71, 72, 73, 74, 79, 94, 105, 106,
+            107, 108), (152, 6), 1, null, null);
+            Table.States (100).Kernel := To_Vector ((0 => (152, 299, 0, 
False)));
+            Table.States (100).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 152, 1)));
+            Table.States (101).Action_List.Set_Capacity (47);
             Add_Action (Table.States (101), (4, 5, 13, 15, 17, 18, 22, 23, 24, 
25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
-            40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 
68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
-            107), (306, 1), 1, null, null);
-            Table.States (101).Kernel := To_Vector ((0 => (306, 303, 0, 
False)));
-            Table.States (101).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 306, 1)));
-            Table.States (102).Action_List.Set_Capacity (40);
-            Add_Action (Table.States (102), (4, 5, 13, 15, 17, 18, 24, 25, 27, 
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
-            47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 
93, 104, 105, 106, 107), (244, 7), 1, null,
-            null);
-            Table.States (102).Kernel := To_Vector ((0 => (244, 304, 0, 
False)));
-            Table.States (102).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 244, 1)));
-            Table.States (103).Action_List.Set_Capacity (40);
+            40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 
68, 69, 71, 72, 73, 74, 79, 94, 105, 106,
+            107, 108), (304, 5), 1, null, null);
+            Table.States (101).Kernel := To_Vector ((0 => (304, 303, 0, 
False)));
+            Table.States (101).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 304, 1)));
+            Table.States (102).Action_List.Set_Capacity (47);
+            Add_Action (Table.States (102), (4, 5, 13, 15, 17, 18, 22, 23, 24, 
25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
+            40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 
68, 69, 71, 72, 73, 74, 79, 94, 105, 106,
+            107, 108), (307, 1), 1, null, null);
+            Table.States (102).Kernel := To_Vector ((0 => (307, 304, 0, 
False)));
+            Table.States (102).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 307, 1)));
+            Table.States (103).Action_List.Set_Capacity (41);
             Add_Action (Table.States (103), (4, 5, 13, 15, 17, 18, 24, 25, 27, 
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
-            47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 
93, 104, 105, 106, 107), (244, 6), 1, null,
-            null);
-            Table.States (103).Kernel := To_Vector ((0 => (244, 305, 0, 
False)));
-            Table.States (103).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 244, 1)));
-            Table.States (104).Action_List.Set_Capacity (39);
-            Add_Action (Table.States (104), (4, 5, 13, 15, 17, 18, 25, 27, 28, 
29, 30, 31, 32, 36, 37, 40, 41, 46, 47,
-            48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 93, 
104, 105, 106, 107), (142, 4), 1, null,
-            null);
-            Table.States (104).Kernel := To_Vector ((0 => (142, 306, 0, 
False)));
-            Table.States (104).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 142, 1)));
+            47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 
79, 94, 105, 106, 107, 108), (245, 7), 1,
+            null, null);
+            Table.States (103).Kernel := To_Vector ((0 => (245, 305, 0, 
False)));
+            Table.States (103).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 245, 1)));
+            Table.States (104).Action_List.Set_Capacity (41);
+            Add_Action (Table.States (104), (4, 5, 13, 15, 17, 18, 24, 25, 27, 
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
+            47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 
79, 94, 105, 106, 107, 108), (245, 6), 1,
+            null, null);
+            Table.States (104).Kernel := To_Vector ((0 => (245, 306, 0, 
False)));
+            Table.States (104).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 245, 1)));
             Table.States (105).Action_List.Set_Capacity (40);
-            Add_Action (Table.States (105), (4, 5, 13, 15, 17, 18, 24, 25, 27, 
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
-            47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 
93, 104, 105, 106, 107), (263, 0), 1, null,
+            Add_Action (Table.States (105), (4, 5, 13, 15, 17, 18, 25, 27, 28, 
29, 30, 31, 32, 36, 37, 40, 41, 46, 47,
+            48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 79, 
94, 105, 106, 107, 108), (143, 4), 1, null,
             null);
-            Table.States (105).Kernel := To_Vector ((0 => (263, 307, 0, 
False)));
-            Table.States (105).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 263, 1)));
-            Table.States (106).Action_List.Set_Capacity (40);
+            Table.States (105).Kernel := To_Vector ((0 => (143, 307, 0, 
False)));
+            Table.States (105).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 143, 1)));
+            Table.States (106).Action_List.Set_Capacity (41);
             Add_Action (Table.States (106), (4, 5, 13, 15, 17, 18, 24, 25, 27, 
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
-            47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 
93, 104, 105, 106, 107), (135, 0), 1, null,
-            null);
-            Table.States (106).Kernel := To_Vector ((0 => (135, 308, 0, 
False)));
-            Table.States (106).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 135, 1)));
-            Table.States (107).Action_List.Set_Capacity (40);
+            47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 
79, 94, 105, 106, 107, 108), (264, 0), 1,
+            null, null);
+            Table.States (106).Kernel := To_Vector ((0 => (264, 308, 0, 
False)));
+            Table.States (106).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 264, 1)));
+            Table.States (107).Action_List.Set_Capacity (41);
             Add_Action (Table.States (107), (4, 5, 13, 15, 17, 18, 24, 25, 27, 
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
-            47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 
93, 104, 105, 106, 107), (157, 13), 1,
+            47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 
79, 94, 105, 106, 107, 108), (136, 0), 1,
             null, null);
-            Table.States (107).Kernel := To_Vector ((0 => (157, 309, 0, 
False)));
-            Table.States (107).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 157, 1)));
-            Table.States (108).Action_List.Set_Capacity (40);
+            Table.States (107).Kernel := To_Vector ((0 => (136, 309, 0, 
False)));
+            Table.States (107).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 136, 1)));
+            Table.States (108).Action_List.Set_Capacity (41);
             Add_Action (Table.States (108), (4, 5, 13, 15, 17, 18, 24, 25, 27, 
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
-            47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 
93, 104, 105, 106, 107), (289, 2), 1, null,
-            null);
-            Table.States (108).Kernel := To_Vector ((0 => (289, 311, 0, 
False)));
-            Table.States (108).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 289, 1)));
-            Table.States (109).Action_List.Set_Capacity (40);
+            47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 
79, 94, 105, 106, 107, 108), (158, 13), 1,
+            null, null);
+            Table.States (108).Kernel := To_Vector ((0 => (158, 310, 0, 
False)));
+            Table.States (108).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 158, 1)));
+            Table.States (109).Action_List.Set_Capacity (41);
             Add_Action (Table.States (109), (4, 5, 13, 15, 17, 18, 24, 25, 27, 
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
-            47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 
93, 104, 105, 106, 107), (157, 14), 1,
+            47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 
79, 94, 105, 106, 107, 108), (290, 2), 1,
             null, null);
-            Table.States (109).Kernel := To_Vector ((0 => (157, 313, 0, 
False)));
-            Table.States (109).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 157, 1)));
-            Table.States (110).Action_List.Set_Capacity (39);
-            Add_Action (Table.States (110), (4, 5, 13, 15, 17, 18, 25, 27, 28, 
29, 30, 31, 32, 36, 37, 40, 41, 46, 47,
-            48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 93, 
104, 105, 106, 107), (142, 1), 1, null,
-            null);
-            Table.States (110).Kernel := To_Vector ((0 => (142, 315, 0, 
False)));
-            Table.States (110).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 142, 1)));
+            Table.States (109).Kernel := To_Vector ((0 => (290, 312, 0, 
False)));
+            Table.States (109).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 290, 1)));
+            Table.States (110).Action_List.Set_Capacity (41);
+            Add_Action (Table.States (110), (4, 5, 13, 15, 17, 18, 24, 25, 27, 
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
+            47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 
79, 94, 105, 106, 107, 108), (158, 14), 1,
+            null, null);
+            Table.States (110).Kernel := To_Vector ((0 => (158, 314, 0, 
False)));
+            Table.States (110).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 158, 1)));
             Table.States (111).Action_List.Set_Capacity (40);
-            Add_Action (Table.States (111), (4, 5, 13, 15, 17, 18, 24, 25, 27, 
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
-            47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 
93, 104, 105, 106, 107), (263, 2), 1, null,
+            Add_Action (Table.States (111), (4, 5, 13, 15, 17, 18, 25, 27, 28, 
29, 30, 31, 32, 36, 37, 40, 41, 46, 47,
+            48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 79, 
94, 105, 106, 107, 108), (143, 1), 1, null,
             null);
-            Table.States (111).Kernel := To_Vector ((0 => (263, 316, 0, 
False)));
-            Table.States (111).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 263, 1)));
-            Table.States (112).Action_List.Set_Capacity (40);
+            Table.States (111).Kernel := To_Vector ((0 => (143, 316, 0, 
False)));
+            Table.States (111).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 143, 1)));
+            Table.States (112).Action_List.Set_Capacity (41);
             Add_Action (Table.States (112), (4, 5, 13, 15, 17, 18, 24, 25, 27, 
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
-            47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 
93, 104, 105, 106, 107), (135, 2), 1, null,
-            null);
-            Table.States (112).Kernel := To_Vector ((0 => (135, 317, 0, 
False)));
-            Table.States (112).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 135, 1)));
-            Table.States (113).Action_List.Set_Capacity (40);
+            47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 
79, 94, 105, 106, 107, 108), (264, 2), 1,
+            null, null);
+            Table.States (112).Kernel := To_Vector ((0 => (264, 317, 0, 
False)));
+            Table.States (112).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 264, 1)));
+            Table.States (113).Action_List.Set_Capacity (41);
             Add_Action (Table.States (113), (4, 5, 13, 15, 17, 18, 24, 25, 27, 
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
-            47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 
93, 104, 105, 106, 107), (206, 1), 1, null,
-            null);
-            Table.States (113).Kernel := To_Vector ((0 => (206, 319, 0, 
False)));
-            Table.States (113).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 206, 1)));
-            Table.States (114).Action_List.Set_Capacity (46);
-            Add_Action (Table.States (114), (4, 5, 13, 15, 17, 18, 22, 23, 24, 
25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
-            40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 
68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
-            107), (298, 1), 1, null, null);
-            Table.States (114).Kernel := To_Vector ((0 => (298, 323, 0, 
False)));
-            Table.States (114).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 298, 1)));
-            Table.States (115).Action_List.Set_Capacity (40);
-            Add_Action (Table.States (115), (4, 5, 13, 15, 17, 18, 24, 25, 27, 
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
-            47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 
93, 104, 105, 106, 107), (157, 15), 1,
+            47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 
79, 94, 105, 106, 107, 108), (136, 2), 1,
             null, null);
-            Table.States (115).Kernel := To_Vector ((0 => (157, 325, 0, 
False)));
-            Table.States (115).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 157, 1)));
-            Table.States (116).Action_List.Set_Capacity (40);
+            Table.States (113).Kernel := To_Vector ((0 => (136, 318, 0, 
False)));
+            Table.States (113).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 136, 1)));
+            Table.States (114).Action_List.Set_Capacity (41);
+            Add_Action (Table.States (114), (4, 5, 13, 15, 17, 18, 24, 25, 27, 
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
+            47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 
79, 94, 105, 106, 107, 108), (207, 1), 1,
+            null, null);
+            Table.States (114).Kernel := To_Vector ((0 => (207, 320, 0, 
False)));
+            Table.States (114).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 207, 1)));
+            Table.States (115).Action_List.Set_Capacity (47);
+            Add_Action (Table.States (115), (4, 5, 13, 15, 17, 18, 22, 23, 24, 
25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
+            40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 
68, 69, 71, 72, 73, 74, 79, 94, 105, 106,
+            107, 108), (299, 1), 1, null, null);
+            Table.States (115).Kernel := To_Vector ((0 => (299, 324, 0, 
False)));
+            Table.States (115).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 299, 1)));
+            Table.States (116).Action_List.Set_Capacity (41);
             Add_Action (Table.States (116), (4, 5, 13, 15, 17, 18, 24, 25, 27, 
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
-            47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 
93, 104, 105, 106, 107), (157, 16), 1,
+            47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 
79, 94, 105, 106, 107, 108), (158, 15), 1,
+            null, null);
+            Table.States (116).Kernel := To_Vector ((0 => (158, 326, 0, 
False)));
+            Table.States (116).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 158, 1)));
+            Table.States (117).Action_List.Set_Capacity (41);
+            Add_Action (Table.States (117), (4, 5, 13, 15, 17, 18, 24, 25, 27, 
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
+            47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 
79, 94, 105, 106, 107, 108), (158, 16), 1,
             null, null);
-            Table.States (116).Kernel := To_Vector ((0 => (157, 331, 0, 
False)));
-            Table.States (116).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 157, 1)));
-            Table.States (117).Action_List.Set_Capacity (39);
-            Add_Action (Table.States (117), (4, 5, 13, 15, 17, 18, 25, 27, 28, 
29, 30, 31, 32, 36, 37, 40, 41, 46, 47,
-            48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 93, 
104, 105, 106, 107), (142, 0), 1, null,
+            Table.States (117).Kernel := To_Vector ((0 => (158, 332, 0, 
False)));
+            Table.States (117).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 158, 1)));
+            Table.States (118).Action_List.Set_Capacity (40);
+            Add_Action (Table.States (118), (4, 5, 13, 15, 17, 18, 25, 27, 28, 
29, 30, 31, 32, 36, 37, 40, 41, 46, 47,
+            48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 79, 
94, 105, 106, 107, 108), (143, 0), 1, null,
             null);
-            Table.States (117).Kernel := To_Vector ((0 => (142, 332, 0, 
False)));
-            Table.States (117).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 142, 1)));
-            Table.States (118).Action_List.Set_Capacity (3);
-            Add_Action (Table.States (118), 21, Reduce, (116, 1), 0, null, 
null);
-            Add_Action (Table.States (118), 76, 250);
-            Add_Conflict (Table.States (118), 76, (116, 1), 0, null, null);
-            Add_Action (Table.States (118), 96, Reduce, (116, 1), 0, null, 
null);
-            Table.States (118).Goto_List.Set_Capacity (2);
-            Add_Goto (Table.States (118), 115, 251);
-            Add_Goto (Table.States (118), 116, 252);
-            Table.States (118).Kernel := To_Vector (((113, 104, 3, False), 
(113, 104, 1, False)));
-            Table.States (118).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 116, 0)));
-            Table.States (119).Action_List.Set_Capacity (62);
-            Add_Action (Table.States (119), (4, 5, 10, 13, 15, 17, 18, 20, 21, 
22, 23, 27, 28, 31, 32, 33, 35, 37, 38,
-            40, 41, 42, 43, 48, 52, 53, 55, 56, 57, 58, 61, 68, 73, 74, 75, 
76, 77, 78, 79, 82, 83, 84, 85, 86, 87, 88,
-            89, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 104, 105, 
106), (239, 5), 1, name_5'Access,
+            Table.States (118).Kernel := To_Vector ((0 => (143, 333, 0, 
False)));
+            Table.States (118).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 143, 1)));
+            Table.States (119).Action_List.Set_Capacity (3);
+            Add_Action (Table.States (119), 21, Reduce, (117, 1), 0, null, 
null);
+            Add_Action (Table.States (119), 76, 251);
+            Add_Conflict (Table.States (119), 76, (117, 1), 0, null, null);
+            Add_Action (Table.States (119), 97, Reduce, (117, 1), 0, null, 
null);
+            Table.States (119).Goto_List.Set_Capacity (2);
+            Add_Goto (Table.States (119), 116, 252);
+            Add_Goto (Table.States (119), 117, 253);
+            Table.States (119).Kernel := To_Vector (((114, 105, 3, False), 
(114, 105, 1, False)));
+            Table.States (119).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 117, 0)));
+            Table.States (120).Action_List.Set_Capacity (63);
+            Add_Action (Table.States (120), (4, 5, 10, 13, 15, 17, 18, 20, 21, 
22, 23, 27, 28, 31, 32, 33, 35, 37, 38,
+            40, 41, 42, 43, 48, 52, 53, 55, 56, 57, 58, 61, 68, 73, 74, 75, 
76, 77, 78, 79, 80, 83, 84, 85, 86, 87, 88,
+            89, 90, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 105, 
106, 107), (240, 5), 1, name_5'Access,
             name_5_check'Access);
-            Table.States (119).Kernel := To_Vector ((0 => (239, 104, 0, 
False)));
-            Table.States (119).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 239, 1)));
-            Table.States (120).Action_List.Set_Capacity (5);
-            Add_Action (Table.States (120), 76, 235);
-            Add_Action (Table.States (120), 84, 237);
-            Add_Action (Table.States (120), 96, 253);
-            Add_Action (Table.States (120), 101, 239);
-            Add_Action (Table.States (120), 102, 240);
-            Table.States (120).Goto_List.Set_Capacity (2);
-            Add_Goto (Table.States (120), 115, 241);
-            Add_Goto (Table.States (120), 322, 242);
-            Table.States (120).Kernel := To_Vector (((128, 239, 2, True), 
(239, 239, 5, True), (239, 239, 2, True),
-            (272, 239, 3, True), (293, 239, 2, True), (293, 239, 2, True), 
(293, 239, 2, True), (293, 239, 2, True),
-            (303, 239, 1, False)));
-            Table.States (120).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 96, 253)));
-            Table.States (121).Action_List.Set_Capacity (7);
-            Add_Action (Table.States (121), 39, 122);
-            Add_Action (Table.States (121), 41, 124);
-            Add_Action (Table.States (121), 76, 126);
-            Add_Action (Table.States (121), 103, 129);
-            Add_Action (Table.States (121), 104, 119);
-            Add_Action (Table.States (121), 105, 33);
-            Add_Action (Table.States (121), 106, 34);
-            Table.States (121).Goto_List.Set_Capacity (6);
-            Add_Goto (Table.States (121), 117, 130);
-            Add_Goto (Table.States (121), 128, 41);
-            Add_Goto (Table.States (121), 239, 134);
-            Add_Goto (Table.States (121), 258, 254);
-            Add_Goto (Table.States (121), 272, 92);
-            Add_Goto (Table.States (121), 293, 97);
-            Table.States (121).Kernel := To_Vector ((0 => (197, 3, 1, False)));
-            Table.States (121).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 103, 129)));
-            Table.States (122).Action_List.Set_Capacity (3);
-            Add_Action (Table.States (122), 104, 119);
-            Add_Action (Table.States (122), 105, 33);
+            Table.States (120).Kernel := To_Vector ((0 => (240, 105, 0, 
False)));
+            Table.States (120).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 240, 1)));
+            Table.States (121).Action_List.Set_Capacity (5);
+            Add_Action (Table.States (121), 76, 236);
+            Add_Action (Table.States (121), 85, 238);
+            Add_Action (Table.States (121), 97, 254);
+            Add_Action (Table.States (121), 102, 240);
+            Add_Action (Table.States (121), 103, 241);
+            Table.States (121).Goto_List.Set_Capacity (2);
+            Add_Goto (Table.States (121), 116, 242);
+            Add_Goto (Table.States (121), 323, 243);
+            Table.States (121).Kernel := To_Vector (((129, 240, 2, True), 
(240, 240, 5, True), (240, 240, 2, True),
+            (273, 240, 3, True), (294, 240, 2, True), (294, 240, 2, True), 
(294, 240, 2, True), (294, 240, 2, True),
+            (304, 240, 1, False)));
+            Table.States (121).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 97, 254)));
+            Table.States (122).Action_List.Set_Capacity (8);
+            Add_Action (Table.States (122), 39, 123);
+            Add_Action (Table.States (122), 41, 125);
+            Add_Action (Table.States (122), 76, 127);
+            Add_Action (Table.States (122), 79, 31);
+            Add_Action (Table.States (122), 104, 130);
+            Add_Action (Table.States (122), 105, 120);
             Add_Action (Table.States (122), 106, 34);
-            Table.States (122).Goto_List.Set_Capacity (4);
-            Add_Goto (Table.States (122), 128, 41);
-            Add_Goto (Table.States (122), 239, 255);
-            Add_Goto (Table.States (122), 272, 92);
-            Add_Goto (Table.States (122), 293, 97);
-            Table.States (122).Kernel := To_Vector ((0 => (258, 39, 1, 
False)));
-            Table.States (122).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 104, 119)));
-            Table.States (123).Action_List.Set_Capacity (7);
-            Add_Action (Table.States (123), 39, 122);
-            Add_Action (Table.States (123), 41, 124);
-            Add_Action (Table.States (123), 76, 126);
-            Add_Action (Table.States (123), 103, 129);
-            Add_Action (Table.States (123), 104, 119);
-            Add_Action (Table.States (123), 105, 33);
+            Add_Action (Table.States (122), 107, 35);
+            Table.States (122).Goto_List.Set_Capacity (6);
+            Add_Goto (Table.States (122), 118, 131);
+            Add_Goto (Table.States (122), 129, 42);
+            Add_Goto (Table.States (122), 240, 135);
+            Add_Goto (Table.States (122), 259, 255);
+            Add_Goto (Table.States (122), 273, 93);
+            Add_Goto (Table.States (122), 294, 98);
+            Table.States (122).Kernel := To_Vector ((0 => (198, 3, 1, False)));
+            Table.States (122).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 104, 130)));
+            Table.States (123).Action_List.Set_Capacity (4);
+            Add_Action (Table.States (123), 79, 31);
+            Add_Action (Table.States (123), 105, 120);
             Add_Action (Table.States (123), 106, 34);
-            Table.States (123).Goto_List.Set_Capacity (6);
-            Add_Goto (Table.States (123), 117, 130);
-            Add_Goto (Table.States (123), 128, 41);
-            Add_Goto (Table.States (123), 239, 134);
-            Add_Goto (Table.States (123), 258, 256);
-            Add_Goto (Table.States (123), 272, 92);
-            Add_Goto (Table.States (123), 293, 97);
-            Table.States (123).Kernel := To_Vector ((0 => (197, 40, 1, 
False)));
-            Table.States (123).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 103, 129)));
-            Table.States (124).Action_List.Set_Capacity (36);
-            Add_Action (Table.States (124), (10, 20, 21, 22, 23, 33, 35, 37, 
38, 40, 42, 43, 53, 55, 68, 74, 75, 77,
-            78, 79, 82, 83, 85, 86, 87, 88, 89, 91, 92, 94, 95, 96, 97, 98, 
99, 100), (258, 1), 1, null, null);
-            Table.States (124).Kernel := To_Vector ((0 => (258, 41, 0, 
False)));
-            Table.States (124).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 258, 1)));
-            Table.States (125).Action_List.Set_Capacity (3);
-            Add_Action (Table.States (125), 104, 119);
-            Add_Action (Table.States (125), 105, 33);
-            Add_Action (Table.States (125), 106, 34);
-            Table.States (125).Goto_List.Set_Capacity (4);
-            Add_Goto (Table.States (125), 128, 41);
-            Add_Goto (Table.States (125), 239, 257);
-            Add_Goto (Table.States (125), 272, 92);
-            Add_Goto (Table.States (125), 293, 97);
-            Table.States (125).Kernel := To_Vector (((275, 52, 2, True), (275, 
52, 1, False)));
-            Table.States (125).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 104, 119)));
-            Table.States (126).Action_List.Set_Capacity (21);
-            Add_Action (Table.States (126), 3, 121);
-            Add_Action (Table.States (126), 15, 258);
-            Add_Action (Table.States (126), 28, 259);
-            Add_Action (Table.States (126), 32, 260);
-            Add_Action (Table.States (126), 39, 122);
-            Add_Action (Table.States (126), 40, 261);
-            Add_Action (Table.States (126), 41, 262);
-            Add_Action (Table.States (126), 44, 263);
-            Add_Action (Table.States (126), 52, 125);
-            Add_Action (Table.States (126), 74, Reduce, (192, 1), 0, null, 
null);
-            Add_Action (Table.States (126), 76, 126);
-            Add_Action (Table.States (126), 77, Reduce, (124, 5), 0, null, 
null);
-            Add_Action (Table.States (126), 79, Reduce, (166, 2), 0, null, 
null);
-            Add_Action (Table.States (126), 83, Reduce, (124, 5), 0, null, 
null);
-            Add_Action (Table.States (126), 87, Reduce, (166, 2), 0, null, 
null);
-            Add_Action (Table.States (126), 94, 127);
-            Add_Action (Table.States (126), 95, 128);
-            Add_Action (Table.States (126), 103, 129);
-            Add_Action (Table.States (126), 104, 119);
-            Add_Action (Table.States (126), 105, 33);
-            Add_Action (Table.States (126), 106, 264);
-            Table.States (126).Goto_List.Set_Capacity (29);
-            Add_Goto (Table.States (126), 117, 130);
-            Add_Goto (Table.States (126), 124, 265);
-            Add_Goto (Table.States (126), 125, 266);
-            Add_Goto (Table.States (126), 128, 41);
-            Add_Goto (Table.States (126), 136, 267);
-            Add_Goto (Table.States (126), 153, 268);
-            Add_Goto (Table.States (126), 165, 269);
-            Add_Goto (Table.States (126), 166, 270);
-            Add_Goto (Table.States (126), 191, 271);
-            Add_Goto (Table.States (126), 192, 272);
-            Add_Goto (Table.States (126), 197, 133);
-            Add_Goto (Table.States (126), 221, 273);
-            Add_Goto (Table.States (126), 239, 274);
-            Add_Goto (Table.States (126), 258, 135);
-            Add_Goto (Table.States (126), 272, 92);
-            Add_Goto (Table.States (126), 273, 275);
-            Add_Goto (Table.States (126), 275, 136);
-            Add_Goto (Table.States (126), 277, 276);
-            Add_Goto (Table.States (126), 282, 137);
-            Add_Goto (Table.States (126), 283, 138);
-            Add_Goto (Table.States (126), 284, 139);
-            Add_Goto (Table.States (126), 285, 140);
-            Add_Goto (Table.States (126), 286, 141);
-            Add_Goto (Table.States (126), 287, 142);
-            Add_Goto (Table.States (126), 293, 97);
-            Add_Goto (Table.States (126), 301, 277);
-            Add_Goto (Table.States (126), 320, 144);
-            Add_Goto (Table.States (126), 321, 145);
-            Add_Goto (Table.States (126), 330, 146);
-            Table.States (126).Kernel := To_Vector (((117, 76, 4, False), 
(117, 76, 2, False), (117, 76, 3, False),
-            (117, 76, 3, False), (117, 76, 1, False)));
-            Table.States (126).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 125, 0)));
-            Table.States (127).Action_List.Set_Capacity (9);
-            Add_Action (Table.States (127), (3, 39, 40, 41, 76, 103, 104, 105, 
106), (330, 1), 1, null, null);
-            Table.States (127).Kernel := To_Vector ((0 => (330, 94, 0, 
False)));
-            Table.States (127).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 330, 1)));
-            Table.States (128).Action_List.Set_Capacity (9);
-            Add_Action (Table.States (128), (3, 39, 40, 41, 76, 103, 104, 105, 
106), (330, 0), 1, null, null);
-            Table.States (128).Kernel := To_Vector ((0 => (330, 95, 0, 
False)));
-            Table.States (128).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 330, 1)));
-            Table.States (129).Action_List.Set_Capacity (36);
-            Add_Action (Table.States (129), (10, 20, 21, 22, 23, 33, 35, 37, 
38, 40, 42, 43, 53, 55, 68, 74, 75, 77,
-            78, 79, 82, 83, 85, 86, 87, 88, 89, 91, 92, 94, 95, 96, 97, 98, 
99, 100), (258, 0), 1, primary_0'Access,
-            null);
-            Table.States (129).Kernel := To_Vector ((0 => (258, 103, 0, 
False)));
-            Table.States (129).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 258, 1)));
+            Add_Action (Table.States (123), 107, 35);
+            Table.States (123).Goto_List.Set_Capacity (4);
+            Add_Goto (Table.States (123), 129, 42);
+            Add_Goto (Table.States (123), 240, 256);
+            Add_Goto (Table.States (123), 273, 93);
+            Add_Goto (Table.States (123), 294, 98);
+            Table.States (123).Kernel := To_Vector ((0 => (259, 39, 1, 
False)));
+            Table.States (123).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 105, 120)));
+            Table.States (124).Action_List.Set_Capacity (8);
+            Add_Action (Table.States (124), 39, 123);
+            Add_Action (Table.States (124), 41, 125);
+            Add_Action (Table.States (124), 76, 127);
+            Add_Action (Table.States (124), 79, 31);
+            Add_Action (Table.States (124), 104, 130);
+            Add_Action (Table.States (124), 105, 120);
+            Add_Action (Table.States (124), 106, 34);
+            Add_Action (Table.States (124), 107, 35);
+            Table.States (124).Goto_List.Set_Capacity (6);
+            Add_Goto (Table.States (124), 118, 131);
+            Add_Goto (Table.States (124), 129, 42);
+            Add_Goto (Table.States (124), 240, 135);
+            Add_Goto (Table.States (124), 259, 257);
+            Add_Goto (Table.States (124), 273, 93);
+            Add_Goto (Table.States (124), 294, 98);
+            Table.States (124).Kernel := To_Vector ((0 => (198, 40, 1, 
False)));
+            Table.States (124).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 104, 130)));
+            Table.States (125).Action_List.Set_Capacity (36);
+            Add_Action (Table.States (125), (10, 20, 21, 22, 23, 33, 35, 37, 
38, 40, 42, 43, 53, 55, 68, 74, 75, 77,
+            78, 80, 83, 84, 86, 87, 88, 89, 90, 92, 93, 95, 96, 97, 98, 99, 
100, 101), (259, 1), 1, null, null);
+            Table.States (125).Kernel := To_Vector ((0 => (259, 41, 0, 
False)));
+            Table.States (125).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 259, 1)));
+            Table.States (126).Action_List.Set_Capacity (4);
+            Add_Action (Table.States (126), 79, 31);
+            Add_Action (Table.States (126), 105, 120);
+            Add_Action (Table.States (126), 106, 34);
+            Add_Action (Table.States (126), 107, 35);
+            Table.States (126).Goto_List.Set_Capacity (4);
+            Add_Goto (Table.States (126), 129, 42);
+            Add_Goto (Table.States (126), 240, 258);
+            Add_Goto (Table.States (126), 273, 93);
+            Add_Goto (Table.States (126), 294, 98);
+            Table.States (126).Kernel := To_Vector (((276, 52, 2, True), (276, 
52, 1, False)));
+            Table.States (126).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 105, 120)));
+            Table.States (127).Action_List.Set_Capacity (22);
+            Add_Action (Table.States (127), 3, 122);
+            Add_Action (Table.States (127), 15, 259);
+            Add_Action (Table.States (127), 28, 260);
+            Add_Action (Table.States (127), 32, 261);
+            Add_Action (Table.States (127), 39, 123);
+            Add_Action (Table.States (127), 40, 262);
+            Add_Action (Table.States (127), 41, 263);
+            Add_Action (Table.States (127), 44, 264);
+            Add_Action (Table.States (127), 52, 126);
+            Add_Action (Table.States (127), 74, Reduce, (193, 1), 0, null, 
null);
+            Add_Action (Table.States (127), 76, 127);
+            Add_Action (Table.States (127), 77, Reduce, (125, 6), 0, null, 
null);
+            Add_Action (Table.States (127), 79, 31);
+            Add_Action (Table.States (127), 80, Reduce, (167, 2), 0, null, 
null);
+            Add_Action (Table.States (127), 84, Reduce, (125, 6), 0, null, 
null);
+            Add_Action (Table.States (127), 88, Reduce, (167, 2), 0, null, 
null);
+            Add_Action (Table.States (127), 95, 128);
+            Add_Action (Table.States (127), 96, 129);
+            Add_Action (Table.States (127), 104, 130);
+            Add_Action (Table.States (127), 105, 120);
+            Add_Action (Table.States (127), 106, 34);
+            Add_Action (Table.States (127), 107, 265);
+            Table.States (127).Goto_List.Set_Capacity (29);
+            Add_Goto (Table.States (127), 118, 131);
+            Add_Goto (Table.States (127), 125, 266);
+            Add_Goto (Table.States (127), 126, 267);
+            Add_Goto (Table.States (127), 129, 42);
+            Add_Goto (Table.States (127), 137, 268);
+            Add_Goto (Table.States (127), 154, 269);
+            Add_Goto (Table.States (127), 166, 270);
+            Add_Goto (Table.States (127), 167, 271);
+            Add_Goto (Table.States (127), 192, 272);
+            Add_Goto (Table.States (127), 193, 273);
+            Add_Goto (Table.States (127), 198, 134);
+            Add_Goto (Table.States (127), 222, 274);
+            Add_Goto (Table.States (127), 240, 275);
+            Add_Goto (Table.States (127), 259, 136);
+            Add_Goto (Table.States (127), 273, 93);
+            Add_Goto (Table.States (127), 274, 276);
+            Add_Goto (Table.States (127), 276, 137);
+            Add_Goto (Table.States (127), 278, 277);
+            Add_Goto (Table.States (127), 283, 138);
+            Add_Goto (Table.States (127), 284, 139);
+            Add_Goto (Table.States (127), 285, 140);
+            Add_Goto (Table.States (127), 286, 141);
+            Add_Goto (Table.States (127), 287, 142);
+            Add_Goto (Table.States (127), 288, 143);
+            Add_Goto (Table.States (127), 294, 98);
+            Add_Goto (Table.States (127), 302, 278);
+            Add_Goto (Table.States (127), 321, 145);
+            Add_Goto (Table.States (127), 322, 146);
+            Add_Goto (Table.States (127), 331, 147);
+            Table.States (127).Kernel := To_Vector (((118, 76, 4, False), 
(118, 76, 2, False), (118, 76, 3, False),
+            (118, 76, 4, False), (118, 76, 3, False), (118, 76, 1, False)));
+            Table.States (127).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 126, 0)));
+            Table.States (128).Action_List.Set_Capacity (10);
+            Add_Action (Table.States (128), (3, 39, 40, 41, 76, 79, 104, 105, 
106, 107), (331, 1), 1, null, null);
+            Table.States (128).Kernel := To_Vector ((0 => (331, 95, 0, 
False)));
+            Table.States (128).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 331, 1)));
+            Table.States (129).Action_List.Set_Capacity (10);
+            Add_Action (Table.States (129), (3, 39, 40, 41, 76, 79, 104, 105, 
106, 107), (331, 0), 1, null, null);
+            Table.States (129).Kernel := To_Vector ((0 => (331, 96, 0, 
False)));
+            Table.States (129).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 331, 1)));
             Table.States (130).Action_List.Set_Capacity (36);
             Add_Action (Table.States (130), (10, 20, 21, 22, 23, 33, 35, 37, 
38, 40, 42, 43, 53, 55, 68, 74, 75, 77,
-            78, 79, 82, 83, 85, 86, 87, 88, 89, 91, 92, 94, 95, 96, 97, 98, 
99, 100), (258, 2), 1, primary_2'Access,
+            78, 80, 83, 84, 86, 87, 88, 89, 90, 92, 93, 95, 96, 97, 98, 99, 
100, 101), (259, 0), 1, primary_0'Access,
             null);
-            Table.States (130).Kernel := To_Vector ((0 => (258, 117, 0, 
False)));
-            Table.States (130).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 258, 1)));
-            Table.States (131).Action_List.Set_Capacity (17);
-            Add_Action (Table.States (131), (10, 20, 21, 22, 23, 35, 37, 43, 
53, 68, 74, 75, 77, 79, 83, 87, 96), (192,
+            Table.States (130).Kernel := To_Vector ((0 => (259, 104, 0, 
False)));
+            Table.States (130).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 259, 1)));
+            Table.States (131).Action_List.Set_Capacity (36);
+            Add_Action (Table.States (131), (10, 20, 21, 22, 23, 33, 35, 37, 
38, 40, 42, 43, 53, 55, 68, 74, 75, 77,
+            78, 80, 83, 84, 86, 87, 88, 89, 90, 92, 93, 95, 96, 97, 98, 99, 
100, 101), (259, 2), 1, primary_2'Access,
+            null);
+            Table.States (131).Kernel := To_Vector ((0 => (259, 118, 0, 
False)));
+            Table.States (131).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 259, 1)));
+            Table.States (132).Action_List.Set_Capacity (17);
+            Add_Action (Table.States (132), (10, 20, 21, 22, 23, 35, 37, 43, 
53, 68, 74, 75, 77, 80, 84, 88, 97), (193,
             0), 1, null, null);
-            Table.States (131).Kernel := To_Vector ((0 => (192, 191, 0, 
True)));
-            Table.States (131).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 192, 1)));
-            Table.States (131).Minimal_Complete_Actions_Recursive := True;
-            Table.States (132).Action_List.Set_Capacity (1);
-            Add_Action (Table.States (132), 35, 278);
-            Table.States (132).Kernel := To_Vector ((0 => (139, 192, 6, 
False)));
-            Table.States (132).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 35, 278)));
-            Table.States (133).Action_List.Set_Capacity (35);
-            Add_Action (Table.States (133), (10, 20, 21, 22, 23, 33, 35, 37, 
38, 40, 42, 43, 53, 55, 68, 74, 75, 77,
-            78, 79, 82, 83, 85, 86, 87, 88, 89, 91, 92, 94, 95, 96, 97, 98, 
99), (320, 1), 1, null, null);
-            Table.States (133).Kernel := To_Vector ((0 => (320, 197, 0, 
False)));
-            Table.States (133).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 320, 1)));
-            Table.States (134).Action_List.Set_Capacity (40);
-            Add_Action (Table.States (134), 10, Reduce, (258, 3), 1, null, 
null);
-            Add_Action (Table.States (134), 20, Reduce, (258, 3), 1, null, 
null);
-            Add_Action (Table.States (134), 21, Reduce, (258, 3), 1, null, 
null);
-            Add_Action (Table.States (134), 22, Reduce, (258, 3), 1, null, 
null);
-            Add_Action (Table.States (134), 23, Reduce, (258, 3), 1, null, 
null);
-            Add_Action (Table.States (134), 33, Reduce, (258, 3), 1, null, 
null);
-            Add_Action (Table.States (134), 35, Reduce, (258, 3), 1, null, 
null);
-            Add_Action (Table.States (134), 37, Reduce, (258, 3), 1, null, 
null);
-            Add_Action (Table.States (134), 38, Reduce, (258, 3), 1, null, 
null);
-            Add_Action (Table.States (134), 40, Reduce, (258, 3), 1, null, 
null);
-            Add_Action (Table.States (134), 42, Reduce, (258, 3), 1, null, 
null);
-            Add_Action (Table.States (134), 43, Reduce, (258, 3), 1, null, 
null);
-            Add_Action (Table.States (134), 53, Reduce, (258, 3), 1, null, 
null);
-            Add_Action (Table.States (134), 55, Reduce, (258, 3), 1, null, 
null);
-            Add_Action (Table.States (134), 68, Reduce, (258, 3), 1, null, 
null);
-            Add_Action (Table.States (134), 74, Reduce, (258, 3), 1, null, 
null);
-            Add_Action (Table.States (134), 75, Reduce, (258, 3), 1, null, 
null);
-            Add_Action (Table.States (134), 76, 235);
-            Add_Action (Table.States (134), 77, Reduce, (258, 3), 1, null, 
null);
-            Add_Action (Table.States (134), 78, Reduce, (258, 3), 1, null, 
null);
-            Add_Action (Table.States (134), 79, Reduce, (258, 3), 1, null, 
null);
-            Add_Action (Table.States (134), 82, Reduce, (258, 3), 1, null, 
null);
-            Add_Action (Table.States (134), 83, Reduce, (258, 3), 1, null, 
null);
-            Add_Action (Table.States (134), 84, 237);
-            Add_Action (Table.States (134), 85, Reduce, (258, 3), 1, null, 
null);
-            Add_Action (Table.States (134), 86, Reduce, (258, 3), 1, null, 
null);
-            Add_Action (Table.States (134), 87, Reduce, (258, 3), 1, null, 
null);
-            Add_Action (Table.States (134), 88, Reduce, (258, 3), 1, null, 
null);
-            Add_Action (Table.States (134), 89, Reduce, (258, 3), 1, null, 
null);
-            Add_Action (Table.States (134), 91, Reduce, (258, 3), 1, null, 
null);
-            Add_Action (Table.States (134), 92, Reduce, (258, 3), 1, null, 
null);
-            Add_Action (Table.States (134), 94, Reduce, (258, 3), 1, null, 
null);
-            Add_Action (Table.States (134), 95, Reduce, (258, 3), 1, null, 
null);
-            Add_Action (Table.States (134), 96, Reduce, (258, 3), 1, null, 
null);
-            Add_Action (Table.States (134), 97, Reduce, (258, 3), 1, null, 
null);
-            Add_Action (Table.States (134), 98, Reduce, (258, 3), 1, null, 
null);
-            Add_Action (Table.States (134), 99, Reduce, (258, 3), 1, null, 
null);
-            Add_Action (Table.States (134), 100, Reduce, (258, 3), 1, null, 
null);
-            Add_Action (Table.States (134), 101, 239);
-            Add_Action (Table.States (134), 102, 240);
-            Table.States (134).Goto_List.Set_Capacity (2);
-            Add_Goto (Table.States (134), 115, 241);
-            Add_Goto (Table.States (134), 322, 242);
-            Table.States (134).Kernel := To_Vector (((128, 239, 2, True), 
(239, 239, 5, True), (239, 239, 2, True),
-            (258, 239, 0, False), (272, 239, 3, True), (293, 239, 2, True), 
(293, 239, 2, True), (293, 239, 2, True),
-            (293, 239, 2, True)));
-            Table.States (134).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 258, 1)));
-            Table.States (135).Action_List.Set_Capacity (36);
-            Add_Action (Table.States (135), 10, Reduce, (197, 1), 1, null, 
null);
-            Add_Action (Table.States (135), 20, Reduce, (197, 1), 1, null, 
null);
-            Add_Action (Table.States (135), 21, Reduce, (197, 1), 1, null, 
null);
-            Add_Action (Table.States (135), 22, Reduce, (197, 1), 1, null, 
null);
-            Add_Action (Table.States (135), 23, Reduce, (197, 1), 1, null, 
null);
-            Add_Action (Table.States (135), 33, Reduce, (197, 1), 1, null, 
null);
-            Add_Action (Table.States (135), 35, Reduce, (197, 1), 1, null, 
null);
-            Add_Action (Table.States (135), 37, Reduce, (197, 1), 1, null, 
null);
-            Add_Action (Table.States (135), 38, Reduce, (197, 1), 1, null, 
null);
-            Add_Action (Table.States (135), 40, Reduce, (197, 1), 1, null, 
null);
-            Add_Action (Table.States (135), 42, Reduce, (197, 1), 1, null, 
null);
-            Add_Action (Table.States (135), 43, Reduce, (197, 1), 1, null, 
null);
-            Add_Action (Table.States (135), 53, Reduce, (197, 1), 1, null, 
null);
-            Add_Action (Table.States (135), 55, Reduce, (197, 1), 1, null, 
null);
-            Add_Action (Table.States (135), 68, Reduce, (197, 1), 1, null, 
null);
-            Add_Action (Table.States (135), 74, Reduce, (197, 1), 1, null, 
null);
-            Add_Action (Table.States (135), 75, Reduce, (197, 1), 1, null, 
null);
-            Add_Action (Table.States (135), 77, Reduce, (197, 1), 1, null, 
null);
-            Add_Action (Table.States (135), 78, Reduce, (197, 1), 1, null, 
null);
-            Add_Action (Table.States (135), 79, Reduce, (197, 1), 1, null, 
null);
-            Add_Action (Table.States (135), 82, Reduce, (197, 1), 1, null, 
null);
-            Add_Action (Table.States (135), 83, Reduce, (197, 1), 1, null, 
null);
-            Add_Action (Table.States (135), 85, Reduce, (197, 1), 1, null, 
null);
-            Add_Action (Table.States (135), 86, Reduce, (197, 1), 1, null, 
null);
-            Add_Action (Table.States (135), 87, Reduce, (197, 1), 1, null, 
null);
-            Add_Action (Table.States (135), 88, Reduce, (197, 1), 1, null, 
null);
-            Add_Action (Table.States (135), 89, Reduce, (197, 1), 1, null, 
null);
-            Add_Action (Table.States (135), 91, Reduce, (197, 1), 1, null, 
null);
-            Add_Action (Table.States (135), 92, Reduce, (197, 1), 1, null, 
null);
-            Add_Action (Table.States (135), 94, Reduce, (197, 1), 1, null, 
null);
-            Add_Action (Table.States (135), 95, Reduce, (197, 1), 1, null, 
null);
-            Add_Action (Table.States (135), 96, Reduce, (197, 1), 1, null, 
null);
-            Add_Action (Table.States (135), 97, Reduce, (197, 1), 1, null, 
null);
-            Add_Action (Table.States (135), 98, Reduce, (197, 1), 1, null, 
null);
-            Add_Action (Table.States (135), 99, Reduce, (197, 1), 1, null, 
null);
-            Add_Action (Table.States (135), 100, 279);
-            Table.States (135).Kernel := To_Vector (((197, 258, 2, False), 
(197, 258, 0, False)));
-            Table.States (135).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 197, 1)));
-            Table.States (136).Action_List.Set_Capacity (17);
-            Add_Action (Table.States (136), (10, 20, 21, 22, 23, 35, 37, 43, 
53, 68, 74, 75, 77, 79, 83, 87, 96), (287,
-            4), 1, null, null);
-            Table.States (136).Kernel := To_Vector ((0 => (287, 275, 0, 
True)));
-            Table.States (136).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 287, 1)));
-            Table.States (136).Minimal_Complete_Actions_Recursive := True;
+            Table.States (132).Kernel := To_Vector ((0 => (193, 192, 0, 
True)));
+            Table.States (132).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 193, 1)));
+            Table.States (132).Minimal_Complete_Actions_Recursive := True;
+            Table.States (133).Action_List.Set_Capacity (1);
+            Add_Action (Table.States (133), 35, 279);
+            Table.States (133).Kernel := To_Vector ((0 => (140, 193, 6, 
False)));
+            Table.States (133).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 35, 279)));
+            Table.States (134).Action_List.Set_Capacity (35);
+            Add_Action (Table.States (134), (10, 20, 21, 22, 23, 33, 35, 37, 
38, 40, 42, 43, 53, 55, 68, 74, 75, 77,
+            78, 80, 83, 84, 86, 87, 88, 89, 90, 92, 93, 95, 96, 97, 98, 99, 
100), (321, 1), 1, null, null);
+            Table.States (134).Kernel := To_Vector ((0 => (321, 198, 0, 
False)));
+            Table.States (134).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 321, 1)));
+            Table.States (135).Action_List.Set_Capacity (40);
+            Add_Action (Table.States (135), 10, Reduce, (259, 3), 1, null, 
null);
+            Add_Action (Table.States (135), 20, Reduce, (259, 3), 1, null, 
null);
+            Add_Action (Table.States (135), 21, Reduce, (259, 3), 1, null, 
null);
+            Add_Action (Table.States (135), 22, Reduce, (259, 3), 1, null, 
null);
+            Add_Action (Table.States (135), 23, Reduce, (259, 3), 1, null, 
null);
+            Add_Action (Table.States (135), 33, Reduce, (259, 3), 1, null, 
null);
+            Add_Action (Table.States (135), 35, Reduce, (259, 3), 1, null, 
null);
+            Add_Action (Table.States (135), 37, Reduce, (259, 3), 1, null, 
null);
+            Add_Action (Table.States (135), 38, Reduce, (259, 3), 1, null, 
null);
+            Add_Action (Table.States (135), 40, Reduce, (259, 3), 1, null, 
null);
+            Add_Action (Table.States (135), 42, Reduce, (259, 3), 1, null, 
null);
+            Add_Action (Table.States (135), 43, Reduce, (259, 3), 1, null, 
null);
+            Add_Action (Table.States (135), 53, Reduce, (259, 3), 1, null, 
null);
+            Add_Action (Table.States (135), 55, Reduce, (259, 3), 1, null, 
null);
+            Add_Action (Table.States (135), 68, Reduce, (259, 3), 1, null, 
null);
+            Add_Action (Table.States (135), 74, Reduce, (259, 3), 1, null, 
null);
+            Add_Action (Table.States (135), 75, Reduce, (259, 3), 1, null, 
null);
+            Add_Action (Table.States (135), 76, 236);
+            Add_Action (Table.States (135), 77, Reduce, (259, 3), 1, null, 
null);
+            Add_Action (Table.States (135), 78, Reduce, (259, 3), 1, null, 
null);
+            Add_Action (Table.States (135), 80, Reduce, (259, 3), 1, null, 
null);
+            Add_Action (Table.States (135), 83, Reduce, (259, 3), 1, null, 
null);
+            Add_Action (Table.States (135), 84, Reduce, (259, 3), 1, null, 
null);
+            Add_Action (Table.States (135), 85, 238);
+            Add_Action (Table.States (135), 86, Reduce, (259, 3), 1, null, 
null);
+            Add_Action (Table.States (135), 87, Reduce, (259, 3), 1, null, 
null);
+            Add_Action (Table.States (135), 88, Reduce, (259, 3), 1, null, 
null);
+            Add_Action (Table.States (135), 89, Reduce, (259, 3), 1, null, 
null);
+            Add_Action (Table.States (135), 90, Reduce, (259, 3), 1, null, 
null);
+            Add_Action (Table.States (135), 92, Reduce, (259, 3), 1, null, 
null);
+            Add_Action (Table.States (135), 93, Reduce, (259, 3), 1, null, 
null);
+            Add_Action (Table.States (135), 95, Reduce, (259, 3), 1, null, 
null);
+            Add_Action (Table.States (135), 96, Reduce, (259, 3), 1, null, 
null);
+            Add_Action (Table.States (135), 97, Reduce, (259, 3), 1, null, 
null);
+            Add_Action (Table.States (135), 98, Reduce, (259, 3), 1, null, 
null);
+            Add_Action (Table.States (135), 99, Reduce, (259, 3), 1, null, 
null);
+            Add_Action (Table.States (135), 100, Reduce, (259, 3), 1, null, 
null);
+            Add_Action (Table.States (135), 101, Reduce, (259, 3), 1, null, 
null);
+            Add_Action (Table.States (135), 102, 240);
+            Add_Action (Table.States (135), 103, 241);
+            Table.States (135).Goto_List.Set_Capacity (2);
+            Add_Goto (Table.States (135), 116, 242);
+            Add_Goto (Table.States (135), 323, 243);
+            Table.States (135).Kernel := To_Vector (((129, 240, 2, True), 
(240, 240, 5, True), (240, 240, 2, True),
+            (259, 240, 0, False), (273, 240, 3, True), (294, 240, 2, True), 
(294, 240, 2, True), (294, 240, 2, True),
+            (294, 240, 2, True)));
+            Table.States (135).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 259, 1)));
+            Table.States (136).Action_List.Set_Capacity (36);
+            Add_Action (Table.States (136), 10, Reduce, (198, 1), 1, null, 
null);
+            Add_Action (Table.States (136), 20, Reduce, (198, 1), 1, null, 
null);
+            Add_Action (Table.States (136), 21, Reduce, (198, 1), 1, null, 
null);
+            Add_Action (Table.States (136), 22, Reduce, (198, 1), 1, null, 
null);
+            Add_Action (Table.States (136), 23, Reduce, (198, 1), 1, null, 
null);
+            Add_Action (Table.States (136), 33, Reduce, (198, 1), 1, null, 
null);
+            Add_Action (Table.States (136), 35, Reduce, (198, 1), 1, null, 
null);
+            Add_Action (Table.States (136), 37, Reduce, (198, 1), 1, null, 
null);
+            Add_Action (Table.States (136), 38, Reduce, (198, 1), 1, null, 
null);
+            Add_Action (Table.States (136), 40, Reduce, (198, 1), 1, null, 
null);
+            Add_Action (Table.States (136), 42, Reduce, (198, 1), 1, null, 
null);
+            Add_Action (Table.States (136), 43, Reduce, (198, 1), 1, null, 
null);
+            Add_Action (Table.States (136), 53, Reduce, (198, 1), 1, null, 
null);
+            Add_Action (Table.States (136), 55, Reduce, (198, 1), 1, null, 
null);
+            Add_Action (Table.States (136), 68, Reduce, (198, 1), 1, null, 
null);
+            Add_Action (Table.States (136), 74, Reduce, (198, 1), 1, null, 
null);
+            Add_Action (Table.States (136), 75, Reduce, (198, 1), 1, null, 
null);
+            Add_Action (Table.States (136), 77, Reduce, (198, 1), 1, null, 
null);
+            Add_Action (Table.States (136), 78, Reduce, (198, 1), 1, null, 
null);
+            Add_Action (Table.States (136), 80, Reduce, (198, 1), 1, null, 
null);
+            Add_Action (Table.States (136), 83, Reduce, (198, 1), 1, null, 
null);
+            Add_Action (Table.States (136), 84, Reduce, (198, 1), 1, null, 
null);
+            Add_Action (Table.States (136), 86, Reduce, (198, 1), 1, null, 
null);
+            Add_Action (Table.States (136), 87, Reduce, (198, 1), 1, null, 
null);
+            Add_Action (Table.States (136), 88, Reduce, (198, 1), 1, null, 
null);
+            Add_Action (Table.States (136), 89, Reduce, (198, 1), 1, null, 
null);
+            Add_Action (Table.States (136), 90, Reduce, (198, 1), 1, null, 
null);
+            Add_Action (Table.States (136), 92, Reduce, (198, 1), 1, null, 
null);
+            Add_Action (Table.States (136), 93, Reduce, (198, 1), 1, null, 
null);
+            Add_Action (Table.States (136), 95, Reduce, (198, 1), 1, null, 
null);
+            Add_Action (Table.States (136), 96, Reduce, (198, 1), 1, null, 
null);
+            Add_Action (Table.States (136), 97, Reduce, (198, 1), 1, null, 
null);
+            Add_Action (Table.States (136), 98, Reduce, (198, 1), 1, null, 
null);
+            Add_Action (Table.States (136), 99, Reduce, (198, 1), 1, null, 
null);
+            Add_Action (Table.States (136), 100, Reduce, (198, 1), 1, null, 
null);
+            Add_Action (Table.States (136), 101, 280);
+            Table.States (136).Kernel := To_Vector (((198, 259, 2, False), 
(198, 259, 0, False)));
+            Table.States (136).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 198, 1)));
             Table.States (137).Action_List.Set_Capacity (17);
-            Add_Action (Table.States (137), 10, 280);
-            Add_Conflict (Table.States (137), 10, (191, 1), 1, null, null);
-            Add_Action (Table.States (137), 20, Reduce, (191, 1), 1, null, 
null);
-            Add_Action (Table.States (137), 21, Reduce, (191, 1), 1, null, 
null);
-            Add_Action (Table.States (137), 22, Reduce, (191, 1), 1, null, 
null);
-            Add_Action (Table.States (137), 23, Reduce, (191, 1), 1, null, 
null);
-            Add_Action (Table.States (137), 35, Reduce, (191, 1), 1, null, 
null);
-            Add_Action (Table.States (137), 37, Reduce, (191, 1), 1, null, 
null);
-            Add_Action (Table.States (137), 43, Reduce, (191, 1), 1, null, 
null);
-            Add_Action (Table.States (137), 53, Reduce, (191, 1), 1, null, 
null);
-            Add_Action (Table.States (137), 68, Reduce, (191, 1), 1, null, 
null);
-            Add_Action (Table.States (137), 74, Reduce, (191, 1), 1, null, 
null);
-            Add_Action (Table.States (137), 75, Reduce, (191, 1), 1, null, 
null);
-            Add_Action (Table.States (137), 77, Reduce, (191, 1), 1, null, 
null);
-            Add_Action (Table.States (137), 79, Reduce, (191, 1), 1, null, 
null);
-            Add_Action (Table.States (137), 83, Reduce, (191, 1), 1, null, 
null);
-            Add_Action (Table.States (137), 87, Reduce, (191, 1), 1, null, 
null);
-            Add_Action (Table.States (137), 96, Reduce, (191, 1), 1, null, 
null);
-            Table.States (137).Kernel := To_Vector (((191, 282, 0, True), 
(282, 282, 2, True)));
-            Table.States (137).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 191, 1)));
+            Add_Action (Table.States (137), (10, 20, 21, 22, 23, 35, 37, 43, 
53, 68, 74, 75, 77, 80, 84, 88, 97), (288,
+            4), 1, null, null);
+            Table.States (137).Kernel := To_Vector ((0 => (288, 276, 0, 
True)));
+            Table.States (137).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 288, 1)));
             Table.States (137).Minimal_Complete_Actions_Recursive := True;
             Table.States (138).Action_List.Set_Capacity (17);
             Add_Action (Table.States (138), 10, 281);
-            Add_Conflict (Table.States (138), 10, (191, 2), 1, null, null);
-            Add_Action (Table.States (138), 20, Reduce, (191, 2), 1, null, 
null);
-            Add_Action (Table.States (138), 21, Reduce, (191, 2), 1, null, 
null);
-            Add_Action (Table.States (138), 22, Reduce, (191, 2), 1, null, 
null);
-            Add_Action (Table.States (138), 23, Reduce, (191, 2), 1, null, 
null);
-            Add_Action (Table.States (138), 35, Reduce, (191, 2), 1, null, 
null);
-            Add_Action (Table.States (138), 37, Reduce, (191, 2), 1, null, 
null);
-            Add_Action (Table.States (138), 43, Reduce, (191, 2), 1, null, 
null);
-            Add_Action (Table.States (138), 53, Reduce, (191, 2), 1, null, 
null);
-            Add_Action (Table.States (138), 68, Reduce, (191, 2), 1, null, 
null);
-            Add_Action (Table.States (138), 74, Reduce, (191, 2), 1, null, 
null);
-            Add_Action (Table.States (138), 75, Reduce, (191, 2), 1, null, 
null);
-            Add_Action (Table.States (138), 77, Reduce, (191, 2), 1, null, 
null);
-            Add_Action (Table.States (138), 79, Reduce, (191, 2), 1, null, 
null);
-            Add_Action (Table.States (138), 83, Reduce, (191, 2), 1, null, 
null);
-            Add_Action (Table.States (138), 87, Reduce, (191, 2), 1, null, 
null);
-            Add_Action (Table.States (138), 96, Reduce, (191, 2), 1, null, 
null);
-            Table.States (138).Kernel := To_Vector (((191, 283, 0, True), 
(283, 283, 3, True)));
-            Table.States (138).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 191, 1)));
+            Add_Conflict (Table.States (138), 10, (192, 1), 1, null, null);
+            Add_Action (Table.States (138), 20, Reduce, (192, 1), 1, null, 
null);
+            Add_Action (Table.States (138), 21, Reduce, (192, 1), 1, null, 
null);
+            Add_Action (Table.States (138), 22, Reduce, (192, 1), 1, null, 
null);
+            Add_Action (Table.States (138), 23, Reduce, (192, 1), 1, null, 
null);
+            Add_Action (Table.States (138), 35, Reduce, (192, 1), 1, null, 
null);
+            Add_Action (Table.States (138), 37, Reduce, (192, 1), 1, null, 
null);
+            Add_Action (Table.States (138), 43, Reduce, (192, 1), 1, null, 
null);
+            Add_Action (Table.States (138), 53, Reduce, (192, 1), 1, null, 
null);
+            Add_Action (Table.States (138), 68, Reduce, (192, 1), 1, null, 
null);
+            Add_Action (Table.States (138), 74, Reduce, (192, 1), 1, null, 
null);
+            Add_Action (Table.States (138), 75, Reduce, (192, 1), 1, null, 
null);
+            Add_Action (Table.States (138), 77, Reduce, (192, 1), 1, null, 
null);
+            Add_Action (Table.States (138), 80, Reduce, (192, 1), 1, null, 
null);
+            Add_Action (Table.States (138), 84, Reduce, (192, 1), 1, null, 
null);
+            Add_Action (Table.States (138), 88, Reduce, (192, 1), 1, null, 
null);
+            Add_Action (Table.States (138), 97, Reduce, (192, 1), 1, null, 
null);
+            Table.States (138).Kernel := To_Vector (((192, 283, 0, True), 
(283, 283, 2, True)));
+            Table.States (138).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 192, 1)));
             Table.States (138).Minimal_Complete_Actions_Recursive := True;
             Table.States (139).Action_List.Set_Capacity (17);
-            Add_Action (Table.States (139), 10, Reduce, (191, 3), 1, null, 
null);
-            Add_Action (Table.States (139), 20, Reduce, (191, 3), 1, null, 
null);
-            Add_Action (Table.States (139), 21, Reduce, (191, 3), 1, null, 
null);
-            Add_Action (Table.States (139), 22, Reduce, (191, 3), 1, null, 
null);
-            Add_Action (Table.States (139), 23, Reduce, (191, 3), 1, null, 
null);
-            Add_Action (Table.States (139), 35, Reduce, (191, 3), 1, null, 
null);
-            Add_Action (Table.States (139), 37, Reduce, (191, 3), 1, null, 
null);
-            Add_Action (Table.States (139), 43, 282);
-            Add_Conflict (Table.States (139), 43, (191, 3), 1, null, null);
-            Add_Action (Table.States (139), 53, Reduce, (191, 3), 1, null, 
null);
-            Add_Action (Table.States (139), 68, Reduce, (191, 3), 1, null, 
null);
-            Add_Action (Table.States (139), 74, Reduce, (191, 3), 1, null, 
null);
-            Add_Action (Table.States (139), 75, Reduce, (191, 3), 1, null, 
null);
-            Add_Action (Table.States (139), 77, Reduce, (191, 3), 1, null, 
null);
-            Add_Action (Table.States (139), 79, Reduce, (191, 3), 1, null, 
null);
-            Add_Action (Table.States (139), 83, Reduce, (191, 3), 1, null, 
null);
-            Add_Action (Table.States (139), 87, Reduce, (191, 3), 1, null, 
null);
-            Add_Action (Table.States (139), 96, Reduce, (191, 3), 1, null, 
null);
-            Table.States (139).Kernel := To_Vector (((191, 284, 0, True), 
(284, 284, 2, True)));
-            Table.States (139).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 191, 1)));
+            Add_Action (Table.States (139), 10, 282);
+            Add_Conflict (Table.States (139), 10, (192, 2), 1, null, null);
+            Add_Action (Table.States (139), 20, Reduce, (192, 2), 1, null, 
null);
+            Add_Action (Table.States (139), 21, Reduce, (192, 2), 1, null, 
null);
+            Add_Action (Table.States (139), 22, Reduce, (192, 2), 1, null, 
null);
+            Add_Action (Table.States (139), 23, Reduce, (192, 2), 1, null, 
null);
+            Add_Action (Table.States (139), 35, Reduce, (192, 2), 1, null, 
null);
+            Add_Action (Table.States (139), 37, Reduce, (192, 2), 1, null, 
null);
+            Add_Action (Table.States (139), 43, Reduce, (192, 2), 1, null, 
null);
+            Add_Action (Table.States (139), 53, Reduce, (192, 2), 1, null, 
null);
+            Add_Action (Table.States (139), 68, Reduce, (192, 2), 1, null, 
null);
+            Add_Action (Table.States (139), 74, Reduce, (192, 2), 1, null, 
null);
+            Add_Action (Table.States (139), 75, Reduce, (192, 2), 1, null, 
null);
+            Add_Action (Table.States (139), 77, Reduce, (192, 2), 1, null, 
null);
+            Add_Action (Table.States (139), 80, Reduce, (192, 2), 1, null, 
null);
+            Add_Action (Table.States (139), 84, Reduce, (192, 2), 1, null, 
null);
+            Add_Action (Table.States (139), 88, Reduce, (192, 2), 1, null, 
null);
+            Add_Action (Table.States (139), 97, Reduce, (192, 2), 1, null, 
null);
+            Table.States (139).Kernel := To_Vector (((192, 284, 0, True), 
(284, 284, 3, True)));
+            Table.States (139).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 192, 1)));
             Table.States (139).Minimal_Complete_Actions_Recursive := True;
          end Subr_2;
          procedure Subr_3
          is begin
             Table.States (140).Action_List.Set_Capacity (17);
-            Add_Action (Table.States (140), 10, Reduce, (191, 4), 1, null, 
null);
-            Add_Action (Table.States (140), 20, Reduce, (191, 4), 1, null, 
null);
-            Add_Action (Table.States (140), 21, Reduce, (191, 4), 1, null, 
null);
-            Add_Action (Table.States (140), 22, Reduce, (191, 4), 1, null, 
null);
-            Add_Action (Table.States (140), 23, Reduce, (191, 4), 1, null, 
null);
-            Add_Action (Table.States (140), 35, Reduce, (191, 4), 1, null, 
null);
-            Add_Action (Table.States (140), 37, Reduce, (191, 4), 1, null, 
null);
+            Add_Action (Table.States (140), 10, Reduce, (192, 3), 1, null, 
null);
+            Add_Action (Table.States (140), 20, Reduce, (192, 3), 1, null, 
null);
+            Add_Action (Table.States (140), 21, Reduce, (192, 3), 1, null, 
null);
+            Add_Action (Table.States (140), 22, Reduce, (192, 3), 1, null, 
null);
+            Add_Action (Table.States (140), 23, Reduce, (192, 3), 1, null, 
null);
+            Add_Action (Table.States (140), 35, Reduce, (192, 3), 1, null, 
null);
+            Add_Action (Table.States (140), 37, Reduce, (192, 3), 1, null, 
null);
             Add_Action (Table.States (140), 43, 283);
-            Add_Conflict (Table.States (140), 43, (191, 4), 1, null, null);
-            Add_Action (Table.States (140), 53, Reduce, (191, 4), 1, null, 
null);
-            Add_Action (Table.States (140), 68, Reduce, (191, 4), 1, null, 
null);
-            Add_Action (Table.States (140), 74, Reduce, (191, 4), 1, null, 
null);
-            Add_Action (Table.States (140), 75, Reduce, (191, 4), 1, null, 
null);
-            Add_Action (Table.States (140), 77, Reduce, (191, 4), 1, null, 
null);
-            Add_Action (Table.States (140), 79, Reduce, (191, 4), 1, null, 
null);
-            Add_Action (Table.States (140), 83, Reduce, (191, 4), 1, null, 
null);
-            Add_Action (Table.States (140), 87, Reduce, (191, 4), 1, null, 
null);
-            Add_Action (Table.States (140), 96, Reduce, (191, 4), 1, null, 
null);
-            Table.States (140).Kernel := To_Vector (((191, 285, 0, True), 
(285, 285, 3, True)));
-            Table.States (140).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 191, 1)));
+            Add_Conflict (Table.States (140), 43, (192, 3), 1, null, null);
+            Add_Action (Table.States (140), 53, Reduce, (192, 3), 1, null, 
null);
+            Add_Action (Table.States (140), 68, Reduce, (192, 3), 1, null, 
null);
+            Add_Action (Table.States (140), 74, Reduce, (192, 3), 1, null, 
null);
+            Add_Action (Table.States (140), 75, Reduce, (192, 3), 1, null, 
null);
+            Add_Action (Table.States (140), 77, Reduce, (192, 3), 1, null, 
null);
+            Add_Action (Table.States (140), 80, Reduce, (192, 3), 1, null, 
null);
+            Add_Action (Table.States (140), 84, Reduce, (192, 3), 1, null, 
null);
+            Add_Action (Table.States (140), 88, Reduce, (192, 3), 1, null, 
null);
+            Add_Action (Table.States (140), 97, Reduce, (192, 3), 1, null, 
null);
+            Table.States (140).Kernel := To_Vector (((192, 285, 0, True), 
(285, 285, 2, True)));
+            Table.States (140).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 192, 1)));
             Table.States (140).Minimal_Complete_Actions_Recursive := True;
             Table.States (141).Action_List.Set_Capacity (17);
-            Add_Action (Table.States (141), 10, Reduce, (191, 5), 1, null, 
null);
-            Add_Action (Table.States (141), 20, Reduce, (191, 5), 1, null, 
null);
-            Add_Action (Table.States (141), 21, Reduce, (191, 5), 1, null, 
null);
-            Add_Action (Table.States (141), 22, Reduce, (191, 5), 1, null, 
null);
-            Add_Action (Table.States (141), 23, Reduce, (191, 5), 1, null, 
null);
-            Add_Action (Table.States (141), 35, Reduce, (191, 5), 1, null, 
null);
-            Add_Action (Table.States (141), 37, Reduce, (191, 5), 1, null, 
null);
-            Add_Action (Table.States (141), 43, Reduce, (191, 5), 1, null, 
null);
-            Add_Action (Table.States (141), 53, Reduce, (191, 5), 1, null, 
null);
-            Add_Action (Table.States (141), 68, Reduce, (191, 5), 1, null, 
null);
-            Add_Action (Table.States (141), 74, Reduce, (191, 5), 1, null, 
null);
-            Add_Action (Table.States (141), 75, 284);
-            Add_Conflict (Table.States (141), 75, (191, 5), 1, null, null);
-            Add_Action (Table.States (141), 77, Reduce, (191, 5), 1, null, 
null);
-            Add_Action (Table.States (141), 79, Reduce, (191, 5), 1, null, 
null);
-            Add_Action (Table.States (141), 83, Reduce, (191, 5), 1, null, 
null);
-            Add_Action (Table.States (141), 87, Reduce, (191, 5), 1, null, 
null);
-            Add_Action (Table.States (141), 96, Reduce, (191, 5), 1, null, 
null);
-            Table.States (141).Kernel := To_Vector (((191, 286, 0, True), 
(286, 286, 2, True)));
-            Table.States (141).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 191, 1)));
+            Add_Action (Table.States (141), 10, Reduce, (192, 4), 1, null, 
null);
+            Add_Action (Table.States (141), 20, Reduce, (192, 4), 1, null, 
null);
+            Add_Action (Table.States (141), 21, Reduce, (192, 4), 1, null, 
null);
+            Add_Action (Table.States (141), 22, Reduce, (192, 4), 1, null, 
null);
+            Add_Action (Table.States (141), 23, Reduce, (192, 4), 1, null, 
null);
+            Add_Action (Table.States (141), 35, Reduce, (192, 4), 1, null, 
null);
+            Add_Action (Table.States (141), 37, Reduce, (192, 4), 1, null, 
null);
+            Add_Action (Table.States (141), 43, 284);
+            Add_Conflict (Table.States (141), 43, (192, 4), 1, null, null);
+            Add_Action (Table.States (141), 53, Reduce, (192, 4), 1, null, 
null);
+            Add_Action (Table.States (141), 68, Reduce, (192, 4), 1, null, 
null);
+            Add_Action (Table.States (141), 74, Reduce, (192, 4), 1, null, 
null);
+            Add_Action (Table.States (141), 75, Reduce, (192, 4), 1, null, 
null);
+            Add_Action (Table.States (141), 77, Reduce, (192, 4), 1, null, 
null);
+            Add_Action (Table.States (141), 80, Reduce, (192, 4), 1, null, 
null);
+            Add_Action (Table.States (141), 84, Reduce, (192, 4), 1, null, 
null);
+            Add_Action (Table.States (141), 88, Reduce, (192, 4), 1, null, 
null);
+            Add_Action (Table.States (141), 97, Reduce, (192, 4), 1, null, 
null);
+            Table.States (141).Kernel := To_Vector (((192, 286, 0, True), 
(286, 286, 3, True)));
+            Table.States (141).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 192, 1)));
             Table.States (141).Minimal_Complete_Actions_Recursive := True;
             Table.States (142).Action_List.Set_Capacity (17);
-            Add_Action (Table.States (142), 10, 285);
-            Add_Conflict (Table.States (142), 10, (191, 0), 1, null, null);
-            Add_Action (Table.States (142), 20, Reduce, (191, 0), 1, null, 
null);
-            Add_Action (Table.States (142), 21, Reduce, (191, 0), 1, null, 
null);
-            Add_Action (Table.States (142), 22, Reduce, (191, 0), 1, null, 
null);
-            Add_Action (Table.States (142), 23, Reduce, (191, 0), 1, null, 
null);
-            Add_Action (Table.States (142), 35, Reduce, (191, 0), 1, null, 
null);
-            Add_Action (Table.States (142), 37, Reduce, (191, 0), 1, null, 
null);
-            Add_Action (Table.States (142), 43, 286);
-            Add_Conflict (Table.States (142), 43, (191, 0), 1, null, null);
-            Add_Action (Table.States (142), 53, Reduce, (191, 0), 1, null, 
null);
-            Add_Action (Table.States (142), 68, Reduce, (191, 0), 1, null, 
null);
-            Add_Action (Table.States (142), 74, Reduce, (191, 0), 1, null, 
null);
-            Add_Action (Table.States (142), 75, 287);
-            Add_Conflict (Table.States (142), 75, (191, 0), 1, null, null);
-            Add_Action (Table.States (142), 77, Reduce, (191, 0), 1, null, 
null);
-            Add_Action (Table.States (142), 79, Reduce, (191, 0), 1, null, 
null);
-            Add_Action (Table.States (142), 83, Reduce, (191, 0), 1, null, 
null);
-            Add_Action (Table.States (142), 87, Reduce, (191, 0), 1, null, 
null);
-            Add_Action (Table.States (142), 96, Reduce, (191, 0), 1, null, 
null);
-            Table.States (142).Kernel := To_Vector (((191, 287, 0, True), 
(282, 287, 2, True), (283, 287, 3, True),
-            (284, 287, 2, True), (285, 287, 3, True), (286, 287, 2, True)));
-            Table.States (142).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 191, 1)));
+            Add_Action (Table.States (142), 10, Reduce, (192, 5), 1, null, 
null);
+            Add_Action (Table.States (142), 20, Reduce, (192, 5), 1, null, 
null);
+            Add_Action (Table.States (142), 21, Reduce, (192, 5), 1, null, 
null);
+            Add_Action (Table.States (142), 22, Reduce, (192, 5), 1, null, 
null);
+            Add_Action (Table.States (142), 23, Reduce, (192, 5), 1, null, 
null);
+            Add_Action (Table.States (142), 35, Reduce, (192, 5), 1, null, 
null);
+            Add_Action (Table.States (142), 37, Reduce, (192, 5), 1, null, 
null);
+            Add_Action (Table.States (142), 43, Reduce, (192, 5), 1, null, 
null);
+            Add_Action (Table.States (142), 53, Reduce, (192, 5), 1, null, 
null);
+            Add_Action (Table.States (142), 68, Reduce, (192, 5), 1, null, 
null);
+            Add_Action (Table.States (142), 74, Reduce, (192, 5), 1, null, 
null);
+            Add_Action (Table.States (142), 75, 285);
+            Add_Conflict (Table.States (142), 75, (192, 5), 1, null, null);
+            Add_Action (Table.States (142), 77, Reduce, (192, 5), 1, null, 
null);
+            Add_Action (Table.States (142), 80, Reduce, (192, 5), 1, null, 
null);
+            Add_Action (Table.States (142), 84, Reduce, (192, 5), 1, null, 
null);
+            Add_Action (Table.States (142), 88, Reduce, (192, 5), 1, null, 
null);
+            Add_Action (Table.States (142), 97, Reduce, (192, 5), 1, null, 
null);
+            Table.States (142).Kernel := To_Vector (((192, 287, 0, True), 
(287, 287, 2, True)));
+            Table.States (142).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 192, 1)));
             Table.States (142).Minimal_Complete_Actions_Recursive := True;
-            Table.States (143).Action_List.Set_Capacity (25);
-            Add_Action (Table.States (143), 10, Reduce, (287, 3), 1, null, 
null);
-            Add_Action (Table.States (143), 20, Reduce, (287, 3), 1, null, 
null);
-            Add_Action (Table.States (143), 21, Reduce, (287, 3), 1, null, 
null);
-            Add_Action (Table.States (143), 22, Reduce, (287, 3), 1, null, 
null);
-            Add_Action (Table.States (143), 23, Reduce, (287, 3), 1, null, 
null);
-            Add_Action (Table.States (143), 33, 288);
-            Add_Action (Table.States (143), 35, Reduce, (287, 3), 1, null, 
null);
-            Add_Action (Table.States (143), 37, Reduce, (287, 3), 1, null, 
null);
-            Add_Action (Table.States (143), 40, 289);
-            Add_Action (Table.States (143), 43, Reduce, (287, 3), 1, null, 
null);
-            Add_Action (Table.States (143), 53, Reduce, (287, 3), 1, null, 
null);
-            Add_Action (Table.States (143), 68, Reduce, (287, 3), 1, null, 
null);
-            Add_Action (Table.States (143), 74, Reduce, (287, 3), 1, null, 
null);
-            Add_Action (Table.States (143), 75, Reduce, (287, 3), 1, null, 
null);
-            Add_Action (Table.States (143), 77, Reduce, (287, 3), 1, null, 
null);
-            Add_Action (Table.States (143), 79, Reduce, (287, 3), 1, null, 
null);
-            Add_Action (Table.States (143), 83, Reduce, (287, 3), 1, null, 
null);
-            Add_Action (Table.States (143), 86, 290);
-            Add_Action (Table.States (143), 87, Reduce, (287, 3), 1, null, 
null);
-            Add_Action (Table.States (143), 88, 291);
-            Add_Action (Table.States (143), 89, 292);
-            Add_Action (Table.States (143), 91, 293);
-            Add_Action (Table.States (143), 92, 294);
-            Add_Action (Table.States (143), 96, Reduce, (287, 3), 1, null, 
null);
-            Add_Action (Table.States (143), 98, 295);
-            Table.States (143).Goto_List.Set_Capacity (1);
-            Add_Goto (Table.States (143), 288, 296);
-            Table.States (143).Kernel := To_Vector (((287, 301, 3, False), 
(287, 301, 2, False), (287, 301, 2, False),
-            (287, 301, 0, False)));
-            Table.States (143).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 287, 1)));
-            Table.States (144).Action_List.Set_Capacity (35);
-            Add_Action (Table.States (144), 10, Reduce, (321, 1), 1, null, 
null);
-            Add_Action (Table.States (144), 20, Reduce, (321, 1), 1, null, 
null);
-            Add_Action (Table.States (144), 21, Reduce, (321, 1), 1, null, 
null);
-            Add_Action (Table.States (144), 22, Reduce, (321, 1), 1, null, 
null);
-            Add_Action (Table.States (144), 23, Reduce, (321, 1), 1, null, 
null);
-            Add_Action (Table.States (144), 33, Reduce, (321, 1), 1, null, 
null);
-            Add_Action (Table.States (144), 35, Reduce, (321, 1), 1, null, 
null);
-            Add_Action (Table.States (144), 37, Reduce, (321, 1), 1, null, 
null);
-            Add_Action (Table.States (144), 38, 297);
-            Add_Action (Table.States (144), 40, Reduce, (321, 1), 1, null, 
null);
-            Add_Action (Table.States (144), 42, Reduce, (321, 1), 1, null, 
null);
-            Add_Action (Table.States (144), 43, Reduce, (321, 1), 1, null, 
null);
-            Add_Action (Table.States (144), 53, Reduce, (321, 1), 1, null, 
null);
-            Add_Action (Table.States (144), 55, 298);
-            Add_Action (Table.States (144), 68, Reduce, (321, 1), 1, null, 
null);
-            Add_Action (Table.States (144), 74, Reduce, (321, 1), 1, null, 
null);
-            Add_Action (Table.States (144), 75, Reduce, (321, 1), 1, null, 
null);
-            Add_Action (Table.States (144), 77, Reduce, (321, 1), 1, null, 
null);
-            Add_Action (Table.States (144), 78, Reduce, (321, 1), 1, null, 
null);
-            Add_Action (Table.States (144), 79, Reduce, (321, 1), 1, null, 
null);
-            Add_Action (Table.States (144), 82, Reduce, (321, 1), 1, null, 
null);
-            Add_Action (Table.States (144), 83, Reduce, (321, 1), 1, null, 
null);
-            Add_Action (Table.States (144), 85, Reduce, (321, 1), 1, null, 
null);
-            Add_Action (Table.States (144), 86, Reduce, (321, 1), 1, null, 
null);
-            Add_Action (Table.States (144), 87, Reduce, (321, 1), 1, null, 
null);
-            Add_Action (Table.States (144), 88, Reduce, (321, 1), 1, null, 
null);
-            Add_Action (Table.States (144), 89, Reduce, (321, 1), 1, null, 
null);
-            Add_Action (Table.States (144), 91, Reduce, (321, 1), 1, null, 
null);
-            Add_Action (Table.States (144), 92, Reduce, (321, 1), 1, null, 
null);
-            Add_Action (Table.States (144), 94, Reduce, (321, 1), 1, null, 
null);
-            Add_Action (Table.States (144), 95, Reduce, (321, 1), 1, null, 
null);
-            Add_Action (Table.States (144), 96, Reduce, (321, 1), 1, null, 
null);
-            Add_Action (Table.States (144), 97, 299);
-            Add_Action (Table.States (144), 98, Reduce, (321, 1), 1, null, 
null);
-            Add_Action (Table.States (144), 99, 300);
+            Table.States (143).Action_List.Set_Capacity (17);
+            Add_Action (Table.States (143), 10, 286);
+            Add_Conflict (Table.States (143), 10, (192, 0), 1, null, null);
+            Add_Action (Table.States (143), 20, Reduce, (192, 0), 1, null, 
null);
+            Add_Action (Table.States (143), 21, Reduce, (192, 0), 1, null, 
null);
+            Add_Action (Table.States (143), 22, Reduce, (192, 0), 1, null, 
null);
+            Add_Action (Table.States (143), 23, Reduce, (192, 0), 1, null, 
null);
+            Add_Action (Table.States (143), 35, Reduce, (192, 0), 1, null, 
null);
+            Add_Action (Table.States (143), 37, Reduce, (192, 0), 1, null, 
null);
+            Add_Action (Table.States (143), 43, 287);
+            Add_Conflict (Table.States (143), 43, (192, 0), 1, null, null);
+            Add_Action (Table.States (143), 53, Reduce, (192, 0), 1, null, 
null);
+            Add_Action (Table.States (143), 68, Reduce, (192, 0), 1, null, 
null);
+            Add_Action (Table.States (143), 74, Reduce, (192, 0), 1, null, 
null);
+            Add_Action (Table.States (143), 75, 288);
+            Add_Conflict (Table.States (143), 75, (192, 0), 1, null, null);
+            Add_Action (Table.States (143), 77, Reduce, (192, 0), 1, null, 
null);
+            Add_Action (Table.States (143), 80, Reduce, (192, 0), 1, null, 
null);
+            Add_Action (Table.States (143), 84, Reduce, (192, 0), 1, null, 
null);
+            Add_Action (Table.States (143), 88, Reduce, (192, 0), 1, null, 
null);
+            Add_Action (Table.States (143), 97, Reduce, (192, 0), 1, null, 
null);
+            Table.States (143).Kernel := To_Vector (((192, 288, 0, True), 
(283, 288, 2, True), (284, 288, 3, True),
+            (285, 288, 2, True), (286, 288, 3, True), (287, 288, 2, True)));
+            Table.States (143).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 192, 1)));
+            Table.States (143).Minimal_Complete_Actions_Recursive := True;
+            Table.States (144).Action_List.Set_Capacity (25);
+            Add_Action (Table.States (144), 10, Reduce, (288, 3), 1, null, 
null);
+            Add_Action (Table.States (144), 20, Reduce, (288, 3), 1, null, 
null);
+            Add_Action (Table.States (144), 21, Reduce, (288, 3), 1, null, 
null);
+            Add_Action (Table.States (144), 22, Reduce, (288, 3), 1, null, 
null);
+            Add_Action (Table.States (144), 23, Reduce, (288, 3), 1, null, 
null);
+            Add_Action (Table.States (144), 33, 289);
+            Add_Action (Table.States (144), 35, Reduce, (288, 3), 1, null, 
null);
+            Add_Action (Table.States (144), 37, Reduce, (288, 3), 1, null, 
null);
+            Add_Action (Table.States (144), 40, 290);
+            Add_Action (Table.States (144), 43, Reduce, (288, 3), 1, null, 
null);
+            Add_Action (Table.States (144), 53, Reduce, (288, 3), 1, null, 
null);
+            Add_Action (Table.States (144), 68, Reduce, (288, 3), 1, null, 
null);
+            Add_Action (Table.States (144), 74, Reduce, (288, 3), 1, null, 
null);
+            Add_Action (Table.States (144), 75, Reduce, (288, 3), 1, null, 
null);
+            Add_Action (Table.States (144), 77, Reduce, (288, 3), 1, null, 
null);
+            Add_Action (Table.States (144), 80, Reduce, (288, 3), 1, null, 
null);
+            Add_Action (Table.States (144), 84, Reduce, (288, 3), 1, null, 
null);
+            Add_Action (Table.States (144), 87, 291);
+            Add_Action (Table.States (144), 88, Reduce, (288, 3), 1, null, 
null);
+            Add_Action (Table.States (144), 89, 292);
+            Add_Action (Table.States (144), 90, 293);
+            Add_Action (Table.States (144), 92, 294);
+            Add_Action (Table.States (144), 93, 295);
+            Add_Action (Table.States (144), 97, Reduce, (288, 3), 1, null, 
null);
+            Add_Action (Table.States (144), 99, 296);
             Table.States (144).Goto_List.Set_Capacity (1);
-            Add_Goto (Table.States (144), 237, 301);
-            Table.States (144).Kernel := To_Vector (((320, 320, 2, True), 
(321, 320, 0, False)));
-            Table.States (144).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 321, 1)));
-            Table.States (145).Action_List.Set_Capacity (31);
-            Add_Action (Table.States (145), 10, Reduce, (301, 1), 1, null, 
null);
-            Add_Action (Table.States (145), 20, Reduce, (301, 1), 1, null, 
null);
-            Add_Action (Table.States (145), 21, Reduce, (301, 1), 1, null, 
null);
-            Add_Action (Table.States (145), 22, Reduce, (301, 1), 1, null, 
null);
-            Add_Action (Table.States (145), 23, Reduce, (301, 1), 1, null, 
null);
-            Add_Action (Table.States (145), 33, Reduce, (301, 1), 1, null, 
null);
-            Add_Action (Table.States (145), 35, Reduce, (301, 1), 1, null, 
null);
-            Add_Action (Table.States (145), 37, Reduce, (301, 1), 1, null, 
null);
-            Add_Action (Table.States (145), 40, Reduce, (301, 1), 1, null, 
null);
-            Add_Action (Table.States (145), 42, Reduce, (301, 1), 1, null, 
null);
-            Add_Action (Table.States (145), 43, Reduce, (301, 1), 1, null, 
null);
-            Add_Action (Table.States (145), 53, Reduce, (301, 1), 1, null, 
null);
-            Add_Action (Table.States (145), 68, Reduce, (301, 1), 1, null, 
null);
-            Add_Action (Table.States (145), 74, Reduce, (301, 1), 1, null, 
null);
-            Add_Action (Table.States (145), 75, Reduce, (301, 1), 1, null, 
null);
-            Add_Action (Table.States (145), 77, Reduce, (301, 1), 1, null, 
null);
-            Add_Action (Table.States (145), 78, 302);
-            Add_Action (Table.States (145), 79, Reduce, (301, 1), 1, null, 
null);
-            Add_Action (Table.States (145), 82, Reduce, (301, 1), 1, null, 
null);
-            Add_Action (Table.States (145), 83, Reduce, (301, 1), 1, null, 
null);
-            Add_Action (Table.States (145), 85, Reduce, (301, 1), 1, null, 
null);
-            Add_Action (Table.States (145), 86, Reduce, (301, 1), 1, null, 
null);
-            Add_Action (Table.States (145), 87, Reduce, (301, 1), 1, null, 
null);
-            Add_Action (Table.States (145), 88, Reduce, (301, 1), 1, null, 
null);
-            Add_Action (Table.States (145), 89, Reduce, (301, 1), 1, null, 
null);
-            Add_Action (Table.States (145), 91, Reduce, (301, 1), 1, null, 
null);
-            Add_Action (Table.States (145), 92, Reduce, (301, 1), 1, null, 
null);
-            Add_Action (Table.States (145), 94, 303);
-            Add_Action (Table.States (145), 95, 304);
-            Add_Action (Table.States (145), 96, Reduce, (301, 1), 1, null, 
null);
-            Add_Action (Table.States (145), 98, Reduce, (301, 1), 1, null, 
null);
+            Add_Goto (Table.States (144), 289, 297);
+            Table.States (144).Kernel := To_Vector (((288, 302, 3, False), 
(288, 302, 2, False), (288, 302, 2, False),
+            (288, 302, 0, False)));
+            Table.States (144).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 288, 1)));
+            Table.States (145).Action_List.Set_Capacity (35);
+            Add_Action (Table.States (145), 10, Reduce, (322, 1), 1, null, 
null);
+            Add_Action (Table.States (145), 20, Reduce, (322, 1), 1, null, 
null);
+            Add_Action (Table.States (145), 21, Reduce, (322, 1), 1, null, 
null);
+            Add_Action (Table.States (145), 22, Reduce, (322, 1), 1, null, 
null);
+            Add_Action (Table.States (145), 23, Reduce, (322, 1), 1, null, 
null);
+            Add_Action (Table.States (145), 33, Reduce, (322, 1), 1, null, 
null);
+            Add_Action (Table.States (145), 35, Reduce, (322, 1), 1, null, 
null);
+            Add_Action (Table.States (145), 37, Reduce, (322, 1), 1, null, 
null);
+            Add_Action (Table.States (145), 38, 298);
+            Add_Action (Table.States (145), 40, Reduce, (322, 1), 1, null, 
null);
+            Add_Action (Table.States (145), 42, Reduce, (322, 1), 1, null, 
null);
+            Add_Action (Table.States (145), 43, Reduce, (322, 1), 1, null, 
null);
+            Add_Action (Table.States (145), 53, Reduce, (322, 1), 1, null, 
null);
+            Add_Action (Table.States (145), 55, 299);
+            Add_Action (Table.States (145), 68, Reduce, (322, 1), 1, null, 
null);
+            Add_Action (Table.States (145), 74, Reduce, (322, 1), 1, null, 
null);
+            Add_Action (Table.States (145), 75, Reduce, (322, 1), 1, null, 
null);
+            Add_Action (Table.States (145), 77, Reduce, (322, 1), 1, null, 
null);
+            Add_Action (Table.States (145), 78, Reduce, (322, 1), 1, null, 
null);
+            Add_Action (Table.States (145), 80, Reduce, (322, 1), 1, null, 
null);
+            Add_Action (Table.States (145), 83, Reduce, (322, 1), 1, null, 
null);
+            Add_Action (Table.States (145), 84, Reduce, (322, 1), 1, null, 
null);
+            Add_Action (Table.States (145), 86, Reduce, (322, 1), 1, null, 
null);
+            Add_Action (Table.States (145), 87, Reduce, (322, 1), 1, null, 
null);
+            Add_Action (Table.States (145), 88, Reduce, (322, 1), 1, null, 
null);
+            Add_Action (Table.States (145), 89, Reduce, (322, 1), 1, null, 
null);
+            Add_Action (Table.States (145), 90, Reduce, (322, 1), 1, null, 
null);
+            Add_Action (Table.States (145), 92, Reduce, (322, 1), 1, null, 
null);
+            Add_Action (Table.States (145), 93, Reduce, (322, 1), 1, null, 
null);
+            Add_Action (Table.States (145), 95, Reduce, (322, 1), 1, null, 
null);
+            Add_Action (Table.States (145), 96, Reduce, (322, 1), 1, null, 
null);
+            Add_Action (Table.States (145), 97, Reduce, (322, 1), 1, null, 
null);
+            Add_Action (Table.States (145), 98, 300);
+            Add_Action (Table.States (145), 99, Reduce, (322, 1), 1, null, 
null);
+            Add_Action (Table.States (145), 100, 301);
             Table.States (145).Goto_List.Set_Capacity (1);
-            Add_Goto (Table.States (145), 130, 305);
-            Table.States (145).Kernel := To_Vector (((301, 321, 0, False), 
(321, 321, 2, True)));
-            Table.States (145).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 301, 1)));
-            Table.States (146).Action_List.Set_Capacity (9);
-            Add_Action (Table.States (146), 3, 121);
-            Add_Action (Table.States (146), 39, 122);
-            Add_Action (Table.States (146), 40, 123);
-            Add_Action (Table.States (146), 41, 124);
-            Add_Action (Table.States (146), 76, 126);
-            Add_Action (Table.States (146), 103, 129);
-            Add_Action (Table.States (146), 104, 119);
-            Add_Action (Table.States (146), 105, 33);
-            Add_Action (Table.States (146), 106, 34);
-            Table.States (146).Goto_List.Set_Capacity (9);
-            Add_Goto (Table.States (146), 117, 130);
-            Add_Goto (Table.States (146), 128, 41);
-            Add_Goto (Table.States (146), 197, 133);
-            Add_Goto (Table.States (146), 239, 134);
-            Add_Goto (Table.States (146), 258, 135);
-            Add_Goto (Table.States (146), 272, 92);
-            Add_Goto (Table.States (146), 293, 97);
-            Add_Goto (Table.States (146), 320, 144);
-            Add_Goto (Table.States (146), 321, 306);
-            Table.States (146).Kernel := To_Vector ((0 => (301, 330, 1, 
False)));
-            Table.States (146).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 103, 129)));
-            Table.States (147).Action_List.Set_Capacity (13);
-            Add_Action (Table.States (147), 3, 121);
-            Add_Action (Table.States (147), 39, 122);
-            Add_Action (Table.States (147), 40, 123);
-            Add_Action (Table.States (147), 41, 124);
-            Add_Action (Table.States (147), 52, 125);
-            Add_Action (Table.States (147), 76, 126);
-            Add_Action (Table.States (147), 94, 127);
-            Add_Action (Table.States (147), 95, 128);
-            Add_Action (Table.States (147), 96, Reduce, (192, 1), 0, null, 
null);
-            Add_Action (Table.States (147), 103, 129);
-            Add_Action (Table.States (147), 104, 119);
-            Add_Action (Table.States (147), 105, 33);
+            Add_Goto (Table.States (145), 238, 302);
+            Table.States (145).Kernel := To_Vector (((321, 321, 2, True), 
(322, 321, 0, False)));
+            Table.States (145).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 322, 1)));
+            Table.States (146).Action_List.Set_Capacity (31);
+            Add_Action (Table.States (146), 10, Reduce, (302, 1), 1, null, 
null);
+            Add_Action (Table.States (146), 20, Reduce, (302, 1), 1, null, 
null);
+            Add_Action (Table.States (146), 21, Reduce, (302, 1), 1, null, 
null);
+            Add_Action (Table.States (146), 22, Reduce, (302, 1), 1, null, 
null);
+            Add_Action (Table.States (146), 23, Reduce, (302, 1), 1, null, 
null);
+            Add_Action (Table.States (146), 33, Reduce, (302, 1), 1, null, 
null);
+            Add_Action (Table.States (146), 35, Reduce, (302, 1), 1, null, 
null);
+            Add_Action (Table.States (146), 37, Reduce, (302, 1), 1, null, 
null);
+            Add_Action (Table.States (146), 40, Reduce, (302, 1), 1, null, 
null);
+            Add_Action (Table.States (146), 42, Reduce, (302, 1), 1, null, 
null);
+            Add_Action (Table.States (146), 43, Reduce, (302, 1), 1, null, 
null);
+            Add_Action (Table.States (146), 53, Reduce, (302, 1), 1, null, 
null);
+            Add_Action (Table.States (146), 68, Reduce, (302, 1), 1, null, 
null);
+            Add_Action (Table.States (146), 74, Reduce, (302, 1), 1, null, 
null);
+            Add_Action (Table.States (146), 75, Reduce, (302, 1), 1, null, 
null);
+            Add_Action (Table.States (146), 77, Reduce, (302, 1), 1, null, 
null);
+            Add_Action (Table.States (146), 78, 303);
+            Add_Action (Table.States (146), 80, Reduce, (302, 1), 1, null, 
null);
+            Add_Action (Table.States (146), 83, Reduce, (302, 1), 1, null, 
null);
+            Add_Action (Table.States (146), 84, Reduce, (302, 1), 1, null, 
null);
+            Add_Action (Table.States (146), 86, Reduce, (302, 1), 1, null, 
null);
+            Add_Action (Table.States (146), 87, Reduce, (302, 1), 1, null, 
null);
+            Add_Action (Table.States (146), 88, Reduce, (302, 1), 1, null, 
null);
+            Add_Action (Table.States (146), 89, Reduce, (302, 1), 1, null, 
null);
+            Add_Action (Table.States (146), 90, Reduce, (302, 1), 1, null, 
null);
+            Add_Action (Table.States (146), 92, Reduce, (302, 1), 1, null, 
null);
+            Add_Action (Table.States (146), 93, Reduce, (302, 1), 1, null, 
null);
+            Add_Action (Table.States (146), 95, 304);
+            Add_Action (Table.States (146), 96, 305);
+            Add_Action (Table.States (146), 97, Reduce, (302, 1), 1, null, 
null);
+            Add_Action (Table.States (146), 99, Reduce, (302, 1), 1, null, 
null);
+            Table.States (146).Goto_List.Set_Capacity (1);
+            Add_Goto (Table.States (146), 131, 306);
+            Table.States (146).Kernel := To_Vector (((302, 322, 0, False), 
(322, 322, 2, True)));
+            Table.States (146).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 302, 1)));
+            Table.States (147).Action_List.Set_Capacity (10);
+            Add_Action (Table.States (147), 3, 122);
+            Add_Action (Table.States (147), 39, 123);
+            Add_Action (Table.States (147), 40, 124);
+            Add_Action (Table.States (147), 41, 125);
+            Add_Action (Table.States (147), 76, 127);
+            Add_Action (Table.States (147), 79, 31);
+            Add_Action (Table.States (147), 104, 130);
+            Add_Action (Table.States (147), 105, 120);
             Add_Action (Table.States (147), 106, 34);
-            Table.States (147).Goto_List.Set_Capacity (20);
-            Add_Goto (Table.States (147), 117, 130);
-            Add_Goto (Table.States (147), 128, 41);
-            Add_Goto (Table.States (147), 191, 131);
-            Add_Goto (Table.States (147), 192, 307);
-            Add_Goto (Table.States (147), 197, 133);
-            Add_Goto (Table.States (147), 239, 134);
-            Add_Goto (Table.States (147), 258, 135);
-            Add_Goto (Table.States (147), 272, 92);
-            Add_Goto (Table.States (147), 275, 136);
-            Add_Goto (Table.States (147), 282, 137);
-            Add_Goto (Table.States (147), 283, 138);
-            Add_Goto (Table.States (147), 284, 139);
-            Add_Goto (Table.States (147), 285, 140);
-            Add_Goto (Table.States (147), 286, 141);
-            Add_Goto (Table.States (147), 287, 142);
-            Add_Goto (Table.States (147), 293, 97);
-            Add_Goto (Table.States (147), 301, 143);
-            Add_Goto (Table.States (147), 320, 144);
+            Add_Action (Table.States (147), 107, 35);
+            Table.States (147).Goto_List.Set_Capacity (9);
+            Add_Goto (Table.States (147), 118, 131);
+            Add_Goto (Table.States (147), 129, 42);
+            Add_Goto (Table.States (147), 198, 134);
+            Add_Goto (Table.States (147), 240, 135);
+            Add_Goto (Table.States (147), 259, 136);
+            Add_Goto (Table.States (147), 273, 93);
+            Add_Goto (Table.States (147), 294, 98);
             Add_Goto (Table.States (147), 321, 145);
-            Add_Goto (Table.States (147), 330, 146);
-            Table.States (147).Kernel := To_Vector ((0 => (161, 70, 1, 
False)));
-            Table.States (147).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 192, 0)));
-            Table.States (148).Action_List.Set_Capacity (1);
-            Add_Action (Table.States (148), 96, 308);
-            Table.States (148).Kernel := To_Vector ((0 => (161, 192, 1, 
False)));
-            Table.States (148).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 96, 308)));
-            Table.States (149).Action_List.Set_Capacity (2);
-            Add_Action (Table.States (149), (72, 96), (220, 0), 1, null, 
identifier_opt_0_check'Access);
-            Table.States (149).Kernel := To_Vector ((0 => (220, 104, 0, 
False)));
-            Table.States (149).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 220, 1)));
+            Add_Goto (Table.States (147), 322, 307);
+            Table.States (147).Kernel := To_Vector ((0 => (302, 331, 1, 
False)));
+            Table.States (147).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 104, 130)));
+            Table.States (148).Action_List.Set_Capacity (14);
+            Add_Action (Table.States (148), 3, 122);
+            Add_Action (Table.States (148), 39, 123);
+            Add_Action (Table.States (148), 40, 124);
+            Add_Action (Table.States (148), 41, 125);
+            Add_Action (Table.States (148), 52, 126);
+            Add_Action (Table.States (148), 76, 127);
+            Add_Action (Table.States (148), 79, 31);
+            Add_Action (Table.States (148), 95, 128);
+            Add_Action (Table.States (148), 96, 129);
+            Add_Action (Table.States (148), 97, Reduce, (193, 1), 0, null, 
null);
+            Add_Action (Table.States (148), 104, 130);
+            Add_Action (Table.States (148), 105, 120);
+            Add_Action (Table.States (148), 106, 34);
+            Add_Action (Table.States (148), 107, 35);
+            Table.States (148).Goto_List.Set_Capacity (20);
+            Add_Goto (Table.States (148), 118, 131);
+            Add_Goto (Table.States (148), 129, 42);
+            Add_Goto (Table.States (148), 192, 132);
+            Add_Goto (Table.States (148), 193, 308);
+            Add_Goto (Table.States (148), 198, 134);
+            Add_Goto (Table.States (148), 240, 135);
+            Add_Goto (Table.States (148), 259, 136);
+            Add_Goto (Table.States (148), 273, 93);
+            Add_Goto (Table.States (148), 276, 137);
+            Add_Goto (Table.States (148), 283, 138);
+            Add_Goto (Table.States (148), 284, 139);
+            Add_Goto (Table.States (148), 285, 140);
+            Add_Goto (Table.States (148), 286, 141);
+            Add_Goto (Table.States (148), 287, 142);
+            Add_Goto (Table.States (148), 288, 143);
+            Add_Goto (Table.States (148), 294, 98);
+            Add_Goto (Table.States (148), 302, 144);
+            Add_Goto (Table.States (148), 321, 145);
+            Add_Goto (Table.States (148), 322, 146);
+            Add_Goto (Table.States (148), 331, 147);
+            Table.States (148).Kernel := To_Vector ((0 => (162, 70, 1, 
False)));
+            Table.States (148).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 193, 0)));
+            Table.States (149).Action_List.Set_Capacity (1);
+            Add_Action (Table.States (149), 97, 309);
+            Table.States (149).Kernel := To_Vector ((0 => (162, 193, 1, 
False)));
+            Table.States (149).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 97, 309)));
             Table.States (150).Action_List.Set_Capacity (2);
-            Add_Action (Table.States (150), 72, 309);
-            Add_Action (Table.States (150), 96, 310);
-            Table.States (150).Kernel := To_Vector (((190, 220, 2, False), 
(190, 220, 1, False)));
-            Table.States (150).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 96, 310)));
-            Table.States (151).Action_List.Set_Capacity (8);
-            Add_Action (Table.States (151), 33, 311);
-            Add_Action (Table.States (151), 42, 312);
-            Add_Action (Table.States (151), 71, Reduce, (163, 0), 1, null, 
null);
-            Add_Conflict (Table.States (151), 71, (239, 5), 1, name_5'Access, 
name_5_check'Access);
-            Add_Action (Table.States (151), 76, Reduce, (239, 5), 1, 
name_5'Access, name_5_check'Access);
-            Add_Action (Table.States (151), 81, 313);
-            Add_Action (Table.States (151), 84, Reduce, (239, 5), 1, 
name_5'Access, name_5_check'Access);
-            Add_Action (Table.States (151), 101, Reduce, (239, 5), 1, 
name_5'Access, name_5_check'Access);
-            Add_Action (Table.States (151), 102, Reduce, (239, 5), 1, 
name_5'Access, name_5_check'Access);
-            Table.States (151).Kernel := To_Vector (((163, 104, 0, False), 
(230, 104, 5, False), (230, 104, 4, False),
-            (230, 104, 3, False), (230, 104, 3, False), (230, 104, 2, False), 
(230, 104, 2, False), (239, 104, 0,
+            Add_Action (Table.States (150), (72, 97), (221, 0), 1, null, 
identifier_opt_0_check'Access);
+            Table.States (150).Kernel := To_Vector ((0 => (221, 105, 0, 
False)));
+            Table.States (150).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 221, 1)));
+            Table.States (151).Action_List.Set_Capacity (2);
+            Add_Action (Table.States (151), 72, 310);
+            Add_Action (Table.States (151), 97, 311);
+            Table.States (151).Kernel := To_Vector (((191, 221, 2, False), 
(191, 221, 1, False)));
+            Table.States (151).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 97, 311)));
+            Table.States (152).Action_List.Set_Capacity (8);
+            Add_Action (Table.States (152), 33, 312);
+            Add_Action (Table.States (152), 42, 313);
+            Add_Action (Table.States (152), 71, Reduce, (164, 0), 1, null, 
null);
+            Add_Conflict (Table.States (152), 71, (240, 5), 1, name_5'Access, 
name_5_check'Access);
+            Add_Action (Table.States (152), 76, Reduce, (240, 5), 1, 
name_5'Access, name_5_check'Access);
+            Add_Action (Table.States (152), 82, 314);
+            Add_Action (Table.States (152), 85, Reduce, (240, 5), 1, 
name_5'Access, name_5_check'Access);
+            Add_Action (Table.States (152), 102, Reduce, (240, 5), 1, 
name_5'Access, name_5_check'Access);
+            Add_Action (Table.States (152), 103, Reduce, (240, 5), 1, 
name_5'Access, name_5_check'Access);
+            Table.States (152).Kernel := To_Vector (((164, 105, 0, False), 
(231, 105, 5, False), (231, 105, 4, False),
+            (231, 105, 3, False), (231, 105, 3, False), (231, 105, 2, False), 
(231, 105, 2, False), (240, 105, 0,
             False)));
-            Table.States (151).Minimal_Complete_Actions := To_Vector 
(((Reduce, 163, 1), (Reduce, 239, 1)));
-            Table.States (152).Action_List.Set_Capacity (5);
-            Add_Action (Table.States (152), 71, Reduce, (163, 1), 1, null, 
null);
-            Add_Conflict (Table.States (152), 71, (239, 7), 1, null, 
name_7_check'Access);
-            Add_Action (Table.States (152), 76, Reduce, (239, 7), 1, null, 
name_7_check'Access);
-            Add_Action (Table.States (152), 84, Reduce, (239, 7), 1, null, 
name_7_check'Access);
-            Add_Action (Table.States (152), 101, Reduce, (239, 7), 1, null, 
name_7_check'Access);
-            Add_Action (Table.States (152), 102, Reduce, (239, 7), 1, null, 
name_7_check'Access);
-            Table.States (152).Kernel := To_Vector (((163, 105, 0, False), 
(239, 105, 0, False)));
-            Table.States (152).Minimal_Complete_Actions := To_Vector 
(((Reduce, 163, 1), (Reduce, 239, 1)));
+            Table.States (152).Minimal_Complete_Actions := To_Vector 
(((Reduce, 164, 1), (Reduce, 240, 1)));
             Table.States (153).Action_List.Set_Capacity (5);
-            Add_Action (Table.States (153), 71, 314);
-            Add_Conflict (Table.States (153), 71, (239, 3), 1, null, null);
-            Add_Action (Table.States (153), 76, Reduce, (239, 3), 1, null, 
null);
-            Add_Action (Table.States (153), 84, Reduce, (239, 3), 1, null, 
null);
-            Add_Action (Table.States (153), 101, Reduce, (239, 3), 1, null, 
null);
-            Add_Action (Table.States (153), 102, Reduce, (239, 3), 1, null, 
null);
-            Table.States (153).Kernel := To_Vector (((121, 128, 2, False), 
(239, 128, 0, True)));
-            Table.States (153).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 239, 1)));
-            Table.States (153).Minimal_Complete_Actions_Recursive := True;
-            Table.States (154).Action_List.Set_Capacity (1);
+            Add_Action (Table.States (153), 71, Reduce, (164, 1), 1, null, 
null);
+            Add_Conflict (Table.States (153), 71, (240, 7), 1, null, 
name_7_check'Access);
+            Add_Action (Table.States (153), 76, Reduce, (240, 7), 1, null, 
name_7_check'Access);
+            Add_Action (Table.States (153), 85, Reduce, (240, 7), 1, null, 
name_7_check'Access);
+            Add_Action (Table.States (153), 102, Reduce, (240, 7), 1, null, 
name_7_check'Access);
+            Add_Action (Table.States (153), 103, Reduce, (240, 7), 1, null, 
name_7_check'Access);
+            Table.States (153).Kernel := To_Vector (((164, 106, 0, False), 
(240, 106, 0, False)));
+            Table.States (153).Minimal_Complete_Actions := To_Vector 
(((Reduce, 164, 1), (Reduce, 240, 1)));
+            Table.States (154).Action_List.Set_Capacity (5);
             Add_Action (Table.States (154), 71, 315);
-            Table.States (154).Kernel := To_Vector ((0 => (127, 163, 3, 
False)));
-            Table.States (154).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 71, 315)));
+            Add_Conflict (Table.States (154), 71, (240, 3), 1, null, null);
+            Add_Action (Table.States (154), 76, Reduce, (240, 3), 1, null, 
null);
+            Add_Action (Table.States (154), 85, Reduce, (240, 3), 1, null, 
null);
+            Add_Action (Table.States (154), 102, Reduce, (240, 3), 1, null, 
null);
+            Add_Action (Table.States (154), 103, Reduce, (240, 3), 1, null, 
null);
+            Table.States (154).Kernel := To_Vector (((122, 129, 2, False), 
(240, 129, 0, True)));
+            Table.States (154).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 240, 1)));
+            Table.States (154).Minimal_Complete_Actions_Recursive := True;
             Table.States (155).Action_List.Set_Capacity (1);
-            Add_Action (Table.States (155), (1 =>  37), (231, 0), 1, null, 
null);
-            Table.States (155).Kernel := To_Vector ((0 => (231, 230, 0, 
False)));
-            Table.States (155).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 231, 1)));
+            Add_Action (Table.States (155), 71, 316);
+            Table.States (155).Kernel := To_Vector ((0 => (128, 164, 3, 
False)));
+            Table.States (155).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 71, 316)));
             Table.States (156).Action_List.Set_Capacity (1);
-            Add_Action (Table.States (156), (1 =>  37), (229, 1), 2, 
iteration_scheme_1'Access, null);
-            Table.States (156).Kernel := To_Vector ((0 => (229, 231, 0, 
False)));
-            Table.States (156).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 229, 2)));
-            Table.States (157).Action_List.Set_Capacity (5);
-            Add_Action (Table.States (157), 71, 316);
-            Add_Action (Table.States (157), 76, 235);
-            Add_Action (Table.States (157), 84, 237);
-            Add_Action (Table.States (157), 101, 239);
-            Add_Action (Table.States (157), 102, 240);
-            Table.States (157).Goto_List.Set_Capacity (2);
-            Add_Goto (Table.States (157), 115, 241);
-            Add_Goto (Table.States (157), 322, 242);
-            Table.States (157).Kernel := To_Vector (((128, 239, 2, True), 
(182, 239, 4, False), (239, 239, 5, True),
-            (239, 239, 2, True), (272, 239, 3, True), (281, 239, 13, False), 
(293, 239, 2, True), (293, 239, 2, True),
-            (293, 239, 2, True), (293, 239, 2, True)));
-            Table.States (157).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 71, 316)));
+            Add_Action (Table.States (156), (1 =>  37), (232, 0), 1, null, 
null);
+            Table.States (156).Kernel := To_Vector ((0 => (232, 231, 0, 
False)));
+            Table.States (156).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 232, 1)));
+            Table.States (157).Action_List.Set_Capacity (1);
+            Add_Action (Table.States (157), (1 =>  37), (230, 1), 2, 
iteration_scheme_1'Access, null);
+            Table.States (157).Kernel := To_Vector ((0 => (230, 232, 0, 
False)));
+            Table.States (157).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 230, 2)));
             Table.States (158).Action_List.Set_Capacity (5);
-            Add_Action (Table.States (158), 58, 317);
-            Add_Action (Table.States (158), 76, 318);
-            Add_Action (Table.States (158), 84, 237);
-            Add_Action (Table.States (158), 101, 239);
+            Add_Action (Table.States (158), 71, 317);
+            Add_Action (Table.States (158), 76, 236);
+            Add_Action (Table.States (158), 85, 238);
             Add_Action (Table.States (158), 102, 240);
-            Table.States (158).Goto_List.Set_Capacity (5);
-            Add_Goto (Table.States (158), 115, 241);
-            Add_Goto (Table.States (158), 199, 319);
-            Add_Goto (Table.States (158), 252, 320);
-            Add_Goto (Table.States (158), 291, 321);
-            Add_Goto (Table.States (158), 322, 242);
-            Table.States (158).Kernel := To_Vector (((128, 239, 2, True), 
(207, 239, 1, False), (239, 239, 5, True),
-            (239, 239, 2, True), (272, 239, 3, True), (293, 239, 2, True), 
(293, 239, 2, True), (293, 239, 2, True),
-            (293, 239, 2, True)));
-            Table.States (158).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 58, 317)));
-            Table.States (159).Action_List.Set_Capacity (3);
-            Add_Action (Table.States (159), 104, 119);
-            Add_Action (Table.States (159), 105, 33);
-            Add_Action (Table.States (159), 106, 34);
-            Table.States (159).Goto_List.Set_Capacity (4);
-            Add_Goto (Table.States (159), 128, 41);
-            Add_Goto (Table.States (159), 239, 322);
-            Add_Goto (Table.States (159), 272, 92);
-            Add_Goto (Table.States (159), 293, 97);
-            Table.States (159).Kernel := To_Vector ((0 => (215, 29, 4, 
False)));
-            Table.States (159).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 104, 119)));
-            Table.States (160).Action_List.Set_Capacity (3);
-            Add_Action (Table.States (160), 104, 119);
-            Add_Action (Table.States (160), 105, 33);
+            Add_Action (Table.States (158), 103, 241);
+            Table.States (158).Goto_List.Set_Capacity (2);
+            Add_Goto (Table.States (158), 116, 242);
+            Add_Goto (Table.States (158), 323, 243);
+            Table.States (158).Kernel := To_Vector (((129, 240, 2, True), 
(183, 240, 4, False), (240, 240, 5, True),
+            (240, 240, 2, True), (273, 240, 3, True), (282, 240, 13, False), 
(294, 240, 2, True), (294, 240, 2, True),
+            (294, 240, 2, True), (294, 240, 2, True)));
+            Table.States (158).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 71, 317)));
+            Table.States (159).Action_List.Set_Capacity (5);
+            Add_Action (Table.States (159), 58, 318);
+            Add_Action (Table.States (159), 76, 319);
+            Add_Action (Table.States (159), 85, 238);
+            Add_Action (Table.States (159), 102, 240);
+            Add_Action (Table.States (159), 103, 241);
+            Table.States (159).Goto_List.Set_Capacity (5);
+            Add_Goto (Table.States (159), 116, 242);
+            Add_Goto (Table.States (159), 200, 320);
+            Add_Goto (Table.States (159), 253, 321);
+            Add_Goto (Table.States (159), 292, 322);
+            Add_Goto (Table.States (159), 323, 243);
+            Table.States (159).Kernel := To_Vector (((129, 240, 2, True), 
(208, 240, 1, False), (240, 240, 5, True),
+            (240, 240, 2, True), (273, 240, 3, True), (294, 240, 2, True), 
(294, 240, 2, True), (294, 240, 2, True),
+            (294, 240, 2, True)));
+            Table.States (159).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 58, 318)));
+            Table.States (160).Action_List.Set_Capacity (4);
+            Add_Action (Table.States (160), 79, 31);
+            Add_Action (Table.States (160), 105, 120);
             Add_Action (Table.States (160), 106, 34);
+            Add_Action (Table.States (160), 107, 35);
             Table.States (160).Goto_List.Set_Capacity (4);
-            Add_Goto (Table.States (160), 128, 41);
-            Add_Goto (Table.States (160), 239, 323);
-            Add_Goto (Table.States (160), 272, 92);
-            Add_Goto (Table.States (160), 293, 97);
-            Table.States (160).Kernel := To_Vector ((0 => (215, 47, 4, 
False)));
-            Table.States (160).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 104, 119)));
-            Table.States (161).Action_List.Set_Capacity (3);
-            Add_Action (Table.States (161), 104, 119);
-            Add_Action (Table.States (161), 105, 33);
+            Add_Goto (Table.States (160), 129, 42);
+            Add_Goto (Table.States (160), 240, 323);
+            Add_Goto (Table.States (160), 273, 93);
+            Add_Goto (Table.States (160), 294, 98);
+            Table.States (160).Kernel := To_Vector ((0 => (216, 29, 4, 
False)));
+            Table.States (160).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 105, 120)));
+            Table.States (161).Action_List.Set_Capacity (4);
+            Add_Action (Table.States (161), 79, 31);
+            Add_Action (Table.States (161), 105, 120);
             Add_Action (Table.States (161), 106, 34);
+            Add_Action (Table.States (161), 107, 35);
             Table.States (161).Goto_List.Set_Capacity (4);
-            Add_Goto (Table.States (161), 128, 41);
-            Add_Goto (Table.States (161), 239, 324);
-            Add_Goto (Table.States (161), 272, 92);
-            Add_Goto (Table.States (161), 293, 97);
-            Table.States (161).Kernel := To_Vector ((0 => (215, 50, 4, 
False)));
-            Table.States (161).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 104, 119)));
-            Table.States (162).Action_List.Set_Capacity (1);
-            Add_Action (Table.States (162), 104, 325);
-            Table.States (162).Kernel := To_Vector (((201, 69, 4, False), 
(201, 69, 4, False), (201, 69, 2, False)));
-            Table.States (162).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 104, 325)));
-            Table.States (163).Action_List.Set_Capacity (3);
-            Add_Action (Table.States (163), 29, 7);
-            Add_Action (Table.States (163), 47, 326);
-            Add_Action (Table.States (163), 50, 18);
-            Table.States (163).Goto_List.Set_Capacity (3);
-            Add_Goto (Table.States (163), 207, 61);
-            Add_Goto (Table.States (163), 262, 87);
-            Add_Goto (Table.States (163), 312, 327);
-            Table.States (163).Kernel := To_Vector (((200, 74, 6, False), 
(200, 74, 5, False), (200, 74, 5, False),
-            (200, 74, 3, False), (204, 74, 6, False)));
-            Table.States (163).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 50, 18)));
-            Table.States (164).Action_List.Set_Capacity (2);
-            Add_Action (Table.States (164), (81, 83), (219, 1), 1, 
identifier_list_1'Access, null);
-            Table.States (164).Kernel := To_Vector ((0 => (219, 104, 0, 
False)));
-            Table.States (164).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 219, 1)));
-            Table.States (165).Action_List.Set_Capacity (8);
-            Add_Action (Table.States (165), (29, 47, 48, 50, 69, 71, 74, 104), 
(212, 0), 1, null, null);
-            Table.States (165).Kernel := To_Vector ((0 => (212, 198, 0, 
False)));
-            Table.States (165).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 212, 1)));
+            Add_Goto (Table.States (161), 129, 42);
+            Add_Goto (Table.States (161), 240, 324);
+            Add_Goto (Table.States (161), 273, 93);
+            Add_Goto (Table.States (161), 294, 98);
+            Table.States (161).Kernel := To_Vector ((0 => (216, 47, 4, 
False)));
+            Table.States (161).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 105, 120)));
+            Table.States (162).Action_List.Set_Capacity (4);
+            Add_Action (Table.States (162), 79, 31);
+            Add_Action (Table.States (162), 105, 120);
+            Add_Action (Table.States (162), 106, 34);
+            Add_Action (Table.States (162), 107, 35);
+            Table.States (162).Goto_List.Set_Capacity (4);
+            Add_Goto (Table.States (162), 129, 42);
+            Add_Goto (Table.States (162), 240, 325);
+            Add_Goto (Table.States (162), 273, 93);
+            Add_Goto (Table.States (162), 294, 98);
+            Table.States (162).Kernel := To_Vector ((0 => (216, 50, 4, 
False)));
+            Table.States (162).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 105, 120)));
+            Table.States (163).Action_List.Set_Capacity (1);
+            Add_Action (Table.States (163), 105, 326);
+            Table.States (163).Kernel := To_Vector (((202, 69, 4, False), 
(202, 69, 4, False), (202, 69, 2, False)));
+            Table.States (163).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 105, 326)));
+            Table.States (164).Action_List.Set_Capacity (3);
+            Add_Action (Table.States (164), 29, 7);
+            Add_Action (Table.States (164), 47, 327);
+            Add_Action (Table.States (164), 50, 18);
+            Table.States (164).Goto_List.Set_Capacity (3);
+            Add_Goto (Table.States (164), 208, 62);
+            Add_Goto (Table.States (164), 263, 88);
+            Add_Goto (Table.States (164), 313, 328);
+            Table.States (164).Kernel := To_Vector (((201, 74, 6, False), 
(201, 74, 5, False), (201, 74, 5, False),
+            (201, 74, 3, False), (205, 74, 6, False)));
+            Table.States (164).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 50, 18)));
+            Table.States (165).Action_List.Set_Capacity (2);
+            Add_Action (Table.States (165), (82, 84), (220, 1), 1, 
identifier_list_1'Access, null);
+            Table.States (165).Kernel := To_Vector ((0 => (220, 105, 0, 
False)));
+            Table.States (165).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 220, 1)));
             Table.States (166).Action_List.Set_Capacity (8);
-            Add_Action (Table.States (166), (29, 47, 48, 50, 69, 71, 74, 104), 
(212, 2), 1, null, null);
-            Table.States (166).Kernel := To_Vector ((0 => (212, 200, 0, 
False)));
-            Table.States (166).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 212, 1)));
+            Add_Action (Table.States (166), (29, 47, 48, 50, 69, 71, 74, 105), 
(213, 0), 1, null, null);
+            Table.States (166).Kernel := To_Vector ((0 => (213, 199, 0, 
False)));
+            Table.States (166).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 213, 1)));
             Table.States (167).Action_List.Set_Capacity (8);
-            Add_Action (Table.States (167), (29, 47, 48, 50, 69, 71, 74, 104), 
(212, 1), 1, null, null);
-            Table.States (167).Kernel := To_Vector ((0 => (212, 201, 0, 
False)));
-            Table.States (167).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 212, 1)));
+            Add_Action (Table.States (167), (29, 47, 48, 50, 69, 71, 74, 105), 
(213, 2), 1, null, null);
+            Table.States (167).Kernel := To_Vector ((0 => (213, 201, 0, 
False)));
+            Table.States (167).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 213, 1)));
             Table.States (168).Action_List.Set_Capacity (8);
-            Add_Action (Table.States (168), (29, 47, 48, 50, 69, 71, 74, 104), 
(212, 3), 1, null, null);
-            Table.States (168).Kernel := To_Vector ((0 => (212, 204, 0, 
False)));
-            Table.States (168).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 212, 1)));
+            Add_Action (Table.States (168), (29, 47, 48, 50, 69, 71, 74, 105), 
(213, 1), 1, null, null);
+            Table.States (168).Kernel := To_Vector ((0 => (213, 202, 0, 
False)));
+            Table.States (168).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 213, 1)));
             Table.States (169).Action_List.Set_Capacity (8);
-            Add_Action (Table.States (169), 29, Reduce, (210, 0), 2, 
generic_formal_part_0'Access, null);
-            Add_Action (Table.States (169), 47, Reduce, (210, 0), 2, 
generic_formal_part_0'Access, null);
-            Add_Action (Table.States (169), 48, 16);
-            Add_Action (Table.States (169), 50, Reduce, (210, 0), 2, 
generic_formal_part_0'Access, null);
-            Add_Action (Table.States (169), 69, 162);
-            Add_Action (Table.States (169), 71, 28);
-            Add_Action (Table.States (169), 74, 163);
-            Add_Action (Table.States (169), 104, 164);
-            Table.States (169).Goto_List.Set_Capacity (8);
-            Add_Goto (Table.States (169), 198, 165);
-            Add_Goto (Table.States (169), 200, 166);
-            Add_Goto (Table.States (169), 201, 167);
-            Add_Goto (Table.States (169), 204, 168);
-            Add_Goto (Table.States (169), 212, 328);
-            Add_Goto (Table.States (169), 219, 171);
-            Add_Goto (Table.States (169), 257, 172);
-            Add_Goto (Table.States (169), 331, 173);
-            Table.States (169).Kernel := To_Vector (((210, 211, 0, False), 
(211, 211, 3, True)));
-            Table.States (169).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 210, 2)));
+            Add_Action (Table.States (169), (29, 47, 48, 50, 69, 71, 74, 105), 
(213, 3), 1, null, null);
+            Table.States (169).Kernel := To_Vector ((0 => (213, 205, 0, 
False)));
+            Table.States (169).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 213, 1)));
             Table.States (170).Action_List.Set_Capacity (8);
-            Add_Action (Table.States (170), (29, 47, 48, 50, 69, 71, 74, 104), 
(211, 1), 1, null, null);
-            Table.States (170).Kernel := To_Vector ((0 => (211, 212, 0, 
False)));
-            Table.States (170).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 211, 1)));
-            Table.States (171).Action_List.Set_Capacity (2);
-            Add_Action (Table.States (171), 81, 329);
-            Add_Action (Table.States (171), 83, 234);
-            Table.States (171).Kernel := To_Vector (((198, 219, 4, False), 
(198, 219, 5, False), (198, 219, 3, False),
-            (198, 219, 4, False), (219, 219, 2, True)));
-            Table.States (171).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 81, 329)));
-            Table.States (172).Action_List.Set_Capacity (8);
-            Add_Action (Table.States (172), (29, 47, 48, 50, 69, 71, 74, 104), 
(212, 4), 1, null, null);
-            Table.States (172).Kernel := To_Vector ((0 => (212, 257, 0, 
False)));
-            Table.States (172).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 212, 1)));
+            Add_Action (Table.States (170), 29, Reduce, (211, 0), 2, 
generic_formal_part_0'Access, null);
+            Add_Action (Table.States (170), 47, Reduce, (211, 0), 2, 
generic_formal_part_0'Access, null);
+            Add_Action (Table.States (170), 48, 16);
+            Add_Action (Table.States (170), 50, Reduce, (211, 0), 2, 
generic_formal_part_0'Access, null);
+            Add_Action (Table.States (170), 69, 163);
+            Add_Action (Table.States (170), 71, 28);
+            Add_Action (Table.States (170), 74, 164);
+            Add_Action (Table.States (170), 105, 165);
+            Table.States (170).Goto_List.Set_Capacity (8);
+            Add_Goto (Table.States (170), 199, 166);
+            Add_Goto (Table.States (170), 201, 167);
+            Add_Goto (Table.States (170), 202, 168);
+            Add_Goto (Table.States (170), 205, 169);
+            Add_Goto (Table.States (170), 213, 329);
+            Add_Goto (Table.States (170), 220, 172);
+            Add_Goto (Table.States (170), 258, 173);
+            Add_Goto (Table.States (170), 332, 174);
+            Table.States (170).Kernel := To_Vector (((211, 212, 0, False), 
(212, 212, 3, True)));
+            Table.States (170).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 211, 2)));
+            Table.States (171).Action_List.Set_Capacity (8);
+            Add_Action (Table.States (171), (29, 47, 48, 50, 69, 71, 74, 105), 
(212, 1), 1, null, null);
+            Table.States (171).Kernel := To_Vector ((0 => (212, 213, 0, 
False)));
+            Table.States (171).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 212, 1)));
+            Table.States (172).Action_List.Set_Capacity (2);
+            Add_Action (Table.States (172), 82, 330);
+            Add_Action (Table.States (172), 84, 235);
+            Table.States (172).Kernel := To_Vector (((199, 220, 4, False), 
(199, 220, 5, False), (199, 220, 3, False),
+            (199, 220, 4, False), (220, 220, 2, True)));
+            Table.States (172).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 82, 330)));
             Table.States (173).Action_List.Set_Capacity (8);
-            Add_Action (Table.States (173), (29, 47, 48, 50, 69, 71, 74, 104), 
(212, 5), 1, null, null);
-            Table.States (173).Kernel := To_Vector ((0 => (212, 331, 0, 
False)));
-            Table.States (173).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 212, 1)));
-            Table.States (174).Action_List.Set_Capacity (1);
-            Add_Action (Table.States (174), 96, 330);
-            Table.States (174).Kernel := To_Vector ((0 => (303, 104, 1, 
False)));
-            Table.States (174).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 96, 330)));
+            Add_Action (Table.States (173), (29, 47, 48, 50, 69, 71, 74, 105), 
(213, 4), 1, null, null);
+            Table.States (173).Kernel := To_Vector ((0 => (213, 258, 0, 
False)));
+            Table.States (173).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 213, 1)));
+            Table.States (174).Action_List.Set_Capacity (8);
+            Add_Action (Table.States (174), (29, 47, 48, 50, 69, 71, 74, 105), 
(213, 5), 1, null, null);
+            Table.States (174).Kernel := To_Vector ((0 => (213, 332, 0, 
False)));
+            Table.States (174).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 213, 1)));
             Table.States (175).Action_List.Set_Capacity (1);
-            Add_Action (Table.States (175), 68, 331);
-            Table.States (175).Kernel := To_Vector (((222, 192, 7, False), 
(222, 192, 5, False), (222, 192, 6, False),
-            (222, 192, 4, False)));
-            Table.States (175).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 68, 331)));
+            Add_Action (Table.States (175), 97, 331);
+            Table.States (175).Kernel := To_Vector ((0 => (304, 105, 1, 
False)));
+            Table.States (175).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 97, 331)));
             Table.States (176).Action_List.Set_Capacity (1);
-            Add_Action (Table.States (176), 74, 332);
-            Table.States (176).Kernel := To_Vector ((0 => (332, 49, 3, 
False)));
-            Table.States (176).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 74, 332)));
-            Table.States (177).Action_List.Set_Capacity (3);
-            Add_Action (Table.States (177), 104, 119);
-            Add_Action (Table.States (177), 105, 33);
-            Add_Action (Table.States (177), 106, 34);
-            Table.States (177).Goto_List.Set_Capacity (5);
-            Add_Goto (Table.States (177), 128, 41);
-            Add_Goto (Table.States (177), 238, 333);
-            Add_Goto (Table.States (177), 239, 219);
-            Add_Goto (Table.States (177), 272, 92);
-            Add_Goto (Table.States (177), 293, 97);
-            Table.States (177).Kernel := To_Vector ((0 => (332, 74, 2, 
False)));
-            Table.States (177).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 104, 119)));
-            Table.States (178).Action_List.Set_Capacity (3);
-            Add_Action (Table.States (178), (25, 29, 50), (246, 0), 2, 
overriding_indicator_opt_0'Access, null);
-            Table.States (178).Kernel := To_Vector ((0 => (246, 46, 0, 
False)));
-            Table.States (178).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 246, 2)));
-            Table.States (179).Action_List.Set_Capacity (46);
-            Add_Action (Table.States (179), (4, 5, 13, 15, 17, 18, 22, 23, 24, 
25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
-            40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 
68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
-            107), (303, 0), 2, simple_statement_0'Access, null);
-            Table.States (179).Kernel := To_Vector ((0 => (303, 96, 0, 
False)));
-            Table.States (179).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 303, 2)));
-            Table.States (180).Action_List.Set_Capacity (3);
-            Add_Action (Table.States (180), 104, 119);
-            Add_Action (Table.States (180), 105, 33);
-            Add_Action (Table.States (180), 106, 34);
-            Table.States (180).Goto_List.Set_Capacity (4);
-            Add_Goto (Table.States (180), 128, 41);
-            Add_Goto (Table.States (180), 239, 334);
-            Add_Goto (Table.States (180), 272, 92);
-            Add_Goto (Table.States (180), 293, 97);
-            Table.States (180).Kernel := To_Vector (((247, 14, 5, False), 
(247, 14, 4, False), (248, 14, 4, False)));
-            Table.States (180).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 104, 119)));
-            Table.States (181).Action_List.Set_Capacity (7);
-            Add_Action (Table.States (181), 35, 335);
-            Add_Conflict (Table.States (181), 35, (122, 1), 0, null, null);
-            Add_Action (Table.States (181), 56, 336);
-            Add_Action (Table.States (181), 74, 337);
-            Add_Action (Table.States (181), 76, 235);
-            Add_Action (Table.States (181), 84, 237);
-            Add_Action (Table.States (181), 101, 239);
-            Add_Action (Table.States (181), 102, 240);
-            Table.States (181).Goto_List.Set_Capacity (3);
-            Add_Goto (Table.States (181), 115, 241);
-            Add_Goto (Table.States (181), 122, 338);
-            Add_Goto (Table.States (181), 322, 242);
-            Table.States (181).Kernel := To_Vector (((128, 239, 2, True), 
(213, 239, 4, False), (239, 239, 5, True),
-            (239, 239, 2, True), (250, 239, 3, False), (251, 239, 3, False), 
(251, 239, 2, False), (272, 239, 3, True),
-            (293, 239, 2, True), (293, 239, 2, True), (293, 239, 2, True), 
(293, 239, 2, True)));
-            Table.States (181).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 122, 0)));
-            Table.States (182).Action_List.Set_Capacity (2);
-            Add_Action (Table.States (182), 76, 339);
-            Add_Action (Table.States (182), 96, 340);
-            Table.States (182).Kernel := To_Vector (((257, 104, 3, False), 
(257, 104, 5, False), (257, 104, 1,
+            Add_Action (Table.States (176), 68, 332);
+            Table.States (176).Kernel := To_Vector (((223, 193, 7, False), 
(223, 193, 5, False), (223, 193, 6, False),
+            (223, 193, 4, False)));
+            Table.States (176).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 68, 332)));
+            Table.States (177).Action_List.Set_Capacity (1);
+            Add_Action (Table.States (177), 74, 333);
+            Table.States (177).Kernel := To_Vector ((0 => (333, 49, 3, 
False)));
+            Table.States (177).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 74, 333)));
+            Table.States (178).Action_List.Set_Capacity (4);
+            Add_Action (Table.States (178), 79, 31);
+            Add_Action (Table.States (178), 105, 120);
+            Add_Action (Table.States (178), 106, 34);
+            Add_Action (Table.States (178), 107, 35);
+            Table.States (178).Goto_List.Set_Capacity (5);
+            Add_Goto (Table.States (178), 129, 42);
+            Add_Goto (Table.States (178), 239, 334);
+            Add_Goto (Table.States (178), 240, 220);
+            Add_Goto (Table.States (178), 273, 93);
+            Add_Goto (Table.States (178), 294, 98);
+            Table.States (178).Kernel := To_Vector ((0 => (333, 74, 2, 
False)));
+            Table.States (178).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 105, 120)));
+            Table.States (179).Action_List.Set_Capacity (3);
+            Add_Action (Table.States (179), (25, 29, 50), (247, 0), 2, 
overriding_indicator_opt_0'Access, null);
+            Table.States (179).Kernel := To_Vector ((0 => (247, 46, 0, 
False)));
+            Table.States (179).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 247, 2)));
+            Table.States (180).Action_List.Set_Capacity (47);
+            Add_Action (Table.States (180), (4, 5, 13, 15, 17, 18, 22, 23, 24, 
25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
+            40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 
68, 69, 71, 72, 73, 74, 79, 94, 105, 106,
+            107, 108), (304, 0), 2, simple_statement_0'Access, null);
+            Table.States (180).Kernel := To_Vector ((0 => (304, 97, 0, 
False)));
+            Table.States (180).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 304, 2)));
+            Table.States (181).Action_List.Set_Capacity (4);
+            Add_Action (Table.States (181), 79, 31);
+            Add_Action (Table.States (181), 105, 120);
+            Add_Action (Table.States (181), 106, 34);
+            Add_Action (Table.States (181), 107, 35);
+            Table.States (181).Goto_List.Set_Capacity (4);
+            Add_Goto (Table.States (181), 129, 42);
+            Add_Goto (Table.States (181), 240, 335);
+            Add_Goto (Table.States (181), 273, 93);
+            Add_Goto (Table.States (181), 294, 98);
+            Table.States (181).Kernel := To_Vector (((248, 14, 5, False), 
(248, 14, 4, False), (249, 14, 4, False)));
+            Table.States (181).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 105, 120)));
+            Table.States (182).Action_List.Set_Capacity (7);
+            Add_Action (Table.States (182), 35, 336);
+            Add_Conflict (Table.States (182), 35, (123, 1), 0, null, null);
+            Add_Action (Table.States (182), 56, 337);
+            Add_Action (Table.States (182), 74, 338);
+            Add_Action (Table.States (182), 76, 236);
+            Add_Action (Table.States (182), 85, 238);
+            Add_Action (Table.States (182), 102, 240);
+            Add_Action (Table.States (182), 103, 241);
+            Table.States (182).Goto_List.Set_Capacity (3);
+            Add_Goto (Table.States (182), 116, 242);
+            Add_Goto (Table.States (182), 123, 339);
+            Add_Goto (Table.States (182), 323, 243);
+            Table.States (182).Kernel := To_Vector (((129, 240, 2, True), 
(214, 240, 4, False), (240, 240, 5, True),
+            (240, 240, 2, True), (251, 240, 3, False), (252, 240, 3, False), 
(252, 240, 2, False), (273, 240, 3, True),
+            (294, 240, 2, True), (294, 240, 2, True), (294, 240, 2, True), 
(294, 240, 2, True)));
+            Table.States (182).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 123, 0)));
+            Table.States (183).Action_List.Set_Capacity (2);
+            Add_Action (Table.States (183), 76, 340);
+            Add_Action (Table.States (183), 97, 341);
+            Table.States (183).Kernel := To_Vector (((258, 105, 3, False), 
(258, 105, 5, False), (258, 105, 1,
             False)));
-            Table.States (182).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 96, 340)));
-            Table.States (183).Action_List.Set_Capacity (3);
-            Add_Action (Table.States (183), 104, 341);
-            Add_Action (Table.States (183), 105, 152);
-            Add_Action (Table.States (183), 106, 34);
-            Table.States (183).Goto_List.Set_Capacity (5);
-            Add_Goto (Table.States (183), 128, 153);
-            Add_Goto (Table.States (183), 163, 154);
-            Add_Goto (Table.States (183), 239, 157);
-            Add_Goto (Table.States (183), 272, 92);
-            Add_Goto (Table.States (183), 293, 97);
-            Table.States (183).Kernel := To_Vector (((121, 28, 5, False), 
(127, 28, 4, False), (182, 28, 5, False),
-            (281, 28, 14, False)));
-            Table.States (183).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 104, 341)));
-            Table.States (184).Action_List.Set_Capacity (3);
-            Add_Action (Table.States (184), 104, 119);
-            Add_Action (Table.States (184), 105, 33);
-            Add_Action (Table.States (184), 106, 34);
+            Table.States (183).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 97, 341)));
+            Table.States (184).Action_List.Set_Capacity (4);
+            Add_Action (Table.States (184), 79, 31);
+            Add_Action (Table.States (184), 105, 342);
+            Add_Action (Table.States (184), 106, 153);
+            Add_Action (Table.States (184), 107, 35);
             Table.States (184).Goto_List.Set_Capacity (5);
-            Add_Goto (Table.States (184), 128, 41);
-            Add_Goto (Table.States (184), 238, 342);
-            Add_Goto (Table.States (184), 239, 219);
-            Add_Goto (Table.States (184), 272, 92);
-            Add_Goto (Table.States (184), 293, 97);
-            Table.States (184).Kernel := To_Vector ((0 => (332, 74, 2, 
False)));
-            Table.States (184).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 104, 119)));
-            Table.States (185).Action_List.Set_Capacity (2);
-            Add_Action (Table.States (185), 81, 343);
-            Add_Conflict (Table.States (185), 81, (219, 1), 1, 
identifier_list_1'Access, null);
-            Add_Action (Table.States (185), 83, Reduce, (219, 1), 1, 
identifier_list_1'Access, null);
-            Table.States (185).Kernel := To_Vector (((219, 104, 0, False), 
(245, 104, 5, False), (245, 104, 6, False),
-            (245, 104, 5, False)));
-            Table.States (185).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 219, 1)));
-            Table.States (186).Action_List.Set_Capacity (39);
-            Add_Action (Table.States (186), (4, 5, 13, 15, 17, 18, 25, 27, 28, 
29, 30, 31, 32, 36, 37, 40, 41, 46, 47,
-            48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 93, 
104, 105, 106, 107), (142, 2), 2,
+            Add_Goto (Table.States (184), 129, 154);
+            Add_Goto (Table.States (184), 164, 155);
+            Add_Goto (Table.States (184), 240, 158);
+            Add_Goto (Table.States (184), 273, 93);
+            Add_Goto (Table.States (184), 294, 98);
+            Table.States (184).Kernel := To_Vector (((122, 28, 5, False), 
(128, 28, 4, False), (183, 28, 5, False),
+            (282, 28, 14, False)));
+            Table.States (184).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 105, 342)));
+            Table.States (185).Action_List.Set_Capacity (4);
+            Add_Action (Table.States (185), 79, 31);
+            Add_Action (Table.States (185), 105, 120);
+            Add_Action (Table.States (185), 106, 34);
+            Add_Action (Table.States (185), 107, 35);
+            Table.States (185).Goto_List.Set_Capacity (5);
+            Add_Goto (Table.States (185), 129, 42);
+            Add_Goto (Table.States (185), 239, 343);
+            Add_Goto (Table.States (185), 240, 220);
+            Add_Goto (Table.States (185), 273, 93);
+            Add_Goto (Table.States (185), 294, 98);
+            Table.States (185).Kernel := To_Vector ((0 => (333, 74, 2, 
False)));
+            Table.States (185).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 105, 120)));
+            Table.States (186).Action_List.Set_Capacity (2);
+            Add_Action (Table.States (186), 82, 344);
+            Add_Conflict (Table.States (186), 82, (220, 1), 1, 
identifier_list_1'Access, null);
+            Add_Action (Table.States (186), 84, Reduce, (220, 1), 1, 
identifier_list_1'Access, null);
+            Table.States (186).Kernel := To_Vector (((220, 105, 0, False), 
(246, 105, 5, False), (246, 105, 6, False),
+            (246, 105, 5, False)));
+            Table.States (186).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 220, 1)));
+            Table.States (187).Action_List.Set_Capacity (40);
+            Add_Action (Table.States (187), (4, 5, 13, 15, 17, 18, 25, 27, 28, 
29, 30, 31, 32, 36, 37, 40, 41, 46, 47,
+            48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 79, 
94, 105, 106, 107, 108), (143, 2), 2,
             compilation_unit_2'Access, null);
-            Table.States (186).Kernel := To_Vector ((0 => (142, 157, 0, 
False)));
-            Table.States (186).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 142, 2)));
-            Table.States (187).Action_List.Set_Capacity (7);
-            Add_Action (Table.States (187), 35, Reduce, (253, 1), 0, null, 
null);
-            Add_Action (Table.States (187), 74, Reduce, (253, 1), 0, null, 
null);
-            Add_Action (Table.States (187), 76, 318);
-            Add_Action (Table.States (187), 84, 237);
-            Add_Action (Table.States (187), 96, Reduce, (253, 1), 0, null, 
null);
-            Add_Action (Table.States (187), 101, 239);
-            Add_Action (Table.States (187), 102, 240);
-            Table.States (187).Goto_List.Set_Capacity (4);
-            Add_Goto (Table.States (187), 115, 241);
-            Add_Goto (Table.States (187), 199, 344);
-            Add_Goto (Table.States (187), 253, 345);
-            Add_Goto (Table.States (187), 322, 242);
-            Table.States (187).Kernel := To_Vector (((128, 239, 2, True), 
(239, 239, 5, True), (239, 239, 2, True),
-            (262, 239, 0, False), (272, 239, 3, True), (293, 239, 2, True), 
(293, 239, 2, True), (293, 239, 2, True),
-            (293, 239, 2, True)));
-            Table.States (187).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 253, 0)));
-            Table.States (188).Action_List.Set_Capacity (1);
-            Add_Action (Table.States (188), 104, 346);
-            Table.States (188).Kernel := To_Vector (((264, 14, 4, False), 
(265, 14, 4, False)));
-            Table.States (188).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 104, 346)));
+            Table.States (187).Kernel := To_Vector ((0 => (143, 158, 0, 
False)));
+            Table.States (187).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 143, 2)));
+            Table.States (188).Action_List.Set_Capacity (7);
+            Add_Action (Table.States (188), 35, Reduce, (254, 1), 0, null, 
null);
+            Add_Action (Table.States (188), 74, Reduce, (254, 1), 0, null, 
null);
+            Add_Action (Table.States (188), 76, 319);
+            Add_Action (Table.States (188), 85, 238);
+            Add_Action (Table.States (188), 97, Reduce, (254, 1), 0, null, 
null);
+            Add_Action (Table.States (188), 102, 240);
+            Add_Action (Table.States (188), 103, 241);
+            Table.States (188).Goto_List.Set_Capacity (4);
+            Add_Goto (Table.States (188), 116, 242);
+            Add_Goto (Table.States (188), 200, 345);
+            Add_Goto (Table.States (188), 254, 346);
+            Add_Goto (Table.States (188), 323, 243);
+            Table.States (188).Kernel := To_Vector (((129, 240, 2, True), 
(240, 240, 5, True), (240, 240, 2, True),
+            (263, 240, 0, False), (273, 240, 3, True), (294, 240, 2, True), 
(294, 240, 2, True), (294, 240, 2, True),
+            (294, 240, 2, True)));
+            Table.States (188).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 254, 0)));
             Table.States (189).Action_List.Set_Capacity (1);
-            Add_Action (Table.States (189), 104, 347);
-            Table.States (189).Kernel := To_Vector (((271, 69, 7, False), 
(271, 69, 4, False)));
-            Table.States (189).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 104, 347)));
-            Table.States (190).Action_List.Set_Capacity (2);
-            Add_Action (Table.States (190), 35, Reduce, (122, 1), 0, null, 
null);
-            Add_Action (Table.States (190), 74, 337);
-            Table.States (190).Goto_List.Set_Capacity (1);
-            Add_Goto (Table.States (190), 122, 348);
-            Table.States (190).Kernel := To_Vector (((304, 104, 6, False), 
(304, 104, 3, False)));
-            Table.States (190).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 122, 0)));
-            Table.States (191).Action_List.Set_Capacity (46);
-            Add_Action (Table.States (191), (4, 5, 13, 15, 17, 18, 22, 23, 24, 
25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
-            40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 
68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
-            107), (276, 2), 2, raise_statement_2'Access, null);
-            Table.States (191).Kernel := To_Vector ((0 => (276, 96, 0, 
False)));
-            Table.States (191).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 276, 2)));
-            Table.States (192).Action_List.Set_Capacity (6);
-            Add_Action (Table.States (192), 74, 349);
-            Add_Action (Table.States (192), 76, 235);
-            Add_Action (Table.States (192), 84, 237);
-            Add_Action (Table.States (192), 96, 350);
-            Add_Action (Table.States (192), 101, 239);
-            Add_Action (Table.States (192), 102, 240);
-            Table.States (192).Goto_List.Set_Capacity (2);
-            Add_Goto (Table.States (192), 115, 241);
-            Add_Goto (Table.States (192), 322, 242);
-            Table.States (192).Kernel := To_Vector (((128, 239, 2, True), 
(239, 239, 5, True), (239, 239, 2, True),
-            (272, 239, 3, True), (276, 239, 2, False), (276, 239, 1, False), 
(293, 239, 2, True), (293, 239, 2, True),
-            (293, 239, 2, True), (293, 239, 2, True)));
-            Table.States (192).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 96, 350)));
+            Add_Action (Table.States (189), 105, 347);
+            Table.States (189).Kernel := To_Vector (((265, 14, 4, False), 
(266, 14, 4, False)));
+            Table.States (189).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 105, 347)));
+            Table.States (190).Action_List.Set_Capacity (1);
+            Add_Action (Table.States (190), 105, 348);
+            Table.States (190).Kernel := To_Vector (((272, 69, 7, False), 
(272, 69, 4, False)));
+            Table.States (190).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 105, 348)));
+            Table.States (191).Action_List.Set_Capacity (2);
+            Add_Action (Table.States (191), 35, Reduce, (123, 1), 0, null, 
null);
+            Add_Action (Table.States (191), 74, 338);
+            Table.States (191).Goto_List.Set_Capacity (1);
+            Add_Goto (Table.States (191), 123, 349);
+            Table.States (191).Kernel := To_Vector (((305, 105, 6, False), 
(305, 105, 3, False)));
+            Table.States (191).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 123, 0)));
+            Table.States (192).Action_List.Set_Capacity (47);
+            Add_Action (Table.States (192), (4, 5, 13, 15, 17, 18, 22, 23, 24, 
25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
+            40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 
68, 69, 71, 72, 73, 74, 79, 94, 105, 106,
+            107, 108), (277, 2), 2, raise_statement_2'Access, null);
+            Table.States (192).Kernel := To_Vector ((0 => (277, 97, 0, 
False)));
+            Table.States (192).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 277, 2)));
             Table.States (193).Action_List.Set_Capacity (6);
-            Add_Action (Table.States (193), 74, 351);
-            Add_Action (Table.States (193), 76, 235);
-            Add_Action (Table.States (193), 84, 237);
-            Add_Action (Table.States (193), 96, 352);
-            Add_Action (Table.States (193), 101, 239);
+            Add_Action (Table.States (193), 74, 350);
+            Add_Action (Table.States (193), 76, 236);
+            Add_Action (Table.States (193), 85, 238);
+            Add_Action (Table.States (193), 97, 351);
             Add_Action (Table.States (193), 102, 240);
+            Add_Action (Table.States (193), 103, 241);
             Table.States (193).Goto_List.Set_Capacity (2);
-            Add_Goto (Table.States (193), 115, 241);
-            Add_Goto (Table.States (193), 322, 242);
-            Table.States (193).Kernel := To_Vector (((128, 239, 2, True), 
(239, 239, 5, True), (239, 239, 2, True),
-            (272, 239, 3, True), (290, 239, 3, False), (290, 239, 1, False), 
(293, 239, 2, True), (293, 239, 2, True),
-            (293, 239, 2, True), (293, 239, 2, True)));
-            Table.States (193).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 96, 352)));
-            Table.States (194).Action_List.Set_Capacity (25);
-            Add_Action (Table.States (194), 10, Reduce, (239, 5), 1, 
name_5'Access, name_5_check'Access);
-            Add_Action (Table.States (194), 33, Reduce, (239, 5), 1, 
name_5'Access, name_5_check'Access);
-            Add_Action (Table.States (194), 38, Reduce, (239, 5), 1, 
name_5'Access, name_5_check'Access);
-            Add_Action (Table.States (194), 40, Reduce, (239, 5), 1, 
name_5'Access, name_5_check'Access);
-            Add_Action (Table.States (194), 43, Reduce, (239, 5), 1, 
name_5'Access, name_5_check'Access);
-            Add_Action (Table.States (194), 55, Reduce, (239, 5), 1, 
name_5'Access, name_5_check'Access);
-            Add_Action (Table.States (194), 75, Reduce, (239, 5), 1, 
name_5'Access, name_5_check'Access);
-            Add_Action (Table.States (194), 76, Reduce, (239, 5), 1, 
name_5'Access, name_5_check'Access);
-            Add_Action (Table.States (194), 78, Reduce, (239, 5), 1, 
name_5'Access, name_5_check'Access);
-            Add_Action (Table.States (194), 81, 353);
-            Add_Action (Table.States (194), 84, Reduce, (239, 5), 1, 
name_5'Access, name_5_check'Access);
-            Add_Action (Table.States (194), 86, Reduce, (239, 5), 1, 
name_5'Access, name_5_check'Access);
-            Add_Action (Table.States (194), 88, Reduce, (239, 5), 1, 
name_5'Access, name_5_check'Access);
-            Add_Action (Table.States (194), 89, Reduce, (239, 5), 1, 
name_5'Access, name_5_check'Access);
-            Add_Action (Table.States (194), 91, Reduce, (239, 5), 1, 
name_5'Access, name_5_check'Access);
-            Add_Action (Table.States (194), 92, Reduce, (239, 5), 1, 
name_5'Access, name_5_check'Access);
-            Add_Action (Table.States (194), 94, Reduce, (239, 5), 1, 
name_5'Access, name_5_check'Access);
-            Add_Action (Table.States (194), 95, Reduce, (239, 5), 1, 
name_5'Access, name_5_check'Access);
-            Add_Action (Table.States (194), 96, Reduce, (239, 5), 1, 
name_5'Access, name_5_check'Access);
-            Add_Action (Table.States (194), 97, Reduce, (239, 5), 1, 
name_5'Access, name_5_check'Access);
-            Add_Action (Table.States (194), 98, Reduce, (239, 5), 1, 
name_5'Access, name_5_check'Access);
-            Add_Action (Table.States (194), 99, Reduce, (239, 5), 1, 
name_5'Access, name_5_check'Access);
-            Add_Action (Table.States (194), 100, Reduce, (239, 5), 1, 
name_5'Access, name_5_check'Access);
-            Add_Action (Table.States (194), 101, Reduce, (239, 5), 1, 
name_5'Access, name_5_check'Access);
-            Add_Action (Table.States (194), 102, Reduce, (239, 5), 1, 
name_5'Access, name_5_check'Access);
-            Table.States (194).Kernel := To_Vector (((194, 104, 3, False), 
(194, 104, 2, False), (239, 104, 0,
+            Add_Goto (Table.States (193), 116, 242);
+            Add_Goto (Table.States (193), 323, 243);
+            Table.States (193).Kernel := To_Vector (((129, 240, 2, True), 
(240, 240, 5, True), (240, 240, 2, True),
+            (273, 240, 3, True), (277, 240, 2, False), (277, 240, 1, False), 
(294, 240, 2, True), (294, 240, 2, True),
+            (294, 240, 2, True), (294, 240, 2, True)));
+            Table.States (193).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 97, 351)));
+            Table.States (194).Action_List.Set_Capacity (6);
+            Add_Action (Table.States (194), 74, 352);
+            Add_Action (Table.States (194), 76, 236);
+            Add_Action (Table.States (194), 85, 238);
+            Add_Action (Table.States (194), 97, 353);
+            Add_Action (Table.States (194), 102, 240);
+            Add_Action (Table.States (194), 103, 241);
+            Table.States (194).Goto_List.Set_Capacity (2);
+            Add_Goto (Table.States (194), 116, 242);
+            Add_Goto (Table.States (194), 323, 243);
+            Table.States (194).Kernel := To_Vector (((129, 240, 2, True), 
(240, 240, 5, True), (240, 240, 2, True),
+            (273, 240, 3, True), (291, 240, 3, False), (291, 240, 1, False), 
(294, 240, 2, True), (294, 240, 2, True),
+            (294, 240, 2, True), (294, 240, 2, True)));
+            Table.States (194).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 97, 353)));
+            Table.States (195).Action_List.Set_Capacity (25);
+            Add_Action (Table.States (195), 10, Reduce, (240, 5), 1, 
name_5'Access, name_5_check'Access);
+            Add_Action (Table.States (195), 33, Reduce, (240, 5), 1, 
name_5'Access, name_5_check'Access);
+            Add_Action (Table.States (195), 38, Reduce, (240, 5), 1, 
name_5'Access, name_5_check'Access);
+            Add_Action (Table.States (195), 40, Reduce, (240, 5), 1, 
name_5'Access, name_5_check'Access);
+            Add_Action (Table.States (195), 43, Reduce, (240, 5), 1, 
name_5'Access, name_5_check'Access);
+            Add_Action (Table.States (195), 55, Reduce, (240, 5), 1, 
name_5'Access, name_5_check'Access);
+            Add_Action (Table.States (195), 75, Reduce, (240, 5), 1, 
name_5'Access, name_5_check'Access);
+            Add_Action (Table.States (195), 76, Reduce, (240, 5), 1, 
name_5'Access, name_5_check'Access);
+            Add_Action (Table.States (195), 78, Reduce, (240, 5), 1, 
name_5'Access, name_5_check'Access);
+            Add_Action (Table.States (195), 82, 354);
+            Add_Action (Table.States (195), 85, Reduce, (240, 5), 1, 
name_5'Access, name_5_check'Access);
+            Add_Action (Table.States (195), 87, Reduce, (240, 5), 1, 
name_5'Access, name_5_check'Access);
+            Add_Action (Table.States (195), 89, Reduce, (240, 5), 1, 
name_5'Access, name_5_check'Access);
+            Add_Action (Table.States (195), 90, Reduce, (240, 5), 1, 
name_5'Access, name_5_check'Access);
+            Add_Action (Table.States (195), 92, Reduce, (240, 5), 1, 
name_5'Access, name_5_check'Access);
+            Add_Action (Table.States (195), 93, Reduce, (240, 5), 1, 
name_5'Access, name_5_check'Access);
+            Add_Action (Table.States (195), 95, Reduce, (240, 5), 1, 
name_5'Access, name_5_check'Access);
+            Add_Action (Table.States (195), 96, Reduce, (240, 5), 1, 
name_5'Access, name_5_check'Access);
+            Add_Action (Table.States (195), 97, Reduce, (240, 5), 1, 
name_5'Access, name_5_check'Access);
+            Add_Action (Table.States (195), 98, Reduce, (240, 5), 1, 
name_5'Access, name_5_check'Access);
+            Add_Action (Table.States (195), 99, Reduce, (240, 5), 1, 
name_5'Access, name_5_check'Access);
+            Add_Action (Table.States (195), 100, Reduce, (240, 5), 1, 
name_5'Access, name_5_check'Access);
+            Add_Action (Table.States (195), 101, Reduce, (240, 5), 1, 
name_5'Access, name_5_check'Access);
+            Add_Action (Table.States (195), 102, Reduce, (240, 5), 1, 
name_5'Access, name_5_check'Access);
+            Add_Action (Table.States (195), 103, Reduce, (240, 5), 1, 
name_5'Access, name_5_check'Access);
+            Table.States (195).Kernel := To_Vector (((195, 105, 3, False), 
(195, 105, 2, False), (240, 105, 0,
             False)));
-            Table.States (194).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 239, 1)));
-            Table.States (195).Action_List.Set_Capacity (1);
-            Add_Action (Table.States (195), 96, 354);
-            Table.States (195).Kernel := To_Vector ((0 => (302, 192, 1, 
False)));
-            Table.States (195).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 96, 354)));
-            Table.States (196).Action_List.Set_Capacity (2);
-            Add_Action (Table.States (196), 21, Reduce, (195, 0), 1, null, 
null);
-            Add_Action (Table.States (196), 96, 355);
-            Table.States (196).Kernel := To_Vector (((195, 194, 0, False), 
(196, 194, 1, False)));
-            Table.States (196).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 195, 1)));
-            Table.States (197).Action_List.Set_Capacity (1);
-            Add_Action (Table.States (197), 21, 356);
-            Table.States (197).Kernel := To_Vector ((0 => (196, 195, 4, 
False)));
-            Table.States (197).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 21, 356)));
-            Table.States (198).Action_List.Set_Capacity (3);
-            Add_Action (Table.States (198), 104, 119);
-            Add_Action (Table.States (198), 105, 33);
-            Add_Action (Table.States (198), 106, 34);
-            Table.States (198).Goto_List.Set_Capacity (4);
-            Add_Goto (Table.States (198), 128, 41);
-            Add_Goto (Table.States (198), 239, 357);
-            Add_Goto (Table.States (198), 272, 92);
-            Add_Goto (Table.States (198), 293, 97);
-            Table.States (198).Kernel := To_Vector ((0 => (315, 76, 8, 
False)));
-            Table.States (198).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 104, 119)));
-            Table.States (199).Action_List.Set_Capacity (1);
-            Add_Action (Table.States (199), 96, 358);
-            Table.States (199).Kernel := To_Vector ((0 => (295, 67, 1, 
False)));
-            Table.States (199).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 96, 358)));
-            Table.States (200).Action_List.Set_Capacity (13);
-            Add_Action (Table.States (200), 3, 121);
-            Add_Action (Table.States (200), 39, 122);
-            Add_Action (Table.States (200), 40, 123);
-            Add_Action (Table.States (200), 41, 124);
-            Add_Action (Table.States (200), 52, 125);
-            Add_Action (Table.States (200), 76, 126);
-            Add_Action (Table.States (200), 87, Reduce, (192, 1), 0, null, 
null);
-            Add_Action (Table.States (200), 94, 127);
-            Add_Action (Table.States (200), 95, 128);
-            Add_Action (Table.States (200), 103, 129);
-            Add_Action (Table.States (200), 104, 119);
-            Add_Action (Table.States (200), 105, 33);
-            Add_Action (Table.States (200), 106, 34);
-            Table.States (200).Goto_List.Set_Capacity (20);
-            Add_Goto (Table.States (200), 117, 130);
-            Add_Goto (Table.States (200), 128, 41);
-            Add_Goto (Table.States (200), 191, 131);
-            Add_Goto (Table.States (200), 192, 359);
-            Add_Goto (Table.States (200), 197, 133);
-            Add_Goto (Table.States (200), 239, 134);
-            Add_Goto (Table.States (200), 258, 135);
-            Add_Goto (Table.States (200), 272, 92);
-            Add_Goto (Table.States (200), 275, 136);
-            Add_Goto (Table.States (200), 282, 137);
-            Add_Goto (Table.States (200), 283, 138);
-            Add_Goto (Table.States (200), 284, 139);
-            Add_Goto (Table.States (200), 285, 140);
-            Add_Goto (Table.States (200), 286, 141);
-            Add_Goto (Table.States (200), 287, 142);
-            Add_Goto (Table.States (200), 293, 97);
-            Add_Goto (Table.States (200), 301, 143);
-            Add_Goto (Table.States (200), 320, 144);
-            Add_Goto (Table.States (200), 321, 145);
-            Add_Goto (Table.States (200), 330, 146);
-            Table.States (200).Kernel := To_Vector (((295, 72, 4, False), 
(295, 72, 3, False), (295, 72, 3, False)));
-            Table.States (200).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 192, 0)));
+            Table.States (195).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 240, 1)));
          end Subr_3;
          procedure Subr_4
          is begin
-            Table.States (201).Action_List.Set_Capacity (25);
-            Add_Action (Table.States (201), 4, 1);
-            Add_Action (Table.States (201), 5, 2);
-            Add_Action (Table.States (201), 13, Reduce, (132, 1), 0, null, 
null);
-            Add_Action (Table.States (201), 15, 3);
-            Add_Action (Table.States (201), 17, Reduce, (132, 1), 0, null, 
null);
-            Add_Action (Table.States (201), 18, 4);
-            Add_Action (Table.States (201), 22, Reduce, (300, 1), 0, null, 
null);
-            Add_Action (Table.States (201), 24, Reduce, (300, 1), 0, null, 
null);
-            Add_Action (Table.States (201), 27, 5);
-            Add_Action (Table.States (201), 28, Reduce, (132, 1), 0, null, 
null);
-            Add_Action (Table.States (201), 31, 9);
-            Add_Action (Table.States (201), 32, 10);
-            Add_Action (Table.States (201), 37, Reduce, (132, 1), 0, null, 
null);
-            Add_Action (Table.States (201), 41, 13);
-            Add_Action (Table.States (201), 43, Reduce, (300, 1), 0, null, 
null);
-            Add_Action (Table.States (201), 48, 16);
-            Add_Action (Table.States (201), 52, 20);
-            Add_Action (Table.States (201), 57, 21);
-            Add_Action (Table.States (201), 58, 22);
-            Add_Action (Table.States (201), 61, 24);
-            Add_Action (Table.States (201), 73, Reduce, (132, 1), 0, null, 
null);
-            Add_Action (Table.States (201), 93, 31);
-            Add_Action (Table.States (201), 104, 360);
-            Add_Action (Table.States (201), 105, 33);
+            Table.States (196).Action_List.Set_Capacity (1);
+            Add_Action (Table.States (196), 97, 355);
+            Table.States (196).Kernel := To_Vector ((0 => (303, 193, 1, 
False)));
+            Table.States (196).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 97, 355)));
+            Table.States (197).Action_List.Set_Capacity (2);
+            Add_Action (Table.States (197), 21, Reduce, (196, 0), 1, null, 
null);
+            Add_Action (Table.States (197), 97, 356);
+            Table.States (197).Kernel := To_Vector (((196, 195, 0, False), 
(197, 195, 1, False)));
+            Table.States (197).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 196, 1)));
+            Table.States (198).Action_List.Set_Capacity (1);
+            Add_Action (Table.States (198), 21, 357);
+            Table.States (198).Kernel := To_Vector ((0 => (197, 196, 4, 
False)));
+            Table.States (198).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 21, 357)));
+            Table.States (199).Action_List.Set_Capacity (4);
+            Add_Action (Table.States (199), 79, 31);
+            Add_Action (Table.States (199), 105, 120);
+            Add_Action (Table.States (199), 106, 34);
+            Add_Action (Table.States (199), 107, 35);
+            Table.States (199).Goto_List.Set_Capacity (4);
+            Add_Goto (Table.States (199), 129, 42);
+            Add_Goto (Table.States (199), 240, 358);
+            Add_Goto (Table.States (199), 273, 93);
+            Add_Goto (Table.States (199), 294, 98);
+            Table.States (199).Kernel := To_Vector ((0 => (316, 76, 8, 
False)));
+            Table.States (199).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 105, 120)));
+            Table.States (200).Action_List.Set_Capacity (1);
+            Add_Action (Table.States (200), 97, 359);
+            Table.States (200).Kernel := To_Vector ((0 => (296, 67, 1, 
False)));
+            Table.States (200).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 97, 359)));
+            Table.States (201).Action_List.Set_Capacity (14);
+            Add_Action (Table.States (201), 3, 122);
+            Add_Action (Table.States (201), 39, 123);
+            Add_Action (Table.States (201), 40, 124);
+            Add_Action (Table.States (201), 41, 125);
+            Add_Action (Table.States (201), 52, 126);
+            Add_Action (Table.States (201), 76, 127);
+            Add_Action (Table.States (201), 79, 31);
+            Add_Action (Table.States (201), 88, Reduce, (193, 1), 0, null, 
null);
+            Add_Action (Table.States (201), 95, 128);
+            Add_Action (Table.States (201), 96, 129);
+            Add_Action (Table.States (201), 104, 130);
+            Add_Action (Table.States (201), 105, 120);
             Add_Action (Table.States (201), 106, 34);
-            Table.States (201).Goto_List.Set_Capacity (31);
-            Add_Goto (Table.States (201), 113, 36);
-            Add_Goto (Table.States (201), 123, 38);
-            Add_Goto (Table.States (201), 126, 39);
-            Add_Goto (Table.States (201), 128, 41);
-            Add_Goto (Table.States (201), 131, 42);
-            Add_Goto (Table.States (201), 132, 43);
-            Add_Goto (Table.States (201), 133, 44);
-            Add_Goto (Table.States (201), 139, 47);
-            Add_Goto (Table.States (201), 151, 50);
-            Add_Goto (Table.States (201), 152, 51);
-            Add_Goto (Table.States (201), 161, 53);
-            Add_Goto (Table.States (201), 190, 57);
-            Add_Goto (Table.States (201), 196, 59);
-            Add_Goto (Table.States (201), 217, 68);
-            Add_Goto (Table.States (201), 222, 70);
-            Add_Goto (Table.States (201), 232, 72);
-            Add_Goto (Table.States (201), 239, 73);
-            Add_Goto (Table.States (201), 257, 83);
-            Add_Goto (Table.States (201), 261, 86);
-            Add_Goto (Table.States (201), 272, 92);
-            Add_Goto (Table.States (201), 276, 93);
-            Add_Goto (Table.States (201), 290, 96);
-            Add_Goto (Table.States (201), 293, 97);
+            Add_Action (Table.States (201), 107, 35);
+            Table.States (201).Goto_List.Set_Capacity (20);
+            Add_Goto (Table.States (201), 118, 131);
+            Add_Goto (Table.States (201), 129, 42);
+            Add_Goto (Table.States (201), 192, 132);
+            Add_Goto (Table.States (201), 193, 360);
+            Add_Goto (Table.States (201), 198, 134);
+            Add_Goto (Table.States (201), 240, 135);
+            Add_Goto (Table.States (201), 259, 136);
+            Add_Goto (Table.States (201), 273, 93);
+            Add_Goto (Table.States (201), 276, 137);
+            Add_Goto (Table.States (201), 283, 138);
+            Add_Goto (Table.States (201), 284, 139);
+            Add_Goto (Table.States (201), 285, 140);
+            Add_Goto (Table.States (201), 286, 141);
+            Add_Goto (Table.States (201), 287, 142);
+            Add_Goto (Table.States (201), 288, 143);
             Add_Goto (Table.States (201), 294, 98);
-            Add_Goto (Table.States (201), 298, 99);
-            Add_Goto (Table.States (201), 299, 361);
-            Add_Goto (Table.States (201), 300, 362);
-            Add_Goto (Table.States (201), 302, 100);
-            Add_Goto (Table.States (201), 303, 101);
-            Add_Goto (Table.States (201), 306, 363);
-            Add_Goto (Table.States (201), 323, 114);
-            Table.States (201).Kernel := To_Vector ((0 => (295, 113, 0, 
False)));
-            Table.States (201).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 300, 0)));
-            Table.States (202).Action_List.Set_Capacity (3);
-            Add_Action (Table.States (202), (22, 24, 43), (295, 5), 1, null, 
null);
-            Table.States (202).Kernel := To_Vector ((0 => (295, 160, 0, 
False)));
-            Table.States (202).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 295, 1)));
-            Table.States (203).Action_List.Set_Capacity (26);
-            Add_Action (Table.States (203), 4, 1);
-            Add_Action (Table.States (203), 5, 2);
-            Add_Action (Table.States (203), 13, Reduce, (132, 1), 0, null, 
null);
-            Add_Action (Table.States (203), 15, 3);
-            Add_Action (Table.States (203), 17, Reduce, (132, 1), 0, null, 
null);
-            Add_Action (Table.States (203), 18, 4);
-            Add_Action (Table.States (203), 22, Reduce, (300, 1), 0, null, 
null);
-            Add_Action (Table.States (203), 24, Reduce, (300, 1), 0, null, 
null);
-            Add_Action (Table.States (203), 27, 5);
-            Add_Action (Table.States (203), 28, Reduce, (132, 1), 0, null, 
null);
-            Add_Action (Table.States (203), 31, 9);
-            Add_Action (Table.States (203), 32, 10);
-            Add_Action (Table.States (203), 37, Reduce, (132, 1), 0, null, 
null);
-            Add_Action (Table.States (203), 41, 13);
-            Add_Action (Table.States (203), 43, Reduce, (300, 1), 0, null, 
null);
-            Add_Action (Table.States (203), 48, 16);
-            Add_Action (Table.States (203), 52, 20);
-            Add_Action (Table.States (203), 57, 21);
-            Add_Action (Table.States (203), 58, 22);
-            Add_Action (Table.States (203), 61, 24);
-            Add_Action (Table.States (203), 68, Reduce, (300, 1), 0, null, 
null);
-            Add_Action (Table.States (203), 73, Reduce, (132, 1), 0, null, 
null);
-            Add_Action (Table.States (203), 93, 31);
-            Add_Action (Table.States (203), 104, 360);
-            Add_Action (Table.States (203), 105, 33);
-            Add_Action (Table.States (203), 106, 34);
-            Table.States (203).Goto_List.Set_Capacity (31);
-            Add_Goto (Table.States (203), 113, 36);
-            Add_Goto (Table.States (203), 123, 38);
-            Add_Goto (Table.States (203), 126, 39);
-            Add_Goto (Table.States (203), 128, 41);
-            Add_Goto (Table.States (203), 131, 42);
-            Add_Goto (Table.States (203), 132, 43);
-            Add_Goto (Table.States (203), 133, 44);
-            Add_Goto (Table.States (203), 139, 47);
-            Add_Goto (Table.States (203), 151, 50);
-            Add_Goto (Table.States (203), 152, 51);
-            Add_Goto (Table.States (203), 161, 53);
-            Add_Goto (Table.States (203), 190, 57);
-            Add_Goto (Table.States (203), 196, 59);
-            Add_Goto (Table.States (203), 217, 68);
-            Add_Goto (Table.States (203), 222, 70);
-            Add_Goto (Table.States (203), 232, 72);
-            Add_Goto (Table.States (203), 239, 73);
-            Add_Goto (Table.States (203), 257, 83);
-            Add_Goto (Table.States (203), 261, 86);
-            Add_Goto (Table.States (203), 272, 92);
-            Add_Goto (Table.States (203), 276, 93);
-            Add_Goto (Table.States (203), 290, 96);
-            Add_Goto (Table.States (203), 293, 97);
-            Add_Goto (Table.States (203), 294, 98);
-            Add_Goto (Table.States (203), 298, 99);
-            Add_Goto (Table.States (203), 299, 361);
-            Add_Goto (Table.States (203), 300, 364);
-            Add_Goto (Table.States (203), 302, 100);
-            Add_Goto (Table.States (203), 303, 101);
-            Add_Goto (Table.States (203), 306, 363);
-            Add_Goto (Table.States (203), 323, 114);
-            Table.States (203).Kernel := To_Vector (((160, 161, 0, False), 
(324, 161, 0, False)));
-            Table.States (203).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 300, 0)));
-            Table.States (204).Action_List.Set_Capacity (2);
-            Add_Action (Table.States (204), 22, 365);
-            Add_Action (Table.States (204), 43, 366);
-            Table.States (204).Kernel := To_Vector (((152, 178, 4, False), 
(323, 178, 6, False)));
-            Table.States (204).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 22, 365)));
-            Table.States (205).Action_List.Set_Capacity (30);
-            Add_Action (Table.States (205), 4, 1);
-            Add_Action (Table.States (205), 5, 2);
-            Add_Action (Table.States (205), 13, Reduce, (132, 1), 0, null, 
null);
-            Add_Action (Table.States (205), 15, 3);
-            Add_Action (Table.States (205), 17, Reduce, (132, 1), 0, null, 
null);
-            Add_Action (Table.States (205), 18, 4);
-            Add_Action (Table.States (205), 22, Reduce, (300, 1), 0, null, 
null);
-            Add_Action (Table.States (205), 27, 5);
-            Add_Action (Table.States (205), 28, Reduce, (132, 1), 0, null, 
null);
-            Add_Action (Table.States (205), 31, 9);
-            Add_Action (Table.States (205), 32, 10);
-            Add_Action (Table.States (205), 37, Reduce, (132, 1), 0, null, 
null);
-            Add_Action (Table.States (205), 41, 13);
-            Add_Action (Table.States (205), 43, Reduce, (300, 1), 0, null, 
null);
-            Add_Action (Table.States (205), 48, 16);
-            Add_Action (Table.States (205), 52, 20);
-            Add_Action (Table.States (205), 57, 21);
-            Add_Action (Table.States (205), 58, 22);
-            Add_Action (Table.States (205), 61, 24);
-            Add_Action (Table.States (205), 68, Reduce, (300, 1), 0, null, 
null);
-            Add_Action (Table.States (205), 73, Reduce, (132, 1), 0, null, 
null);
-            Add_Action (Table.States (205), 76, 235);
-            Add_Action (Table.States (205), 84, 237);
-            Add_Action (Table.States (205), 93, 31);
-            Add_Action (Table.States (205), 96, 238);
-            Add_Action (Table.States (205), 101, 239);
-            Add_Action (Table.States (205), 102, 240);
-            Add_Action (Table.States (205), 104, 360);
-            Add_Action (Table.States (205), 105, 33);
-            Add_Action (Table.States (205), 106, 34);
-            Table.States (205).Goto_List.Set_Capacity (33);
-            Add_Goto (Table.States (205), 113, 36);
-            Add_Goto (Table.States (205), 115, 241);
-            Add_Goto (Table.States (205), 123, 38);
-            Add_Goto (Table.States (205), 126, 39);
-            Add_Goto (Table.States (205), 128, 41);
-            Add_Goto (Table.States (205), 131, 42);
-            Add_Goto (Table.States (205), 132, 43);
-            Add_Goto (Table.States (205), 133, 44);
-            Add_Goto (Table.States (205), 139, 47);
-            Add_Goto (Table.States (205), 151, 50);
-            Add_Goto (Table.States (205), 152, 51);
-            Add_Goto (Table.States (205), 161, 53);
-            Add_Goto (Table.States (205), 190, 57);
-            Add_Goto (Table.States (205), 196, 59);
-            Add_Goto (Table.States (205), 217, 68);
-            Add_Goto (Table.States (205), 222, 70);
-            Add_Goto (Table.States (205), 232, 72);
-            Add_Goto (Table.States (205), 239, 73);
-            Add_Goto (Table.States (205), 257, 83);
-            Add_Goto (Table.States (205), 261, 86);
-            Add_Goto (Table.States (205), 272, 92);
-            Add_Goto (Table.States (205), 276, 93);
-            Add_Goto (Table.States (205), 290, 96);
-            Add_Goto (Table.States (205), 293, 97);
-            Add_Goto (Table.States (205), 294, 98);
-            Add_Goto (Table.States (205), 298, 99);
-            Add_Goto (Table.States (205), 299, 361);
-            Add_Goto (Table.States (205), 300, 367);
-            Add_Goto (Table.States (205), 302, 100);
-            Add_Goto (Table.States (205), 303, 101);
-            Add_Goto (Table.States (205), 306, 363);
-            Add_Goto (Table.States (205), 322, 242);
-            Add_Goto (Table.States (205), 323, 114);
-            Table.States (205).Kernel := To_Vector (((128, 239, 2, True), 
(178, 239, 0, False), (239, 239, 5, True),
-            (239, 239, 2, True), (261, 239, 1, False), (272, 239, 3, True), 
(293, 239, 2, True), (293, 239, 2, True),
-            (293, 239, 2, True), (293, 239, 2, True), (324, 239, 0, False)));
-            Table.States (205).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 300, 0)));
-            Table.States (206).Action_List.Set_Capacity (25);
+            Add_Goto (Table.States (201), 302, 144);
+            Add_Goto (Table.States (201), 321, 145);
+            Add_Goto (Table.States (201), 322, 146);
+            Add_Goto (Table.States (201), 331, 147);
+            Table.States (201).Kernel := To_Vector (((296, 72, 4, False), 
(296, 72, 3, False), (296, 72, 3, False)));
+            Table.States (201).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 193, 0)));
+            Table.States (202).Action_List.Set_Capacity (26);
+            Add_Action (Table.States (202), 4, 1);
+            Add_Action (Table.States (202), 5, 2);
+            Add_Action (Table.States (202), 13, Reduce, (133, 1), 0, null, 
null);
+            Add_Action (Table.States (202), 15, 3);
+            Add_Action (Table.States (202), 17, Reduce, (133, 1), 0, null, 
null);
+            Add_Action (Table.States (202), 18, 4);
+            Add_Action (Table.States (202), 22, Reduce, (301, 1), 0, null, 
null);
+            Add_Action (Table.States (202), 24, Reduce, (301, 1), 0, null, 
null);
+            Add_Action (Table.States (202), 27, 5);
+            Add_Action (Table.States (202), 28, Reduce, (133, 1), 0, null, 
null);
+            Add_Action (Table.States (202), 31, 9);
+            Add_Action (Table.States (202), 32, 10);
+            Add_Action (Table.States (202), 37, Reduce, (133, 1), 0, null, 
null);
+            Add_Action (Table.States (202), 41, 13);
+            Add_Action (Table.States (202), 43, Reduce, (301, 1), 0, null, 
null);
+            Add_Action (Table.States (202), 48, 16);
+            Add_Action (Table.States (202), 52, 20);
+            Add_Action (Table.States (202), 57, 21);
+            Add_Action (Table.States (202), 58, 22);
+            Add_Action (Table.States (202), 61, 24);
+            Add_Action (Table.States (202), 73, Reduce, (133, 1), 0, null, 
null);
+            Add_Action (Table.States (202), 79, 31);
+            Add_Action (Table.States (202), 94, 32);
+            Add_Action (Table.States (202), 105, 361);
+            Add_Action (Table.States (202), 106, 34);
+            Add_Action (Table.States (202), 107, 35);
+            Table.States (202).Goto_List.Set_Capacity (31);
+            Add_Goto (Table.States (202), 114, 37);
+            Add_Goto (Table.States (202), 124, 39);
+            Add_Goto (Table.States (202), 127, 40);
+            Add_Goto (Table.States (202), 129, 42);
+            Add_Goto (Table.States (202), 132, 43);
+            Add_Goto (Table.States (202), 133, 44);
+            Add_Goto (Table.States (202), 134, 45);
+            Add_Goto (Table.States (202), 140, 48);
+            Add_Goto (Table.States (202), 152, 51);
+            Add_Goto (Table.States (202), 153, 52);
+            Add_Goto (Table.States (202), 162, 54);
+            Add_Goto (Table.States (202), 191, 58);
+            Add_Goto (Table.States (202), 197, 60);
+            Add_Goto (Table.States (202), 218, 69);
+            Add_Goto (Table.States (202), 223, 71);
+            Add_Goto (Table.States (202), 233, 73);
+            Add_Goto (Table.States (202), 240, 74);
+            Add_Goto (Table.States (202), 258, 84);
+            Add_Goto (Table.States (202), 262, 87);
+            Add_Goto (Table.States (202), 273, 93);
+            Add_Goto (Table.States (202), 277, 94);
+            Add_Goto (Table.States (202), 291, 97);
+            Add_Goto (Table.States (202), 294, 98);
+            Add_Goto (Table.States (202), 295, 99);
+            Add_Goto (Table.States (202), 299, 100);
+            Add_Goto (Table.States (202), 300, 362);
+            Add_Goto (Table.States (202), 301, 363);
+            Add_Goto (Table.States (202), 303, 101);
+            Add_Goto (Table.States (202), 304, 102);
+            Add_Goto (Table.States (202), 307, 364);
+            Add_Goto (Table.States (202), 324, 115);
+            Table.States (202).Kernel := To_Vector ((0 => (296, 114, 0, 
False)));
+            Table.States (202).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 301, 0)));
+            Table.States (203).Action_List.Set_Capacity (3);
+            Add_Action (Table.States (203), (22, 24, 43), (296, 5), 1, null, 
null);
+            Table.States (203).Kernel := To_Vector ((0 => (296, 161, 0, 
False)));
+            Table.States (203).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 296, 1)));
+            Table.States (204).Action_List.Set_Capacity (27);
+            Add_Action (Table.States (204), 4, 1);
+            Add_Action (Table.States (204), 5, 2);
+            Add_Action (Table.States (204), 13, Reduce, (133, 1), 0, null, 
null);
+            Add_Action (Table.States (204), 15, 3);
+            Add_Action (Table.States (204), 17, Reduce, (133, 1), 0, null, 
null);
+            Add_Action (Table.States (204), 18, 4);
+            Add_Action (Table.States (204), 22, Reduce, (301, 1), 0, null, 
null);
+            Add_Action (Table.States (204), 24, Reduce, (301, 1), 0, null, 
null);
+            Add_Action (Table.States (204), 27, 5);
+            Add_Action (Table.States (204), 28, Reduce, (133, 1), 0, null, 
null);
+            Add_Action (Table.States (204), 31, 9);
+            Add_Action (Table.States (204), 32, 10);
+            Add_Action (Table.States (204), 37, Reduce, (133, 1), 0, null, 
null);
+            Add_Action (Table.States (204), 41, 13);
+            Add_Action (Table.States (204), 43, Reduce, (301, 1), 0, null, 
null);
+            Add_Action (Table.States (204), 48, 16);
+            Add_Action (Table.States (204), 52, 20);
+            Add_Action (Table.States (204), 57, 21);
+            Add_Action (Table.States (204), 58, 22);
+            Add_Action (Table.States (204), 61, 24);
+            Add_Action (Table.States (204), 68, Reduce, (301, 1), 0, null, 
null);
+            Add_Action (Table.States (204), 73, Reduce, (133, 1), 0, null, 
null);
+            Add_Action (Table.States (204), 79, 31);
+            Add_Action (Table.States (204), 94, 32);
+            Add_Action (Table.States (204), 105, 361);
+            Add_Action (Table.States (204), 106, 34);
+            Add_Action (Table.States (204), 107, 35);
+            Table.States (204).Goto_List.Set_Capacity (31);
+            Add_Goto (Table.States (204), 114, 37);
+            Add_Goto (Table.States (204), 124, 39);
+            Add_Goto (Table.States (204), 127, 40);
+            Add_Goto (Table.States (204), 129, 42);
+            Add_Goto (Table.States (204), 132, 43);
+            Add_Goto (Table.States (204), 133, 44);
+            Add_Goto (Table.States (204), 134, 45);
+            Add_Goto (Table.States (204), 140, 48);
+            Add_Goto (Table.States (204), 152, 51);
+            Add_Goto (Table.States (204), 153, 52);
+            Add_Goto (Table.States (204), 162, 54);
+            Add_Goto (Table.States (204), 191, 58);
+            Add_Goto (Table.States (204), 197, 60);
+            Add_Goto (Table.States (204), 218, 69);
+            Add_Goto (Table.States (204), 223, 71);
+            Add_Goto (Table.States (204), 233, 73);
+            Add_Goto (Table.States (204), 240, 74);
+            Add_Goto (Table.States (204), 258, 84);
+            Add_Goto (Table.States (204), 262, 87);
+            Add_Goto (Table.States (204), 273, 93);
+            Add_Goto (Table.States (204), 277, 94);
+            Add_Goto (Table.States (204), 291, 97);
+            Add_Goto (Table.States (204), 294, 98);
+            Add_Goto (Table.States (204), 295, 99);
+            Add_Goto (Table.States (204), 299, 100);
+            Add_Goto (Table.States (204), 300, 362);
+            Add_Goto (Table.States (204), 301, 365);
+            Add_Goto (Table.States (204), 303, 101);
+            Add_Goto (Table.States (204), 304, 102);
+            Add_Goto (Table.States (204), 307, 364);
+            Add_Goto (Table.States (204), 324, 115);
+            Table.States (204).Kernel := To_Vector (((161, 162, 0, False), 
(325, 162, 0, False)));
+            Table.States (204).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 301, 0)));
+            Table.States (205).Action_List.Set_Capacity (2);
+            Add_Action (Table.States (205), 22, 366);
+            Add_Action (Table.States (205), 43, 367);
+            Table.States (205).Kernel := To_Vector (((153, 179, 4, False), 
(324, 179, 6, False)));
+            Table.States (205).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 22, 366)));
+            Table.States (206).Action_List.Set_Capacity (31);
             Add_Action (Table.States (206), 4, 1);
             Add_Action (Table.States (206), 5, 2);
-            Add_Action (Table.States (206), 13, Reduce, (132, 1), 0, null, 
null);
+            Add_Action (Table.States (206), 13, Reduce, (133, 1), 0, null, 
null);
             Add_Action (Table.States (206), 15, 3);
-            Add_Action (Table.States (206), 17, Reduce, (132, 1), 0, null, 
null);
+            Add_Action (Table.States (206), 17, Reduce, (133, 1), 0, null, 
null);
             Add_Action (Table.States (206), 18, 4);
-            Add_Action (Table.States (206), 22, Reduce, (300, 1), 0, null, 
null);
+            Add_Action (Table.States (206), 22, Reduce, (301, 1), 0, null, 
null);
             Add_Action (Table.States (206), 27, 5);
-            Add_Action (Table.States (206), 28, Reduce, (132, 1), 0, null, 
null);
+            Add_Action (Table.States (206), 28, Reduce, (133, 1), 0, null, 
null);
             Add_Action (Table.States (206), 31, 9);
             Add_Action (Table.States (206), 32, 10);
-            Add_Action (Table.States (206), 37, Reduce, (132, 1), 0, null, 
null);
+            Add_Action (Table.States (206), 37, Reduce, (133, 1), 0, null, 
null);
             Add_Action (Table.States (206), 41, 13);
-            Add_Action (Table.States (206), 43, Reduce, (300, 1), 0, null, 
null);
+            Add_Action (Table.States (206), 43, Reduce, (301, 1), 0, null, 
null);
             Add_Action (Table.States (206), 48, 16);
             Add_Action (Table.States (206), 52, 20);
             Add_Action (Table.States (206), 57, 21);
             Add_Action (Table.States (206), 58, 22);
             Add_Action (Table.States (206), 61, 24);
-            Add_Action (Table.States (206), 68, Reduce, (300, 1), 0, null, 
null);
-            Add_Action (Table.States (206), 73, Reduce, (132, 1), 0, null, 
null);
-            Add_Action (Table.States (206), 93, 31);
-            Add_Action (Table.States (206), 104, 360);
-            Add_Action (Table.States (206), 105, 33);
+            Add_Action (Table.States (206), 68, Reduce, (301, 1), 0, null, 
null);
+            Add_Action (Table.States (206), 73, Reduce, (133, 1), 0, null, 
null);
+            Add_Action (Table.States (206), 76, 236);
+            Add_Action (Table.States (206), 79, 31);
+            Add_Action (Table.States (206), 85, 238);
+            Add_Action (Table.States (206), 94, 32);
+            Add_Action (Table.States (206), 97, 239);
+            Add_Action (Table.States (206), 102, 240);
+            Add_Action (Table.States (206), 103, 241);
+            Add_Action (Table.States (206), 105, 361);
             Add_Action (Table.States (206), 106, 34);
-            Table.States (206).Goto_List.Set_Capacity (31);
-            Add_Goto (Table.States (206), 113, 36);
-            Add_Goto (Table.States (206), 123, 38);
-            Add_Goto (Table.States (206), 126, 39);
-            Add_Goto (Table.States (206), 128, 41);
-            Add_Goto (Table.States (206), 131, 42);
+            Add_Action (Table.States (206), 107, 35);
+            Table.States (206).Goto_List.Set_Capacity (33);
+            Add_Goto (Table.States (206), 114, 37);
+            Add_Goto (Table.States (206), 116, 242);
+            Add_Goto (Table.States (206), 124, 39);
+            Add_Goto (Table.States (206), 127, 40);
+            Add_Goto (Table.States (206), 129, 42);
             Add_Goto (Table.States (206), 132, 43);
             Add_Goto (Table.States (206), 133, 44);
-            Add_Goto (Table.States (206), 139, 47);
-            Add_Goto (Table.States (206), 151, 50);
+            Add_Goto (Table.States (206), 134, 45);
+            Add_Goto (Table.States (206), 140, 48);
             Add_Goto (Table.States (206), 152, 51);
-            Add_Goto (Table.States (206), 161, 53);
-            Add_Goto (Table.States (206), 190, 57);
-            Add_Goto (Table.States (206), 196, 59);
-            Add_Goto (Table.States (206), 217, 68);
-            Add_Goto (Table.States (206), 222, 70);
-            Add_Goto (Table.States (206), 232, 72);
-            Add_Goto (Table.States (206), 239, 73);
-            Add_Goto (Table.States (206), 257, 83);
-            Add_Goto (Table.States (206), 261, 86);
-            Add_Goto (Table.States (206), 272, 92);
-            Add_Goto (Table.States (206), 276, 93);
-            Add_Goto (Table.States (206), 290, 96);
-            Add_Goto (Table.States (206), 293, 97);
+            Add_Goto (Table.States (206), 153, 52);
+            Add_Goto (Table.States (206), 162, 54);
+            Add_Goto (Table.States (206), 191, 58);
+            Add_Goto (Table.States (206), 197, 60);
+            Add_Goto (Table.States (206), 218, 69);
+            Add_Goto (Table.States (206), 223, 71);
+            Add_Goto (Table.States (206), 233, 73);
+            Add_Goto (Table.States (206), 240, 74);
+            Add_Goto (Table.States (206), 258, 84);
+            Add_Goto (Table.States (206), 262, 87);
+            Add_Goto (Table.States (206), 273, 93);
+            Add_Goto (Table.States (206), 277, 94);
+            Add_Goto (Table.States (206), 291, 97);
             Add_Goto (Table.States (206), 294, 98);
-            Add_Goto (Table.States (206), 298, 99);
-            Add_Goto (Table.States (206), 299, 361);
-            Add_Goto (Table.States (206), 300, 368);
-            Add_Goto (Table.States (206), 302, 100);
+            Add_Goto (Table.States (206), 295, 99);
+            Add_Goto (Table.States (206), 299, 100);
+            Add_Goto (Table.States (206), 300, 362);
+            Add_Goto (Table.States (206), 301, 368);
             Add_Goto (Table.States (206), 303, 101);
-            Add_Goto (Table.States (206), 306, 363);
-            Add_Goto (Table.States (206), 323, 114);
-            Table.States (206).Kernel := To_Vector (((178, 261, 0, False), 
(324, 261, 0, False)));
-            Table.States (206).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 300, 0)));
-            Table.States (207).Action_List.Set_Capacity (3);
-            Add_Action (Table.States (207), (22, 24, 43), (296, 1), 1, 
select_alternative_list_1'Access, null);
-            Table.States (207).Kernel := To_Vector ((0 => (296, 295, 0, 
False)));
-            Table.States (207).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 296, 1)));
+            Add_Goto (Table.States (206), 304, 102);
+            Add_Goto (Table.States (206), 307, 364);
+            Add_Goto (Table.States (206), 323, 243);
+            Add_Goto (Table.States (206), 324, 115);
+            Table.States (206).Kernel := To_Vector (((129, 240, 2, True), 
(179, 240, 0, False), (240, 240, 5, True),
+            (240, 240, 2, True), (262, 240, 1, False), (273, 240, 3, True), 
(294, 240, 2, True), (294, 240, 2, True),
+            (294, 240, 2, True), (294, 240, 2, True), (325, 240, 0, False)));
+            Table.States (206).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 301, 0)));
+            Table.States (207).Action_List.Set_Capacity (26);
+            Add_Action (Table.States (207), 4, 1);
+            Add_Action (Table.States (207), 5, 2);
+            Add_Action (Table.States (207), 13, Reduce, (133, 1), 0, null, 
null);
+            Add_Action (Table.States (207), 15, 3);
+            Add_Action (Table.States (207), 17, Reduce, (133, 1), 0, null, 
null);
+            Add_Action (Table.States (207), 18, 4);
+            Add_Action (Table.States (207), 22, Reduce, (301, 1), 0, null, 
null);
+            Add_Action (Table.States (207), 27, 5);
+            Add_Action (Table.States (207), 28, Reduce, (133, 1), 0, null, 
null);
+            Add_Action (Table.States (207), 31, 9);
+            Add_Action (Table.States (207), 32, 10);
+            Add_Action (Table.States (207), 37, Reduce, (133, 1), 0, null, 
null);
+            Add_Action (Table.States (207), 41, 13);
+            Add_Action (Table.States (207), 43, Reduce, (301, 1), 0, null, 
null);
+            Add_Action (Table.States (207), 48, 16);
+            Add_Action (Table.States (207), 52, 20);
+            Add_Action (Table.States (207), 57, 21);
+            Add_Action (Table.States (207), 58, 22);
+            Add_Action (Table.States (207), 61, 24);
+            Add_Action (Table.States (207), 68, Reduce, (301, 1), 0, null, 
null);
+            Add_Action (Table.States (207), 73, Reduce, (133, 1), 0, null, 
null);
+            Add_Action (Table.States (207), 79, 31);
+            Add_Action (Table.States (207), 94, 32);
+            Add_Action (Table.States (207), 105, 361);
+            Add_Action (Table.States (207), 106, 34);
+            Add_Action (Table.States (207), 107, 35);
+            Table.States (207).Goto_List.Set_Capacity (31);
+            Add_Goto (Table.States (207), 114, 37);
+            Add_Goto (Table.States (207), 124, 39);
+            Add_Goto (Table.States (207), 127, 40);
+            Add_Goto (Table.States (207), 129, 42);
+            Add_Goto (Table.States (207), 132, 43);
+            Add_Goto (Table.States (207), 133, 44);
+            Add_Goto (Table.States (207), 134, 45);
+            Add_Goto (Table.States (207), 140, 48);
+            Add_Goto (Table.States (207), 152, 51);
+            Add_Goto (Table.States (207), 153, 52);
+            Add_Goto (Table.States (207), 162, 54);
+            Add_Goto (Table.States (207), 191, 58);
+            Add_Goto (Table.States (207), 197, 60);
+            Add_Goto (Table.States (207), 218, 69);
+            Add_Goto (Table.States (207), 223, 71);
+            Add_Goto (Table.States (207), 233, 73);
+            Add_Goto (Table.States (207), 240, 74);
+            Add_Goto (Table.States (207), 258, 84);
+            Add_Goto (Table.States (207), 262, 87);
+            Add_Goto (Table.States (207), 273, 93);
+            Add_Goto (Table.States (207), 277, 94);
+            Add_Goto (Table.States (207), 291, 97);
+            Add_Goto (Table.States (207), 294, 98);
+            Add_Goto (Table.States (207), 295, 99);
+            Add_Goto (Table.States (207), 299, 100);
+            Add_Goto (Table.States (207), 300, 362);
+            Add_Goto (Table.States (207), 301, 369);
+            Add_Goto (Table.States (207), 303, 101);
+            Add_Goto (Table.States (207), 304, 102);
+            Add_Goto (Table.States (207), 307, 364);
+            Add_Goto (Table.States (207), 324, 115);
+            Table.States (207).Kernel := To_Vector (((179, 262, 0, False), 
(325, 262, 0, False)));
+            Table.States (207).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 301, 0)));
             Table.States (208).Action_List.Set_Capacity (3);
-            Add_Action (Table.States (208), 22, Reduce, (297, 0), 1, null, 
null);
-            Add_Action (Table.States (208), 24, Reduce, (297, 0), 1, null, 
null);
-            Add_Action (Table.States (208), 43, 369);
-            Table.States (208).Kernel := To_Vector (((296, 296, 3, True), 
(297, 296, 0, False)));
+            Add_Action (Table.States (208), (22, 24, 43), (297, 1), 1, 
select_alternative_list_1'Access, null);
+            Table.States (208).Kernel := To_Vector ((0 => (297, 296, 0, 
False)));
             Table.States (208).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 297, 1)));
-            Table.States (209).Action_List.Set_Capacity (2);
-            Add_Action (Table.States (209), 22, 370);
-            Add_Action (Table.States (209), 24, 371);
-            Table.States (209).Kernel := To_Vector (((294, 297, 4, False), 
(294, 297, 3, False)));
-            Table.States (209).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 24, 371)));
-            Table.States (210).Action_List.Set_Capacity (1);
-            Add_Action (Table.States (210), 68, 372);
-            Table.States (210).Kernel := To_Vector ((0 => (126, 324, 5, 
False)));
-            Table.States (210).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 68, 372)));
+            Table.States (209).Action_List.Set_Capacity (3);
+            Add_Action (Table.States (209), 22, Reduce, (298, 0), 1, null, 
null);
+            Add_Action (Table.States (209), 24, Reduce, (298, 0), 1, null, 
null);
+            Add_Action (Table.States (209), 43, 370);
+            Table.States (209).Kernel := To_Vector (((297, 297, 3, True), 
(298, 297, 0, False)));
+            Table.States (209).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 298, 1)));
+            Table.States (210).Action_List.Set_Capacity (2);
+            Add_Action (Table.States (210), 22, 371);
+            Add_Action (Table.States (210), 24, 372);
+            Table.States (210).Kernel := To_Vector (((295, 298, 4, False), 
(295, 298, 3, False)));
+            Table.States (210).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 24, 372)));
             Table.States (211).Action_List.Set_Capacity (1);
-            Add_Action (Table.States (211), 35, 373);
-            Table.States (211).Kernel := To_Vector ((0 => (313, 104, 3, 
False)));
-            Table.States (211).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 35, 373)));
+            Add_Action (Table.States (211), 68, 373);
+            Table.States (211).Kernel := To_Vector ((0 => (127, 325, 5, 
False)));
+            Table.States (211).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 68, 373)));
             Table.States (212).Action_List.Set_Capacity (1);
-            Add_Action (Table.States (212), 104, 374);
-            Table.States (212).Kernel := To_Vector (((316, 14, 5, False), 
(317, 14, 4, False)));
-            Table.States (212).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 104, 374)));
+            Add_Action (Table.States (212), 35, 374);
+            Table.States (212).Kernel := To_Vector ((0 => (314, 105, 3, 
False)));
+            Table.States (212).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 35, 374)));
             Table.States (213).Action_List.Set_Capacity (1);
-            Add_Action (Table.States (213), 104, 375);
-            Table.States (213).Kernel := To_Vector (((319, 69, 7, False), 
(319, 69, 4, False), (319, 69, 2, False)));
-            Table.States (213).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 104, 375)));
-            Table.States (214).Action_List.Set_Capacity (3);
-            Add_Action (Table.States (214), 35, Reduce, (122, 1), 0, null, 
null);
-            Add_Action (Table.States (214), 74, 337);
-            Add_Action (Table.States (214), 96, Reduce, (122, 1), 0, null, 
null);
-            Table.States (214).Goto_List.Set_Capacity (1);
-            Add_Goto (Table.States (214), 122, 376);
-            Table.States (214).Kernel := To_Vector (((305, 104, 6, False), 
(305, 104, 3, False), (305, 104, 1,
-            False)));
-            Table.States (214).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 122, 0)));
+            Add_Action (Table.States (213), 105, 375);
+            Table.States (213).Kernel := To_Vector (((317, 14, 5, False), 
(318, 14, 4, False)));
+            Table.States (213).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 105, 375)));
+            Table.States (214).Action_List.Set_Capacity (1);
+            Add_Action (Table.States (214), 105, 376);
+            Table.States (214).Kernel := To_Vector (((320, 69, 7, False), 
(320, 69, 4, False), (320, 69, 2, False)));
+            Table.States (214).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 105, 376)));
             Table.States (215).Action_List.Set_Capacity (3);
-            Add_Action (Table.States (215), 35, Reduce, (169, 2), 0, null, 
null);
-            Add_Action (Table.States (215), 76, 377);
-            Add_Action (Table.States (215), 96, Reduce, (169, 2), 0, null, 
null);
+            Add_Action (Table.States (215), 35, Reduce, (123, 1), 0, null, 
null);
+            Add_Action (Table.States (215), 74, 338);
+            Add_Action (Table.States (215), 97, Reduce, (123, 1), 0, null, 
null);
             Table.States (215).Goto_List.Set_Capacity (1);
-            Add_Goto (Table.States (215), 169, 378);
-            Table.States (215).Kernel := To_Vector (((206, 104, 3, False), 
(223, 104, 3, False), (223, 104, 1, False),
-            (259, 104, 6, False), (260, 104, 3, False)));
-            Table.States (215).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 169, 0)));
-            Table.States (216).Action_List.Set_Capacity (1);
-            Add_Action (Table.States (216), 69, 379);
-            Table.States (216).Kernel := To_Vector ((0 => (331, 9, 3, False)));
-            Table.States (216).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 69, 379)));
-            Table.States (217).Action_List.Set_Capacity (3);
-            Add_Action (Table.States (217), 104, 119);
-            Add_Action (Table.States (217), 105, 33);
-            Add_Action (Table.States (217), 106, 34);
-            Table.States (217).Goto_List.Set_Capacity (5);
-            Add_Goto (Table.States (217), 128, 41);
-            Add_Goto (Table.States (217), 238, 380);
-            Add_Goto (Table.States (217), 239, 219);
-            Add_Goto (Table.States (217), 272, 92);
-            Add_Goto (Table.States (217), 293, 97);
-            Table.States (217).Kernel := To_Vector ((0 => (331, 69, 2, 
False)));
-            Table.States (217).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 104, 119)));
-            Table.States (218).Action_List.Set_Capacity (2);
-            Add_Action (Table.States (218), 83, 381);
-            Add_Action (Table.States (218), 96, 382);
-            Table.States (218).Kernel := To_Vector (((238, 238, 2, True), 
(331, 238, 1, False)));
-            Table.States (218).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 96, 382)));
-            Table.States (219).Action_List.Set_Capacity (6);
-            Add_Action (Table.States (219), 76, 235);
-            Add_Action (Table.States (219), 83, Reduce, (238, 1), 1, null, 
null);
-            Add_Action (Table.States (219), 84, 237);
-            Add_Action (Table.States (219), 96, Reduce, (238, 1), 1, null, 
null);
-            Add_Action (Table.States (219), 101, 239);
-            Add_Action (Table.States (219), 102, 240);
-            Table.States (219).Goto_List.Set_Capacity (2);
-            Add_Goto (Table.States (219), 115, 241);
-            Add_Goto (Table.States (219), 322, 242);
-            Table.States (219).Kernel := To_Vector (((128, 239, 2, True), 
(238, 239, 0, False), (239, 239, 5, True),
-            (239, 239, 2, True), (272, 239, 3, True), (293, 239, 2, True), 
(293, 239, 2, True), (293, 239, 2, True),
-            (293, 239, 2, True)));
-            Table.States (219).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 238, 1)));
-            Table.States (220).Action_List.Set_Capacity (1);
-            Add_Action (Table.States (220), (1 =>  37), (229, 0), 2, 
iteration_scheme_0'Access, null);
-            Table.States (220).Kernel := To_Vector ((0 => (229, 192, 0, 
False)));
-            Table.States (220).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 229, 2)));
-            Table.States (221).Action_List.Set_Capacity (2);
-            Add_Action (Table.States (221), 83, 381);
-            Add_Action (Table.States (221), 96, 383);
-            Table.States (221).Kernel := To_Vector (((238, 238, 2, True), 
(332, 238, 1, False)));
-            Table.States (221).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 96, 383)));
-            Table.States (222).Action_List.Set_Capacity (1);
-            Add_Action (Table.States (222), 90, 384);
-            Table.States (222).Kernel := To_Vector ((0 => (217, 104, 1, 
False)));
-            Table.States (222).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 90, 384)));
-            Table.States (223).Action_List.Set_Capacity (11);
-            Add_Action (Table.States (223), 7, Reduce, (241, 1), 0, null, 
null);
-            Add_Action (Table.States (223), 13, Reduce, (131, 0), 2, 
block_label_0'Access, block_label_0_check'Access);
-            Add_Action (Table.States (223), 17, Reduce, (131, 0), 2, 
block_label_0'Access, block_label_0_check'Access);
-            Add_Action (Table.States (223), 26, 385);
-            Add_Action (Table.States (223), 28, Reduce, (131, 0), 2, 
block_label_0'Access, block_label_0_check'Access);
-            Add_Action (Table.States (223), 37, Reduce, (131, 0), 2, 
block_label_0'Access, block_label_0_check'Access);
-            Add_Action (Table.States (223), 40, 386);
-            Add_Action (Table.States (223), 73, Reduce, (131, 0), 2, 
block_label_0'Access, block_label_0_check'Access);
-            Add_Action (Table.States (223), 104, Reduce, (241, 1), 0, null, 
null);
-            Add_Action (Table.States (223), 105, Reduce, (241, 1), 0, null, 
null);
-            Add_Action (Table.States (223), 106, Reduce, (241, 1), 0, null, 
null);
-            Table.States (223).Goto_List.Set_Capacity (2);
-            Add_Goto (Table.States (223), 114, 387);
-            Add_Goto (Table.States (223), 241, 388);
-            Table.States (223).Kernel := To_Vector (((131, 81, 0, False), 
(245, 81, 4, False), (245, 81, 5, False),
-            (245, 81, 4, False)));
-            Table.States (223).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 131, 2)));
-            Table.States (224).Action_List.Set_Capacity (24);
-            Add_Action (Table.States (224), 4, 1);
-            Add_Action (Table.States (224), 5, 2);
-            Add_Action (Table.States (224), 13, Reduce, (132, 1), 0, null, 
null);
-            Add_Action (Table.States (224), 15, 3);
-            Add_Action (Table.States (224), 17, Reduce, (132, 1), 0, null, 
null);
-            Add_Action (Table.States (224), 18, 4);
-            Add_Action (Table.States (224), 24, Reduce, (300, 1), 0, null, 
null);
-            Add_Action (Table.States (224), 26, Reduce, (300, 1), 0, null, 
null);
-            Add_Action (Table.States (224), 27, 5);
-            Add_Action (Table.States (224), 28, Reduce, (132, 1), 0, null, 
null);
-            Add_Action (Table.States (224), 31, 9);
-            Add_Action (Table.States (224), 32, 10);
-            Add_Action (Table.States (224), 37, Reduce, (132, 1), 0, null, 
null);
-            Add_Action (Table.States (224), 41, 13);
-            Add_Action (Table.States (224), 48, 16);
-            Add_Action (Table.States (224), 52, 20);
-            Add_Action (Table.States (224), 57, 21);
-            Add_Action (Table.States (224), 58, 22);
-            Add_Action (Table.States (224), 61, 24);
-            Add_Action (Table.States (224), 73, Reduce, (132, 1), 0, null, 
null);
-            Add_Action (Table.States (224), 93, 31);
-            Add_Action (Table.States (224), 104, 360);
-            Add_Action (Table.States (224), 105, 33);
-            Add_Action (Table.States (224), 106, 34);
-            Table.States (224).Goto_List.Set_Capacity (32);
-            Add_Goto (Table.States (224), 113, 36);
-            Add_Goto (Table.States (224), 123, 38);
-            Add_Goto (Table.States (224), 126, 39);
-            Add_Goto (Table.States (224), 128, 41);
-            Add_Goto (Table.States (224), 131, 42);
-            Add_Goto (Table.States (224), 132, 43);
-            Add_Goto (Table.States (224), 133, 44);
-            Add_Goto (Table.States (224), 139, 47);
-            Add_Goto (Table.States (224), 151, 50);
-            Add_Goto (Table.States (224), 152, 51);
-            Add_Goto (Table.States (224), 161, 53);
-            Add_Goto (Table.States (224), 190, 57);
-            Add_Goto (Table.States (224), 196, 59);
-            Add_Goto (Table.States (224), 217, 68);
-            Add_Goto (Table.States (224), 218, 389);
-            Add_Goto (Table.States (224), 222, 70);
-            Add_Goto (Table.States (224), 232, 72);
-            Add_Goto (Table.States (224), 239, 73);
-            Add_Goto (Table.States (224), 257, 83);
-            Add_Goto (Table.States (224), 261, 86);
-            Add_Goto (Table.States (224), 272, 92);
-            Add_Goto (Table.States (224), 276, 93);
-            Add_Goto (Table.States (224), 290, 96);
-            Add_Goto (Table.States (224), 293, 97);
-            Add_Goto (Table.States (224), 294, 98);
-            Add_Goto (Table.States (224), 298, 99);
-            Add_Goto (Table.States (224), 299, 361);
-            Add_Goto (Table.States (224), 300, 390);
-            Add_Goto (Table.States (224), 302, 100);
-            Add_Goto (Table.States (224), 303, 101);
-            Add_Goto (Table.States (224), 306, 363);
-            Add_Goto (Table.States (224), 323, 114);
-            Table.States (224).Kernel := To_Vector ((0 => (133, 13, 2, 
False)));
-            Table.States (224).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 218, 0)));
-            Table.States (225).Action_List.Set_Capacity (16);
-            Add_Action (Table.States (225), 13, Reduce, (159, 1), 0, null, 
null);
-            Add_Action (Table.States (225), 25, Reduce, (246, 2), 0, null, 
null);
-            Add_Action (Table.States (225), 28, 183);
-            Add_Action (Table.States (225), 29, Reduce, (246, 2), 0, null, 
null);
-            Add_Action (Table.States (225), 30, 8);
-            Add_Action (Table.States (225), 40, 12);
-            Add_Action (Table.States (225), 46, 14);
-            Add_Action (Table.States (225), 47, 15);
+            Add_Goto (Table.States (215), 123, 377);
+            Table.States (215).Kernel := To_Vector (((306, 105, 6, False), 
(306, 105, 3, False), (306, 105, 1,
+            False)));
+            Table.States (215).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 123, 0)));
+            Table.States (216).Action_List.Set_Capacity (3);
+            Add_Action (Table.States (216), 35, Reduce, (170, 2), 0, null, 
null);
+            Add_Action (Table.States (216), 76, 378);
+            Add_Action (Table.States (216), 97, Reduce, (170, 2), 0, null, 
null);
+            Table.States (216).Goto_List.Set_Capacity (1);
+            Add_Goto (Table.States (216), 170, 379);
+            Table.States (216).Kernel := To_Vector (((207, 105, 3, False), 
(224, 105, 3, False), (224, 105, 1, False),
+            (260, 105, 6, False), (261, 105, 3, False)));
+            Table.States (216).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 170, 0)));
+            Table.States (217).Action_List.Set_Capacity (1);
+            Add_Action (Table.States (217), 69, 380);
+            Table.States (217).Kernel := To_Vector ((0 => (332, 9, 3, False)));
+            Table.States (217).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 69, 380)));
+            Table.States (218).Action_List.Set_Capacity (4);
+            Add_Action (Table.States (218), 79, 31);
+            Add_Action (Table.States (218), 105, 120);
+            Add_Action (Table.States (218), 106, 34);
+            Add_Action (Table.States (218), 107, 35);
+            Table.States (218).Goto_List.Set_Capacity (5);
+            Add_Goto (Table.States (218), 129, 42);
+            Add_Goto (Table.States (218), 239, 381);
+            Add_Goto (Table.States (218), 240, 220);
+            Add_Goto (Table.States (218), 273, 93);
+            Add_Goto (Table.States (218), 294, 98);
+            Table.States (218).Kernel := To_Vector ((0 => (332, 69, 2, 
False)));
+            Table.States (218).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 105, 120)));
+            Table.States (219).Action_List.Set_Capacity (2);
+            Add_Action (Table.States (219), 84, 382);
+            Add_Action (Table.States (219), 97, 383);
+            Table.States (219).Kernel := To_Vector (((239, 239, 2, True), 
(332, 239, 1, False)));
+            Table.States (219).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 97, 383)));
+            Table.States (220).Action_List.Set_Capacity (6);
+            Add_Action (Table.States (220), 76, 236);
+            Add_Action (Table.States (220), 84, Reduce, (239, 1), 1, null, 
null);
+            Add_Action (Table.States (220), 85, 238);
+            Add_Action (Table.States (220), 97, Reduce, (239, 1), 1, null, 
null);
+            Add_Action (Table.States (220), 102, 240);
+            Add_Action (Table.States (220), 103, 241);
+            Table.States (220).Goto_List.Set_Capacity (2);
+            Add_Goto (Table.States (220), 116, 242);
+            Add_Goto (Table.States (220), 323, 243);
+            Table.States (220).Kernel := To_Vector (((129, 240, 2, True), 
(239, 240, 0, False), (240, 240, 5, True),
+            (240, 240, 2, True), (273, 240, 3, True), (294, 240, 2, True), 
(294, 240, 2, True), (294, 240, 2, True),
+            (294, 240, 2, True)));
+            Table.States (220).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 239, 1)));
+            Table.States (221).Action_List.Set_Capacity (1);
+            Add_Action (Table.States (221), (1 =>  37), (230, 0), 2, 
iteration_scheme_0'Access, null);
+            Table.States (221).Kernel := To_Vector ((0 => (230, 193, 0, 
False)));
+            Table.States (221).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 230, 2)));
+            Table.States (222).Action_List.Set_Capacity (2);
+            Add_Action (Table.States (222), 84, 382);
+            Add_Action (Table.States (222), 97, 384);
+            Table.States (222).Kernel := To_Vector (((239, 239, 2, True), 
(333, 239, 1, False)));
+            Table.States (222).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 97, 384)));
+            Table.States (223).Action_List.Set_Capacity (1);
+            Add_Action (Table.States (223), 91, 385);
+            Table.States (223).Kernel := To_Vector ((0 => (218, 105, 1, 
False)));
+            Table.States (223).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 91, 385)));
+            Table.States (224).Action_List.Set_Capacity (12);
+            Add_Action (Table.States (224), 7, Reduce, (242, 1), 0, null, 
null);
+            Add_Action (Table.States (224), 13, Reduce, (132, 0), 2, 
block_label_0'Access, block_label_0_check'Access);
+            Add_Action (Table.States (224), 17, Reduce, (132, 0), 2, 
block_label_0'Access, block_label_0_check'Access);
+            Add_Action (Table.States (224), 26, 386);
+            Add_Action (Table.States (224), 28, Reduce, (132, 0), 2, 
block_label_0'Access, block_label_0_check'Access);
+            Add_Action (Table.States (224), 37, Reduce, (132, 0), 2, 
block_label_0'Access, block_label_0_check'Access);
+            Add_Action (Table.States (224), 40, 387);
+            Add_Action (Table.States (224), 73, Reduce, (132, 0), 2, 
block_label_0'Access, block_label_0_check'Access);
+            Add_Action (Table.States (224), 79, Reduce, (242, 1), 0, null, 
null);
+            Add_Action (Table.States (224), 105, Reduce, (242, 1), 0, null, 
null);
+            Add_Action (Table.States (224), 106, Reduce, (242, 1), 0, null, 
null);
+            Add_Action (Table.States (224), 107, Reduce, (242, 1), 0, null, 
null);
+            Table.States (224).Goto_List.Set_Capacity (2);
+            Add_Goto (Table.States (224), 115, 388);
+            Add_Goto (Table.States (224), 242, 389);
+            Table.States (224).Kernel := To_Vector (((132, 82, 0, False), 
(246, 82, 4, False), (246, 82, 5, False),
+            (246, 82, 4, False)));
+            Table.States (224).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 132, 2)));
+            Table.States (225).Action_List.Set_Capacity (25);
+            Add_Action (Table.States (225), 4, 1);
+            Add_Action (Table.States (225), 5, 2);
+            Add_Action (Table.States (225), 13, Reduce, (133, 1), 0, null, 
null);
+            Add_Action (Table.States (225), 15, 3);
+            Add_Action (Table.States (225), 17, Reduce, (133, 1), 0, null, 
null);
+            Add_Action (Table.States (225), 18, 4);
+            Add_Action (Table.States (225), 24, Reduce, (301, 1), 0, null, 
null);
+            Add_Action (Table.States (225), 26, Reduce, (301, 1), 0, null, 
null);
+            Add_Action (Table.States (225), 27, 5);
+            Add_Action (Table.States (225), 28, Reduce, (133, 1), 0, null, 
null);
+            Add_Action (Table.States (225), 31, 9);
+            Add_Action (Table.States (225), 32, 10);
+            Add_Action (Table.States (225), 37, Reduce, (133, 1), 0, null, 
null);
+            Add_Action (Table.States (225), 41, 13);
             Add_Action (Table.States (225), 48, 16);
-            Add_Action (Table.States (225), 50, Reduce, (246, 2), 0, null, 
null);
-            Add_Action (Table.States (225), 51, 19);
-            Add_Action (Table.States (225), 63, 25);
-            Add_Action (Table.States (225), 66, 26);
-            Add_Action (Table.States (225), 69, 27);
-            Add_Action (Table.States (225), 71, 28);
-            Add_Action (Table.States (225), 104, 185);
-            Table.States (225).Goto_List.Set_Capacity (53);
-            Add_Goto (Table.States (225), 112, 35);
-            Add_Goto (Table.States (225), 121, 37);
+            Add_Action (Table.States (225), 52, 20);
+            Add_Action (Table.States (225), 57, 21);
+            Add_Action (Table.States (225), 58, 22);
+            Add_Action (Table.States (225), 61, 24);
+            Add_Action (Table.States (225), 73, Reduce, (133, 1), 0, null, 
null);
+            Add_Action (Table.States (225), 79, 31);
+            Add_Action (Table.States (225), 94, 32);
+            Add_Action (Table.States (225), 105, 361);
+            Add_Action (Table.States (225), 106, 34);
+            Add_Action (Table.States (225), 107, 35);
+            Table.States (225).Goto_List.Set_Capacity (32);
+            Add_Goto (Table.States (225), 114, 37);
+            Add_Goto (Table.States (225), 124, 39);
             Add_Goto (Table.States (225), 127, 40);
+            Add_Goto (Table.States (225), 129, 42);
+            Add_Goto (Table.States (225), 132, 43);
+            Add_Goto (Table.States (225), 133, 44);
             Add_Goto (Table.States (225), 134, 45);
-            Add_Goto (Table.States (225), 135, 46);
-            Add_Goto (Table.States (225), 157, 391);
-            Add_Goto (Table.States (225), 158, 392);
-            Add_Goto (Table.States (225), 159, 393);
-            Add_Goto (Table.States (225), 179, 54);
-            Add_Goto (Table.States (225), 182, 55);
-            Add_Goto (Table.States (225), 186, 56);
-            Add_Goto (Table.States (225), 193, 58);
-            Add_Goto (Table.States (225), 206, 60);
-            Add_Goto (Table.States (225), 207, 61);
-            Add_Goto (Table.States (225), 209, 62);
-            Add_Goto (Table.States (225), 210, 63);
-            Add_Goto (Table.States (225), 213, 64);
-            Add_Goto (Table.States (225), 214, 65);
-            Add_Goto (Table.States (225), 215, 66);
-            Add_Goto (Table.States (225), 216, 67);
-            Add_Goto (Table.States (225), 219, 69);
+            Add_Goto (Table.States (225), 140, 48);
+            Add_Goto (Table.States (225), 152, 51);
+            Add_Goto (Table.States (225), 153, 52);
+            Add_Goto (Table.States (225), 162, 54);
+            Add_Goto (Table.States (225), 191, 58);
+            Add_Goto (Table.States (225), 197, 60);
+            Add_Goto (Table.States (225), 218, 69);
+            Add_Goto (Table.States (225), 219, 390);
             Add_Goto (Table.States (225), 223, 71);
-            Add_Goto (Table.States (225), 243, 74);
-            Add_Goto (Table.States (225), 244, 75);
-            Add_Goto (Table.States (225), 245, 76);
-            Add_Goto (Table.States (225), 246, 77);
-            Add_Goto (Table.States (225), 247, 78);
-            Add_Goto (Table.States (225), 248, 79);
-            Add_Goto (Table.States (225), 249, 80);
-            Add_Goto (Table.States (225), 250, 81);
-            Add_Goto (Table.States (225), 251, 82);
-            Add_Goto (Table.States (225), 257, 394);
-            Add_Goto (Table.States (225), 259, 84);
-            Add_Goto (Table.States (225), 260, 85);
+            Add_Goto (Table.States (225), 233, 73);
+            Add_Goto (Table.States (225), 240, 74);
+            Add_Goto (Table.States (225), 258, 84);
             Add_Goto (Table.States (225), 262, 87);
-            Add_Goto (Table.States (225), 263, 88);
-            Add_Goto (Table.States (225), 264, 89);
-            Add_Goto (Table.States (225), 265, 90);
-            Add_Goto (Table.States (225), 271, 91);
-            Add_Goto (Table.States (225), 281, 94);
-            Add_Goto (Table.States (225), 289, 95);
+            Add_Goto (Table.States (225), 273, 93);
+            Add_Goto (Table.States (225), 277, 94);
+            Add_Goto (Table.States (225), 291, 97);
+            Add_Goto (Table.States (225), 294, 98);
+            Add_Goto (Table.States (225), 295, 99);
+            Add_Goto (Table.States (225), 299, 100);
+            Add_Goto (Table.States (225), 300, 362);
+            Add_Goto (Table.States (225), 301, 391);
+            Add_Goto (Table.States (225), 303, 101);
             Add_Goto (Table.States (225), 304, 102);
-            Add_Goto (Table.States (225), 305, 103);
-            Add_Goto (Table.States (225), 307, 105);
-            Add_Goto (Table.States (225), 308, 106);
-            Add_Goto (Table.States (225), 309, 107);
-            Add_Goto (Table.States (225), 311, 108);
-            Add_Goto (Table.States (225), 313, 109);
-            Add_Goto (Table.States (225), 316, 111);
-            Add_Goto (Table.States (225), 317, 112);
-            Add_Goto (Table.States (225), 319, 113);
-            Add_Goto (Table.States (225), 325, 115);
-            Add_Goto (Table.States (225), 331, 116);
-            Table.States (225).Kernel := To_Vector ((0 => (133, 17, 3, 
False)));
-            Table.States (225).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 159, 0)));
-            Table.States (226).Action_List.Set_Capacity (2);
-            Add_Action (Table.States (226), 37, Reduce, (231, 1), 0, null, 
null);
-            Add_Action (Table.States (226), 104, 395);
-            Table.States (226).Goto_List.Set_Capacity (2);
-            Add_Goto (Table.States (226), 230, 155);
-            Add_Goto (Table.States (226), 231, 156);
-            Table.States (226).Kernel := To_Vector ((0 => (229, 28, 0, 
False)));
-            Table.States (226).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 231, 0)));
-            Table.States (227).Action_List.Set_Capacity (23);
-            Add_Action (Table.States (227), 4, 1);
-            Add_Action (Table.States (227), 5, 2);
-            Add_Action (Table.States (227), 13, Reduce, (132, 1), 0, null, 
null);
-            Add_Action (Table.States (227), 15, 3);
-            Add_Action (Table.States (227), 17, Reduce, (132, 1), 0, null, 
null);
-            Add_Action (Table.States (227), 18, 4);
-            Add_Action (Table.States (227), 24, Reduce, (300, 1), 0, null, 
null);
-            Add_Action (Table.States (227), 27, 5);
-            Add_Action (Table.States (227), 28, Reduce, (132, 1), 0, null, 
null);
-            Add_Action (Table.States (227), 31, 9);
-            Add_Action (Table.States (227), 32, 10);
-            Add_Action (Table.States (227), 37, Reduce, (132, 1), 0, null, 
null);
-            Add_Action (Table.States (227), 41, 13);
-            Add_Action (Table.States (227), 48, 16);
-            Add_Action (Table.States (227), 52, 20);
-            Add_Action (Table.States (227), 57, 21);
-            Add_Action (Table.States (227), 58, 22);
-            Add_Action (Table.States (227), 61, 24);
-            Add_Action (Table.States (227), 73, Reduce, (132, 1), 0, null, 
null);
-            Add_Action (Table.States (227), 93, 31);
-            Add_Action (Table.States (227), 104, 360);
-            Add_Action (Table.States (227), 105, 33);
-            Add_Action (Table.States (227), 106, 34);
-            Table.States (227).Goto_List.Set_Capacity (31);
-            Add_Goto (Table.States (227), 113, 36);
-            Add_Goto (Table.States (227), 123, 38);
-            Add_Goto (Table.States (227), 126, 39);
-            Add_Goto (Table.States (227), 128, 41);
-            Add_Goto (Table.States (227), 131, 42);
-            Add_Goto (Table.States (227), 132, 43);
-            Add_Goto (Table.States (227), 133, 44);
-            Add_Goto (Table.States (227), 139, 47);
-            Add_Goto (Table.States (227), 151, 50);
-            Add_Goto (Table.States (227), 152, 51);
-            Add_Goto (Table.States (227), 161, 53);
-            Add_Goto (Table.States (227), 190, 57);
-            Add_Goto (Table.States (227), 196, 59);
-            Add_Goto (Table.States (227), 217, 68);
-            Add_Goto (Table.States (227), 222, 70);
-            Add_Goto (Table.States (227), 232, 72);
-            Add_Goto (Table.States (227), 239, 73);
-            Add_Goto (Table.States (227), 257, 83);
-            Add_Goto (Table.States (227), 261, 86);
-            Add_Goto (Table.States (227), 272, 92);
-            Add_Goto (Table.States (227), 276, 93);
-            Add_Goto (Table.States (227), 290, 96);
-            Add_Goto (Table.States (227), 293, 97);
-            Add_Goto (Table.States (227), 294, 98);
-            Add_Goto (Table.States (227), 298, 99);
-            Add_Goto (Table.States (227), 299, 361);
-            Add_Goto (Table.States (227), 300, 396);
-            Add_Goto (Table.States (227), 302, 100);
-            Add_Goto (Table.States (227), 303, 101);
-            Add_Goto (Table.States (227), 306, 363);
-            Add_Goto (Table.States (227), 323, 114);
-            Table.States (227).Kernel := To_Vector ((0 => (232, 37, 3, 
False)));
-            Table.States (227).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 300, 0)));
-            Table.States (228).Action_List.Set_Capacity (1);
-            Add_Action (Table.States (228), 37, 397);
-            Table.States (228).Kernel := To_Vector ((0 => (232, 229, 4, 
False)));
-            Table.States (228).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 37, 397)));
-            Table.States (229).Action_List.Set_Capacity (39);
-            Add_Action (Table.States (229), (4, 5, 13, 15, 17, 18, 25, 27, 28, 
29, 30, 31, 32, 36, 37, 40, 41, 46, 47,
-            48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 93, 
104, 105, 106, 107), (143, 0), 2,
+            Add_Goto (Table.States (225), 307, 364);
+            Add_Goto (Table.States (225), 324, 115);
+            Table.States (225).Kernel := To_Vector ((0 => (134, 13, 2, 
False)));
+            Table.States (225).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 219, 0)));
+            Table.States (226).Action_List.Set_Capacity (16);
+            Add_Action (Table.States (226), 13, Reduce, (160, 1), 0, null, 
null);
+            Add_Action (Table.States (226), 25, Reduce, (247, 2), 0, null, 
null);
+            Add_Action (Table.States (226), 28, 184);
+            Add_Action (Table.States (226), 29, Reduce, (247, 2), 0, null, 
null);
+            Add_Action (Table.States (226), 30, 8);
+            Add_Action (Table.States (226), 40, 12);
+            Add_Action (Table.States (226), 46, 14);
+            Add_Action (Table.States (226), 47, 15);
+            Add_Action (Table.States (226), 48, 16);
+            Add_Action (Table.States (226), 50, Reduce, (247, 2), 0, null, 
null);
+            Add_Action (Table.States (226), 51, 19);
+            Add_Action (Table.States (226), 63, 25);
+            Add_Action (Table.States (226), 66, 26);
+            Add_Action (Table.States (226), 69, 27);
+            Add_Action (Table.States (226), 71, 28);
+            Add_Action (Table.States (226), 105, 186);
+            Table.States (226).Goto_List.Set_Capacity (53);
+            Add_Goto (Table.States (226), 113, 36);
+            Add_Goto (Table.States (226), 122, 38);
+            Add_Goto (Table.States (226), 128, 41);
+            Add_Goto (Table.States (226), 135, 46);
+            Add_Goto (Table.States (226), 136, 47);
+            Add_Goto (Table.States (226), 158, 392);
+            Add_Goto (Table.States (226), 159, 393);
+            Add_Goto (Table.States (226), 160, 394);
+            Add_Goto (Table.States (226), 180, 55);
+            Add_Goto (Table.States (226), 183, 56);
+            Add_Goto (Table.States (226), 187, 57);
+            Add_Goto (Table.States (226), 194, 59);
+            Add_Goto (Table.States (226), 207, 61);
+            Add_Goto (Table.States (226), 208, 62);
+            Add_Goto (Table.States (226), 210, 63);
+            Add_Goto (Table.States (226), 211, 64);
+            Add_Goto (Table.States (226), 214, 65);
+            Add_Goto (Table.States (226), 215, 66);
+            Add_Goto (Table.States (226), 216, 67);
+            Add_Goto (Table.States (226), 217, 68);
+            Add_Goto (Table.States (226), 220, 70);
+            Add_Goto (Table.States (226), 224, 72);
+            Add_Goto (Table.States (226), 244, 75);
+            Add_Goto (Table.States (226), 245, 76);
+            Add_Goto (Table.States (226), 246, 77);
+            Add_Goto (Table.States (226), 247, 78);
+            Add_Goto (Table.States (226), 248, 79);
+            Add_Goto (Table.States (226), 249, 80);
+            Add_Goto (Table.States (226), 250, 81);
+            Add_Goto (Table.States (226), 251, 82);
+            Add_Goto (Table.States (226), 252, 83);
+            Add_Goto (Table.States (226), 258, 395);
+            Add_Goto (Table.States (226), 260, 85);
+            Add_Goto (Table.States (226), 261, 86);
+            Add_Goto (Table.States (226), 263, 88);
+            Add_Goto (Table.States (226), 264, 89);
+            Add_Goto (Table.States (226), 265, 90);
+            Add_Goto (Table.States (226), 266, 91);
+            Add_Goto (Table.States (226), 272, 92);
+            Add_Goto (Table.States (226), 282, 95);
+            Add_Goto (Table.States (226), 290, 96);
+            Add_Goto (Table.States (226), 305, 103);
+            Add_Goto (Table.States (226), 306, 104);
+            Add_Goto (Table.States (226), 308, 106);
+            Add_Goto (Table.States (226), 309, 107);
+            Add_Goto (Table.States (226), 310, 108);
+            Add_Goto (Table.States (226), 312, 109);
+            Add_Goto (Table.States (226), 314, 110);
+            Add_Goto (Table.States (226), 317, 112);
+            Add_Goto (Table.States (226), 318, 113);
+            Add_Goto (Table.States (226), 320, 114);
+            Add_Goto (Table.States (226), 326, 116);
+            Add_Goto (Table.States (226), 332, 117);
+            Table.States (226).Kernel := To_Vector ((0 => (134, 17, 3, 
False)));
+            Table.States (226).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 160, 0)));
+            Table.States (227).Action_List.Set_Capacity (2);
+            Add_Action (Table.States (227), 37, Reduce, (232, 1), 0, null, 
null);
+            Add_Action (Table.States (227), 105, 396);
+            Table.States (227).Goto_List.Set_Capacity (2);
+            Add_Goto (Table.States (227), 231, 156);
+            Add_Goto (Table.States (227), 232, 157);
+            Table.States (227).Kernel := To_Vector ((0 => (230, 28, 0, 
False)));
+            Table.States (227).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 232, 0)));
+            Table.States (228).Action_List.Set_Capacity (24);
+            Add_Action (Table.States (228), 4, 1);
+            Add_Action (Table.States (228), 5, 2);
+            Add_Action (Table.States (228), 13, Reduce, (133, 1), 0, null, 
null);
+            Add_Action (Table.States (228), 15, 3);
+            Add_Action (Table.States (228), 17, Reduce, (133, 1), 0, null, 
null);
+            Add_Action (Table.States (228), 18, 4);
+            Add_Action (Table.States (228), 24, Reduce, (301, 1), 0, null, 
null);
+            Add_Action (Table.States (228), 27, 5);
+            Add_Action (Table.States (228), 28, Reduce, (133, 1), 0, null, 
null);
+            Add_Action (Table.States (228), 31, 9);
+            Add_Action (Table.States (228), 32, 10);
+            Add_Action (Table.States (228), 37, Reduce, (133, 1), 0, null, 
null);
+            Add_Action (Table.States (228), 41, 13);
+            Add_Action (Table.States (228), 48, 16);
+            Add_Action (Table.States (228), 52, 20);
+            Add_Action (Table.States (228), 57, 21);
+            Add_Action (Table.States (228), 58, 22);
+            Add_Action (Table.States (228), 61, 24);
+            Add_Action (Table.States (228), 73, Reduce, (133, 1), 0, null, 
null);
+            Add_Action (Table.States (228), 79, 31);
+            Add_Action (Table.States (228), 94, 32);
+            Add_Action (Table.States (228), 105, 361);
+            Add_Action (Table.States (228), 106, 34);
+            Add_Action (Table.States (228), 107, 35);
+            Table.States (228).Goto_List.Set_Capacity (31);
+            Add_Goto (Table.States (228), 114, 37);
+            Add_Goto (Table.States (228), 124, 39);
+            Add_Goto (Table.States (228), 127, 40);
+            Add_Goto (Table.States (228), 129, 42);
+            Add_Goto (Table.States (228), 132, 43);
+            Add_Goto (Table.States (228), 133, 44);
+            Add_Goto (Table.States (228), 134, 45);
+            Add_Goto (Table.States (228), 140, 48);
+            Add_Goto (Table.States (228), 152, 51);
+            Add_Goto (Table.States (228), 153, 52);
+            Add_Goto (Table.States (228), 162, 54);
+            Add_Goto (Table.States (228), 191, 58);
+            Add_Goto (Table.States (228), 197, 60);
+            Add_Goto (Table.States (228), 218, 69);
+            Add_Goto (Table.States (228), 223, 71);
+            Add_Goto (Table.States (228), 233, 73);
+            Add_Goto (Table.States (228), 240, 74);
+            Add_Goto (Table.States (228), 258, 84);
+            Add_Goto (Table.States (228), 262, 87);
+            Add_Goto (Table.States (228), 273, 93);
+            Add_Goto (Table.States (228), 277, 94);
+            Add_Goto (Table.States (228), 291, 97);
+            Add_Goto (Table.States (228), 294, 98);
+            Add_Goto (Table.States (228), 295, 99);
+            Add_Goto (Table.States (228), 299, 100);
+            Add_Goto (Table.States (228), 300, 362);
+            Add_Goto (Table.States (228), 301, 397);
+            Add_Goto (Table.States (228), 303, 101);
+            Add_Goto (Table.States (228), 304, 102);
+            Add_Goto (Table.States (228), 307, 364);
+            Add_Goto (Table.States (228), 324, 115);
+            Table.States (228).Kernel := To_Vector ((0 => (233, 37, 3, 
False)));
+            Table.States (228).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 301, 0)));
+            Table.States (229).Action_List.Set_Capacity (1);
+            Add_Action (Table.States (229), 37, 398);
+            Table.States (229).Kernel := To_Vector ((0 => (233, 230, 4, 
False)));
+            Table.States (229).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 37, 398)));
+            Table.States (230).Action_List.Set_Capacity (40);
+            Add_Action (Table.States (230), (4, 5, 13, 15, 17, 18, 25, 27, 28, 
29, 30, 31, 32, 36, 37, 40, 41, 46, 47,
+            48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 79, 
94, 105, 106, 107, 108), (144, 0), 2,
             compilation_unit_list_0'Access, null);
-            Table.States (229).Kernel := To_Vector ((0 => (143, 142, 0, 
True)));
-            Table.States (229).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 143, 2)));
-            Table.States (229).Minimal_Complete_Actions_Recursive := True;
-            Table.States (230).Action_List.Set_Capacity (3);
-            Add_Action (Table.States (230), 104, 119);
-            Add_Action (Table.States (230), 105, 33);
-            Add_Action (Table.States (230), 106, 34);
-            Table.States (230).Goto_List.Set_Capacity (4);
-            Add_Goto (Table.States (230), 128, 41);
-            Add_Goto (Table.States (230), 239, 398);
-            Add_Goto (Table.States (230), 272, 92);
-            Add_Goto (Table.States (230), 293, 97);
-            Table.States (230).Kernel := To_Vector (((251, 47, 4, False), 
(251, 47, 3, False)));
-            Table.States (230).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 104, 119)));
-            Table.States (231).Action_List.Set_Capacity (1);
-            Add_Action (Table.States (231), 96, 399);
-            Table.States (231).Kernel := To_Vector ((0 => (214, 251, 1, 
False)));
-            Table.States (231).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 96, 399)));
-            Table.States (232).Action_List.Set_Capacity (2);
-            Add_Action (Table.States (232), 74, 337);
-            Add_Action (Table.States (232), 96, Reduce, (122, 1), 0, null, 
null);
-            Table.States (232).Goto_List.Set_Capacity (1);
-            Add_Goto (Table.States (232), 122, 400);
-            Table.States (232).Kernel := To_Vector ((0 => (216, 312, 1, 
False)));
-            Table.States (232).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 122, 0)));
-            Table.States (233).Action_List.Set_Capacity (12);
-            Add_Action (Table.States (233), 7, Reduce, (118, 1), 0, null, 
null);
-            Add_Action (Table.States (233), 8, 401);
-            Add_Action (Table.States (233), 11, Reduce, (118, 1), 0, null, 
null);
-            Add_Action (Table.States (233), 16, 402);
-            Add_Conflict (Table.States (233), 16, (118, 1), 0, null, null);
-            Add_Action (Table.States (233), 26, 403);
-            Add_Action (Table.States (233), 40, Reduce, (118, 1), 0, null, 
null);
-            Add_Action (Table.States (233), 74, Reduce, (118, 1), 0, null, 
null);
-            Add_Action (Table.States (233), 82, Reduce, (118, 1), 0, null, 
null);
-            Add_Action (Table.States (233), 96, Reduce, (118, 1), 0, null, 
null);
-            Add_Action (Table.States (233), 104, Reduce, (118, 1), 0, null, 
null);
-            Add_Action (Table.States (233), 105, Reduce, (118, 1), 0, null, 
null);
-            Add_Action (Table.States (233), 106, Reduce, (118, 1), 0, null, 
null);
+            Table.States (230).Kernel := To_Vector ((0 => (144, 143, 0, 
True)));
+            Table.States (230).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 144, 2)));
+            Table.States (230).Minimal_Complete_Actions_Recursive := True;
+            Table.States (231).Action_List.Set_Capacity (4);
+            Add_Action (Table.States (231), 79, 31);
+            Add_Action (Table.States (231), 105, 120);
+            Add_Action (Table.States (231), 106, 34);
+            Add_Action (Table.States (231), 107, 35);
+            Table.States (231).Goto_List.Set_Capacity (4);
+            Add_Goto (Table.States (231), 129, 42);
+            Add_Goto (Table.States (231), 240, 399);
+            Add_Goto (Table.States (231), 273, 93);
+            Add_Goto (Table.States (231), 294, 98);
+            Table.States (231).Kernel := To_Vector (((252, 47, 4, False), 
(252, 47, 3, False)));
+            Table.States (231).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 105, 120)));
+            Table.States (232).Action_List.Set_Capacity (1);
+            Add_Action (Table.States (232), 97, 400);
+            Table.States (232).Kernel := To_Vector ((0 => (215, 252, 1, 
False)));
+            Table.States (232).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 97, 400)));
+            Table.States (233).Action_List.Set_Capacity (2);
+            Add_Action (Table.States (233), 74, 338);
+            Add_Action (Table.States (233), 97, Reduce, (123, 1), 0, null, 
null);
             Table.States (233).Goto_List.Set_Capacity (1);
-            Add_Goto (Table.States (233), 118, 404);
-            Table.States (233).Kernel := To_Vector (((157, 81, 3, False), 
(186, 81, 2, False), (244, 81, 3, False),
-            (244, 81, 4, False), (244, 81, 10, False), (244, 81, 2, False), 
(244, 81, 3, False), (244, 81, 9, False)));
-            Table.States (233).Minimal_Complete_Actions := To_Vector (((Shift, 
26, 403), (Reduce, 118, 0)));
-            Table.States (234).Action_List.Set_Capacity (1);
-            Add_Action (Table.States (234), 104, 405);
-            Table.States (234).Kernel := To_Vector ((0 => (219, 83, 1, True)));
-            Table.States (234).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 104, 405)));
-            Table.States (234).Minimal_Complete_Actions_Recursive := True;
-            Table.States (235).Action_List.Set_Capacity (20);
-            Add_Action (Table.States (235), 3, 121);
-            Add_Action (Table.States (235), 15, 258);
-            Add_Action (Table.States (235), 28, 259);
-            Add_Action (Table.States (235), 32, 260);
-            Add_Action (Table.States (235), 39, 122);
-            Add_Action (Table.States (235), 40, 261);
-            Add_Action (Table.States (235), 41, 124);
-            Add_Action (Table.States (235), 44, 263);
-            Add_Action (Table.States (235), 52, 125);
-            Add_Action (Table.States (235), 76, 126);
-            Add_Action (Table.States (235), 77, Reduce, (124, 5), 0, null, 
null);
-            Add_Action (Table.States (235), 79, Reduce, (166, 2), 0, null, 
null);
-            Add_Action (Table.States (235), 83, Reduce, (124, 5), 0, null, 
null);
-            Add_Action (Table.States (235), 87, Reduce, (166, 2), 0, null, 
null);
-            Add_Action (Table.States (235), 94, 127);
-            Add_Action (Table.States (235), 95, 128);
-            Add_Action (Table.States (235), 103, 129);
-            Add_Action (Table.States (235), 104, 119);
-            Add_Action (Table.States (235), 105, 33);
-            Add_Action (Table.States (235), 106, 264);
-            Table.States (235).Goto_List.Set_Capacity (29);
-            Add_Goto (Table.States (235), 117, 130);
-            Add_Goto (Table.States (235), 124, 265);
-            Add_Goto (Table.States (235), 125, 406);
-            Add_Goto (Table.States (235), 128, 41);
-            Add_Goto (Table.States (235), 136, 267);
-            Add_Goto (Table.States (235), 153, 407);
-            Add_Goto (Table.States (235), 165, 269);
-            Add_Goto (Table.States (235), 166, 270);
-            Add_Goto (Table.States (235), 191, 408);
-            Add_Goto (Table.States (235), 197, 133);
-            Add_Goto (Table.States (235), 221, 273);
-            Add_Goto (Table.States (235), 239, 274);
-            Add_Goto (Table.States (235), 258, 135);
-            Add_Goto (Table.States (235), 272, 92);
-            Add_Goto (Table.States (235), 273, 275);
-            Add_Goto (Table.States (235), 275, 136);
-            Add_Goto (Table.States (235), 277, 409);
-            Add_Goto (Table.States (235), 278, 410);
-            Add_Goto (Table.States (235), 282, 137);
-            Add_Goto (Table.States (235), 283, 138);
-            Add_Goto (Table.States (235), 284, 139);
-            Add_Goto (Table.States (235), 285, 140);
-            Add_Goto (Table.States (235), 286, 141);
-            Add_Goto (Table.States (235), 287, 142);
-            Add_Goto (Table.States (235), 293, 97);
-            Add_Goto (Table.States (235), 301, 277);
-            Add_Goto (Table.States (235), 320, 144);
-            Add_Goto (Table.States (235), 321, 145);
-            Add_Goto (Table.States (235), 330, 146);
-            Table.States (235).Kernel := To_Vector (((115, 76, 1, False), 
(115, 76, 3, False), (239, 76, 4, True)));
-            Table.States (235).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 125, 0)));
+            Add_Goto (Table.States (233), 123, 401);
+            Table.States (233).Kernel := To_Vector ((0 => (217, 313, 1, 
False)));
+            Table.States (233).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 123, 0)));
+            Table.States (234).Action_List.Set_Capacity (13);
+            Add_Action (Table.States (234), 7, Reduce, (119, 1), 0, null, 
null);
+            Add_Action (Table.States (234), 8, 402);
+            Add_Action (Table.States (234), 11, Reduce, (119, 1), 0, null, 
null);
+            Add_Action (Table.States (234), 16, 403);
+            Add_Conflict (Table.States (234), 16, (119, 1), 0, null, null);
+            Add_Action (Table.States (234), 26, 404);
+            Add_Action (Table.States (234), 40, Reduce, (119, 1), 0, null, 
null);
+            Add_Action (Table.States (234), 74, Reduce, (119, 1), 0, null, 
null);
+            Add_Action (Table.States (234), 79, Reduce, (119, 1), 0, null, 
null);
+            Add_Action (Table.States (234), 83, Reduce, (119, 1), 0, null, 
null);
+            Add_Action (Table.States (234), 97, Reduce, (119, 1), 0, null, 
null);
+            Add_Action (Table.States (234), 105, Reduce, (119, 1), 0, null, 
null);
+            Add_Action (Table.States (234), 106, Reduce, (119, 1), 0, null, 
null);
+            Add_Action (Table.States (234), 107, Reduce, (119, 1), 0, null, 
null);
+            Table.States (234).Goto_List.Set_Capacity (1);
+            Add_Goto (Table.States (234), 119, 405);
+            Table.States (234).Kernel := To_Vector (((158, 82, 3, False), 
(187, 82, 2, False), (245, 82, 3, False),
+            (245, 82, 4, False), (245, 82, 10, False), (245, 82, 2, False), 
(245, 82, 3, False), (245, 82, 9, False)));
+            Table.States (234).Minimal_Complete_Actions := To_Vector (((Shift, 
26, 404), (Reduce, 119, 0)));
+            Table.States (235).Action_List.Set_Capacity (1);
+            Add_Action (Table.States (235), 105, 406);
+            Table.States (235).Kernel := To_Vector ((0 => (220, 84, 1, True)));
+            Table.States (235).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 105, 406)));
             Table.States (235).Minimal_Complete_Actions_Recursive := True;
-            Table.States (236).Action_List.Set_Capacity (13);
-            Add_Action (Table.States (236), 3, 121);
-            Add_Action (Table.States (236), 39, 122);
-            Add_Action (Table.States (236), 40, 123);
-            Add_Action (Table.States (236), 41, 124);
-            Add_Action (Table.States (236), 52, 125);
-            Add_Action (Table.States (236), 76, 126);
-            Add_Action (Table.States (236), 94, 127);
+            Table.States (236).Action_List.Set_Capacity (21);
+            Add_Action (Table.States (236), 3, 122);
+            Add_Action (Table.States (236), 15, 259);
+            Add_Action (Table.States (236), 28, 260);
+            Add_Action (Table.States (236), 32, 261);
+            Add_Action (Table.States (236), 39, 123);
+            Add_Action (Table.States (236), 40, 262);
+            Add_Action (Table.States (236), 41, 125);
+            Add_Action (Table.States (236), 44, 264);
+            Add_Action (Table.States (236), 52, 126);
+            Add_Action (Table.States (236), 76, 127);
+            Add_Action (Table.States (236), 77, Reduce, (125, 6), 0, null, 
null);
+            Add_Action (Table.States (236), 79, 31);
+            Add_Action (Table.States (236), 80, Reduce, (167, 2), 0, null, 
null);
+            Add_Action (Table.States (236), 84, Reduce, (125, 6), 0, null, 
null);
+            Add_Action (Table.States (236), 88, Reduce, (167, 2), 0, null, 
null);
             Add_Action (Table.States (236), 95, 128);
-            Add_Action (Table.States (236), 96, Reduce, (192, 1), 0, null, 
null);
-            Add_Action (Table.States (236), 103, 129);
-            Add_Action (Table.States (236), 104, 119);
-            Add_Action (Table.States (236), 105, 33);
+            Add_Action (Table.States (236), 96, 129);
+            Add_Action (Table.States (236), 104, 130);
+            Add_Action (Table.States (236), 105, 120);
             Add_Action (Table.States (236), 106, 34);
-            Table.States (236).Goto_List.Set_Capacity (20);
-            Add_Goto (Table.States (236), 117, 130);
-            Add_Goto (Table.States (236), 128, 41);
-            Add_Goto (Table.States (236), 191, 131);
-            Add_Goto (Table.States (236), 192, 411);
-            Add_Goto (Table.States (236), 197, 133);
-            Add_Goto (Table.States (236), 239, 134);
-            Add_Goto (Table.States (236), 258, 135);
-            Add_Goto (Table.States (236), 272, 92);
-            Add_Goto (Table.States (236), 275, 136);
-            Add_Goto (Table.States (236), 282, 137);
+            Add_Action (Table.States (236), 107, 265);
+            Table.States (236).Goto_List.Set_Capacity (29);
+            Add_Goto (Table.States (236), 118, 131);
+            Add_Goto (Table.States (236), 125, 266);
+            Add_Goto (Table.States (236), 126, 407);
+            Add_Goto (Table.States (236), 129, 42);
+            Add_Goto (Table.States (236), 137, 268);
+            Add_Goto (Table.States (236), 154, 408);
+            Add_Goto (Table.States (236), 166, 270);
+            Add_Goto (Table.States (236), 167, 271);
+            Add_Goto (Table.States (236), 192, 409);
+            Add_Goto (Table.States (236), 198, 134);
+            Add_Goto (Table.States (236), 222, 274);
+            Add_Goto (Table.States (236), 240, 275);
+            Add_Goto (Table.States (236), 259, 136);
+            Add_Goto (Table.States (236), 273, 93);
+            Add_Goto (Table.States (236), 274, 276);
+            Add_Goto (Table.States (236), 276, 137);
+            Add_Goto (Table.States (236), 278, 410);
+            Add_Goto (Table.States (236), 279, 411);
             Add_Goto (Table.States (236), 283, 138);
             Add_Goto (Table.States (236), 284, 139);
             Add_Goto (Table.States (236), 285, 140);
             Add_Goto (Table.States (236), 286, 141);
             Add_Goto (Table.States (236), 287, 142);
-            Add_Goto (Table.States (236), 293, 97);
-            Add_Goto (Table.States (236), 301, 143);
-            Add_Goto (Table.States (236), 320, 144);
+            Add_Goto (Table.States (236), 288, 143);
+            Add_Goto (Table.States (236), 294, 98);
+            Add_Goto (Table.States (236), 302, 278);
             Add_Goto (Table.States (236), 321, 145);
-            Add_Goto (Table.States (236), 330, 146);
-            Table.States (236).Kernel := To_Vector ((0 => (123, 82, 1, 
False)));
-            Table.States (236).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 192, 0)));
-            Table.States (237).Action_List.Set_Capacity (4);
-            Add_Action (Table.States (237), 9, 412);
-            Add_Action (Table.States (237), 104, 413);
-            Add_Action (Table.States (237), 105, 414);
-            Add_Action (Table.States (237), 106, 415);
-            Table.States (237).Kernel := To_Vector (((293, 84, 1, True), (293, 
84, 1, True), (293, 84, 1, True), (293,
-            84, 1, True)));
-            Table.States (237).Minimal_Complete_Actions := To_Vector (((Shift, 
104, 413), (Shift, 106, 415), (Shift,
-            105, 414), (Shift, 9, 412)));
-            Table.States (237).Minimal_Complete_Actions_Recursive := True;
+            Add_Goto (Table.States (236), 322, 146);
+            Add_Goto (Table.States (236), 331, 147);
+            Table.States (236).Kernel := To_Vector (((116, 76, 1, False), 
(116, 76, 3, False), (240, 76, 4, True)));
+            Table.States (236).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 126, 0)));
+            Table.States (236).Minimal_Complete_Actions_Recursive := True;
          end Subr_4;
          procedure Subr_5
          is begin
-            Table.States (238).Action_List.Set_Capacity (46);
-            Add_Action (Table.States (238), (4, 5, 13, 15, 17, 18, 22, 23, 24, 
25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
-            40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 
68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
-            107), (261, 0), 2, procedure_call_statement_0'Access, null);
-            Table.States (238).Kernel := To_Vector ((0 => (261, 96, 0, 
False)));
-            Table.States (238).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 261, 2)));
-            Table.States (239).Action_List.Set_Capacity (7);
-            Add_Action (Table.States (239), (7, 19, 20, 38, 53, 76, 104), 
(322, 0), 1, null, null);
-            Table.States (239).Kernel := To_Vector ((0 => (322, 101, 0, 
False)));
-            Table.States (239).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 322, 1)));
+            Table.States (237).Action_List.Set_Capacity (14);
+            Add_Action (Table.States (237), 3, 122);
+            Add_Action (Table.States (237), 39, 123);
+            Add_Action (Table.States (237), 40, 124);
+            Add_Action (Table.States (237), 41, 125);
+            Add_Action (Table.States (237), 52, 126);
+            Add_Action (Table.States (237), 76, 127);
+            Add_Action (Table.States (237), 79, 31);
+            Add_Action (Table.States (237), 95, 128);
+            Add_Action (Table.States (237), 96, 129);
+            Add_Action (Table.States (237), 97, Reduce, (193, 1), 0, null, 
null);
+            Add_Action (Table.States (237), 104, 130);
+            Add_Action (Table.States (237), 105, 120);
+            Add_Action (Table.States (237), 106, 34);
+            Add_Action (Table.States (237), 107, 35);
+            Table.States (237).Goto_List.Set_Capacity (20);
+            Add_Goto (Table.States (237), 118, 131);
+            Add_Goto (Table.States (237), 129, 42);
+            Add_Goto (Table.States (237), 192, 132);
+            Add_Goto (Table.States (237), 193, 412);
+            Add_Goto (Table.States (237), 198, 134);
+            Add_Goto (Table.States (237), 240, 135);
+            Add_Goto (Table.States (237), 259, 136);
+            Add_Goto (Table.States (237), 273, 93);
+            Add_Goto (Table.States (237), 276, 137);
+            Add_Goto (Table.States (237), 283, 138);
+            Add_Goto (Table.States (237), 284, 139);
+            Add_Goto (Table.States (237), 285, 140);
+            Add_Goto (Table.States (237), 286, 141);
+            Add_Goto (Table.States (237), 287, 142);
+            Add_Goto (Table.States (237), 288, 143);
+            Add_Goto (Table.States (237), 294, 98);
+            Add_Goto (Table.States (237), 302, 144);
+            Add_Goto (Table.States (237), 321, 145);
+            Add_Goto (Table.States (237), 322, 146);
+            Add_Goto (Table.States (237), 331, 147);
+            Table.States (237).Kernel := To_Vector ((0 => (124, 83, 1, 
False)));
+            Table.States (237).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 193, 0)));
+            Table.States (238).Action_List.Set_Capacity (4);
+            Add_Action (Table.States (238), 9, 413);
+            Add_Action (Table.States (238), 105, 414);
+            Add_Action (Table.States (238), 106, 415);
+            Add_Action (Table.States (238), 107, 416);
+            Table.States (238).Kernel := To_Vector (((294, 85, 1, True), (294, 
85, 1, True), (294, 85, 1, True), (294,
+            85, 1, True)));
+            Table.States (238).Minimal_Complete_Actions := To_Vector (((Shift, 
105, 414), (Shift, 107, 416), (Shift,
+            106, 415), (Shift, 9, 413)));
+            Table.States (238).Minimal_Complete_Actions_Recursive := True;
+            Table.States (239).Action_List.Set_Capacity (47);
+            Add_Action (Table.States (239), (4, 5, 13, 15, 17, 18, 22, 23, 24, 
25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
+            40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 
68, 69, 71, 72, 73, 74, 79, 94, 105, 106,
+            107, 108), (262, 0), 2, procedure_call_statement_0'Access, null);
+            Table.States (239).Kernel := To_Vector ((0 => (262, 97, 0, 
False)));
+            Table.States (239).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 262, 2)));
             Table.States (240).Action_List.Set_Capacity (7);
-            Add_Action (Table.States (240), (7, 19, 20, 38, 53, 76, 104), 
(322, 1), 1, null, null);
-            Table.States (240).Kernel := To_Vector ((0 => (322, 102, 0, 
False)));
-            Table.States (240).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 322, 1)));
-            Table.States (241).Action_List.Set_Capacity (63);
-            Add_Action (Table.States (241), (4, 5, 10, 13, 15, 17, 18, 20, 21, 
22, 23, 27, 28, 31, 32, 33, 35, 37, 38,
-            40, 41, 42, 43, 48, 52, 53, 55, 56, 57, 58, 61, 68, 71, 73, 74, 
75, 76, 77, 78, 79, 82, 83, 84, 85, 86, 87,
-            88, 89, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 104, 
105, 106), (239, 1), 2, name_1'Access,
+            Add_Action (Table.States (240), (7, 19, 20, 38, 53, 76, 105), 
(323, 0), 1, null, null);
+            Table.States (240).Kernel := To_Vector ((0 => (323, 102, 0, 
False)));
+            Table.States (240).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 323, 1)));
+            Table.States (241).Action_List.Set_Capacity (7);
+            Add_Action (Table.States (241), (7, 19, 20, 38, 53, 76, 105), 
(323, 1), 1, null, null);
+            Table.States (241).Kernel := To_Vector ((0 => (323, 103, 0, 
False)));
+            Table.States (241).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 323, 1)));
+            Table.States (242).Action_List.Set_Capacity (64);
+            Add_Action (Table.States (242), (4, 5, 10, 13, 15, 17, 18, 20, 21, 
22, 23, 27, 28, 31, 32, 33, 35, 37, 38,
+            40, 41, 42, 43, 48, 52, 53, 55, 56, 57, 58, 61, 68, 71, 73, 74, 
75, 76, 77, 78, 79, 80, 83, 84, 85, 86, 87,
+            88, 89, 90, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 
105, 106, 107), (240, 1), 2, name_1'Access,
             null);
-            Table.States (241).Kernel := To_Vector ((0 => (239, 115, 0, 
True)));
-            Table.States (241).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 239, 2)));
-            Table.States (241).Minimal_Complete_Actions_Recursive := True;
-            Table.States (242).Action_List.Set_Capacity (6);
-            Add_Action (Table.States (242), 7, 416);
-            Add_Action (Table.States (242), 19, 417);
-            Add_Action (Table.States (242), 20, 418);
-            Add_Action (Table.States (242), 38, 419);
-            Add_Action (Table.States (242), 76, 126);
-            Add_Action (Table.States (242), 104, 420);
-            Table.States (242).Goto_List.Set_Capacity (2);
-            Add_Goto (Table.States (242), 117, 421);
-            Add_Goto (Table.States (242), 129, 422);
-            Table.States (242).Kernel := To_Vector (((128, 322, 1, True), 
(272, 322, 2, True)));
-            Table.States (242).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 104, 420)));
+            Table.States (242).Kernel := To_Vector ((0 => (240, 116, 0, 
True)));
+            Table.States (242).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 240, 2)));
             Table.States (242).Minimal_Complete_Actions_Recursive := True;
-            Table.States (243).Action_List.Set_Capacity (1);
-            Add_Action (Table.States (243), 104, 423);
-            Table.States (243).Kernel := To_Vector (((179, 25, 5, False), 
(179, 25, 2, False)));
-            Table.States (243).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 104, 423)));
-            Table.States (244).Action_List.Set_Capacity (3);
-            Add_Action (Table.States (244), 104, 119);
-            Add_Action (Table.States (244), 105, 33);
-            Add_Action (Table.States (244), 106, 34);
-            Table.States (244).Goto_List.Set_Capacity (4);
-            Add_Goto (Table.States (244), 128, 41);
-            Add_Goto (Table.States (244), 239, 424);
-            Add_Goto (Table.States (244), 272, 92);
-            Add_Goto (Table.States (244), 293, 97);
-            Table.States (244).Kernel := To_Vector (((207, 29, 2, False), 
(213, 29, 5, False)));
-            Table.States (244).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 104, 119)));
-            Table.States (245).Action_List.Set_Capacity (3);
-            Add_Action (Table.States (245), 104, 119);
-            Add_Action (Table.States (245), 105, 33);
+            Table.States (243).Action_List.Set_Capacity (6);
+            Add_Action (Table.States (243), 7, 417);
+            Add_Action (Table.States (243), 19, 418);
+            Add_Action (Table.States (243), 20, 419);
+            Add_Action (Table.States (243), 38, 420);
+            Add_Action (Table.States (243), 76, 127);
+            Add_Action (Table.States (243), 105, 421);
+            Table.States (243).Goto_List.Set_Capacity (2);
+            Add_Goto (Table.States (243), 118, 422);
+            Add_Goto (Table.States (243), 130, 423);
+            Table.States (243).Kernel := To_Vector (((129, 323, 1, True), 
(273, 323, 2, True)));
+            Table.States (243).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 105, 421)));
+            Table.States (243).Minimal_Complete_Actions_Recursive := True;
+            Table.States (244).Action_List.Set_Capacity (1);
+            Add_Action (Table.States (244), 105, 424);
+            Table.States (244).Kernel := To_Vector (((180, 25, 5, False), 
(180, 25, 2, False)));
+            Table.States (244).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 105, 424)));
+            Table.States (245).Action_List.Set_Capacity (4);
+            Add_Action (Table.States (245), 79, 31);
+            Add_Action (Table.States (245), 105, 120);
             Add_Action (Table.States (245), 106, 34);
+            Add_Action (Table.States (245), 107, 35);
             Table.States (245).Goto_List.Set_Capacity (4);
-            Add_Goto (Table.States (245), 128, 41);
-            Add_Goto (Table.States (245), 239, 425);
-            Add_Goto (Table.States (245), 272, 92);
-            Add_Goto (Table.States (245), 293, 97);
-            Table.States (245).Kernel := To_Vector (((213, 50, 5, False), 
(262, 50, 1, False)));
-            Table.States (245).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 104, 119)));
+            Add_Goto (Table.States (245), 129, 42);
+            Add_Goto (Table.States (245), 240, 425);
+            Add_Goto (Table.States (245), 273, 93);
+            Add_Goto (Table.States (245), 294, 98);
+            Table.States (245).Kernel := To_Vector (((208, 29, 2, False), 
(214, 29, 5, False)));
+            Table.States (245).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 105, 120)));
             Table.States (246).Action_List.Set_Capacity (4);
-            Add_Action (Table.States (246), 35, 426);
-            Add_Conflict (Table.States (246), 35, (312, 1), 1, null, 
subprogram_specification_1_check'Access);
-            Add_Action (Table.States (246), 56, Reduce, (312, 1), 1, null, 
subprogram_specification_1_check'Access);
-            Add_Action (Table.States (246), 74, Reduce, (312, 1), 1, null, 
subprogram_specification_1_check'Access);
-            Add_Action (Table.States (246), 96, Reduce, (312, 1), 1, null, 
subprogram_specification_1_check'Access);
-            Table.States (246).Kernel := To_Vector (((193, 207, 4, False), 
(312, 207, 0, False)));
-            Table.States (246).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 312, 1)));
+            Add_Action (Table.States (246), 79, 31);
+            Add_Action (Table.States (246), 105, 120);
+            Add_Action (Table.States (246), 106, 34);
+            Add_Action (Table.States (246), 107, 35);
+            Table.States (246).Goto_List.Set_Capacity (4);
+            Add_Goto (Table.States (246), 129, 42);
+            Add_Goto (Table.States (246), 240, 426);
+            Add_Goto (Table.States (246), 273, 93);
+            Add_Goto (Table.States (246), 294, 98);
+            Table.States (246).Kernel := To_Vector (((214, 50, 5, False), 
(263, 50, 1, False)));
+            Table.States (246).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 105, 120)));
             Table.States (247).Action_List.Set_Capacity (4);
             Add_Action (Table.States (247), 35, 427);
-            Add_Conflict (Table.States (247), 35, (312, 0), 1, null, 
subprogram_specification_0_check'Access);
-            Add_Action (Table.States (247), 56, Reduce, (312, 0), 1, null, 
subprogram_specification_0_check'Access);
-            Add_Action (Table.States (247), 74, Reduce, (312, 0), 1, null, 
subprogram_specification_0_check'Access);
-            Add_Action (Table.States (247), 96, Reduce, (312, 0), 1, null, 
subprogram_specification_0_check'Access);
-            Table.States (247).Kernel := To_Vector (((243, 262, 3, False), 
(312, 262, 0, False)));
-            Table.States (247).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 312, 1)));
+            Add_Conflict (Table.States (247), 35, (313, 1), 1, null, 
subprogram_specification_1_check'Access);
+            Add_Action (Table.States (247), 56, Reduce, (313, 1), 1, null, 
subprogram_specification_1_check'Access);
+            Add_Action (Table.States (247), 74, Reduce, (313, 1), 1, null, 
subprogram_specification_1_check'Access);
+            Add_Action (Table.States (247), 97, Reduce, (313, 1), 1, null, 
subprogram_specification_1_check'Access);
+            Table.States (247).Kernel := To_Vector (((194, 208, 4, False), 
(313, 208, 0, False)));
+            Table.States (247).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 313, 1)));
             Table.States (248).Action_List.Set_Capacity (4);
             Add_Action (Table.States (248), 35, 428);
-            Add_Conflict (Table.States (248), 35, (122, 1), 0, null, null);
-            Add_Action (Table.States (248), 56, 429);
-            Add_Action (Table.States (248), 74, 337);
-            Add_Action (Table.States (248), 96, Reduce, (122, 1), 0, null, 
null);
-            Table.States (248).Goto_List.Set_Capacity (1);
-            Add_Goto (Table.States (248), 122, 430);
-            Table.States (248).Kernel := To_Vector (((112, 312, 3, False), 
(307, 312, 4, False), (308, 312, 3, False),
-            (309, 312, 1, False), (311, 312, 3, False)));
-            Table.States (248).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 122, 0)));
-            Table.States (249).Action_List.Set_Capacity (40);
-            Add_Action (Table.States (249), (4, 5, 13, 15, 17, 18, 24, 25, 27, 
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
-            47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 
93, 104, 105, 106, 107), (249, 0), 2,
+            Add_Conflict (Table.States (248), 35, (313, 0), 1, null, 
subprogram_specification_0_check'Access);
+            Add_Action (Table.States (248), 56, Reduce, (313, 0), 1, null, 
subprogram_specification_0_check'Access);
+            Add_Action (Table.States (248), 74, Reduce, (313, 0), 1, null, 
subprogram_specification_0_check'Access);
+            Add_Action (Table.States (248), 97, Reduce, (313, 0), 1, null, 
subprogram_specification_0_check'Access);
+            Table.States (248).Kernel := To_Vector (((244, 263, 3, False), 
(313, 263, 0, False)));
+            Table.States (248).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 313, 1)));
+            Table.States (249).Action_List.Set_Capacity (4);
+            Add_Action (Table.States (249), 35, 429);
+            Add_Conflict (Table.States (249), 35, (123, 1), 0, null, null);
+            Add_Action (Table.States (249), 56, 430);
+            Add_Action (Table.States (249), 74, 338);
+            Add_Action (Table.States (249), 97, Reduce, (123, 1), 0, null, 
null);
+            Table.States (249).Goto_List.Set_Capacity (1);
+            Add_Goto (Table.States (249), 123, 431);
+            Table.States (249).Kernel := To_Vector (((113, 313, 3, False), 
(308, 313, 4, False), (309, 313, 3, False),
+            (310, 313, 1, False), (312, 313, 3, False)));
+            Table.States (249).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 123, 0)));
+            Table.States (250).Action_List.Set_Capacity (41);
+            Add_Action (Table.States (250), (4, 5, 13, 15, 17, 18, 24, 25, 27, 
28, 29, 30, 31, 32, 36, 37, 40, 41, 46,
+            47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 69, 71, 73, 74, 
79, 94, 105, 106, 107, 108), (250, 0), 2,
             package_declaration_0'Access, null);
-            Table.States (249).Kernel := To_Vector ((0 => (249, 96, 0, 
False)));
-            Table.States (249).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 249, 2)));
-            Table.States (250).Action_List.Set_Capacity (20);
-            Add_Action (Table.States (250), 3, 121);
-            Add_Action (Table.States (250), 15, 258);
-            Add_Action (Table.States (250), 28, 259);
-            Add_Action (Table.States (250), 32, 260);
-            Add_Action (Table.States (250), 39, 122);
-            Add_Action (Table.States (250), 40, 261);
-            Add_Action (Table.States (250), 41, 124);
-            Add_Action (Table.States (250), 44, 263);
-            Add_Action (Table.States (250), 52, 125);
-            Add_Action (Table.States (250), 76, 126);
-            Add_Action (Table.States (250), 77, Reduce, (124, 5), 0, null, 
null);
-            Add_Action (Table.States (250), 79, Reduce, (166, 2), 0, null, 
null);
-            Add_Action (Table.States (250), 83, Reduce, (124, 5), 0, null, 
null);
-            Add_Action (Table.States (250), 87, Reduce, (166, 2), 0, null, 
null);
-            Add_Action (Table.States (250), 94, 127);
-            Add_Action (Table.States (250), 95, 128);
-            Add_Action (Table.States (250), 103, 129);
-            Add_Action (Table.States (250), 104, 119);
-            Add_Action (Table.States (250), 105, 33);
-            Add_Action (Table.States (250), 106, 264);
-            Table.States (250).Goto_List.Set_Capacity (28);
-            Add_Goto (Table.States (250), 117, 130);
-            Add_Goto (Table.States (250), 124, 265);
-            Add_Goto (Table.States (250), 125, 406);
-            Add_Goto (Table.States (250), 128, 41);
-            Add_Goto (Table.States (250), 136, 267);
-            Add_Goto (Table.States (250), 153, 407);
-            Add_Goto (Table.States (250), 165, 269);
-            Add_Goto (Table.States (250), 166, 270);
-            Add_Goto (Table.States (250), 191, 408);
-            Add_Goto (Table.States (250), 197, 133);
-            Add_Goto (Table.States (250), 221, 273);
-            Add_Goto (Table.States (250), 239, 274);
-            Add_Goto (Table.States (250), 258, 135);
-            Add_Goto (Table.States (250), 272, 92);
-            Add_Goto (Table.States (250), 273, 275);
-            Add_Goto (Table.States (250), 275, 136);
-            Add_Goto (Table.States (250), 277, 276);
-            Add_Goto (Table.States (250), 282, 137);
-            Add_Goto (Table.States (250), 283, 138);
-            Add_Goto (Table.States (250), 284, 139);
-            Add_Goto (Table.States (250), 285, 140);
-            Add_Goto (Table.States (250), 286, 141);
-            Add_Goto (Table.States (250), 287, 142);
-            Add_Goto (Table.States (250), 293, 97);
-            Add_Goto (Table.States (250), 301, 277);
-            Add_Goto (Table.States (250), 320, 144);
-            Add_Goto (Table.States (250), 321, 145);
-            Add_Goto (Table.States (250), 330, 146);
-            Table.States (250).Kernel := To_Vector (((115, 76, 1, False), 
(115, 76, 3, False)));
-            Table.States (250).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 125, 0)));
-            Table.States (251).Action_List.Set_Capacity (3);
-            Add_Action (Table.States (251), (21, 76, 96), (116, 0), 1, null, 
null);
-            Table.States (251).Kernel := To_Vector ((0 => (116, 115, 0, 
False)));
-            Table.States (251).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 116, 1)));
+            Table.States (250).Kernel := To_Vector ((0 => (250, 97, 0, 
False)));
+            Table.States (250).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 250, 2)));
+            Table.States (251).Action_List.Set_Capacity (21);
+            Add_Action (Table.States (251), 3, 122);
+            Add_Action (Table.States (251), 15, 259);
+            Add_Action (Table.States (251), 28, 260);
+            Add_Action (Table.States (251), 32, 261);
+            Add_Action (Table.States (251), 39, 123);
+            Add_Action (Table.States (251), 40, 262);
+            Add_Action (Table.States (251), 41, 125);
+            Add_Action (Table.States (251), 44, 264);
+            Add_Action (Table.States (251), 52, 126);
+            Add_Action (Table.States (251), 76, 127);
+            Add_Action (Table.States (251), 77, Reduce, (125, 6), 0, null, 
null);
+            Add_Action (Table.States (251), 79, 31);
+            Add_Action (Table.States (251), 80, Reduce, (167, 2), 0, null, 
null);
+            Add_Action (Table.States (251), 84, Reduce, (125, 6), 0, null, 
null);
+            Add_Action (Table.States (251), 88, Reduce, (167, 2), 0, null, 
null);
+            Add_Action (Table.States (251), 95, 128);
+            Add_Action (Table.States (251), 96, 129);
+            Add_Action (Table.States (251), 104, 130);
+            Add_Action (Table.States (251), 105, 120);
+            Add_Action (Table.States (251), 106, 34);
+            Add_Action (Table.States (251), 107, 265);
+            Table.States (251).Goto_List.Set_Capacity (28);
+            Add_Goto (Table.States (251), 118, 131);
+            Add_Goto (Table.States (251), 125, 266);
+            Add_Goto (Table.States (251), 126, 407);
+            Add_Goto (Table.States (251), 129, 42);
+            Add_Goto (Table.States (251), 137, 268);
+            Add_Goto (Table.States (251), 154, 408);
+            Add_Goto (Table.States (251), 166, 270);
+            Add_Goto (Table.States (251), 167, 271);
+            Add_Goto (Table.States (251), 192, 409);
+            Add_Goto (Table.States (251), 198, 134);
+            Add_Goto (Table.States (251), 222, 274);
+            Add_Goto (Table.States (251), 240, 275);
+            Add_Goto (Table.States (251), 259, 136);
+            Add_Goto (Table.States (251), 273, 93);
+            Add_Goto (Table.States (251), 274, 276);
+            Add_Goto (Table.States (251), 276, 137);
+            Add_Goto (Table.States (251), 278, 277);
+            Add_Goto (Table.States (251), 283, 138);
+            Add_Goto (Table.States (251), 284, 139);
+            Add_Goto (Table.States (251), 285, 140);
+            Add_Goto (Table.States (251), 286, 141);
+            Add_Goto (Table.States (251), 287, 142);
+            Add_Goto (Table.States (251), 288, 143);
+            Add_Goto (Table.States (251), 294, 98);
+            Add_Goto (Table.States (251), 302, 278);
+            Add_Goto (Table.States (251), 321, 145);
+            Add_Goto (Table.States (251), 322, 146);
+            Add_Goto (Table.States (251), 331, 147);
+            Table.States (251).Kernel := To_Vector (((116, 76, 1, False), 
(116, 76, 3, False)));
+            Table.States (251).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 126, 0)));
             Table.States (252).Action_List.Set_Capacity (3);
-            Add_Action (Table.States (252), 21, Reduce, (253, 1), 0, null, 
null);
-            Add_Action (Table.States (252), 76, 431);
-            Add_Action (Table.States (252), 96, Reduce, (253, 1), 0, null, 
null);
-            Table.States (252).Goto_List.Set_Capacity (2);
-            Add_Goto (Table.States (252), 199, 344);
-            Add_Goto (Table.States (252), 253, 432);
-            Table.States (252).Kernel := To_Vector (((113, 116, 3, False), 
(113, 116, 1, False)));
-            Table.States (252).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 253, 0)));
-            Table.States (253).Action_List.Set_Capacity (46);
-            Add_Action (Table.States (253), (4, 5, 13, 15, 17, 18, 22, 23, 24, 
25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
-            40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 
68, 69, 71, 72, 73, 74, 93, 104, 105, 106,
-            107), (303, 8), 3, simple_statement_8'Access, null);
-            Table.States (253).Kernel := To_Vector ((0 => (303, 96, 0, 
False)));
-            Table.States (253).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 303, 3)));
-            Table.States (254).Action_List.Set_Capacity (35);
-            Add_Action (Table.States (254), (10, 20, 21, 22, 23, 33, 35, 37, 
38, 40, 42, 43, 53, 55, 68, 74, 75, 77,
-            78, 79, 82, 83, 85, 86, 87, 88, 89, 91, 92, 94, 95, 96, 97, 98, 
99), (197, 2), 2, null, null);
-            Table.States (254).Kernel := To_Vector ((0 => (197, 258, 0, 
False)));
-            Table.States (254).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 197, 2)));
-            Table.States (255).Action_List.Set_Capacity (40);
-            Add_Action (Table.States (255), 10, Reduce, (258, 4), 2, 
primary_4'Access, null);
-            Add_Action (Table.States (255), 20, Reduce, (258, 4), 2, 
primary_4'Access, null);
-            Add_Action (Table.States (255), 21, Reduce, (258, 4), 2, 
primary_4'Access, null);
-            Add_Action (Table.States (255), 22, Reduce, (258, 4), 2, 
primary_4'Access, null);
-            Add_Action (Table.States (255), 23, Reduce, (258, 4), 2, 
primary_4'Access, null);
-            Add_Action (Table.States (255), 33, Reduce, (258, 4), 2, 
primary_4'Access, null);
-            Add_Action (Table.States (255), 35, Reduce, (258, 4), 2, 
primary_4'Access, null);
-            Add_Action (Table.States (255), 37, Reduce, (258, 4), 2, 
primary_4'Access, null);
-            Add_Action (Table.States (255), 38, Reduce, (258, 4), 2, 
primary_4'Access, null);
-            Add_Action (Table.States (255), 40, Reduce, (258, 4), 2, 
primary_4'Access, null);
-            Add_Action (Table.States (255), 42, Reduce, (258, 4), 2, 
primary_4'Access, null);
-            Add_Action (Table.States (255), 43, Reduce, (258, 4), 2, 
primary_4'Access, null);
-            Add_Action (Table.States (255), 53, Reduce, (258, 4), 2, 
primary_4'Access, null);
-            Add_Action (Table.States (255), 55, Reduce, (258, 4), 2, 
primary_4'Access, null);
-            Add_Action (Table.States (255), 68, Reduce, (258, 4), 2, 
primary_4'Access, null);
-            Add_Action (Table.States (255), 74, Reduce, (258, 4), 2, 
primary_4'Access, null);
-            Add_Action (Table.States (255), 75, Reduce, (258, 4), 2, 
primary_4'Access, null);
-            Add_Action (Table.States (255), 76, 235);
-            Add_Action (Table.States (255), 77, Reduce, (258, 4), 2, 
primary_4'Access, null);
-            Add_Action (Table.States (255), 78, Reduce, (258, 4), 2, 
primary_4'Access, null);
-            Add_Action (Table.States (255), 79, Reduce, (258, 4), 2, 
primary_4'Access, null);
-            Add_Action (Table.States (255), 82, Reduce, (258, 4), 2, 
primary_4'Access, null);
-            Add_Action (Table.States (255), 83, Reduce, (258, 4), 2, 
primary_4'Access, null);
-            Add_Action (Table.States (255), 84, 237);
-            Add_Action (Table.States (255), 85, Reduce, (258, 4), 2, 
primary_4'Access, null);
-            Add_Action (Table.States (255), 86, Reduce, (258, 4), 2, 
primary_4'Access, null);
-            Add_Action (Table.States (255), 87, Reduce, (258, 4), 2, 
primary_4'Access, null);
-            Add_Action (Table.States (255), 88, Reduce, (258, 4), 2, 
primary_4'Access, null);
-            Add_Action (Table.States (255), 89, Reduce, (258, 4), 2, 
primary_4'Access, null);
-            Add_Action (Table.States (255), 91, Reduce, (258, 4), 2, 
primary_4'Access, null);
-            Add_Action (Table.States (255), 92, Reduce, (258, 4), 2, 
primary_4'Access, null);
-            Add_Action (Table.States (255), 94, Reduce, (258, 4), 2, 
primary_4'Access, null);
-            Add_Action (Table.States (255), 95, Reduce, (258, 4), 2, 
primary_4'Access, null);
-            Add_Action (Table.States (255), 96, Reduce, (258, 4), 2, 
primary_4'Access, null);
-            Add_Action (Table.States (255), 97, Reduce, (258, 4), 2, 
primary_4'Access, null);
-            Add_Action (Table.States (255), 98, Reduce, (258, 4), 2, 
primary_4'Access, null);
-            Add_Action (Table.States (255), 99, Reduce, (258, 4), 2, 
primary_4'Access, null);
-            Add_Action (Table.States (255), 100, Reduce, (258, 4), 2, 
primary_4'Access, null);
-            Add_Action (Table.States (255), 101, 239);
-            Add_Action (Table.States (255), 102, 240);
-            Table.States (255).Goto_List.Set_Capacity (2);
-            Add_Goto (Table.States (255), 115, 241);
-            Add_Goto (Table.States (255), 322, 242);
-            Table.States (255).Kernel := To_Vector (((128, 239, 2, True), 
(239, 239, 5, True), (239, 239, 2, True),
-            (258, 239, 0, False), (272, 239, 3, True), (293, 239, 2, True), 
(293, 239, 2, True), (293, 239, 2, True),
-            (293, 239, 2, True)));
-            Table.States (255).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 258, 2)));
-            Table.States (256).Action_List.Set_Capacity (35);
-            Add_Action (Table.States (256), (10, 20, 21, 22, 23, 33, 35, 37, 
38, 40, 42, 43, 53, 55, 68, 74, 75, 77,
-            78, 79, 82, 83, 85, 86, 87, 88, 89, 91, 92, 94, 95, 96, 97, 98, 
99), (197, 3), 2, null, null);
-            Table.States (256).Kernel := To_Vector ((0 => (197, 258, 0, 
False)));
-            Table.States (256).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 197, 2)));
-            Table.States (257).Action_List.Set_Capacity (21);
-            Add_Action (Table.States (257), 10, Reduce, (275, 1), 2, null, 
null);
-            Add_Action (Table.States (257), 20, Reduce, (275, 1), 2, null, 
null);
-            Add_Action (Table.States (257), 21, Reduce, (275, 1), 2, null, 
null);
-            Add_Action (Table.States (257), 22, Reduce, (275, 1), 2, null, 
null);
-            Add_Action (Table.States (257), 23, Reduce, (275, 1), 2, null, 
null);
-            Add_Action (Table.States (257), 35, Reduce, (275, 1), 2, null, 
null);
-            Add_Action (Table.States (257), 37, Reduce, (275, 1), 2, null, 
null);
-            Add_Action (Table.States (257), 43, Reduce, (275, 1), 2, null, 
null);
-            Add_Action (Table.States (257), 53, Reduce, (275, 1), 2, null, 
null);
-            Add_Action (Table.States (257), 68, Reduce, (275, 1), 2, null, 
null);
-            Add_Action (Table.States (257), 74, 433);
-            Add_Conflict (Table.States (257), 74, (275, 1), 2, null, null);
-            Add_Action (Table.States (257), 75, Reduce, (275, 1), 2, null, 
null);
-            Add_Action (Table.States (257), 76, 235);
-            Add_Action (Table.States (257), 77, Reduce, (275, 1), 2, null, 
null);
-            Add_Action (Table.States (257), 79, Reduce, (275, 1), 2, null, 
null);
-            Add_Action (Table.States (257), 83, Reduce, (275, 1), 2, null, 
null);
-            Add_Action (Table.States (257), 84, 237);
-            Add_Action (Table.States (257), 87, Reduce, (275, 1), 2, null, 
null);
-            Add_Action (Table.States (257), 96, Reduce, (275, 1), 2, null, 
null);
-            Add_Action (Table.States (257), 101, 239);
-            Add_Action (Table.States (257), 102, 240);
-            Table.States (257).Goto_List.Set_Capacity (2);
-            Add_Goto (Table.States (257), 115, 241);
-            Add_Goto (Table.States (257), 322, 242);
-            Table.States (257).Kernel := To_Vector (((128, 239, 2, True), 
(239, 239, 5, True), (239, 239, 2, True),
-            (272, 239, 3, True), (275, 239, 1, True), (275, 239, 0, False), 
(293, 239, 2, True), (293, 239, 2, True),
-            (293, 239, 2, True), (293, 239, 2, True)));
-            Table.States (257).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 275, 2)));
-            Table.States (257).Minimal_Complete_Actions_Recursive := True;
-            Table.States (258).Action_List.Set_Capacity (13);
-            Add_Action (Table.States (258), 3, 121);
-            Add_Action (Table.States (258), 35, Reduce, (192, 1), 0, null, 
null);
-            Add_Action (Table.States (258), 39, 122);
-            Add_Action (Table.States (258), 40, 123);
-            Add_Action (Table.States (258), 41, 124);
-            Add_Action (Table.States (258), 52, 125);
-            Add_Action (Table.States (258), 76, 126);
-            Add_Action (Table.States (258), 94, 127);
-            Add_Action (Table.States (258), 95, 128);
-            Add_Action (Table.States (258), 103, 129);
-            Add_Action (Table.States (258), 104, 119);
-            Add_Action (Table.States (258), 105, 33);
-            Add_Action (Table.States (258), 106, 34);
-            Table.States (258).Goto_List.Set_Capacity (20);
-            Add_Goto (Table.States (258), 117, 130);
-            Add_Goto (Table.States (258), 128, 41);
-            Add_Goto (Table.States (258), 191, 131);
-            Add_Goto (Table.States (258), 192, 434);
-            Add_Goto (Table.States (258), 197, 133);
-            Add_Goto (Table.States (258), 239, 134);
-            Add_Goto (Table.States (258), 258, 135);
-            Add_Goto (Table.States (258), 272, 92);
-            Add_Goto (Table.States (258), 275, 136);
-            Add_Goto (Table.States (258), 282, 137);
-            Add_Goto (Table.States (258), 283, 138);
-            Add_Goto (Table.States (258), 284, 139);
-            Add_Goto (Table.States (258), 285, 140);
-            Add_Goto (Table.States (258), 286, 141);
-            Add_Goto (Table.States (258), 287, 142);
-            Add_Goto (Table.States (258), 293, 97);
-            Add_Goto (Table.States (258), 301, 143);
-            Add_Goto (Table.States (258), 320, 144);
-            Add_Goto (Table.States (258), 321, 145);
-            Add_Goto (Table.States (258), 330, 146);
-            Table.States (258).Kernel := To_Vector ((0 => (136, 15, 3, 
False)));
-            Table.States (258).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 192, 0)));
-            Table.States (259).Action_List.Set_Capacity (2);
-            Add_Action (Table.States (259), 9, 435);
-            Add_Action (Table.States (259), 62, 436);
-            Table.States (259).Goto_List.Set_Capacity (1);
-            Add_Goto (Table.States (259), 274, 437);
-            Table.States (259).Kernel := To_Vector ((0 => (273, 28, 5, 
False)));
-            Table.States (259).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 9, 435)));
-            Table.States (260).Action_List.Set_Capacity (13);
-            Add_Action (Table.States (260), 3, 121);
-            Add_Action (Table.States (260), 39, 122);
-            Add_Action (Table.States (260), 40, 123);
-            Add_Action (Table.States (260), 41, 124);
-            Add_Action (Table.States (260), 52, 125);
-            Add_Action (Table.States (260), 68, Reduce, (192, 1), 0, null, 
null);
-            Add_Action (Table.States (260), 76, 126);
-            Add_Action (Table.States (260), 94, 127);
-            Add_Action (Table.States (260), 95, 128);
-            Add_Action (Table.States (260), 103, 129);
-            Add_Action (Table.States (260), 104, 119);
-            Add_Action (Table.States (260), 105, 33);
-            Add_Action (Table.States (260), 106, 34);
-            Table.States (260).Goto_List.Set_Capacity (20);
-            Add_Goto (Table.States (260), 117, 130);
-            Add_Goto (Table.States (260), 128, 41);
-            Add_Goto (Table.States (260), 191, 131);
-            Add_Goto (Table.States (260), 192, 438);
-            Add_Goto (Table.States (260), 197, 133);
-            Add_Goto (Table.States (260), 239, 134);
-            Add_Goto (Table.States (260), 258, 135);
-            Add_Goto (Table.States (260), 272, 92);
-            Add_Goto (Table.States (260), 275, 136);
-            Add_Goto (Table.States (260), 282, 137);
-            Add_Goto (Table.States (260), 283, 138);
-            Add_Goto (Table.States (260), 284, 139);
-            Add_Goto (Table.States (260), 285, 140);
-            Add_Goto (Table.States (260), 286, 141);
-            Add_Goto (Table.States (260), 287, 142);
-            Add_Goto (Table.States (260), 293, 97);
-            Add_Goto (Table.States (260), 301, 143);
-            Add_Goto (Table.States (260), 320, 144);
-            Add_Goto (Table.States (260), 321, 145);
-            Add_Goto (Table.States (260), 330, 146);
-            Table.States (260).Kernel := To_Vector (((221, 32, 4, False), 
(221, 32, 2, False), (221, 32, 3, False),
-            (221, 32, 1, False)));
-            Table.States (260).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 192, 0)));
-            Table.States (261).Action_List.Set_Capacity (7);
-            Add_Action (Table.States (261), 39, 122);
-            Add_Action (Table.States (261), 41, 439);
-            Add_Action (Table.States (261), 76, 126);
-            Add_Action (Table.States (261), 103, 129);
-            Add_Action (Table.States (261), 104, 119);
-            Add_Action (Table.States (261), 105, 33);
+            Add_Action (Table.States (252), (21, 76, 97), (117, 0), 1, null, 
null);
+            Table.States (252).Kernel := To_Vector ((0 => (117, 116, 0, 
False)));
+            Table.States (252).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 117, 1)));
+            Table.States (253).Action_List.Set_Capacity (3);
+            Add_Action (Table.States (253), 21, Reduce, (254, 1), 0, null, 
null);
+            Add_Action (Table.States (253), 76, 432);
+            Add_Action (Table.States (253), 97, Reduce, (254, 1), 0, null, 
null);
+            Table.States (253).Goto_List.Set_Capacity (2);
+            Add_Goto (Table.States (253), 200, 345);
+            Add_Goto (Table.States (253), 254, 433);
+            Table.States (253).Kernel := To_Vector (((114, 117, 3, False), 
(114, 117, 1, False)));
+            Table.States (253).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 254, 0)));
+            Table.States (254).Action_List.Set_Capacity (47);
+            Add_Action (Table.States (254), (4, 5, 13, 15, 17, 18, 22, 23, 24, 
25, 26, 27, 28, 29, 30, 31, 32, 36, 37,
+            40, 41, 43, 46, 47, 48, 49, 50, 51, 52, 57, 58, 60, 61, 63, 66, 
68, 69, 71, 72, 73, 74, 79, 94, 105, 106,
+            107, 108), (304, 8), 3, simple_statement_8'Access, null);
+            Table.States (254).Kernel := To_Vector ((0 => (304, 97, 0, 
False)));
+            Table.States (254).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 304, 3)));
+            Table.States (255).Action_List.Set_Capacity (35);
+            Add_Action (Table.States (255), (10, 20, 21, 22, 23, 33, 35, 37, 
38, 40, 42, 43, 53, 55, 68, 74, 75, 77,
+            78, 80, 83, 84, 86, 87, 88, 89, 90, 92, 93, 95, 96, 97, 98, 99, 
100), (198, 2), 2, null, null);
+            Table.States (255).Kernel := To_Vector ((0 => (198, 259, 0, 
False)));
+            Table.States (255).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 198, 2)));
+            Table.States (256).Action_List.Set_Capacity (40);
+            Add_Action (Table.States (256), 10, Reduce, (259, 4), 2, 
primary_4'Access, null);
+            Add_Action (Table.States (256), 20, Reduce, (259, 4), 2, 
primary_4'Access, null);
+            Add_Action (Table.States (256), 21, Reduce, (259, 4), 2, 
primary_4'Access, null);
+            Add_Action (Table.States (256), 22, Reduce, (259, 4), 2, 
primary_4'Access, null);
+            Add_Action (Table.States (256), 23, Reduce, (259, 4), 2, 
primary_4'Access, null);
+            Add_Action (Table.States (256), 33, Reduce, (259, 4), 2, 
primary_4'Access, null);
+            Add_Action (Table.States (256), 35, Reduce, (259, 4), 2, 
primary_4'Access, null);
+            Add_Action (Table.States (256), 37, Reduce, (259, 4), 2, 
primary_4'Access, null);
+            Add_Action (Table.States (256), 38, Reduce, (259, 4), 2, 
primary_4'Access, null);
+            Add_Action (Table.States (256), 40, Reduce, (259, 4), 2, 
primary_4'Access, null);
+            Add_Action (Table.States (256), 42, Reduce, (259, 4), 2, 
primary_4'Access, null);
+            Add_Action (Table.States (256), 43, Reduce, (259, 4), 2, 
primary_4'Access, null);
+            Add_Action (Table.States (256), 53, Reduce, (259, 4), 2, 
primary_4'Access, null);
+            Add_Action (Table.States (256), 55, Reduce, (259, 4), 2, 
primary_4'Access, null);
+            Add_Action (Table.States (256), 68, Reduce, (259, 4), 2, 
primary_4'Access, null);
+            Add_Action (Table.States (256), 74, Reduce, (259, 4), 2, 
primary_4'Access, null);
+            Add_Action (Table.States (256), 75, Reduce, (259, 4), 2, 
primary_4'Access, null);
+            Add_Action (Table.States (256), 76, 236);
+            Add_Action (Table.States (256), 77, Reduce, (259, 4), 2, 
primary_4'Access, null);
+            Add_Action (Table.States (256), 78, Reduce, (259, 4), 2, 
primary_4'Access, null);
+            Add_Action (Table.States (256), 80, Reduce, (259, 4), 2, 
primary_4'Access, null);
+            Add_Action (Table.States (256), 83, Reduce, (259, 4), 2, 
primary_4'Access, null);
+            Add_Action (Table.States (256), 84, Reduce, (259, 4), 2, 
primary_4'Access, null);
+            Add_Action (Table.States (256), 85, 238);
+            Add_Action (Table.States (256), 86, Reduce, (259, 4), 2, 
primary_4'Access, null);
+            Add_Action (Table.States (256), 87, Reduce, (259, 4), 2, 
primary_4'Access, null);
+            Add_Action (Table.States (256), 88, Reduce, (259, 4), 2, 
primary_4'Access, null);
+            Add_Action (Table.States (256), 89, Reduce, (259, 4), 2, 
primary_4'Access, null);
+            Add_Action (Table.States (256), 90, Reduce, (259, 4), 2, 
primary_4'Access, null);
+            Add_Action (Table.States (256), 92, Reduce, (259, 4), 2, 
primary_4'Access, null);
+            Add_Action (Table.States (256), 93, Reduce, (259, 4), 2, 
primary_4'Access, null);
+            Add_Action (Table.States (256), 95, Reduce, (259, 4), 2, 
primary_4'Access, null);
+            Add_Action (Table.States (256), 96, Reduce, (259, 4), 2, 
primary_4'Access, null);
+            Add_Action (Table.States (256), 97, Reduce, (259, 4), 2, 
primary_4'Access, null);
+            Add_Action (Table.States (256), 98, Reduce, (259, 4), 2, 
primary_4'Access, null);
+            Add_Action (Table.States (256), 99, Reduce, (259, 4), 2, 
primary_4'Access, null);
+            Add_Action (Table.States (256), 100, Reduce, (259, 4), 2, 
primary_4'Access, null);
+            Add_Action (Table.States (256), 101, Reduce, (259, 4), 2, 
primary_4'Access, null);
+            Add_Action (Table.States (256), 102, 240);
+            Add_Action (Table.States (256), 103, 241);
+            Table.States (256).Goto_List.Set_Capacity (2);
+            Add_Goto (Table.States (256), 116, 242);
+            Add_Goto (Table.States (256), 323, 243);
+            Table.States (256).Kernel := To_Vector (((129, 240, 2, True), 
(240, 240, 5, True), (240, 240, 2, True),
+            (259, 240, 0, False), (273, 240, 3, True), (294, 240, 2, True), 
(294, 240, 2, True), (294, 240, 2, True),
+            (294, 240, 2, True)));
+            Table.States (256).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 259, 2)));
+            Table.States (257).Action_List.Set_Capacity (35);
+            Add_Action (Table.States (257), (10, 20, 21, 22, 23, 33, 35, 37, 
38, 40, 42, 43, 53, 55, 68, 74, 75, 77,
+            78, 80, 83, 84, 86, 87, 88, 89, 90, 92, 93, 95, 96, 97, 98, 99, 
100), (198, 3), 2, null, null);
+            Table.States (257).Kernel := To_Vector ((0 => (198, 259, 0, 
False)));
+            Table.States (257).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 198, 2)));
+            Table.States (258).Action_List.Set_Capacity (21);
+            Add_Action (Table.States (258), 10, Reduce, (276, 1), 2, null, 
null);
+            Add_Action (Table.States (258), 20, Reduce, (276, 1), 2, null, 
null);
+            Add_Action (Table.States (258), 21, Reduce, (276, 1), 2, null, 
null);
+            Add_Action (Table.States (258), 22, Reduce, (276, 1), 2, null, 
null);
+            Add_Action (Table.States (258), 23, Reduce, (276, 1), 2, null, 
null);
+            Add_Action (Table.States (258), 35, Reduce, (276, 1), 2, null, 
null);
+            Add_Action (Table.States (258), 37, Reduce, (276, 1), 2, null, 
null);
+            Add_Action (Table.States (258), 43, Reduce, (276, 1), 2, null, 
null);
+            Add_Action (Table.States (258), 53, Reduce, (276, 1), 2, null, 
null);
+            Add_Action (Table.States (258), 68, Reduce, (276, 1), 2, null, 
null);
+            Add_Action (Table.States (258), 74, 434);
+            Add_Conflict (Table.States (258), 74, (276, 1), 2, null, null);
+            Add_Action (Table.States (258), 75, Reduce, (276, 1), 2, null, 
null);
+            Add_Action (Table.States (258), 76, 236);
+            Add_Action (Table.States (258), 77, Reduce, (276, 1), 2, null, 
null);
+            Add_Action (Table.States (258), 80, Reduce, (276, 1), 2, null, 
null);
+            Add_Action (Table.States (258), 84, Reduce, (276, 1), 2, null, 
null);
+            Add_Action (Table.States (258), 85, 238);
+            Add_Action (Table.States (258), 88, Reduce, (276, 1), 2, null, 
null);
+            Add_Action (Table.States (258), 97, Reduce, (276, 1), 2, null, 
null);
+            Add_Action (Table.States (258), 102, 240);
+            Add_Action (Table.States (258), 103, 241);
+            Table.States (258).Goto_List.Set_Capacity (2);
+            Add_Goto (Table.States (258), 116, 242);
+            Add_Goto (Table.States (258), 323, 243);
+            Table.States (258).Kernel := To_Vector (((129, 240, 2, True), 
(240, 240, 5, True), (240, 240, 2, True),
+            (273, 240, 3, True), (276, 240, 1, True), (276, 240, 0, False), 
(294, 240, 2, True), (294, 240, 2, True),
+            (294, 240, 2, True), (294, 240, 2, True)));
+            Table.States (258).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 276, 2)));
+            Table.States (258).Minimal_Complete_Actions_Recursive := True;
+            Table.States (259).Action_List.Set_Capacity (14);
+            Add_Action (Table.States (259), 3, 122);
+            Add_Action (Table.States (259), 35, Reduce, (193, 1), 0, null, 
null);
+            Add_Action (Table.States (259), 39, 123);
+            Add_Action (Table.States (259), 40, 124);
+            Add_Action (Table.States (259), 41, 125);
+            Add_Action (Table.States (259), 52, 126);
+            Add_Action (Table.States (259), 76, 127);
+            Add_Action (Table.States (259), 79, 31);
+            Add_Action (Table.States (259), 95, 128);
+            Add_Action (Table.States (259), 96, 129);
+            Add_Action (Table.States (259), 104, 130);
+            Add_Action (Table.States (259), 105, 120);
+            Add_Action (Table.States (259), 106, 34);
+            Add_Action (Table.States (259), 107, 35);
+            Table.States (259).Goto_List.Set_Capacity (20);
+            Add_Goto (Table.States (259), 118, 131);
+            Add_Goto (Table.States (259), 129, 42);
+            Add_Goto (Table.States (259), 192, 132);
+            Add_Goto (Table.States (259), 193, 435);
+            Add_Goto (Table.States (259), 198, 134);
+            Add_Goto (Table.States (259), 240, 135);
+            Add_Goto (Table.States (259), 259, 136);
+            Add_Goto (Table.States (259), 273, 93);
+            Add_Goto (Table.States (259), 276, 137);
+            Add_Goto (Table.States (259), 283, 138);
+            Add_Goto (Table.States (259), 284, 139);
+            Add_Goto (Table.States (259), 285, 140);
+            Add_Goto (Table.States (259), 286, 141);
+            Add_Goto (Table.States (259), 287, 142);
+            Add_Goto (Table.States (259), 288, 143);
+            Add_Goto (Table.States (259), 294, 98);
+            Add_Goto (Table.States (259), 302, 144);
+            Add_Goto (Table.States (259), 321, 145);
+            Add_Goto (Table.States (259), 322, 146);
+            Add_Goto (Table.States (259), 331, 147);
+            Table.States (259).Kernel := To_Vector ((0 => (137, 15, 3, 
False)));
+            Table.States (259).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 193, 0)));
+            Table.States (260).Action_List.Set_Capacity (3);
+            Add_Action (Table.States (260), 9, 436);
+            Add_Action (Table.States (260), 62, 437);
+            Add_Action (Table.States (260), 105, 438);
+            Table.States (260).Goto_List.Set_Capacity (1);
+            Add_Goto (Table.States (260), 275, 439);
+            Table.States (260).Kernel := To_Vector (((125, 28, 4, False), 
(274, 28, 5, False)));
+            Table.States (260).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 105, 438)));
+            Table.States (261).Action_List.Set_Capacity (14);
+            Add_Action (Table.States (261), 3, 122);
+            Add_Action (Table.States (261), 39, 123);
+            Add_Action (Table.States (261), 40, 124);
+            Add_Action (Table.States (261), 41, 125);
+            Add_Action (Table.States (261), 52, 126);
+            Add_Action (Table.States (261), 68, Reduce, (193, 1), 0, null, 
null);
+            Add_Action (Table.States (261), 76, 127);
+            Add_Action (Table.States (261), 79, 31);
+            Add_Action (Table.States (261), 95, 128);
+            Add_Action (Table.States (261), 96, 129);
+            Add_Action (Table.States (261), 104, 130);
+            Add_Action (Table.States (261), 105, 120);
             Add_Action (Table.States (261), 106, 34);
-            Table.States (261).Goto_List.Set_Capacity (6);
-            Add_Goto (Table.States (261), 117, 130);
-            Add_Goto (Table.States (261), 128, 41);
-            Add_Goto (Table.States (261), 239, 134);
-            Add_Goto (Table.States (261), 258, 256);
-            Add_Goto (Table.States (261), 272, 92);
-            Add_Goto (Table.States (261), 293, 97);
-            Table.States (261).Kernel := To_Vector (((165, 40, 2, False), 
(197, 40, 1, False)));
-            Table.States (261).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 103, 129)));
-            Table.States (262).Action_List.Set_Capacity (26);
-            Add_Action (Table.States (262), 10, Reduce, (258, 1), 1, null, 
null);
-            Add_Action (Table.States (262), 33, Reduce, (258, 1), 1, null, 
null);
-            Add_Action (Table.States (262), 38, Reduce, (258, 1), 1, null, 
null);
-            Add_Action (Table.States (262), 40, Reduce, (258, 1), 1, null, 
null);
-            Add_Action (Table.States (262), 43, Reduce, (258, 1), 1, null, 
null);
-            Add_Action (Table.States (262), 54, 440);
-            Add_Action (Table.States (262), 55, Reduce, (258, 1), 1, null, 
null);
-            Add_Action (Table.States (262), 74, Reduce, (258, 1), 1, null, 
null);
-            Add_Action (Table.States (262), 75, Reduce, (258, 1), 1, null, 
null);
-            Add_Action (Table.States (262), 77, Reduce, (258, 1), 1, null, 
null);
-            Add_Action (Table.States (262), 78, Reduce, (258, 1), 1, null, 
null);
-            Add_Action (Table.States (262), 79, Reduce, (258, 1), 1, null, 
null);
-            Add_Action (Table.States (262), 83, Reduce, (258, 1), 1, null, 
null);
-            Add_Action (Table.States (262), 85, Reduce, (258, 1), 1, null, 
null);
-            Add_Action (Table.States (262), 86, Reduce, (258, 1), 1, null, 
null);
-            Add_Action (Table.States (262), 87, Reduce, (258, 1), 1, null, 
null);
-            Add_Action (Table.States (262), 88, Reduce, (258, 1), 1, null, 
null);
-            Add_Action (Table.States (262), 89, Reduce, (258, 1), 1, null, 
null);
-            Add_Action (Table.States (262), 91, Reduce, (258, 1), 1, null, 
null);
-            Add_Action (Table.States (262), 92, Reduce, (258, 1), 1, null, 
null);
-            Add_Action (Table.States (262), 94, Reduce, (258, 1), 1, null, 
null);
-            Add_Action (Table.States (262), 95, Reduce, (258, 1), 1, null, 
null);
-            Add_Action (Table.States (262), 97, Reduce, (258, 1), 1, null, 
null);
-            Add_Action (Table.States (262), 98, Reduce, (258, 1), 1, null, 
null);
-            Add_Action (Table.States (262), 99, Reduce, (258, 1), 1, null, 
null);
-            Add_Action (Table.States (262), 100, Reduce, (258, 1), 1, null, 
null);
-            Table.States (262).Kernel := To_Vector (((117, 41, 2, False), 
(258, 41, 0, False)));
-            Table.States (262).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 258, 1)));
-            Table.States (263).Action_List.Set_Capacity (2);
-            Add_Action (Table.States (263), (79, 87), (165, 3), 1, null, null);
-            Table.States (263).Kernel := To_Vector ((0 => (165, 44, 0, 
False)));
-            Table.States (263).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 165, 1)));
-            Table.States (264).Action_List.Set_Capacity (32);
-            Add_Action (Table.States (264), 10, Reduce, (239, 6), 1, null, 
null);
-            Add_Action (Table.States (264), 33, Reduce, (239, 6), 1, null, 
null);
-            Add_Action (Table.States (264), 35, Reduce, (239, 6), 1, null, 
null);
-            Add_Action (Table.States (264), 38, Reduce, (239, 6), 1, null, 
null);
-            Add_Action (Table.States (264), 40, Reduce, (239, 6), 1, null, 
null);
-            Add_Action (Table.States (264), 43, Reduce, (239, 6), 1, null, 
null);
-            Add_Action (Table.States (264), 53, Reduce, (239, 6), 1, null, 
null);
-            Add_Action (Table.States (264), 55, Reduce, (239, 6), 1, null, 
null);
-            Add_Action (Table.States (264), 74, Reduce, (239, 6), 1, null, 
null);
-            Add_Action (Table.States (264), 75, Reduce, (239, 6), 1, null, 
null);
-            Add_Action (Table.States (264), 76, Reduce, (239, 6), 1, null, 
null);
-            Add_Action (Table.States (264), 77, Reduce, (239, 6), 1, null, 
null);
-            Add_Action (Table.States (264), 78, Reduce, (239, 6), 1, null, 
null);
-            Add_Action (Table.States (264), 79, Reduce, (239, 6), 1, null, 
null);
-            Add_Action (Table.States (264), 83, Reduce, (239, 6), 1, null, 
null);
-            Add_Action (Table.States (264), 84, Reduce, (239, 6), 1, null, 
null);
-            Add_Action (Table.States (264), 85, Reduce, (239, 6), 1, null, 
null);
-            Add_Action (Table.States (264), 86, Reduce, (239, 6), 1, null, 
null);
-            Add_Action (Table.States (264), 87, 441);
-            Add_Conflict (Table.States (264), 87, (239, 6), 1, null, null);
-            Add_Action (Table.States (264), 88, Reduce, (239, 6), 1, null, 
null);
-            Add_Action (Table.States (264), 89, Reduce, (239, 6), 1, null, 
null);
-            Add_Action (Table.States (264), 91, Reduce, (239, 6), 1, null, 
null);
-            Add_Action (Table.States (264), 92, Reduce, (239, 6), 1, null, 
null);
-            Add_Action (Table.States (264), 94, Reduce, (239, 6), 1, null, 
null);
-            Add_Action (Table.States (264), 95, Reduce, (239, 6), 1, null, 
null);
-            Add_Action (Table.States (264), 96, Reduce, (239, 6), 1, null, 
null);
-            Add_Action (Table.States (264), 97, Reduce, (239, 6), 1, null, 
null);
-            Add_Action (Table.States (264), 98, Reduce, (239, 6), 1, null, 
null);
-            Add_Action (Table.States (264), 99, Reduce, (239, 6), 1, null, 
null);
-            Add_Action (Table.States (264), 100, Reduce, (239, 6), 1, null, 
null);
-            Add_Action (Table.States (264), 101, Reduce, (239, 6), 1, null, 
null);
-            Add_Action (Table.States (264), 102, Reduce, (239, 6), 1, null, 
null);
-            Table.States (264).Kernel := To_Vector (((124, 106, 1, False), 
(124, 106, 2, False), (239, 106, 0,
+            Add_Action (Table.States (261), 107, 35);
+            Table.States (261).Goto_List.Set_Capacity (20);
+            Add_Goto (Table.States (261), 118, 131);
+            Add_Goto (Table.States (261), 129, 42);
+            Add_Goto (Table.States (261), 192, 132);
+            Add_Goto (Table.States (261), 193, 440);
+            Add_Goto (Table.States (261), 198, 134);
+            Add_Goto (Table.States (261), 240, 135);
+            Add_Goto (Table.States (261), 259, 136);
+            Add_Goto (Table.States (261), 273, 93);
+            Add_Goto (Table.States (261), 276, 137);
+            Add_Goto (Table.States (261), 283, 138);
+            Add_Goto (Table.States (261), 284, 139);
+            Add_Goto (Table.States (261), 285, 140);
+            Add_Goto (Table.States (261), 286, 141);
+            Add_Goto (Table.States (261), 287, 142);
+            Add_Goto (Table.States (261), 288, 143);
+            Add_Goto (Table.States (261), 294, 98);
+            Add_Goto (Table.States (261), 302, 144);
+            Add_Goto (Table.States (261), 321, 145);
+            Add_Goto (Table.States (261), 322, 146);
+            Add_Goto (Table.States (261), 331, 147);
+            Table.States (261).Kernel := To_Vector (((222, 32, 4, False), 
(222, 32, 2, False), (222, 32, 3, False),
+            (222, 32, 1, False)));
+            Table.States (261).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 193, 0)));
+            Table.States (262).Action_List.Set_Capacity (8);
+            Add_Action (Table.States (262), 39, 123);
+            Add_Action (Table.States (262), 41, 441);
+            Add_Action (Table.States (262), 76, 127);
+            Add_Action (Table.States (262), 79, 31);
+            Add_Action (Table.States (262), 104, 130);
+            Add_Action (Table.States (262), 105, 120);
+            Add_Action (Table.States (262), 106, 34);
+            Add_Action (Table.States (262), 107, 35);
+            Table.States (262).Goto_List.Set_Capacity (6);
+            Add_Goto (Table.States (262), 118, 131);
+            Add_Goto (Table.States (262), 129, 42);
+            Add_Goto (Table.States (262), 240, 135);
+            Add_Goto (Table.States (262), 259, 257);
+            Add_Goto (Table.States (262), 273, 93);
+            Add_Goto (Table.States (262), 294, 98);
+            Table.States (262).Kernel := To_Vector (((166, 40, 2, False), 
(198, 40, 1, False)));
+            Table.States (262).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 104, 130)));
+            Table.States (263).Action_List.Set_Capacity (26);
+            Add_Action (Table.States (263), 10, Reduce, (259, 1), 1, null, 
null);
+            Add_Action (Table.States (263), 33, Reduce, (259, 1), 1, null, 
null);
+            Add_Action (Table.States (263), 38, Reduce, (259, 1), 1, null, 
null);
+            Add_Action (Table.States (263), 40, Reduce, (259, 1), 1, null, 
null);
+            Add_Action (Table.States (263), 43, Reduce, (259, 1), 1, null, 
null);
+            Add_Action (Table.States (263), 54, 442);
+            Add_Action (Table.States (263), 55, Reduce, (259, 1), 1, null, 
null);
+            Add_Action (Table.States (263), 74, Reduce, (259, 1), 1, null, 
null);
+            Add_Action (Table.States (263), 75, Reduce, (259, 1), 1, null, 
null);
+            Add_Action (Table.States (263), 77, Reduce, (259, 1), 1, null, 
null);
+            Add_Action (Table.States (263), 78, Reduce, (259, 1), 1, null, 
null);
+            Add_Action (Table.States (263), 80, Reduce, (259, 1), 1, null, 
null);
+            Add_Action (Table.States (263), 84, Reduce, (259, 1), 1, null, 
null);
+            Add_Action (Table.States (263), 86, Reduce, (259, 1), 1, null, 
null);
+            Add_Action (Table.States (263), 87, Reduce, (259, 1), 1, null, 
null);
+            Add_Action (Table.States (263), 88, Reduce, (259, 1), 1, null, 
null);
+            Add_Action (Table.States (263), 89, Reduce, (259, 1), 1, null, 
null);
+            Add_Action (Table.States (263), 90, Reduce, (259, 1), 1, null, 
null);
+            Add_Action (Table.States (263), 92, Reduce, (259, 1), 1, null, 
null);
+            Add_Action (Table.States (263), 93, Reduce, (259, 1), 1, null, 
null);
+            Add_Action (Table.States (263), 95, Reduce, (259, 1), 1, null, 
null);
+            Add_Action (Table.States (263), 96, Reduce, (259, 1), 1, null, 
null);
+            Add_Action (Table.States (263), 98, Reduce, (259, 1), 1, null, 
null);
+            Add_Action (Table.States (263), 99, Reduce, (259, 1), 1, null, 
null);
+            Add_Action (Table.States (263), 100, Reduce, (259, 1), 1, null, 
null);
+            Add_Action (Table.States (263), 101, Reduce, (259, 1), 1, null, 
null);
+            Table.States (263).Kernel := To_Vector (((118, 41, 2, False), 
(259, 41, 0, False)));
+            Table.States (263).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 259, 1)));
+            Table.States (264).Action_List.Set_Capacity (2);
+            Add_Action (Table.States (264), (80, 88), (166, 3), 1, null, null);
+            Table.States (264).Kernel := To_Vector ((0 => (166, 44, 0, 
False)));
+            Table.States (264).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 166, 1)));
+            Table.States (265).Action_List.Set_Capacity (32);
+            Add_Action (Table.States (265), 10, Reduce, (240, 6), 1, null, 
null);
+            Add_Action (Table.States (265), 33, Reduce, (240, 6), 1, null, 
null);
+            Add_Action (Table.States (265), 35, Reduce, (240, 6), 1, null, 
null);
+            Add_Action (Table.States (265), 38, Reduce, (240, 6), 1, null, 
null);
+            Add_Action (Table.States (265), 40, Reduce, (240, 6), 1, null, 
null);
+            Add_Action (Table.States (265), 43, Reduce, (240, 6), 1, null, 
null);
+            Add_Action (Table.States (265), 53, Reduce, (240, 6), 1, null, 
null);
+            Add_Action (Table.States (265), 55, Reduce, (240, 6), 1, null, 
null);
+            Add_Action (Table.States (265), 74, Reduce, (240, 6), 1, null, 
null);
+            Add_Action (Table.States (265), 75, Reduce, (240, 6), 1, null, 
null);
+            Add_Action (Table.States (265), 76, Reduce, (240, 6), 1, null, 
null);
+            Add_Action (Table.States (265), 77, Reduce, (240, 6), 1, null, 
null);
+            Add_Action (Table.States (265), 78, Reduce, (240, 6), 1, null, 
null);
+            Add_Action (Table.States (265), 80, Reduce, (240, 6), 1, null, 
null);
+            Add_Action (Table.States (265), 84, Reduce, (240, 6), 1, null, 
null);
+            Add_Action (Table.States (265), 85, Reduce, (240, 6), 1, null, 
null);
+            Add_Action (Table.States (265), 86, Reduce, (240, 6), 1, null, 
null);
+            Add_Action (Table.States (265), 87, Reduce, (240, 6), 1, null, 
null);
+            Add_Action (Table.States (265), 88, 443);
+            Add_Conflict (Table.States (265), 88, (240, 6), 1, null, null);
+            Add_Action (Table.States (265), 89, Reduce, (240, 6), 1, null, 
null);
+            Add_Action (Table.States (265), 90, Reduce, (240, 6), 1, null, 
null);
+            Add_Action (Table.States (265), 92, Reduce, (240, 6), 1, null, 
null);
+            Add_Action (Table.States (265), 93, Reduce, (240, 6), 1, null, 
null);
+            Add_Action (Table.States (265), 95, Reduce, (240, 6), 1, null, 
null);
+            Add_Action (Table.States (265), 96, Reduce, (240, 6), 1, null, 
null);
+            Add_Action (Table.States (265), 97, Reduce, (240, 6), 1, null, 
null);
+            Add_Action (Table.States (265), 98, Reduce, (240, 6), 1, null, 
null);
+            Add_Action (Table.States (265), 99, Reduce, (240, 6), 1, null, 
null);
+            Add_Action (Table.States (265), 100, Reduce, (240, 6), 1, null, 
null);
+            Add_Action (Table.States (265), 101, Reduce, (240, 6), 1, null, 
null);
+            Add_Action (Table.States (265), 102, Reduce, (240, 6), 1, null, 
null);
+            Add_Action (Table.States (265), 103, Reduce, (240, 6), 1, null, 
null);
+            Table.States (265).Kernel := To_Vector (((125, 107, 1, False), 
(125, 107, 2, False), (240, 107, 0,
             False)));
-            Table.States (264).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 239, 1)));
-            Table.States (265).Action_List.Set_Capacity (4);
-            Add_Action (Table.States (265), (35, 77, 83, 96), (125, 1), 1, 
null, null);
-            Table.States (265).Kernel := To_Vector ((0 => (125, 124, 0, 
False)));
-            Table.States (265).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 125, 1)));
-            Table.States (266).Action_List.Set_Capacity (2);
-            Add_Action (Table.States (266), 77, 442);
-            Add_Action (Table.States (266), 83, 443);
-            Table.States (266).Kernel := To_Vector (((117, 125, 1, False), 
(125, 125, 1, True)));
-            Table.States (266).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 77, 442)));
-            Table.States (267).Action_List.Set_Capacity (1);
-            Add_Action (Table.States (267), (1 =>  77), (153, 1), 1, null, 
null);
-            Table.States (267).Kernel := To_Vector ((0 => (153, 136, 0, 
False)));
-            Table.States (267).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 153, 1)));
+            Table.States (265).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 240, 1)));
+            Table.States (266).Action_List.Set_Capacity (4);
+            Add_Action (Table.States (266), (35, 77, 84, 97), (126, 1), 1, 
null, null);
+            Table.States (266).Kernel := To_Vector ((0 => (126, 125, 0, 
False)));
+            Table.States (266).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 126, 1)));
+            Table.States (267).Action_List.Set_Capacity (2);
+            Add_Action (Table.States (267), 77, 444);
+            Add_Action (Table.States (267), 84, 445);
+            Table.States (267).Kernel := To_Vector (((118, 126, 1, False), 
(126, 126, 1, True)));
+            Table.States (267).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 77, 444)));
             Table.States (268).Action_List.Set_Capacity (1);
-            Add_Action (Table.States (268), 77, 444);
-            Table.States (268).Kernel := To_Vector ((0 => (117, 153, 1, 
False)));
-            Table.States (268).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 77, 444)));
-            Table.States (269).Action_List.Set_Capacity (2);
-            Add_Action (Table.States (269), (79, 87), (166, 1), 1, null, null);
-            Table.States (269).Kernel := To_Vector ((0 => (166, 165, 0, 
False)));
-            Table.States (269).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 166, 1)));
+            Add_Action (Table.States (268), (1 =>  77), (154, 1), 1, null, 
null);
+            Table.States (268).Kernel := To_Vector ((0 => (154, 137, 0, 
False)));
+            Table.States (268).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 154, 1)));
+            Table.States (269).Action_List.Set_Capacity (1);
+            Add_Action (Table.States (269), 77, 446);
+            Table.States (269).Kernel := To_Vector ((0 => (118, 154, 1, 
False)));
+            Table.States (269).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 77, 446)));
             Table.States (270).Action_List.Set_Capacity (2);
-            Add_Action (Table.States (270), 79, 445);
-            Add_Action (Table.States (270), 87, 446);
-            Table.States (270).Kernel := To_Vector (((124, 166, 1, False), 
(124, 166, 2, False), (166, 166, 2, True)));
-            Table.States (270).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 87, 446)));
-            Table.States (271).Action_List.Set_Capacity (5);
-            Add_Action (Table.States (271), 74, Reduce, (192, 0), 1, null, 
null);
-            Add_Action (Table.States (271), 77, Reduce, (124, 4), 1, 
association_opt_4'Access, null);
-            Add_Conflict (Table.States (271), 77, (192, 0), 1, null, null);
-            Add_Action (Table.States (271), 79, Reduce, (165, 0), 1, null, 
null);
-            Add_Action (Table.States (271), 83, Reduce, (124, 4), 1, 
association_opt_4'Access, null);
-            Add_Action (Table.States (271), 87, Reduce, (165, 0), 1, null, 
null);
-            Table.States (271).Kernel := To_Vector (((124, 191, 0, False), 
(165, 191, 0, False), (192, 191, 0, True)));
-            Table.States (271).Minimal_Complete_Actions := To_Vector 
(((Reduce, 124, 1), (Reduce, 165, 1), (Reduce,
-            192, 1)));
-            Table.States (271).Minimal_Complete_Actions_Recursive := True;
-            Table.States (272).Action_List.Set_Capacity (1);
-            Add_Action (Table.States (272), 74, 447);
-            Table.States (272).Kernel := To_Vector (((117, 192, 4, False), 
(117, 192, 2, False)));
-            Table.States (272).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 74, 447)));
+            Add_Action (Table.States (270), (80, 88), (167, 1), 1, null, null);
+            Table.States (270).Kernel := To_Vector ((0 => (167, 166, 0, 
False)));
+            Table.States (270).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 167, 1)));
+            Table.States (271).Action_List.Set_Capacity (2);
+            Add_Action (Table.States (271), 80, 447);
+            Add_Action (Table.States (271), 88, 448);
+            Table.States (271).Kernel := To_Vector (((125, 167, 1, False), 
(125, 167, 2, False), (167, 167, 2, True)));
+            Table.States (271).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 88, 448)));
+            Table.States (272).Action_List.Set_Capacity (5);
+            Add_Action (Table.States (272), 74, 449);
+            Add_Conflict (Table.States (272), 74, (193, 0), 1, null, null);
+            Add_Action (Table.States (272), 77, Reduce, (125, 5), 1, 
association_opt_5'Access, null);
+            Add_Conflict (Table.States (272), 77, (193, 0), 1, null, null);
+            Add_Action (Table.States (272), 80, Reduce, (166, 0), 1, null, 
null);
+            Add_Action (Table.States (272), 84, Reduce, (125, 5), 1, 
association_opt_5'Access, null);
+            Add_Action (Table.States (272), 88, Reduce, (166, 0), 1, null, 
null);
+            Table.States (272).Kernel := To_Vector (((118, 192, 3, False), 
(125, 192, 0, False), (166, 192, 0, False),
+            (193, 192, 0, True)));
+            Table.States (272).Minimal_Complete_Actions := To_Vector 
(((Reduce, 125, 1), (Reduce, 166, 1), (Reduce,
+            193, 1)));
+            Table.States (272).Minimal_Complete_Actions_Recursive := True;
             Table.States (273).Action_List.Set_Capacity (1);
-            Add_Action (Table.States (273), (1 =>  77), (153, 0), 1, null, 
null);
-            Table.States (273).Kernel := To_Vector ((0 => (153, 221, 0, 
False)));
-            Table.States (273).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 153, 1)));
-            Table.States (274).Action_List.Set_Capacity (38);
-            Add_Action (Table.States (274), 10, Reduce, (258, 3), 1, null, 
null);
-            Add_Action (Table.States (274), 20, Reduce, (258, 3), 1, null, 
null);
-            Add_Action (Table.States (274), 21, Reduce, (258, 3), 1, null, 
null);
-            Add_Action (Table.States (274), 22, Reduce, (258, 3), 1, null, 
null);
-            Add_Action (Table.States (274), 23, Reduce, (258, 3), 1, null, 
null);
-            Add_Action (Table.States (274), 33, Reduce, (258, 3), 1, null, 
null);
-            Add_Action (Table.States (274), 35, Reduce, (258, 3), 1, null, 
null);
-            Add_Action (Table.States (274), 37, Reduce, (258, 3), 1, null, 
null);
-            Add_Action (Table.States (274), 38, Reduce, (258, 3), 1, null, 
null);
-            Add_Action (Table.States (274), 40, Reduce, (258, 3), 1, null, 
null);
-            Add_Action (Table.States (274), 43, Reduce, (258, 3), 1, null, 
null);
-            Add_Action (Table.States (274), 53, Reduce, (258, 3), 1, null, 
null);
-            Add_Action (Table.States (274), 55, Reduce, (258, 3), 1, null, 
null);
-            Add_Action (Table.States (274), 68, Reduce, (258, 3), 1, null, 
null);
-            Add_Action (Table.States (274), 74, Reduce, (258, 3), 1, null, 
null);
-            Add_Action (Table.States (274), 75, Reduce, (258, 3), 1, null, 
null);
-            Add_Action (Table.States (274), 76, 235);
-            Add_Action (Table.States (274), 77, Reduce, (258, 3), 1, null, 
null);
-            Add_Action (Table.States (274), 78, Reduce, (258, 3), 1, null, 
null);
-            Add_Action (Table.States (274), 79, Reduce, (258, 3), 1, null, 
null);
-            Add_Action (Table.States (274), 83, Reduce, (258, 3), 1, null, 
null);
-            Add_Action (Table.States (274), 84, 237);
-            Add_Action (Table.States (274), 85, Reduce, (258, 3), 1, null, 
null);
-            Add_Action (Table.States (274), 86, Reduce, (258, 3), 1, null, 
null);
-            Add_Action (Table.States (274), 87, Reduce, (258, 3), 1, null, 
null);
-            Add_Action (Table.States (274), 88, Reduce, (258, 3), 1, null, 
null);
-            Add_Action (Table.States (274), 89, Reduce, (258, 3), 1, null, 
null);
-            Add_Action (Table.States (274), 91, Reduce, (258, 3), 1, null, 
null);
-            Add_Action (Table.States (274), 92, Reduce, (258, 3), 1, null, 
null);
-            Add_Action (Table.States (274), 94, Reduce, (258, 3), 1, null, 
null);
-            Add_Action (Table.States (274), 95, Reduce, (258, 3), 1, null, 
null);
-            Add_Action (Table.States (274), 96, Reduce, (258, 3), 1, null, 
null);
-            Add_Action (Table.States (274), 97, Reduce, (258, 3), 1, null, 
null);
-            Add_Action (Table.States (274), 98, Reduce, (258, 3), 1, null, 
null);
-            Add_Action (Table.States (274), 99, Reduce, (258, 3), 1, null, 
null);
-            Add_Action (Table.States (274), 100, Reduce, (258, 3), 1, null, 
null);
-            Add_Action (Table.States (274), 101, 239);
-            Add_Action (Table.States (274), 102, 240);
-            Table.States (274).Goto_List.Set_Capacity (2);
-            Add_Goto (Table.States (274), 115, 241);
-            Add_Goto (Table.States (274), 322, 448);
-            Table.States (274).Kernel := To_Vector (((128, 239, 2, True), 
(239, 239, 5, True), (239, 239, 2, True),
-            (258, 239, 0, False), (272, 239, 3, True), (277, 239, 4, False), 
(277, 239, 2, False), (293, 239, 2, True),
-            (293, 239, 2, True), (293, 239, 2, True), (293, 239, 2, True)));
-            Table.States (274).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 258, 1)));
-            Table.States (275).Action_List.Set_Capacity (1);
-            Add_Action (Table.States (275), (1 =>  77), (153, 2), 1, null, 
null);
-            Table.States (275).Kernel := To_Vector ((0 => (153, 273, 0, 
False)));
-            Table.States (275).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 153, 1)));
-            Table.States (276).Action_List.Set_Capacity (2);
-            Add_Action (Table.States (276), (79, 87), (165, 2), 1, null, null);
-            Table.States (276).Kernel := To_Vector ((0 => (165, 277, 0, 
False)));
-            Table.States (276).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 165, 1)));
-            Table.States (277).Action_List.Set_Capacity (19);
-            Add_Action (Table.States (277), 10, Reduce, (287, 3), 1, null, 
null);
-            Add_Action (Table.States (277), 33, 288);
-            Add_Action (Table.States (277), 35, Reduce, (287, 3), 1, null, 
null);
-            Add_Action (Table.States (277), 40, 289);
-            Add_Action (Table.States (277), 43, Reduce, (287, 3), 1, null, 
null);
-            Add_Action (Table.States (277), 74, Reduce, (287, 3), 1, null, 
null);
-            Add_Action (Table.States (277), 75, Reduce, (287, 3), 1, null, 
null);
-            Add_Action (Table.States (277), 77, Reduce, (287, 3), 1, null, 
null);
-            Add_Action (Table.States (277), 79, Reduce, (287, 3), 1, null, 
null);
-            Add_Action (Table.States (277), 83, Reduce, (287, 3), 1, null, 
null);
-            Add_Action (Table.States (277), 85, 449);
-            Add_Action (Table.States (277), 86, 290);
-            Add_Action (Table.States (277), 87, Reduce, (287, 3), 1, null, 
null);
-            Add_Action (Table.States (277), 88, 291);
-            Add_Action (Table.States (277), 89, 292);
-            Add_Action (Table.States (277), 91, 293);
-            Add_Action (Table.States (277), 92, 294);
-            Add_Action (Table.States (277), 96, Reduce, (287, 3), 1, null, 
null);
-            Add_Action (Table.States (277), 98, 295);
-            Table.States (277).Goto_List.Set_Capacity (1);
-            Add_Goto (Table.States (277), 288, 296);
-            Table.States (277).Kernel := To_Vector (((277, 301, 2, False), 
(287, 301, 3, False), (287, 301, 2, False),
-            (287, 301, 2, False), (287, 301, 0, False)));
-            Table.States (277).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 287, 1)));
-            Table.States (278).Action_List.Set_Capacity (1);
-            Add_Action (Table.States (278), 72, 450);
-            Table.States (278).Goto_List.Set_Capacity (2);
-            Add_Goto (Table.States (278), 140, 451);
-            Add_Goto (Table.States (278), 141, 452);
-            Table.States (278).Kernel := To_Vector ((0 => (139, 35, 5, 
False)));
-            Table.States (278).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 72, 450)));
-            Table.States (279).Action_List.Set_Capacity (7);
-            Add_Action (Table.States (279), 39, 122);
-            Add_Action (Table.States (279), 41, 124);
-            Add_Action (Table.States (279), 76, 126);
-            Add_Action (Table.States (279), 103, 129);
-            Add_Action (Table.States (279), 104, 119);
-            Add_Action (Table.States (279), 105, 33);
-            Add_Action (Table.States (279), 106, 34);
-            Table.States (279).Goto_List.Set_Capacity (6);
-            Add_Goto (Table.States (279), 117, 130);
-            Add_Goto (Table.States (279), 128, 41);
-            Add_Goto (Table.States (279), 239, 134);
-            Add_Goto (Table.States (279), 258, 453);
-            Add_Goto (Table.States (279), 272, 92);
-            Add_Goto (Table.States (279), 293, 97);
-            Table.States (279).Kernel := To_Vector ((0 => (197, 100, 1, 
False)));
-            Table.States (279).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 103, 129)));
-            Table.States (280).Action_List.Set_Capacity (12);
-            Add_Action (Table.States (280), 3, 121);
-            Add_Action (Table.States (280), 39, 122);
-            Add_Action (Table.States (280), 40, 123);
-            Add_Action (Table.States (280), 41, 124);
-            Add_Action (Table.States (280), 52, 125);
-            Add_Action (Table.States (280), 76, 126);
-            Add_Action (Table.States (280), 94, 127);
-            Add_Action (Table.States (280), 95, 128);
-            Add_Action (Table.States (280), 103, 129);
-            Add_Action (Table.States (280), 104, 119);
-            Add_Action (Table.States (280), 105, 33);
+            Add_Action (Table.States (273), 74, 450);
+            Table.States (273).Kernel := To_Vector (((118, 193, 4, False), 
(118, 193, 2, False)));
+            Table.States (273).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 74, 450)));
+            Table.States (274).Action_List.Set_Capacity (1);
+            Add_Action (Table.States (274), (1 =>  77), (154, 0), 1, null, 
null);
+            Table.States (274).Kernel := To_Vector ((0 => (154, 222, 0, 
False)));
+            Table.States (274).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 154, 1)));
+            Table.States (275).Action_List.Set_Capacity (38);
+            Add_Action (Table.States (275), 10, Reduce, (259, 3), 1, null, 
null);
+            Add_Action (Table.States (275), 20, Reduce, (259, 3), 1, null, 
null);
+            Add_Action (Table.States (275), 21, Reduce, (259, 3), 1, null, 
null);
+            Add_Action (Table.States (275), 22, Reduce, (259, 3), 1, null, 
null);
+            Add_Action (Table.States (275), 23, Reduce, (259, 3), 1, null, 
null);
+            Add_Action (Table.States (275), 33, Reduce, (259, 3), 1, null, 
null);
+            Add_Action (Table.States (275), 35, Reduce, (259, 3), 1, null, 
null);
+            Add_Action (Table.States (275), 37, Reduce, (259, 3), 1, null, 
null);
+            Add_Action (Table.States (275), 38, Reduce, (259, 3), 1, null, 
null);
+            Add_Action (Table.States (275), 40, Reduce, (259, 3), 1, null, 
null);
+            Add_Action (Table.States (275), 43, Reduce, (259, 3), 1, null, 
null);
+            Add_Action (Table.States (275), 53, Reduce, (259, 3), 1, null, 
null);
+            Add_Action (Table.States (275), 55, Reduce, (259, 3), 1, null, 
null);
+            Add_Action (Table.States (275), 68, Reduce, (259, 3), 1, null, 
null);
+            Add_Action (Table.States (275), 74, Reduce, (259, 3), 1, null, 
null);
+            Add_Action (Table.States (275), 75, Reduce, (259, 3), 1, null, 
null);
+            Add_Action (Table.States (275), 76, 236);
+            Add_Action (Table.States (275), 77, Reduce, (259, 3), 1, null, 
null);
+            Add_Action (Table.States (275), 78, Reduce, (259, 3), 1, null, 
null);
+            Add_Action (Table.States (275), 80, Reduce, (259, 3), 1, null, 
null);
+            Add_Action (Table.States (275), 84, Reduce, (259, 3), 1, null, 
null);
+            Add_Action (Table.States (275), 85, 238);
+            Add_Action (Table.States (275), 86, Reduce, (259, 3), 1, null, 
null);
+            Add_Action (Table.States (275), 87, Reduce, (259, 3), 1, null, 
null);
+            Add_Action (Table.States (275), 88, Reduce, (259, 3), 1, null, 
null);
+            Add_Action (Table.States (275), 89, Reduce, (259, 3), 1, null, 
null);
+            Add_Action (Table.States (275), 90, Reduce, (259, 3), 1, null, 
null);
+            Add_Action (Table.States (275), 92, Reduce, (259, 3), 1, null, 
null);
+            Add_Action (Table.States (275), 93, Reduce, (259, 3), 1, null, 
null);
+            Add_Action (Table.States (275), 95, Reduce, (259, 3), 1, null, 
null);
+            Add_Action (Table.States (275), 96, Reduce, (259, 3), 1, null, 
null);
+            Add_Action (Table.States (275), 97, Reduce, (259, 3), 1, null, 
null);
+            Add_Action (Table.States (275), 98, Reduce, (259, 3), 1, null, 
null);
+            Add_Action (Table.States (275), 99, Reduce, (259, 3), 1, null, 
null);
+            Add_Action (Table.States (275), 100, Reduce, (259, 3), 1, null, 
null);
+            Add_Action (Table.States (275), 101, Reduce, (259, 3), 1, null, 
null);
+            Add_Action (Table.States (275), 102, 240);
+            Add_Action (Table.States (275), 103, 241);
+            Table.States (275).Goto_List.Set_Capacity (2);
+            Add_Goto (Table.States (275), 116, 242);
+            Add_Goto (Table.States (275), 323, 451);
+            Table.States (275).Kernel := To_Vector (((129, 240, 2, True), 
(240, 240, 5, True), (240, 240, 2, True),
+            (259, 240, 0, False), (273, 240, 3, True), (278, 240, 4, False), 
(278, 240, 2, False), (294, 240, 2, True),
+            (294, 240, 2, True), (294, 240, 2, True), (294, 240, 2, True)));
+            Table.States (275).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 259, 1)));
+            Table.States (276).Action_List.Set_Capacity (1);
+            Add_Action (Table.States (276), (1 =>  77), (154, 2), 1, null, 
null);
+            Table.States (276).Kernel := To_Vector ((0 => (154, 274, 0, 
False)));
+            Table.States (276).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 154, 1)));
+            Table.States (277).Action_List.Set_Capacity (2);
+            Add_Action (Table.States (277), (80, 88), (166, 2), 1, null, null);
+            Table.States (277).Kernel := To_Vector ((0 => (166, 278, 0, 
False)));
+            Table.States (277).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 166, 1)));
+            Table.States (278).Action_List.Set_Capacity (19);
+            Add_Action (Table.States (278), 10, Reduce, (288, 3), 1, null, 
null);
+            Add_Action (Table.States (278), 33, 289);
+            Add_Action (Table.States (278), 35, Reduce, (288, 3), 1, null, 
null);
+            Add_Action (Table.States (278), 40, 290);
+            Add_Action (Table.States (278), 43, Reduce, (288, 3), 1, null, 
null);
+            Add_Action (Table.States (278), 74, Reduce, (288, 3), 1, null, 
null);
+            Add_Action (Table.States (278), 75, Reduce, (288, 3), 1, null, 
null);
+            Add_Action (Table.States (278), 77, Reduce, (288, 3), 1, null, 
null);
+            Add_Action (Table.States (278), 80, Reduce, (288, 3), 1, null, 
null);
+            Add_Action (Table.States (278), 84, Reduce, (288, 3), 1, null, 
null);
+            Add_Action (Table.States (278), 86, 452);
+            Add_Action (Table.States (278), 87, 291);
+            Add_Action (Table.States (278), 88, Reduce, (288, 3), 1, null, 
null);
+            Add_Action (Table.States (278), 89, 292);
+            Add_Action (Table.States (278), 90, 293);
+            Add_Action (Table.States (278), 92, 294);
+            Add_Action (Table.States (278), 93, 295);
+            Add_Action (Table.States (278), 97, Reduce, (288, 3), 1, null, 
null);
+            Add_Action (Table.States (278), 99, 296);
+            Table.States (278).Goto_List.Set_Capacity (1);
+            Add_Goto (Table.States (278), 289, 297);
+            Table.States (278).Kernel := To_Vector (((278, 302, 2, False), 
(288, 302, 3, False), (288, 302, 2, False),
+            (288, 302, 2, False), (288, 302, 0, False)));
+            Table.States (278).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 288, 1)));
+            Table.States (279).Action_List.Set_Capacity (1);
+            Add_Action (Table.States (279), 72, 453);
+            Table.States (279).Goto_List.Set_Capacity (2);
+            Add_Goto (Table.States (279), 141, 454);
+            Add_Goto (Table.States (279), 142, 455);
+            Table.States (279).Kernel := To_Vector ((0 => (140, 35, 5, 
False)));
+            Table.States (279).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 72, 453)));
+            Table.States (280).Action_List.Set_Capacity (8);
+            Add_Action (Table.States (280), 39, 123);
+            Add_Action (Table.States (280), 41, 125);
+            Add_Action (Table.States (280), 76, 127);
+            Add_Action (Table.States (280), 79, 31);
+            Add_Action (Table.States (280), 104, 130);
+            Add_Action (Table.States (280), 105, 120);
             Add_Action (Table.States (280), 106, 34);
-            Table.States (280).Goto_List.Set_Capacity (13);
-            Add_Goto (Table.States (280), 117, 130);
-            Add_Goto (Table.States (280), 128, 41);
-            Add_Goto (Table.States (280), 197, 133);
-            Add_Goto (Table.States (280), 239, 134);
-            Add_Goto (Table.States (280), 258, 135);
-            Add_Goto (Table.States (280), 272, 92);
-            Add_Goto (Table.States (280), 275, 136);
-            Add_Goto (Table.States (280), 287, 454);
-            Add_Goto (Table.States (280), 293, 97);
-            Add_Goto (Table.States (280), 301, 143);
-            Add_Goto (Table.States (280), 320, 144);
-            Add_Goto (Table.States (280), 321, 145);
-            Add_Goto (Table.States (280), 330, 146);
-            Table.States (280).Kernel := To_Vector ((0 => (282, 10, 1, True)));
-            Table.States (280).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 103, 129)));
-            Table.States (280).Minimal_Complete_Actions_Recursive := True;
-            Table.States (281).Action_List.Set_Capacity (1);
-            Add_Action (Table.States (281), 68, 455);
-            Table.States (281).Kernel := To_Vector ((0 => (283, 10, 2, True)));
-            Table.States (281).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 68, 455)));
+            Add_Action (Table.States (280), 107, 35);
+            Table.States (280).Goto_List.Set_Capacity (6);
+            Add_Goto (Table.States (280), 118, 131);
+            Add_Goto (Table.States (280), 129, 42);
+            Add_Goto (Table.States (280), 240, 135);
+            Add_Goto (Table.States (280), 259, 456);
+            Add_Goto (Table.States (280), 273, 93);
+            Add_Goto (Table.States (280), 294, 98);
+            Table.States (280).Kernel := To_Vector ((0 => (198, 101, 1, 
False)));
+            Table.States (280).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 104, 130)));
+            Table.States (281).Action_List.Set_Capacity (13);
+            Add_Action (Table.States (281), 3, 122);
+            Add_Action (Table.States (281), 39, 123);
+            Add_Action (Table.States (281), 40, 124);
+            Add_Action (Table.States (281), 41, 125);
+            Add_Action (Table.States (281), 52, 126);
+            Add_Action (Table.States (281), 76, 127);
+            Add_Action (Table.States (281), 79, 31);
+            Add_Action (Table.States (281), 95, 128);
+            Add_Action (Table.States (281), 96, 129);
+            Add_Action (Table.States (281), 104, 130);
+            Add_Action (Table.States (281), 105, 120);
+            Add_Action (Table.States (281), 106, 34);
+            Add_Action (Table.States (281), 107, 35);
+            Table.States (281).Goto_List.Set_Capacity (13);
+            Add_Goto (Table.States (281), 118, 131);
+            Add_Goto (Table.States (281), 129, 42);
+            Add_Goto (Table.States (281), 198, 134);
+            Add_Goto (Table.States (281), 240, 135);
+            Add_Goto (Table.States (281), 259, 136);
+            Add_Goto (Table.States (281), 273, 93);
+            Add_Goto (Table.States (281), 276, 137);
+            Add_Goto (Table.States (281), 288, 457);
+            Add_Goto (Table.States (281), 294, 98);
+            Add_Goto (Table.States (281), 302, 144);
+            Add_Goto (Table.States (281), 321, 145);
+            Add_Goto (Table.States (281), 322, 146);
+            Add_Goto (Table.States (281), 331, 147);
+            Table.States (281).Kernel := To_Vector ((0 => (283, 10, 1, True)));
+            Table.States (281).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 104, 130)));
             Table.States (281).Minimal_Complete_Actions_Recursive := True;
-            Table.States (282).Action_List.Set_Capacity (12);
-            Add_Action (Table.States (282), 3, 121);
-            Add_Action (Table.States (282), 39, 122);
-            Add_Action (Table.States (282), 40, 123);
-            Add_Action (Table.States (282), 41, 124);
-            Add_Action (Table.States (282), 52, 125);
-            Add_Action (Table.States (282), 76, 126);
-            Add_Action (Table.States (282), 94, 127);
-            Add_Action (Table.States (282), 95, 128);
-            Add_Action (Table.States (282), 103, 129);
-            Add_Action (Table.States (282), 104, 119);
-            Add_Action (Table.States (282), 105, 33);
-            Add_Action (Table.States (282), 106, 34);
-            Table.States (282).Goto_List.Set_Capacity (13);
-            Add_Goto (Table.States (282), 117, 130);
-            Add_Goto (Table.States (282), 128, 41);
-            Add_Goto (Table.States (282), 197, 133);
-            Add_Goto (Table.States (282), 239, 134);
-            Add_Goto (Table.States (282), 258, 135);
-            Add_Goto (Table.States (282), 272, 92);
-            Add_Goto (Table.States (282), 275, 136);
-            Add_Goto (Table.States (282), 287, 456);
-            Add_Goto (Table.States (282), 293, 97);
-            Add_Goto (Table.States (282), 301, 143);
-            Add_Goto (Table.States (282), 320, 144);
-            Add_Goto (Table.States (282), 321, 145);
-            Add_Goto (Table.States (282), 330, 146);
-            Table.States (282).Kernel := To_Vector ((0 => (284, 43, 1, True)));
-            Table.States (282).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 103, 129)));
-            Table.States (282).Minimal_Complete_Actions_Recursive := True;
-            Table.States (283).Action_List.Set_Capacity (1);
-            Add_Action (Table.States (283), 22, 457);
-            Table.States (283).Kernel := To_Vector ((0 => (285, 43, 2, True)));
-            Table.States (283).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 22, 457)));
-            Table.States (283).Minimal_Complete_Actions_Recursive := True;
-            Table.States (284).Action_List.Set_Capacity (12);
-            Add_Action (Table.States (284), 3, 121);
-            Add_Action (Table.States (284), 39, 122);
-            Add_Action (Table.States (284), 40, 123);
-            Add_Action (Table.States (284), 41, 124);
-            Add_Action (Table.States (284), 52, 125);
-            Add_Action (Table.States (284), 76, 126);
-            Add_Action (Table.States (284), 94, 127);
-            Add_Action (Table.States (284), 95, 128);
-            Add_Action (Table.States (284), 103, 129);
-            Add_Action (Table.States (284), 104, 119);
-            Add_Action (Table.States (284), 105, 33);
-            Add_Action (Table.States (284), 106, 34);
-            Table.States (284).Goto_List.Set_Capacity (13);
-            Add_Goto (Table.States (284), 117, 130);
-            Add_Goto (Table.States (284), 128, 41);
-            Add_Goto (Table.States (284), 197, 133);
-            Add_Goto (Table.States (284), 239, 134);
-            Add_Goto (Table.States (284), 258, 135);
-            Add_Goto (Table.States (284), 272, 92);
-            Add_Goto (Table.States (284), 275, 136);
-            Add_Goto (Table.States (284), 287, 458);
-            Add_Goto (Table.States (284), 293, 97);
-            Add_Goto (Table.States (284), 301, 143);
-            Add_Goto (Table.States (284), 320, 144);
-            Add_Goto (Table.States (284), 321, 145);
-            Add_Goto (Table.States (284), 330, 146);
-            Table.States (284).Kernel := To_Vector ((0 => (286, 75, 1, True)));
-            Table.States (284).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 103, 129)));
-            Table.States (284).Minimal_Complete_Actions_Recursive := True;
          end Subr_5;
          procedure Subr_6
          is begin
+            Table.States (282).Action_List.Set_Capacity (1);
+            Add_Action (Table.States (282), 68, 458);
+            Table.States (282).Kernel := To_Vector ((0 => (284, 10, 2, True)));
+            Table.States (282).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 68, 458)));
+            Table.States (282).Minimal_Complete_Actions_Recursive := True;
+            Table.States (283).Action_List.Set_Capacity (13);
+            Add_Action (Table.States (283), 3, 122);
+            Add_Action (Table.States (283), 39, 123);
+            Add_Action (Table.States (283), 40, 124);
+            Add_Action (Table.States (283), 41, 125);
+            Add_Action (Table.States (283), 52, 126);
+            Add_Action (Table.States (283), 76, 127);
+            Add_Action (Table.States (283), 79, 31);
+            Add_Action (Table.States (283), 95, 128);
+            Add_Action (Table.States (283), 96, 129);
+            Add_Action (Table.States (283), 104, 130);
+            Add_Action (Table.States (283), 105, 120);
+            Add_Action (Table.States (283), 106, 34);
+            Add_Action (Table.States (283), 107, 35);
+            Table.States (283).Goto_List.Set_Capacity (13);
+            Add_Goto (Table.States (283), 118, 131);
+            Add_Goto (Table.States (283), 129, 42);
+            Add_Goto (Table.States (283), 198, 134);
+            Add_Goto (Table.States (283), 240, 135);
+            Add_Goto (Table.States (283), 259, 136);
+            Add_Goto (Table.States (283), 273, 93);
+            Add_Goto (Table.States (283), 276, 137);
+            Add_Goto (Table.States (283), 288, 459);
+            Add_Goto (Table.States (283), 294, 98);
+            Add_Goto (Table.States (283), 302, 144);
+            Add_Goto (Table.States (283), 321, 145);
+            Add_Goto (Table.States (283), 322, 146);
+            Add_Goto (Table.States (283), 331, 147);
+            Table.States (283).Kernel := To_Vector ((0 => (285, 43, 1, True)));
+            Table.States (283).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 104, 130)));
+            Table.States (283).Minimal_Complete_Actions_Recursive := True;
+            Table.States (284).Action_List.Set_Capacity (1);
+            Add_Action (Table.States (284), 22, 460);
+            Table.States (284).Kernel := To_Vector ((0 => (286, 43, 2, True)));
+            Table.States (284).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 22, 460)));
+            Table.States (284).Minimal_Complete_Actions_Recursive := True;
             Table.States (285).Action_List.Set_Capacity (13);
-            Add_Action (Table.States (285), 3, 121);
-            Add_Action (Table.States (285), 39, 122);
-            Add_Action (Table.States (285), 40, 123);
-            Add_Action (Table.States (285), 41, 124);
-            Add_Action (Table.States (285), 52, 125);
-            Add_Action (Table.States (285), 68, 459);
-            Add_Action (Table.States (285), 76, 126);
-            Add_Action (Table.States (285), 94, 127);
+            Add_Action (Table.States (285), 3, 122);
+            Add_Action (Table.States (285), 39, 123);
+            Add_Action (Table.States (285), 40, 124);
+            Add_Action (Table.States (285), 41, 125);
+            Add_Action (Table.States (285), 52, 126);
+            Add_Action (Table.States (285), 76, 127);
+            Add_Action (Table.States (285), 79, 31);
             Add_Action (Table.States (285), 95, 128);
-            Add_Action (Table.States (285), 103, 129);
-            Add_Action (Table.States (285), 104, 119);
-            Add_Action (Table.States (285), 105, 33);
+            Add_Action (Table.States (285), 96, 129);
+            Add_Action (Table.States (285), 104, 130);
+            Add_Action (Table.States (285), 105, 120);
             Add_Action (Table.States (285), 106, 34);
+            Add_Action (Table.States (285), 107, 35);
             Table.States (285).Goto_List.Set_Capacity (13);
-            Add_Goto (Table.States (285), 117, 130);
-            Add_Goto (Table.States (285), 128, 41);
-            Add_Goto (Table.States (285), 197, 133);
-            Add_Goto (Table.States (285), 239, 134);
-            Add_Goto (Table.States (285), 258, 135);
-            Add_Goto (Table.States (285), 272, 92);
-            Add_Goto (Table.States (285), 275, 136);
-            Add_Goto (Table.States (285), 287, 460);
-            Add_Goto (Table.States (285), 293, 97);
-            Add_Goto (Table.States (285), 301, 143);
-            Add_Goto (Table.States (285), 320, 144);
+            Add_Goto (Table.States (285), 118, 131);
+            Add_Goto (Table.States (285), 129, 42);
+            Add_Goto (Table.States (285), 198, 134);
+            Add_Goto (Table.States (285), 240, 135);
+            Add_Goto (Table.States (285), 259, 136);
+            Add_Goto (Table.States (285), 273, 93);
+            Add_Goto (Table.States (285), 276, 137);
+            Add_Goto (Table.States (285), 288, 461);
+            Add_Goto (Table.States (285), 294, 98);
+            Add_Goto (Table.States (285), 302, 144);
             Add_Goto (Table.States (285), 321, 145);
-            Add_Goto (Table.States (285), 330, 146);
-            Table.States (285).Kernel := To_Vector (((282, 10, 1, True), (283, 
10, 2, True)));
-            Table.States (285).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 103, 129)));
+            Add_Goto (Table.States (285), 322, 146);
+            Add_Goto (Table.States (285), 331, 147);
+            Table.States (285).Kernel := To_Vector ((0 => (287, 75, 1, True)));
+            Table.States (285).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 104, 130)));
             Table.States (285).Minimal_Complete_Actions_Recursive := True;
-            Table.States (286).Action_List.Set_Capacity (13);
-            Add_Action (Table.States (286), 3, 121);
-            Add_Action (Table.States (286), 22, 461);
-            Add_Action (Table.States (286), 39, 122);
-            Add_Action (Table.States (286), 40, 123);
-            Add_Action (Table.States (286), 41, 124);
-            Add_Action (Table.States (286), 52, 125);
-            Add_Action (Table.States (286), 76, 126);
-            Add_Action (Table.States (286), 94, 127);
+            Table.States (286).Action_List.Set_Capacity (14);
+            Add_Action (Table.States (286), 3, 122);
+            Add_Action (Table.States (286), 39, 123);
+            Add_Action (Table.States (286), 40, 124);
+            Add_Action (Table.States (286), 41, 125);
+            Add_Action (Table.States (286), 52, 126);
+            Add_Action (Table.States (286), 68, 462);
+            Add_Action (Table.States (286), 76, 127);
+            Add_Action (Table.States (286), 79, 31);
             Add_Action (Table.States (286), 95, 128);
-            Add_Action (Table.States (286), 103, 129);
-            Add_Action (Table.States (286), 104, 119);
-            Add_Action (Table.States (286), 105, 33);
+            Add_Action (Table.States (286), 96, 129);
+            Add_Action (Table.States (286), 104, 130);
+            Add_Action (Table.States (286), 105, 120);
             Add_Action (Table.States (286), 106, 34);
+            Add_Action (Table.States (286), 107, 35);
             Table.States (286).Goto_List.Set_Capacity (13);
-            Add_Goto (Table.States (286), 117, 130);
-            Add_Goto (Table.States (286), 128, 41);
-            Add_Goto (Table.States (286), 197, 133);
-            Add_Goto (Table.States (286), 239, 134);
-            Add_Goto (Table.States (286), 258, 135);
-            Add_Goto (Table.States (286), 272, 92);
-            Add_Goto (Table.States (286), 275, 136);
-            Add_Goto (Table.States (286), 287, 462);
-            Add_Goto (Table.States (286), 293, 97);
-            Add_Goto (Table.States (286), 301, 143);
-            Add_Goto (Table.States (286), 320, 144);
+            Add_Goto (Table.States (286), 118, 131);
+            Add_Goto (Table.States (286), 129, 42);
+            Add_Goto (Table.States (286), 198, 134);
+            Add_Goto (Table.States (286), 240, 135);
+            Add_Goto (Table.States (286), 259, 136);
+            Add_Goto (Table.States (286), 273, 93);
+            Add_Goto (Table.States (286), 276, 137);
+            Add_Goto (Table.States (286), 288, 463);
+            Add_Goto (Table.States (286), 294, 98);
+            Add_Goto (Table.States (286), 302, 144);
             Add_Goto (Table.States (286), 321, 145);
-            Add_Goto (Table.States (286), 330, 146);
-            Table.States (286).Kernel := To_Vector (((284, 43, 1, True), (285, 
43, 2, True)));
-            Table.States (286).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 103, 129)));
+            Add_Goto (Table.States (286), 322, 146);
+            Add_Goto (Table.States (286), 331, 147);
+            Table.States (286).Kernel := To_Vector (((283, 10, 1, True), (284, 
10, 2, True)));
+            Table.States (286).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 104, 130)));
             Table.States (286).Minimal_Complete_Actions_Recursive := True;
-            Table.States (287).Action_List.Set_Capacity (12);
-            Add_Action (Table.States (287), 3, 121);
-            Add_Action (Table.States (287), 39, 122);
-            Add_Action (Table.States (287), 40, 123);
-            Add_Action (Table.States (287), 41, 124);
-            Add_Action (Table.States (287), 52, 125);
-            Add_Action (Table.States (287), 76, 126);
-            Add_Action (Table.States (287), 94, 127);
+            Table.States (287).Action_List.Set_Capacity (14);
+            Add_Action (Table.States (287), 3, 122);
+            Add_Action (Table.States (287), 22, 464);
+            Add_Action (Table.States (287), 39, 123);
+            Add_Action (Table.States (287), 40, 124);
+            Add_Action (Table.States (287), 41, 125);
+            Add_Action (Table.States (287), 52, 126);
+            Add_Action (Table.States (287), 76, 127);
+            Add_Action (Table.States (287), 79, 31);
             Add_Action (Table.States (287), 95, 128);
-            Add_Action (Table.States (287), 103, 129);
-            Add_Action (Table.States (287), 104, 119);
-            Add_Action (Table.States (287), 105, 33);
+            Add_Action (Table.States (287), 96, 129);
+            Add_Action (Table.States (287), 104, 130);
+            Add_Action (Table.States (287), 105, 120);
             Add_Action (Table.States (287), 106, 34);
+            Add_Action (Table.States (287), 107, 35);
             Table.States (287).Goto_List.Set_Capacity (13);
-            Add_Goto (Table.States (287), 117, 130);
-            Add_Goto (Table.States (287), 128, 41);
-            Add_Goto (Table.States (287), 197, 133);
-            Add_Goto (Table.States (287), 239, 134);
-            Add_Goto (Table.States (287), 258, 135);
-            Add_Goto (Table.States (287), 272, 92);
-            Add_Goto (Table.States (287), 275, 136);
-            Add_Goto (Table.States (287), 287, 463);
-            Add_Goto (Table.States (287), 293, 97);
-            Add_Goto (Table.States (287), 301, 143);
-            Add_Goto (Table.States (287), 320, 144);
+            Add_Goto (Table.States (287), 118, 131);
+            Add_Goto (Table.States (287), 129, 42);
+            Add_Goto (Table.States (287), 198, 134);
+            Add_Goto (Table.States (287), 240, 135);
+            Add_Goto (Table.States (287), 259, 136);
+            Add_Goto (Table.States (287), 273, 93);
+            Add_Goto (Table.States (287), 276, 137);
+            Add_Goto (Table.States (287), 288, 465);
+            Add_Goto (Table.States (287), 294, 98);
+            Add_Goto (Table.States (287), 302, 144);
             Add_Goto (Table.States (287), 321, 145);
-            Add_Goto (Table.States (287), 330, 146);
-            Table.States (287).Kernel := To_Vector ((0 => (286, 75, 1, True)));
-            Table.States (287).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 103, 129)));
+            Add_Goto (Table.States (287), 322, 146);
+            Add_Goto (Table.States (287), 331, 147);
+            Table.States (287).Kernel := To_Vector (((285, 43, 1, True), (286, 
43, 2, True)));
+            Table.States (287).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 104, 130)));
             Table.States (287).Minimal_Complete_Actions_Recursive := True;
-            Table.States (288).Action_List.Set_Capacity (11);
-            Add_Action (Table.States (288), 3, 121);
-            Add_Action (Table.States (288), 39, 122);
-            Add_Action (Table.States (288), 40, 123);
-            Add_Action (Table.States (288), 41, 124);
-            Add_Action (Table.States (288), 76, 126);
-            Add_Action (Table.States (288), 94, 127);
+            Table.States (288).Action_List.Set_Capacity (13);
+            Add_Action (Table.States (288), 3, 122);
+            Add_Action (Table.States (288), 39, 123);
+            Add_Action (Table.States (288), 40, 124);
+            Add_Action (Table.States (288), 41, 125);
+            Add_Action (Table.States (288), 52, 126);
+            Add_Action (Table.States (288), 76, 127);
+            Add_Action (Table.States (288), 79, 31);
             Add_Action (Table.States (288), 95, 128);
-            Add_Action (Table.States (288), 103, 129);
-            Add_Action (Table.States (288), 104, 119);
-            Add_Action (Table.States (288), 105, 33);
+            Add_Action (Table.States (288), 96, 129);
+            Add_Action (Table.States (288), 104, 130);
+            Add_Action (Table.States (288), 105, 120);
             Add_Action (Table.States (288), 106, 34);
-            Table.States (288).Goto_List.Set_Capacity (14);
-            Add_Goto (Table.States (288), 117, 130);
-            Add_Goto (Table.States (288), 128, 41);
-            Add_Goto (Table.States (288), 197, 133);
-            Add_Goto (Table.States (288), 233, 464);
-            Add_Goto (Table.States (288), 234, 465);
-            Add_Goto (Table.States (288), 239, 274);
-            Add_Goto (Table.States (288), 258, 135);
-            Add_Goto (Table.States (288), 272, 92);
-            Add_Goto (Table.States (288), 277, 466);
-            Add_Goto (Table.States (288), 293, 97);
-            Add_Goto (Table.States (288), 301, 467);
-            Add_Goto (Table.States (288), 320, 144);
+            Add_Action (Table.States (288), 107, 35);
+            Table.States (288).Goto_List.Set_Capacity (13);
+            Add_Goto (Table.States (288), 118, 131);
+            Add_Goto (Table.States (288), 129, 42);
+            Add_Goto (Table.States (288), 198, 134);
+            Add_Goto (Table.States (288), 240, 135);
+            Add_Goto (Table.States (288), 259, 136);
+            Add_Goto (Table.States (288), 273, 93);
+            Add_Goto (Table.States (288), 276, 137);
+            Add_Goto (Table.States (288), 288, 466);
+            Add_Goto (Table.States (288), 294, 98);
+            Add_Goto (Table.States (288), 302, 144);
             Add_Goto (Table.States (288), 321, 145);
-            Add_Goto (Table.States (288), 330, 146);
-            Table.States (288).Kernel := To_Vector ((0 => (287, 33, 1, 
False)));
-            Table.States (288).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 103, 129)));
-            Table.States (289).Action_List.Set_Capacity (1);
-            Add_Action (Table.States (289), 33, 468);
-            Table.States (289).Kernel := To_Vector ((0 => (287, 40, 2, 
False)));
-            Table.States (289).Minimal_Complete_Actions := To_Vector ((0 => 
(Shift, 33, 468)));
-            Table.States (290).Action_List.Set_Capacity (11);
-            Add_Action (Table.States (290), (3, 39, 40, 41, 76, 94, 95, 103, 
104, 105, 106), (288, 0), 1, null, null);
-            Table.States (290).Kernel := To_Vector ((0 => (288, 86, 0, 
False)));
-            Table.States (290).Minimal_Complete_Actions := To_Vector ((0 => 
(Reduce, 288, 1)));
-            Table.States (291).Action_List.Set_Capacity (11);
-            Add_Action (Table.States (291), (3, 39, 40, 41, 76, 94, 95, 103, 
104, 105, 106), (288, 4), 1, null, null);
-            Table.States (291).Kernel := To_Vector ((0 => (288, 88, 0, 
False)));
-            Table.States (291).Minimal_Complete