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

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

[ELPA-diffs] ELPA branch, master, updated. 6d5b40e20601bf41656f6055cceff


From: Stephen Leake
Subject: [ELPA-diffs] ELPA branch, master, updated. 6d5b40e20601bf41656f6055cceff664667af41c
Date: Tue, 24 Dec 2013 09:53:43 +0000

This is an automated email from the git hooks/post-receive script. It was
generated because a ref change was pushed to the repository containing
the project "ELPA".

The branch, master has been updated
       via  6d5b40e20601bf41656f6055cceff664667af41c (commit)
      from  829641e050c37aeecc2750de5eb0ba4e47d18971 (commit)

Those revisions listed above that are new to this repository have
not appeared on any other notification email; so we list those
revisions in full, below.

- Log -----------------------------------------------------------------
commit 6d5b40e20601bf41656f6055cceff664667af41c
Author: U-takver\stephe <address@hidden(none)>
Date:   Tue Dec 24 03:46:45 2013 -0600

    Add ada-mode, wisi packages
    
    * packages/ada-mode/: New directory.
    
    * packages/wisi/: New directory.

diff --git a/packages/ada-mode/ada-build.el b/packages/ada-mode/ada-build.el
new file mode 100755
index 0000000..8a50e89
--- /dev/null
+++ b/packages/ada-mode/ada-build.el
@@ -0,0 +1,305 @@
+;;; ada-build.el --- extensions to ada-mode for compiling and running
+;;; Ada projects without 'make' or similar tool
+;;
+;;; Copyright (C) 1994, 1995, 1997 - 2013  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/>.
+;;
+;;; Usage:
+;;
+;; Add (require 'ada-build) to your .emacs
+
+;;; Design:
+;;
+;; Separate from ada-mode.el because sophisticated users don't need
+;; this (they use 'make' or similar tool), so it would just get in the
+;; way, particularly for fixing bugs in the core capabilities of
+;; ada-mode.
+
+;;; History:
+;;
+;; see ada-mode.el; the current code is a complete rewrite of the
+;; compiling and running capabilities in Ada mode 4.01, done in 2013 by
+;; Stephen Leake <address@hidden>.
+
+(require 'ada-mode)
+
+;;;; User customization
+
+(defgroup ada-build nil
+  "Major mode for compiling and running Ada projects in Emacs."
+  :group 'ada)
+
+(defcustom ada-build-prompt-prj 'default
+  "Policy for finding a project file when none is currently selected."
+  :type '(choice (const default)
+                (const prompt-default)
+                (const prompt-exist)
+                (const error))
+  :group 'ada-build
+  :safe  'symbolp)
+
+(defcustom ada-build-confirm-command nil
+  "If non-nil, prompt for confirmation/edit of each command before it is run."
+  :type  'boolean
+  :group 'ada-build
+  :safe  'booleanp)
+
+(defcustom ada-build-check-cmd
+  (concat "${cross_prefix}gnatmake -u -c -gnatc ${gnatmake_opt} 
${full_current} -cargs -I${src_dir} ${comp_opt}")
+  "Default command to syntax check a single file.
+Overridden by project variable 'check_cmd'."
+  :type 'string
+  :group 'ada-build)
+
+(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}")
+  "Default command to compile the application.
+Overridden by project variable 'make_cmd'."
+  :type 'string
+  :group 'ada-build)
+
+(defcustom ada-build-run-cmd "./${main}"
+  "Default command to run the application, in a spawned shell.
+Overridden by project variable 'run_cmd'."
+  :type 'string
+  :group 'ada-build)
+
+;;;; code
+
+(defun ada-build-replace-vars (cmd-string)
+  "Recursively expand variable references in CMD-STRING.
+${var} is a project variable or environment variable, $var an
+environment variable.
+
+A prefix may be specified with the format '-<prefix>${var}'; then
+the value is expanded with the prefix prepended. If the value is
+a list, the prefix is prepended to each list element. For
+example, if src_dir contains 'dir_1 dir_2', '-I${src_dir}'
+expands to '-Idir_1 -Idir_2'.
+
+As a special case, ${full_current} is replaced by the name
+including the directory and extension."
+
+  (while (string-match "\\(-[^-$ ]+\\)?\\${\\([^}]+\\)}" cmd-string)
+    (let ((prefix (match-string 1 cmd-string))
+         (name (match-string 2 cmd-string))
+         value)
+
+      (when (string= name "full_current")
+       (setq value (buffer-file-name)))
+
+      (when (null value)
+       (setq value (ada-prj-get (intern name))))
+
+      (when (null value)
+       (setq value (getenv name)))
+
+      (cond
+       ((null value)
+       (setq cmd-string (replace-match "" t t cmd-string)))
+
+       ((stringp value)
+       (setq cmd-string (replace-match (concat prefix value) t t cmd-string)))
+
+       ((listp value)
+       (setq cmd-string (replace-match
+                         (mapconcat (lambda (x) (concat prefix x)) value " ")
+                           t t cmd-string)))
+       )))
+
+  (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, with current buffer as main 
program."
+  (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 ()
+  "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
+selected, nil otherwise."
+  (let* ((base-file-name (file-name-base
+                         (or (ada-prj-get '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)))))
+       )
+    (when filename
+      (ada-parse-prj-file filename)
+      (ada-select-prj-file filename))
+    ))
+
+(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."
+  (interactive)
+  (let ((ext (append ada-prj-file-extensions ada-prj-file-ext-extra))
+       filename)
+    (condition-case err
+       (setq filename
+             (read-file-name
+              "Project file: " ; prompt
+              nil ; dir
+              "" ; default-filename
+              t   ; mustmatch
+              nil; initial
+              (lambda (name)
+                ;; this allows directories, which enables navigating
+                ;; 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)))))
+      (err
+       (setq filename nil))
+      )
+
+    (when (not (equal "" filename))
+      (ada-parse-prj-file filename)
+      (ada-select-prj-file filename)
+      t)
+    ))
+
+(defun ada-build-require-project-file ()
+  "Ensure that a project file is selected.
+Action when no project file is currently selected is determined
+by `ada-build-prompt-prj':
+
+default - Search for a project file in the current directory with
+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
+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 - Prompt for a project file; error result does not
+change current project.
+
+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)))
+
+      (default-prompt
+       (or (ada-build-find-select-prj-file)
+           (ada-build-prompt-select-prj-file)))
+
+      (prompt
+       (ada-build-prompt-select-prj-file))
+
+      (error
+       (error "no project file selected"))
+      )))
+
+;;;; user functions
+
+(defun ada-build-run-cmd (prj-field confirm prompt)
+  "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 (ada-prj-get 'proc_env)))
+
+    (unless cmd
+      (setq cmd '("")
+           confirm t))
+
+    (when (or ada-build-confirm-command confirm)
+      (setq cmd (read-from-minibuffer (concat prompt ": ") cmd)))
+
+    (compile (ada-build-replace-vars cmd))))
+
+(defun ada-build-check (&optional confirm)
+  "Run the check_cmd project variable.
+By default, this checks the current file for syntax errors.
+If CONFIRM is non-nil, prompt for user confirmation of the command."
+  (interactive "P")
+  (ada-build-run-cmd 'check_cmd confirm "check command"))
+
+(defun ada-build-make (&optional confirm)
+  "Run the make_cmd project variable.
+By default, this compiles and links the main program.
+If CONFIRM is non-nil, prompt for user confirmation of the command."
+  (interactive "P")
+  (ada-build-run-cmd 'make_cmd confirm "make command"))
+
+(defun ada-build-set-make (&optional confirm)
+  "Set the main project variable to the current file, then run the make_cmd 
project variable.
+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))))
+  (ada-build-run-cmd 'make_cmd confirm "make command"))
+
+(defun ada-build-run (&optional confirm)
+  "Run the run_cmd project variable.
+By default, this runs the main program.
+If CONFIRM is non-nil, prompt for user confirmation of the command."
+  (interactive "P")
+  (ada-build-run-cmd 'run_cmd confirm "run command"))
+
+(defun ada-build-show-main ()
+  "Show current project main program filename."
+  (interactive)
+  (message "Ada mode main: %s"(ada-prj-get 'main)))
+
+;;; setup
+(add-to-list 'ada-prj-default-list 'ada-build-default-prj)
+
+(provide 'ada-build)
+;; end of file
diff --git a/packages/ada-mode/ada-fix-error.el 
b/packages/ada-mode/ada-fix-error.el
new file mode 100755
index 0000000..1c8df93
--- /dev/null
+++ b/packages/ada-mode/ada-fix-error.el
@@ -0,0 +1,180 @@
+;;; ada-fix-error.el --- utilities for automatically fixing
+;; errors reported by the compiler.
+
+;; Copyright (C) 1999-2009, 2012, 2013 Stephen Leake.
+
+;; 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 'compile)
+
+(eval-when-compile (require 'cl-macs))
+
+(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.
+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-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)
+      ;; FIXME (later): this puts "limited with", "private with" at top of 
list; prefer at bottom
+      (sort-lines nil (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)
+  (insert "use type " type ";")
+  (newline-and-indent)
+  (forward-line -1)
+  (indent-according-to-mode))
+
+(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)
+  (insert "use " package ";")
+  (newline-and-indent)
+  (forward-line -1)
+  (indent-according-to-mode))
+
+(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 point.
+Compatible with Emacs 23.4 and 24.x."
+  (cl-case emacs-major-version
+    (23 (get-text-property (point) 'message))
+    (24 (get-text-property (point) 'compilation-message))))
+
+(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))
+       ;; not clear why this can happens, but it does
+       (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-compile.el 
b/packages/ada-mode/ada-gnat-compile.el
new file mode 100755
index 0000000..cf1fe8c
--- /dev/null
+++ b/packages/ada-mode/ada-gnat-compile.el
@@ -0,0 +1,603 @@
+;; Ada mode compiling functionality provided by the 'gnat'
+;; tool.
+;;
+;; These tools are all Ada-specific; use Makefiles for multi-language
+;; GNAT compilation tools.
+;;
+;; GNAT is provided by AdaCore; see http://libre.adacore.com/
+;;
+;;; Copyright (C) 2012, 2013  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/>.
+;;
+;;; Usage:
+;;
+;; Emacs should enter Ada mode automatically when you load an Ada
+;; 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.
+
+(require 'compile)
+(require 'gnat-core)
+
+;;;;; code
+
+;;;; compiler message handling
+
+(defun ada-gnat-compilation-filter ()
+  "Filter to add text properties to secondary file references.
+For `compilation-filter-hook'."
+  (save-excursion
+    (goto-char compilation-filter-start)
+
+    ;; primary references are handled by font-lock functions; see
+    ;; `compilation-mode-font-lock-keywords'.
+    ;;
+    ;; compilation-filter might insert partial lines, or it might insert 
multiple lines
+    (when (bolp)
+      (while (not (eobp))
+       ;; We don't want 'next-error' to always go to secondary
+       ;; references, so we _don't_ set 'compilation-message text
+       ;; property. Instead, we set 'ada-secondary-error, so
+       ;; `ada-goto-secondary-error' will handle it. We also set
+       ;; fonts, so the user can see the reference.
+
+       ;; typical secondary references look like:
+       ;;
+       ;; trivial_productions_test.adb:57:77:   ==> in call to "Get" at \
+       ;;    opentoken-token-enumerated-analyzer.ads:88, instance at line 41
+       ;;
+       ;; c:/foo/bar/lookahead_test.adb:379:14: found type access to 
"Standard.String" defined at line 379
+       ;;
+       ;; lookahead_test.ads:23:09: "Name" has been inherited from subprogram 
at aunit-simple_test_cases.ads:47
+       ;;
+       ;; lalr.adb:668:37: non-visible declaration at analyzer.ads:60, 
instance at parser.ads:38
+       ;;
+       ;; save the file from the primary reference, look for "*.ad?:nn", "at 
line nnn"
+
+       (let (file)
+         (when (looking-at "^\\(\\(.:\\)?[^ :\n]+\\):")
+           (setq file (match-string-no-properties 1)))
+
+         (skip-syntax-forward "^-"); space following primary reference
+
+         (while (search-forward-regexp 
"\\s-\\(\\([^[:blank:]]+\\.[[:alpha:]]+\\):\\([0-9]+\\)\\)"
+                                       (line-end-position) t)
+
+           (goto-char (match-end 0))
+           (with-silent-modifications
+             (compilation--put-prop 2 'font-lock-face compilation-info-face); 
file
+             (compilation--put-prop 3 'font-lock-face compilation-line-face); 
line
+             (put-text-property
+              (match-beginning 0) (match-end 0)
+              'ada-secondary-error
+              (list
+               (match-string-no-properties 2); file
+               (string-to-number (match-string-no-properties 3)); line
+               1)); column
+             ))
+
+         (when (search-forward-regexp "\\(at line \\)\\([0-9]+\\)" 
(line-end-position) t)
+           (with-silent-modifications
+             (compilation--put-prop 1 'font-lock-face compilation-info-face); 
"at line" instead of file
+             (compilation--put-prop 2 'font-lock-face compilation-line-face); 
line
+             (put-text-property
+              (match-beginning 1) (match-end 1)
+              'ada-secondary-error
+              (list
+               file
+               (string-to-number (match-string-no-properties 2)); line
+               1)); column
+             ))
+         (forward-line 1))
+       ))
+    ))
+
+(defun ada-gnat-debug-filter ()
+  ;; call ada-gnat-compilation-filter with `compilation-filter-start' bound
+  (interactive)
+  (beginning-of-line)
+  (let ((compilation-filter-start (point)))
+    (ada-gnat-compilation-filter)))
+
+;;;;; auto fix compilation errors
+
+(defconst ada-gnat-quoted-name-regexp
+  "\"\\([a-zA-Z0-9_.']+\\)\""
+  "regexp to extract the quoted names in error messages")
+
+(defconst ada-gnat-quoted-punctuation-regexp
+  "\"\\([,:;=()|]+\\)\""
+  "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."
+  ;; wisi-output.adb:115:41: no selector "Productions" for type "RHS_Type" 
defined at wisi.ads:77
+  ;; wisi-output.adb:115:41: invalid expression in loop iterator
+  ;; wisi-output.adb:115:42: possible misspelling of "Production"
+  ;; wisi-output.adb:115:42: possible misspelling of "Production"
+  ;;
+  ;; column number can vary, so only check the line number
+
+  (let ((line (progn (beginning-of-line) (nth 1 (compilation--message->loc 
(ada-get-compilation-message)))))
+       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)))))))
+      (when (and (not done)
+                (progn
+                  (skip-syntax-forward "^-")
+                  (forward-char 1)
+                  (looking-at (concat "possible misspelling of " 
ada-gnat-quoted-name-regexp))))
+       (push (match-string 1) choices)))
+
+    ;; return correct spelling
+    (cond
+     ((= 0 (length choices))
+      nil)
+
+     ((= 1 (length choices))
+      (car choices))
+
+     (t ;; multiple choices
+      (completing-read "correct spelling: " choices))
+     )))
+
+(defun ada-gnat-fix-error (msg source-buffer source-window)
+  "For `ada-gnat-fix-error-hook'."
+  (let ((start-pos (point))
+       message-column
+       result)
+    ;; Move to start of error message text
+    (skip-syntax-forward "^-")
+    (forward-char 1)
+    (setq message-column (current-column))
+
+    ;; recognize it, handle it
+    (setq
+     result
+     (unwind-protect
+        (cond
+         ;; It is tempting to define an alist of (MATCH . ACTION), but
+         ;; that is too hard to debug
+         ;;
+         ;; This list will get long, so let's impose some order.
+         ;;
+         ;; First expressions that start with a named regexp, alphabetical by 
variable name.
+         ;;
+         ;; Then expressions that start with a string, alphabetical by string.
+         ;;
+         ;; Then style errors.
+
+         ((looking-at (concat ada-gnat-quoted-name-regexp " is not visible"))
+          (let ((ident (match-string 1))
+                (done nil)
+                (file-line-struct (progn (beginning-of-line) 
(ada-get-compilation-message)))
+                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
+            ;;
+            ;; or the next line may contain "multiple use clauses cause hiding"
+            ;;
+            ;; the lines after that may contain alternate matches;
+            ;; collect all, let user choose.
+            (while (not done)
+              (forward-line 1)
+              (unless (looking-at ".* multiple use clauses cause hiding")
+                (setq done (not
+                            (and
+                             (equal file-line-struct 
(ada-get-compilation-message))
+                             (let ((limit (1- (line-end-position))))
+                               ;; 1- because next compilation error is at next 
line beginning
+                               (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)))
+                    (add-to-list 'choices (ada-ada-name-from-file-name 
unit-file)))))
+              );; while
+
+            (cond
+             ((= 0 (length choices))
+              (setq unit-name nil))
+
+             ((= 1 (length choices))
+              (setq unit-name (car choices)))
+
+             (t ;; multiple choices
+              (setq unit-name
+                    (completing-read "package name: " choices)))
+             );; cond
+
+            (when unit-name
+              (pop-to-buffer source-buffer)
+              ;; We either need to add a with_clause for a package, or
+              ;; prepend the package name here (or add a use clause, but I
+              ;; don't want to do that automatically).
+              ;;
+              ;; If we need to add a with_clause, unit-name may be only
+              ;; the prefix of the real package name, but in that case
+              ;; we'll be back after the next compile; no way to get the
+              ;; full package name (without the function/type name) now.
+              ;; Note that we can't use gnat find, because the code
+              ;; doesn't compile.
+              (cond
+               ((looking-at (concat unit-name "\\."))
+                (ada-fix-add-with-clause unit-name))
+               (t
+                (ada-fix-insert-unit-name unit-name)
+                (insert ".")))
+              t) ;; success, else nil => fail
+            ))
+
+         ((or (looking-at (concat ada-gnat-quoted-name-regexp " is undefined"))
+              (looking-at (concat ada-gnat-quoted-name-regexp " is not a 
predefined library unit")))
+          ;; We either need to add a with_clause for a package, or
+          ;; something is spelled wrong.
+          (save-excursion
+            (let ((unit-name (match-string 1))
+                  (correct-spelling (ada-gnat-misspelling)))
+              (if correct-spelling
+                  (progn
+                    (pop-to-buffer source-buffer)
+                    (search-forward unit-name)
+                    (replace-match correct-spelling))
+
+                ;; else assume missing with
+                (pop-to-buffer source-buffer)
+                (ada-fix-add-with-clause unit-name))))
+          t)
+
+         ((looking-at (concat ada-gnat-quoted-name-regexp " not declared in " 
ada-gnat-quoted-name-regexp))
+          (save-excursion
+            (let ((child-name (match-string 1))
+                  (correct-spelling (ada-gnat-misspelling)))
+              (if correct-spelling
+                  (progn
+                    (setq correct-spelling (match-string 1))
+                    (pop-to-buffer source-buffer)
+                    (search-forward child-name)
+                    (replace-match correct-spelling))
+
+                ;; else guess that "child" is a child package, and extend the 
with_clause
+                (pop-to-buffer source-buffer)
+                (ada-fix-extend-with-clause child-name))))
+          t)
+
+         ((looking-at (concat ada-gnat-quoted-punctuation-regexp
+                              " should be "
+                              ada-gnat-quoted-punctuation-regexp))
+          (let ((bad (match-string-no-properties 1))
+                (good (match-string-no-properties 2)))
+            (pop-to-buffer source-buffer)
+            (looking-at bad)
+            (delete-region (match-beginning 0) (match-end 0))
+            (insert good))
+          t)
+
+;;;; strings
+         ((looking-at (concat "misspelling of " ada-gnat-quoted-name-regexp))
+          (let ((expected-name (match-string 1)))
+            (pop-to-buffer source-buffer)
+            (looking-at ada-name-regexp)
+            (delete-region (match-beginning 1) (match-end 1))
+            (insert expected-name))
+          t)
+
+         ((looking-at (concat "\"end " ada-name-regexp ";\" expected"))
+          (let ((expected-name (match-string 1)))
+            (pop-to-buffer source-buffer)
+            (if (looking-at (concat "end " ada-name-regexp ";"))
+                (progn
+                  (goto-char (match-end 1))   ; just before ';'
+                  (delete-region (match-beginning 1) (match-end 1)))
+              ;; else we have just 'end;'
+              (forward-word 1)
+              (insert " "))
+            (insert expected-name))
+          t)
+
+         ((looking-at "expected an access type")
+          (progn
+            (set-buffer source-buffer)
+            (backward-char 1)
+            (when (looking-at "\\.all")
+              (delete-char 4)
+              t)))
+
+         ((looking-at (concat "expected \\(private \\)?type " 
ada-gnat-quoted-name-regexp))
+          (let ((type (match-string 2)))
+            (forward-line 1)
+            (move-to-column message-column)
+            (when (or (looking-at "found type access")
+                      (looking-at "found type .*_Access_Type"))
+              ;; assume just need '.all'
+              (pop-to-buffer source-buffer)
+              (forward-word 1)
+              (insert ".all")
+              t)))
+
+         ((looking-at "extra \".\" ignored")
+          (set-buffer source-buffer)
+          (delete-char 1)
+          t)
+
+         ((looking-at (concat "keyword " ada-gnat-quoted-name-regexp " 
expected here"))
+          (let ((expected-keyword (match-string 1)))
+            (pop-to-buffer source-buffer)
+            (insert " " expected-keyword))
+          t)
+
+         ((looking-at "\\(?:possible \\)?missing \"with \\([a-zA-Z0-9_.]+\\);")
+          ;; also 'possible missing "with Ada.Text_IO; use Ada.Text_IO"' - 
ignoring the 'use'
+          (let ((package-name (match-string-no-properties 1)))
+            (pop-to-buffer source-buffer)
+            ;; FIXME (later): should check if prefix is already with'd, extend 
it
+            (ada-fix-add-with-clause package-name))
+          t)
+
+         ;; must be after above
+         ((looking-at "missing \"\\(.+\\)\"")
+          (let ((stuff (match-string-no-properties 1)))
+            (set-buffer source-buffer)
+            (insert (concat stuff)));; if missing ")", don't need space; 
otherwise do?
+          t)
+
+         ((looking-at "No legal interpretation for operator")
+          (forward-line 1)
+          (move-to-column message-column)
+          (looking-at (concat "use clause on " ada-gnat-quoted-name-regexp))
+          (let ((package (match-string 1)))
+            (pop-to-buffer source-buffer)
+            (ada-fix-add-use package))
+          t)
+
+         ((looking-at (concat "no selector " ada-gnat-quoted-name-regexp))
+          ;; Check next line for spelling error.
+          (save-excursion
+            (let ((unit-name (match-string 1))
+                  (correct-spelling (ada-gnat-misspelling)))
+              (when correct-spelling
+                (pop-to-buffer source-buffer)
+                (search-forward unit-name)
+                (replace-match correct-spelling)
+                t))))
+
+         ((looking-at (concat "operator for \\(private \\)?type " 
ada-gnat-quoted-name-regexp))
+          (let ((type (match-string 2)))
+            (pop-to-buffer source-buffer)
+            (ada-goto-declarative-region-start)
+            (newline-and-indent)
+            (insert "use type " type ";"))
+          t)
+
+         ((looking-at "parentheses required for unary minus")
+          (set-buffer source-buffer)
+          (insert "(")
+          (forward-word 1)
+          (insert ")")
+          t)
+
+         ((looking-at "prefix of dereference must be an access type")
+          (pop-to-buffer source-buffer)
+          ;; point is after '.' in '.all'
+          (delete-region (- (point) 1) (+ (point) 3))
+          t)
+
+;;;; warnings
+         ((looking-at (concat "warning: " ada-gnat-quoted-name-regexp " is 
already use-visible"))
+          ;; just delete the 'use'; assume it's on a line by itself.
+          (pop-to-buffer source-buffer)
+          (beginning-of-line)
+          (delete-region (point) (progn (forward-line 1) (point)))
+          t)
+
+         ((looking-at (concat "warning: " ada-gnat-quoted-name-regexp " is not 
modified, could be declared constant"))
+          (pop-to-buffer source-buffer)
+          (search-forward ":")
+          (forward-comment (- (point-max) (point)))
+          ;; "aliased" must be before "constant", so check for it
+          (when (looking-at "aliased")
+            (forward-word 1)
+            (forward-char 1))
+          (insert "constant ")
+          t)
+
+         ((looking-at (concat "warning: constant " ada-gnat-quoted-name-regexp 
" is not referenced"))
+          (let ((constant (match-string 1)))
+            (pop-to-buffer source-buffer)
+            (end-of-line)
+            (newline-and-indent)
+            (insert "pragma Unreferenced (" constant ");"))
+          t)
+
+         ((looking-at (concat "warning: formal parameter " 
ada-gnat-quoted-name-regexp " is not referenced"))
+          (let ((param (match-string 1)))
+            (pop-to-buffer source-buffer)
+            (ada-goto-declarative-region-start)
+            (newline-and-indent)
+            (insert "pragma Unreferenced (" param ");"))
+          t)
+
+         ((looking-at (concat "warning: formal parameter " 
ada-gnat-quoted-name-regexp " is not modified"))
+          (let ((param (match-string 1))
+                (mode-regexp "\"\\([in out]+\\)\"")
+                new-mode
+                old-mode)
+            (forward-line 1)
+            (search-forward-regexp
+             (concat "mode could be " mode-regexp " instead of " mode-regexp))
+            (setq new-mode (match-string 1))
+            (setq old-mode (match-string 2))
+            (pop-to-buffer source-buffer)
+            (search-forward old-mode)
+            (replace-match new-mode)
+            (ada-align)
+            )
+          t)
+
+         ((or
+           (looking-at (concat "warning: no entities of " 
ada-gnat-quoted-name-regexp " are referenced$"))
+           (looking-at (concat "warning: unit " ada-gnat-quoted-name-regexp " 
is never instantiated$"))
+           (looking-at "warning: redundant with clause"))
+          ;; just delete the 'with'; assume it's on a line by itself.
+          (pop-to-buffer source-buffer)
+          (beginning-of-line)
+          (delete-region (point) (progn (forward-line 1) (point)))
+          t)
+
+         ((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)
+            (newline-and-indent)
+            (insert "pragma Unreferenced (" param ");"))
+          t)
+
+         ((looking-at (concat "warning: unit " ada-gnat-quoted-name-regexp " 
is not referenced$"))
+          ;; just delete the 'with'; assume it's on a line by itself.
+          (pop-to-buffer source-buffer)
+          (beginning-of-line)
+          (delete-region (point) (progn (forward-line 1) (point)))
+          t)
+
+;;;; style errors
+         ((looking-at "(style) \".*\" in wrong column")
+          (progn
+            (set-buffer source-buffer)
+            (funcall indent-line-function))
+          t)
+
+         ((looking-at "(style) bad capitalization, mixed case required")
+          (progn
+            (set-buffer source-buffer)
+            (forward-word)
+            (ada-case-adjust-identifier)
+            t))
+
+         ((looking-at (concat "(style) bad casing of " 
ada-gnat-quoted-name-regexp))
+          (let ((correct (match-string-no-properties 1))
+                end)
+            ;; gnat leaves point on first bad character, but we need to 
replace the whole word
+            (set-buffer source-buffer)
+            (skip-syntax-backward "w_")
+            (setq end (point))
+            (skip-syntax-forward "w_")
+            (delete-region (point) end)
+            (insert correct))
+          t)
+
+         ((or
+           (looking-at "(style) bad column")
+           (looking-at "(style) bad indentation")
+           (looking-at "(style) incorrect layout"))
+          (set-buffer source-buffer)
+          (funcall indent-line-function)
+          t)
+
+         ((looking-at "(style) missing \"overriding\" indicator")
+          (set-buffer source-buffer)
+          (cond
+           ((looking-at "\\(procedure\\)\\|\\(function\\)")
+            (insert "overriding ")
+           t)
+           (t
+            nil)))
+
+         ((looking-at "(style) space not allowed")
+          (set-buffer source-buffer)
+          ;; Error places point on space. More than one trailing space
+          ;; should be fixed by delete-trailing-whitespace in
+          ;; before-save-hook, once the file is modified.
+          (delete-char 1)
+          t)
+
+         ((looking-at "(style) space required")
+          (set-buffer source-buffer)
+          (insert " ")
+          t)
+         )));; end of setq unwind-protect cond
+    (if result
+       t
+      (goto-char start-pos)
+      nil)
+    ))
+
+;;;;; setup
+
+(defun ada-gnat-compile-select-prj ()
+  (setq ada-fix-error-hook 'ada-gnat-fix-error-hook)
+  (add-to-list 'completion-ignored-extensions ".ali") ;; gnat library files
+
+  (add-hook 'compilation-filter-hook 'ada-gnat-compilation-filter)
+
+  ;; 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)
+  )
+
+(defun ada-gnat-compile-deselect-prj ()
+  (setq ada-fix-error-hook nil)
+  (setq completion-ignored-extensions (delete ".ali" 
completion-ignored-extensions))
+  (setq compilation-filter-hook (delete 'ada-gnat-compilation-filter 
compilation-filter-hook))
+  (setq compilation-error-regexp-alist (delete 'gnat 
compilation-error-regexp-alist))
+  )
+
+(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))
+
+  (add-hook 'ada-gnat-fix-error-hook 'ada-gnat-fix-error))
+
+(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)
+   "^\\(\\(.:\\)?[^ :\n]+\\):\\([0-9]+\\)\\s-?:?\\([0-9]+\\)?" 1 3 4))
+
+(unless (default-value ada-compiler)
+    (set-default 'ada-compiler 'gnat))
+
+;; end of file
diff --git a/packages/ada-mode/ada-gnat-xref.el 
b/packages/ada-mode/ada-gnat-xref.el
new file mode 100755
index 0000000..4f0d716
--- /dev/null
+++ b/packages/ada-mode/ada-gnat-xref.el
@@ -0,0 +1,238 @@
+;; Ada mode cross-reference functionality provided by the 'gnat xref'
+;; tool. Includes related functions, such as gnatprep support.
+;;
+;; These tools are all Ada-specific; see gnat-inspect for
+;; multi-language GNAT cross-reference tools.
+;;
+;; GNAT is provided by AdaCore; see http://libre.adacore.com/
+;;
+;;; Copyright (C) 2012, 2013  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/>.
+;;
+;;; Usage:
+;;
+;; Emacs should enter Ada mode automatically when you load an Ada
+;; 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.
+
+(require 'ada-fix-error)
+(require 'compile)
+(require 'gnat-core)
+
+;;;;; code
+
+;;;; uses of gnat tools
+
+(defconst ada-gnat-file-line-col-regexp "\\(.*\\):\\([0-9]+\\):\\([0-9]+\\)")
+
+(defun ada-gnat-xref-other (identifier file line col)
+  "For `ada-xref-other-function', using 'gnat find', which is Ada-specific."
+
+  (when (eq ?\" (aref identifier 0))
+    ;; gnat find wants the quotes on operators, but the column is after the 
first quote.
+    (setq col (+ 1 col))
+    )
+
+  (let* ((arg (format "%s:%s:%d:%d" identifier file line col))
+        (switches (when (ada-prj-get 'gpr_ext) (concat "--ext=" (ada-prj-get 
'gpr_ext))))
+        status
+        (result nil))
+    (with-current-buffer (gnat-run-buffer)
+      (gnat-run-gnat "find" (list switches arg))
+
+      (goto-char (point-min))
+      (forward-line 2); skip ADA_PROJECT_PATH, 'gnat find'
+
+      ;; gnat find returns two items; the starting point, and the 'other' point
+      (unless (looking-at (concat ada-gnat-file-line-col-regexp ":"))
+       ;; no results
+       (error "'%s' not found in cross-reference files; recompile?" 
identifier))
+
+      (while (not result)
+       (looking-at (concat ada-gnat-file-line-col-regexp "\\(: warning:\\)?"))
+       (if (match-string 4)
+           ;; error in *.gpr; ignore here.
+           (forward-line 1)
+         ;; else process line
+         (let ((found-file (match-string 1))
+               (found-line (string-to-number (match-string 2)))
+               (found-col  (string-to-number (match-string 3))))
+           (if (not
+                (and
+                 (equal file found-file)
+                 (= line found-line)
+                 (= col found-col)))
+               ;; found other item
+               (setq result (list found-file found-line (1- found-col)))
+             (forward-line 1))
+           ))
+
+       (when (eobp)
+         (pop-to-buffer (current-buffer))
+         (error "gnat find did not return other item"))
+       ))
+    result))
+
+(defun ada-gnat-xref-parents (identifier file line col)
+  "For `ada-xref-parents-function', using 'gnat find', which is Ada-specific."
+
+  (let* ((arg (format "%s:%s:%d:%d" identifier file line col))
+        (switches (concat
+                   "-d"
+                   (when (ada-prj-get 'gpr_ext) (concat "--ext=" (ada-prj-get 
'gpr_ext)))
+                   ))
+        (result nil))
+    (with-current-buffer (gnat-run-buffer)
+      (gnat-run-gnat "find" (list switches arg))
+
+      (goto-char (point-min))
+      (forward-line 2); skip GPR_PROJECT_PATH, 'gnat find'
+
+      ;; gnat find returns two items; the starting point, and the 'other' point
+      (unless (looking-at (concat ada-gnat-file-line-col-regexp ":"))
+       ;; no results
+       (error "'%s' not found in cross-reference files; recompile?" 
identifier))
+
+      (while (not result)
+       (looking-at (concat ada-gnat-file-line-col-regexp "\\(: warning:\\)?"))
+       (if (match-string 4)
+           ;; error in *.gpr; ignore here.
+           (forward-line 1)
+         ;; else process line
+         (let ((found-file (match-string 1))
+               (found-line (string-to-number (match-string 2)))
+               (found-col  (string-to-number (match-string 3))))
+
+           (skip-syntax-forward "^ ")
+           (skip-syntax-forward " ")
+           (if (looking-at (concat "derived from .* (" 
ada-gnat-file-line-col-regexp ")"))
+               ;; found other item
+               (setq result (list (match-string 1)
+                                  (string-to-number (match-string 2))
+                                  (1- (string-to-number (match-string 3)))))
+             (forward-line 1)))
+         )
+       (when (eobp)
+         (pop-to-buffer (current-buffer))
+         (error "gnat find did not return parent types"))
+       ))
+
+    (ada-goto-source (nth 0 result)
+                    (nth 1 result)
+                    (nth 2 result)
+                    nil ;; other-window
+                    )
+    ))
+
+(defun ada-gnat-xref-all (identifier file line col)
+  "For `ada-xref-all-function'."
+  ;; we use `compilation-start' to run gnat, not `gnat-run', so it
+  ;; is asynchronous, and automatically runs the compilation error
+  ;; filter.
+
+  (let* ((cmd (format "gnat find -r %s:%s:%d:%d" identifier file line col)))
+
+    (with-current-buffer (gnat-run-buffer); for default-directory
+      (let ((compilation-environment (ada-prj-get 'proc_env))
+           (compilation-error "reference")
+           ;; gnat find uses standard gnu format for output, so don't
+           ;; need to set compilation-error-regexp-alist
+           )
+       (when (ada-prj-get 'gpr_file)
+         (setq cmd (concat cmd " -P" (file-name-nondirectory (ada-prj-get 
'gpr_file)))))
+
+       (compilation-start cmd
+                          'compilation-mode
+                          (lambda (mode-name) (concat mode-name "-gnatfind")))
+    ))))
+
+;;;;; 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)
+
+  (add-hook 'ada-syntax-propertize-hook 'gnatprep-syntax-propertize)
+
+  ;; must be after indentation engine setup, because that resets the
+  ;; indent function list.
+  (add-hook 'ada-mode-hook 'ada-gnat-xref-setup t)
+
+  (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)
+
+  ;; gnatmake -gnatD generates files with .dg extensions. But we don't
+  ;; need to navigate between them.
+  ;;
+  ;; There is no common convention for a file extension for gnatprep files.
+
+  (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)
+
+  (setq ada-syntax-propertize-hook (delq 'gnatprep-syntax-propertize 
ada-syntax-propertize-hook))
+  (setq ada-mode-hook (delq 'ada-gnat-xref-setup ada-mode-hook))
+
+  (setq ada-xref-other-function  nil)
+  (setq ada-xref-parent-function nil)
+  (setq ada-xref-all-function    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-setup ()
+  (when (boundp 'wisi-indent-calculate-functions)
+    (add-to-list 'wisi-indent-calculate-functions 'gnatprep-indent))
+  )
+
+(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
+
+  (font-lock-add-keywords 'ada-mode
+   ;; gnatprep preprocessor line
+   (list (list "^[ \t]*\\(#.*\n\\)"  '(1 font-lock-type-face t))))
+
+  (add-hook 'ada-gnat-fix-error-hook 'ada-gnat-fix-error))
+
+(ada-gnat-xref)
+
+(provide 'ada-gnat-xref)
+(provide 'ada-xref-tool)
+
+(unless (default-value 'ada-xref-tool)
+  (set-default 'ada-xref-tool 'gnat))
+
+;; end of file
diff --git a/packages/ada-mode/ada-grammar-wy.el 
b/packages/ada-mode/ada-grammar-wy.el
new file mode 100755
index 0000000..790997c
--- /dev/null
+++ b/packages/ada-mode/ada-grammar-wy.el
@@ -0,0 +1,4215 @@
+;;; ada-grammar-wy.el --- Generated parser support file
+
+;; Copyright (C) 2013 Stephen Leake.  All Rights Reserved.
+
+;; 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 2, or (at
+;; your option) any later version.
+;;
+;; This software 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, Inc., 51 Franklin Street, Fifth Floor,
+;; Boston, MA 02110-1301, USA.
+
+;; PLEASE DO NOT MANUALLY EDIT THIS FILE!  It is automatically
+;; generated from the grammar file ada-grammar.wy
+
+(require 'wisi)
+(require 'semantic/lex)
+(require 'wisi-compile)
+
+(defconst ada-grammar-wy--keyword-table
+  (semantic-lex-make-keyword-table
+   '(
+    ("abs" . ABS)
+    ("accept" . ACCEPT)
+    ("abort" . ABORT)
+    ("abstract" . ABSTRACT)
+    ("access" . ACCESS)
+    ("aliased" . ALIASED)
+    ("all" . ALL)
+    ("and" . AND)
+    ("array" . ARRAY)
+    ("at" . AT)
+    ("begin" . BEGIN)
+    ("body" . BODY)
+    ("case" . CASE)
+    ("constant" . CONSTANT)
+    ("declare" . DECLARE)
+    ("delay" . DELAY)
+    ("delta" . DELTA)
+    ("digits" . DIGITS)
+    ("do" . DO)
+    ("else" . ELSE)
+    ("elsif" . ELSIF)
+    ("end" . END)
+    ("entry" . ENTRY)
+    ("exception" . EXCEPTION)
+    ("exit" . EXIT)
+    ("for" . FOR)
+    ("function" . FUNCTION)
+    ("generic" . GENERIC)
+    ("goto" . GOTO)
+    ("if" . IF)
+    ("in" . IN)
+    ("interface" . INTERFACE)
+    ("is" . IS)
+    ("(" . LEFT_PAREN)
+    ("limited" . LIMITED)
+    ("loop" . LOOP)
+    ("mod" . MOD)
+    ("new" . NEW)
+    ("not" . NOT)
+    ("null" . NULL)
+    ("of" . OF)
+    ("or" . OR)
+    ("others" . OTHERS)
+    ("out" . OUT)
+    ("overriding" . OVERRIDING)
+    ("package" . PACKAGE)
+    ("pragma" . PRAGMA)
+    ("private" . PRIVATE)
+    ("procedure" . PROCEDURE)
+    ("protected" . PROTECTED)
+    ("raise" . RAISE)
+    ("range" . RANGE)
+    ("record" . RECORD)
+    ("rem" . REM)
+    ("renames" . RENAMES)
+    ("requeue" . REQUEUE)
+    ("return" . RETURN)
+    ("reverse" . REVERSE)
+    (")" . RIGHT_PAREN)
+    ("separate" . SEPARATE)
+    ("select" . SELECT)
+    ("some" . SOME)
+    ("subtype" . SUBTYPE)
+    ("synchronized" . SYNCHRONIZED)
+    ("tagged" . TAGGED)
+    ("task" . TASK)
+    ("terminate" . TERMINATE)
+    ("then" . THEN)
+    ("type" . TYPE)
+    ("until" . UNTIL)
+    ("use" . USE)
+    ("when" . WHEN)
+    ("while" . WHILE)
+    ("with" . WITH)
+    ("xor" . XOR)
+    )
+   nil)
+  "Table of language keywords.")
+
+(defconst ada-grammar-wy--token-table
+  (semantic-lex-make-type-table
+   '(
+     ("punctuation"
+      (AMPERSAND . "&")
+      (BAR . "|")
+      (BOX . "<>")
+      (COLON . ":")
+      (COLON_EQUAL . ":=")
+      (COMMA . ",")
+      (DOT . ".")
+      (DOT_DOT . "..")
+      (EQUAL . "=")
+      (EQUAL_GREATER . "=>")
+      (GREATER . ">")
+      (GREATER_EQUAL . ">=")
+      (GREATER_GREATER . ">>")
+      (LESS . "<")
+      (LESS_EQUAL . "<=")
+      (LESS_LESS . "<<")
+      (MINUS . "-")
+      (PLUS . "+")
+      (SEMICOLON . ";")
+      (SLASH . "/")
+      (SLASH_EQUAL . "/=")
+      (STAR . "*")
+      (STAR_STAR . "**")
+      (TICK . "'")
+     )
+     ("symbol"
+      (IDENTIFIER)
+     )
+     ("string-double"
+      (STRING_LITERAL)
+     )
+     ("string-single"
+      (CHARACTER_LITERAL)
+     )
+    )
+   nil)
+  "Table of language tokens.")
+
+(defconst ada-grammar-wy--parse-table
+   (wisi-compile-grammar
+   '((AMPERSAND BAR BOX COLON COLON_EQUAL COMMA DOT DOT_DOT EQUAL 
EQUAL_GREATER GREATER GREATER_EQUAL GREATER_GREATER LESS LESS_EQUAL LESS_LESS 
MINUS PLUS SEMICOLON SLASH SLASH_EQUAL STAR STAR_STAR TICK IDENTIFIER 
STRING_LITERAL CHARACTER_LITERAL ABS ACCEPT ABORT ABSTRACT ACCESS ALIASED ALL 
AND ARRAY AT BEGIN BODY CASE CONSTANT DECLARE DELAY DELTA DIGITS DO ELSE ELSIF 
END ENTRY EXCEPTION EXIT FOR FUNCTION GENERIC GOTO IF IN INTERFACE IS 
LEFT_PAREN LIMITED LOOP MOD NEW NOT NULL OF OR OTHERS OUT OVERRIDING PACKAGE 
PRAGMA PRIVATE PROCEDURE PROTECTED RAISE RANGE RECORD REM RENAMES REQUEUE 
RETURN REVERSE RIGHT_PAREN SEPARATE SELECT SOME SUBTYPE SYNCHRONIZED TAGGED 
TASK TERMINATE THEN TYPE UNTIL USE WHEN WHILE WITH XOR )
+     ((abstract_limited_synchronized_opt
+       (())
+       ((ABSTRACT LIMITED ))
+       ((ABSTRACT SYNCHRONIZED ))
+       ((ABSTRACT ))
+       ((LIMITED ))
+       ((SYNCHRONIZED )))
+      (abstract_limited_opt
+       (())
+       ((ABSTRACT LIMITED ))
+       ((LIMITED ))
+       ((ABSTRACT )))
+      (abstract_tagged_limited_opt
+       (())
+       ((ABSTRACT TAGGED LIMITED ))
+       ((ABSTRACT TAGGED ))
+       ((TAGGED LIMITED ))
+       ((TAGGED ))
+       ((LIMITED )))
+      (abstract_subprogram_declaration
+       ((overriding_indicator_opt subprogram_specification IS ABSTRACT 
aspect_specification_opt SEMICOLON )
+        (wisi-statement-action 1 'statement-start 2 'statement-other 6 
'statement-end)))
+      (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 'block-start 2 'name-paren 5 'block-middle 7 
'block-end 9 'statement-end)
+        (wisi-containing-action 2 3)
+        (wisi-containing-action 2 4)
+        (wisi-containing-action 5 6)
+        (wisi-motion-action 1 5 '(6 EXCEPTION))))
+       ((ACCEPT IDENTIFIER actual_parameter_part_opt parameter_profile_opt 
SEMICOLON )
+        (progn
+        (wisi-statement-action 1 'statement-start 2 'name-paren 7 
'statement-end)
+        (wisi-containing-action 2 3)
+        (wisi-containing-action 2 4))))
+      (access_definition
+       ((null_exclusion_opt ACCESS general_access_modifier_opt name )
+        (wisi-statement-action 4 'type))
+       ((null_exclusion_opt ACCESS protected_opt PROCEDURE 
parameter_profile_opt )
+        (progn
+        (wisi-statement-action 4 'name-paren)
+        (wisi-containing-action 4 5)))
+       ((null_exclusion_opt ACCESS protected_opt FUNCTION 
parameter_and_result_profile )
+        (progn
+        (wisi-statement-action 4 'name-paren)
+        (wisi-containing-action 4 5)
+        (wisi-motion-action 4 '(5 RETURN)))))
+      (actual_parameter_part
+       ((LEFT_PAREN association_list RIGHT_PAREN )
+        (progn
+        (wisi-statement-action 1 'open-paren 3 'close-paren)
+        (wisi-containing-action 1 2))))
+      (actual_parameter_part_opt
+       (())
+       ((actual_parameter_part )))
+      (aggregate
+       ((LEFT_PAREN association_list RIGHT_PAREN )
+        (progn
+        (wisi-statement-action 1 'open-paren 3 'close-paren)
+        (wisi-containing-action 1 2)))
+       ((LEFT_PAREN expression WITH association_list RIGHT_PAREN )
+        (progn
+        (wisi-statement-action 1 'open-paren 3 'statement-other 5 'close-paren)
+        (wisi-containing-action 1 2)
+        (wisi-containing-action 1 3)
+        (wisi-containing-action 3 4)))
+       ((LEFT_PAREN expression WITH NULL RECORD RIGHT_PAREN )
+        (progn
+        (wisi-statement-action 1 'open-paren 3 'statement-other 6 'close-paren)
+        (wisi-containing-action 1 2)
+        (wisi-containing-action 1 3)))
+       ((LEFT_PAREN NULL RECORD RIGHT_PAREN )
+        (wisi-statement-action 1 'open-paren 4 'close-paren)))
+      (aliased_opt
+       (())
+       ((ALIASED )))
+      (and_interface_list_opt
+       (())
+       ((AND interface_list )))
+      (array_type_definition
+       ((ARRAY LEFT_PAREN index_subtype_definition_list RIGHT_PAREN OF 
component_definition )
+        (progn
+        (wisi-statement-action 2 'open-paren 4 'close-paren 5 'statement-other)
+        (wisi-containing-action 2 3)
+        (wisi-containing-action 5 6)))
+       ((ARRAY LEFT_PAREN discrete_subtype_definition_list RIGHT_PAREN OF 
component_definition )
+        (progn
+        (wisi-statement-action 2 'open-paren 4 'close-paren 5 'statement-other)
+        (wisi-containing-action 2 3)
+        (wisi-containing-action 5 6))))
+      (assignment_statement
+       ((name COLON_EQUAL expression SEMICOLON )
+        (progn
+        (wisi-statement-action 1 'statement-start 2 'statement-other 4 
'statement-end)
+        (wisi-containing-action 2 3))))
+      (association_opt
+       (())
+       ((CHARACTER_LITERAL EQUAL_GREATER expression )
+        (progn
+        (wisi-statement-action 2 'statement-other)
+        (wisi-containing-action 2 3)))
+       ((CHARACTER_LITERAL EQUAL_GREATER BOX ))
+       ((discrete_choice_list EQUAL_GREATER expression )
+        (progn
+        (wisi-statement-action 2 'statement-other)
+        (wisi-containing-action 2 3)))
+       ((discrete_choice_list EQUAL_GREATER BOX ))
+       ((expression_opt )))
+      (association_list
+       ((association_opt ))
+       ((association_list COMMA association_opt )
+        (progn
+        (wisi-statement-action 2 'list-break)
+        (wisi-containing-action 2 3))))
+      (aspect_clause
+       ((FOR attribute_reference USE expression SEMICOLON )
+        (progn
+        (wisi-statement-action 1 'statement-start 3 'statement-other 5 
'statement-end)
+        (wisi-containing-action 3 4)))
+       ((enumeration_representation_clause ))
+       ((record_representation_clause ))
+       ((at_clause )))
+      (aspect_specification_opt
+       (())
+       ((WITH IDENTIFIER ))
+       ((WITH IDENTIFIER EQUAL_GREATER expression )))
+      (asynchronous_select
+       ((SELECT triggering_alternative THEN ABORT sequence_of_statements_opt 
END SELECT SEMICOLON )
+        (progn
+        (wisi-statement-action 1 'block-start 3 'block-middle 4 
'statement-other 6 'block-end 8 'statement-end)
+        (wisi-containing-action 1 2)
+        (wisi-containing-action 3 5))))
+      (at_clause
+       ((FOR direct_name USE AT expression SEMICOLON )
+        (progn
+        (wisi-statement-action 1 'statement-start 4 'statement-other 6 
'statement-end)
+        (wisi-containing-action 4 5))))
+      (attribute_reference
+       ((name TICK attribute_designator )))
+      (attribute_designator
+       ((name ))
+       ((ACCESS ))
+       ((DELTA ))
+       ((DIGITS ))
+       ((MOD )))
+      (binary_adding_operator
+       ((PLUS ))
+       ((MINUS ))
+       ((AMPERSAND )))
+      (block_statement
+       ((DECLARE declarative_part_opt BEGIN handled_sequence_of_statements END 
identifier_opt SEMICOLON )
+        (progn
+        (wisi-statement-action 1 'block-start 3 'block-middle 5 'block-end 7 
'statement-end)
+        (wisi-containing-action 1 2)
+        (wisi-containing-action 3 4)
+        (wisi-motion-action 1 3 '(4 EXCEPTION) 5)))
+       ((BEGIN handled_sequence_of_statements END identifier_opt SEMICOLON )
+        (progn
+        (wisi-statement-action 1 'block-start 3 'block-end 5 'statement-end)
+        (wisi-containing-action 1 2)
+        (wisi-motion-action 1 '(2 EXCEPTION) 3))))
+      (body
+       ((proper_body ))
+       ((body_stub )))
+      (body_stub
+       ((subprogram_body_stub ))
+       ((package_body_stub ))
+       ((task_body_stub ))
+       ((protected_body_stub )))
+      (case_expression
+       ((CASE expression IS case_expression_alternative_list )
+        (progn
+        (wisi-statement-action 1 'statement-start 3 'block-middle)
+        (wisi-containing-action 1 2)
+        (wisi-containing-action 3 4))))
+      (case_expression_alternative
+       ((WHEN discrete_choice_list EQUAL_GREATER expression )
+        (progn
+        (wisi-statement-action 1 'block-middle 3 'statement-other)
+        (wisi-containing-action 3 4))))
+      (case_expression_alternative_list
+       ((case_expression_alternative ))
+       ((case_expression_alternative_list COMMA case_expression_alternative )
+        (progn
+        (wisi-statement-action 2 'list-break)
+        (wisi-containing-action 2 3))))
+      (case_statement
+       ((CASE expression IS case_statement_alternative_list END CASE SEMICOLON 
)
+        (progn
+        (wisi-statement-action 1 'block-start 3 'block-middle 5 'block-end 7 
'statement-end)
+        (wisi-containing-action 1 2)
+        (wisi-containing-action 3 4)
+        (wisi-motion-action 1 '(4 WHEN) 5))))
+      (case_statement_alternative
+       ((WHEN discrete_choice_list EQUAL_GREATER sequence_of_statements_opt )
+        (progn
+        (wisi-statement-action 1 'block-middle 3 'statement-other)
+        (wisi-containing-action 1 2)
+        (wisi-containing-action 3 4))))
+      (case_statement_alternative_list
+       ((case_statement_alternative ))
+       ((case_statement_alternative_list case_statement_alternative )))
+      (choice_expression
+       ((choice_relation ))
+       ((choice_relation_and_list ))
+       ((choice_relation_or_list ))
+       ((choice_relation_xor_list ))
+       ((choice_relation_and_then_list ))
+       ((choice_relation_or_else_list )))
+      (choice_relation_and_list
+       ((choice_relation AND choice_relation ))
+       ((choice_relation_and_list AND choice_relation )))
+      (choice_relation_or_list
+       ((choice_relation OR choice_relation ))
+       ((choice_relation_or_list OR choice_relation )))
+      (choice_relation_xor_list
+       ((choice_relation XOR choice_relation ))
+       ((choice_relation_xor_list XOR choice_relation )))
+      (choice_relation_and_then_list
+       ((choice_relation AND THEN choice_relation ))
+       ((choice_relation_and_then_list AND THEN choice_relation )))
+      (choice_relation_or_else_list
+       ((choice_relation OR ELSE choice_relation ))
+       ((choice_relation_or_else_list OR ELSE choice_relation )))
+      (choice_relation
+       ((simple_expression relational_operator simple_expression ))
+       ((simple_expression )))
+      (compilation_unit
+       ((context_item ))
+       ((library_item ))
+       ((subunit )))
+      (compilation_unit_list
+       ((compilation_unit ))
+       ((compilation_unit_list compilation_unit )))
+      (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-containing-action 2 3)
+        (wisi-containing-action 4 5)
+        (wisi-containing-action 6 7))))
+      (component_clause_list
+       ((component_clause ))
+       ((component_clause_list component_clause )))
+      (component_declaration
+       ((identifier_list COLON component_definition COLON_EQUAL expression 
aspect_specification_opt SEMICOLON )
+        (progn
+        (wisi-statement-action 1 'statement-start 2 'statement-other 7 
'statement-end)
+        (wisi-containing-action 2 3)
+        (wisi-containing-action 4 5)))
+       ((identifier_list COLON component_definition aspect_specification_opt 
SEMICOLON )
+        (progn
+        (wisi-statement-action 1 'statement-start 2 'statement-other 5 
'statement-end)
+        (wisi-containing-action 2 3))))
+      (component_definition
+       ((ALIASED subtype_indication ))
+       ((subtype_indication ))
+       ((ALIASED access_definition ))
+       ((access_definition )))
+      (component_item
+       ((component_declaration ))
+       ((aspect_clause )))
+      (component_list
+       ((component_item ))
+       ((component_list component_item ))
+       ((component_list variant_part ))
+       ((variant_part ))
+       ((NULL SEMICOLON )
+        (wisi-statement-action 1 'statement-start 2 'statement-end)))
+      (component_list_opt
+       (())
+       ((component_list )))
+      (compound_statement
+       ((if_statement ))
+       ((case_statement ))
+       ((loop_statement ))
+       ((block_statement ))
+       ((extended_return_statement ))
+       ((accept_statement ))
+       ((select_statement )))
+      (conditional_entry_call
+       ((SELECT entry_call_alternative ELSE sequence_of_statements_opt END 
SELECT SEMICOLON )
+        (progn
+        (wisi-statement-action 1 'block-start 3 'block-middle 5 'block-end 7 
'statement-end)
+        (wisi-containing-action 1 2)
+        (wisi-containing-action 3 4))))
+      (constant_opt
+       (())
+       ((CONSTANT )))
+      (constraint
+       ((RANGE range ))
+       ((index_constraint )))
+      (context_item
+       ((pragma ))
+       ((with_clause ))
+       ((use_clause )))
+      (declaration
+       ((abstract_subprogram_declaration ))
+       ((aspect_clause ))
+       ((body ))
+       ((entry_declaration ))
+       ((exception_declaration ))
+       ((generic_declaration ))
+       ((generic_instantiation ))
+       ((null_procedure_declaration ))
+       ((identifier_list COLON CONSTANT COLON_EQUAL expression SEMICOLON )
+        (progn
+        (wisi-statement-action 1 'statement-start 6 'statement-end)
+        (wisi-containing-action 1 5)))
+       ((object_declaration ))
+       ((package_declaration ))
+       ((pragma ))
+       ((renaming_declaration ))
+       ((subprogram_declaration ))
+       ((subtype_declaration ))
+       ((type_declaration ))
+       ((use_clause )))
+      (declarations
+       ((declaration ))
+       ((declarations declaration )))
+      (declarative_part_opt
+       (())
+       ((declarations )))
+      (delay_alternative
+       ((delay_statement sequence_of_statements_opt )))
+      (delay_statement
+       ((DELAY UNTIL expression SEMICOLON )
+        (progn
+        (wisi-statement-action 1 'statement-start 4 'statement-end)
+        (wisi-containing-action 1 3)))
+       ((DELAY expression SEMICOLON )
+        (progn
+        (wisi-statement-action 1 'statement-start 3 'statement-end)
+        (wisi-containing-action 1 2))))
+      (derived_type_definition
+       ((abstract_limited_opt NEW name and_interface_list_opt WITH 
record_definition ))
+       ((abstract_limited_opt NEW name )))
+      (direct_name
+       ((IDENTIFIER ))
+       ((STRING_LITERAL )))
+      (discrete_choice
+       ((choice_expression ))
+       ((NOT NULL name ))
+       ((range ))
+       ((OTHERS )))
+      (discrete_choice_list
+       (())
+       ((discrete_choice ))
+       ((discrete_choice_list BAR discrete_choice )))
+      (discrete_subtype_definition
+       ((subtype_indication ))
+       ((range )))
+      (discrete_subtype_definition_list
+       ((discrete_subtype_definition ))
+       ((discrete_subtype_definition_list COMMA discrete_subtype_definition )
+        (progn
+        (wisi-statement-action 2 'list-break)
+        (wisi-containing-action 2 3))))
+      (discriminant_part_opt
+       (())
+       ((LEFT_PAREN BOX RIGHT_PAREN ))
+       ((LEFT_PAREN discriminant_specification_list RIGHT_PAREN )
+        (progn
+        (wisi-statement-action 1 'open-paren 3 'close-paren)
+        (wisi-containing-action 1 2))))
+      (discriminant_specification_opt
+       (())
+       ((identifier_list COLON null_exclusion_opt_name COLON_EQUAL expression 
))
+       ((identifier_list COLON null_exclusion_opt_name ))
+       ((identifier_list COLON access_definition COLON_EQUAL expression ))
+       ((identifier_list COLON access_definition )))
+      (discriminant_specification_list
+       ((discriminant_specification_opt ))
+       ((discriminant_specification_list SEMICOLON 
discriminant_specification_opt )
+        (progn
+        (wisi-statement-action 2 'list-break)
+        (wisi-containing-action 2 3))))
+      (elsif_expression_item
+       ((ELSIF expression THEN expression )
+        (progn
+        (wisi-statement-action 1 'statement-other 3 'block-middle)
+        (wisi-containing-action 1 2)
+        (wisi-containing-action 3 4))))
+      (elsif_expression_list
+       ((elsif_expression_item ))
+       ((elsif_expression_list elsif_expression_item )))
+      (elsif_statement_item
+       ((ELSIF expression_opt THEN sequence_of_statements_opt )
+        (progn
+        (wisi-statement-action 1 'statement-other 3 'block-middle)
+        (wisi-containing-action 1 2)
+        (wisi-containing-action 3 4))))
+      (elsif_statement_list
+       ((elsif_statement_item ))
+       ((elsif_statement_list elsif_statement_item )))
+      (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 'block-start 4' statement-other 6 
'block-middle 8 'block-middle 10 'block-end
+        12 'statement-end)
+        (wisi-containing-action 1 3)
+        (wisi-containing-action 4 5)
+        (wisi-containing-action 6 7)
+        (wisi-containing-action 8 9)
+        (wisi-motion-action 1 4 6 8 10))))
+      (entry_body_formal_part
+       ((LEFT_PAREN FOR IDENTIFIER IN discrete_subtype_definition RIGHT_PAREN 
parameter_profile_opt )
+        (progn
+        (wisi-statement-action 1 'open-paren 6 'close-paren)
+        (wisi-containing-action 1 4)))
+       ((parameter_profile_opt )))
+      (entry_call_alternative
+       ((procedure_call_statement sequence_of_statements_opt ))
+       ((name sequence_of_statements_opt )))
+      (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 'block-middle 4 
'open-paren 6 'close-paren 8 'statement-end)
+        (wisi-containing-action 1 2)
+        (wisi-containing-action 2 4)
+        (wisi-containing-action 4 5)
+        (wisi-containing-action 2 6)))
+       ((overriding_indicator_opt ENTRY IDENTIFIER parameter_profile_opt 
aspect_specification_opt SEMICOLON )
+        (progn
+        (wisi-statement-action 1 'statement-start 2 'block-middle 6 
'statement-end)
+        (wisi-containing-action 1 2)
+        (wisi-containing-action 2 4))))
+      (enumeration_literal
+       ((IDENTIFIER ))
+       ((CHARACTER_LITERAL )))
+      (enumeration_literal_list
+       ((enumeration_literal ))
+       ((enumeration_literal_list COMMA enumeration_literal )
+        (progn
+        (wisi-statement-action 2 'list-break)
+        (wisi-containing-action 2 3))))
+      (enumeration_representation_clause
+       ((FOR name USE aggregate SEMICOLON )
+        (progn
+        (wisi-statement-action 1 'statement-start 3 'statement-other 5 
'statement-end)
+        (wisi-containing-action 3 4))))
+      (enumeration_type_definition
+       ((LEFT_PAREN enumeration_literal_list RIGHT_PAREN )
+        (progn
+        (wisi-statement-action 1 'open-paren 3 'close-paren)
+        (wisi-containing-action 1 2))))
+      (exception_choice
+       ((name ))
+       ((OTHERS )))
+      (exception_choice_list
+       ((exception_choice ))
+       ((exception_choice_list BAR exception_choice )))
+      (exception_declaration
+       ((identifier_list COLON EXCEPTION SEMICOLON )
+        (wisi-statement-action 1 'statement-start 4 'statement-end)))
+      (exception_handler
+       ((WHEN IDENTIFIER COLON exception_choice_list EQUAL_GREATER 
sequence_of_statements_opt )
+        (progn
+        (wisi-statement-action 1 'block-middle 5 'statement-other)
+        (wisi-containing-action 1 4)
+        (wisi-containing-action 5 6)))
+       ((WHEN exception_choice_list EQUAL_GREATER sequence_of_statements_opt )
+        (progn
+        (wisi-statement-action 1 'block-middle 3 'statement-other)
+        (wisi-containing-action 1 2)
+        (wisi-containing-action 3 4))))
+      (exception_handler_list
+       ((exception_handler ))
+       ((exception_handler_list exception_handler )))
+      (exception_handler_list_opt
+       (())
+       ((exception_handler_list )))
+      (exit_statement
+       ((EXIT identifier_opt WHEN expression_opt SEMICOLON )
+        (progn
+        (wisi-statement-action 1 'statement-start 3 'statement-other 5 
'statement-end)
+        (wisi-containing-action 3 4)))
+       ((EXIT identifier_opt SEMICOLON )
+        (wisi-statement-action 1 'statement-start 3 'statement-end)))
+      (expression
+       ((relation ))
+       ((relation_and_list ))
+       ((relation_and_then_list ))
+       ((relation_or_list ))
+       ((relation_or_else_list ))
+       ((relation_xor_list )))
+      (expression_opt
+       (())
+       ((expression )))
+      (extended_return_object_declaration
+       ((IDENTIFIER COLON aliased_opt constant_opt return_subtype_indication 
COLON_EQUAL expression ))
+       ((IDENTIFIER COLON aliased_opt constant_opt return_subtype_indication 
)))
+      (extended_return_object_declaration_opt
+       (())
+       ((extended_return_object_declaration )))
+      (extended_return_statement
+       ((RETURN extended_return_object_declaration_opt DO 
handled_sequence_of_statements END RETURN SEMICOLON )
+        (progn
+        (wisi-statement-action 1 'block-start 3 'block-middle 5 'block-end 7 
'statement-end)
+        (wisi-containing-action 3 4)))
+       ((RETURN extended_return_object_declaration SEMICOLON )
+        (wisi-statement-action 1 'statement-start 3 'statement-end)))
+      (factor
+       ((primary STAR_STAR primary ))
+       ((primary ))
+       ((ABS primary ))
+       ((NOT primary )))
+      (formal_object_declaration
+       ((identifier_list COLON mode_opt null_exclusion_opt name COLON_EQUAL 
expression aspect_specification_opt SEMICOLON )
+        (progn
+        (wisi-statement-action 1 'statement-start 6 'statement-other 9 
'statement-end)
+        (wisi-containing-action 6 7)))
+       ((identifier_list COLON mode_opt null_exclusion_opt name 
aspect_specification_opt SEMICOLON )
+        (wisi-statement-action 1 'statement-start 7 'statement-end))
+       ((identifier_list COLON mode_opt access_definition COLON_EQUAL 
expression aspect_specification_opt SEMICOLON )
+        (progn
+        (wisi-statement-action 1 'statement-start 5 'statement-other 8 
'statement-end)
+        (wisi-containing-action 5 6)))
+       ((identifier_list COLON mode_opt access_definition 
aspect_specification_opt SEMICOLON )
+        (wisi-statement-action 1 'statement-start 6 'statement-end)))
+      (formal_part
+       ((LEFT_PAREN parameter_specification_list RIGHT_PAREN )
+        (progn
+        (wisi-statement-action 1 'open-paren 3 'close-paren)
+        (wisi-containing-action 1 2))))
+      (formal_subprogram_declaration
+       ((WITH subprogram_specification IS subprogram_default 
aspect_specification_opt SEMICOLON )
+        (progn
+        (wisi-statement-action 1 'statement-start 6 'statement-end)
+        (wisi-containing-action 1 2)))
+       ((WITH subprogram_specification aspect_specification_opt SEMICOLON )
+        (progn
+        (wisi-statement-action 1 'statement-start 4 'statement-end)
+        (wisi-containing-action 1 2)))
+       ((WITH subprogram_specification IS ABSTRACT subprogram_default 
aspect_specification_opt SEMICOLON )
+        (progn
+        (wisi-statement-action 1 'statement-start 7 'statement-end)
+        (wisi-containing-action 1 2)))
+       ((WITH subprogram_specification IS ABSTRACT aspect_specification_opt 
SEMICOLON )
+        (progn
+        (wisi-statement-action 1 'statement-start 6 'statement-end)
+        (wisi-containing-action 1 2))))
+      (formal_type_declaration
+       ((TYPE IDENTIFIER discriminant_part_opt IS formal_type_definition 
aspect_specification_opt SEMICOLON )
+        (progn
+        (wisi-statement-action 1 'statement-start 4 'statement-other 7 
'statement-end)
+        (wisi-containing-action 1 3)
+        (wisi-containing-action 4 5)))
+       ((TYPE IDENTIFIER discriminant_part_opt IS TAGGED 
aspect_specification_opt SEMICOLON )
+        (progn
+        (wisi-statement-action 1 'statement-start 7 'statement-end)
+        (wisi-containing-action 1 3)))
+       ((TYPE IDENTIFIER discriminant_part_opt aspect_specification_opt 
SEMICOLON )
+        (progn
+        (wisi-statement-action 1 'statement-start 5 'statement-end)
+        (wisi-containing-action 1 3))))
+      (formal_type_definition
+       ((abstract_tagged_limited_opt PRIVATE ))
+       ((formal_derived_type_definition ))
+       ((LEFT_PAREN BOX RIGHT_PAREN ))
+       ((RANGE BOX ))
+       ((MOD BOX ))
+       ((DIGITS BOX ))
+       ((DELTA BOX ))
+       ((DELTA BOX DIGITS BOX ))
+       ((array_type_definition ))
+       ((access_definition ))
+       ((interface_type_definition )))
+      (formal_derived_type_definition
+       ((ABSTRACT LIMITED NEW name AND interface_list WITH PRIVATE ))
+       ((ABSTRACT SYNCHRONIZED NEW name AND interface_list WITH PRIVATE ))
+       ((ABSTRACT LIMITED NEW name AND interface_list ))
+       ((ABSTRACT SYNCHRONIZED NEW name AND interface_list ))
+       ((ABSTRACT LIMITED NEW name WITH PRIVATE ))
+       ((ABSTRACT SYNCHRONIZED NEW name WITH PRIVATE ))
+       ((ABSTRACT NEW name ))
+       ((NEW name )))
+      (formal_package_declaration
+       ((WITH PACKAGE name IS NEW name formal_package_actual_part 
aspect_specification_opt SEMICOLON )
+        (progn
+        (wisi-statement-action 1 'statement-start 5 'statement-other 9 
'statement-end)
+        (wisi-containing-action 1 3)
+        (wisi-containing-action 5 6)
+        (wisi-containing-action 5 7))))
+      (formal_package_actual_part
+       ((LEFT_PAREN BOX RIGHT_PAREN ))
+       (()))
+      (full_type_declaration
+       ((TYPE IDENTIFIER discriminant_part_opt IS type_definition 
aspect_specification_opt SEMICOLON )
+        (progn
+        (wisi-statement-action 1 'statement-start 2 'name 4 'statement-other 7 
'statement-end)
+        (wisi-containing-action 1 3)
+        (wisi-containing-action 4 5)))
+       ((task_type_declaration ))
+       ((protected_type_declaration )))
+      (general_access_modifier_opt
+       (())
+       ((ALL ))
+       ((CONSTANT )))
+      (generic_declaration
+       ((generic_subprogram_declaration ))
+       ((generic_package_declaration )))
+      (generic_formal_part
+       ((GENERIC generic_formal_parameter_declarations )
+        (progn
+        (wisi-statement-action 1 'block-start)
+        (wisi-containing-action 1 2)))
+       ((GENERIC )
+        (wisi-statement-action 1 'block-start)))
+      (generic_formal_parameter_declarations
+       ((generic_formal_parameter_declaration ))
+       ((generic_formal_parameter_declarations 
generic_formal_parameter_declaration )))
+      (generic_formal_parameter_declaration
+       ((formal_object_declaration ))
+       ((formal_type_declaration ))
+       ((formal_subprogram_declaration ))
+       ((formal_package_declaration ))
+       ((pragma )))
+      (generic_instantiation
+       ((PACKAGE name IS NEW name aspect_specification_opt SEMICOLON )
+        (progn
+        (wisi-statement-action 1 'statement-start 2 'name 4 'statement-other 7 
'statement-end)
+        (wisi-containing-action 4 5)))
+       ((overriding_indicator_opt PROCEDURE name IS NEW name 
aspect_specification_opt SEMICOLON )
+        (progn
+        (wisi-statement-action 1 'statement-start 2 'block-middle 3 'name 5 
'statement-other 8 'statement-end)
+        (wisi-containing-action 5 6)))
+       ((overriding_indicator_opt FUNCTION name IS NEW name 
aspect_specification_opt SEMICOLON )
+        (progn
+        (wisi-statement-action 1 'statement-start 2 'block-middle 3 'name 5 
'statement-other 8 'statement-end)
+        (wisi-containing-action 5 6))))
+      (generic_package_declaration
+       ((generic_formal_part package_specification SEMICOLON )
+        (progn
+        (wisi-statement-action 1 'block-start 2 'block-middle 3 'statement-end)
+        (wisi-motion-action 1 2 3))))
+      (generic_renaming_declaration
+       ((GENERIC PACKAGE name RENAMES name aspect_specification_opt SEMICOLON )
+        (wisi-statement-action 1 'statement-start 2 'statement-other 3 'name 4 
'statement-other 7 'statement-end))
+       ((GENERIC PROCEDURE name RENAMES name aspect_specification_opt 
SEMICOLON )
+        (wisi-statement-action 1 'statement-start 2 'statement-other 3 'name 4 
'statement-other 7 'statement-end))
+       ((GENERIC FUNCTION name RENAMES name aspect_specification_opt SEMICOLON 
)
+        (wisi-statement-action 1 'statement-start 2 'statement-other 3 'name 4 
'statement-other 7 'statement-end)))
+      (generic_subprogram_declaration
+       ((generic_formal_part subprogram_specification aspect_specification_opt 
SEMICOLON )
+        (progn
+        (wisi-statement-action 1 'block-start 2 'block-middle 4 'statement-end)
+        (wisi-motion-action 1 2))))
+      (handled_sequence_of_statements
+       ((sequence_of_statements_opt EXCEPTION exception_handler_list_opt )
+        (progn
+        (wisi-statement-action 2 'block-middle)
+        (wisi-containing-action 2 3)
+        (wisi-motion-action 2 '(3 WHEN))))
+       ((sequence_of_statements_opt )))
+      (identifier_list
+       ((IDENTIFIER ))
+       ((identifier_list COMMA IDENTIFIER )))
+      (identifier_opt
+       (())
+       ((IDENTIFIER )))
+      (if_expression
+       ((IF expression THEN expression elsif_expression_list ELSE expression )
+        (progn
+        (wisi-statement-action 1 'statement-start 3 'block-middle 6 
'block-middle)
+        (wisi-containing-action 1 2)
+        (wisi-containing-action 3 4)
+        (wisi-containing-action 3 5)
+        (wisi-containing-action 6 7)
+        (wisi-motion-action 1 3 '(5 (ELSIF THEN)) 6)))
+       ((IF expression THEN expression elsif_expression_list )
+        (progn
+        (wisi-statement-action 1 'statement-start 3 'block-middle)
+        (wisi-containing-action 1 2)
+        (wisi-containing-action 3 4)
+        (wisi-containing-action 3 5)
+        (wisi-motion-action 1 3 '(5 (ELSIF THEN)))))
+       ((IF expression THEN expression ELSE expression )
+        (progn
+        (wisi-statement-action 1 'statement-start 3 'block-middle 5 
'block-middle)
+        (wisi-containing-action 1 2)
+        (wisi-containing-action 3 4)
+        (wisi-containing-action 5 6)
+        (wisi-motion-action 1 3 5)))
+       ((IF expression THEN expression )
+        (progn
+        (wisi-statement-action 1 'statement-start 3 'block-middle)
+        (wisi-containing-action 1 2)
+        (wisi-containing-action 3 4)
+        (wisi-motion-action 1 3))))
+      (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 'block-middle 6 
'block-middle 8 'block-end 10 'statement-end)
+        (wisi-containing-action 1 2)
+        (wisi-containing-action 3 4)
+        (wisi-containing-action 3 5)
+        (wisi-containing-action 6 7)
+        (wisi-motion-action 1 3 '(5 (ELSIF THEN)) 6 8)))
+       ((IF expression_opt THEN sequence_of_statements_opt 
elsif_statement_list END IF SEMICOLON )
+        (progn
+        (wisi-statement-action 1 'statement-start 3 'block-middle 6 'block-end 
9 'statement-end)
+        (wisi-containing-action 1 2)
+        (wisi-containing-action 3 4)
+        (wisi-containing-action 3 5)
+        (wisi-motion-action 1 3 '(5 (ELSIF THEN)) 6)))
+       ((IF expression_opt THEN sequence_of_statements_opt ELSE 
sequence_of_statements_opt END IF SEMICOLON )
+        (progn
+        (wisi-statement-action 1 'statement-start 3 'block-middle 5 
'block-middle 7 'block-end 9 'statement-end)
+        (wisi-containing-action 1 2)
+        (wisi-containing-action 3 4)
+        (wisi-containing-action 5 6)
+        (wisi-motion-action 1 3 5 7)))
+       ((IF expression_opt THEN sequence_of_statements_opt END IF SEMICOLON )
+        (progn
+        (wisi-statement-action 1 'statement-start 3 'block-middle 5 'block-end 
7 'statement-end)
+        (wisi-containing-action 1 2)
+        (wisi-containing-action 3 4)
+        (wisi-motion-action 1 3 5))))
+      (incomplete_type_declaration
+       ((TYPE IDENTIFIER discriminant_part_opt IS TAGGED SEMICOLON )
+        (progn
+        (wisi-statement-action 1 'statement-start 2 'name 6 'statement-end)
+        (wisi-containing-action 1 3)))
+       ((TYPE IDENTIFIER SEMICOLON )
+        (wisi-statement-action 1 'statement-start 2 'name 3 'statement-end)))
+      (index_constraint
+       ((LEFT_PAREN discrete_subtype_definition_list RIGHT_PAREN )
+        (progn
+        (wisi-statement-action 1 'open-paren 3 'close-paren)
+        (wisi-containing-action 1 2))))
+      (index_subtype_definition
+       ((name RANGE BOX )))
+      (index_subtype_definition_list
+       ((index_subtype_definition ))
+       ((index_subtype_definition_list COMMA index_subtype_definition )
+        (progn
+        (wisi-statement-action 2 'list-break)
+        (wisi-containing-action 2 3))))
+      (interface_list
+       ((name ))
+       ((interface_list AND name )))
+      (interface_type_definition
+       ((LIMITED INTERFACE AND interface_list ))
+       ((TASK INTERFACE AND interface_list ))
+       ((PROTECTED INTERFACE AND interface_list ))
+       ((SYNCHRONIZED INTERFACE AND interface_list ))
+       ((LIMITED INTERFACE ))
+       ((TASK INTERFACE ))
+       ((PROTECTED INTERFACE ))
+       ((SYNCHRONIZED INTERFACE ))
+       ((INTERFACE )))
+      (iteration_scheme
+       ((WHILE expression_opt )
+        (progn
+        (wisi-statement-action 1 'statement-start)
+        (wisi-containing-action 1 2)))
+       ((FOR iterator_specification_opt )
+        (progn
+        (wisi-statement-action 1 'statement-start)
+        (wisi-containing-action 1 2))))
+      (iterator_specification
+       ((IDENTIFIER IN REVERSE discrete_subtype_definition ))
+       ((IDENTIFIER IN discrete_subtype_definition ))
+       ((IDENTIFIER COLON subtype_indication OF REVERSE name ))
+       ((IDENTIFIER COLON subtype_indication OF name ))
+       ((IDENTIFIER OF REVERSE name ))
+       ((IDENTIFIER OF name )))
+      (iterator_specification_opt
+       (())
+       ((iterator_specification )))
+      (label_opt
+       (())
+       ((LESS_LESS IDENTIFIER GREATER_GREATER ))
+       ((IDENTIFIER COLON )))
+      (library_item
+       ((PRIVATE library_unit_declaration ))
+       ((library_unit_declaration ))
+       ((subprogram_body ))
+       ((package_body ))
+       ((library_unit_renaming_declaration )))
+      (library_unit_declaration
+       ((subprogram_declaration ))
+       ((package_declaration ))
+       ((generic_declaration ))
+       ((generic_instantiation )))
+      (library_unit_renaming_declaration
+       ((generic_renaming_declaration )))
+      (loop_statement
+       ((iteration_scheme LOOP sequence_of_statements_opt END LOOP 
identifier_opt SEMICOLON )
+        (progn
+        (wisi-statement-action 1 'statement-start 2 'block-middle 4 'block-end 
7 'statement-end)
+        (wisi-containing-action 2 3)
+        (wisi-motion-action 1 2 4)))
+       ((LOOP sequence_of_statements_opt END LOOP identifier_opt SEMICOLON )
+        (progn
+        (wisi-statement-action 1 'block-start 3 'block-end 6 'statement-end)
+        (wisi-containing-action 1 2)
+        (wisi-motion-action 1 3))))
+      (membership_choice_list
+       ((membership_choice ))
+       ((membership_choice_list BAR membership_choice )))
+      (membership_choice
+       ((simple_expression ))
+       ((range )))
+      (mod_clause_opt
+       (())
+       ((AT MOD expression SEMICOLON )))
+      (mode_opt
+       (())
+       ((IN ))
+       ((IN OUT ))
+       ((OUT )))
+      (multiplying_operator
+       ((STAR ))
+       ((SLASH ))
+       ((MOD ))
+       ((REM )))
+      (name_list
+       ((name ))
+       ((name_list COMMA name )
+        (progn
+        (wisi-statement-action 2 'statement-other)
+        (wisi-containing-action 2 3))))
+      (name
+       ((IDENTIFIER ))
+       ((CHARACTER_LITERAL ))
+       ((name LEFT_PAREN range RIGHT_PAREN )
+        (progn
+        (wisi-statement-action 1 'name-paren 2 'open-paren 4 'close-paren)
+        (wisi-containing-action 2 3)))
+       ((selected_component ))
+       ((attribute_reference ))
+       ((name actual_parameter_part )
+        (progn
+        (wisi-statement-action 1 'name-paren)
+        (wisi-containing-action 1 2)))
+       ((qualified_expression ))
+       ((STRING_LITERAL )))
+      (name_opt
+       (())
+       ((name )))
+      (null_exclusion_opt
+       (())
+       ((NOT NULL )))
+      (null_exclusion_opt_name
+       ((IDENTIFIER ))
+       ((selected_component ))
+       ((NOT NULL IDENTIFIER ))
+       ((NOT NULL selected_component )))
+      (null_procedure_declaration
+       ((overriding_indicator_opt procedure_specification IS NULL 
aspect_specification_opt SEMICOLON )
+        (progn
+        (wisi-statement-action 1 'statement-start 2 'statement-other 3 'name 6 
'statement-end)
+        (wisi-containing-action 1 2))))
+      (object_declaration
+       ((identifier_list COLON aliased_opt constant_opt subtype_indication 
COLON_EQUAL expression aspect_specification_opt SEMICOLON )
+        (progn
+        (wisi-statement-action 1 'statement-start 2 'statement-other 6 
'statement-other 9 'statement-end)
+        (wisi-containing-action 2 5)
+        (wisi-containing-action 6 7)))
+       ((identifier_list COLON aliased_opt constant_opt subtype_indication 
aspect_specification_opt SEMICOLON )
+        (progn
+        (wisi-statement-action 1 'statement-start 2 'statement-other 7 
'statement-end)
+        (wisi-containing-action 2 5)))
+       ((identifier_list COLON aliased_opt constant_opt access_definition 
COLON_EQUAL expression aspect_specification_opt SEMICOLON )
+        (progn
+        (wisi-statement-action 1 'statement-start 2 'statement-other 9 
'statement-end)
+        (wisi-containing-action 2 5)
+        (wisi-containing-action 6 7)))
+       ((identifier_list COLON aliased_opt constant_opt access_definition 
aspect_specification_opt SEMICOLON )
+        (progn
+        (wisi-statement-action 1 'statement-start 2 'statement-other 7 
'statement-end)
+        (wisi-containing-action 2 5)))
+       ((identifier_list COLON aliased_opt constant_opt array_type_definition 
COLON_EQUAL expression aspect_specification_opt SEMICOLON )
+        (progn
+        (wisi-statement-action 1 'statement-start 2 'statement-other 9 
'statement-end)
+        (wisi-containing-action 2 5)
+        (wisi-containing-action 6 7)))
+       ((identifier_list COLON aliased_opt constant_opt array_type_definition 
aspect_specification_opt SEMICOLON )
+        (progn
+        (wisi-statement-action 1 'statement-start 2 'statement-other 7 
'statement-end)
+        (wisi-containing-action 2 5)))
+       ((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 4 'name 5 'statement-other 6 
'name 8 'statement-end)
+        (wisi-containing-action 1 4)
+        (wisi-containing-action 1 6)))
+       ((IDENTIFIER COLON access_definition RENAMES name 
aspect_specification_opt SEMICOLON )
+        (progn
+        (wisi-statement-action 1 'statement-start 4 'statement-other 5 'name 7 
'statement-end)
+        (wisi-containing-action 1 3)
+        (wisi-containing-action 1 5)))
+       ((IDENTIFIER COLON EXCEPTION RENAMES name aspect_specification_opt 
SEMICOLON )
+        (progn
+        (wisi-statement-action 1 'statement-start 4 'statement-other 5 'name 7 
'statement-end)
+        (wisi-containing-action 1 5))))
+      (overriding_indicator_opt
+       ((NOT OVERRIDING )
+        (wisi-statement-action 1 'statement-start 2 'statement-other))
+       ((OVERRIDING )
+        (wisi-statement-action 1 'statement-start))
+       (()))
+      (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 'block-start 3 'name 5 'block-middle 7 
'block-middle
+        9 'block-end 11 'statement-end)
+        (wisi-containing-action 5 6)
+        (wisi-containing-action 7 8)))
+       ((PACKAGE BODY name aspect_specification_opt IS declarative_part_opt 
END name_opt SEMICOLON )
+        (progn
+        (wisi-statement-action 1 'block-start 3 'name 5 'block-middle 7 
'block-end 9 'statement-end)
+        (wisi-containing-action 5 6))))
+      (package_body_stub
+       ((PACKAGE BODY name IS SEPARATE aspect_specification_opt SEMICOLON )
+        (wisi-statement-action 1 'statement-start 7 'statement-end)))
+      (package_declaration
+       ((package_specification SEMICOLON )
+        (wisi-statement-action 1 'statement-start 2 'statement-end)))
+      (package_renaming_declaration
+       ((PACKAGE name RENAMES name aspect_specification_opt SEMICOLON )
+        (wisi-statement-action 1 'statement-start 2 'name 3 'statement-other 6 
'statement-end)))
+      (package_specification
+       ((PACKAGE name aspect_specification_opt IS declarative_part_opt PRIVATE 
declarative_part_opt END name )
+        (progn
+        (wisi-statement-action 1 'statement-start 2 'name 4 'block-start 6 
'block-middle 8 'block-end)
+        (wisi-containing-action 4 5)
+        (wisi-containing-action 6 7)
+        (wisi-motion-action 1 4 6 8)))
+       ((PACKAGE name aspect_specification_opt IS declarative_part_opt END 
name )
+        (progn
+        (wisi-statement-action 1 'statement-start 2 'name 4 'block-start 6 
'block-end)
+        (wisi-containing-action 4 5)
+        (wisi-motion-action 1 4 6))))
+      (parameter_and_result_profile
+       ((formal_part RETURN null_exclusion_opt name )
+        (progn
+        (wisi-statement-action
+        2 'return-1
+        4 'type)
+        (wisi-containing-action 2 4)))
+       ((RETURN name )
+        (wisi-statement-action 1 'return-2 2 'type))
+       ((formal_part RETURN access_definition )
+        (progn
+        (wisi-statement-action 2 'return-1)
+        (wisi-containing-action 2 3)))
+       ((RETURN access_definition )
+        (progn
+        (wisi-statement-action 1 'return-2)
+        (wisi-containing-action 1 2))))
+      (parameter_profile_opt
+       (())
+       ((formal_part )))
+      (parameter_specification
+       ((identifier_list COLON aliased_opt mode_opt null_exclusion_opt name 
COLON_EQUAL expression ))
+       ((identifier_list COLON aliased_opt mode_opt null_exclusion_opt name ))
+       ((identifier_list COLON access_definition COLON_EQUAL expression ))
+       ((identifier_list COLON access_definition )))
+      (parameter_specification_list
+       ((parameter_specification ))
+       ((parameter_specification_list SEMICOLON parameter_specification )
+        (progn
+        (wisi-statement-action 2 'list-break)
+        (wisi-containing-action 2 3))))
+      (pragma
+       ((PRAGMA IDENTIFIER LEFT_PAREN pragma_argument_association_list 
RIGHT_PAREN SEMICOLON )
+        (progn
+        (wisi-statement-action 1 'statement-start 3 'open-paren 5 'close-paren 
6 'statement-end)
+        (wisi-containing-action 3 4)))
+       ((PRAGMA IDENTIFIER SEMICOLON )
+        (wisi-statement-action 1 'statement-start 3 'statement-end)))
+      (pragma_argument_association
+       ((IDENTIFIER EQUAL_GREATER expression ))
+       ((expression ))
+       ((IDENTIFIER TICK IDENTIFIER EQUAL_GREATER expression )))
+      (pragma_argument_association_list
+       ((pragma_argument_association ))
+       ((pragma_argument_association_list COMMA pragma_argument_association )))
+      (primary
+       ((NULL ))
+       ((aggregate ))
+       ((name ))
+       ((NEW name ))
+       ((LEFT_PAREN if_expression RIGHT_PAREN )
+        (progn
+        (wisi-statement-action 1 'open-paren 3 'close-paren)
+        (wisi-containing-action 1 2)))
+       ((LEFT_PAREN case_expression RIGHT_PAREN )
+        (progn
+        (wisi-statement-action 1 'open-paren 3 'close-paren)
+        (wisi-containing-action 1 2)))
+       ((LEFT_PAREN quantified_expression RIGHT_PAREN )
+        (progn
+        (wisi-statement-action 1 'open-paren 3 'close-paren)
+        (wisi-containing-action 1 2))))
+      (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 2 'name 6 'statement-other 
12 'statement-end)
+        (wisi-containing-action 1 3)
+        (wisi-containing-action 6 7)
+        (wisi-containing-action 6 8))))
+      (private_type_declaration
+       ((TYPE IDENTIFIER discriminant_part_opt IS abstract_tagged_limited_opt 
PRIVATE aspect_specification_opt SEMICOLON )
+        (wisi-statement-action 1 'statement-start 2 'name 8 'statement-end)))
+      (procedure_call_statement
+       ((name SEMICOLON )
+        (wisi-statement-action 1 'statement-start 2 'statement-end)))
+      (procedure_specification
+       ((PROCEDURE name parameter_profile_opt )
+        (progn
+        (wisi-statement-action 1 'statement-start 2 'name)
+        (wisi-containing-action 1 3))))
+      (proper_body
+       ((subprogram_body ))
+       ((package_body ))
+       ((task_body ))
+       ((protected_body )))
+      (protected_body
+       ((PROTECTED BODY IDENTIFIER aspect_specification_opt IS 
protected_operation_item_list_opt END identifier_opt SEMICOLON )
+        (progn
+        (wisi-statement-action 1 'block-start 3 'name 5 'block-middle 7 
'block-end 9 'statement-end)
+        (wisi-containing-action 5 6)
+        (wisi-motion-action 1 5 7))))
+      (protected_body_stub
+       ((PROTECTED BODY IDENTIFIER IS SEPARATE aspect_specification_opt 
SEMICOLON )
+        (wisi-statement-action 1 'statement-start 7 'statement-end)))
+      (protected_definition
+       ((declarative_part_opt PRIVATE declarative_part_opt END identifier_opt )
+        (progn
+        (wisi-statement-action 2 'block-middle 4 'block-end)
+        (wisi-containing-action 2 3)))
+       ((declarative_part_opt END identifier_opt )
+        (wisi-statement-action 2 'block-end)))
+      (protected_operation_item
+       ((subprogram_declaration ))
+       ((subprogram_body ))
+       ((entry_body ))
+       ((aspect_clause )))
+      (protected_operation_item_list
+       ((protected_operation_item ))
+       ((protected_operation_item_list protected_operation_item )))
+      (protected_operation_item_list_opt
+       (())
+       ((protected_operation_item_list )))
+      (protected_opt
+       (())
+       ((PROTECTED )))
+      (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 3 'name 6 'block-start 11 
'statement-end)
+        (wisi-containing-action 9 10)))
+       ((PROTECTED TYPE IDENTIFIER discriminant_part_opt 
aspect_specification_opt IS protected_definition SEMICOLON )
+        (progn
+        (wisi-statement-action 1 'statement-start 3 'name 6 'block-start 8 
'statement-end)
+        (wisi-containing-action 6 7))))
+      (qualified_expression
+       ((name TICK aggregate )
+        (progn
+        (wisi-statement-action 1 'statement-other)
+        (wisi-containing-action 1 3))))
+      (quantified_expression
+       ((FOR quantifier iterator_specification EQUAL_GREATER expression )
+        (progn
+        (wisi-statement-action 4 'statement-other)
+        (wisi-containing-action 4 5))))
+      (quantifier
+       ((ALL ))
+       ((SOME )))
+      (raise_statement
+       ((RAISE SEMICOLON )
+        (wisi-statement-action 1 'statement-start 2 'statement-end))
+       ((RAISE name WITH expression SEMICOLON )
+        (progn
+        (wisi-statement-action 1 'statement-start 3 'statement-other 5 
'statement-end)
+        (wisi-containing-action 3 4)))
+       ((RAISE name SEMICOLON )
+        (wisi-statement-action 1 'statement-start 3 'statement-end)))
+      (range
+       ((name TICK RANGE LEFT_PAREN expression RIGHT_PAREN )
+        (progn
+        (wisi-statement-action 4 'open-paren 6 'close-paren)
+        (wisi-containing-action 4 5)))
+       ((name TICK RANGE ))
+       ((simple_expression DOT_DOT simple_expression )))
+      (real_range_specification_opt
+       (())
+       ((RANGE simple_expression DOT_DOT simple_expression )))
+      (record_definition
+       ((RECORD component_list_opt END RECORD )
+        (progn
+        (wisi-statement-action 1 'block-start 3 'block-end)
+        (wisi-containing-action 1 2)))
+       ((NULL RECORD )))
+      (record_representation_clause
+       ((FOR name USE record_rep SEMICOLON )
+        (progn
+        (wisi-statement-action 1 'statement-start 3 'statement-other 5 
'statement-end)
+        (wisi-containing-action 3 4))))
+      (record_rep
+       ((RECORD mod_clause_opt component_clause_list END RECORD )
+        (progn
+        (wisi-statement-action 1 'block-start 4 'block-end)
+        (wisi-containing-action 1 3))))
+      (record_type_definition
+       ((abstract_tagged_limited_opt record_definition )))
+      (relation_and_list
+       ((relation AND relation ))
+       ((relation_and_list AND relation )))
+      (relation_and_then_list
+       ((relation AND THEN relation ))
+       ((relation_and_then_list AND THEN relation )))
+      (relation_or_list
+       ((relation OR relation ))
+       ((relation_or_list OR relation )))
+      (relation_or_else_list
+       ((relation OR ELSE relation ))
+       ((relation_or_else_list OR ELSE relation )))
+      (relation_xor_list
+       ((relation XOR relation ))
+       ((relation_xor_list XOR relation )))
+      (relation
+       ((simple_expression ))
+       ((simple_expression relational_operator simple_expression ))
+       ((simple_expression NOT IN membership_choice_list ))
+       ((simple_expression IN membership_choice_list )))
+      (relational_operator
+       ((EQUAL ))
+       ((SLASH_EQUAL ))
+       ((LESS ))
+       ((LESS_EQUAL ))
+       ((GREATER ))
+       ((GREATER_EQUAL )))
+      (renaming_declaration
+       ((object_renaming_declaration ))
+       ((package_renaming_declaration ))
+       ((subprogram_renaming_declaration ))
+       ((generic_renaming_declaration )))
+      (requeue_statement
+       ((REQUEUE name WITH ABORT SEMICOLON )
+        (progn
+        (wisi-statement-action 1 'statement-start 2 'name 5 'statement-end)
+        (wisi-containing-action 1 2)))
+       ((REQUEUE name SEMICOLON )
+        (progn
+        (wisi-statement-action 1 'statement-start 2 'name 5 'statement-end)
+        (wisi-containing-action 1 2))))
+      (return_subtype_indication
+       ((subtype_indication ))
+       ((access_definition )))
+      (selected_component
+       ((name DOT IDENTIFIER ))
+       ((name DOT CHARACTER_LITERAL ))
+       ((name DOT STRING_LITERAL ))
+       ((name DOT ALL )))
+      (selective_accept
+       ((SELECT select_alternative_list_opt ELSE sequence_of_statements_opt 
END SELECT SEMICOLON )
+        (progn
+        (wisi-statement-action 1 'block-start 3 'block-middle 5 'block-end 7 
'statement-end)
+        (wisi-containing-action 1 2)
+        (wisi-containing-action 3 4)
+        (wisi-motion-action 1 '(2 OR) 3 5)))
+       ((SELECT select_alternative_list_opt END SELECT SEMICOLON )
+        (progn
+        (wisi-statement-action 1 'block-start 3 'block-end 5 'statement-end)
+        (wisi-containing-action 1 2)
+        (wisi-motion-action 1 '(2 OR) 3))))
+      (select_alternative
+       ((WHEN expression EQUAL_GREATER accept_statement 
sequence_of_statements_opt )
+        (progn
+        (wisi-statement-action 1 'block-start 3 'statement-other)
+        (wisi-containing-action 1 2)
+        (wisi-containing-action 3 4)
+        (wisi-containing-action 3 5)))
+       ((accept_statement sequence_of_statements_opt ))
+       ((WHEN expression EQUAL_GREATER delay_alternative )
+        (progn
+        (wisi-statement-action 1 'block-start 3 'statement-other)
+        (wisi-containing-action 1 2)
+        (wisi-containing-action 3 4)))
+       ((delay_alternative ))
+       ((WHEN expression EQUAL_GREATER TERMINATE SEMICOLON )
+        (progn
+        (wisi-statement-action 1 'block-start 3 'statement-other 4 
'statement-start 5 'statement-end)
+        (wisi-containing-action 1 2)))
+       ((TERMINATE SEMICOLON )
+        (wisi-statement-action 1 'statement-start 2 'statement-end)))
+      (select_alternative_list
+       ((select_alternative ))
+       ((select_alternative_list OR select_alternative )
+        (wisi-statement-action 2 'block-middle)))
+      (select_alternative_list_opt
+       (())
+       ((select_alternative_list )))
+      (select_statement
+       ((selective_accept ))
+       ((timed_entry_call ))
+       ((conditional_entry_call ))
+       ((asynchronous_select )))
+      (sequence_of_statements
+       ((statement ))
+       ((sequence_of_statements statement )))
+      (sequence_of_statements_opt
+       (())
+       ((sequence_of_statements )))
+      (simple_expression
+       ((unary_adding_operator term_list ))
+       ((term_list )))
+      (simple_return_statement
+       ((RETURN SEMICOLON )
+        (wisi-statement-action 1 'statement-start 2 'statement-end))
+       ((RETURN expression SEMICOLON )
+        (progn
+        (wisi-statement-action 1 'statement-start 3 'statement-end)
+        (wisi-containing-action 1 2))))
+      (simple_statement
+       ((NULL SEMICOLON )
+        (wisi-statement-action 1 'statement-start 2 'statement-end))
+       ((assignment_statement ))
+       ((exit_statement ))
+       ((GOTO IDENTIFIER SEMICOLON )
+        (wisi-statement-action 1 'statement-start 3 'statement-end))
+       ((procedure_call_statement ))
+       ((simple_return_statement ))
+       ((requeue_statement ))
+       ((delay_statement ))
+       ((ABORT name SEMICOLON )
+        (wisi-statement-action 1 'statement-start 3 'statement-end))
+       ((raise_statement ))
+       ((pragma )))
+      (single_protected_declaration
+       ((PROTECTED IDENTIFIER aspect_specification_opt IS NEW interface_list 
WITH protected_definition SEMICOLON )
+        (progn
+        (wisi-statement-action 1 'block-start 2 'name 7 'block-middle 9 
'statement-end)
+        (wisi-containing-action 7 8)))
+       ((PROTECTED IDENTIFIER aspect_specification_opt IS protected_definition 
SEMICOLON )
+        (progn
+        (wisi-statement-action 1 'block-start 2 'name 4 'block-middle 6 
'statement-end)
+        (wisi-containing-action 4 5))))
+      (single_task_declaration
+       ((TASK IDENTIFIER aspect_specification_opt IS NEW interface_list WITH 
task_definition SEMICOLON )
+        (progn
+        (wisi-statement-action 1 'block-start 2 'name 7 'block-middle 9 
'statement-end)
+        (wisi-containing-action 7 8)))
+       ((TASK IDENTIFIER aspect_specification_opt IS task_definition SEMICOLON 
)
+        (progn
+        (wisi-statement-action 1 'block-start 2 'name 4 'block-middle 6 
'statement-end)
+        (wisi-containing-action 4 5)))
+       ((TASK IDENTIFIER aspect_specification_opt SEMICOLON )
+        (wisi-statement-action 1 'statement-start 4 'statement-end)))
+      (statement
+       ((label_opt simple_statement )
+        (wisi-statement-action 1 'statement-start 2 'statement-other))
+       ((label_opt compound_statement )
+        (wisi-statement-action 1 'statement-start 2 'statement-other)))
+      (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 'block-middle 4 
'block-middle 6 'block-middle 8 'block-end 10 'statement-end)
+        (wisi-containing-action 4 5)
+        (wisi-containing-action 6 7)
+        (wisi-motion-action 1 2 4 6 8))))
+      (subprogram_body_stub
+       ((overriding_indicator_opt subprogram_specification IS SEPARATE 
aspect_specification_opt SEMICOLON )
+        (wisi-statement-action 1 'statement-start 2 'block-middle 6 
'statement-end)))
+      (subprogram_declaration
+       ((overriding_indicator_opt subprogram_specification SEMICOLON )
+        (wisi-statement-action 1 'statement-start 2 'block-middle 3 
'statement-end)))
+      (subprogram_default
+       ((name ))
+       ((BOX ))
+       ((NULL )))
+      (subprogram_renaming_declaration
+       ((overriding_indicator_opt subprogram_specification RENAMES name 
aspect_specification_opt SEMICOLON )
+        (wisi-statement-action 1 'statement-start 2 'block-middle 3 
'statement-other 6 'statement-end)))
+      (subprogram_specification
+       ((procedure_specification ))
+       ((FUNCTION name parameter_and_result_profile )
+        (progn
+        (wisi-statement-action 1 'statement-start 2 'name)
+        (wisi-containing-action 1 3)
+        (wisi-motion-action 1 '(3 RETURN)))))
+      (subtype_declaration
+       ((SUBTYPE IDENTIFIER IS subtype_indication aspect_specification_opt 
SEMICOLON )
+        (progn
+        (wisi-statement-action 1 'statement-start 3 'statement-other 6 
'statement-end)
+        (wisi-containing-action 3 4))))
+      (subtype_indication
+       ((NOT NULL name constraint )
+        (progn
+        (wisi-statement-action 3 'name)
+        (wisi-containing-action 3 4)))
+       ((NOT NULL name ))
+       ((name constraint )
+        (progn
+        (wisi-statement-action 1 'name)
+        (wisi-containing-action 1 2)))
+       ((name )))
+      (subunit
+       ((SEPARATE LEFT_PAREN name RIGHT_PAREN proper_body )
+        (progn
+        (wisi-statement-action 2 'open-paren 4 'close-paren)
+        (wisi-containing-action 2 3))))
+      (task_body
+       ((TASK BODY IDENTIFIER aspect_specification_opt IS declarative_part_opt 
BEGIN handled_sequence_of_statements END identifier_opt SEMICOLON )
+        (progn
+        (wisi-statement-action 1 'statement-start 3 'name 5 'block-start 7 
'block-middle 9 'block-end 11 'statement-end)
+        (wisi-containing-action 5 6)
+        (wisi-containing-action 7 8)
+        (wisi-motion-action 1 5 7 9))))
+      (task_body_stub
+       ((TASK BODY IDENTIFIER IS SEPARATE aspect_specification_opt SEMICOLON )
+        (wisi-statement-action 1 'statement-start 7 'statement-end)))
+      (task_definition
+       ((declarative_part_opt PRIVATE declarative_part_opt END identifier_opt )
+        (progn
+        (wisi-statement-action 2 'block-middle 4 'block-end)
+        (wisi-containing-action 2 3)))
+       ((declarative_part_opt END identifier_opt )
+        (wisi-statement-action 2 'block-end)))
+      (task_type_declaration
+       ((TASK TYPE IDENTIFIER discriminant_part_opt aspect_specification_opt 
IS NEW interface_list WITH task_definition SEMICOLON )
+        (progn
+        (wisi-statement-action 1 'statement-start 3 'name 10 'statement-other 
11 'statement-end)
+        (wisi-containing-action 9 10)))
+       ((TASK TYPE IDENTIFIER discriminant_part_opt aspect_specification_opt 
IS task_definition SEMICOLON )
+        (progn
+        (wisi-statement-action 1 'statement-start 3 'name 6 'block-start 8 
'statement-end)
+        (wisi-containing-action 6 7)))
+       ((TASK TYPE IDENTIFIER discriminant_part_opt aspect_specification_opt 
SEMICOLON )
+        (wisi-statement-action 1 'statement-start 3 'name 6 'statement-end)))
+      (term
+       ((factor ))
+       ((term multiplying_operator factor )))
+      (term_list
+       ((term ))
+       ((term_list binary_adding_operator term )))
+      (timed_entry_call
+       ((SELECT entry_call_alternative OR delay_alternative END SELECT 
SEMICOLON )
+        (progn
+        (wisi-statement-action 1 'block-start 3 'block-middle 5 'block-end 6 
'statement-end)
+        (wisi-containing-action 1 2)
+        (wisi-containing-action 3 4))))
+      (triggering_alternative
+       ((procedure_call_statement sequence_of_statements_opt ))
+       ((name sequence_of_statements_opt ))
+       ((delay_statement sequence_of_statements_opt )))
+      (type_declaration
+       ((full_type_declaration ))
+       ((incomplete_type_declaration ))
+       ((private_type_declaration ))
+       ((private_extension_declaration )))
+      (type_definition
+       ((enumeration_type_definition ))
+       ((RANGE simple_expression DOT_DOT simple_expression ))
+       ((MOD expression ))
+       ((DIGITS expression real_range_specification_opt ))
+       ((DELTA expression real_range_specification_opt ))
+       ((DELTA expression DIGITS expression real_range_specification_opt ))
+       ((array_type_definition ))
+       ((record_type_definition ))
+       ((access_definition ))
+       ((derived_type_definition ))
+       ((interface_type_definition )))
+      (variant_part
+       ((CASE direct_name IS variant_list END CASE SEMICOLON )
+        (progn
+        (wisi-statement-action 1 'statement-start 3 'block-start 5 'block-end 
7 'statement-end)
+        (wisi-containing-action 3 4))))
+      (variant_list
+       ((variant ))
+       ((variant_list variant )))
+      (variant
+       ((WHEN discrete_choice_list EQUAL_GREATER component_list )
+        (progn
+        (wisi-statement-action 1 'block-middle 3 'statement-other)
+        (wisi-containing-action 1 2)
+        (wisi-containing-action 3 4))))
+      (unary_adding_operator
+       ((PLUS ))
+       ((MINUS )))
+      (use_clause
+       ((USE name_list SEMICOLON )
+        (progn
+        (wisi-statement-action 1 'statement-start 3 'statement-end)
+        (wisi-containing-action 1 2)))
+       ((USE ALL TYPE name_list SEMICOLON )
+        (progn
+        (wisi-statement-action 1 'statement-start 5 'statement-end)
+        (wisi-containing-action 1 4)))
+       ((USE TYPE name_list SEMICOLON )
+        (progn
+        (wisi-statement-action 1 'statement-start 4 'statement-end)
+        (wisi-containing-action 1 3))))
+      (with_clause
+       ((LIMITED PRIVATE WITH name_list SEMICOLON )
+        (progn
+        (wisi-statement-action 1 'statement-start 3 'statement-other 5 
'statement-end)
+        (wisi-containing-action 3 4)))
+       ((LIMITED WITH name_list SEMICOLON )
+        (progn
+        (wisi-statement-action 1 'statement-start 2 'statement-other 4 
'statement-end)
+        (wisi-containing-action 2 3)))
+       ((PRIVATE WITH name_list SEMICOLON )
+        (progn
+        (wisi-statement-action 1 'statement-start 2 'statement-other 4 
'statement-end)
+        (wisi-containing-action 2 3)))
+       ((WITH name_list SEMICOLON )
+        (progn
+        (wisi-statement-action 1 'statement-start 3 'statement-end)
+        (wisi-containing-action 1 2)))))
+     [((default . error) (SEPARATE .  10) (USE .  11) (LIMITED .  3) (PRIVATE 
.  8) (WITH .  12) (PRAGMA .  7) (NOT .  4) (OVERRIDING .  5) (FUNCTION . 
(overriding_indicator_opt . 2)) (PROCEDURE . (overriding_indicator_opt . 2)) 
(PACKAGE .  6) (GENERIC .  2))
+      ((default . error) (IDENTIFIER .  45) (CHARACTER_LITERAL .  47) 
(STRING_LITERAL .  46))
+      ((default . error) (FUNCTION . ( 70 (generic_formal_part . 1))) 
(PROCEDURE . ( 72 (generic_formal_part . 1))) (PACKAGE . ( 71 
(generic_formal_part . 1))) (PRAGMA .  7) (WITH .  74) (TYPE .  73) (IDENTIFIER 
.  69))
+      ((default . error) (WITH .  68) (PRIVATE .  67))
+      ((default . error) (OVERRIDING .  66))
+      ((default . error) (FUNCTION . (overriding_indicator_opt . 1)) 
(PROCEDURE . (overriding_indicator_opt . 1)) (ENTRY . (overriding_indicator_opt 
. 1)))
+      ((default . error) (BODY .  64) (IDENTIFIER .  45) (CHARACTER_LITERAL .  
47) (STRING_LITERAL .  46))
+      ((default . error) (IDENTIFIER .  63))
+      ((default . error) (WITH .  60) (NOT .  4) (OVERRIDING .  5) (FUNCTION . 
(overriding_indicator_opt . 2)) (PROCEDURE . (overriding_indicator_opt . 2)) 
(PACKAGE .  59) (GENERIC .  58))
+      ((default . error) (IDENTIFIER .  45) (CHARACTER_LITERAL .  47) 
(STRING_LITERAL .  46))
+      ((default . error) (LEFT_PAREN .  56))
+      ((default . error) (TYPE .  54) (ALL .  53) (IDENTIFIER .  45) 
(CHARACTER_LITERAL .  47) (STRING_LITERAL .  46))
+      ((default . error) (IDENTIFIER .  45) (CHARACTER_LITERAL .  47) 
(STRING_LITERAL .  46))
+      ((default . error) ($EOI . (compilation_unit_list . 0)) (FUNCTION . 
(compilation_unit_list . 0)) (GENERIC . (compilation_unit_list . 0)) (LIMITED . 
(compilation_unit_list . 0)) (NOT . (compilation_unit_list . 0)) (OVERRIDING . 
(compilation_unit_list . 0)) (PACKAGE . (compilation_unit_list . 0)) (PRAGMA . 
(compilation_unit_list . 0)) (PRIVATE . (compilation_unit_list . 0)) (PROCEDURE 
. (compilation_unit_list . 0)) (SEPARATE . (compilation_unit_list . 0)) (USE . 
(compilation_unit_list . 0)) (WITH . (compilation_unit_list . 0)))
+      ((default . error) ($EOI .  43) (SEPARATE .  10) (USE .  11) (LIMITED .  
3) (PRIVATE .  8) (WITH .  12) (PRAGMA .  7) (NOT .  4) (OVERRIDING .  5) 
(FUNCTION . (overriding_indicator_opt . 2)) (PROCEDURE . 
(overriding_indicator_opt . 2)) (PACKAGE .  6) (GENERIC .  2))
+      ((default . error) (WITH . (compilation_unit . 0)) (USE . 
(compilation_unit . 0)) (SEPARATE . (compilation_unit . 0)) (PROCEDURE . 
(compilation_unit . 0)) (PRIVATE . (compilation_unit . 0)) (PRAGMA . 
(compilation_unit . 0)) (PACKAGE . (compilation_unit . 0)) (OVERRIDING . 
(compilation_unit . 0)) (NOT . (compilation_unit . 0)) (LIMITED . 
(compilation_unit . 0)) (GENERIC . (compilation_unit . 0)) (FUNCTION . 
(compilation_unit . 0)) ($EOI . (compilation_unit . 0)))
+      ((default . error) (WITH . (library_unit_declaration . 2)) (USE . 
(library_unit_declaration . 2)) (SEPARATE . (library_unit_declaration . 2)) 
(PROCEDURE . (library_unit_declaration . 2)) (PRIVATE . 
(library_unit_declaration . 2)) (PRAGMA . (library_unit_declaration . 2)) 
(PACKAGE . (library_unit_declaration . 2)) (OVERRIDING . 
(library_unit_declaration . 2)) (NOT . (library_unit_declaration . 2)) (LIMITED 
. (library_unit_declaration . 2)) (GENERIC . (library_unit_declaration . 2)) 
(FUNCTION . (library_unit_declaration . 2)) ($EOI . (library_unit_declaration . 
2)))
+      ((default . error) (PACKAGE .  40) (FUNCTION .  1) (PROCEDURE .  9))
+      ((default . error) (WITH . (library_unit_declaration . 3)) (USE . 
(library_unit_declaration . 3)) (SEPARATE . (library_unit_declaration . 3)) 
(PROCEDURE . (library_unit_declaration . 3)) (PRIVATE . 
(library_unit_declaration . 3)) (PRAGMA . (library_unit_declaration . 3)) 
(PACKAGE . (library_unit_declaration . 3)) (OVERRIDING . 
(library_unit_declaration . 3)) (NOT . (library_unit_declaration . 3)) (LIMITED 
. (library_unit_declaration . 3)) (GENERIC . (library_unit_declaration . 3)) 
(FUNCTION . (library_unit_declaration . 3)) ($EOI . (library_unit_declaration . 
3)))
+      ((default . error) ($EOI . (generic_declaration . 1)) (LIMITED . 
(generic_declaration . 1)) (SEPARATE . (generic_declaration . 1)) (WITH . 
(generic_declaration . 1)) (PRIVATE . (generic_declaration . 1)) (END . 
(generic_declaration . 1)) (BEGIN . (generic_declaration . 1)) (IDENTIFIER . 
(generic_declaration . 1)) (ENTRY . (generic_declaration . 1)) (FOR . 
(generic_declaration . 1)) (FUNCTION . (generic_declaration . 1)) (GENERIC . 
(generic_declaration . 1)) (NOT . (generic_declaration . 1)) (OVERRIDING . 
(generic_declaration . 1)) (PACKAGE . (generic_declaration . 1)) (PRAGMA . 
(generic_declaration . 1)) (PROCEDURE . (generic_declaration . 1)) (PROTECTED . 
(generic_declaration . 1)) (SUBTYPE . (generic_declaration . 1)) (TASK . 
(generic_declaration . 1)) (TYPE . (generic_declaration . 1)) (USE . 
(generic_declaration . 1)))
+      ((default . error) (WITH . (library_unit_renaming_declaration . 0)) (USE 
. (library_unit_renaming_declaration . 0)) (SEPARATE . 
(library_unit_renaming_declaration . 0)) (PROCEDURE . 
(library_unit_renaming_declaration . 0)) (PRIVATE . 
(library_unit_renaming_declaration . 0)) (PRAGMA . 
(library_unit_renaming_declaration . 0)) (PACKAGE . 
(library_unit_renaming_declaration . 0)) (OVERRIDING . 
(library_unit_renaming_declaration . 0)) (NOT . 
(library_unit_renaming_declaration . 0)) (LIMITED . 
(library_unit_renaming_declaration . 0)) (GENERIC . 
(library_unit_renaming_declaration . 0)) (FUNCTION . 
(library_unit_renaming_declaration . 0)) ($EOI . 
(library_unit_renaming_declaration . 0)))
+      ((default . error) ($EOI . (generic_declaration . 0)) (LIMITED . 
(generic_declaration . 0)) (SEPARATE . (generic_declaration . 0)) (WITH . 
(generic_declaration . 0)) (PRIVATE . (generic_declaration . 0)) (END . 
(generic_declaration . 0)) (BEGIN . (generic_declaration . 0)) (IDENTIFIER . 
(generic_declaration . 0)) (ENTRY . (generic_declaration . 0)) (FOR . 
(generic_declaration . 0)) (FUNCTION . (generic_declaration . 0)) (GENERIC . 
(generic_declaration . 0)) (NOT . (generic_declaration . 0)) (OVERRIDING . 
(generic_declaration . 0)) (PACKAGE . (generic_declaration . 0)) (PRAGMA . 
(generic_declaration . 0)) (PROCEDURE . (generic_declaration . 0)) (PROTECTED . 
(generic_declaration . 0)) (SUBTYPE . (generic_declaration . 0)) (TASK . 
(generic_declaration . 0)) (TYPE . (generic_declaration . 0)) (USE . 
(generic_declaration . 0)))
+      ((default . error) (WITH . (compilation_unit . 1)) (USE . 
(compilation_unit . 1)) (SEPARATE . (compilation_unit . 1)) (PROCEDURE . 
(compilation_unit . 1)) (PRIVATE . (compilation_unit . 1)) (PRAGMA . 
(compilation_unit . 1)) (PACKAGE . (compilation_unit . 1)) (OVERRIDING . 
(compilation_unit . 1)) (NOT . (compilation_unit . 1)) (LIMITED . 
(compilation_unit . 1)) (GENERIC . (compilation_unit . 1)) (FUNCTION . 
(compilation_unit . 1)) ($EOI . (compilation_unit . 1)))
+      ((default . error) ($EOI . (library_item . 1)) (FUNCTION . (library_item 
. 1)) (GENERIC . (library_item . 1)) (LIMITED . (library_item . 1)) (NOT . 
(library_item . 1)) (OVERRIDING . (library_item . 1)) (PACKAGE . (library_item 
. 1)) (PRAGMA . (library_item . 1)) (PRIVATE . (library_item . 1)) (PROCEDURE . 
(library_item . 1)) (SEPARATE . (library_item . 1)) (USE . (library_item . 1)) 
(WITH . (library_item . 1)))
+      ((default . error) ($EOI . (library_item . 4)) (FUNCTION . (library_item 
. 4)) (GENERIC . (library_item . 4)) (LIMITED . (library_item . 4)) (NOT . 
(library_item . 4)) (OVERRIDING . (library_item . 4)) (PACKAGE . (library_item 
. 4)) (PRAGMA . (library_item . 4)) (PRIVATE . (library_item . 4)) (PROCEDURE . 
(library_item . 4)) (SEPARATE . (library_item . 4)) (USE . (library_item . 4)) 
(WITH . (library_item . 4)))
+      ((default . error) (FUNCTION .  37) (PROCEDURE .  38))
+      ((default . error) ($EOI . (library_item . 3)) (FUNCTION . (library_item 
. 3)) (GENERIC . (library_item . 3)) (LIMITED . (library_item . 3)) (NOT . 
(library_item . 3)) (OVERRIDING . (library_item . 3)) (PACKAGE . (library_item 
. 3)) (PRAGMA . (library_item . 3)) (PRIVATE . (library_item . 3)) (PROCEDURE . 
(library_item . 3)) (SEPARATE . (library_item . 3)) (USE . (library_item . 3)) 
(WITH . (library_item . 3)))
+      ((default . error) (WITH . (library_unit_declaration . 1)) (USE . 
(library_unit_declaration . 1)) (SEPARATE . (library_unit_declaration . 1)) 
(PROCEDURE . (library_unit_declaration . 1)) (PRIVATE . 
(library_unit_declaration . 1)) (PRAGMA . (library_unit_declaration . 1)) 
(PACKAGE . (library_unit_declaration . 1)) (OVERRIDING . 
(library_unit_declaration . 1)) (NOT . (library_unit_declaration . 1)) (LIMITED 
. (library_unit_declaration . 1)) (GENERIC . (library_unit_declaration . 1)) 
(FUNCTION . (library_unit_declaration . 1)) ($EOI . (library_unit_declaration . 
1)))
+      ((default . error) (SEMICOLON .  36))
+      ((default . error) ($EOI . (context_item . 0)) (FUNCTION . (context_item 
. 0)) (GENERIC . (context_item . 0)) (LIMITED . (context_item . 0)) (NOT . 
(context_item . 0)) (OVERRIDING . (context_item . 0)) (PACKAGE . (context_item 
. 0)) (PRAGMA . (context_item . 0)) (PRIVATE . (context_item . 0)) (PROCEDURE . 
(context_item . 0)) (SEPARATE . (context_item . 0)) (USE . (context_item . 0)) 
(WITH . (context_item . 0)))
+      ((default . error) (WITH . (subprogram_specification . 0)) (IS . 
(subprogram_specification . 0)) (SEMICOLON . (subprogram_specification . 0)))
+      ((default . error) ($EOI . (library_item . 2)) (FUNCTION . (library_item 
. 2)) (GENERIC . (library_item . 2)) (LIMITED . (library_item . 2)) (NOT . 
(library_item . 2)) (OVERRIDING . (library_item . 2)) (PACKAGE . (library_item 
. 2)) (PRAGMA . (library_item . 2)) (PRIVATE . (library_item . 2)) (PROCEDURE . 
(library_item . 2)) (SEPARATE . (library_item . 2)) (USE . (library_item . 2)) 
(WITH . (library_item . 2)))
+      ((default . error) (WITH . (library_unit_declaration . 0)) (USE . 
(library_unit_declaration . 0)) (SEPARATE . (library_unit_declaration . 0)) 
(PROCEDURE . (library_unit_declaration . 0)) (PRIVATE . 
(library_unit_declaration . 0)) (PRAGMA . (library_unit_declaration . 0)) 
(PACKAGE . (library_unit_declaration . 0)) (OVERRIDING . 
(library_unit_declaration . 0)) (NOT . (library_unit_declaration . 0)) (LIMITED 
. (library_unit_declaration . 0)) (GENERIC . (library_unit_declaration . 0)) 
(FUNCTION . (library_unit_declaration . 0)) ($EOI . (library_unit_declaration . 
0)))
+      ((default . error) (WITH . (compilation_unit . 2)) (USE . 
(compilation_unit . 2)) (SEPARATE . (compilation_unit . 2)) (PROCEDURE . 
(compilation_unit . 2)) (PRIVATE . (compilation_unit . 2)) (PRAGMA . 
(compilation_unit . 2)) (PACKAGE . (compilation_unit . 2)) (OVERRIDING . 
(compilation_unit . 2)) (NOT . (compilation_unit . 2)) (LIMITED . 
(compilation_unit . 2)) (GENERIC . (compilation_unit . 2)) (FUNCTION . 
(compilation_unit . 2)) ($EOI . (compilation_unit . 2)))
+      ((default . error) ($EOI . (context_item . 2)) (FUNCTION . (context_item 
. 2)) (GENERIC . (context_item . 2)) (LIMITED . (context_item . 2)) (NOT . 
(context_item . 2)) (OVERRIDING . (context_item . 2)) (PACKAGE . (context_item 
. 2)) (PRAGMA . (context_item . 2)) (PRIVATE . (context_item . 2)) (PROCEDURE . 
(context_item . 2)) (SEPARATE . (context_item . 2)) (USE . (context_item . 2)) 
(WITH . (context_item . 2)))
+      ((default . error) ($EOI . (context_item . 1)) (FUNCTION . (context_item 
. 1)) (GENERIC . (context_item . 1)) (LIMITED . (context_item . 1)) (NOT . 
(context_item . 1)) (OVERRIDING . (context_item . 1)) (PACKAGE . (context_item 
. 1)) (PRAGMA . (context_item . 1)) (PRIVATE . (context_item . 1)) (PROCEDURE . 
(context_item . 1)) (SEPARATE . (context_item . 1)) (USE . (context_item . 1)) 
(WITH . (context_item . 1)))
+      ((default . error) (USE . (package_declaration . 0)) (TYPE . 
(package_declaration . 0)) (TASK . (package_declaration . 0)) (SUBTYPE . 
(package_declaration . 0)) (PROTECTED . (package_declaration . 0)) (PROCEDURE . 
(package_declaration . 0)) (PRAGMA . (package_declaration . 0)) (PACKAGE . 
(package_declaration . 0)) (OVERRIDING . (package_declaration . 0)) (NOT . 
(package_declaration . 0)) (GENERIC . (package_declaration . 0)) (FUNCTION . 
(package_declaration . 0)) (FOR . (package_declaration . 0)) (ENTRY . 
(package_declaration . 0)) (IDENTIFIER . (package_declaration . 0)) (BEGIN . 
(package_declaration . 0)) (END . (package_declaration . 0)) (PRIVATE . 
(package_declaration . 0)) (WITH . (package_declaration . 0)) (SEPARATE . 
(package_declaration . 0)) (LIMITED . (package_declaration . 0)) ($EOI . 
(package_declaration . 0)))
+      ((default . error) (IDENTIFIER .  45) (CHARACTER_LITERAL .  47) 
(STRING_LITERAL .  46))
+      ((default . error) (IDENTIFIER .  45) (CHARACTER_LITERAL .  47) 
(STRING_LITERAL .  46))
+      ((default . error) (SEMICOLON .  122) (IS . (aspect_specification_opt . 
0)) (WITH .  104))
+      ((default . error) (IDENTIFIER .  45) (CHARACTER_LITERAL .  47) 
(STRING_LITERAL .  46))
+      ((default . error) (SEMICOLON .  120))
+      ((default . error) (SEMICOLON . (aspect_specification_opt . 0)) (WITH .  
104))
+      ((default . error) ($EOI . accept) (XOR . accept) (WITH . accept) (WHILE 
. accept) (WHEN . accept) (USE . accept) (UNTIL . accept) (TYPE . accept) (THEN 
. accept) (TERMINATE . accept) (TASK . accept) (TAGGED . accept) (SYNCHRONIZED 
. accept) (SUBTYPE . accept) (SOME . accept) (SELECT . accept) (SEPARATE . 
accept) (RIGHT_PAREN . accept) (REVERSE . accept) (RETURN . accept) (REQUEUE . 
accept) (RENAMES . accept) (REM . accept) (RECORD . accept) (RANGE . accept) 
(RAISE . accept) (PROTECTED . accept) (PROCEDURE . accept) (PRIVATE . accept) 
(PRAGMA . accept) (PACKAGE . accept) (OVERRIDING . accept) (OUT . accept) 
(OTHERS . accept) (OR . accept) (OF . accept) (NULL . accept) (NOT . accept) 
(NEW . accept) (MOD . accept) (LOOP . accept) (LIMITED . accept) (LEFT_PAREN . 
accept) (IS . accept) (INTERFACE . accept) (IN . accept) (IF . accept) (GOTO . 
accept) (GENERIC . accept) (FUNCTION . accept) (FOR . accept) (EXIT . accept) 
(EXCEPTION . accept) (ENTRY . accept) (END . accept) (ELSIF . accept) (ELSE . 
accept) (DO . accept) (DIGITS . accept) (DELTA . accept) (DELAY . accept) 
(DECLARE . accept) (CONSTANT . accept) (CASE . accept) (BODY . accept) (BEGIN . 
accept) (AT . accept) (ARRAY . accept) (AND . accept) (ALL . accept) (ALIASED . 
accept) (ACCESS . accept) (ABSTRACT . accept) (ABORT . accept) (ACCEPT . 
accept) (ABS . accept) (CHARACTER_LITERAL . accept) (STRING_LITERAL . accept) 
(IDENTIFIER . accept) (TICK . accept) (STAR_STAR . accept) (STAR . accept) 
(SLASH_EQUAL . accept) (SLASH . accept) (SEMICOLON . accept) (PLUS . accept) 
(MINUS . accept) (LESS_LESS . accept) (LESS_EQUAL . accept) (LESS . accept) 
(GREATER_GREATER . accept) (GREATER_EQUAL . accept) (GREATER . accept) 
(EQUAL_GREATER . accept) (EQUAL . accept) (DOT_DOT . accept) (DOT . accept) 
(COMMA . accept) (COLON_EQUAL . accept) (COLON . accept) (BOX . accept) (BAR . 
accept) (AMPERSAND . accept))
+      ((default . error) (WITH . (compilation_unit_list . 1)) (USE . 
(compilation_unit_list . 1)) (SEPARATE . (compilation_unit_list . 1)) 
(PROCEDURE . (compilation_unit_list . 1)) (PRIVATE . (compilation_unit_list . 
1)) (PRAGMA . (compilation_unit_list . 1)) (PACKAGE . (compilation_unit_list . 
1)) (OVERRIDING . (compilation_unit_list . 1)) (NOT . (compilation_unit_list . 
1)) (LIMITED . (compilation_unit_list . 1)) (GENERIC . (compilation_unit_list . 
1)) (FUNCTION . (compilation_unit_list . 1)) ($EOI . (compilation_unit_list . 
1)))
+      ((default . error) (USE . (name . 0)) (DO . (name . 0)) (RENAMES . (name 
. 0)) (ELSIF . (name . 0)) (ELSE . (name . 0)) (LESS_LESS . (name . 0)) 
(IDENTIFIER . (name . 0)) (STRING_LITERAL . (name . 0)) (CHARACTER_LITERAL . 
(name . 0)) (ACCEPT . (name . 0)) (ABORT . (name . 0)) (BEGIN . (name . 0)) 
(CASE . (name . 0)) (DECLARE . (name . 0)) (DELAY . (name . 0)) (EXIT . (name . 
0)) (FOR . (name . 0)) (GOTO . (name . 0)) (IF . (name . 0)) (LOOP . (name . 
0)) (NULL . (name . 0)) (PRAGMA . (name . 0)) (RAISE . (name . 0)) (REQUEUE . 
(name . 0)) (RETURN . (name . 0)) (SELECT . (name . 0)) (WHILE . (name . 0)) 
(OF . (name . 0)) (DIGITS . (name . 0)) (COMMA . (name . 0)) (THEN . (name . 
0)) (COLON_EQUAL . (name . 0)) (WITH . (name . 0)) (BAR . (name . 0)) 
(EQUAL_GREATER . (name . 0)) (IS . (name . 0)) (SLASH_EQUAL . (name . 0)) 
(LESS_EQUAL . (name . 0)) (LESS . (name . 0)) (GREATER_EQUAL . (name . 0)) 
(GREATER . (name . 0)) (EQUAL . (name . 0)) (NOT . (name . 0)) (IN . (name . 
0)) (AND . (name . 0)) (OR . (name . 0)) (XOR . (name . 0)) (SEMICOLON . (name 
. 0)) (RIGHT_PAREN . (name . 0)) (LEFT_PAREN . (name . 0)) (RANGE . (name . 0)) 
(TICK . (name . 0)) (DOT . (name . 0)) (PLUS . (name . 0)) (MINUS . (name . 0)) 
(AMPERSAND . (name . 0)) (DOT_DOT . (name . 0)) (SLASH . (name . 0)) (STAR . 
(name . 0)) (MOD . (name . 0)) (REM . (name . 0)) (STAR_STAR . (name . 0)))
+      ((default . error) (USE . (name . 7)) (DO . (name . 7)) (RENAMES . (name 
. 7)) (ELSIF . (name . 7)) (ELSE . (name . 7)) (LESS_LESS . (name . 7)) 
(IDENTIFIER . (name . 7)) (STRING_LITERAL . (name . 7)) (CHARACTER_LITERAL . 
(name . 7)) (ACCEPT . (name . 7)) (ABORT . (name . 7)) (BEGIN . (name . 7)) 
(CASE . (name . 7)) (DECLARE . (name . 7)) (DELAY . (name . 7)) (EXIT . (name . 
7)) (FOR . (name . 7)) (GOTO . (name . 7)) (IF . (name . 7)) (LOOP . (name . 
7)) (NULL . (name . 7)) (PRAGMA . (name . 7)) (RAISE . (name . 7)) (REQUEUE . 
(name . 7)) (RETURN . (name . 7)) (SELECT . (name . 7)) (WHILE . (name . 7)) 
(OF . (name . 7)) (DIGITS . (name . 7)) (COMMA . (name . 7)) (THEN . (name . 
7)) (COLON_EQUAL . (name . 7)) (WITH . (name . 7)) (BAR . (name . 7)) 
(EQUAL_GREATER . (name . 7)) (IS . (name . 7)) (SLASH_EQUAL . (name . 7)) 
(LESS_EQUAL . (name . 7)) (LESS . (name . 7)) (GREATER_EQUAL . (name . 7)) 
(GREATER . (name . 7)) (EQUAL . (name . 7)) (NOT . (name . 7)) (IN . (name . 
7)) (AND . (name . 7)) (OR . (name . 7)) (XOR . (name . 7)) (SEMICOLON . (name 
. 7)) (RIGHT_PAREN . (name . 7)) (LEFT_PAREN . (name . 7)) (RANGE . (name . 7)) 
(TICK . (name . 7)) (DOT . (name . 7)) (PLUS . (name . 7)) (MINUS . (name . 7)) 
(AMPERSAND . (name . 7)) (DOT_DOT . (name . 7)) (SLASH . (name . 7)) (STAR . 
(name . 7)) (MOD . (name . 7)) (REM . (name . 7)) (STAR_STAR . (name . 7)))
+      ((default . error) (DO . (name . 1)) (USE . (name . 1)) (COMMA . (name . 
1)) (RENAMES . (name . 1)) (ELSIF . (name . 1)) (ELSE . (name . 1)) (LESS_LESS 
. (name . 1)) (IDENTIFIER . (name . 1)) (STRING_LITERAL . (name . 1)) 
(CHARACTER_LITERAL . (name . 1)) (ACCEPT . (name . 1)) (ABORT . (name . 1)) 
(BEGIN . (name . 1)) (CASE . (name . 1)) (DECLARE . (name . 1)) (DELAY . (name 
. 1)) (EXIT . (name . 1)) (FOR . (name . 1)) (GOTO . (name . 1)) (IF . (name . 
1)) (LOOP . (name . 1)) (NULL . (name . 1)) (PRAGMA . (name . 1)) (RAISE . 
(name . 1)) (REQUEUE . (name . 1)) (RETURN . (name . 1)) (SELECT . (name . 1)) 
(WHILE . (name . 1)) (OF . (name . 1)) (DIGITS . (name . 1)) (THEN . (name . 
1)) (COLON_EQUAL . (name . 1)) (WITH . (name . 1)) (BAR . (name . 1)) 
(EQUAL_GREATER . (name . 1)) (IS . (name . 1)) (SLASH_EQUAL . (name . 1)) 
(LESS_EQUAL . (name . 1)) (LESS . (name . 1)) (GREATER_EQUAL . (name . 1)) 
(GREATER . (name . 1)) (EQUAL . (name . 1)) (NOT . (name . 1)) (IN . (name . 
1)) (AND . (name . 1)) (OR . (name . 1)) (XOR . (name . 1)) (SEMICOLON . (name 
. 1)) (RIGHT_PAREN . (name . 1)) (LEFT_PAREN . (name . 1)) (RANGE . (name . 1)) 
(TICK . (name . 1)) (DOT . (name . 1)) (PLUS . (name . 1)) (MINUS . (name . 1)) 
(AMPERSAND . (name . 1)) (DOT_DOT . (name . 1)) (SLASH . (name . 1)) (STAR . 
(name . 1)) (MOD . (name . 1)) (REM . (name . 1)) (STAR_STAR . (name . 1)))
+      ((default . error) (USE . (name . 4)) (DO . (name . 4)) (RENAMES . (name 
. 4)) (ELSIF . (name . 4)) (ELSE . (name . 4)) (LESS_LESS . (name . 4)) 
(IDENTIFIER . (name . 4)) (STRING_LITERAL . (name . 4)) (CHARACTER_LITERAL . 
(name . 4)) (ACCEPT . (name . 4)) (ABORT . (name . 4)) (BEGIN . (name . 4)) 
(CASE . (name . 4)) (DECLARE . (name . 4)) (DELAY . (name . 4)) (EXIT . (name . 
4)) (FOR . (name . 4)) (GOTO . (name . 4)) (IF . (name . 4)) (LOOP . (name . 
4)) (NULL . (name . 4)) (PRAGMA . (name . 4)) (RAISE . (name . 4)) (REQUEUE . 
(name . 4)) (RETURN . (name . 4)) (SELECT . (name . 4)) (WHILE . (name . 4)) 
(OF . (name . 4)) (DIGITS . (name . 4)) (COMMA . (name . 4)) (THEN . (name . 
4)) (COLON_EQUAL . (name . 4)) (WITH . (name . 4)) (BAR . (name . 4)) 
(EQUAL_GREATER . (name . 4)) (IS . (name . 4)) (SLASH_EQUAL . (name . 4)) 
(LESS_EQUAL . (name . 4)) (LESS . (name . 4)) (GREATER_EQUAL . (name . 4)) 
(GREATER . (name . 4)) (EQUAL . (name . 4)) (NOT . (name . 4)) (IN . (name . 
4)) (AND . (name . 4)) (OR . (name . 4)) (XOR . (name . 4)) (SEMICOLON . (name 
. 4)) (RIGHT_PAREN . (name . 4)) (LEFT_PAREN . (name . 4)) (RANGE . (name . 4)) 
(TICK . (name . 4)) (DOT . (name . 4)) (PLUS . (name . 4)) (MINUS . (name . 4)) 
(AMPERSAND . (name . 4)) (DOT_DOT . (name . 4)) (SLASH . (name . 4)) (STAR . 
(name . 4)) (MOD . (name . 4)) (REM . (name . 4)) (STAR_STAR . (name . 4)))
+      ((default . error) (COMMA .  114) (SEMICOLON .  118))
+      ((default . error) (DOT .  84) (SEMICOLON . (name_list . 0)) (COMMA . 
(name_list . 0)) (TICK .  85) (LEFT_PAREN .  103))
+      ((default . error) (DO . (name . 6)) (USE . (name . 6)) (RENAMES . (name 
. 6)) (ELSIF . (name . 6)) (ELSE . (name . 6)) (LESS_LESS . (name . 6)) 
(IDENTIFIER . (name . 6)) (STRING_LITERAL . (name . 6)) (CHARACTER_LITERAL . 
(name . 6)) (ACCEPT . (name . 6)) (ABORT . (name . 6)) (BEGIN . (name . 6)) 
(CASE . (name . 6)) (DECLARE . (name . 6)) (DELAY . (name . 6)) (EXIT . (name . 
6)) (FOR . (name . 6)) (GOTO . (name . 6)) (IF . (name . 6)) (LOOP . (name . 
6)) (NULL . (name . 6)) (PRAGMA . (name . 6)) (RAISE . (name . 6)) (REQUEUE . 
(name . 6)) (RETURN . (name . 6)) (SELECT . (name . 6)) (WHILE . (name . 6)) 
(OF . (name . 6)) (DIGITS . (name . 6)) (COMMA . (name . 6)) (THEN . (name . 
6)) (COLON_EQUAL . (name . 6)) (WITH . (name . 6)) (BAR . (name . 6)) 
(EQUAL_GREATER . (name . 6)) (IS . (name . 6)) (SLASH_EQUAL . (name . 6)) 
(LESS_EQUAL . (name . 6)) (LESS . (name . 6)) (GREATER_EQUAL . (name . 6)) 
(GREATER . (name . 6)) (EQUAL . (name . 6)) (NOT . (name . 6)) (IN . (name . 
6)) (AND . (name . 6)) (OR . (name . 6)) (XOR . (name . 6)) (SEMICOLON . (name 
. 6)) (RIGHT_PAREN . (name . 6)) (LEFT_PAREN . (name . 6)) (RANGE . (name . 6)) 
(TICK . (name . 6)) (DOT . (name . 6)) (PLUS . (name . 6)) (MINUS . (name . 6)) 
(AMPERSAND . (name . 6)) (DOT_DOT . (name . 6)) (SLASH . (name . 6)) (STAR . 
(name . 6)) (MOD . (name . 6)) (REM . (name . 6)) (STAR_STAR . (name . 6)))
+      ((default . error) (DO . (name . 3)) (USE . (name . 3)) (RENAMES . (name 
. 3)) (ELSIF . (name . 3)) (ELSE . (name . 3)) (LESS_LESS . (name . 3)) 
(IDENTIFIER . (name . 3)) (STRING_LITERAL . (name . 3)) (CHARACTER_LITERAL . 
(name . 3)) (ACCEPT . (name . 3)) (ABORT . (name . 3)) (BEGIN . (name . 3)) 
(CASE . (name . 3)) (DECLARE . (name . 3)) (DELAY . (name . 3)) (EXIT . (name . 
3)) (FOR . (name . 3)) (GOTO . (name . 3)) (IF . (name . 3)) (LOOP . (name . 
3)) (NULL . (name . 3)) (PRAGMA . (name . 3)) (RAISE . (name . 3)) (REQUEUE . 
(name . 3)) (RETURN . (name . 3)) (SELECT . (name . 3)) (WHILE . (name . 3)) 
(OF . (name . 3)) (DIGITS . (name . 3)) (COMMA . (name . 3)) (THEN . (name . 
3)) (COLON_EQUAL . (name . 3)) (WITH . (name . 3)) (BAR . (name . 3)) 
(EQUAL_GREATER . (name . 3)) (IS . (name . 3)) (SLASH_EQUAL . (name . 3)) 
(LESS_EQUAL . (name . 3)) (LESS . (name . 3)) (GREATER_EQUAL . (name . 3)) 
(GREATER . (name . 3)) (EQUAL . (name . 3)) (NOT . (name . 3)) (IN . (name . 
3)) (AND . (name . 3)) (OR . (name . 3)) (XOR . (name . 3)) (SEMICOLON . (name 
. 3)) (RIGHT_PAREN . (name . 3)) (LEFT_PAREN . (name . 3)) (RANGE . (name . 3)) 
(TICK . (name . 3)) (DOT . (name . 3)) (PLUS . (name . 3)) (MINUS . (name . 3)) 
(AMPERSAND . (name . 3)) (DOT_DOT . (name . 3)) (SLASH . (name . 3)) (STAR . 
(name . 3)) (MOD . (name . 3)) (REM . (name . 3)) (STAR_STAR . (name . 3)))
+      ((default . error) (TYPE .  117))
+      ((default . error) (IDENTIFIER .  45) (CHARACTER_LITERAL .  47) 
(STRING_LITERAL .  46))
+      ((default . error) (COMMA .  114) (SEMICOLON .  115))
+      ((default . error) (IDENTIFIER .  45) (CHARACTER_LITERAL .  47) 
(STRING_LITERAL .  46))
+      ((default . error) (DOT .  84) (TICK .  85) (IS . (parameter_profile_opt 
. 0)) (WITH . (parameter_profile_opt . 0)) (SEMICOLON . (parameter_profile_opt 
. 0)) (LEFT_PAREN .  86))
+      ((default . error) (FUNCTION . (generic_formal_part . 1)) (PROCEDURE . 
(generic_formal_part . 1)) (PACKAGE . (generic_formal_part . 1)) (PRAGMA .  7) 
(WITH .  74) (TYPE .  73) (IDENTIFIER .  69))
+      ((default . error) (IDENTIFIER .  45) (CHARACTER_LITERAL .  47) 
(STRING_LITERAL .  46))
+      ((default . error) (IDENTIFIER .  45) (CHARACTER_LITERAL .  47) 
(STRING_LITERAL .  46))
+      ((default . error) (WITH . (library_item . 0)) (USE . (library_item . 
0)) (SEPARATE . (library_item . 0)) (PROCEDURE . (library_item . 0)) (PRIVATE . 
(library_item . 0)) (PRAGMA . (library_item . 0)) (PACKAGE . (library_item . 
0)) (OVERRIDING . (library_item . 0)) (NOT . (library_item . 0)) (LIMITED . 
(library_item . 0)) (GENERIC . (library_item . 0)) (FUNCTION . (library_item . 
0)) ($EOI . (library_item . 0)))
+      ((default . error) (FUNCTION .  37) (PROCEDURE .  38))
+      ((default . error) (LEFT_PAREN .  108) (SEMICOLON .  107))
+      ((default . error) (IDENTIFIER .  45) (CHARACTER_LITERAL .  47) 
(STRING_LITERAL .  46))
+      ((default . error) (DOT .  84) (TICK .  85) (IS . ( 102 
(aspect_specification_opt . 0))) (WITH .  104) (LEFT_PAREN .  103))
+      ((default . error) (ENTRY . (overriding_indicator_opt . 0)) (PROCEDURE . 
(overriding_indicator_opt . 0)) (FUNCTION . (overriding_indicator_opt . 0)))
+      ((default . error) (WITH .  101))
+      ((default . error) (IDENTIFIER .  45) (CHARACTER_LITERAL .  47) 
(STRING_LITERAL .  46))
+      ((default . error) (COLON . (identifier_list . 0)) (COMMA . 
(identifier_list . 0)))
+      ((default . error) (IDENTIFIER .  45) (CHARACTER_LITERAL .  47) 
(STRING_LITERAL .  46))
+      ((default . error) (IDENTIFIER .  45) (CHARACTER_LITERAL .  47) 
(STRING_LITERAL .  46))
+      ((default . error) (IDENTIFIER .  45) (CHARACTER_LITERAL .  47) 
(STRING_LITERAL .  46))
+      ((default . error) (IDENTIFIER .  96))
+      ((default . error) (PACKAGE .  94) (FUNCTION .  1) (PROCEDURE .  9))
+      ((default . error) (PACKAGE . (generic_formal_parameter_declaration . 
0)) (PROCEDURE . (generic_formal_parameter_declaration . 0)) (FUNCTION . 
(generic_formal_parameter_declaration . 0)) (WITH . 
(generic_formal_parameter_declaration . 0)) (TYPE . 
(generic_formal_parameter_declaration . 0)) (PRAGMA . 
(generic_formal_parameter_declaration . 0)) (IDENTIFIER . 
(generic_formal_parameter_declaration . 0)))
+      ((default . error) (PACKAGE . (generic_formal_parameter_declaration . 
2)) (PROCEDURE . (generic_formal_parameter_declaration . 2)) (FUNCTION . 
(generic_formal_parameter_declaration . 2)) (WITH . 
(generic_formal_parameter_declaration . 2)) (TYPE . 
(generic_formal_parameter_declaration . 2)) (PRAGMA . 
(generic_formal_parameter_declaration . 2)) (IDENTIFIER . 
(generic_formal_parameter_declaration . 2)))
+      ((default . error) (PACKAGE . (generic_formal_parameter_declaration . 
1)) (PROCEDURE . (generic_formal_parameter_declaration . 1)) (FUNCTION . 
(generic_formal_parameter_declaration . 1)) (WITH . 
(generic_formal_parameter_declaration . 1)) (TYPE . 
(generic_formal_parameter_declaration . 1)) (PRAGMA . 
(generic_formal_parameter_declaration . 1)) (IDENTIFIER . 
(generic_formal_parameter_declaration . 1)))
+      ((default . error) (PACKAGE . (generic_formal_parameter_declaration . 
3)) (PROCEDURE . (generic_formal_parameter_declaration . 3)) (FUNCTION . 
(generic_formal_parameter_declaration . 3)) (WITH . 
(generic_formal_parameter_declaration . 3)) (TYPE . 
(generic_formal_parameter_declaration . 3)) (PRAGMA . 
(generic_formal_parameter_declaration . 3)) (IDENTIFIER . 
(generic_formal_parameter_declaration . 3)))
+      ((default . error) (PACKAGE . (generic_formal_part . 0)) (PROCEDURE . 
(generic_formal_part . 0)) (FUNCTION . (generic_formal_part . 0)) (PRAGMA .  7) 
(WITH .  74) (TYPE .  73) (IDENTIFIER .  69))
+      ((default . error) (PACKAGE . (generic_formal_parameter_declarations . 
0)) (PROCEDURE . (generic_formal_parameter_declarations . 0)) (FUNCTION . 
(generic_formal_parameter_declarations . 0)) (IDENTIFIER . 
(generic_formal_parameter_declarations . 0)) (PRAGMA . 
(generic_formal_parameter_declarations . 0)) (TYPE . 
(generic_formal_parameter_declarations . 0)) (WITH . 
(generic_formal_parameter_declarations . 0)))
+      ((default . error) (COMMA .  92) (COLON .  91))
+      ((default . error) (PACKAGE . (generic_formal_parameter_declaration . 
4)) (PROCEDURE . (generic_formal_parameter_declaration . 4)) (FUNCTION . 
(generic_formal_parameter_declaration . 4)) (WITH . 
(generic_formal_parameter_declaration . 4)) (TYPE . 
(generic_formal_parameter_declaration . 4)) (PRAGMA . 
(generic_formal_parameter_declaration . 4)) (IDENTIFIER . 
(generic_formal_parameter_declaration . 4)))
+      ((default . error) (DOT .  84) (TICK .  85) (RETURN .  87) (LEFT_PAREN . 
 86))
+      ((default . error) (IDENTIFIER .  214) (CHARACTER_LITERAL .  216) 
(STRING_LITERAL .  215) (ALL .  217))
+      ((default . error) (LEFT_PAREN .  209) (ACCESS .  206) (DELTA .  207) 
(DIGITS .  208) (MOD .  210) (IDENTIFIER .  45) (CHARACTER_LITERAL .  47) 
(STRING_LITERAL .  46))
+      ((default . error) (STRING_LITERAL .  46) (CHARACTER_LITERAL .  163) 
(RIGHT_PAREN . ((association_opt . 0) (expression_opt . 0))) (COMMA . 
((association_opt . 0) (expression_opt . 0))) (EQUAL_GREATER . 
(discrete_choice_list . 0)) (BAR . (discrete_choice_list . 0)) (PLUS .  136) 
(MINUS .  135) (IDENTIFIER .  202) (OTHERS .  165) (ABS .  138) (NOT .  164) 
(NULL .  142) (NEW .  140) (LEFT_PAREN .  139))
+      ((default . error) (IDENTIFIER .  45) (CHARACTER_LITERAL .  47) 
(STRING_LITERAL .  46) (ACCESS . (null_exclusion_opt . 0)) (NOT .  198))
+      ((default . error) (DO . (name . 5)) (OF . (name . 5)) (WHILE . (name . 
5)) (SELECT . (name . 5)) (REQUEUE . (name . 5)) (RAISE . (name . 5)) (PRAGMA . 
(name . 5)) (NULL . (name . 5)) (LOOP . (name . 5)) (IF . (name . 5)) (GOTO . 
(name . 5)) (FOR . (name . 5)) (EXIT . (name . 5)) (DELAY . (name . 5)) 
(DECLARE . (name . 5)) (CASE . (name . 5)) (BEGIN . (name . 5)) (ABORT . (name 
. 5)) (ACCEPT . (name . 5)) (CHARACTER_LITERAL . (name . 5)) (STRING_LITERAL . 
(name . 5)) (IDENTIFIER . (name . 5)) (LESS_LESS . (name . 5)) (COLON_EQUAL . 
(name . 5)) (USE . (name . 5)) (PLUS . (name . 5)) (MINUS . (name . 5)) 
(AMPERSAND . (name . 5)) (SLASH . (name . 5)) (STAR . (name . 5)) (MOD . (name 
. 5)) (REM . (name . 5)) (STAR_STAR . (name . 5)) (XOR . (name . 5)) (OR . 
(name . 5)) (AND . (name . 5)) (IN . (name . 5)) (NOT . (name . 5)) (EQUAL . 
(name . 5)) (GREATER . (name . 5)) (GREATER_EQUAL . (name . 5)) (LESS . (name . 
5)) (LESS_EQUAL . (name . 5)) (SLASH_EQUAL . (name . 5)) (DOT_DOT . (name . 5)) 
(THEN . (name . 5)) (RANGE . (name . 5)) (DIGITS . (name . 5)) (EQUAL_GREATER . 
(name . 5)) (ELSE . (name . 5)) (ELSIF . (name . 5)) (BAR . (name . 5)) 
(RIGHT_PAREN . (name . 5)) (RENAMES . (name . 5)) (RETURN . (name . 5)) (IS . 
(name . 5)) (WITH . (name . 5)) (TICK . (name . 5)) (DOT . (name . 5)) 
(LEFT_PAREN . (name . 5)) (SEMICOLON . (name . 5)) (COMMA . (name . 5)))
+      ((default . error) (RETURN .  197))
+      ((default . error) (RENAMES . (subprogram_specification . 1)) (WITH . 
(subprogram_specification . 1)) (IS . (subprogram_specification . 1)) 
(SEMICOLON . (subprogram_specification . 1)))
+      ((default . error) (ACCESS . (mode_opt . 0)) (NOT . (mode_opt . 0)) 
(IDENTIFIER . (mode_opt . 0)) (STRING_LITERAL . (mode_opt . 0)) 
(CHARACTER_LITERAL . (mode_opt . 0)) (IN .  194) (OUT .  195))
+      ((default . error) (IDENTIFIER .  193))
+      ((default . error) (WITH . (generic_formal_parameter_declarations . 1)) 
(TYPE . (generic_formal_parameter_declarations . 1)) (PRAGMA . 
(generic_formal_parameter_declarations . 1)) (IDENTIFIER . 
(generic_formal_parameter_declarations . 1)) (FUNCTION . 
(generic_formal_parameter_declarations . 1)) (PROCEDURE . 
(generic_formal_parameter_declarations . 1)) (PACKAGE . 
(generic_formal_parameter_declarations . 1)))
+      ((default . error) (IDENTIFIER .  45) (CHARACTER_LITERAL .  47) 
(STRING_LITERAL .  46))
+      ((default . error) (IS .  190) (SEMICOLON . (aspect_specification_opt . 
0)) (WITH .  104))
+      ((default . error) (WITH . (discriminant_part_opt . 0)) (SEMICOLON . 
(discriminant_part_opt . 0)) (IS . (discriminant_part_opt . 0)) (LEFT_PAREN .  
188))
+      ((default . error) (DOT .  84) (TICK .  85) (RENAMES .  187) (LEFT_PAREN 
.  103))
+      ((default . error) (DOT .  84) (TICK .  85) (RENAMES .  186) (LEFT_PAREN 
.  103))
+      ((default . error) (DOT .  84) (TICK .  85) (RENAMES .  185) (LEFT_PAREN 
.  103))
+      ((default . error) (COMMA .  114) (SEMICOLON .  184))
+      ((default . error) (IDENTIFIER .  45) (CHARACTER_LITERAL .  47) 
(STRING_LITERAL .  46))
+      ((default . error) (NEW .  182))
+      ((default . error) (IDENTIFIER .  45) (STRING_LITERAL .  46) 
(CHARACTER_LITERAL .  163) (RIGHT_PAREN . ((association_opt . 0) 
(expression_opt . 0))) (COMMA . ((association_opt . 0) (expression_opt . 0))) 
(EQUAL_GREATER . (discrete_choice_list . 0)) (BAR . (discrete_choice_list . 0)) 
(PLUS .  136) (MINUS .  135) (OTHERS .  165) (ABS .  138) (NOT .  164) (NULL .  
142) (NEW .  140) (LEFT_PAREN .  139))
+      ((default . error) (IDENTIFIER .  162))
+      ((default . error) (IS .  161))
+      ((default . error) (DOT .  84) (TICK .  85) (IS . 
(aspect_specification_opt . 0)) (WITH .  104) (LEFT_PAREN .  103))
+      ((default . error) (OR . (pragma . 1)) (THEN . (pragma . 1)) (WHEN . 
(pragma . 1)) (EXCEPTION . (pragma . 1)) (LESS_LESS . (pragma . 1)) 
(STRING_LITERAL . (pragma . 1)) (CHARACTER_LITERAL . (pragma . 1)) (ACCEPT . 
(pragma . 1)) (ABORT . (pragma . 1)) (CASE . (pragma . 1)) (DECLARE . (pragma . 
1)) (DELAY . (pragma . 1)) (EXIT . (pragma . 1)) (GOTO . (pragma . 1)) (IF . 
(pragma . 1)) (LOOP . (pragma . 1)) (NULL . (pragma . 1)) (RAISE . (pragma . 
1)) (REQUEUE . (pragma . 1)) (RETURN . (pragma . 1)) (SELECT . (pragma . 1)) 
(WHILE . (pragma . 1)) (ELSE . (pragma . 1)) (ELSIF . (pragma . 1)) (SEPARATE . 
(pragma . 1)) (LIMITED . (pragma . 1)) ($EOI . (pragma . 1)) (WITH . (pragma . 
1)) (PRIVATE . (pragma . 1)) (END . (pragma . 1)) (BEGIN . (pragma . 1)) 
(IDENTIFIER . (pragma . 1)) (ENTRY . (pragma . 1)) (FOR . (pragma . 1)) 
(FUNCTION . (pragma . 1)) (GENERIC . (pragma . 1)) (NOT . (pragma . 1)) 
(OVERRIDING . (pragma . 1)) (PACKAGE . (pragma . 1)) (PRAGMA . (pragma . 1)) 
(PROCEDURE . (pragma . 1)) (PROTECTED . (pragma . 1)) (SUBTYPE . (pragma . 1)) 
(TASK . (pragma . 1)) (TYPE . (pragma . 1)) (USE . (pragma . 1)))
+      ((default . error) (PLUS .  136) (MINUS .  135) (ABS .  138) (NOT .  
141) (NULL .  142) (NEW .  140) (IDENTIFIER .  137) (CHARACTER_LITERAL .  47) 
(STRING_LITERAL .  46) (LEFT_PAREN .  139))
+      ((default . error) (SEMICOLON .  122))
+      ((default . error) (COMMA .  114) (SEMICOLON .  134))
+      ((default . error) (RIGHT_PAREN . (parameter_profile_opt . 1)) 
(COLON_EQUAL . (parameter_profile_opt . 1)) (RENAMES . (parameter_profile_opt . 
1)) (IS . (parameter_profile_opt . 1)) (DO . (parameter_profile_opt . 1)) (WITH 
. (parameter_profile_opt . 1)) (SEMICOLON . (parameter_profile_opt . 1)) (WHEN 
. (parameter_profile_opt . 1)))
+      ((default . error) (RENAMES . (procedure_specification . 0)) (IS . 
(procedure_specification . 0)) (WITH . (procedure_specification . 0)) 
(SEMICOLON . (procedure_specification . 0)))
+      ((default . error) (DOT .  84) (TICK .  85) (RIGHT_PAREN .  133) 
(LEFT_PAREN .  103))
+      ((default . error) (IDENTIFIER .  45) (CHARACTER_LITERAL .  47) 
(STRING_LITERAL .  46))
+      ((default . error) (WITH . (use_clause . 0)) (SEPARATE . (use_clause . 
0)) (LIMITED . (use_clause . 0)) ($EOI . (use_clause . 0)) (PRIVATE . 
(use_clause . 0)) (END . (use_clause . 0)) (BEGIN . (use_clause . 0)) 
(IDENTIFIER . (use_clause . 0)) (ENTRY . (use_clause . 0)) (FOR . (use_clause . 
0)) (FUNCTION . (use_clause . 0)) (GENERIC . (use_clause . 0)) (NOT . 
(use_clause . 0)) (OVERRIDING . (use_clause . 0)) (PACKAGE . (use_clause . 0)) 
(PRAGMA . (use_clause . 0)) (PROCEDURE . (use_clause . 0)) (PROTECTED . 
(use_clause . 0)) (SUBTYPE . (use_clause . 0)) (TASK . (use_clause . 0)) (TYPE 
. (use_clause . 0)) (USE . (use_clause . 0)))
+      ((default . error) (COMMA .  114) (SEMICOLON .  131))
+      ((default . error) (IDENTIFIER .  45) (CHARACTER_LITERAL .  47) 
(STRING_LITERAL .  46))
+      ((default . error) (WITH . (with_clause . 3)) (USE . (with_clause . 3)) 
(SEPARATE . (with_clause . 3)) (PROCEDURE . (with_clause . 3)) (PRIVATE . 
(with_clause . 3)) (PRAGMA . (with_clause . 3)) (PACKAGE . (with_clause . 3)) 
(OVERRIDING . (with_clause . 3)) (NOT . (with_clause . 3)) (LIMITED . 
(with_clause . 3)) (GENERIC . (with_clause . 3)) (FUNCTION . (with_clause . 3)) 
($EOI . (with_clause . 3)))
+      ((default . error) (SEMICOLON .  129))
+      ((default . error) (WITH . (generic_package_declaration . 0)) (SEPARATE 
. (generic_package_declaration . 0)) (LIMITED . (generic_package_declaration . 
0)) ($EOI . (generic_package_declaration . 0)) (END . 
(generic_package_declaration . 0)) (PRIVATE . (generic_package_declaration . 
0)) (USE . (generic_package_declaration . 0)) (TYPE . 
(generic_package_declaration . 0)) (TASK . (generic_package_declaration . 0)) 
(SUBTYPE . (generic_package_declaration . 0)) (PROTECTED . 
(generic_package_declaration . 0)) (PROCEDURE . (generic_package_declaration . 
0)) (PRAGMA . (generic_package_declaration . 0)) (PACKAGE . 
(generic_package_declaration . 0)) (OVERRIDING . (generic_package_declaration . 
0)) (NOT . (generic_package_declaration . 0)) (GENERIC . 
(generic_package_declaration . 0)) (FUNCTION . (generic_package_declaration . 
0)) (FOR . (generic_package_declaration . 0)) (ENTRY . 
(generic_package_declaration . 0)) (IDENTIFIER . (generic_package_declaration . 
0)) (BEGIN . (generic_package_declaration . 0)))
+      ((default . error) (DOT .  84) (TICK .  85) (IS . 
(aspect_specification_opt . 0)) (WITH .  104) (LEFT_PAREN .  103))
+      ((default . error) (END . (subprogram_declaration . 0)) (BEGIN . 
(subprogram_declaration . 0)) (IDENTIFIER . (subprogram_declaration . 0)) 
(ENTRY . (subprogram_declaration . 0)) (FOR . (subprogram_declaration . 0)) 
(PROTECTED . (subprogram_declaration . 0)) (SUBTYPE . (subprogram_declaration . 
0)) (TASK . (subprogram_declaration . 0)) (TYPE . (subprogram_declaration . 0)) 
($EOI . (subprogram_declaration . 0)) (FUNCTION . (subprogram_declaration . 0)) 
(GENERIC . (subprogram_declaration . 0)) (LIMITED . (subprogram_declaration . 
0)) (NOT . (subprogram_declaration . 0)) (OVERRIDING . (subprogram_declaration 
. 0)) (PACKAGE . (subprogram_declaration . 0)) (PRAGMA . 
(subprogram_declaration . 0)) (PRIVATE . (subprogram_declaration . 0)) 
(PROCEDURE . (subprogram_declaration . 0)) (SEPARATE . (subprogram_declaration 
. 0)) (USE . (subprogram_declaration . 0)) (WITH . (subprogram_declaration . 
0)))
+      ((default . error) (IS .  128))
+      ((default . error) (DOT .  84) (TICK .  85) (WITH . 
(parameter_profile_opt . 0)) (IS . ( 127 (parameter_profile_opt . 0))) 
(SEMICOLON . (parameter_profile_opt . 0)) (RENAMES . (parameter_profile_opt . 
0)) (LEFT_PAREN .  86))
+      ((default . error) (DOT .  84) (TICK .  85) (IS .  126) (RETURN .  87) 
(LEFT_PAREN .  86))
+      ((default . error) (NEW .  372))
+      ((default . error) (NEW .  371))
+      ((default . error) (BEGIN . (declarative_part_opt . 0)) (USE .  11) 
(SUBTYPE .  282) (PRAGMA .  7) (NOT .  4) (OVERRIDING .  5) (FUNCTION . 
(overriding_indicator_opt . 2)) (PROCEDURE . (overriding_indicator_opt . 2)) 
(ENTRY . (overriding_indicator_opt . 2)) (FOR .  279) (IDENTIFIER .  278) (TYPE 
.  284) (GENERIC .  2) (PROTECTED .  281) (TASK .  283) (PACKAGE .  280))
+      ((default . error) (BEGIN . (generic_subprogram_declaration . 0)) 
(IDENTIFIER . (generic_subprogram_declaration . 0)) (ENTRY . 
(generic_subprogram_declaration . 0)) (FOR . (generic_subprogram_declaration . 
0)) (FUNCTION . (generic_subprogram_declaration . 0)) (GENERIC . 
(generic_subprogram_declaration . 0)) (NOT . (generic_subprogram_declaration . 
0)) (OVERRIDING . (generic_subprogram_declaration . 0)) (PACKAGE . 
(generic_subprogram_declaration . 0)) (PRAGMA . (generic_subprogram_declaration 
. 0)) (PROCEDURE . (generic_subprogram_declaration . 0)) (PROTECTED . 
(generic_subprogram_declaration . 0)) (SUBTYPE . 
(generic_subprogram_declaration . 0)) (TASK . (generic_subprogram_declaration . 
0)) (TYPE . (generic_subprogram_declaration . 0)) (USE . 
(generic_subprogram_declaration . 0)) (PRIVATE . 
(generic_subprogram_declaration . 0)) (END . (generic_subprogram_declaration . 
0)) ($EOI . (generic_subprogram_declaration . 0)) (LIMITED . 
(generic_subprogram_declaration . 0)) (SEPARATE . 
(generic_subprogram_declaration . 0)) (WITH . (generic_subprogram_declaration . 
0)))
+      ((default . error) (COMMA .  114) (SEMICOLON .  369))
+      ((default . error) (USE . (use_clause . 2)) (TYPE . (use_clause . 2)) 
(TASK . (use_clause . 2)) (SUBTYPE . (use_clause . 2)) (PROTECTED . (use_clause 
. 2)) (PROCEDURE . (use_clause . 2)) (PRAGMA . (use_clause . 2)) (PACKAGE . 
(use_clause . 2)) (OVERRIDING . (use_clause . 2)) (NOT . (use_clause . 2)) 
(GENERIC . (use_clause . 2)) (FUNCTION . (use_clause . 2)) (FOR . (use_clause . 
2)) (ENTRY . (use_clause . 2)) (IDENTIFIER . (use_clause . 2)) (BEGIN . 
(use_clause . 2)) (END . (use_clause . 2)) (PRIVATE . (use_clause . 2)) ($EOI . 
(use_clause . 2)) (LIMITED . (use_clause . 2)) (SEPARATE . (use_clause . 2)) 
(WITH . (use_clause . 2)))
+      ((default . error) (DOT .  84) (TICK .  85) (SEMICOLON . (name_list . 
1)) (COMMA . (name_list . 1)) (LEFT_PAREN .  103))
+      ((default . error) (PROTECTED .  365) (TASK .  366) (PACKAGE .  364) 
(NOT .  4) (OVERRIDING .  5) (FUNCTION . (overriding_indicator_opt . 2)) 
(PROCEDURE . (overriding_indicator_opt . 2)))
+      ((default . error) ($EOI . (with_clause . 2)) (FUNCTION . (with_clause . 
2)) (GENERIC . (with_clause . 2)) (LIMITED . (with_clause . 2)) (NOT . 
(with_clause . 2)) (OVERRIDING . (with_clause . 2)) (PACKAGE . (with_clause . 
2)) (PRAGMA . (with_clause . 2)) (PRIVATE . (with_clause . 2)) (PROCEDURE . 
(with_clause . 2)) (SEPARATE . (with_clause . 2)) (USE . (with_clause . 2)) 
(WITH . (with_clause . 2)))
+      ((default . error) (IDENTIFIER . (unary_adding_operator . 1)) 
(STRING_LITERAL . (unary_adding_operator . 1)) (CHARACTER_LITERAL . 
(unary_adding_operator . 1)) (ABS . (unary_adding_operator . 1)) (LEFT_PAREN . 
(unary_adding_operator . 1)) (NEW . (unary_adding_operator . 1)) (NOT . 
(unary_adding_operator . 1)) (NULL . (unary_adding_operator . 1)))
+      ((default . error) (IDENTIFIER . (unary_adding_operator . 0)) 
(STRING_LITERAL . (unary_adding_operator . 0)) (CHARACTER_LITERAL . 
(unary_adding_operator . 0)) (ABS . (unary_adding_operator . 0)) (LEFT_PAREN . 
(unary_adding_operator . 0)) (NEW . (unary_adding_operator . 0)) (NOT . 
(unary_adding_operator . 0)) (NULL . (unary_adding_operator . 0)))
+      ((default . error) (EQUAL_GREATER .  362) (RIGHT_PAREN . (name . 0)) 
(COMMA . (name . 0)) (STAR_STAR . (name . 0)) (REM . (name . 0)) (MOD . (name . 
0)) (STAR . (name . 0)) (SLASH . (name . 0)) (SLASH_EQUAL . (name . 0)) 
(LESS_EQUAL . (name . 0)) (LESS . (name . 0)) (GREATER_EQUAL . (name . 0)) 
(GREATER . (name . 0)) (EQUAL . (name . 0)) (NOT . (name . 0)) (IN . (name . 
0)) (AMPERSAND . (name . 0)) (MINUS . (name . 0)) (PLUS . (name . 0)) 
(LEFT_PAREN . (name . 0)) (AND . (name . 0)) (OR . (name . 0)) (XOR . (name . 
0)) (DOT . (name . 0)) (TICK . ( 363 (name . 0))))
+      ((default . error) (NULL .  142) (NEW .  140) (IDENTIFIER .  45) 
(CHARACTER_LITERAL .  47) (STRING_LITERAL .  46) (LEFT_PAREN .  139))
+      ((default . error) (IF .  357) (CASE .  355) (FOR .  356) (RIGHT_PAREN . 
((association_opt . 0) (expression_opt . 0))) (COMMA . ((association_opt . 0) 
(expression_opt . 0))) (EQUAL_GREATER . (discrete_choice_list . 0)) (BAR . 
(discrete_choice_list . 0)) (PLUS .  136) (MINUS .  135) (OTHERS .  165) (ABS . 
 138) (NOT .  164) (IDENTIFIER .  45) (CHARACTER_LITERAL .  163) 
(STRING_LITERAL .  46) (NULL .  218) (NEW .  140) (LEFT_PAREN .  139))
+      ((default . error) (IDENTIFIER .  45) (CHARACTER_LITERAL .  47) 
(STRING_LITERAL .  46))
+      ((default . error) (NULL .  142) (NEW .  140) (IDENTIFIER .  45) 
(CHARACTER_LITERAL .  47) (STRING_LITERAL .  46) (LEFT_PAREN .  139))
+      ((default . error) (OF . (primary . 0)) (COLON_EQUAL . (primary . 0)) 
(DO . (primary . 0)) (LOOP . (primary . 0)) (ELSIF . (primary . 0)) (ELSE . 
(primary . 0)) (DIGITS . (primary . 0)) (RIGHT_PAREN . (primary . 0)) (COMMA . 
(primary . 0)) (RANGE . (primary . 0)) (THEN . (primary . 0)) (WITH . (primary 
. 0)) (BAR . (primary . 0)) (EQUAL_GREATER . (primary . 0)) (IS . (primary . 
0)) (IN . (primary . 0)) (NOT . (primary . 0)) (EQUAL . (primary . 0)) (GREATER 
. (primary . 0)) (GREATER_EQUAL . (primary . 0)) (LESS . (primary . 0)) 
(LESS_EQUAL . (primary . 0)) (SLASH_EQUAL . (primary . 0)) (AND . (primary . 
0)) (OR . (primary . 0)) (XOR . (primary . 0)) (SEMICOLON . (primary . 0)) 
(PLUS . (primary . 0)) (MINUS . (primary . 0)) (AMPERSAND . (primary . 0)) 
(DOT_DOT . (primary . 0)) (SLASH . (primary . 0)) (STAR . (primary . 0)) (MOD . 
(primary . 0)) (REM . (primary . 0)) (STAR_STAR . (primary . 0)))
+      ((default . error) (OF . (primary . 1)) (COLON_EQUAL . (primary . 1)) 
(DO . (primary . 1)) (LOOP . (primary . 1)) (ELSIF . (primary . 1)) (ELSE . 
(primary . 1)) (DIGITS . (primary . 1)) (RIGHT_PAREN . (primary . 1)) (COMMA . 
(primary . 1)) (RANGE . (primary . 1)) (THEN . (primary . 1)) (WITH . (primary 
. 1)) (BAR . (primary . 1)) (EQUAL_GREATER . (primary . 1)) (IS . (primary . 
1)) (IN . (primary . 1)) (NOT . (primary . 1)) (EQUAL . (primary . 1)) (GREATER 
. (primary . 1)) (GREATER_EQUAL . (primary . 1)) (LESS . (primary . 1)) 
(LESS_EQUAL . (primary . 1)) (SLASH_EQUAL . (primary . 1)) (AND . (primary . 
1)) (OR . (primary . 1)) (XOR . (primary . 1)) (SEMICOLON . (primary . 1)) 
(PLUS . (primary . 1)) (MINUS . (primary . 1)) (AMPERSAND . (primary . 1)) 
(DOT_DOT . (primary . 1)) (SLASH . (primary . 1)) (STAR . (primary . 1)) (MOD . 
(primary . 1)) (REM . (primary . 1)) (STAR_STAR . (primary . 1)))
+      ((default . error) (COMMA . (pragma_argument_association . 1)) 
(RIGHT_PAREN . (pragma_argument_association . 1)))
+      ((default . error) (OF . (term . 0)) (COLON_EQUAL . (term . 0)) (DO . 
(term . 0)) (LOOP . (term . 0)) (ELSIF . (term . 0)) (ELSE . (term . 0)) 
(DIGITS . (term . 0)) (RIGHT_PAREN . (term . 0)) (COMMA . (term . 0)) (RANGE . 
(term . 0)) (THEN . (term . 0)) (WITH . (term . 0)) (BAR . (term . 0)) 
(EQUAL_GREATER . (term . 0)) (IS . (term . 0)) (IN . (term . 0)) (NOT . (term . 
0)) (EQUAL . (term . 0)) (GREATER . (term . 0)) (GREATER_EQUAL . (term . 0)) 
(LESS . (term . 0)) (LESS_EQUAL . (term . 0)) (SLASH_EQUAL . (term . 0)) (AND . 
(term . 0)) (OR . (term . 0)) (XOR . (term . 0)) (SEMICOLON . (term . 0)) (PLUS 
. (term . 0)) (MINUS . (term . 0)) (AMPERSAND . (term . 0)) (DOT_DOT . (term . 
0)) (SLASH . (term . 0)) (STAR . (term . 0)) (MOD . (term . 0)) (REM . (term . 
0)))
+      ((default . error) (DOT .  84) (OF . (primary . 2)) (COLON_EQUAL . 
(primary . 2)) (DO . (primary . 2)) (LOOP . (primary . 2)) (BAR . (primary . 
2)) (COMMA . (primary . 2)) (RIGHT_PAREN . (primary . 2)) (ELSIF . (primary . 
2)) (ELSE . (primary . 2)) (EQUAL_GREATER . (primary . 2)) (DIGITS . (primary . 
2)) (RANGE . (primary . 2)) (THEN . (primary . 2)) (DOT_DOT . (primary . 2)) 
(WITH . (primary . 2)) (IS . (primary . 2)) (IN . (primary . 2)) (NOT . 
(primary . 2)) (EQUAL . (primary . 2)) (GREATER . (primary . 2)) (GREATER_EQUAL 
. (primary . 2)) (LESS . (primary . 2)) (LESS_EQUAL . (primary . 2)) 
(SLASH_EQUAL . (primary . 2)) (AND . (primary . 2)) (OR . (primary . 2)) (XOR . 
(primary . 2)) (PLUS . (primary . 2)) (MINUS . (primary . 2)) (AMPERSAND . 
(primary . 2)) (SEMICOLON . (primary . 2)) (SLASH . (primary . 2)) (STAR . 
(primary . 2)) (MOD . (primary . 2)) (REM . (primary . 2)) (STAR_STAR . 
(primary . 2)) (TICK .  85) (LEFT_PAREN .  103))
+      ((default . error) (RIGHT_PAREN . (pragma_argument_association_list . 
0)) (COMMA . (pragma_argument_association_list . 0)))
+      ((default . error) (COMMA .  352) (RIGHT_PAREN .  353))
+      ((default . error) (OF . (factor . 1)) (COLON_EQUAL . (factor . 1)) (DO 
. (factor . 1)) (LOOP . (factor . 1)) (ELSIF . (factor . 1)) (ELSE . (factor . 
1)) (DIGITS . (factor . 1)) (COMMA . (factor . 1)) (RIGHT_PAREN . (factor . 1)) 
(RANGE . (factor . 1)) (THEN . (factor . 1)) (WITH . (factor . 1)) (BAR . 
(factor . 1)) (EQUAL_GREATER . (factor . 1)) (IS . (factor . 1)) (SLASH_EQUAL . 
(factor . 1)) (LESS_EQUAL . (factor . 1)) (LESS . (factor . 1)) (GREATER_EQUAL 
. (factor . 1)) (GREATER . (factor . 1)) (EQUAL . (factor . 1)) (NOT . (factor 
. 1)) (IN . (factor . 1)) (AND . (factor . 1)) (OR . (factor . 1)) (XOR . 
(factor . 1)) (SEMICOLON . (factor . 1)) (REM . (factor . 1)) (MOD . (factor . 
1)) (STAR . (factor . 1)) (SLASH . (factor . 1)) (DOT_DOT . (factor . 1)) 
(AMPERSAND . (factor . 1)) (MINUS . (factor . 1)) (PLUS . (factor . 1)) 
(STAR_STAR .  351))
+      ((default . error) (AND .  350) (DO . (expression . 1)) (LOOP . 
(expression . 1)) (ELSIF . (expression . 1)) (ELSE . (expression . 1)) 
(EQUAL_GREATER . (expression . 1)) (DIGITS . (expression . 1)) (COMMA . 
(expression . 1)) (RIGHT_PAREN . (expression . 1)) (RANGE . (expression . 1)) 
(THEN . (expression . 1)) (WITH . (expression . 1)) (SEMICOLON . (expression . 
1)) (IS . (expression . 1)))
+      ((default . error) (AND .  349) (DO . (expression . 2)) (LOOP . 
(expression . 2)) (ELSIF . (expression . 2)) (ELSE . (expression . 2)) 
(EQUAL_GREATER . (expression . 2)) (DIGITS . (expression . 2)) (COMMA . 
(expression . 2)) (RIGHT_PAREN . (expression . 2)) (RANGE . (expression . 2)) 
(THEN . (expression . 2)) (WITH . (expression . 2)) (SEMICOLON . (expression . 
2)) (IS . (expression . 2)))
+      ((default . error) (OR .  348) (DO . (expression . 3)) (LOOP . 
(expression . 3)) (ELSIF . (expression . 3)) (ELSE . (expression . 3)) 
(EQUAL_GREATER . (expression . 3)) (DIGITS . (expression . 3)) (COMMA . 
(expression . 3)) (RIGHT_PAREN . (expression . 3)) (RANGE . (expression . 3)) 
(THEN . (expression . 3)) (WITH . (expression . 3)) (SEMICOLON . (expression . 
3)) (IS . (expression . 3)))
+      ((default . error) (OR .  347) (DO . (expression . 4)) (LOOP . 
(expression . 4)) (ELSIF . (expression . 4)) (ELSE . (expression . 4)) 
(EQUAL_GREATER . (expression . 4)) (DIGITS . (expression . 4)) (COMMA . 
(expression . 4)) (RIGHT_PAREN . (expression . 4)) (RANGE . (expression . 4)) 
(THEN . (expression . 4)) (WITH . (expression . 4)) (SEMICOLON . (expression . 
4)) (IS . (expression . 4)))
+      ((default . error) (XOR .  346) (DO . (expression . 5)) (LOOP . 
(expression . 5)) (ELSIF . (expression . 5)) (ELSE . (expression . 5)) 
(EQUAL_GREATER . (expression . 5)) (DIGITS . (expression . 5)) (COMMA . 
(expression . 5)) (RIGHT_PAREN . (expression . 5)) (RANGE . (expression . 5)) 
(THEN . (expression . 5)) (WITH . (expression . 5)) (SEMICOLON . (expression . 
5)) (IS . (expression . 5)))
+      ((default . error) (XOR .  345) (OR .  344) (AND .  343) (DO . 
(expression . 0)) (LOOP . (expression . 0)) (ELSIF . (expression . 0)) (ELSE . 
(expression . 0)) (EQUAL_GREATER . (expression . 0)) (DIGITS . (expression . 
0)) (COMMA . (expression . 0)) (RIGHT_PAREN . (expression . 0)) (RANGE . 
(expression . 0)) (THEN . (expression . 0)) (WITH . (expression . 0)) 
(SEMICOLON . (expression . 0)) (IS . (expression . 0)))
+      ((default . error) (IN .  257) (NOT .  258) (DO . (relation . 0)) (LOOP 
. (relation . 0)) (COMMA . (relation . 0)) (RIGHT_PAREN . (relation . 0)) 
(ELSIF . (relation . 0)) (ELSE . (relation . 0)) (EQUAL_GREATER . (relation . 
0)) (DIGITS . (relation . 0)) (RANGE . (relation . 0)) (THEN . (relation . 0)) 
(SEMICOLON . (relation . 0)) (WITH . (relation . 0)) (IS . (relation . 0)) (AND 
. (relation . 0)) (OR . (relation . 0)) (XOR . (relation . 0)) (EQUAL .  251) 
(SLASH_EQUAL .  256) (LESS .  254) (LESS_EQUAL .  255) (GREATER .  252) 
(GREATER_EQUAL .  253))
+      ((default . error) (OF . (term_list . 0)) (COLON_EQUAL . (term_list . 
0)) (DO . (term_list . 0)) (LOOP . (term_list . 0)) (ELSIF . (term_list . 0)) 
(ELSE . (term_list . 0)) (DIGITS . (term_list . 0)) (COMMA . (term_list . 0)) 
(RIGHT_PAREN . (term_list . 0)) (RANGE . (term_list . 0)) (THEN . (term_list . 
0)) (WITH . (term_list . 0)) (BAR . (term_list . 0)) (EQUAL_GREATER . 
(term_list . 0)) (IS . (term_list . 0)) (SLASH_EQUAL . (term_list . 0)) 
(LESS_EQUAL . (term_list . 0)) (LESS . (term_list . 0)) (GREATER_EQUAL . 
(term_list . 0)) (GREATER . (term_list . 0)) (EQUAL . (term_list . 0)) (NOT . 
(term_list . 0)) (IN . (term_list . 0)) (AND . (term_list . 0)) (OR . 
(term_list . 0)) (XOR . (term_list . 0)) (SEMICOLON . (term_list . 0)) (DOT_DOT 
. (term_list . 0)) (AMPERSAND . (term_list . 0)) (MINUS . (term_list . 0)) 
(PLUS . (term_list . 0)) (STAR .  338) (SLASH .  337) (MOD .  339) (REM .  340))
+      ((default . error) (OF . (simple_expression . 1)) (COLON_EQUAL . 
(simple_expression . 1)) (DO . (simple_expression . 1)) (LOOP . 
(simple_expression . 1)) (ELSIF . (simple_expression . 1)) (ELSE . 
(simple_expression . 1)) (DIGITS . (simple_expression . 1)) (RIGHT_PAREN . 
(simple_expression . 1)) (COMMA . (simple_expression . 1)) (RANGE . 
(simple_expression . 1)) (THEN . (simple_expression . 1)) (WITH . 
(simple_expression . 1)) (BAR . (simple_expression . 1)) (EQUAL_GREATER . 
(simple_expression . 1)) (IS . (simple_expression . 1)) (IN . 
(simple_expression . 1)) (NOT . (simple_expression . 1)) (EQUAL . 
(simple_expression . 1)) (GREATER . (simple_expression . 1)) (GREATER_EQUAL . 
(simple_expression . 1)) (LESS . (simple_expression . 1)) (LESS_EQUAL . 
(simple_expression . 1)) (SLASH_EQUAL . (simple_expression . 1)) (AND . 
(simple_expression . 1)) (OR . (simple_expression . 1)) (XOR . 
(simple_expression . 1)) (SEMICOLON . (simple_expression . 1)) (DOT_DOT . 
(simple_expression . 1)) (PLUS .  335) (MINUS .  334) (AMPERSAND .  333))
+      ((default . error) (ABS .  138) (NOT .  141) (NULL .  142) (NEW .  140) 
(IDENTIFIER .  45) (CHARACTER_LITERAL .  47) (STRING_LITERAL .  46) (LEFT_PAREN 
.  139))
+      ((default . error) (IS .  331))
+      ((default . error) (END . (declarative_part_opt . 0)) (PRIVATE . 
(declarative_part_opt . 0)) (USE .  11) (SUBTYPE .  282) (PRAGMA .  7) (NOT .  
4) (OVERRIDING .  5) (FUNCTION . (overriding_indicator_opt . 2)) (PROCEDURE . 
(overriding_indicator_opt . 2)) (ENTRY . (overriding_indicator_opt . 2)) (FOR . 
 279) (IDENTIFIER .  278) (TYPE .  284) (GENERIC .  2) (PROTECTED .  281) (TASK 
.  283) (PACKAGE .  280))
+      ((default . error) (SEMICOLON . (aspect_specification_opt . 1)) (IS . 
(aspect_specification_opt . 1)) (EQUAL_GREATER .  277))
+      ((default . error) (WITH . (name . 1)) (RANGE . (name . 1)) (TICK . 
(name . 1)) (LEFT_PAREN . (name . 1)) (DOT . (name . 1)) (PLUS . (name . 1)) 
(MINUS . (name . 1)) (AMPERSAND . (name . 1)) (DOT_DOT . (name . 1)) (IN . 
(name . 1)) (NOT . (name . 1)) (EQUAL . (name . 1)) (GREATER . (name . 1)) 
(GREATER_EQUAL . (name . 1)) (LESS . (name . 1)) (LESS_EQUAL . (name . 1)) 
(SLASH_EQUAL . (name . 1)) (RIGHT_PAREN . (name . 1)) (COMMA . (name . 1)) 
(SLASH . (name . 1)) (STAR . (name . 1)) (MOD . (name . 1)) (REM . (name . 1)) 
(STAR_STAR . (name . 1)) (BAR . (name . 1)) (EQUAL_GREATER . ( 276 (name . 1))) 
(AND . (name . 1)) (OR . (name . 1)) (XOR . (name . 1)))
+      ((default . error) (NULL .  274) (NEW .  140) (IDENTIFIER .  45) 
(CHARACTER_LITERAL .  47) (STRING_LITERAL .  46) (LEFT_PAREN .  139))
+      ((default . error) (BAR . (discrete_choice . 3)) (EQUAL_GREATER . 
(discrete_choice . 3)))
+      ((default . error) (RIGHT_PAREN . (association_list . 0)) (COMMA . 
(association_list . 0)))
+      ((default . error) (COMMA .  272) (RIGHT_PAREN .  273))
+      ((default . error) (BAR . (discrete_choice . 0)) (EQUAL_GREATER . 
(discrete_choice . 0)))
+      ((default . error) (AND .  271) (EQUAL_GREATER . (choice_expression . 
1)) (BAR . (choice_expression . 1)))
+      ((default . error) (OR .  270) (EQUAL_GREATER . (choice_expression . 2)) 
(BAR . (choice_expression . 2)))
+      ((default . error) (XOR .  269) (EQUAL_GREATER . (choice_expression . 
3)) (BAR . (choice_expression . 3)))
+      ((default . error) (AND .  268) (EQUAL_GREATER . (choice_expression . 
4)) (BAR . (choice_expression . 4)))
+      ((default . error) (OR .  267) (EQUAL_GREATER . (choice_expression . 5)) 
(BAR . (choice_expression . 5)))
+      ((default . error) (XOR .  266) (OR .  265) (AND .  264) (EQUAL_GREATER 
. (choice_expression . 0)) (BAR . (choice_expression . 0)))
+      ((default . error) (EQUAL_GREATER . (discrete_choice_list . 1)) (BAR . 
(discrete_choice_list . 1)))
+      ((default . error) (BAR .  262) (EQUAL_GREATER .  263))
+      ((default . error) (LOOP . (expression_opt . 1)) (RIGHT_PAREN . 
(expression_opt . 1)) (COMMA . (expression_opt . 1)) (SEMICOLON . 
(expression_opt . 1)) (THEN . (expression_opt . 1)) (IS . (expression_opt . 1)))
+      ((default . error) (COMMA . (association_opt . 5)) (RIGHT_PAREN . 
(association_opt . 5)))
+      ((default . error) (DOT .  84) (DO . (primary . 2)) (LOOP . (primary . 
2)) (ELSIF . (primary . 2)) (ELSE . (primary . 2)) (DIGITS . (primary . 2)) 
(RANGE . (primary . 2)) (THEN . (primary . 2)) (SEMICOLON . (primary . 2)) (IS 
. (primary . 2)) (WITH . (primary . 2)) (IN . (primary . 2)) (NOT . (primary . 
2)) (RIGHT_PAREN . (primary . 2)) (COMMA . (primary . 2)) (PLUS . (primary . 
2)) (MINUS . (primary . 2)) (AMPERSAND . (primary . 2)) (DOT_DOT . (primary . 
2)) (SLASH . (primary . 2)) (STAR . (primary . 2)) (MOD . (primary . 2)) (REM . 
(primary . 2)) (STAR_STAR . (primary . 2)) (BAR . (primary . 2)) (EQUAL_GREATER 
. (primary . 2)) (EQUAL . (primary . 2)) (GREATER . (primary . 2)) 
(GREATER_EQUAL . (primary . 2)) (LESS . (primary . 2)) (LESS_EQUAL . (primary . 
2)) (SLASH_EQUAL . (primary . 2)) (AND . (primary . 2)) (OR . (primary . 2)) 
(XOR . (primary . 2)) (TICK .  261) (LEFT_PAREN .  103))
+      ((default . error) (BAR . (discrete_choice . 2)) (EQUAL_GREATER . 
(discrete_choice . 2)) (RIGHT_PAREN .  260))
+      ((default . error) (IN .  257) (NOT .  258) (WITH . (relation . 0)) 
(RIGHT_PAREN . (relation . 0)) (COMMA . (relation . 0)) (BAR . (choice_relation 
. 1)) (EQUAL_GREATER . (choice_relation . 1)) (AND . ((relation . 0) 
(choice_relation . 1))) (OR . ((relation . 0) (choice_relation . 1))) (XOR . 
((relation . 0) (choice_relation . 1))) (DOT_DOT .  250) (EQUAL .  251) 
(SLASH_EQUAL .  256) (LESS .  254) (LESS_EQUAL .  255) (GREATER .  252) 
(GREATER_EQUAL .  253))
+      ((default . error) (IDENTIFIER .  45) (CHARACTER_LITERAL .  47) 
(STRING_LITERAL .  46))
+      ((default . error) (COMMA .  114) (SEMICOLON .  248))
+      ((default . error) ($EOI . (with_clause . 1)) (FUNCTION . (with_clause . 
1)) (GENERIC . (with_clause . 1)) (LIMITED . (with_clause . 1)) (NOT . 
(with_clause . 1)) (OVERRIDING . (with_clause . 1)) (PACKAGE . (with_clause . 
1)) (PRAGMA . (with_clause . 1)) (PRIVATE . (with_clause . 1)) (PROCEDURE . 
(with_clause . 1)) (SEPARATE . (with_clause . 1)) (USE . (with_clause . 1)) 
(WITH . (with_clause . 1)))
+      ((default . error) (IDENTIFIER .  45) (CHARACTER_LITERAL .  47) 
(STRING_LITERAL .  46))
+      ((default . error) (IDENTIFIER .  45) (CHARACTER_LITERAL .  47) 
(STRING_LITERAL .  46))
+      ((default . error) (IDENTIFIER .  45) (CHARACTER_LITERAL .  47) 
(STRING_LITERAL .  46))
+      ((default . error) (BOX .  241) (SEMICOLON . 
(discriminant_specification_opt . 0)) (RIGHT_PAREN . 
(discriminant_specification_opt . 0)) (IDENTIFIER .  69))
+      ((default . error) (IS .  239) (SEMICOLON . (aspect_specification_opt . 
0)) (WITH .  104))
+      ((default . error) (ABSTRACT .  235) (BOX .  234) (NULL .  236) 
(IDENTIFIER .  45) (CHARACTER_LITERAL .  47) (STRING_LITERAL .  46))
+      ((default . error) (SEMICOLON .  233))
+      ((default . error) (DOT .  84) (TICK .  85) (IS .  232) (LEFT_PAREN .  
103))
+      ((default . error) (COLON . (identifier_list . 1)) (COMMA . 
(identifier_list . 1)))
+      ((default . error) (OUT .  231) (ACCESS . (mode_opt . 1)) (NOT . 
(mode_opt . 1)) (IDENTIFIER . (mode_opt . 1)) (STRING_LITERAL . (mode_opt . 1)) 
(CHARACTER_LITERAL . (mode_opt . 1)))
+      ((default . error) (ACCESS . (mode_opt . 3)) (NOT . (mode_opt . 3)) 
(IDENTIFIER . (mode_opt . 3)) (STRING_LITERAL . (mode_opt . 3)) 
(CHARACTER_LITERAL . (mode_opt . 3)))
+      ((default . error) (IDENTIFIER . (null_exclusion_opt . 0)) 
(STRING_LITERAL . (null_exclusion_opt . 0)) (CHARACTER_LITERAL . 
(null_exclusion_opt . 0)) (ACCESS . (null_exclusion_opt . 0)) (NOT .  198))
+      ((default . error) (IDENTIFIER . (null_exclusion_opt . 0)) 
(STRING_LITERAL . (null_exclusion_opt . 0)) (CHARACTER_LITERAL . 
(null_exclusion_opt . 0)) (ACCESS . (null_exclusion_opt . 0)) (NOT .  198))
+      ((default . error) (NULL .  226))
+      ((default . error) (RIGHT_PAREN . (parameter_and_result_profile . 3)) 
(DO . (parameter_and_result_profile . 3)) (RENAMES . 
(parameter_and_result_profile . 3)) (COLON_EQUAL . 
(parameter_and_result_profile . 3)) (SEMICOLON . (parameter_and_result_profile 
. 3)) (IS . (parameter_and_result_profile . 3)) (WITH . 
(parameter_and_result_profile . 3)))
+      ((default . error) (DOT .  84) (TICK .  85) (RIGHT_PAREN . 
(parameter_and_result_profile . 1)) (DO . (parameter_and_result_profile . 1)) 
(RENAMES . (parameter_and_result_profile . 1)) (COLON_EQUAL . 
(parameter_and_result_profile . 1)) (SEMICOLON . (parameter_and_result_profile 
. 1)) (IS . (parameter_and_result_profile . 1)) (WITH . 
(parameter_and_result_profile . 1)) (LEFT_PAREN .  103))
+      ((default . error) (ACCESS .  225))
+      ((default . error) (IN . (name . 0)) (NOT . (name . 0)) (EQUAL . (name . 
0)) (GREATER . (name . 0)) (GREATER_EQUAL . (name . 0)) (LESS . (name . 0)) 
(LESS_EQUAL . (name . 0)) (SLASH_EQUAL . (name . 0)) (BAR . (name . 0)) 
(EQUAL_GREATER . (name . 0)) (AND . (name . 0)) (OR . (name . 0)) (XOR . (name 
. 0)) (RIGHT_PAREN . (name . 0)) (LEFT_PAREN . (name . 0)) (RANGE . (name . 0)) 
(TICK . (name . 0)) (DOT . (name . 0)) (PLUS . (name . 0)) (MINUS . (name . 0)) 
(AMPERSAND . (name . 0)) (DOT_DOT . (name . 0)) (SLASH . (name . 0)) (STAR . 
(name . 0)) (MOD . (name . 0)) (REM . (name . 0)) (STAR_STAR . (name . 0)) 
(COLON . (identifier_list . 0)) (COMMA . ((name . 0) (identifier_list . 0))))
+      ((default . error) (COLON .  224) (COMMA .  92))
+      ((default . error) (RIGHT_PAREN . (parameter_specification_list . 0)) 
(SEMICOLON . (parameter_specification_list . 0)))
+      ((default . error) (SEMICOLON .  222) (RIGHT_PAREN .  223))
+      ((default . error) (DO . (attribute_designator . 1)) (RENAMES . 
(attribute_designator . 1)) (ELSIF . (attribute_designator . 1)) (ELSE . 
(attribute_designator . 1)) (DIGITS . (attribute_designator . 1)) (RANGE . 
(attribute_designator . 1)) (THEN . (attribute_designator . 1)) (USE . 
(attribute_designator . 1)) (COLON_EQUAL . (attribute_designator . 1)) (WHILE . 
(attribute_designator . 1)) (SELECT . (attribute_designator . 1)) (REQUEUE . 
(attribute_designator . 1)) (RAISE . (attribute_designator . 1)) (PRAGMA . 
(attribute_designator . 1)) (NULL . (attribute_designator . 1)) (LOOP . 
(attribute_designator . 1)) (IF . (attribute_designator . 1)) (GOTO . 
(attribute_designator . 1)) (FOR . (attribute_designator . 1)) (EXIT . 
(attribute_designator . 1)) (DELAY . (attribute_designator . 1)) (DECLARE . 
(attribute_designator . 1)) (CASE . (attribute_designator . 1)) (BEGIN . 
(attribute_designator . 1)) (ABORT . (attribute_designator . 1)) (ACCEPT . 
(attribute_designator . 1)) (CHARACTER_LITERAL . (attribute_designator . 1)) 
(STRING_LITERAL . (attribute_designator . 1)) (IDENTIFIER . 
(attribute_designator . 1)) (LESS_LESS . (attribute_designator . 1)) (OF . 
(attribute_designator . 1)) (IN . (attribute_designator . 1)) (NOT . 
(attribute_designator . 1)) (RIGHT_PAREN . (attribute_designator . 1)) (PLUS . 
(attribute_designator . 1)) (MINUS . (attribute_designator . 1)) (AMPERSAND . 
(attribute_designator . 1)) (DOT_DOT . (attribute_designator . 1)) (SLASH . 
(attribute_designator . 1)) (STAR . (attribute_designator . 1)) (MOD . 
(attribute_designator . 1)) (REM . (attribute_designator . 1)) (STAR_STAR . 
(attribute_designator . 1)) (BAR . (attribute_designator . 1)) (EQUAL_GREATER . 
(attribute_designator . 1)) (EQUAL . (attribute_designator . 1)) (GREATER . 
(attribute_designator . 1)) (GREATER_EQUAL . (attribute_designator . 1)) (LESS 
. (attribute_designator . 1)) (LESS_EQUAL . (attribute_designator . 1)) 
(SLASH_EQUAL . (attribute_designator . 1)) (AND . (attribute_designator . 1)) 
(OR . (attribute_designator . 1)) (XOR . (attribute_designator . 1)) 
(LEFT_PAREN . (attribute_designator . 1)) (SEMICOLON . (attribute_designator . 
1)) (COMMA . (attribute_designator . 1)) (DOT . (attribute_designator . 1)) 
(TICK . (attribute_designator . 1)) (WITH . (attribute_designator . 1)) (IS . 
(attribute_designator . 1)) (RETURN . (attribute_designator . 1)))
+      ((default . error) (DO . (attribute_designator . 2)) (RENAMES . 
(attribute_designator . 2)) (ELSIF . (attribute_designator . 2)) (ELSE . 
(attribute_designator . 2)) (DIGITS . (attribute_designator . 2)) (RANGE . 
(attribute_designator . 2)) (THEN . (attribute_designator . 2)) (USE . 
(attribute_designator . 2)) (COLON_EQUAL . (attribute_designator . 2)) (WHILE . 
(attribute_designator . 2)) (SELECT . (attribute_designator . 2)) (REQUEUE . 
(attribute_designator . 2)) (RAISE . (attribute_designator . 2)) (PRAGMA . 
(attribute_designator . 2)) (NULL . (attribute_designator . 2)) (LOOP . 
(attribute_designator . 2)) (IF . (attribute_designator . 2)) (GOTO . 
(attribute_designator . 2)) (FOR . (attribute_designator . 2)) (EXIT . 
(attribute_designator . 2)) (DELAY . (attribute_designator . 2)) (DECLARE . 
(attribute_designator . 2)) (CASE . (attribute_designator . 2)) (BEGIN . 
(attribute_designator . 2)) (ABORT . (attribute_designator . 2)) (ACCEPT . 
(attribute_designator . 2)) (CHARACTER_LITERAL . (attribute_designator . 2)) 
(STRING_LITERAL . (attribute_designator . 2)) (IDENTIFIER . 
(attribute_designator . 2)) (LESS_LESS . (attribute_designator . 2)) (OF . 
(attribute_designator . 2)) (IN . (attribute_designator . 2)) (NOT . 
(attribute_designator . 2)) (RIGHT_PAREN . (attribute_designator . 2)) (PLUS . 
(attribute_designator . 2)) (MINUS . (attribute_designator . 2)) (AMPERSAND . 
(attribute_designator . 2)) (DOT_DOT . (attribute_designator . 2)) (SLASH . 
(attribute_designator . 2)) (STAR . (attribute_designator . 2)) (MOD . 
(attribute_designator . 2)) (REM . (attribute_designator . 2)) (STAR_STAR . 
(attribute_designator . 2)) (BAR . (attribute_designator . 2)) (EQUAL_GREATER . 
(attribute_designator . 2)) (EQUAL . (attribute_designator . 2)) (GREATER . 
(attribute_designator . 2)) (GREATER_EQUAL . (attribute_designator . 2)) (LESS 
. (attribute_designator . 2)) (LESS_EQUAL . (attribute_designator . 2)) 
(SLASH_EQUAL . (attribute_designator . 2)) (AND . (attribute_designator . 2)) 
(OR . (attribute_designator . 2)) (XOR . (attribute_designator . 2)) 
(LEFT_PAREN . (attribute_designator . 2)) (SEMICOLON . (attribute_designator . 
2)) (COMMA . (attribute_designator . 2)) (DOT . (attribute_designator . 2)) 
(TICK . (attribute_designator . 2)) (WITH . (attribute_designator . 2)) (IS . 
(attribute_designator . 2)) (RETURN . (attribute_designator . 2)))
+      ((default . error) (DO . (attribute_designator . 3)) (RENAMES . 
(attribute_designator . 3)) (ELSIF . (attribute_designator . 3)) (ELSE . 
(attribute_designator . 3)) (DIGITS . (attribute_designator . 3)) (RANGE . 
(attribute_designator . 3)) (THEN . (attribute_designator . 3)) (USE . 
(attribute_designator . 3)) (COLON_EQUAL . (attribute_designator . 3)) (WHILE . 
(attribute_designator . 3)) (SELECT . (attribute_designator . 3)) (REQUEUE . 
(attribute_designator . 3)) (RAISE . (attribute_designator . 3)) (PRAGMA . 
(attribute_designator . 3)) (NULL . (attribute_designator . 3)) (LOOP . 
(attribute_designator . 3)) (IF . (attribute_designator . 3)) (GOTO . 
(attribute_designator . 3)) (FOR . (attribute_designator . 3)) (EXIT . 
(attribute_designator . 3)) (DELAY . (attribute_designator . 3)) (DECLARE . 
(attribute_designator . 3)) (CASE . (attribute_designator . 3)) (BEGIN . 
(attribute_designator . 3)) (ABORT . (attribute_designator . 3)) (ACCEPT . 
(attribute_designator . 3)) (CHARACTER_LITERAL . (attribute_designator . 3)) 
(STRING_LITERAL . (attribute_designator . 3)) (IDENTIFIER . 
(attribute_designator . 3)) (LESS_LESS . (attribute_designator . 3)) (OF . 
(attribute_designator . 3)) (IN . (attribute_designator . 3)) (NOT . 
(attribute_designator . 3)) (RIGHT_PAREN . (attribute_designator . 3)) (PLUS . 
(attribute_designator . 3)) (MINUS . (attribute_designator . 3)) (AMPERSAND . 
(attribute_designator . 3)) (DOT_DOT . (attribute_designator . 3)) (SLASH . 
(attribute_designator . 3)) (STAR . (attribute_designator . 3)) (MOD . 
(attribute_designator . 3)) (REM . (attribute_designator . 3)) (STAR_STAR . 
(attribute_designator . 3)) (BAR . (attribute_designator . 3)) (EQUAL_GREATER . 
(attribute_designator . 3)) (EQUAL . (attribute_designator . 3)) (GREATER . 
(attribute_designator . 3)) (GREATER_EQUAL . (attribute_designator . 3)) (LESS 
. (attribute_designator . 3)) (LESS_EQUAL . (attribute_designator . 3)) 
(SLASH_EQUAL . (attribute_designator . 3)) (AND . (attribute_designator . 3)) 
(OR . (attribute_designator . 3)) (XOR . (attribute_designator . 3)) 
(LEFT_PAREN . (attribute_designator . 3)) (SEMICOLON . (attribute_designator . 
3)) (COMMA . (attribute_designator . 3)) (DOT . (attribute_designator . 3)) 
(TICK . (attribute_designator . 3)) (WITH . (attribute_designator . 3)) (IS . 
(attribute_designator . 3)) (RETURN . (attribute_designator . 3)))
+      ((default . error) (RIGHT_PAREN . ((association_opt . 0) (expression_opt 
. 0))) (COMMA . ((association_opt . 0) (expression_opt . 0))) (EQUAL_GREATER . 
(discrete_choice_list . 0)) (BAR . (discrete_choice_list . 0)) (PLUS .  136) 
(MINUS .  135) (OTHERS .  165) (ABS .  138) (NOT .  164) (IDENTIFIER .  45) 
(CHARACTER_LITERAL .  163) (STRING_LITERAL .  46) (NULL .  218) (NEW .  140) 
(LEFT_PAREN .  139))
+      ((default . error) (DO . (attribute_designator . 4)) (RENAMES . 
(attribute_designator . 4)) (ELSIF . (attribute_designator . 4)) (ELSE . 
(attribute_designator . 4)) (DIGITS . (attribute_designator . 4)) (RANGE . 
(attribute_designator . 4)) (THEN . (attribute_designator . 4)) (USE . 
(attribute_designator . 4)) (COLON_EQUAL . (attribute_designator . 4)) (WHILE . 
(attribute_designator . 4)) (SELECT . (attribute_designator . 4)) (REQUEUE . 
(attribute_designator . 4)) (RAISE . (attribute_designator . 4)) (PRAGMA . 
(attribute_designator . 4)) (NULL . (attribute_designator . 4)) (LOOP . 
(attribute_designator . 4)) (IF . (attribute_designator . 4)) (GOTO . 
(attribute_designator . 4)) (FOR . (attribute_designator . 4)) (EXIT . 
(attribute_designator . 4)) (DELAY . (attribute_designator . 4)) (DECLARE . 
(attribute_designator . 4)) (CASE . (attribute_designator . 4)) (BEGIN . 
(attribute_designator . 4)) (ABORT . (attribute_designator . 4)) (ACCEPT . 
(attribute_designator . 4)) (CHARACTER_LITERAL . (attribute_designator . 4)) 
(STRING_LITERAL . (attribute_designator . 4)) (IDENTIFIER . 
(attribute_designator . 4)) (LESS_LESS . (attribute_designator . 4)) (OF . 
(attribute_designator . 4)) (IN . (attribute_designator . 4)) (NOT . 
(attribute_designator . 4)) (RIGHT_PAREN . (attribute_designator . 4)) (PLUS . 
(attribute_designator . 4)) (MINUS . (attribute_designator . 4)) (AMPERSAND . 
(attribute_designator . 4)) (DOT_DOT . (attribute_designator . 4)) (SLASH . 
(attribute_designator . 4)) (STAR . (attribute_designator . 4)) (MOD . 
(attribute_designator . 4)) (REM . (attribute_designator . 4)) (STAR_STAR . 
(attribute_designator . 4)) (BAR . (attribute_designator . 4)) (EQUAL_GREATER . 
(attribute_designator . 4)) (EQUAL . (attribute_designator . 4)) (GREATER . 
(attribute_designator . 4)) (GREATER_EQUAL . (attribute_designator . 4)) (LESS 
. (attribute_designator . 4)) (LESS_EQUAL . (attribute_designator . 4)) 
(SLASH_EQUAL . (attribute_designator . 4)) (AND . (attribute_designator . 4)) 
(OR . (attribute_designator . 4)) (XOR . (attribute_designator . 4)) 
(LEFT_PAREN . (attribute_designator . 4)) (SEMICOLON . (attribute_designator . 
4)) (COMMA . (attribute_designator . 4)) (DOT . (attribute_designator . 4)) 
(TICK . (attribute_designator . 4)) (WITH . (attribute_designator . 4)) (IS . 
(attribute_designator . 4)) (RETURN . (attribute_designator . 4)))
+      ((default . error) (DO . (qualified_expression . 0)) (RENAMES . 
(qualified_expression . 0)) (ELSIF . (qualified_expression . 0)) (ELSE . 
(qualified_expression . 0)) (DIGITS . (qualified_expression . 0)) (RANGE . 
(qualified_expression . 0)) (THEN . (qualified_expression . 0)) (USE . 
(qualified_expression . 0)) (COLON_EQUAL . (qualified_expression . 0)) (WHILE . 
(qualified_expression . 0)) (SELECT . (qualified_expression . 0)) (REQUEUE . 
(qualified_expression . 0)) (RAISE . (qualified_expression . 0)) (PRAGMA . 
(qualified_expression . 0)) (NULL . (qualified_expression . 0)) (LOOP . 
(qualified_expression . 0)) (IF . (qualified_expression . 0)) (GOTO . 
(qualified_expression . 0)) (FOR . (qualified_expression . 0)) (EXIT . 
(qualified_expression . 0)) (DELAY . (qualified_expression . 0)) (DECLARE . 
(qualified_expression . 0)) (CASE . (qualified_expression . 0)) (BEGIN . 
(qualified_expression . 0)) (ABORT . (qualified_expression . 0)) (ACCEPT . 
(qualified_expression . 0)) (CHARACTER_LITERAL . (qualified_expression . 0)) 
(STRING_LITERAL . (qualified_expression . 0)) (IDENTIFIER . 
(qualified_expression . 0)) (LESS_LESS . (qualified_expression . 0)) (OF . 
(qualified_expression . 0)) (IN . (qualified_expression . 0)) (NOT . 
(qualified_expression . 0)) (RIGHT_PAREN . (qualified_expression . 0)) (PLUS . 
(qualified_expression . 0)) (MINUS . (qualified_expression . 0)) (AMPERSAND . 
(qualified_expression . 0)) (DOT_DOT . (qualified_expression . 0)) (SLASH . 
(qualified_expression . 0)) (STAR . (qualified_expression . 0)) (MOD . 
(qualified_expression . 0)) (REM . (qualified_expression . 0)) (STAR_STAR . 
(qualified_expression . 0)) (BAR . (qualified_expression . 0)) (EQUAL_GREATER . 
(qualified_expression . 0)) (EQUAL . (qualified_expression . 0)) (GREATER . 
(qualified_expression . 0)) (GREATER_EQUAL . (qualified_expression . 0)) (LESS 
. (qualified_expression . 0)) (LESS_EQUAL . (qualified_expression . 0)) 
(SLASH_EQUAL . (qualified_expression . 0)) (AND . (qualified_expression . 0)) 
(OR . (qualified_expression . 0)) (XOR . (qualified_expression . 0)) (SEMICOLON 
. (qualified_expression . 0)) (COMMA . (qualified_expression . 0)) (LEFT_PAREN 
. (qualified_expression . 0)) (DOT . (qualified_expression . 0)) (TICK . 
(qualified_expression . 0)) (WITH . (qualified_expression . 0)) (IS . 
(qualified_expression . 0)) (RETURN . (qualified_expression . 0)))
+      ((default . error) (DO . (attribute_reference . 0)) (RENAMES . 
(attribute_reference . 0)) (ELSIF . (attribute_reference . 0)) (ELSE . 
(attribute_reference . 0)) (DIGITS . (attribute_reference . 0)) (RANGE . 
(attribute_reference . 0)) (THEN . (attribute_reference . 0)) (USE . 
(attribute_reference . 0)) (COLON_EQUAL . (attribute_reference . 0)) (WHILE . 
(attribute_reference . 0)) (SELECT . (attribute_reference . 0)) (REQUEUE . 
(attribute_reference . 0)) (RAISE . (attribute_reference . 0)) (PRAGMA . 
(attribute_reference . 0)) (NULL . (attribute_reference . 0)) (LOOP . 
(attribute_reference . 0)) (IF . (attribute_reference . 0)) (GOTO . 
(attribute_reference . 0)) (FOR . (attribute_reference . 0)) (EXIT . 
(attribute_reference . 0)) (DELAY . (attribute_reference . 0)) (DECLARE . 
(attribute_reference . 0)) (CASE . (attribute_reference . 0)) (BEGIN . 
(attribute_reference . 0)) (ABORT . (attribute_reference . 0)) (ACCEPT . 
(attribute_reference . 0)) (CHARACTER_LITERAL . (attribute_reference . 0)) 
(STRING_LITERAL . (attribute_reference . 0)) (IDENTIFIER . (attribute_reference 
. 0)) (LESS_LESS . (attribute_reference . 0)) (OF . (attribute_reference . 0)) 
(IN . (attribute_reference . 0)) (NOT . (attribute_reference . 0)) (RIGHT_PAREN 
. (attribute_reference . 0)) (PLUS . (attribute_reference . 0)) (MINUS . 
(attribute_reference . 0)) (AMPERSAND . (attribute_reference . 0)) (DOT_DOT . 
(attribute_reference . 0)) (SLASH . (attribute_reference . 0)) (STAR . 
(attribute_reference . 0)) (MOD . (attribute_reference . 0)) (REM . 
(attribute_reference . 0)) (STAR_STAR . (attribute_reference . 0)) (BAR . 
(attribute_reference . 0)) (EQUAL_GREATER . (attribute_reference . 0)) (EQUAL . 
(attribute_reference . 0)) (GREATER . (attribute_reference . 0)) (GREATER_EQUAL 
. (attribute_reference . 0)) (LESS . (attribute_reference . 0)) (LESS_EQUAL . 
(attribute_reference . 0)) (SLASH_EQUAL . (attribute_reference . 0)) (AND . 
(attribute_reference . 0)) (OR . (attribute_reference . 0)) (XOR . 
(attribute_reference . 0)) (LEFT_PAREN . (attribute_reference . 0)) (SEMICOLON 
. (attribute_reference . 0)) (COMMA . (attribute_reference . 0)) (DOT . 
(attribute_reference . 0)) (TICK . (attribute_reference . 0)) (WITH . 
(attribute_reference . 0)) (IS . (attribute_reference . 0)) (RETURN . 
(attribute_reference . 0)))
+      ((default . error) (DO . (attribute_designator . 0)) (RENAMES . 
(attribute_designator . 0)) (ELSIF . (attribute_designator . 0)) (ELSE . 
(attribute_designator . 0)) (DIGITS . (attribute_designator . 0)) (RANGE . 
(attribute_designator . 0)) (THEN . (attribute_designator . 0)) (USE . 
(attribute_designator . 0)) (COLON_EQUAL . (attribute_designator . 0)) (WHILE . 
(attribute_designator . 0)) (SELECT . (attribute_designator . 0)) (REQUEUE . 
(attribute_designator . 0)) (RAISE . (attribute_designator . 0)) (PRAGMA . 
(attribute_designator . 0)) (NULL . (attribute_designator . 0)) (LOOP . 
(attribute_designator . 0)) (IF . (attribute_designator . 0)) (GOTO . 
(attribute_designator . 0)) (FOR . (attribute_designator . 0)) (EXIT . 
(attribute_designator . 0)) (DELAY . (attribute_designator . 0)) (DECLARE . 
(attribute_designator . 0)) (CASE . (attribute_designator . 0)) (BEGIN . 
(attribute_designator . 0)) (ABORT . (attribute_designator . 0)) (ACCEPT . 
(attribute_designator . 0)) (CHARACTER_LITERAL . (attribute_designator . 0)) 
(STRING_LITERAL . (attribute_designator . 0)) (IDENTIFIER . 
(attribute_designator . 0)) (LESS_LESS . (attribute_designator . 0)) (OF . 
(attribute_designator . 0)) (IN . (attribute_designator . 0)) (NOT . 
(attribute_designator . 0)) (RIGHT_PAREN . (attribute_designator . 0)) (PLUS . 
(attribute_designator . 0)) (MINUS . (attribute_designator . 0)) (AMPERSAND . 
(attribute_designator . 0)) (DOT_DOT . (attribute_designator . 0)) (SLASH . 
(attribute_designator . 0)) (STAR . (attribute_designator . 0)) (MOD . 
(attribute_designator . 0)) (REM . (attribute_designator . 0)) (STAR_STAR . 
(attribute_designator . 0)) (BAR . (attribute_designator . 0)) (EQUAL_GREATER . 
(attribute_designator . 0)) (EQUAL . (attribute_designator . 0)) (GREATER . 
(attribute_designator . 0)) (GREATER_EQUAL . (attribute_designator . 0)) (LESS 
. (attribute_designator . 0)) (LESS_EQUAL . (attribute_designator . 0)) 
(SLASH_EQUAL . (attribute_designator . 0)) (AND . (attribute_designator . 0)) 
(OR . (attribute_designator . 0)) (XOR . (attribute_designator . 0)) (SEMICOLON 
. (attribute_designator . 0)) (COMMA . (attribute_designator . 0)) (DOT . ( 84 
(attribute_designator . 0))) (WITH . (attribute_designator . 0)) (IS . 
(attribute_designator . 0)) (RETURN . (attribute_designator . 0)) (TICK . ( 85 
(attribute_designator . 0)  85)) (LEFT_PAREN . ( 103 (attribute_designator . 0) 
 103)))
+      ((default . error) (DO . (selected_component . 0)) (RENAMES . 
(selected_component . 0)) (RIGHT_PAREN . (selected_component . 0)) (BAR . 
(selected_component . 0)) (ELSIF . (selected_component . 0)) (ELSE . 
(selected_component . 0)) (EQUAL_GREATER . (selected_component . 0)) (DIGITS . 
(selected_component . 0)) (RANGE . (selected_component . 0)) (THEN . 
(selected_component . 0)) (DOT_DOT . (selected_component . 0)) (IN . 
(selected_component . 0)) (NOT . (selected_component . 0)) (EQUAL . 
(selected_component . 0)) (GREATER . (selected_component . 0)) (GREATER_EQUAL . 
(selected_component . 0)) (LESS . (selected_component . 0)) (LESS_EQUAL . 
(selected_component . 0)) (SLASH_EQUAL . (selected_component . 0)) (AND . 
(selected_component . 0)) (OR . (selected_component . 0)) (XOR . 
(selected_component . 0)) (PLUS . (selected_component . 0)) (MINUS . 
(selected_component . 0)) (AMPERSAND . (selected_component . 0)) (SLASH . 
(selected_component . 0)) (STAR . (selected_component . 0)) (MOD . 
(selected_component . 0)) (REM . (selected_component . 0)) (STAR_STAR . 
(selected_component . 0)) (USE . (selected_component . 0)) (COLON_EQUAL . 
(selected_component . 0)) (WHILE . (selected_component . 0)) (SELECT . 
(selected_component . 0)) (REQUEUE . (selected_component . 0)) (RAISE . 
(selected_component . 0)) (PRAGMA . (selected_component . 0)) (NULL . 
(selected_component . 0)) (LOOP . (selected_component . 0)) (IF . 
(selected_component . 0)) (GOTO . (selected_component . 0)) (FOR . 
(selected_component . 0)) (EXIT . (selected_component . 0)) (DELAY . 
(selected_component . 0)) (DECLARE . (selected_component . 0)) (CASE . 
(selected_component . 0)) (BEGIN . (selected_component . 0)) (ABORT . 
(selected_component . 0)) (ACCEPT . (selected_component . 0)) 
(CHARACTER_LITERAL . (selected_component . 0)) (STRING_LITERAL . 
(selected_component . 0)) (IDENTIFIER . (selected_component . 0)) (LESS_LESS . 
(selected_component . 0)) (OF . (selected_component . 0)) (LEFT_PAREN . 
(selected_component . 0)) (SEMICOLON . (selected_component . 0)) (COMMA . 
(selected_component . 0)) (DOT . (selected_component . 0)) (TICK . 
(selected_component . 0)) (WITH . (selected_component . 0)) (IS . 
(selected_component . 0)) (RETURN . (selected_component . 0)))
+      ((default . error) (DO . (selected_component . 2)) (RENAMES . 
(selected_component . 2)) (RIGHT_PAREN . (selected_component . 2)) (BAR . 
(selected_component . 2)) (ELSIF . (selected_component . 2)) (ELSE . 
(selected_component . 2)) (EQUAL_GREATER . (selected_component . 2)) (DIGITS . 
(selected_component . 2)) (RANGE . (selected_component . 2)) (THEN . 
(selected_component . 2)) (DOT_DOT . (selected_component . 2)) (IN . 
(selected_component . 2)) (NOT . (selected_component . 2)) (EQUAL . 
(selected_component . 2)) (GREATER . (selected_component . 2)) (GREATER_EQUAL . 
(selected_component . 2)) (LESS . (selected_component . 2)) (LESS_EQUAL . 
(selected_component . 2)) (SLASH_EQUAL . (selected_component . 2)) (AND . 
(selected_component . 2)) (OR . (selected_component . 2)) (XOR . 
(selected_component . 2)) (PLUS . (selected_component . 2)) (MINUS . 
(selected_component . 2)) (AMPERSAND . (selected_component . 2)) (SLASH . 
(selected_component . 2)) (STAR . (selected_component . 2)) (MOD . 
(selected_component . 2)) (REM . (selected_component . 2)) (STAR_STAR . 
(selected_component . 2)) (USE . (selected_component . 2)) (COLON_EQUAL . 
(selected_component . 2)) (WHILE . (selected_component . 2)) (SELECT . 
(selected_component . 2)) (REQUEUE . (selected_component . 2)) (RAISE . 
(selected_component . 2)) (PRAGMA . (selected_component . 2)) (NULL . 
(selected_component . 2)) (LOOP . (selected_component . 2)) (IF . 
(selected_component . 2)) (GOTO . (selected_component . 2)) (FOR . 
(selected_component . 2)) (EXIT . (selected_component . 2)) (DELAY . 
(selected_component . 2)) (DECLARE . (selected_component . 2)) (CASE . 
(selected_component . 2)) (BEGIN . (selected_component . 2)) (ABORT . 
(selected_component . 2)) (ACCEPT . (selected_component . 2)) 
(CHARACTER_LITERAL . (selected_component . 2)) (STRING_LITERAL . 
(selected_component . 2)) (IDENTIFIER . (selected_component . 2)) (LESS_LESS . 
(selected_component . 2)) (OF . (selected_component . 2)) (LEFT_PAREN . 
(selected_component . 2)) (SEMICOLON . (selected_component . 2)) (COMMA . 
(selected_component . 2)) (DOT . (selected_component . 2)) (TICK . 
(selected_component . 2)) (WITH . (selected_component . 2)) (IS . 
(selected_component . 2)) (RETURN . (selected_component . 2)))
+      ((default . error) (DO . (selected_component . 1)) (RENAMES . 
(selected_component . 1)) (RIGHT_PAREN . (selected_component . 1)) (BAR . 
(selected_component . 1)) (ELSIF . (selected_component . 1)) (ELSE . 
(selected_component . 1)) (EQUAL_GREATER . (selected_component . 1)) (DIGITS . 
(selected_component . 1)) (RANGE . (selected_component . 1)) (THEN . 
(selected_component . 1)) (DOT_DOT . (selected_component . 1)) (IN . 
(selected_component . 1)) (NOT . (selected_component . 1)) (EQUAL . 
(selected_component . 1)) (GREATER . (selected_component . 1)) (GREATER_EQUAL . 
(selected_component . 1)) (LESS . (selected_component . 1)) (LESS_EQUAL . 
(selected_component . 1)) (SLASH_EQUAL . (selected_component . 1)) (AND . 
(selected_component . 1)) (OR . (selected_component . 1)) (XOR . 
(selected_component . 1)) (PLUS . (selected_component . 1)) (MINUS . 
(selected_component . 1)) (AMPERSAND . (selected_component . 1)) (SLASH . 
(selected_component . 1)) (STAR . (selected_component . 1)) (MOD . 
(selected_component . 1)) (REM . (selected_component . 1)) (STAR_STAR . 
(selected_component . 1)) (USE . (selected_component . 1)) (COLON_EQUAL . 
(selected_component . 1)) (WHILE . (selected_component . 1)) (SELECT . 
(selected_component . 1)) (REQUEUE . (selected_component . 1)) (RAISE . 
(selected_component . 1)) (PRAGMA . (selected_component . 1)) (NULL . 
(selected_component . 1)) (LOOP . (selected_component . 1)) (IF . 
(selected_component . 1)) (GOTO . (selected_component . 1)) (FOR . 
(selected_component . 1)) (EXIT . (selected_component . 1)) (DELAY . 
(selected_component . 1)) (DECLARE . (selected_component . 1)) (CASE . 
(selected_component . 1)) (BEGIN . (selected_component . 1)) (ABORT . 
(selected_component . 1)) (ACCEPT . (selected_component . 1)) 
(CHARACTER_LITERAL . (selected_component . 1)) (STRING_LITERAL . 
(selected_component . 1)) (IDENTIFIER . (selected_component . 1)) (LESS_LESS . 
(selected_component . 1)) (OF . (selected_component . 1)) (LEFT_PAREN . 
(selected_component . 1)) (SEMICOLON . (selected_component . 1)) (COMMA . 
(selected_component . 1)) (DOT . (selected_component . 1)) (TICK . 
(selected_component . 1)) (WITH . (selected_component . 1)) (IS . 
(selected_component . 1)) (RETURN . (selected_component . 1)))
+      ((default . error) (DO . (selected_component . 3)) (RENAMES . 
(selected_component . 3)) (RIGHT_PAREN . (selected_component . 3)) (BAR . 
(selected_component . 3)) (ELSIF . (selected_component . 3)) (ELSE . 
(selected_component . 3)) (EQUAL_GREATER . (selected_component . 3)) (DIGITS . 
(selected_component . 3)) (RANGE . (selected_component . 3)) (THEN . 
(selected_component . 3)) (DOT_DOT . (selected_component . 3)) (IN . 
(selected_component . 3)) (NOT . (selected_component . 3)) (EQUAL . 
(selected_component . 3)) (GREATER . (selected_component . 3)) (GREATER_EQUAL . 
(selected_component . 3)) (LESS . (selected_component . 3)) (LESS_EQUAL . 
(selected_component . 3)) (SLASH_EQUAL . (selected_component . 3)) (AND . 
(selected_component . 3)) (OR . (selected_component . 3)) (XOR . 
(selected_component . 3)) (PLUS . (selected_component . 3)) (MINUS . 
(selected_component . 3)) (AMPERSAND . (selected_component . 3)) (SLASH . 
(selected_component . 3)) (STAR . (selected_component . 3)) (MOD . 
(selected_component . 3)) (REM . (selected_component . 3)) (STAR_STAR . 
(selected_component . 3)) (USE . (selected_component . 3)) (COLON_EQUAL . 
(selected_component . 3)) (WHILE . (selected_component . 3)) (SELECT . 
(selected_component . 3)) (REQUEUE . (selected_component . 3)) (RAISE . 
(selected_component . 3)) (PRAGMA . (selected_component . 3)) (NULL . 
(selected_component . 3)) (LOOP . (selected_component . 3)) (IF . 
(selected_component . 3)) (GOTO . (selected_component . 3)) (FOR . 
(selected_component . 3)) (EXIT . (selected_component . 3)) (DELAY . 
(selected_component . 3)) (DECLARE . (selected_component . 3)) (CASE . 
(selected_component . 3)) (BEGIN . (selected_component . 3)) (ABORT . 
(selected_component . 3)) (ACCEPT . (selected_component . 3)) 
(CHARACTER_LITERAL . (selected_component . 3)) (STRING_LITERAL . 
(selected_component . 3)) (IDENTIFIER . (selected_component . 3)) (LESS_LESS . 
(selected_component . 3)) (OF . (selected_component . 3)) (LEFT_PAREN . 
(selected_component . 3)) (SEMICOLON . (selected_component . 3)) (COMMA . 
(selected_component . 3)) (DOT . (selected_component . 3)) (TICK . 
(selected_component . 3)) (WITH . (selected_component . 3)) (IS . 
(selected_component . 3)) (RETURN . (selected_component . 3)))
+      ((default . error) (DOT_DOT . (primary . 0)) (RIGHT_PAREN . (primary . 
0)) (COMMA . (primary . 0)) (BAR . (primary . 0)) (EQUAL_GREATER . (primary . 
0)) (PLUS . (primary . 0)) (MINUS . (primary . 0)) (AMPERSAND . (primary . 0)) 
(IN . (primary . 0)) (NOT . (primary . 0)) (EQUAL . (primary . 0)) (GREATER . 
(primary . 0)) (GREATER_EQUAL . (primary . 0)) (LESS . (primary . 0)) 
(LESS_EQUAL . (primary . 0)) (SLASH_EQUAL . (primary . 0)) (WITH . (primary . 
0)) (SLASH . (primary . 0)) (STAR . (primary . 0)) (MOD . (primary . 0)) (REM . 
(primary . 0)) (STAR_STAR . (primary . 0)) (AND . (primary . 0)) (OR . (primary 
. 0)) (XOR . (primary . 0)) (RECORD .  505))
+      ((default . error) (COMMA .  272) (RIGHT_PAREN .  504))
+      ((default . error) (RIGHT_PAREN . (expression_opt . 1)) (COMMA . 
(expression_opt . 1)) (WITH .  503))
+      ((default . error) (BAR . (discrete_choice . 2)) (EQUAL_GREATER . 
(discrete_choice . 2)))
+      ((default . error) (IDENTIFIER .  69))
+      ((default . error) (RIGHT_PAREN . (formal_part . 0)) (COLON_EQUAL . 
(formal_part . 0)) (DO . (formal_part . 0)) (WHEN . (formal_part . 0)) (RENAMES 
. (formal_part . 0)) (IS . (formal_part . 0)) (WITH . (formal_part . 0)) 
(SEMICOLON . (formal_part . 0)) (RETURN . (formal_part . 0)))
+      ((default . error) (IN . (aliased_opt . 0)) (OUT . (aliased_opt . 0)) 
(IDENTIFIER . (aliased_opt . 0)) (STRING_LITERAL . (aliased_opt . 0)) 
(CHARACTER_LITERAL . (aliased_opt . 0)) (ALIASED .  499) (ACCESS . 
(null_exclusion_opt . 0)) (NOT . ((aliased_opt . 0)  198)))
+      ((default . error) (FUNCTION . (protected_opt . 0)) (PROCEDURE . 
(protected_opt . 0)) (PROTECTED .  496) (IDENTIFIER . 
(general_access_modifier_opt . 0)) (STRING_LITERAL . 
(general_access_modifier_opt . 0)) (CHARACTER_LITERAL . 
(general_access_modifier_opt . 0)) (ALL .  494) (CONSTANT .  495))
+      ((default . error) (ACCESS . (null_exclusion_opt . 1)) 
(CHARACTER_LITERAL . (null_exclusion_opt . 1)) (STRING_LITERAL . 
(null_exclusion_opt . 1)) (IDENTIFIER . (null_exclusion_opt . 1)))
+      ((default . error) (DO . (parameter_and_result_profile . 2)) 
(RIGHT_PAREN . (parameter_and_result_profile . 2)) (COLON_EQUAL . 
(parameter_and_result_profile . 2)) (RENAMES . (parameter_and_result_profile . 
2)) (WITH . (parameter_and_result_profile . 2)) (IS . 
(parameter_and_result_profile . 2)) (SEMICOLON . (parameter_and_result_profile 
. 2)))
+      ((default . error) (ACCESS .  225) (IDENTIFIER .  45) (CHARACTER_LITERAL 
.  47) (STRING_LITERAL .  46))
+      ((default . error) (COLON_EQUAL .  491) (SEMICOLON . 
(aspect_specification_opt . 0)) (WITH .  104))
+      ((default . error) (ACCESS .  225) (IDENTIFIER .  45) (CHARACTER_LITERAL 
.  47) (STRING_LITERAL .  46))
+      ((default . error) (CHARACTER_LITERAL . (mode_opt . 2)) (STRING_LITERAL 
. (mode_opt . 2)) (IDENTIFIER . (mode_opt . 2)) (NOT . (mode_opt . 2)) (ACCESS 
. (mode_opt . 2)))
+      ((default . error) (NEW .  489))
+      ((default . error) (WITH . (formal_subprogram_declaration . 1)) (TYPE . 
(formal_subprogram_declaration . 1)) (PRAGMA . (formal_subprogram_declaration . 
1)) (IDENTIFIER . (formal_subprogram_declaration . 1)) (FUNCTION . 
(formal_subprogram_declaration . 1)) (PROCEDURE . 
(formal_subprogram_declaration . 1)) (PACKAGE . (formal_subprogram_declaration 
. 1)))
+      ((default . error) (WITH . (subprogram_default . 1)) (SEMICOLON . 
(subprogram_default . 1)))
+      ((default . error) (SEMICOLON . (aspect_specification_opt . 0)) (WITH .  
104) (BOX .  234) (NULL .  236) (IDENTIFIER .  45) (CHARACTER_LITERAL .  47) 
(STRING_LITERAL .  46))
+      ((default . error) (WITH . (subprogram_default . 2)) (SEMICOLON . 
(subprogram_default . 2)))
+      ((default . error) (WITH . (subprogram_default . 0)) (SEMICOLON . 
(subprogram_default . 0)) (DOT .  84) (TICK .  85) (LEFT_PAREN .  103))
+      ((default . error) (SEMICOLON . (aspect_specification_opt . 0)) (WITH .  
104))
+      ((default . error) (LEFT_PAREN .  471) (RANGE .  476) (MOD .  473) 
(DIGITS .  469) (DELTA .  468) (TASK .  479) (PROTECTED .  475) (SYNCHRONIZED . 
 477) (INTERFACE .  470) (ARRAY .  467) (NEW .  474) (PRIVATE . 
(abstract_tagged_limited_opt . 0)) (ABSTRACT .  466) (TAGGED .  478) (LIMITED . 
 472) (ACCESS . (null_exclusion_opt . 0)) (NOT .  198))
+      ((default . error) (SEMICOLON .  465))
+      ((default . error) (RIGHT_PAREN .  464))
+      ((default . error) (RIGHT_PAREN . (discriminant_specification_list . 0)) 
(SEMICOLON . (discriminant_specification_list . 0)))
+      ((default . error) (SEMICOLON .  462) (RIGHT_PAREN .  463))
+      ((default . error) (COMMA .  92) (COLON .  461))
+      ((default . error) (DOT .  84) (TICK .  85) (SEMICOLON . 
(aspect_specification_opt . 0)) (WITH .  104) (LEFT_PAREN .  103))
+      ((default . error) (DOT .  84) (TICK .  85) (SEMICOLON . 
(aspect_specification_opt . 0)) (WITH .  104) (LEFT_PAREN .  103))
+      ((default . error) (DOT .  84) (TICK .  85) (SEMICOLON . 
(aspect_specification_opt . 0)) (WITH .  104) (LEFT_PAREN .  103))
+      ((default . error) (WITH . (with_clause . 0)) (USE . (with_clause . 0)) 
(SEPARATE . (with_clause . 0)) (PROCEDURE . (with_clause . 0)) (PRIVATE . 
(with_clause . 0)) (PRAGMA . (with_clause . 0)) (PACKAGE . (with_clause . 0)) 
(OVERRIDING . (with_clause . 0)) (NOT . (with_clause . 0)) (LIMITED . 
(with_clause . 0)) (GENERIC . (with_clause . 0)) (FUNCTION . (with_clause . 0)) 
($EOI . (with_clause . 0)))
+      ((default . error) (DOT .  84) (TICK .  85) (SEMICOLON . 
(aspect_specification_opt . 0)) (WITH .  104) (LEFT_PAREN .  103))
+      ((default . error) (PLUS .  136) (MINUS .  135) (ABS .  138) (NOT .  
141) (NULL .  142) (NEW .  140) (IDENTIFIER .  45) (CHARACTER_LITERAL .  47) 
(STRING_LITERAL .  46) (LEFT_PAREN .  139))
+      ((default . error) (MINUS . (relational_operator . 0)) (PLUS . 
(relational_operator . 0)) (IDENTIFIER . (relational_operator . 0)) 
(STRING_LITERAL . (relational_operator . 0)) (CHARACTER_LITERAL . 
(relational_operator . 0)) (ABS . (relational_operator . 0)) (LEFT_PAREN . 
(relational_operator . 0)) (NEW . (relational_operator . 0)) (NOT . 
(relational_operator . 0)) (NULL . (relational_operator . 0)))
+      ((default . error) (MINUS . (relational_operator . 4)) (PLUS . 
(relational_operator . 4)) (IDENTIFIER . (relational_operator . 4)) 
(STRING_LITERAL . (relational_operator . 4)) (CHARACTER_LITERAL . 
(relational_operator . 4)) (ABS . (relational_operator . 4)) (LEFT_PAREN . 
(relational_operator . 4)) (NEW . (relational_operator . 4)) (NOT . 
(relational_operator . 4)) (NULL . (relational_operator . 4)))
+      ((default . error) (MINUS . (relational_operator . 5)) (PLUS . 
(relational_operator . 5)) (IDENTIFIER . (relational_operator . 5)) 
(STRING_LITERAL . (relational_operator . 5)) (CHARACTER_LITERAL . 
(relational_operator . 5)) (ABS . (relational_operator . 5)) (LEFT_PAREN . 
(relational_operator . 5)) (NEW . (relational_operator . 5)) (NOT . 
(relational_operator . 5)) (NULL . (relational_operator . 5)))
+      ((default . error) (MINUS . (relational_operator . 2)) (PLUS . 
(relational_operator . 2)) (IDENTIFIER . (relational_operator . 2)) 
(STRING_LITERAL . (relational_operator . 2)) (CHARACTER_LITERAL . 
(relational_operator . 2)) (ABS . (relational_operator . 2)) (LEFT_PAREN . 
(relational_operator . 2)) (NEW . (relational_operator . 2)) (NOT . 
(relational_operator . 2)) (NULL . (relational_operator . 2)))
+      ((default . error) (MINUS . (relational_operator . 3)) (PLUS . 
(relational_operator . 3)) (IDENTIFIER . (relational_operator . 3)) 
(STRING_LITERAL . (relational_operator . 3)) (CHARACTER_LITERAL . 
(relational_operator . 3)) (ABS . (relational_operator . 3)) (LEFT_PAREN . 
(relational_operator . 3)) (NEW . (relational_operator . 3)) (NOT . 
(relational_operator . 3)) (NULL . (relational_operator . 3)))
+      ((default . error) (MINUS . (relational_operator . 1)) (PLUS . 
(relational_operator . 1)) (IDENTIFIER . (relational_operator . 1)) 
(STRING_LITERAL . (relational_operator . 1)) (CHARACTER_LITERAL . 
(relational_operator . 1)) (ABS . (relational_operator . 1)) (LEFT_PAREN . 
(relational_operator . 1)) (NEW . (relational_operator . 1)) (NOT . 
(relational_operator . 1)) (NULL . (relational_operator . 1)))
+      ((default . error) (PLUS .  136) (MINUS .  135) (IDENTIFIER .  45) 
(CHARACTER_LITERAL .  47) (STRING_LITERAL .  46) (ABS .  138) (NOT .  141) 
(NULL .  142) (NEW .  140) (LEFT_PAREN .  139))
+      ((default . error) (IN .  451))
+      ((default . error) (PLUS .  136) (MINUS .  135) (ABS .  138) (NOT .  
141) (NULL .  142) (NEW .  140) (IDENTIFIER .  45) (CHARACTER_LITERAL .  47) 
(STRING_LITERAL .  46) (LEFT_PAREN .  139))
+      ((default . error) (DO . (name . 2)) (WHILE . (name . 2)) (SELECT . 
(name . 2)) (REQUEUE . (name . 2)) (RAISE . (name . 2)) (PRAGMA . (name . 2)) 
(NULL . (name . 2)) (LOOP . (name . 2)) (IF . (name . 2)) (GOTO . (name . 2)) 
(FOR . (name . 2)) (EXIT . (name . 2)) (DELAY . (name . 2)) (DECLARE . (name . 
2)) (CASE . (name . 2)) (BEGIN . (name . 2)) (ABORT . (name . 2)) (ACCEPT . 
(name . 2)) (CHARACTER_LITERAL . (name . 2)) (STRING_LITERAL . (name . 2)) 
(IDENTIFIER . (name . 2)) (LESS_LESS . (name . 2)) (USE . (name . 2)) (XOR . 
(name . 2)) (OR . (name . 2)) (IN . (name . 2)) (NOT . (name . 2)) (EQUAL . 
(name . 2)) (GREATER . (name . 2)) (GREATER_EQUAL . (name . 2)) (LESS . (name . 
2)) (LESS_EQUAL . (name . 2)) (SLASH_EQUAL . (name . 2)) (THEN . (name . 2)) 
(DIGITS . (name . 2)) (EQUAL_GREATER . (name . 2)) (ELSE . (name . 2)) (ELSIF . 
(name . 2)) (BAR . (name . 2)) (STAR_STAR . (name . 2)) (REM . (name . 2)) (MOD 
. (name . 2)) (STAR . (name . 2)) (SLASH . (name . 2)) (DOT_DOT . (name . 2)) 
(AMPERSAND . (name . 2)) (MINUS . (name . 2)) (PLUS . (name . 2)) (RIGHT_PAREN 
. (name . 2)) (RANGE . (name . 2)) (COLON_EQUAL . (name . 2)) (AND . (name . 
2)) (OF . (name . 2)) (RETURN . (name . 2)) (TICK . (name . 2)) (DOT . (name . 
2)) (LEFT_PAREN . (name . 2)) (IS . (name . 2)) (WITH . (name . 2)) (SEMICOLON 
. (name . 2)) (RENAMES . (name . 2)) (COMMA . (name . 2)))
+      ((default . error) (RANGE .  449) (LEFT_PAREN .  209) (ACCESS .  206) 
(DELTA .  207) (DIGITS .  208) (MOD .  210) (IDENTIFIER .  45) 
(CHARACTER_LITERAL .  47) (STRING_LITERAL .  46))
+      ((default . error) (OTHERS .  165) (IDENTIFIER .  45) (CHARACTER_LITERAL 
.  47) (STRING_LITERAL .  46) (PLUS .  136) (MINUS .  135) (ABS .  138) (NOT .  
164) (NULL .  142) (NEW .  140) (LEFT_PAREN .  139))
+      ((default . error) (BOX .  445) (PLUS .  136) (MINUS .  135) (ABS .  
138) (NOT .  141) (NULL .  142) (NEW .  140) (IDENTIFIER .  45) 
(CHARACTER_LITERAL .  47) (STRING_LITERAL .  46) (LEFT_PAREN .  139))
+      ((default . error) (THEN .  443) (PLUS .  136) (MINUS .  135) (ABS .  
138) (NOT .  141) (NULL .  142) (NEW .  140) (IDENTIFIER .  45) 
(CHARACTER_LITERAL .  47) (STRING_LITERAL .  46) (LEFT_PAREN .  139))
+      ((default . error) (ELSE .  441) (PLUS .  136) (MINUS .  135) (ABS .  
138) (NOT .  141) (NULL .  142) (NEW .  140) (IDENTIFIER .  45) 
(CHARACTER_LITERAL .  47) (STRING_LITERAL .  46) (LEFT_PAREN .  139))
+      ((default . error) (PLUS .  136) (MINUS .  135) (ABS .  138) (NOT .  
141) (NULL .  142) (NEW .  140) (IDENTIFIER .  45) (CHARACTER_LITERAL .  47) 
(STRING_LITERAL .  46) (LEFT_PAREN .  139))
+      ((default . error) (ELSE .  439))
+      ((default . error) (THEN .  438))
+      ((default . error) (PLUS .  136) (MINUS .  135) (ABS .  138) (NOT .  
141) (NULL .  142) (NEW .  140) (IDENTIFIER .  45) (CHARACTER_LITERAL .  47) 
(STRING_LITERAL .  46) (LEFT_PAREN .  139))
+      ((default . error) (PLUS .  136) (MINUS .  135) (ABS .  138) (NOT .  
141) (NULL .  142) (NEW .  140) (IDENTIFIER .  45) (CHARACTER_LITERAL .  47) 
(STRING_LITERAL .  46) (LEFT_PAREN .  139))
+      ((default . error) (PLUS .  136) (MINUS .  135) (ABS .  138) (NOT .  
141) (NULL .  142) (NEW .  140) (IDENTIFIER .  45) (CHARACTER_LITERAL .  47) 
(STRING_LITERAL .  46) (LEFT_PAREN .  139))
+      ((default . error) (COMMA . ((association_opt . 0) (expression_opt . 
0))) (RIGHT_PAREN . ((association_opt . 0) (expression_opt . 0))) 
(EQUAL_GREATER . (discrete_choice_list . 0)) (BAR . (discrete_choice_list . 0)) 
(OTHERS .  165) (IDENTIFIER .  45) (CHARACTER_LITERAL .  163) (STRING_LITERAL . 
 46) (PLUS .  136) (MINUS .  135) (ABS .  138) (NOT .  164) (NULL .  142) (NEW 
.  140) (LEFT_PAREN .  139))
+      ((default . error) (STAR_STAR . (actual_parameter_part . 0)) (REM . 
(actual_parameter_part . 0)) (MOD . (actual_parameter_part . 0)) (STAR . 
(actual_parameter_part . 0)) (SLASH . (actual_parameter_part . 0)) (DOT_DOT . 
(actual_parameter_part . 0)) (AMPERSAND . (actual_parameter_part . 0)) (MINUS . 
(actual_parameter_part . 0)) (PLUS . (actual_parameter_part . 0)) (RIGHT_PAREN 
. (actual_parameter_part . 0)) (RANGE . (actual_parameter_part . 0)) 
(COLON_EQUAL . (actual_parameter_part . 0)) (AND . (actual_parameter_part . 0)) 
(OF . (actual_parameter_part . 0)) (DO . (actual_parameter_part . 0)) (WHILE . 
(actual_parameter_part . 0)) (SELECT . (actual_parameter_part . 0)) (REQUEUE . 
(actual_parameter_part . 0)) (RAISE . (actual_parameter_part . 0)) (PRAGMA . 
(actual_parameter_part . 0)) (NULL . (actual_parameter_part . 0)) (LOOP . 
(actual_parameter_part . 0)) (IF . (actual_parameter_part . 0)) (GOTO . 
(actual_parameter_part . 0)) (FOR . (actual_parameter_part . 0)) (EXIT . 
(actual_parameter_part . 0)) (DELAY . (actual_parameter_part . 0)) (DECLARE . 
(actual_parameter_part . 0)) (CASE . (actual_parameter_part . 0)) (BEGIN . 
(actual_parameter_part . 0)) (ABORT . (actual_parameter_part . 0)) (ACCEPT . 
(actual_parameter_part . 0)) (CHARACTER_LITERAL . (actual_parameter_part . 0)) 
(STRING_LITERAL . (actual_parameter_part . 0)) (IDENTIFIER . 
(actual_parameter_part . 0)) (LESS_LESS . (actual_parameter_part . 0)) (USE . 
(actual_parameter_part . 0)) (XOR . (actual_parameter_part . 0)) (OR . 
(actual_parameter_part . 0)) (IN . (actual_parameter_part . 0)) (NOT . 
(actual_parameter_part . 0)) (EQUAL . (actual_parameter_part . 0)) (GREATER . 
(actual_parameter_part . 0)) (GREATER_EQUAL . (actual_parameter_part . 0)) 
(LESS . (actual_parameter_part . 0)) (LESS_EQUAL . (actual_parameter_part . 0)) 
(SLASH_EQUAL . (actual_parameter_part . 0)) (THEN . (actual_parameter_part . 
0)) (DIGITS . (actual_parameter_part . 0)) (EQUAL_GREATER . 
(actual_parameter_part . 0)) (ELSE . (actual_parameter_part . 0)) (ELSIF . 
(actual_parameter_part . 0)) (BAR . (actual_parameter_part . 0)) (RETURN . 
(actual_parameter_part . 0)) (TICK . (actual_parameter_part . 0)) (DOT . 
(actual_parameter_part . 0)) (LEFT_PAREN . (actual_parameter_part . 0)) (IS . 
(actual_parameter_part . 0)) (WITH . (actual_parameter_part . 0)) (SEMICOLON . 
(actual_parameter_part . 0)) (RENAMES . (actual_parameter_part . 0)) (COMMA . 
(actual_parameter_part . 0)))
+      ((default . error) (XOR . (primary . 0)) (OR . (primary . 0)) (AND . 
(primary . 0)) (SLASH_EQUAL . (primary . 0)) (LESS_EQUAL . (primary . 0)) (LESS 
. (primary . 0)) (GREATER_EQUAL . (primary . 0)) (GREATER . (primary . 0)) 
(EQUAL . (primary . 0)) (EQUAL_GREATER . (primary . 0)) (BAR . (primary . 0)) 
(PLUS . (primary . 0)) (MINUS . (primary . 0)) (AMPERSAND . (primary . 0)) 
(DOT_DOT . (primary . 0)) (SLASH . (primary . 0)) (STAR . (primary . 0)) (MOD . 
(primary . 0)) (REM . (primary . 0)) (IN . (primary . 0)) (NOT . (primary . 0)) 
(RIGHT_PAREN . (primary . 0)) (COMMA . (primary . 0)) (WITH . (primary . 0)) 
(IDENTIFIER .  45) (CHARACTER_LITERAL .  47) (STRING_LITERAL .  46))
+      ((default . error) (COLON_EQUAL . (factor . 3)) (OF . (factor . 3)) 
(LOOP . (factor . 3)) (DO . (factor . 3)) (PLUS . (factor . 3)) (MINUS . 
(factor . 3)) (AMPERSAND . (factor . 3)) (SEMICOLON . (factor . 3)) (SLASH . 
(factor . 3)) (STAR . (factor . 3)) (MOD . (factor . 3)) (REM . (factor . 3)) 
(XOR . (factor . 3)) (OR . (factor . 3)) (AND . (factor . 3)) (IN . (factor . 
3)) (NOT . (factor . 3)) (EQUAL . (factor . 3)) (GREATER . (factor . 3)) 
(GREATER_EQUAL . (factor . 3)) (LESS . (factor . 3)) (LESS_EQUAL . (factor . 
3)) (SLASH_EQUAL . (factor . 3)) (IS . (factor . 3)) (WITH . (factor . 3)) 
(DOT_DOT . (factor . 3)) (THEN . (factor . 3)) (RANGE . (factor . 3)) (DIGITS . 
(factor . 3)) (EQUAL_GREATER . (factor . 3)) (ELSE . (factor . 3)) (ELSIF . 
(factor . 3)) (RIGHT_PAREN . (factor . 3)) (BAR . (factor . 3)) (COMMA . 
(factor . 3)))
+      ((default . error) (BOX .  430) (PLUS .  136) (MINUS .  135) (ABS .  
138) (NOT .  141) (NULL .  142) (NEW .  140) (IDENTIFIER .  45) 
(CHARACTER_LITERAL .  47) (STRING_LITERAL .  46) (LEFT_PAREN .  139))
+      ((default . error) (PLUS .  136) (MINUS .  135) (ABS .  138) (NOT .  
141) (NULL .  142) (NEW .  140) (IDENTIFIER .  45) (CHARACTER_LITERAL .  47) 
(STRING_LITERAL .  46) (LEFT_PAREN .  139))
+      ((default . error) (COLON . ( 428 (identifier_list . 0))) (COMMA . 
(identifier_list . 0)))
+      ((default . error) (IDENTIFIER .  423) (CHARACTER_LITERAL .  47) 
(STRING_LITERAL .  424))
+      ((default . error) (BODY .  421) (IDENTIFIER .  45) (CHARACTER_LITERAL . 
 47) (STRING_LITERAL .  46))
+      ((default . error) (IDENTIFIER .  418) (TYPE .  420) (BODY .  419))
+      ((default . error) (IDENTIFIER .  417))
+      ((default . error) (TYPE .  416) (BODY .  415) (IDENTIFIER .  414))
+      ((default . error) (IDENTIFIER .  413))
+      ((default . error) (END . (declaration . 0)) (PRIVATE . (declaration . 
0)) (USE . (declaration . 0)) (TYPE . (declaration . 0)) (TASK . (declaration . 
0)) (SUBTYPE . (declaration . 0)) (PROTECTED . (declaration . 0)) (PROCEDURE . 
(declaration . 0)) (PRAGMA . (declaration . 0)) (PACKAGE . (declaration . 0)) 
(OVERRIDING . (declaration . 0)) (NOT . (declaration . 0)) (GENERIC . 
(declaration . 0)) (FUNCTION . (declaration . 0)) (FOR . (declaration . 0)) 
(ENTRY . (declaration . 0)) (IDENTIFIER . (declaration . 0)) (BEGIN . 
(declaration . 0)))
+      ((default . error) (END . (declaration . 1)) (PRIVATE . (declaration . 
1)) (USE . (declaration . 1)) (TYPE . (declaration . 1)) (TASK . (declaration . 
1)) (SUBTYPE . (declaration . 1)) (PROTECTED . (declaration . 1)) (PROCEDURE . 
(declaration . 1)) (PRAGMA . (declaration . 1)) (PACKAGE . (declaration . 1)) 
(OVERRIDING . (declaration . 1)) (NOT . (declaration . 1)) (GENERIC . 
(declaration . 1)) (FUNCTION . (declaration . 1)) (FOR . (declaration . 1)) 
(ENTRY . (declaration . 1)) (IDENTIFIER . (declaration . 1)) (BEGIN . 
(declaration . 1)))
+      ((default . error) (WHEN . (aspect_clause . 3)) (PRIVATE . 
(aspect_clause . 3)) (END . (aspect_clause . 3)) (CASE . (aspect_clause . 3)) 
(BEGIN . (aspect_clause . 3)) (IDENTIFIER . (aspect_clause . 3)) (ENTRY . 
(aspect_clause . 3)) (FOR . (aspect_clause . 3)) (FUNCTION . (aspect_clause . 
3)) (GENERIC . (aspect_clause . 3)) (NOT . (aspect_clause . 3)) (OVERRIDING . 
(aspect_clause . 3)) (PACKAGE . (aspect_clause . 3)) (PRAGMA . (aspect_clause . 
3)) (PROCEDURE . (aspect_clause . 3)) (PROTECTED . (aspect_clause . 3)) 
(SUBTYPE . (aspect_clause . 3)) (TASK . (aspect_clause . 3)) (TYPE . 
(aspect_clause . 3)) (USE . (aspect_clause . 3)))
+      ((default . error) (END . (declaration . 2)) (PRIVATE . (declaration . 
2)) (USE . (declaration . 2)) (TYPE . (declaration . 2)) (TASK . (declaration . 
2)) (SUBTYPE . (declaration . 2)) (PROTECTED . (declaration . 2)) (PROCEDURE . 
(declaration . 2)) (PRAGMA . (declaration . 2)) (PACKAGE . (declaration . 2)) 
(OVERRIDING . (declaration . 2)) (NOT . (declaration . 2)) (GENERIC . 
(declaration . 2)) (FUNCTION . (declaration . 2)) (FOR . (declaration . 2)) 
(ENTRY . (declaration . 2)) (IDENTIFIER . (declaration . 2)) (BEGIN . 
(declaration . 2)))
+      ((default . error) (PRIVATE . (body . 1)) (END . (body . 1)) (BEGIN . 
(body . 1)) (IDENTIFIER . (body . 1)) (ENTRY . (body . 1)) (FOR . (body . 1)) 
(FUNCTION . (body . 1)) (GENERIC . (body . 1)) (NOT . (body . 1)) (OVERRIDING . 
(body . 1)) (PACKAGE . (body . 1)) (PRAGMA . (body . 1)) (PROCEDURE . (body . 
1)) (PROTECTED . (body . 1)) (SUBTYPE . (body . 1)) (TASK . (body . 1)) (TYPE . 
(body . 1)) (USE . (body . 1)))
+      ((default . error) (PRIVATE . (declarations . 0)) (END . (declarations . 
0)) (BEGIN . (declarations . 0)) (IDENTIFIER . (declarations . 0)) (ENTRY . 
(declarations . 0)) (FOR . (declarations . 0)) (FUNCTION . (declarations . 0)) 
(GENERIC . (declarations . 0)) (NOT . (declarations . 0)) (OVERRIDING . 
(declarations . 0)) (PACKAGE . (declarations . 0)) (PRAGMA . (declarations . 
0)) (PROCEDURE . (declarations . 0)) (PROTECTED . (declarations . 0)) (SUBTYPE 
. (declarations . 0)) (TASK . (declarations . 0)) (TYPE . (declarations . 0)) 
(USE . (declarations . 0)))
+      ((default . error) (END . (declarative_part_opt . 1)) (PRIVATE . 
(declarative_part_opt . 1)) (BEGIN . (declarative_part_opt . 1)) (USE .  11) 
(SUBTYPE .  282) (PRAGMA .  7) (NOT .  4) (OVERRIDING .  5) (FUNCTION . 
(overriding_indicator_opt . 2)) (PROCEDURE . (overriding_indicator_opt . 2)) 
(ENTRY . (overriding_indicator_opt . 2)) (FOR .  279) (IDENTIFIER .  278) (TYPE 
.  284) (GENERIC .  2) (PROTECTED .  281) (TASK .  283) (PACKAGE .  280))
+      ((default . error) (END .  410) (PRIVATE .  411))
+      ((default . error) (END . (declaration . 3)) (PRIVATE . (declaration . 
3)) (USE . (declaration . 3)) (TYPE . (declaration . 3)) (TASK . (declaration . 
3)) (SUBTYPE . (declaration . 3)) (PROTECTED . (declaration . 3)) (PROCEDURE . 
(declaration . 3)) (PRAGMA . (declaration . 3)) (PACKAGE . (declaration . 3)) 
(OVERRIDING . (declaration . 3)) (NOT . (declaration . 3)) (GENERIC . 
(declaration . 3)) (FUNCTION . (declaration . 3)) (FOR . (declaration . 3)) 
(ENTRY . (declaration . 3)) (IDENTIFIER . (declaration . 3)) (BEGIN . 
(declaration . 3)))
+      ((default . error) (WHEN . (aspect_clause . 1)) (PRIVATE . 
(aspect_clause . 1)) (END . (aspect_clause . 1)) (CASE . (aspect_clause . 1)) 
(BEGIN . (aspect_clause . 1)) (IDENTIFIER . (aspect_clause . 1)) (ENTRY . 
(aspect_clause . 1)) (FOR . (aspect_clause . 1)) (FUNCTION . (aspect_clause . 
1)) (GENERIC . (aspect_clause . 1)) (NOT . (aspect_clause . 1)) (OVERRIDING . 
(aspect_clause . 1)) (PACKAGE . (aspect_clause . 1)) (PRAGMA . (aspect_clause . 
1)) (PROCEDURE . (aspect_clause . 1)) (PROTECTED . (aspect_clause . 1)) 
(SUBTYPE . (aspect_clause . 1)) (TASK . (aspect_clause . 1)) (TYPE . 
(aspect_clause . 1)) (USE . (aspect_clause . 1)))
+      ((default . error) (END . (declaration . 4)) (PRIVATE . (declaration . 
4)) (USE . (declaration . 4)) (TYPE . (declaration . 4)) (TASK . (declaration . 
4)) (SUBTYPE . (declaration . 4)) (PROTECTED . (declaration . 4)) (PROCEDURE . 
(declaration . 4)) (PRAGMA . (declaration . 4)) (PACKAGE . (declaration . 4)) 
(OVERRIDING . (declaration . 4)) (NOT . (declaration . 4)) (GENERIC . 
(declaration . 4)) (FUNCTION . (declaration . 4)) (FOR . (declaration . 4)) 
(ENTRY . (declaration . 4)) (IDENTIFIER . (declaration . 4)) (BEGIN . 
(declaration . 4)))
+      ((default . error) (PRIVATE . (type_declaration . 0)) (END . 
(type_declaration . 0)) (BEGIN . (type_declaration . 0)) (IDENTIFIER . 
(type_declaration . 0)) (ENTRY . (type_declaration . 0)) (FOR . 
(type_declaration . 0)) (FUNCTION . (type_declaration . 0)) (GENERIC . 
(type_declaration . 0)) (NOT . (type_declaration . 0)) (OVERRIDING . 
(type_declaration . 0)) (PACKAGE . (type_declaration . 0)) (PRAGMA . 
(type_declaration . 0)) (PROCEDURE . (type_declaration . 0)) (PROTECTED . 
(type_declaration . 0)) (SUBTYPE . (type_declaration . 0)) (TASK . 
(type_declaration . 0)) (TYPE . (type_declaration . 0)) (USE . 
(type_declaration . 0)))
+      ((default . error) (END . (declaration . 5)) (PRIVATE . (declaration . 
5)) (USE . (declaration . 5)) (TYPE . (declaration . 5)) (TASK . (declaration . 
5)) (SUBTYPE . (declaration . 5)) (PROTECTED . (declaration . 5)) (PROCEDURE . 
(declaration . 5)) (PRAGMA . (declaration . 5)) (PACKAGE . (declaration . 5)) 
(OVERRIDING . (declaration . 5)) (NOT . (declaration . 5)) (GENERIC . 
(declaration . 5)) (FUNCTION . (declaration . 5)) (FOR . (declaration . 5)) 
(ENTRY . (declaration . 5)) (IDENTIFIER . (declaration . 5)) (BEGIN . 
(declaration . 5)))
+      ((default . error) (END . (declaration . 6)) (PRIVATE . (declaration . 
6)) (USE . (declaration . 6)) (TYPE . (declaration . 6)) (TASK . (declaration . 
6)) (SUBTYPE . (declaration . 6)) (PROTECTED . (declaration . 6)) (PROCEDURE . 
(declaration . 6)) (PRAGMA . (declaration . 6)) (PACKAGE . (declaration . 6)) 
(OVERRIDING . (declaration . 6)) (NOT . (declaration . 6)) (GENERIC . 
(declaration . 6)) (FUNCTION . (declaration . 6)) (FOR . (declaration . 6)) 
(ENTRY . (declaration . 6)) (IDENTIFIER . (declaration . 6)) (BEGIN . 
(declaration . 6)))
+      ((default . error) (PRIVATE . (renaming_declaration . 3)) (END . 
(renaming_declaration . 3)) (BEGIN . (renaming_declaration . 3)) (IDENTIFIER . 
(renaming_declaration . 3)) (ENTRY . (renaming_declaration . 3)) (FOR . 
(renaming_declaration . 3)) (FUNCTION . (renaming_declaration . 3)) (GENERIC . 
(renaming_declaration . 3)) (NOT . (renaming_declaration . 3)) (OVERRIDING . 
(renaming_declaration . 3)) (PACKAGE . (renaming_declaration . 3)) (PRAGMA . 
(renaming_declaration . 3)) (PROCEDURE . (renaming_declaration . 3)) (PROTECTED 
. (renaming_declaration . 3)) (SUBTYPE . (renaming_declaration . 3)) (TASK . 
(renaming_declaration . 3)) (TYPE . (renaming_declaration . 3)) (USE . 
(renaming_declaration . 3)))
+      ((default . error) (COMMA .  92) (COLON .  409))
+      ((default . error) (PRIVATE . (type_declaration . 1)) (END . 
(type_declaration . 1)) (BEGIN . (type_declaration . 1)) (IDENTIFIER . 
(type_declaration . 1)) (ENTRY . (type_declaration . 1)) (FOR . 
(type_declaration . 1)) (FUNCTION . (type_declaration . 1)) (GENERIC . 
(type_declaration . 1)) (NOT . (type_declaration . 1)) (OVERRIDING . 
(type_declaration . 1)) (PACKAGE . (type_declaration . 1)) (PRAGMA . 
(type_declaration . 1)) (PROCEDURE . (type_declaration . 1)) (PROTECTED . 
(type_declaration . 1)) (SUBTYPE . (type_declaration . 1)) (TASK . 
(type_declaration . 1)) (TYPE . (type_declaration . 1)) (USE . 
(type_declaration . 1)))
+      ((default . error) (END . (declaration . 7)) (PRIVATE . (declaration . 
7)) (USE . (declaration . 7)) (TYPE . (declaration . 7)) (TASK . (declaration . 
7)) (SUBTYPE . (declaration . 7)) (PROTECTED . (declaration . 7)) (PROCEDURE . 
(declaration . 7)) (PRAGMA . (declaration . 7)) (PACKAGE . (declaration . 7)) 
(OVERRIDING . (declaration . 7)) (NOT . (declaration . 7)) (GENERIC . 
(declaration . 7)) (FUNCTION . (declaration . 7)) (FOR . (declaration . 7)) 
(ENTRY . (declaration . 7)) (IDENTIFIER . (declaration . 7)) (BEGIN . 
(declaration . 7)))
+      ((default . error) (END . (declaration . 9)) (PRIVATE . (declaration . 
9)) (USE . (declaration . 9)) (TYPE . (declaration . 9)) (TASK . (declaration . 
9)) (SUBTYPE . (declaration . 9)) (PROTECTED . (declaration . 9)) (PROCEDURE . 
(declaration . 9)) (PRAGMA . (declaration . 9)) (PACKAGE . (declaration . 9)) 
(OVERRIDING . (declaration . 9)) (NOT . (declaration . 9)) (GENERIC . 
(declaration . 9)) (FUNCTION . (declaration . 9)) (FOR . (declaration . 9)) 
(ENTRY . (declaration . 9)) (IDENTIFIER . (declaration . 9)) (BEGIN . 
(declaration . 9)))
+      ((default . error) (PRIVATE . (renaming_declaration . 0)) (END . 
(renaming_declaration . 0)) (BEGIN . (renaming_declaration . 0)) (IDENTIFIER . 
(renaming_declaration . 0)) (ENTRY . (renaming_declaration . 0)) (FOR . 
(renaming_declaration . 0)) (FUNCTION . (renaming_declaration . 0)) (GENERIC . 
(renaming_declaration . 0)) (NOT . (renaming_declaration . 0)) (OVERRIDING . 
(renaming_declaration . 0)) (PACKAGE . (renaming_declaration . 0)) (PRAGMA . 
(renaming_declaration . 0)) (PROCEDURE . (renaming_declaration . 0)) (PROTECTED 
. (renaming_declaration . 0)) (SUBTYPE . (renaming_declaration . 0)) (TASK . 
(renaming_declaration . 0)) (TYPE . (renaming_declaration . 0)) (USE . 
(renaming_declaration . 0)))
+      ((default . error) (ENTRY .  406) (FUNCTION .  37) (PROCEDURE .  38))
+      ((default . error) ($EOI . (proper_body . 1)) (LIMITED . (proper_body . 
1)) (SEPARATE . (proper_body . 1)) (WITH . (proper_body . 1)) (END . 
(proper_body . 1)) (PRIVATE . (proper_body . 1)) (USE . (proper_body . 1)) 
(TYPE . (proper_body . 1)) (TASK . (proper_body . 1)) (SUBTYPE . (proper_body . 
1)) (PROTECTED . (proper_body . 1)) (PROCEDURE . (proper_body . 1)) (PRAGMA . 
(proper_body . 1)) (PACKAGE . (proper_body . 1)) (OVERRIDING . (proper_body . 
1)) (NOT . (proper_body . 1)) (GENERIC . (proper_body . 1)) (FUNCTION . 
(proper_body . 1)) (FOR . (proper_body . 1)) (ENTRY . (proper_body . 1)) 
(IDENTIFIER . (proper_body . 1)) (BEGIN . (proper_body . 1)))
+      ((default . error) (END . (body_stub . 1)) (PRIVATE . (body_stub . 1)) 
(USE . (body_stub . 1)) (TYPE . (body_stub . 1)) (TASK . (body_stub . 1)) 
(SUBTYPE . (body_stub . 1)) (PROTECTED . (body_stub . 1)) (PROCEDURE . 
(body_stub . 1)) (PRAGMA . (body_stub . 1)) (PACKAGE . (body_stub . 1)) 
(OVERRIDING . (body_stub . 1)) (NOT . (body_stub . 1)) (GENERIC . (body_stub . 
1)) (FUNCTION . (body_stub . 1)) (FOR . (body_stub . 1)) (ENTRY . (body_stub . 
1)) (IDENTIFIER . (body_stub . 1)) (BEGIN . (body_stub . 1)))
+      ((default . error) (END . (declaration . 10)) (PRIVATE . (declaration . 
10)) (USE . (declaration . 10)) (TYPE . (declaration . 10)) (TASK . 
(declaration . 10)) (SUBTYPE . (declaration . 10)) (PROTECTED . (declaration . 
10)) (PROCEDURE . (declaration . 10)) (PRAGMA . (declaration . 10)) (PACKAGE . 
(declaration . 10)) (OVERRIDING . (declaration . 10)) (NOT . (declaration . 
10)) (GENERIC . (declaration . 10)) (FUNCTION . (declaration . 10)) (FOR . 
(declaration . 10)) (ENTRY . (declaration . 10)) (IDENTIFIER . (declaration . 
10)) (BEGIN . (declaration . 10)))
+      ((default . error) (PRIVATE . (renaming_declaration . 1)) (END . 
(renaming_declaration . 1)) (BEGIN . (renaming_declaration . 1)) (IDENTIFIER . 
(renaming_declaration . 1)) (ENTRY . (renaming_declaration . 1)) (FOR . 
(renaming_declaration . 1)) (FUNCTION . (renaming_declaration . 1)) (GENERIC . 
(renaming_declaration . 1)) (NOT . (renaming_declaration . 1)) (OVERRIDING . 
(renaming_declaration . 1)) (PACKAGE . (renaming_declaration . 1)) (PRAGMA . 
(renaming_declaration . 1)) (PROCEDURE . (renaming_declaration . 1)) (PROTECTED 
. (renaming_declaration . 1)) (SUBTYPE . (renaming_declaration . 1)) (TASK . 
(renaming_declaration . 1)) (TYPE . (renaming_declaration . 1)) (USE . 
(renaming_declaration . 1)))
+      ((default . error) (END . (declaration . 11)) (PRIVATE . (declaration . 
11)) (USE . (declaration . 11)) (TYPE . (declaration . 11)) (TASK . 
(declaration . 11)) (SUBTYPE . (declaration . 11)) (PROTECTED . (declaration . 
11)) (PROCEDURE . (declaration . 11)) (PRAGMA . (declaration . 11)) (PACKAGE . 
(declaration . 11)) (OVERRIDING . (declaration . 11)) (NOT . (declaration . 
11)) (GENERIC . (declaration . 11)) (FUNCTION . (declaration . 11)) (FOR . 
(declaration . 11)) (ENTRY . (declaration . 11)) (IDENTIFIER . (declaration . 
11)) (BEGIN . (declaration . 11)))
+      ((default . error) (PRIVATE . (type_declaration . 3)) (END . 
(type_declaration . 3)) (BEGIN . (type_declaration . 3)) (IDENTIFIER . 
(type_declaration . 3)) (ENTRY . (type_declaration . 3)) (FOR . 
(type_declaration . 3)) (FUNCTION . (type_declaration . 3)) (GENERIC . 
(type_declaration . 3)) (NOT . (type_declaration . 3)) (OVERRIDING . 
(type_declaration . 3)) (PACKAGE . (type_declaration . 3)) (PRAGMA . 
(type_declaration . 3)) (PROCEDURE . (type_declaration . 3)) (PROTECTED . 
(type_declaration . 3)) (SUBTYPE . (type_declaration . 3)) (TASK . 
(type_declaration . 3)) (TYPE . (type_declaration . 3)) (USE . 
(type_declaration . 3)))
+      ((default . error) (PRIVATE . (type_declaration . 2)) (END . 
(type_declaration . 2)) (BEGIN . (type_declaration . 2)) (IDENTIFIER . 
(type_declaration . 2)) (ENTRY . (type_declaration . 2)) (FOR . 
(type_declaration . 2)) (FUNCTION . (type_declaration . 2)) (GENERIC . 
(type_declaration . 2)) (NOT . (type_declaration . 2)) (OVERRIDING . 
(type_declaration . 2)) (PACKAGE . (type_declaration . 2)) (PRAGMA . 
(type_declaration . 2)) (PROCEDURE . (type_declaration . 2)) (PROTECTED . 
(type_declaration . 2)) (SUBTYPE . (type_declaration . 2)) (TASK . 
(type_declaration . 2)) (TYPE . (type_declaration . 2)) (USE . 
(type_declaration . 2)))
+      ((default . error) (PRIVATE . (body . 0)) (END . (body . 0)) (BEGIN . 
(body . 0)) (IDENTIFIER . (body . 0)) (ENTRY . (body . 0)) (FOR . (body . 0)) 
(FUNCTION . (body . 0)) (GENERIC . (body . 0)) (NOT . (body . 0)) (OVERRIDING . 
(body . 0)) (PACKAGE . (body . 0)) (PRAGMA . (body . 0)) (PROCEDURE . (body . 
0)) (PROTECTED . (body . 0)) (SUBTYPE . (body . 0)) (TASK . (body . 0)) (TYPE . 
(body . 0)) (USE . (body . 0)))
+      ((default . error) ($EOI . (proper_body . 3)) (LIMITED . (proper_body . 
3)) (SEPARATE . (proper_body . 3)) (WITH . (proper_body . 3)) (END . 
(proper_body . 3)) (PRIVATE . (proper_body . 3)) (USE . (proper_body . 3)) 
(TYPE . (proper_body . 3)) (TASK . (proper_body . 3)) (SUBTYPE . (proper_body . 
3)) (PROTECTED . (proper_body . 3)) (PROCEDURE . (proper_body . 3)) (PRAGMA . 
(proper_body . 3)) (PACKAGE . (proper_body . 3)) (OVERRIDING . (proper_body . 
3)) (NOT . (proper_body . 3)) (GENERIC . (proper_body . 3)) (FUNCTION . 
(proper_body . 3)) (FOR . (proper_body . 3)) (ENTRY . (proper_body . 3)) 
(IDENTIFIER . (proper_body . 3)) (BEGIN . (proper_body . 3)))
+      ((default . error) (END . (body_stub . 3)) (PRIVATE . (body_stub . 3)) 
(USE . (body_stub . 3)) (TYPE . (body_stub . 3)) (TASK . (body_stub . 3)) 
(SUBTYPE . (body_stub . 3)) (PROTECTED . (body_stub . 3)) (PROCEDURE . 
(body_stub . 3)) (PRAGMA . (body_stub . 3)) (PACKAGE . (body_stub . 3)) 
(OVERRIDING . (body_stub . 3)) (NOT . (body_stub . 3)) (GENERIC . (body_stub . 
3)) (FUNCTION . (body_stub . 3)) (FOR . (body_stub . 3)) (ENTRY . (body_stub . 
3)) (IDENTIFIER . (body_stub . 3)) (BEGIN . (body_stub . 3)))
+      ((default . error) (END . (full_type_declaration . 2)) (PRIVATE . 
(full_type_declaration . 2)) (USE . (full_type_declaration . 2)) (TYPE . 
(full_type_declaration . 2)) (TASK . (full_type_declaration . 2)) (SUBTYPE . 
(full_type_declaration . 2)) (PROTECTED . (full_type_declaration . 2)) 
(PROCEDURE . (full_type_declaration . 2)) (PRAGMA . (full_type_declaration . 
2)) (PACKAGE . (full_type_declaration . 2)) (OVERRIDING . 
(full_type_declaration . 2)) (NOT . (full_type_declaration . 2)) (GENERIC . 
(full_type_declaration . 2)) (FUNCTION . (full_type_declaration . 2)) (FOR . 
(full_type_declaration . 2)) (ENTRY . (full_type_declaration . 2)) (IDENTIFIER 
. (full_type_declaration . 2)) (BEGIN . (full_type_declaration . 2)))
+      ((default . error) (WHEN . (aspect_clause . 2)) (PRIVATE . 
(aspect_clause . 2)) (END . (aspect_clause . 2)) (CASE . (aspect_clause . 2)) 
(BEGIN . (aspect_clause . 2)) (IDENTIFIER . (aspect_clause . 2)) (ENTRY . 
(aspect_clause . 2)) (FOR . (aspect_clause . 2)) (FUNCTION . (aspect_clause . 
2)) (GENERIC . (aspect_clause . 2)) (NOT . (aspect_clause . 2)) (OVERRIDING . 
(aspect_clause . 2)) (PACKAGE . (aspect_clause . 2)) (PRAGMA . (aspect_clause . 
2)) (PROCEDURE . (aspect_clause . 2)) (PROTECTED . (aspect_clause . 2)) 
(SUBTYPE . (aspect_clause . 2)) (TASK . (aspect_clause . 2)) (TYPE . 
(aspect_clause . 2)) (USE . (aspect_clause . 2)))
+      ((default . error) (END . (declaration . 12)) (PRIVATE . (declaration . 
12)) (USE . (declaration . 12)) (TYPE . (declaration . 12)) (TASK . 
(declaration . 12)) (SUBTYPE . (declaration . 12)) (PROTECTED . (declaration . 
12)) (PROCEDURE . (declaration . 12)) (PRAGMA . (declaration . 12)) (PACKAGE . 
(declaration . 12)) (OVERRIDING . (declaration . 12)) (NOT . (declaration . 
12)) (GENERIC . (declaration . 12)) (FUNCTION . (declaration . 12)) (FOR . 
(declaration . 12)) (ENTRY . (declaration . 12)) (IDENTIFIER . (declaration . 
12)) (BEGIN . (declaration . 12)))
+      ((default . error) (PRIVATE . (object_declaration . 7)) (END . 
(object_declaration . 7)) (BEGIN . (object_declaration . 7)) (IDENTIFIER . 
(object_declaration . 7)) (ENTRY . (object_declaration . 7)) (FOR . 
(object_declaration . 7)) (FUNCTION . (object_declaration . 7)) (GENERIC . 
(object_declaration . 7)) (NOT . (object_declaration . 7)) (OVERRIDING . 
(object_declaration . 7)) (PACKAGE . (object_declaration . 7)) (PRAGMA . 
(object_declaration . 7)) (PROCEDURE . (object_declaration . 7)) (PROTECTED . 
(object_declaration . 7)) (SUBTYPE . (object_declaration . 7)) (TASK . 
(object_declaration . 7)) (TYPE . (object_declaration . 7)) (USE . 
(object_declaration . 7)))
+      ((default . error) (PRIVATE . (object_declaration . 6)) (END . 
(object_declaration . 6)) (BEGIN . (object_declaration . 6)) (IDENTIFIER . 
(object_declaration . 6)) (ENTRY . (object_declaration . 6)) (FOR . 
(object_declaration . 6)) (FUNCTION . (object_declaration . 6)) (GENERIC . 
(object_declaration . 6)) (NOT . (object_declaration . 6)) (OVERRIDING . 
(object_declaration . 6)) (PACKAGE . (object_declaration . 6)) (PRAGMA . 
(object_declaration . 6)) (PROCEDURE . (object_declaration . 6)) (PROTECTED . 
(object_declaration . 6)) (SUBTYPE . (object_declaration . 6)) (TASK . 
(object_declaration . 6)) (TYPE . (object_declaration . 6)) (USE . 
(object_declaration . 6)))
+      ((default . error) ($EOI . (proper_body . 0)) (LIMITED . (proper_body . 
0)) (SEPARATE . (proper_body . 0)) (WITH . (proper_body . 0)) (END . 
(proper_body . 0)) (PRIVATE . (proper_body . 0)) (USE . (proper_body . 0)) 
(TYPE . (proper_body . 0)) (TASK . (proper_body . 0)) (SUBTYPE . (proper_body . 
0)) (PROTECTED . (proper_body . 0)) (PROCEDURE . (proper_body . 0)) (PRAGMA . 
(proper_body . 0)) (PACKAGE . (proper_body . 0)) (OVERRIDING . (proper_body . 
0)) (NOT . (proper_body . 0)) (GENERIC . (proper_body . 0)) (FUNCTION . 
(proper_body . 0)) (FOR . (proper_body . 0)) (ENTRY . (proper_body . 0)) 
(IDENTIFIER . (proper_body . 0)) (BEGIN . (proper_body . 0)))
+      ((default . error) (END . (body_stub . 0)) (PRIVATE . (body_stub . 0)) 
(USE . (body_stub . 0)) (TYPE . (body_stub . 0)) (TASK . (body_stub . 0)) 
(SUBTYPE . (body_stub . 0)) (PROTECTED . (body_stub . 0)) (PROCEDURE . 
(body_stub . 0)) (PRAGMA . (body_stub . 0)) (PACKAGE . (body_stub . 0)) 
(OVERRIDING . (body_stub . 0)) (NOT . (body_stub . 0)) (GENERIC . (body_stub . 
0)) (FUNCTION . (body_stub . 0)) (FOR . (body_stub . 0)) (ENTRY . (body_stub . 
0)) (IDENTIFIER . (body_stub . 0)) (BEGIN . (body_stub . 0)))
+      ((default . error) (END . (declaration . 13)) (PRIVATE . (declaration . 
13)) (USE . (declaration . 13)) (TYPE . (declaration . 13)) (TASK . 
(declaration . 13)) (SUBTYPE . (declaration . 13)) (PROTECTED . (declaration . 
13)) (PROCEDURE . (declaration . 13)) (PRAGMA . (declaration . 13)) (PACKAGE . 
(declaration . 13)) (OVERRIDING . (declaration . 13)) (NOT . (declaration . 
13)) (GENERIC . (declaration . 13)) (FUNCTION . (declaration . 13)) (FOR . 
(declaration . 13)) (ENTRY . (declaration . 13)) (IDENTIFIER . (declaration . 
13)) (BEGIN . (declaration . 13)))
+      ((default . error) (PRIVATE . (renaming_declaration . 2)) (END . 
(renaming_declaration . 2)) (BEGIN . (renaming_declaration . 2)) (IDENTIFIER . 
(renaming_declaration . 2)) (ENTRY . (renaming_declaration . 2)) (FOR . 
(renaming_declaration . 2)) (FUNCTION . (renaming_declaration . 2)) (GENERIC . 
(renaming_declaration . 2)) (NOT . (renaming_declaration . 2)) (OVERRIDING . 
(renaming_declaration . 2)) (PACKAGE . (renaming_declaration . 2)) (PRAGMA . 
(renaming_declaration . 2)) (PROCEDURE . (renaming_declaration . 2)) (PROTECTED 
. (renaming_declaration . 2)) (SUBTYPE . (renaming_declaration . 2)) (TASK . 
(renaming_declaration . 2)) (TYPE . (renaming_declaration . 2)) (USE . 
(renaming_declaration . 2)))
+      ((default . error) (END . (declaration . 14)) (PRIVATE . (declaration . 
14)) (USE . (declaration . 14)) (TYPE . (declaration . 14)) (TASK . 
(declaration . 14)) (SUBTYPE . (declaration . 14)) (PROTECTED . (declaration . 
14)) (PROCEDURE . (declaration . 14)) (PRAGMA . (declaration . 14)) (PACKAGE . 
(declaration . 14)) (OVERRIDING . (declaration . 14)) (NOT . (declaration . 
14)) (GENERIC . (declaration . 14)) (FUNCTION . (declaration . 14)) (FOR . 
(declaration . 14)) (ENTRY . (declaration . 14)) (IDENTIFIER . (declaration . 
14)) (BEGIN . (declaration . 14)))
+      ((default . error) ($EOI . (proper_body . 2)) (LIMITED . (proper_body . 
2)) (SEPARATE . (proper_body . 2)) (WITH . (proper_body . 2)) (END . 
(proper_body . 2)) (PRIVATE . (proper_body . 2)) (USE . (proper_body . 2)) 
(TYPE . (proper_body . 2)) (TASK . (proper_body . 2)) (SUBTYPE . (proper_body . 
2)) (PROTECTED . (proper_body . 2)) (PROCEDURE . (proper_body . 2)) (PRAGMA . 
(proper_body . 2)) (PACKAGE . (proper_body . 2)) (OVERRIDING . (proper_body . 
2)) (NOT . (proper_body . 2)) (GENERIC . (proper_body . 2)) (FUNCTION . 
(proper_body . 2)) (FOR . (proper_body . 2)) (ENTRY . (proper_body . 2)) 
(IDENTIFIER . (proper_body . 2)) (BEGIN . (proper_body . 2)))
+      ((default . error) (END . (body_stub . 2)) (PRIVATE . (body_stub . 2)) 
(USE . (body_stub . 2)) (TYPE . (body_stub . 2)) (TASK . (body_stub . 2)) 
(SUBTYPE . (body_stub . 2)) (PROTECTED . (body_stub . 2)) (PROCEDURE . 
(body_stub . 2)) (PRAGMA . (body_stub . 2)) (PACKAGE . (body_stub . 2)) 
(OVERRIDING . (body_stub . 2)) (NOT . (body_stub . 2)) (GENERIC . (body_stub . 
2)) (FUNCTION . (body_stub . 2)) (FOR . (body_stub . 2)) (ENTRY . (body_stub . 
2)) (IDENTIFIER . (body_stub . 2)) (BEGIN . (body_stub . 2)))
+      ((default . error) (END . (full_type_declaration . 1)) (PRIVATE . 
(full_type_declaration . 1)) (USE . (full_type_declaration . 1)) (TYPE . 
(full_type_declaration . 1)) (TASK . (full_type_declaration . 1)) (SUBTYPE . 
(full_type_declaration . 1)) (PROTECTED . (full_type_declaration . 1)) 
(PROCEDURE . (full_type_declaration . 1)) (PRAGMA . (full_type_declaration . 
1)) (PACKAGE . (full_type_declaration . 1)) (OVERRIDING . 
(full_type_declaration . 1)) (NOT . (full_type_declaration . 1)) (GENERIC . 
(full_type_declaration . 1)) (FUNCTION . (full_type_declaration . 1)) (FOR . 
(full_type_declaration . 1)) (ENTRY . (full_type_declaration . 1)) (IDENTIFIER 
. (full_type_declaration . 1)) (BEGIN . (full_type_declaration . 1)))
+      ((default . error) (END . (declaration . 15)) (PRIVATE . (declaration . 
15)) (USE . (declaration . 15)) (TYPE . (declaration . 15)) (TASK . 
(declaration . 15)) (SUBTYPE . (declaration . 15)) (PROTECTED . (declaration . 
15)) (PROCEDURE . (declaration . 15)) (PRAGMA . (declaration . 15)) (PACKAGE . 
(declaration . 15)) (OVERRIDING . (declaration . 15)) (NOT . (declaration . 
15)) (GENERIC . (declaration . 15)) (FUNCTION . (declaration . 15)) (FOR . 
(declaration . 15)) (ENTRY . (declaration . 15)) (IDENTIFIER . (declaration . 
15)) (BEGIN . (declaration . 15)))
+      ((default . error) (END . (declaration . 16)) (PRIVATE . (declaration . 
16)) (USE . (declaration . 16)) (TYPE . (declaration . 16)) (TASK . 
(declaration . 16)) (SUBTYPE . (declaration . 16)) (PROTECTED . (declaration . 
16)) (PROCEDURE . (declaration . 16)) (PRAGMA . (declaration . 16)) (PACKAGE . 
(declaration . 16)) (OVERRIDING . (declaration . 16)) (NOT . (declaration . 
16)) (GENERIC . (declaration . 16)) (FUNCTION . (declaration . 16)) (FOR . 
(declaration . 16)) (ENTRY . (declaration . 16)) (IDENTIFIER . (declaration . 
16)) (BEGIN . (declaration . 16)))
+      ((default . error) (BEGIN . (declarative_part_opt . 0)) (END . 
(declarative_part_opt . 0)) (USE .  11) (SUBTYPE .  282) (PRAGMA .  7) (NOT .  
4) (OVERRIDING .  5) (FUNCTION . (overriding_indicator_opt . 2)) (PROCEDURE . 
(overriding_indicator_opt . 2)) (ENTRY . (overriding_indicator_opt . 2)) (FOR . 
 279) (IDENTIFIER .  278) (TYPE .  284) (GENERIC .  2) (PROTECTED .  281) (TASK 
.  283) (PACKAGE .  280))
+      ((default . error) (COLON_EQUAL . (simple_expression . 0)) (OF . 
(simple_expression . 0)) (LOOP . (simple_expression . 0)) (DO . 
(simple_expression . 0)) (DOT_DOT . (simple_expression . 0)) (SEMICOLON . 
(simple_expression . 0)) (XOR . (simple_expression . 0)) (OR . 
(simple_expression . 0)) (AND . (simple_expression . 0)) (SLASH_EQUAL . 
(simple_expression . 0)) (LESS_EQUAL . (simple_expression . 0)) (LESS . 
(simple_expression . 0)) (GREATER_EQUAL . (simple_expression . 0)) (GREATER . 
(simple_expression . 0)) (EQUAL . (simple_expression . 0)) (NOT . 
(simple_expression . 0)) (IN . (simple_expression . 0)) (IS . 
(simple_expression . 0)) (EQUAL_GREATER . (simple_expression . 0)) (BAR . 
(simple_expression . 0)) (WITH . (simple_expression . 0)) (THEN . 
(simple_expression . 0)) (RANGE . (simple_expression . 0)) (COMMA . 
(simple_expression . 0)) (RIGHT_PAREN . (simple_expression . 0)) (DIGITS . 
(simple_expression . 0)) (ELSE . (simple_expression . 0)) (ELSIF . 
(simple_expression . 0)) (PLUS .  335) (MINUS .  334) (AMPERSAND .  333))
+      ((default . error) (IDENTIFIER . (binary_adding_operator . 2)) 
(STRING_LITERAL . (binary_adding_operator . 2)) (CHARACTER_LITERAL . 
(binary_adding_operator . 2)) (ABS . (binary_adding_operator . 2)) (LEFT_PAREN 
. (binary_adding_operator . 2)) (NEW . (binary_adding_operator . 2)) (NOT . 
(binary_adding_operator . 2)) (NULL . (binary_adding_operator . 2)))
+      ((default . error) (IDENTIFIER . (binary_adding_operator . 1)) 
(STRING_LITERAL . (binary_adding_operator . 1)) (CHARACTER_LITERAL . 
(binary_adding_operator . 1)) (ABS . (binary_adding_operator . 1)) (LEFT_PAREN 
. (binary_adding_operator . 1)) (NEW . (binary_adding_operator . 1)) (NOT . 
(binary_adding_operator . 1)) (NULL . (binary_adding_operator . 1)))
+      ((default . error) (IDENTIFIER . (binary_adding_operator . 0)) 
(STRING_LITERAL . (binary_adding_operator . 0)) (CHARACTER_LITERAL . 
(binary_adding_operator . 0)) (ABS . (binary_adding_operator . 0)) (LEFT_PAREN 
. (binary_adding_operator . 0)) (NEW . (binary_adding_operator . 0)) (NOT . 
(binary_adding_operator . 0)) (NULL . (binary_adding_operator . 0)))
+      ((default . error) (ABS .  138) (NOT .  141) (NULL .  142) (NEW .  140) 
(IDENTIFIER .  45) (CHARACTER_LITERAL .  47) (STRING_LITERAL .  46) (LEFT_PAREN 
.  139))
+      ((default . error) (IDENTIFIER . (multiplying_operator . 1)) 
(STRING_LITERAL . (multiplying_operator . 1)) (CHARACTER_LITERAL . 
(multiplying_operator . 1)) (ABS . (multiplying_operator . 1)) (LEFT_PAREN . 
(multiplying_operator . 1)) (NEW . (multiplying_operator . 1)) (NOT . 
(multiplying_operator . 1)) (NULL . (multiplying_operator . 1)))
+      ((default . error) (IDENTIFIER . (multiplying_operator . 0)) 
(STRING_LITERAL . (multiplying_operator . 0)) (CHARACTER_LITERAL . 
(multiplying_operator . 0)) (ABS . (multiplying_operator . 0)) (LEFT_PAREN . 
(multiplying_operator . 0)) (NEW . (multiplying_operator . 0)) (NOT . 
(multiplying_operator . 0)) (NULL . (multiplying_operator . 0)))
+      ((default . error) (IDENTIFIER . (multiplying_operator . 2)) 
(STRING_LITERAL . (multiplying_operator . 2)) (CHARACTER_LITERAL . 
(multiplying_operator . 2)) (ABS . (multiplying_operator . 2)) (LEFT_PAREN . 
(multiplying_operator . 2)) (NEW . (multiplying_operator . 2)) (NOT . 
(multiplying_operator . 2)) (NULL . (multiplying_operator . 2)))
+      ((default . error) (IDENTIFIER . (multiplying_operator . 3)) 
(STRING_LITERAL . (multiplying_operator . 3)) (CHARACTER_LITERAL . 
(multiplying_operator . 3)) (ABS . (multiplying_operator . 3)) (LEFT_PAREN . 
(multiplying_operator . 3)) (NEW . (multiplying_operator . 3)) (NOT . 
(multiplying_operator . 3)) (NULL . (multiplying_operator . 3)))
+      ((default . error) (ABS .  138) (NOT .  141) (NULL .  142) (NEW .  140) 
(IDENTIFIER .  45) (CHARACTER_LITERAL .  47) (STRING_LITERAL .  46) (LEFT_PAREN 
.  139))
+      ((default . error) (PLUS .  136) (MINUS .  135) (ABS .  138) (NOT .  
141) (NULL .  142) (NEW .  140) (IDENTIFIER .  45) (CHARACTER_LITERAL .  47) 
(STRING_LITERAL .  46) (LEFT_PAREN .  139))
+      ((default . error) (THEN .  400) (PLUS .  136) (MINUS .  135) (ABS .  
138) (NOT .  141) (NULL .  142) (NEW .  140) (IDENTIFIER .  45) 
(CHARACTER_LITERAL .  47) (STRING_LITERAL .  46) (LEFT_PAREN .  139))
+      ((default . error) (ELSE .  398) (PLUS .  136) (MINUS .  135) (ABS .  
138) (NOT .  141) (NULL .  142) (NEW .  140) (IDENTIFIER .  45) 
(CHARACTER_LITERAL .  47) (STRING_LITERAL .  46) (LEFT_PAREN .  139))
+      ((default . error) (PLUS .  136) (MINUS .  135) (ABS .  138) (NOT .  
141) (NULL .  142) (NEW .  140) (IDENTIFIER .  45) (CHARACTER_LITERAL .  47) 
(STRING_LITERAL .  46) (LEFT_PAREN .  139))
+      ((default . error) (PLUS .  136) (MINUS .  135) (ABS .  138) (NOT .  
141) (NULL .  142) (NEW .  140) (IDENTIFIER .  45) (CHARACTER_LITERAL .  47) 
(STRING_LITERAL .  46) (LEFT_PAREN .  139))
+      ((default . error) (ELSE .  395))
+      ((default . error) (PLUS .  136) (MINUS .  135) (ABS .  138) (NOT .  
141) (NULL .  142) (NEW .  140) (IDENTIFIER .  45) (CHARACTER_LITERAL .  47) 
(STRING_LITERAL .  46) (LEFT_PAREN .  139))
+      ((default . error) (THEN .  393))
+      ((default . error) (PLUS .  136) (MINUS .  135) (ABS .  138) (NOT .  
141) (NULL .  142) (NEW .  140) (IDENTIFIER .  45) (CHARACTER_LITERAL .  47) 
(STRING_LITERAL .  46) (LEFT_PAREN .  139))
+      ((default . error) (NULL .  142) (NEW .  140) (IDENTIFIER .  45) 
(CHARACTER_LITERAL .  47) (STRING_LITERAL .  46) (LEFT_PAREN .  139))
+      ((default . error) (PLUS .  136) (MINUS .  135) (ABS .  138) (NOT .  
141) (NULL .  142) (NEW .  140) (IDENTIFIER .  137) (CHARACTER_LITERAL .  47) 
(STRING_LITERAL .  46) (LEFT_PAREN .  139))
+      ((default . error) (SEMICOLON .  389))
+      ((default . error) (DOT .  84) (TICK .  85) (COLON_EQUAL . (primary . 
3)) (OF . (primary . 3)) (LOOP . (primary . 3)) (DO . (primary . 3)) (STAR_STAR 
. (primary . 3)) (REM . (primary . 3)) (MOD . (primary . 3)) (STAR . (primary . 
3)) (SLASH . (primary . 3)) (DOT_DOT . (primary . 3)) (AMPERSAND . (primary . 
3)) (MINUS . (primary . 3)) (PLUS . (primary . 3)) (SEMICOLON . (primary . 3)) 
(XOR . (primary . 3)) (OR . (primary . 3)) (AND . (primary . 3)) (SLASH_EQUAL . 
(primary . 3)) (LESS_EQUAL . (primary . 3)) (LESS . (primary . 3)) 
(GREATER_EQUAL . (primary . 3)) (GREATER . (primary . 3)) (EQUAL . (primary . 
3)) (NOT . (primary . 3)) (IN . (primary . 3)) (IS . (primary . 3)) 
(EQUAL_GREATER . (primary . 3)) (BAR . (primary . 3)) (WITH . (primary . 3)) 
(THEN . (primary . 3)) (RANGE . (primary . 3)) (COMMA . (primary . 3)) 
(RIGHT_PAREN . (primary . 3)) (DIGITS . (primary . 3)) (ELSE . (primary . 3)) 
(ELSIF . (primary . 3)) (LEFT_PAREN .  103))
+      ((default . error) (PLUS .  136) (MINUS .  135) (ABS .  138) (NOT .  
141) (NULL .  142) (NEW .  140) (IDENTIFIER .  45) (CHARACTER_LITERAL .  47) 
(STRING_LITERAL .  46) (LEFT_PAREN .  139))
+      ((default . error) (ALL .  385) (SOME .  386))
+      ((default . error) (PLUS .  136) (MINUS .  135) (ABS .  138) (NOT .  
141) (NULL .  142) (NEW .  140) (IDENTIFIER .  45) (CHARACTER_LITERAL .  47) 
(STRING_LITERAL .  46) (LEFT_PAREN .  139))
+      ((default . error) (RIGHT_PAREN .  383))
+      ((default . error) (RIGHT_PAREN .  382))
+      ((default . error) (RIGHT_PAREN .  381))
+      ((default . error) (COLON_EQUAL . (factor . 2)) (OF . (factor . 2)) 
(LOOP . (factor . 2)) (DO . (factor . 2)) (PLUS . (factor . 2)) (MINUS . 
(factor . 2)) (AMPERSAND . (factor . 2)) (DOT_DOT . (factor . 2)) (SLASH . 
(factor . 2)) (STAR . (factor . 2)) (MOD . (factor . 2)) (REM . (factor . 2)) 
(SEMICOLON . (factor . 2)) (XOR . (factor . 2)) (OR . (factor . 2)) (AND . 
(factor . 2)) (IN . (factor . 2)) (NOT . (factor . 2)) (EQUAL . (factor . 2)) 
(GREATER . (factor . 2)) (GREATER_EQUAL . (factor . 2)) (LESS . (factor . 2)) 
(LESS_EQUAL . (factor . 2)) (SLASH_EQUAL . (factor . 2)) (IS . (factor . 2)) 
(EQUAL_GREATER . (factor . 2)) (BAR . (factor . 2)) (WITH . (factor . 2)) (THEN 
. (factor . 2)) (RANGE . (factor . 2)) (RIGHT_PAREN . (factor . 2)) (COMMA . 
(factor . 2)) (DIGITS . (factor . 2)) (ELSE . (factor . 2)) (ELSIF . (factor . 
2)))
+      ((default . error) (PLUS .  136) (MINUS .  135) (ABS .  138) (NOT .  
141) (NULL .  142) (NEW .  140) (IDENTIFIER .  45) (CHARACTER_LITERAL .  47) 
(STRING_LITERAL .  46) (LEFT_PAREN .  139))
+      ((default . error) (IDENTIFIER .  379))
+      ((default . error) (BODY .  64))
+      ((default . error) (BODY .  378))
+      ((default . error) (BODY .  377))
+      ((default . error) (FUNCTION .  1) (PROCEDURE .  9))
+      ((default . error) ($EOI . (subunit . 0)) (FUNCTION . (subunit . 0)) 
(GENERIC . (subunit . 0)) (LIMITED . (subunit . 0)) (NOT . (subunit . 0)) 
(OVERRIDING . (subunit . 0)) (PACKAGE . (subunit . 0)) (PRAGMA . (subunit . 0)) 
(PRIVATE . (subunit . 0)) (PROCEDURE . (subunit . 0)) (SEPARATE . (subunit . 
0)) (USE . (subunit . 0)) (WITH . (subunit . 0)))
+      ((default . error) (WITH . (use_clause . 1)) (SEPARATE . (use_clause . 
1)) (LIMITED . (use_clause . 1)) ($EOI . (use_clause . 1)) (PRIVATE . 
(use_clause . 1)) (END . (use_clause . 1)) (BEGIN . (use_clause . 1)) 
(IDENTIFIER . (use_clause . 1)) (ENTRY . (use_clause . 1)) (FOR . (use_clause . 
1)) (FUNCTION . (use_clause . 1)) (GENERIC . (use_clause . 1)) (NOT . 
(use_clause . 1)) (OVERRIDING . (use_clause . 1)) (PACKAGE . (use_clause . 1)) 
(PRAGMA . (use_clause . 1)) (PROCEDURE . (use_clause . 1)) (PROTECTED . 
(use_clause . 1)) (SUBTYPE . (use_clause . 1)) (TASK . (use_clause . 1)) (TYPE 
. (use_clause . 1)) (USE . (use_clause . 1)))
+      ((default . error) (BEGIN .  375))
+      ((default . error) (IDENTIFIER .  45) (CHARACTER_LITERAL .  47) 
(STRING_LITERAL .  46))
+      ((default . error) (IDENTIFIER .  45) (CHARACTER_LITERAL .  47) 
(STRING_LITERAL .  46))
+      ((default . error) (DOT .  84) (TICK .  85) (SEMICOLON . 
(aspect_specification_opt . 0)) (WITH .  104) (LEFT_PAREN .  103))
+      ((default . error) (DOT .  84) (TICK .  85) (SEMICOLON . 
(aspect_specification_opt . 0)) (WITH .  104) (LEFT_PAREN .  103))
+      ((default . error) (END . (sequence_of_statements_opt . 0)) (EXCEPTION . 
(sequence_of_statements_opt . 0)) (ACCEPT . (label_opt . 0)) (BEGIN . 
(label_opt . 0)) (CASE . (label_opt . 0)) (DECLARE . (label_opt . 0)) (FOR . 
(label_opt . 0)) (IF . (label_opt . 0)) (LOOP . (label_opt . 0)) (RETURN . 
(label_opt . 0)) (SELECT . (label_opt . 0)) (WHILE . (label_opt . 0)) 
(STRING_LITERAL . (label_opt . 0)) (CHARACTER_LITERAL . (label_opt . 0)) (ABORT 
. (label_opt . 0)) (DELAY . (label_opt . 0)) (EXIT . (label_opt . 0)) (GOTO . 
(label_opt . 0)) (NULL . (label_opt . 0)) (PRAGMA . (label_opt . 0)) (RAISE . 
(label_opt . 0)) (REQUEUE . (label_opt . 0)) (LESS_LESS .  599) (IDENTIFIER . 
((label_opt . 0)  600)))
+      ((default . error) (IS . (aspect_specification_opt . 0)) (WITH .  104))
+      ((default . error) (IDENTIFIER .  598))
+      ((default . error) (IDENTIFIER .  597))
+      ((default . error) (EQUAL_GREATER .  596))
+      ((default . error) (COMMA . (pragma_argument_association . 0)) 
(RIGHT_PAREN . (pragma_argument_association . 0)))
+      ((default . error) (OF . (primary . 6)) (COLON_EQUAL . (primary . 6)) 
(DO . (primary . 6)) (LOOP . (primary . 6)) (ELSIF . (primary . 6)) (ELSE . 
(primary . 6)) (DIGITS . (primary . 6)) (RIGHT_PAREN . (primary . 6)) (COMMA . 
(primary . 6)) (RANGE . (primary . 6)) (THEN . (primary . 6)) (WITH . (primary 
. 6)) (BAR . (primary . 6)) (EQUAL_GREATER . (primary . 6)) (IS . (primary . 
6)) (IN . (primary . 6)) (NOT . (primary . 6)) (EQUAL . (primary . 6)) (GREATER 
. (primary . 6)) (GREATER_EQUAL . (primary . 6)) (LESS . (primary . 6)) 
(LESS_EQUAL . (primary . 6)) (SLASH_EQUAL . (primary . 6)) (AND . (primary . 
6)) (OR . (primary . 6)) (XOR . (primary . 6)) (SEMICOLON . (primary . 6)) 
(PLUS . (primary . 6)) (MINUS . (primary . 6)) (AMPERSAND . (primary . 6)) 
(DOT_DOT . (primary . 6)) (SLASH . (primary . 6)) (STAR . (primary . 6)) (MOD . 
(primary . 6)) (REM . (primary . 6)) (STAR_STAR . (primary . 6)))
+      ((default . error) (OF . (primary . 4)) (COLON_EQUAL . (primary . 4)) 
(DO . (primary . 4)) (LOOP . (primary . 4)) (ELSIF . (primary . 4)) (ELSE . 
(primary . 4)) (DIGITS . (primary . 4)) (RIGHT_PAREN . (primary . 4)) (COMMA . 
(primary . 4)) (RANGE . (primary . 4)) (THEN . (primary . 4)) (WITH . (primary 
. 4)) (BAR . (primary . 4)) (EQUAL_GREATER . (primary . 4)) (IS . (primary . 
4)) (IN . (primary . 4)) (NOT . (primary . 4)) (EQUAL . (primary . 4)) (GREATER 
. (primary . 4)) (GREATER_EQUAL . (primary . 4)) (LESS . (primary . 4)) 
(LESS_EQUAL . (primary . 4)) (SLASH_EQUAL . (primary . 4)) (AND . (primary . 
4)) (OR . (primary . 4)) (XOR . (primary . 4)) (SEMICOLON . (primary . 4)) 
(PLUS . (primary . 4)) (MINUS . (primary . 4)) (AMPERSAND . (primary . 4)) 
(DOT_DOT . (primary . 4)) (SLASH . (primary . 4)) (STAR . (primary . 4)) (MOD . 
(primary . 4)) (REM . (primary . 4)) (STAR_STAR . (primary . 4)))
+      ((default . error) (OF . (primary . 5)) (COLON_EQUAL . (primary . 5)) 
(DO . (primary . 5)) (LOOP . (primary . 5)) (ELSIF . (primary . 5)) (ELSE . 
(primary . 5)) (DIGITS . (primary . 5)) (RIGHT_PAREN . (primary . 5)) (COMMA . 
(primary . 5)) (RANGE . (primary . 5)) (THEN . (primary . 5)) (WITH . (primary 
. 5)) (BAR . (primary . 5)) (EQUAL_GREATER . (primary . 5)) (IS . (primary . 
5)) (IN . (primary . 5)) (NOT . (primary . 5)) (EQUAL . (primary . 5)) (GREATER 
. (primary . 5)) (GREATER_EQUAL . (primary . 5)) (LESS . (primary . 5)) 
(LESS_EQUAL . (primary . 5)) (SLASH_EQUAL . (primary . 5)) (AND . (primary . 
5)) (OR . (primary . 5)) (XOR . (primary . 5)) (SEMICOLON . (primary . 5)) 
(PLUS . (primary . 5)) (MINUS . (primary . 5)) (AMPERSAND . (primary . 5)) 
(DOT_DOT . (primary . 5)) (SLASH . (primary . 5)) (STAR . (primary . 5)) (MOD . 
(primary . 5)) (REM . (primary . 5)) (STAR_STAR . (primary . 5)))
+      ((default . error) (THEN .  595))
+      ((default . error) (IDENTIFIER . (quantifier . 0)))
+      ((default . error) (IDENTIFIER . (quantifier . 1)))
+      ((default . error) (IDENTIFIER .  593))
+      ((default . error) (IS .  592))
+      ((default . error) (WHEN . (pragma . 0)) (THEN . (pragma . 0)) (OR . 
(pragma . 0)) (ELSIF . (pragma . 0)) (ELSE . (pragma . 0)) (WHILE . (pragma . 
0)) (SELECT . (pragma . 0)) (RETURN . (pragma . 0)) (REQUEUE . (pragma . 0)) 
(RAISE . (pragma . 0)) (NULL . (pragma . 0)) (LOOP . (pragma . 0)) (IF . 
(pragma . 0)) (GOTO . (pragma . 0)) (EXIT . (pragma . 0)) (DELAY . (pragma . 
0)) (DECLARE . (pragma . 0)) (CASE . (pragma . 0)) (ABORT . (pragma . 0)) 
(ACCEPT . (pragma . 0)) (CHARACTER_LITERAL . (pragma . 0)) (STRING_LITERAL . 
(pragma . 0)) (LESS_LESS . (pragma . 0)) (EXCEPTION . (pragma . 0)) (USE . 
(pragma . 0)) (TYPE . (pragma . 0)) (TASK . (pragma . 0)) (SUBTYPE . (pragma . 
0)) (PROTECTED . (pragma . 0)) (PROCEDURE . (pragma . 0)) (PRAGMA . (pragma . 
0)) (PACKAGE . (pragma . 0)) (OVERRIDING . (pragma . 0)) (NOT . (pragma . 0)) 
(GENERIC . (pragma . 0)) (FUNCTION . (pragma . 0)) (FOR . (pragma . 0)) (ENTRY 
. (pragma . 0)) (IDENTIFIER . (pragma . 0)) (BEGIN . (pragma . 0)) (END . 
(pragma . 0)) (PRIVATE . (pragma . 0)) (WITH . (pragma . 0)) ($EOI . (pragma . 
0)) (LIMITED . (pragma . 0)) (SEPARATE . (pragma . 0)))
+      ((default . error) (RIGHT_PAREN . (pragma_argument_association_list . 
1)) (COMMA . (pragma_argument_association_list . 1)))
+      ((default . error) (OF . (factor . 0)) (COLON_EQUAL . (factor . 0)) (DO 
. (factor . 0)) (LOOP . (factor . 0)) (ELSIF . (factor . 0)) (ELSE . (factor . 
0)) (DIGITS . (factor . 0)) (COMMA . (factor . 0)) (RIGHT_PAREN . (factor . 0)) 
(RANGE . (factor . 0)) (THEN . (factor . 0)) (WITH . (factor . 0)) (BAR . 
(factor . 0)) (EQUAL_GREATER . (factor . 0)) (IS . (factor . 0)) (SLASH_EQUAL . 
(factor . 0)) (LESS_EQUAL . (factor . 0)) (LESS . (factor . 0)) (GREATER_EQUAL 
. (factor . 0)) (GREATER . (factor . 0)) (EQUAL . (factor . 0)) (NOT . (factor 
. 0)) (IN . (factor . 0)) (AND . (factor . 0)) (OR . (factor . 0)) (XOR . 
(factor . 0)) (SEMICOLON . (factor . 0)) (REM . (factor . 0)) (MOD . (factor . 
0)) (STAR . (factor . 0)) (SLASH . (factor . 0)) (DOT_DOT . (factor . 0)) 
(AMPERSAND . (factor . 0)) (MINUS . (factor . 0)) (PLUS . (factor . 0)))
+      ((default . error) (DO . (relation_and_list . 1)) (LOOP . 
(relation_and_list . 1)) (ELSIF . (relation_and_list . 1)) (ELSE . 
(relation_and_list . 1)) (EQUAL_GREATER . (relation_and_list . 1)) (DIGITS . 
(relation_and_list . 1)) (RIGHT_PAREN . (relation_and_list . 1)) (COMMA . 
(relation_and_list . 1)) (RANGE . (relation_and_list . 1)) (THEN . 
(relation_and_list . 1)) (SEMICOLON . (relation_and_list . 1)) (WITH . 
(relation_and_list . 1)) (IS . (relation_and_list . 1)) (AND . 
(relation_and_list . 1)))
+      ((default . error) (PLUS .  136) (MINUS .  135) (ABS .  138) (NOT .  
141) (NULL .  142) (NEW .  140) (IDENTIFIER .  45) (CHARACTER_LITERAL .  47) 
(STRING_LITERAL .  46) (LEFT_PAREN .  139))
+      ((default . error) (DO . (relation_or_list . 1)) (LOOP . 
(relation_or_list . 1)) (ELSIF . (relation_or_list . 1)) (ELSE . 
(relation_or_list . 1)) (EQUAL_GREATER . (relation_or_list . 1)) (DIGITS . 
(relation_or_list . 1)) (RIGHT_PAREN . (relation_or_list . 1)) (COMMA . 
(relation_or_list . 1)) (RANGE . (relation_or_list . 1)) (THEN . 
(relation_or_list . 1)) (SEMICOLON . (relation_or_list . 1)) (WITH . 
(relation_or_list . 1)) (IS . (relation_or_list . 1)) (OR . (relation_or_list . 
1)))
+      ((default . error) (PLUS .  136) (MINUS .  135) (ABS .  138) (NOT .  
141) (NULL .  142) (NEW .  140) (IDENTIFIER .  45) (CHARACTER_LITERAL .  47) 
(STRING_LITERAL .  46) (LEFT_PAREN .  139))
+      ((default . error) (DO . (relation_xor_list . 1)) (LOOP . 
(relation_xor_list . 1)) (ELSIF . (relation_xor_list . 1)) (ELSE . 
(relation_xor_list . 1)) (EQUAL_GREATER . (relation_xor_list . 1)) (DIGITS . 
(relation_xor_list . 1)) (RIGHT_PAREN . (relation_xor_list . 1)) (COMMA . 
(relation_xor_list . 1)) (RANGE . (relation_xor_list . 1)) (THEN . 
(relation_xor_list . 1)) (SEMICOLON . (relation_xor_list . 1)) (WITH . 
(relation_xor_list . 1)) (IS . (relation_xor_list . 1)) (XOR . 
(relation_xor_list . 1)))
+      ((default . error) (DO . (relation_xor_list . 0)) (LOOP . 
(relation_xor_list . 0)) (ELSIF . (relation_xor_list . 0)) (ELSE . 
(relation_xor_list . 0)) (EQUAL_GREATER . (relation_xor_list . 0)) (DIGITS . 
(relation_xor_list . 0)) (RIGHT_PAREN . (relation_xor_list . 0)) (COMMA . 
(relation_xor_list . 0)) (RANGE . (relation_xor_list . 0)) (THEN . 
(relation_xor_list . 0)) (SEMICOLON . (relation_xor_list . 0)) (WITH . 
(relation_xor_list . 0)) (IS . (relation_xor_list . 0)) (XOR . 
(relation_xor_list . 0)))
+      ((default . error) (PLUS .  136) (MINUS .  135) (ABS .  138) (NOT .  
141) (NULL .  142) (NEW .  140) (IDENTIFIER .  45) (CHARACTER_LITERAL .  47) 
(STRING_LITERAL .  46) (LEFT_PAREN .  139))
+      ((default . error) (DO . (relation_or_list . 0)) (LOOP . 
(relation_or_list . 0)) (ELSIF . (relation_or_list . 0)) (ELSE . 
(relation_or_list . 0)) (EQUAL_GREATER . (relation_or_list . 0)) (DIGITS . 
(relation_or_list . 0)) (RIGHT_PAREN . (relation_or_list . 0)) (COMMA . 
(relation_or_list . 0)) (RANGE . (relation_or_list . 0)) (THEN . 
(relation_or_list . 0)) (SEMICOLON . (relation_or_list . 0)) (WITH . 
(relation_or_list . 0)) (IS . (relation_or_list . 0)) (OR . (relation_or_list . 
0)))
+      ((default . error) (PLUS .  136) (MINUS .  135) (ABS .  138) (NOT .  
141) (NULL .  142) (NEW .  140) (IDENTIFIER .  45) (CHARACTER_LITERAL .  47) 
(STRING_LITERAL .  46) (LEFT_PAREN .  139))
+      ((default . error) (DO . (relation_and_list . 0)) (LOOP . 
(relation_and_list . 0)) (ELSIF . (relation_and_list . 0)) (ELSE . 
(relation_and_list . 0)) (EQUAL_GREATER . (relation_and_list . 0)) (DIGITS . 
(relation_and_list . 0)) (RIGHT_PAREN . (relation_and_list . 0)) (COMMA . 
(relation_and_list . 0)) (RANGE . (relation_and_list . 0)) (THEN . 
(relation_and_list . 0)) (SEMICOLON . (relation_and_list . 0)) (WITH . 
(relation_and_list . 0)) (IS . (relation_and_list . 0)) (AND . 
(relation_and_list . 0)))
+      ((default . error) (DO . (relation . 1)) (LOOP . (relation . 1)) (COMMA 
. (relation . 1)) (RIGHT_PAREN . (relation . 1)) (ELSIF . (relation . 1)) (ELSE 
. (relation . 1)) (EQUAL_GREATER . (relation . 1)) (DIGITS . (relation . 1)) 
(RANGE . (relation . 1)) (THEN . (relation . 1)) (SEMICOLON . (relation . 1)) 
(WITH . (relation . 1)) (IS . (relation . 1)) (AND . (relation . 1)) (OR . 
(relation . 1)) (XOR . (relation . 1)))
+      ((default . error) (OF . (term . 1)) (COLON_EQUAL . (term . 1)) (DO . 
(term . 1)) (LOOP . (term . 1)) (ELSIF . (term . 1)) (ELSE . (term . 1)) 
(DIGITS . (term . 1)) (RIGHT_PAREN . (term . 1)) (COMMA . (term . 1)) (RANGE . 
(term . 1)) (THEN . (term . 1)) (WITH . (term . 1)) (BAR . (term . 1)) 
(EQUAL_GREATER . (term . 1)) (IS . (term . 1)) (IN . (term . 1)) (NOT . (term . 
1)) (EQUAL . (term . 1)) (GREATER . (term . 1)) (GREATER_EQUAL . (term . 1)) 
(LESS . (term . 1)) (LESS_EQUAL . (term . 1)) (SLASH_EQUAL . (term . 1)) (AND . 
(term . 1)) (OR . (term . 1)) (XOR . (term . 1)) (SEMICOLON . (term . 1)) (PLUS 
. (term . 1)) (MINUS . (term . 1)) (AMPERSAND . (term . 1)) (DOT_DOT . (term . 
1)) (SLASH . (term . 1)) (STAR . (term . 1)) (MOD . (term . 1)) (REM . (term . 
1)))
+      ((default . error) (OF . (term_list . 1)) (COLON_EQUAL . (term_list . 
1)) (DO . (term_list . 1)) (LOOP . (term_list . 1)) (ELSIF . (term_list . 1)) 
(ELSE . (term_list . 1)) (DIGITS . (term_list . 1)) (COMMA . (term_list . 1)) 
(RIGHT_PAREN . (term_list . 1)) (RANGE . (term_list . 1)) (THEN . (term_list . 
1)) (WITH . (term_list . 1)) (BAR . (term_list . 1)) (EQUAL_GREATER . 
(term_list . 1)) (IS . (term_list . 1)) (SLASH_EQUAL . (term_list . 1)) 
(LESS_EQUAL . (term_list . 1)) (LESS . (term_list . 1)) (GREATER_EQUAL . 
(term_list . 1)) (GREATER . (term_list . 1)) (EQUAL . (term_list . 1)) (NOT . 
(term_list . 1)) (IN . (term_list . 1)) (AND . (term_list . 1)) (OR . 
(term_list . 1)) (XOR . (term_list . 1)) (SEMICOLON . (term_list . 1)) (DOT_DOT 
. (term_list . 1)) (AMPERSAND . (term_list . 1)) (MINUS . (term_list . 1)) 
(PLUS . (term_list . 1)) (STAR .  338) (SLASH .  337) (MOD .  339) (REM .  340))
+      ((default . error) (BEGIN .  586) (END .  587))
+      ((default . error) (IDENTIFIER .  585))
+      ((default . error) (WITH . (subprogram_specification . 0)) (IS . ( 584 
(subprogram_specification . 0))) (SEMICOLON . (subprogram_specification . 0)) 
(RENAMES . (subprogram_specification . 0)))
+      ((default . error) (SEMICOLON .  122) (RENAMES .  583) (IS . ( 582 
(aspect_specification_opt . 0))) (WITH .  104))
+      ((default . error) (EXCEPTION .  580) (CONSTANT . ( 579 (aliased_opt . 
0))) (ARRAY . (aliased_opt . 0)) (ACCESS . (aliased_opt . 0)) (NOT . 
(aliased_opt . 0)) (IDENTIFIER . (aliased_opt . 0)) (STRING_LITERAL . 
(aliased_opt . 0)) (CHARACTER_LITERAL . (aliased_opt . 0)) (ALIASED .  499))
+      ((default . error) (IDENTIFIER .  45) (CHARACTER_LITERAL .  47) 
(STRING_LITERAL .  46))
+      ((default . error) (END . (declarative_part_opt . 0)) (USE .  11) 
(SUBTYPE .  282) (PRAGMA .  7) (NOT .  4) (OVERRIDING .  5) (FUNCTION . 
(overriding_indicator_opt . 2)) (PROCEDURE . (overriding_indicator_opt . 2)) 
(ENTRY . (overriding_indicator_opt . 2)) (FOR .  279) (IDENTIFIER .  278) (TYPE 
.  284) (GENERIC .  2) (PROTECTED .  281) (TASK .  283) (PACKAGE .  280))
+      ((default . error) (USE . (declarations . 1)) (TYPE . (declarations . 
1)) (TASK . (declarations . 1)) (SUBTYPE . (declarations . 1)) (PROTECTED . 
(declarations . 1)) (PROCEDURE . (declarations . 1)) (PRAGMA . (declarations . 
1)) (PACKAGE . (declarations . 1)) (OVERRIDING . (declarations . 1)) (NOT . 
(declarations . 1)) (GENERIC . (declarations . 1)) (FUNCTION . (declarations . 
1)) (FOR . (declarations . 1)) (ENTRY . (declarations . 1)) (IDENTIFIER . 
(declarations . 1)) (BEGIN . (declarations . 1)) (END . (declarations . 1)) 
(PRIVATE . (declarations . 1)))
+      ((default . error) (SEMICOLON .  575) (IS . (discriminant_part_opt . 0)) 
(LEFT_PAREN .  188))
+      ((default . error) (SEMICOLON . (aspect_specification_opt . 0)) (IS . 
(aspect_specification_opt . 0)) (WITH .  104))
+      ((default . error) (IDENTIFIER .  573))
+      ((default . error) (IDENTIFIER .  572))
+      ((default . error) (IS .  571))
+      ((default . error) (IS . (aspect_specification_opt . 0)) (WITH .  104))
+      ((default . error) (IDENTIFIER .  569))
+      ((default . error) (IDENTIFIER .  568))
+      ((default . error) (IDENTIFIER .  45) (CHARACTER_LITERAL .  47) 
(STRING_LITERAL .  46))
+      ((default . error) (RENAMES .  566) (DOT .  84) (TICK .  85) (IS . ( 102 
(aspect_specification_opt . 0))) (WITH .  104) (LEFT_PAREN .  103))
+      ((default . error) (USE . ((direct_name . 0) (name . 0))) (LEFT_PAREN . 
(name . 0)) (DOT . (name . 0)) (TICK . (name . 0)))
+      ((default . error) (USE . ((direct_name . 1) (name . 7))) (LEFT_PAREN . 
(name . 7)) (DOT . (name . 7)) (TICK . (name . 7)))
+      ((default . error) (USE . ( 565 (name . 4))) (LEFT_PAREN . (name . 4)) 
(DOT . (name . 4)) (TICK . (name . 4)))
+      ((default . error) (USE .  564))
+      ((default . error) (DOT .  84) (TICK .  85) (USE .  563) (LEFT_PAREN .  
103))
+      ((default . error) (EXCEPTION .  560) (IDENTIFIER . (null_exclusion_opt 
. 0)) (STRING_LITERAL . (null_exclusion_opt . 0)) (CHARACTER_LITERAL . 
(null_exclusion_opt . 0)) (ACCESS . (null_exclusion_opt . 0)) (NOT .  198))
+      ((default . error) (SEMICOLON . (aspect_specification_opt . 2)) (IS . 
(aspect_specification_opt . 2)))
+      ((default . error) (COMMA . (association_opt . 2)) (RIGHT_PAREN . 
(association_opt . 2)))
+      ((default . error) (COMMA . (association_opt . 1)) (RIGHT_PAREN . 
(association_opt . 1)))
+      ((default . error) (DOT .  84) (TICK .  85) (BAR . (discrete_choice . 
1)) (EQUAL_GREATER . (discrete_choice . 1)) (LEFT_PAREN .  103))
+      ((default . error) (RIGHT_PAREN . (association_list . 1)) (COMMA . 
(association_list . 1)))
+      ((default . error) (BAR . (choice_relation_and_list . 1)) (EQUAL_GREATER 
. (choice_relation_and_list . 1)) (AND . (choice_relation_and_list . 1)))
+      ((default . error) (XOR . (choice_relation . 1)) (OR . (choice_relation 
. 1)) (BAR . (choice_relation . 1)) (EQUAL_GREATER . (choice_relation . 1)) 
(AND . (choice_relation . 1)) (EQUAL .  251) (SLASH_EQUAL .  256) (LESS .  254) 
(LESS_EQUAL .  255) (GREATER .  252) (GREATER_EQUAL .  253))
+      ((default . error) (BAR . (choice_relation_or_list . 1)) (EQUAL_GREATER 
. (choice_relation_or_list . 1)) (OR . (choice_relation_or_list . 1)))
+      ((default . error) (BAR . (choice_relation_xor_list . 1)) (EQUAL_GREATER 
. (choice_relation_xor_list . 1)) (XOR . (choice_relation_xor_list . 1)))
+      ((default . error) (PLUS .  136) (MINUS .  135) (ABS .  138) (NOT .  
141) (NULL .  142) (NEW .  140) (IDENTIFIER .  45) (CHARACTER_LITERAL .  47) 
(STRING_LITERAL .  46) (LEFT_PAREN .  139))
+      ((default . error) (PLUS .  136) (MINUS .  135) (ABS .  138) (NOT .  
141) (NULL .  142) (NEW .  140) (IDENTIFIER .  45) (CHARACTER_LITERAL .  47) 
(STRING_LITERAL .  46) (LEFT_PAREN .  139))
+      ((default . error) (BAR . (choice_relation_xor_list . 0)) (EQUAL_GREATER 
. (choice_relation_xor_list . 0)) (XOR . (choice_relation_xor_list . 0)))
+      ((default . error) (PLUS .  136) (MINUS .  135) (ABS .  138) (NOT .  
141) (NULL .  142) (NEW .  140) (IDENTIFIER .  45) (CHARACTER_LITERAL .  47) 
(STRING_LITERAL .  46) (LEFT_PAREN .  139))
+      ((default . error) (BAR . (choice_relation_or_list . 0)) (EQUAL_GREATER 
. (choice_relation_or_list . 0)) (OR . (choice_relation_or_list . 0)))
+      ((default . error) (PLUS .  136) (MINUS .  135) (ABS .  138) (NOT .  
141) (NULL .  142) (NEW .  140) (IDENTIFIER .  45) (CHARACTER_LITERAL .  47) 
(STRING_LITERAL .  46) (LEFT_PAREN .  139))
+      ((default . error) (BAR . (choice_relation_and_list . 0)) (EQUAL_GREATER 
. (choice_relation_and_list . 0)) (AND . (choice_relation_and_list . 0)))
+      ((default . error) (COMMA . (association_opt . 4)) (RIGHT_PAREN . 
(association_opt . 4)))
+      ((default . error) (COMMA . (association_opt . 3)) (RIGHT_PAREN . 
(association_opt . 3)))
+      ((default . error) (EQUAL_GREATER . (discrete_choice_list . 2)) (BAR . 
(discrete_choice_list . 2)))
+      ((default . error) (DOT_DOT .  250) (BAR . (choice_relation . 1)) 
(EQUAL_GREATER . (choice_relation . 1)) (AND . (choice_relation . 1)) (OR . 
(choice_relation . 1)) (XOR . (choice_relation . 1)) (EQUAL .  251) 
(SLASH_EQUAL .  256) (LESS .  254) (LESS_EQUAL .  255) (GREATER .  252) 
(GREATER_EQUAL .  253))
+      ((default . error) (LOOP . (range . 1)) (DO . (range . 1)) (COMMA . 
(range . 1)) (OF . (range . 1)) (COLON_EQUAL . (range . 1)) (ELSIF . (range . 
1)) (ELSE . (range . 1)) (DIGITS . (range . 1)) (RANGE . (range . 1)) (THEN . 
(range . 1)) (SEMICOLON . (range . 1)) (WITH . (range . 1)) (IS . (range . 1)) 
(AND . (range . 1)) (OR . (range . 1)) (XOR . (range . 1)) (RIGHT_PAREN . 
(range . 1)) (EQUAL_GREATER . (range . 1)) (BAR . (range . 1)) (LEFT_PAREN .  
554))
+      ((default . error) (WITH . (relation . 1)) (RIGHT_PAREN . (relation . 
1)) (COMMA . (relation . 1)) (BAR . (choice_relation . 0)) (EQUAL_GREATER . 
(choice_relation . 0)) (AND . ((relation . 1) (choice_relation . 0))) (OR . 
((relation . 1) (choice_relation . 0))) (XOR . ((relation . 1) (choice_relation 
. 0))))
+      ((default . error) (PLUS .  136) (MINUS .  135) (IDENTIFIER .  45) 
(CHARACTER_LITERAL .  47) (STRING_LITERAL .  46) (ABS .  138) (NOT .  141) 
(NULL .  142) (NEW .  140) (LEFT_PAREN .  139))
+      ((default . error) (BAR .  552) (DO . (relation . 3)) (LOOP . (relation 
. 3)) (COMMA . (relation . 3)) (RIGHT_PAREN . (relation . 3)) (ELSIF . 
(relation . 3)) (ELSE . (relation . 3)) (EQUAL_GREATER . (relation . 3)) 
(DIGITS . (relation . 3)) (RANGE . (relation . 3)) (THEN . (relation . 3)) 
(SEMICOLON . (relation . 3)) (WITH . (relation . 3)) (IS . (relation . 3)) (AND 
. (relation . 3)) (OR . (relation . 3)) (XOR . (relation . 3)))
+      ((default . error) (DO . (membership_choice_list . 0)) (LOOP . 
(membership_choice_list . 0)) (COMMA . (membership_choice_list . 0)) 
(RIGHT_PAREN . (membership_choice_list . 0)) (ELSIF . (membership_choice_list . 
0)) (ELSE . (membership_choice_list . 0)) (EQUAL_GREATER . 
(membership_choice_list . 0)) (DIGITS . (membership_choice_list . 0)) (RANGE . 
(membership_choice_list . 0)) (THEN . (membership_choice_list . 0)) (SEMICOLON 
. (membership_choice_list . 0)) (WITH . (membership_choice_list . 0)) (IS . 
(membership_choice_list . 0)) (AND . (membership_choice_list . 0)) (OR . 
(membership_choice_list . 0)) (XOR . (membership_choice_list . 0)) (BAR . 
(membership_choice_list . 0)))
+      ((default . error) (DO . (membership_choice . 1)) (LOOP . 
(membership_choice . 1)) (COMMA . (membership_choice . 1)) (RIGHT_PAREN . 
(membership_choice . 1)) (ELSIF . (membership_choice . 1)) (ELSE . 
(membership_choice . 1)) (EQUAL_GREATER . (membership_choice . 1)) (DIGITS . 
(membership_choice . 1)) (RANGE . (membership_choice . 1)) (THEN . 
(membership_choice . 1)) (SEMICOLON . (membership_choice . 1)) (WITH . 
(membership_choice . 1)) (IS . (membership_choice . 1)) (AND . 
(membership_choice . 1)) (OR . (membership_choice . 1)) (XOR . 
(membership_choice . 1)) (BAR . (membership_choice . 1)))
+      ((default . error) (DOT_DOT .  250) (DO . (membership_choice . 0)) (LOOP 
. (membership_choice . 0)) (COMMA . (membership_choice . 0)) (RIGHT_PAREN . 
(membership_choice . 0)) (ELSIF . (membership_choice . 0)) (ELSE . 
(membership_choice . 0)) (EQUAL_GREATER . (membership_choice . 0)) (DIGITS . 
(membership_choice . 0)) (RANGE . (membership_choice . 0)) (THEN . 
(membership_choice . 0)) (SEMICOLON . (membership_choice . 0)) (WITH . 
(membership_choice . 0)) (IS . (membership_choice . 0)) (AND . 
(membership_choice . 0)) (OR . (membership_choice . 0)) (XOR . 
(membership_choice . 0)) (BAR . (membership_choice . 0)))
+      ((default . error) (DO . (range . 2)) (LOOP . (range . 2)) (OF . (range 
. 2)) (COLON_EQUAL . (range . 2)) (ELSIF . (range . 2)) (ELSE . (range . 2)) 
(DIGITS . (range . 2)) (RANGE . (range . 2)) (THEN . (range . 2)) (SEMICOLON . 
(range . 2)) (WITH . (range . 2)) (IS . (range . 2)) (AND . (range . 2)) (OR . 
(range . 2)) (XOR . (range . 2)) (COMMA . (range . 2)) (RIGHT_PAREN . (range . 
2)) (EQUAL_GREATER . (range . 2)) (BAR . (range . 2)))
+      ((default . error) (SEMICOLON .  551))
+      ((default . error) (SEMICOLON .  550))
+      ((default . error) (SEMICOLON .  549))
+      ((default . error) (SEMICOLON .  548))
+      ((default . error) (ACCESS . (null_exclusion_opt . 0)) (NOT .  543) 
(IDENTIFIER .  542) (CHARACTER_LITERAL .  47) (STRING_LITERAL .  46))
+      ((default . error) (RIGHT_PAREN . (discriminant_specification_opt . 0)) 
(SEMICOLON . (discriminant_specification_opt . 0)) (IDENTIFIER .  69))
+      ((default . error) (IS . (discriminant_part_opt . 2)) (WITH . 
(discriminant_part_opt . 2)) (SEMICOLON . (discriminant_part_opt . 2)))
+      ((default . error) (IS . (discriminant_part_opt . 1)) (WITH . 
(discriminant_part_opt . 1)) (SEMICOLON . (discriminant_part_opt . 1)))
+      ((default . error) (PACKAGE . (formal_type_declaration . 2)) (PROCEDURE 
. (formal_type_declaration . 2)) (FUNCTION . (formal_type_declaration . 2)) 
(IDENTIFIER . (formal_type_declaration . 2)) (PRAGMA . (formal_type_declaration 
. 2)) (TYPE . (formal_type_declaration . 2)) (WITH . (formal_type_declaration . 
2)))
+      ((default . error) (NEW .  538) (SYNCHRONIZED .  539) (LIMITED .  537) 
(TAGGED .  540))
+      ((default . error) (LEFT_PAREN .  536))
+      ((default . error) (BOX .  535))
+      ((default . error) (BOX .  534))
+      ((default . error) (SEMICOLON . (interface_type_definition . 8)) (WITH . 
(interface_type_definition . 8)))
+      ((default . error) (BOX .  533))
+      ((default . error) (INTERFACE .  532) (PRIVATE . 
(abstract_tagged_limited_opt . 5)))
+      ((default . error) (BOX .  531))
+      ((default . error) (IDENTIFIER .  45) (CHARACTER_LITERAL .  47) 
(STRING_LITERAL .  46))
+      ((default . error) (INTERFACE .  529))
+      ((default . error) (BOX .  528))
+      ((default . error) (INTERFACE .  527))
+      ((default . error) (PRIVATE . (abstract_tagged_limited_opt . 4)) 
(LIMITED .  525) (SEMICOLON . (aspect_specification_opt . 0)) (WITH .  104))
+      ((default . error) (INTERFACE .  524))
+      ((default . error) (PRIVATE .  523))
+      ((default . error) (WITH . (formal_type_definition . 9)) (SEMICOLON . 
(formal_type_definition . 9)))
+      ((default . error) (WITH . (formal_type_definition . 8)) (SEMICOLON . 
(formal_type_definition . 8)))
+      ((default . error) (SEMICOLON . (aspect_specification_opt . 0)) (WITH .  
104))
+      ((default . error) (WITH . (formal_type_definition . 1)) (SEMICOLON . 
(formal_type_definition . 1)))
+      ((default . error) (WITH . (formal_type_definition . 10)) (SEMICOLON . 
(formal_type_definition . 10)))
+      ((default . error) (SEMICOLON .  521))
+      ((default . error) (SEMICOLON .  520))
+      ((default . error) (SEMICOLON . (aspect_specification_opt . 0)) (WITH .  
104))
+      ((default . error) (IDENTIFIER .  45) (CHARACTER_LITERAL .  47) 
(STRING_LITERAL .  46))
+      ((default . error) (DOT .  84) (TICK .  85) (COLON_EQUAL .  516) 
(LEFT_PAREN .  103) (SEMICOLON . (aspect_specification_opt . 0)) (WITH .  104))
+      ((default . error) (PLUS .  136) (MINUS .  135) (ABS .  138) (NOT .  
141) (NULL .  142) (NEW .  140) (IDENTIFIER .  45) (CHARACTER_LITERAL .  47) 
(STRING_LITERAL .  46) (LEFT_PAREN .  139))
+      ((default . error) (SEMICOLON .  514))
+      ((default . error) (DOT .  84) (TICK .  85) (RIGHT_PAREN . 
(parameter_and_result_profile . 0)) (DO . (parameter_and_result_profile . 0)) 
(RENAMES . (parameter_and_result_profile . 0)) (COLON_EQUAL . 
(parameter_and_result_profile . 0)) (SEMICOLON . (parameter_and_result_profile 
. 0)) (IS . (parameter_and_result_profile . 0)) (WITH . 
(parameter_and_result_profile . 0)) (LEFT_PAREN .  103))
+      ((default . error) (IDENTIFIER . (general_access_modifier_opt . 1)) 
(STRING_LITERAL . (general_access_modifier_opt . 1)) (CHARACTER_LITERAL . 
(general_access_modifier_opt . 1)))
+      ((default . error) (IDENTIFIER . (general_access_modifier_opt . 2)) 
(STRING_LITERAL . (general_access_modifier_opt . 2)) (CHARACTER_LITERAL . 
(general_access_modifier_opt . 2)))
+      ((default . error) (FUNCTION . (protected_opt . 1)) (PROCEDURE . 
(protected_opt . 1)))
+      ((default . error) (IDENTIFIER .  45) (CHARACTER_LITERAL .  47) 
(STRING_LITERAL .  46))
+      ((default . error) (FUNCTION .  511) (PROCEDURE .  512))
+      ((default . error) (IN . (aliased_opt . 1)) (OUT . (aliased_opt . 1)) 
(ARRAY . (aliased_opt . 1)) (CONSTANT . (aliased_opt . 1)) (IDENTIFIER . 
(aliased_opt . 1)) (STRING_LITERAL . (aliased_opt . 1)) (CHARACTER_LITERAL . 
(aliased_opt . 1)) (ACCESS . (aliased_opt . 1)) (NOT . (aliased_opt . 1)))
+      ((default . error) (SEMICOLON . (parameter_specification . 3)) 
(RIGHT_PAREN . (parameter_specification . 3)) (COLON_EQUAL .  510))
+      ((default . error) (NOT . (mode_opt . 0)) (IDENTIFIER . (mode_opt . 0)) 
(STRING_LITERAL . (mode_opt . 0)) (CHARACTER_LITERAL . (mode_opt . 0)) (IN .  
194) (OUT .  195))
+      ((default . error) (RIGHT_PAREN . (parameter_specification_list . 1)) 
(SEMICOLON . (parameter_specification_list . 1)))
+      ((default . error) (RIGHT_PAREN . ((association_opt . 0) (expression_opt 
. 0))) (COMMA . ((association_opt . 0) (expression_opt . 0))) (EQUAL_GREATER . 
(discrete_choice_list . 0)) (BAR . (discrete_choice_list . 0)) (OTHERS .  165) 
(IDENTIFIER .  45) (CHARACTER_LITERAL .  163) (STRING_LITERAL .  46) (PLUS .  
136) (MINUS .  135) (ABS .  138) (NOT .  164) (NULL .  507) (NEW .  140) 
(LEFT_PAREN .  139))
+      ((default . error) (DO . (aggregate . 0)) (LOOP . (aggregate . 0)) 
(RENAMES . (aggregate . 0)) (USE . (aggregate . 0)) (COLON_EQUAL . (aggregate . 
0)) (WHILE . (aggregate . 0)) (SELECT . (aggregate . 0)) (REQUEUE . (aggregate 
. 0)) (RAISE . (aggregate . 0)) (PRAGMA . (aggregate . 0)) (NULL . (aggregate . 
0)) (IF . (aggregate . 0)) (GOTO . (aggregate . 0)) (FOR . (aggregate . 0)) 
(EXIT . (aggregate . 0)) (DELAY . (aggregate . 0)) (DECLARE . (aggregate . 0)) 
(CASE . (aggregate . 0)) (BEGIN . (aggregate . 0)) (ABORT . (aggregate . 0)) 
(ACCEPT . (aggregate . 0)) (CHARACTER_LITERAL . (aggregate . 0)) 
(STRING_LITERAL . (aggregate . 0)) (IDENTIFIER . (aggregate . 0)) (LESS_LESS . 
(aggregate . 0)) (OF . (aggregate . 0)) (ELSIF . (aggregate . 0)) (ELSE . 
(aggregate . 0)) (DIGITS . (aggregate . 0)) (COMMA . (aggregate . 0)) 
(RIGHT_PAREN . (aggregate . 0)) (RANGE . (aggregate . 0)) (THEN . (aggregate . 
0)) (WITH . (aggregate . 0)) (BAR . (aggregate . 0)) (EQUAL_GREATER . 
(aggregate . 0)) (IS . (aggregate . 0)) (SLASH_EQUAL . (aggregate . 0)) 
(LESS_EQUAL . (aggregate . 0)) (LESS . (aggregate . 0)) (GREATER_EQUAL . 
(aggregate . 0)) (GREATER . (aggregate . 0)) (EQUAL . (aggregate . 0)) (NOT . 
(aggregate . 0)) (IN . (aggregate . 0)) (AND . (aggregate . 0)) (OR . 
(aggregate . 0)) (XOR . (aggregate . 0)) (SEMICOLON . (aggregate . 0)) 
(STAR_STAR . (aggregate . 0)) (REM . (aggregate . 0)) (MOD . (aggregate . 0)) 
(STAR . (aggregate . 0)) (SLASH . (aggregate . 0)) (DOT_DOT . (aggregate . 0)) 
(AMPERSAND . (aggregate . 0)) (MINUS . (aggregate . 0)) (PLUS . (aggregate . 
0)) (LEFT_PAREN . (aggregate . 0)) (DOT . (aggregate . 0)) (TICK . (aggregate . 
0)) (RETURN . (aggregate . 0)))
+      ((default . error) (RIGHT_PAREN .  506))
+      ((default . error) (OF . (aggregate . 3)) (LESS_LESS . (aggregate . 3)) 
(IDENTIFIER . (aggregate . 3)) (STRING_LITERAL . (aggregate . 3)) 
(CHARACTER_LITERAL . (aggregate . 3)) (ACCEPT . (aggregate . 3)) (ABORT . 
(aggregate . 3)) (BEGIN . (aggregate . 3)) (CASE . (aggregate . 3)) (DECLARE . 
(aggregate . 3)) (DELAY . (aggregate . 3)) (EXIT . (aggregate . 3)) (FOR . 
(aggregate . 3)) (GOTO . (aggregate . 3)) (IF . (aggregate . 3)) (NULL . 
(aggregate . 3)) (PRAGMA . (aggregate . 3)) (RAISE . (aggregate . 3)) (REQUEUE 
. (aggregate . 3)) (SELECT . (aggregate . 3)) (WHILE . (aggregate . 3)) 
(COLON_EQUAL . (aggregate . 3)) (USE . (aggregate . 3)) (RENAMES . (aggregate . 
3)) (LOOP . (aggregate . 3)) (DO . (aggregate . 3)) (RETURN . (aggregate . 3)) 
(TICK . (aggregate . 3)) (DOT . (aggregate . 3)) (LEFT_PAREN . (aggregate . 3)) 
(PLUS . (aggregate . 3)) (MINUS . (aggregate . 3)) (AMPERSAND . (aggregate . 
3)) (DOT_DOT . (aggregate . 3)) (SLASH . (aggregate . 3)) (STAR . (aggregate . 
3)) (MOD . (aggregate . 3)) (REM . (aggregate . 3)) (STAR_STAR . (aggregate . 
3)) (SEMICOLON . (aggregate . 3)) (XOR . (aggregate . 3)) (OR . (aggregate . 
3)) (AND . (aggregate . 3)) (IN . (aggregate . 3)) (NOT . (aggregate . 3)) 
(EQUAL . (aggregate . 3)) (GREATER . (aggregate . 3)) (GREATER_EQUAL . 
(aggregate . 3)) (LESS . (aggregate . 3)) (LESS_EQUAL . (aggregate . 3)) 
(SLASH_EQUAL . (aggregate . 3)) (IS . (aggregate . 3)) (EQUAL_GREATER . 
(aggregate . 3)) (BAR . (aggregate . 3)) (WITH . (aggregate . 3)) (THEN . 
(aggregate . 3)) (RANGE . (aggregate . 3)) (RIGHT_PAREN . (aggregate . 3)) 
(COMMA . (aggregate . 3)) (DIGITS . (aggregate . 3)) (ELSE . (aggregate . 3)) 
(ELSIF . (aggregate . 3)))
+      ((default . error) (PLUS . (primary . 0)) (MINUS . (primary . 0)) 
(AMPERSAND . (primary . 0)) (DOT_DOT . (primary . 0)) (IN . (primary . 0)) (NOT 
. (primary . 0)) (EQUAL . (primary . 0)) (GREATER . (primary . 0)) 
(GREATER_EQUAL . (primary . 0)) (LESS . (primary . 0)) (LESS_EQUAL . (primary . 
0)) (SLASH_EQUAL . (primary . 0)) (RIGHT_PAREN . (primary . 0)) (COMMA . 
(primary . 0)) (SLASH . (primary . 0)) (STAR . (primary . 0)) (MOD . (primary . 
0)) (REM . (primary . 0)) (STAR_STAR . (primary . 0)) (BAR . (primary . 0)) 
(EQUAL_GREATER . (primary . 0)) (AND . (primary . 0)) (OR . (primary . 0)) (XOR 
. (primary . 0)) (RECORD .  779))
+      ((default . error) (COMMA .  272) (RIGHT_PAREN .  778))
+      ((default . error) (IDENTIFIER . (null_exclusion_opt . 0)) 
(STRING_LITERAL . (null_exclusion_opt . 0)) (CHARACTER_LITERAL . 
(null_exclusion_opt . 0)) (NOT .  198))
+      ((default . error) (PLUS .  136) (MINUS .  135) (ABS .  138) (NOT .  
141) (NULL .  142) (NEW .  140) (IDENTIFIER .  45) (CHARACTER_LITERAL .  47) 
(STRING_LITERAL .  46) (LEFT_PAREN .  139))
+      ((default . error) (RETURN .  87) (LEFT_PAREN .  773))
+      ((default . error) (IS . (parameter_profile_opt . 0)) (SEMICOLON . 
(parameter_profile_opt . 0)) (WITH . (parameter_profile_opt . 0)) (COLON_EQUAL 
. (parameter_profile_opt . 0)) (RENAMES . (parameter_profile_opt . 0)) (DO . 
(parameter_profile_opt . 0)) (RIGHT_PAREN . (parameter_profile_opt . 0)) 
(LEFT_PAREN .  773))
+      ((default . error) (DOT .  84) (TICK .  85) (RIGHT_PAREN . 
(access_definition . 0)) (DO . (access_definition . 0)) (RENAMES . 
(access_definition . 0)) (COLON_EQUAL . (access_definition . 0)) (WITH . 
(access_definition . 0)) (SEMICOLON . (access_definition . 0)) (IS . 
(access_definition . 0)) (LEFT_PAREN .  103))
+      ((default . error) (WITH . (formal_object_declaration . 3)) (TYPE . 
(formal_object_declaration . 3)) (PRAGMA . (formal_object_declaration . 3)) 
(IDENTIFIER . (formal_object_declaration . 3)) (FUNCTION . 
(formal_object_declaration . 3)) (PROCEDURE . (formal_object_declaration . 3)) 
(PACKAGE . (formal_object_declaration . 3)))
+      ((default . error) (SEMICOLON . (aspect_specification_opt . 0)) (WITH .  
104))
+      ((default . error) (PLUS .  136) (MINUS .  135) (ABS .  138) (NOT .  
141) (NULL .  142) (NEW .  140) (IDENTIFIER .  45) (CHARACTER_LITERAL .  47) 
(STRING_LITERAL .  46) (LEFT_PAREN .  139))
+      ((default . error) (SEMICOLON .  770))
+      ((default . error) (DOT .  84) (TICK .  85) (WITH . 
(formal_package_actual_part . 1)) (SEMICOLON . (formal_package_actual_part . 
1)) (LEFT_PAREN .  768))
+      ((default . error) (SEMICOLON .  767))
+      ((default . error) (WITH . (formal_subprogram_declaration . 3)) (TYPE . 
(formal_subprogram_declaration . 3)) (PRAGMA . (formal_subprogram_declaration . 
3)) (IDENTIFIER . (formal_subprogram_declaration . 3)) (FUNCTION . 
(formal_subprogram_declaration . 3)) (PROCEDURE . 
(formal_subprogram_declaration . 3)) (PACKAGE . (formal_subprogram_declaration 
. 3)))
+      ((default . error) (WITH . (formal_subprogram_declaration . 0)) (TYPE . 
(formal_subprogram_declaration . 0)) (PRAGMA . (formal_subprogram_declaration . 
0)) (IDENTIFIER . (formal_subprogram_declaration . 0)) (FUNCTION . 
(formal_subprogram_declaration . 0)) (PROCEDURE . 
(formal_subprogram_declaration . 0)) (PACKAGE . (formal_subprogram_declaration 
. 0)))
+      ((default . error) (SEMICOLON .  766))
+      ((default . error) (SEMICOLON . (formal_type_definition . 0)) (WITH . 
(formal_type_definition . 0)))
+      ((default . error) (AND .  765) (WITH . (interface_type_definition . 5)) 
(SEMICOLON . (interface_type_definition . 5)))
+      ((default . error) (RECORD . (abstract_tagged_limited_opt . 3)) (NULL . 
(abstract_tagged_limited_opt . 3)) (PRIVATE . (abstract_tagged_limited_opt . 
3)))
+      ((default . error) (SEMICOLON .  764))
+      ((default . error) (AND .  763) (WITH . (interface_type_definition . 7)) 
(SEMICOLON . (interface_type_definition . 7)))
+      ((default . error) (SEMICOLON . (formal_type_definition . 3)) (WITH . 
(formal_type_definition . 3)))
+      ((default . error) (AND .  762) (WITH . (interface_type_definition . 6)) 
(SEMICOLON . (interface_type_definition . 6)))
+      ((default . error) (DOT .  84) (TICK .  85) (WITH . 
(formal_derived_type_definition . 7)) (SEMICOLON . 
(formal_derived_type_definition . 7)) (LEFT_PAREN .  103))
+      ((default . error) (SEMICOLON . (formal_type_definition . 4)) (WITH . 
(formal_type_definition . 4)))
+      ((default . error) (AND .  761) (WITH . (interface_type_definition . 4)) 
(SEMICOLON . (interface_type_definition . 4)))
+      ((default . error) (RIGHT_PAREN .  760))
+      ((default . error) (SEMICOLON . (formal_type_definition . 5)) (WITH . 
(formal_type_definition . 5)))
+      ((default . error) (SEMICOLON . (formal_type_definition . 6)) (WITH . 
(formal_type_definition . 6)) (DIGITS .  759))
+      ((default . error) (IDENTIFIER .  45) (CHARACTER_LITERAL .  47) 
(STRING_LITERAL .  46) (PLUS .  136) (MINUS .  135) (ABS .  138) (NOT .  750) 
(NULL .  142) (NEW .  140) (LEFT_PAREN .  139))
+      ((default . error) (NEW .  749))
+      ((default . error) (IDENTIFIER .  45) (CHARACTER_LITERAL .  47) 
(STRING_LITERAL .  46))
+      ((default . error) (NEW .  747))
+      ((default . error) (LIMITED .  746) (RECORD . 
(abstract_tagged_limited_opt . 2)) (NULL . (abstract_tagged_limited_opt . 2)) 
(PRIVATE . (abstract_tagged_limited_opt . 2)))
+      ((default . error) (RIGHT_PAREN . (discriminant_specification_list . 1)) 
(SEMICOLON . (discriminant_specification_list . 1)))
+      ((default . error) (SEMICOLON . (null_exclusion_opt_name . 0)) 
(RIGHT_PAREN . (null_exclusion_opt_name . 0)) (COLON_EQUAL . 
(null_exclusion_opt_name . 0)) (DOT . (name . 0)) (LEFT_PAREN . (name . 0)) 
(TICK . (name . 0)))
+      ((default . error) (NULL .  745))
+      ((default . error) (SEMICOLON . (discriminant_specification_opt . 4)) 
(RIGHT_PAREN . (discriminant_specification_opt . 4)) (COLON_EQUAL .  744))
+      ((default . error) (DOT .  84) (TICK .  85) (LEFT_PAREN .  103))
+      ((default . error) (SEMICOLON . (discriminant_specification_opt . 2)) 
(RIGHT_PAREN . (discriminant_specification_opt . 2)) (COLON_EQUAL .  743))
+      ((default . error) (SEMICOLON . (null_exclusion_opt_name . 1)) 
(RIGHT_PAREN . (null_exclusion_opt_name . 1)) (COLON_EQUAL . 
(null_exclusion_opt_name . 1)) (DOT . (name . 3)) (LEFT_PAREN . (name . 3)) 
(TICK . (name . 3)))
+      ((default . error) ($EOI . (generic_renaming_declaration . 1)) (LIMITED 
. (generic_renaming_declaration . 1)) (SEPARATE . (generic_renaming_declaration 
. 1)) (WITH . (generic_renaming_declaration . 1)) (END . 
(generic_renaming_declaration . 1)) (PRIVATE . (generic_renaming_declaration . 
1)) (USE . (generic_renaming_declaration . 1)) (TYPE . 
(generic_renaming_declaration . 1)) (TASK . (generic_renaming_declaration . 1)) 
(SUBTYPE . (generic_renaming_declaration . 1)) (PROTECTED . 
(generic_renaming_declaration . 1)) (PROCEDURE . (generic_renaming_declaration 
. 1)) (PRAGMA . (generic_renaming_declaration . 1)) (PACKAGE . 
(generic_renaming_declaration . 1)) (OVERRIDING . (generic_renaming_declaration 
. 1)) (NOT . (generic_renaming_declaration . 1)) (GENERIC . 
(generic_renaming_declaration . 1)) (FUNCTION . (generic_renaming_declaration . 
1)) (FOR . (generic_renaming_declaration . 1)) (ENTRY . 
(generic_renaming_declaration . 1)) (IDENTIFIER . (generic_renaming_declaration 
. 1)) (BEGIN . (generic_renaming_declaration . 1)))
+      ((default . error) ($EOI . (generic_renaming_declaration . 0)) (LIMITED 
. (generic_renaming_declaration . 0)) (SEPARATE . (generic_renaming_declaration 
. 0)) (WITH . (generic_renaming_declaration . 0)) (END . 
(generic_renaming_declaration . 0)) (PRIVATE . (generic_renaming_declaration . 
0)) (USE . (generic_renaming_declaration . 0)) (TYPE . 
(generic_renaming_declaration . 0)) (TASK . (generic_renaming_declaration . 0)) 
(SUBTYPE . (generic_renaming_declaration . 0)) (PROTECTED . 
(generic_renaming_declaration . 0)) (PROCEDURE . (generic_renaming_declaration 
. 0)) (PRAGMA . (generic_renaming_declaration . 0)) (PACKAGE . 
(generic_renaming_declaration . 0)) (OVERRIDING . (generic_renaming_declaration 
. 0)) (NOT . (generic_renaming_declaration . 0)) (GENERIC . 
(generic_renaming_declaration . 0)) (FUNCTION . (generic_renaming_declaration . 
0)) (FOR . (generic_renaming_declaration . 0)) (ENTRY . 
(generic_renaming_declaration . 0)) (IDENTIFIER . (generic_renaming_declaration 
. 0)) (BEGIN . (generic_renaming_declaration . 0)))
+      ((default . error) ($EOI . (generic_renaming_declaration . 2)) (LIMITED 
. (generic_renaming_declaration . 2)) (SEPARATE . (generic_renaming_declaration 
. 2)) (WITH . (generic_renaming_declaration . 2)) (END . 
(generic_renaming_declaration . 2)) (PRIVATE . (generic_renaming_declaration . 
2)) (USE . (generic_renaming_declaration . 2)) (TYPE . 
(generic_renaming_declaration . 2)) (TASK . (generic_renaming_declaration . 2)) 
(SUBTYPE . (generic_renaming_declaration . 2)) (PROTECTED . 
(generic_renaming_declaration . 2)) (PROCEDURE . (generic_renaming_declaration 
. 2)) (PRAGMA . (generic_renaming_declaration . 2)) (PACKAGE . 
(generic_renaming_declaration . 2)) (OVERRIDING . (generic_renaming_declaration 
. 2)) (NOT . (generic_renaming_declaration . 2)) (GENERIC . 
(generic_renaming_declaration . 2)) (FUNCTION . (generic_renaming_declaration . 
2)) (FOR . (generic_renaming_declaration . 2)) (ENTRY . 
(generic_renaming_declaration . 2)) (IDENTIFIER . (generic_renaming_declaration 
. 2)) (BEGIN . (generic_renaming_declaration . 2)))
+      ((default . error) (END . (generic_instantiation . 0)) (BEGIN . 
(generic_instantiation . 0)) (IDENTIFIER . (generic_instantiation . 0)) (ENTRY 
. (generic_instantiation . 0)) (FOR . (generic_instantiation . 0)) (PROTECTED . 
(generic_instantiation . 0)) (SUBTYPE . (generic_instantiation . 0)) (TASK . 
(generic_instantiation . 0)) (TYPE . (generic_instantiation . 0)) ($EOI . 
(generic_instantiation . 0)) (FUNCTION . (generic_instantiation . 0)) (GENERIC 
. (generic_instantiation . 0)) (LIMITED . (generic_instantiation . 0)) (NOT . 
(generic_instantiation . 0)) (OVERRIDING . (generic_instantiation . 0)) 
(PACKAGE . (generic_instantiation . 0)) (PRAGMA . (generic_instantiation . 0)) 
(PRIVATE . (generic_instantiation . 0)) (PROCEDURE . (generic_instantiation . 
0)) (SEPARATE . (generic_instantiation . 0)) (USE . (generic_instantiation . 
0)) (WITH . (generic_instantiation . 0)))
+      ((default . error) (PLUS .  136) (MINUS .  135) (IDENTIFIER .  45) 
(CHARACTER_LITERAL .  47) (STRING_LITERAL .  46) (ABS .  138) (NOT .  141) 
(NULL .  142) (NEW .  140) (LEFT_PAREN .  139))
+      ((default . error) (BAR .  552) (LOOP . (relation . 2)) (DO . (relation 
. 2)) (XOR . (relation . 2)) (OR . (relation . 2)) (AND . (relation . 2)) (IS . 
(relation . 2)) (WITH . (relation . 2)) (SEMICOLON . (relation . 2)) (THEN . 
(relation . 2)) (RANGE . (relation . 2)) (DIGITS . (relation . 2)) 
(EQUAL_GREATER . (relation . 2)) (ELSE . (relation . 2)) (ELSIF . (relation . 
2)) (RIGHT_PAREN . (relation . 2)) (COMMA . (relation . 2)))
+      ((default . error) (PLUS .  136) (MINUS .  135) (ABS .  138) (NOT .  
141) (NULL .  142) (NEW .  140) (IDENTIFIER .  45) (CHARACTER_LITERAL .  47) 
(STRING_LITERAL .  46) (LEFT_PAREN .  139))
+      ((default . error) (PLUS .  136) (MINUS .  135) (ABS .  138) (NOT .  
141) (NULL .  142) (NEW .  140) (IDENTIFIER .  45) (CHARACTER_LITERAL .  47) 
(STRING_LITERAL .  46) (LEFT_PAREN .  139))
+      ((default . error) (AND . (choice_relation_and_then_list . 0)) 
(EQUAL_GREATER . (choice_relation_and_then_list . 0)) (BAR . 
(choice_relation_and_then_list . 0)))
+      ((default . error) (OR . (choice_relation_or_else_list . 0)) 
(EQUAL_GREATER . (choice_relation_or_else_list . 0)) (BAR . 
(choice_relation_or_else_list . 0)))
+      ((default . error) (OR . (choice_relation_or_else_list . 1)) 
(EQUAL_GREATER . (choice_relation_or_else_list . 1)) (BAR . 
(choice_relation_or_else_list . 1)))
+      ((default . error) (AND . (choice_relation_and_then_list . 1)) 
(EQUAL_GREATER . (choice_relation_and_then_list . 1)) (BAR . 
(choice_relation_and_then_list . 1)))
+      ((default . error) (RENAMES .  739))
+      ((default . error) (RENAMES .  738))
+      ((default . error) (ACCESS .  225) (IDENTIFIER .  45) (CHARACTER_LITERAL 
.  47) (STRING_LITERAL .  46))
+      ((default . error) (LEFT_PAREN .  209) (RECORD .  734))
+      ((default . error) (AT .  733))
+      ((default . error) (PLUS .  136) (MINUS .  135) (ABS .  138) (NOT .  
141) (NULL .  142) (NEW .  140) (IDENTIFIER .  45) (CHARACTER_LITERAL .  47) 
(STRING_LITERAL .  46) (LEFT_PAREN .  139))
+      ((default . error) (IDENTIFIER .  45) (CHARACTER_LITERAL .  47) 
(STRING_LITERAL .  46))
+      ((default . error) (DOT .  84) (TICK .  85) (IS . ( 730 
(aspect_specification_opt . 0))) (WITH .  104) (LEFT_PAREN .  103))
+      ((default . error) (WITH . (discriminant_part_opt . 0)) (IS . 
(discriminant_part_opt . 0)) (LEFT_PAREN .  188))
+      ((default . error) (IS . ( 728 (aspect_specification_opt . 0))) (WITH .  
104))
+      ((default . error) (IS .  727))
+      ((default . error) (NOT .  724) (IDENTIFIER .  45) (CHARACTER_LITERAL .  
47) (STRING_LITERAL .  46))
+      ((default . error) (WITH . (discriminant_part_opt . 0)) (IS . 
(discriminant_part_opt . 0)) (SEMICOLON . (discriminant_part_opt . 0)) 
(LEFT_PAREN .  188))
+      ((default . error) (IS . ( 722 (aspect_specification_opt . 0))) (WITH .  
104))
+      ((default . error) (SEMICOLON .  720) (IS .  721))
+      ((default . error) (END . (incomplete_type_declaration . 1)) (PRIVATE . 
(incomplete_type_declaration . 1)) (USE . (incomplete_type_declaration . 1)) 
(TYPE . (incomplete_type_declaration . 1)) (TASK . (incomplete_type_declaration 
. 1)) (SUBTYPE . (incomplete_type_declaration . 1)) (PROTECTED . 
(incomplete_type_declaration . 1)) (PROCEDURE . (incomplete_type_declaration . 
1)) (PRAGMA . (incomplete_type_declaration . 1)) (PACKAGE . 
(incomplete_type_declaration . 1)) (OVERRIDING . (incomplete_type_declaration . 
1)) (NOT . (incomplete_type_declaration . 1)) (GENERIC . 
(incomplete_type_declaration . 1)) (FUNCTION . (incomplete_type_declaration . 
1)) (FOR . (incomplete_type_declaration . 1)) (ENTRY . 
(incomplete_type_declaration . 1)) (IDENTIFIER . (incomplete_type_declaration . 
1)) (BEGIN . (incomplete_type_declaration . 1)))
+      ((default . error) (IS .  719))
+      ((default . error) (END .  718))
+      ((default . error) (DOT .  84) (TICK .  85) (SEMICOLON . 
(package_specification . 1)) (LEFT_PAREN .  103))
+      ((default . error) (COLON_EQUAL .  717))
+      ((default . error) (SEMICOLON .  716))
+      ((default . error) (IDENTIFIER . (constant_opt . 0)) (STRING_LITERAL . 
(constant_opt . 0)) (CHARACTER_LITERAL . (constant_opt . 0)) (NOT . 
(constant_opt . 0)) (ACCESS . (constant_opt . 0)) (ARRAY . (constant_opt . 0)) 
(CONSTANT .  714))
+      ((default . error) (SEPARATE .  713) (ABSTRACT .  712))
+      ((default . error) (IDENTIFIER .  45) (CHARACTER_LITERAL .  47) 
(STRING_LITERAL .  46))
+      ((default . error) (NULL .  710))
+      ((default . error) (WITH . (parameter_profile_opt . 0)) (SEMICOLON . 
(parameter_profile_opt . 0)) (LEFT_PAREN .  708))
+      ((default . error) (END . (sequence_of_statements_opt . 0)) (EXCEPTION . 
(sequence_of_statements_opt . 0)) (ACCEPT . (label_opt . 0)) (BEGIN . 
(label_opt . 0)) (CASE . (label_opt . 0)) (DECLARE . (label_opt . 0)) (FOR . 
(label_opt . 0)) (IF . (label_opt . 0)) (LOOP . (label_opt . 0)) (RETURN . 
(label_opt . 0)) (SELECT . (label_opt . 0)) (WHILE . (label_opt . 0)) 
(STRING_LITERAL . (label_opt . 0)) (CHARACTER_LITERAL . (label_opt . 0)) (ABORT 
. (label_opt . 0)) (DELAY . (label_opt . 0)) (EXIT . (label_opt . 0)) (GOTO . 
(label_opt . 0)) (NULL . (label_opt . 0)) (PRAGMA . (label_opt . 0)) (RAISE . 
(label_opt . 0)) (REQUEUE . (label_opt . 0)) (LESS_LESS .  599) (IDENTIFIER . 
((label_opt . 0)  600)))
+      ((default . error) (SEMICOLON . (name_opt . 0)) (IDENTIFIER .  45) 
(CHARACTER_LITERAL .  47) (STRING_LITERAL .  46))
+      ((default . error) (LOOP . (relation_and_then_list . 0)) (DO . 
(relation_and_then_list . 0)) (AND . (relation_and_then_list . 0)) (IS . 
(relation_and_then_list . 0)) (WITH . (relation_and_then_list . 0)) (SEMICOLON 
. (relation_and_then_list . 0)) (THEN . (relation_and_then_list . 0)) (RANGE . 
(relation_and_then_list . 0)) (COMMA . (relation_and_then_list . 0)) 
(RIGHT_PAREN . (relation_and_then_list . 0)) (DIGITS . (relation_and_then_list 
. 0)) (EQUAL_GREATER . (relation_and_then_list . 0)) (ELSE . 
(relation_and_then_list . 0)) (ELSIF . (relation_and_then_list . 0)))
+      ((default . error) (LOOP . (relation_or_else_list . 0)) (DO . 
(relation_or_else_list . 0)) (OR . (relation_or_else_list . 0)) (IS . 
(relation_or_else_list . 0)) (WITH . (relation_or_else_list . 0)) (SEMICOLON . 
(relation_or_else_list . 0)) (THEN . (relation_or_else_list . 0)) (RANGE . 
(relation_or_else_list . 0)) (COMMA . (relation_or_else_list . 0)) (RIGHT_PAREN 
. (relation_or_else_list . 0)) (DIGITS . (relation_or_else_list . 0)) 
(EQUAL_GREATER . (relation_or_else_list . 0)) (ELSE . (relation_or_else_list . 
0)) (ELSIF . (relation_or_else_list . 0)))
+      ((default . error) (LOOP . (relation_or_else_list . 1)) (DO . 
(relation_or_else_list . 1)) (OR . (relation_or_else_list . 1)) (IS . 
(relation_or_else_list . 1)) (WITH . (relation_or_else_list . 1)) (SEMICOLON . 
(relation_or_else_list . 1)) (THEN . (relation_or_else_list . 1)) (RANGE . 
(relation_or_else_list . 1)) (COMMA . (relation_or_else_list . 1)) (RIGHT_PAREN 
. (relation_or_else_list . 1)) (DIGITS . (relation_or_else_list . 1)) 
(EQUAL_GREATER . (relation_or_else_list . 1)) (ELSE . (relation_or_else_list . 
1)) (ELSIF . (relation_or_else_list . 1)))
+      ((default . error) (LOOP . (relation_and_then_list . 1)) (DO . 
(relation_and_then_list . 1)) (AND . (relation_and_then_list . 1)) (IS . 
(relation_and_then_list . 1)) (WITH . (relation_and_then_list . 1)) (SEMICOLON 
. (relation_and_then_list . 1)) (THEN . (relation_and_then_list . 1)) (RANGE . 
(relation_and_then_list . 1)) (COMMA . (relation_and_then_list . 1)) 
(RIGHT_PAREN . (relation_and_then_list . 1)) (DIGITS . (relation_and_then_list 
. 1)) (EQUAL_GREATER . (relation_and_then_list . 1)) (ELSE . 
(relation_and_then_list . 1)) (ELSIF . (relation_and_then_list . 1)))
+      ((default . error) (WHEN .  702))
+      ((default . error) (OF .  701) (COLON .  699) (IN .  700))
+      ((default . error) (EQUAL_GREATER .  698))
+      ((default . error) (PLUS .  136) (MINUS .  135) (ABS .  138) (NOT .  
141) (NULL .  142) (NEW .  140) (IDENTIFIER .  45) (CHARACTER_LITERAL .  47) 
(STRING_LITERAL .  46) (LEFT_PAREN .  139))
+      ((default . error) (PLUS .  136) (MINUS .  135) (ABS .  138) (NOT .  
141) (NULL .  142) (NEW .  140) (IDENTIFIER .  45) (CHARACTER_LITERAL .  47) 
(STRING_LITERAL .  46) (LEFT_PAREN .  139))
+      ((default . error) (IS . (aspect_specification_opt . 0)) (WITH .  104))
+      ((default . error) (IS . (aspect_specification_opt . 0)) (WITH .  104))
+      ((default . error) (IDENTIFIER .  693))
+      ((default . error) (COLON .  692))
+      ((default . error) (IDENTIFIER .  691))
+      ((default . error) (IDENTIFIER .  45) (CHARACTER_LITERAL .  47) 
(STRING_LITERAL .  46))
+      ((default . error) (END . (sequence_of_statements_opt . 0)) (EXCEPTION . 
(sequence_of_statements_opt . 0)) (ACCEPT . (label_opt . 0)) (BEGIN . 
(label_opt . 0)) (CASE . (label_opt . 0)) (DECLARE . (label_opt . 0)) (FOR . 
(label_opt . 0)) (IF . (label_opt . 0)) (LOOP . (label_opt . 0)) (RETURN . 
(label_opt . 0)) (SELECT . (label_opt . 0)) (WHILE . (label_opt . 0)) 
(STRING_LITERAL . (label_opt . 0)) (CHARACTER_LITERAL . (label_opt . 0)) (ABORT 
. (label_opt . 0)) (DELAY . (label_opt . 0)) (EXIT . (label_opt . 0)) (GOTO . 
(label_opt . 0)) (NULL . (label_opt . 0)) (PRAGMA . (label_opt . 0)) (RAISE . 
(label_opt . 0)) (REQUEUE . (label_opt . 0)) (LESS_LESS .  599) (IDENTIFIER . 
((label_opt . 0)  600)))
+      ((default . error) (PLUS .  136) (MINUS .  135) (ABS .  138) (NOT .  
141) (NULL .  142) (NEW .  140) (IDENTIFIER .  45) (CHARACTER_LITERAL .  47) 
(STRING_LITERAL .  46) (LEFT_PAREN .  139))
+      ((default . error) (BEGIN . (declarative_part_opt . 0)) (USE .  11) 
(SUBTYPE .  282) (PRAGMA .  7) (NOT .  4) (OVERRIDING .  5) (FUNCTION . 
(overriding_indicator_opt . 2)) (PROCEDURE . (overriding_indicator_opt . 2)) 
(ENTRY . (overriding_indicator_opt . 2)) (FOR .  279) (IDENTIFIER .  278) (TYPE 
.  284) (GENERIC .  2) (PROTECTED .  281) (TASK .  283) (PACKAGE .  280))
+      ((default . error) (UNTIL .  685) (PLUS .  136) (MINUS .  135) (ABS .  
138) (NOT .  141) (NULL .  142) (NEW .  140) (IDENTIFIER .  45) 
(CHARACTER_LITERAL .  47) (STRING_LITERAL .  46) (LEFT_PAREN .  139))
+      ((default . error) (WHEN . (identifier_opt . 0)) (SEMICOLON . 
(identifier_opt . 0)) (IDENTIFIER .  683))
+      ((default . error) (LOOP . (iterator_specification_opt . 0)) (IDENTIFIER 
.  593))
+      ((default . error) (IDENTIFIER .  680))
+      ((default . error) (THEN . (expression_opt . 0)) (PLUS .  136) (MINUS .  
135) (ABS .  138) (NOT .  141) (NULL .  142) (NEW .  140) (IDENTIFIER .  45) 
(CHARACTER_LITERAL .  47) (STRING_LITERAL .  46) (LEFT_PAREN .  139))
+      ((default . error) (END . (sequence_of_statements_opt . 0)) (ACCEPT . 
(label_opt . 0)) (BEGIN . (label_opt . 0)) (CASE . (label_opt . 0)) (DECLARE . 
(label_opt . 0)) (FOR . (label_opt . 0)) (IF . (label_opt . 0)) (LOOP . 
(label_opt . 0)) (RETURN . (label_opt . 0)) (SELECT . (label_opt . 0)) (WHILE . 
(label_opt . 0)) (STRING_LITERAL . (label_opt . 0)) (CHARACTER_LITERAL . 
(label_opt . 0)) (ABORT . (label_opt . 0)) (DELAY . (label_opt . 0)) (EXIT . 
(label_opt . 0)) (GOTO . (label_opt . 0)) (NULL . (label_opt . 0)) (PRAGMA . 
(label_opt . 0)) (RAISE . (label_opt . 0)) (REQUEUE . (label_opt . 0)) 
(LESS_LESS .  599) (IDENTIFIER . ((label_opt . 0)  600)))
+      ((default . error) (SEMICOLON .  677))
+      ((default . error) (SEMICOLON .  675) (IDENTIFIER .  45) 
(CHARACTER_LITERAL .  47) (STRING_LITERAL .  46))
+      ((default . error) (IDENTIFIER .  45) (CHARACTER_LITERAL .  47) 
(STRING_LITERAL .  46))
+      ((default . error) (SEMICOLON .  669) (DO . 
(extended_return_object_declaration_opt . 0)) (PLUS .  136) (MINUS .  135) (ABS 
.  138) (NOT .  141) (NULL .  142) (NEW .  140) (IDENTIFIER .  670) 
(CHARACTER_LITERAL .  47) (STRING_LITERAL .  46) (LEFT_PAREN .  139))
+      ((default . error) (ELSE . (select_alternative_list_opt . 0)) (END . 
(select_alternative_list_opt . 0)) (IDENTIFIER .  45) (CHARACTER_LITERAL .  47) 
(STRING_LITERAL .  46) (DELAY .  606) (WHEN .  658) (TERMINATE .  657) (ACCEPT 
.  601))
+      ((default . error) (LOOP . (expression_opt . 0)) (PLUS .  136) (MINUS .  
135) (ABS .  138) (NOT .  141) (NULL .  142) (NEW .  140) (IDENTIFIER .  45) 
(CHARACTER_LITERAL .  47) (STRING_LITERAL .  46) (LEFT_PAREN .  139))
+      ((default . error) (OR . (compound_statement . 5)) (THEN . 
(compound_statement . 5)) (WHEN . (compound_statement . 5)) (EXCEPTION . 
(compound_statement . 5)) (END . (compound_statement . 5)) (LESS_LESS . 
(compound_statement . 5)) (IDENTIFIER . (compound_statement . 5)) 
(STRING_LITERAL . (compound_statement . 5)) (CHARACTER_LITERAL . 
(compound_statement . 5)) (ACCEPT . (compound_statement . 5)) (ABORT . 
(compound_statement . 5)) (BEGIN . (compound_statement . 5)) (CASE . 
(compound_statement . 5)) (DECLARE . (compound_statement . 5)) (DELAY . 
(compound_statement . 5)) (EXIT . (compound_statement . 5)) (FOR . 
(compound_statement . 5)) (GOTO . (compound_statement . 5)) (IF . 
(compound_statement . 5)) (LOOP . (compound_statement . 5)) (NULL . 
(compound_statement . 5)) (PRAGMA . (compound_statement . 5)) (RAISE . 
(compound_statement . 5)) (REQUEUE . (compound_statement . 5)) (RETURN . 
(compound_statement . 5)) (SELECT . (compound_statement . 5)) (WHILE . 
(compound_statement . 5)) (ELSE . (compound_statement . 5)) (ELSIF . 
(compound_statement . 5)))
+      ((default . error) (OR . (simple_statement . 1)) (THEN . 
(simple_statement . 1)) (WHEN . (simple_statement . 1)) (EXCEPTION . 
(simple_statement . 1)) (END . (simple_statement . 1)) (LESS_LESS . 
(simple_statement . 1)) (IDENTIFIER . (simple_statement . 1)) (STRING_LITERAL . 
(simple_statement . 1)) (CHARACTER_LITERAL . (simple_statement . 1)) (ACCEPT . 
(simple_statement . 1)) (ABORT . (simple_statement . 1)) (BEGIN . 
(simple_statement . 1)) (CASE . (simple_statement . 1)) (DECLARE . 
(simple_statement . 1)) (DELAY . (simple_statement . 1)) (EXIT . 
(simple_statement . 1)) (FOR . (simple_statement . 1)) (GOTO . 
(simple_statement . 1)) (IF . (simple_statement . 1)) (LOOP . (simple_statement 
. 1)) (NULL . (simple_statement . 1)) (PRAGMA . (simple_statement . 1)) (RAISE 
. (simple_statement . 1)) (REQUEUE . (simple_statement . 1)) (RETURN . 
(simple_statement . 1)) (SELECT . (simple_statement . 1)) (WHILE . 
(simple_statement . 1)) (ELSE . (simple_statement . 1)) (ELSIF . 
(simple_statement . 1)))
+      ((default . error) (OR . (select_statement . 3)) (THEN . 
(select_statement . 3)) (WHEN . (select_statement . 3)) (EXCEPTION . 
(select_statement . 3)) (END . (select_statement . 3)) (LESS_LESS . 
(select_statement . 3)) (IDENTIFIER . (select_statement . 3)) (STRING_LITERAL . 
(select_statement . 3)) (CHARACTER_LITERAL . (select_statement . 3)) (ACCEPT . 
(select_statement . 3)) (ABORT . (select_statement . 3)) (BEGIN . 
(select_statement . 3)) (CASE . (select_statement . 3)) (DECLARE . 
(select_statement . 3)) (DELAY . (select_statement . 3)) (EXIT . 
(select_statement . 3)) (FOR . (select_statement . 3)) (GOTO . 
(select_statement . 3)) (IF . (select_statement . 3)) (LOOP . (select_statement 
. 3)) (NULL . (select_statement . 3)) (PRAGMA . (select_statement . 3)) (RAISE 
. (select_statement . 3)) (REQUEUE . (select_statement . 3)) (RETURN . 
(select_statement . 3)) (SELECT . (select_statement . 3)) (WHILE . 
(select_statement . 3)) (ELSE . (select_statement . 3)) (ELSIF . 
(select_statement . 3)))
+      ((default . error) (OR . (compound_statement . 3)) (THEN . 
(compound_statement . 3)) (WHEN . (compound_statement . 3)) (EXCEPTION . 
(compound_statement . 3)) (END . (compound_statement . 3)) (LESS_LESS . 
(compound_statement . 3)) (IDENTIFIER . (compound_statement . 3)) 
(STRING_LITERAL . (compound_statement . 3)) (CHARACTER_LITERAL . 
(compound_statement . 3)) (ACCEPT . (compound_statement . 3)) (ABORT . 
(compound_statement . 3)) (BEGIN . (compound_statement . 3)) (CASE . 
(compound_statement . 3)) (DECLARE . (compound_statement . 3)) (DELAY . 
(compound_statement . 3)) (EXIT . (compound_statement . 3)) (FOR . 
(compound_statement . 3)) (GOTO . (compound_statement . 3)) (IF . 
(compound_statement . 3)) (LOOP . (compound_statement . 3)) (NULL . 
(compound_statement . 3)) (PRAGMA . (compound_statement . 3)) (RAISE . 
(compound_statement . 3)) (REQUEUE . (compound_statement . 3)) (RETURN . 
(compound_statement . 3)) (SELECT . (compound_statement . 3)) (WHILE . 
(compound_statement . 3)) (ELSE . (compound_statement . 3)) (ELSIF . 
(compound_statement . 3)))
+      ((default . error) (OR . (compound_statement . 1)) (THEN . 
(compound_statement . 1)) (WHEN . (compound_statement . 1)) (EXCEPTION . 
(compound_statement . 1)) (END . (compound_statement . 1)) (LESS_LESS . 
(compound_statement . 1)) (IDENTIFIER . (compound_statement . 1)) 
(STRING_LITERAL . (compound_statement . 1)) (CHARACTER_LITERAL . 
(compound_statement . 1)) (ACCEPT . (compound_statement . 1)) (ABORT . 
(compound_statement . 1)) (BEGIN . (compound_statement . 1)) (CASE . 
(compound_statement . 1)) (DECLARE . (compound_statement . 1)) (DELAY . 
(compound_statement . 1)) (EXIT . (compound_statement . 1)) (FOR . 
(compound_statement . 1)) (GOTO . (compound_statement . 1)) (IF . 
(compound_statement . 1)) (LOOP . (compound_statement . 1)) (NULL . 
(compound_statement . 1)) (PRAGMA . (compound_statement . 1)) (RAISE . 
(compound_statement . 1)) (REQUEUE . (compound_statement . 1)) (RETURN . 
(compound_statement . 1)) (SELECT . (compound_statement . 1)) (WHILE . 
(compound_statement . 1)) (ELSE . (compound_statement . 1)) (ELSIF . 
(compound_statement . 1)))
+      ((default . error) (OR . (select_statement . 2)) (THEN . 
(select_statement . 2)) (WHEN . (select_statement . 2)) (EXCEPTION . 
(select_statement . 2)) (END . (select_statement . 2)) (LESS_LESS . 
(select_statement . 2)) (IDENTIFIER . (select_statement . 2)) (STRING_LITERAL . 
(select_statement . 2)) (CHARACTER_LITERAL . (select_statement . 2)) (ACCEPT . 
(select_statement . 2)) (ABORT . (select_statement . 2)) (BEGIN . 
(select_statement . 2)) (CASE . (select_statement . 2)) (DECLARE . 
(select_statement . 2)) (DELAY . (select_statement . 2)) (EXIT . 
(select_statement . 2)) (FOR . (select_statement . 2)) (GOTO . 
(select_statement . 2)) (IF . (select_statement . 2)) (LOOP . (select_statement 
. 2)) (NULL . (select_statement . 2)) (PRAGMA . (select_statement . 2)) (RAISE 
. (select_statement . 2)) (REQUEUE . (select_statement . 2)) (RETURN . 
(select_statement . 2)) (SELECT . (select_statement . 2)) (WHILE . 
(select_statement . 2)) (ELSE . (select_statement . 2)) (ELSIF . 
(select_statement . 2)))
+      ((default . error) (OR . (simple_statement . 7)) (THEN . 
(simple_statement . 7)) (WHEN . (simple_statement . 7)) (EXCEPTION . 
(simple_statement . 7)) (END . (simple_statement . 7)) (LESS_LESS . 
(simple_statement . 7)) (IDENTIFIER . (simple_statement . 7)) (STRING_LITERAL . 
(simple_statement . 7)) (CHARACTER_LITERAL . (simple_statement . 7)) (ACCEPT . 
(simple_statement . 7)) (ABORT . (simple_statement . 7)) (BEGIN . 
(simple_statement . 7)) (CASE . (simple_statement . 7)) (DECLARE . 
(simple_statement . 7)) (DELAY . (simple_statement . 7)) (EXIT . 
(simple_statement . 7)) (FOR . (simple_statement . 7)) (GOTO . 
(simple_statement . 7)) (IF . (simple_statement . 7)) (LOOP . (simple_statement 
. 7)) (NULL . (simple_statement . 7)) (PRAGMA . (simple_statement . 7)) (RAISE 
. (simple_statement . 7)) (REQUEUE . (simple_statement . 7)) (RETURN . 
(simple_statement . 7)) (SELECT . (simple_statement . 7)) (WHILE . 
(simple_statement . 7)) (ELSE . (simple_statement . 7)) (ELSIF . 
(simple_statement . 7)))
+      ((default . error) (OR . (simple_statement . 2)) (THEN . 
(simple_statement . 2)) (WHEN . (simple_statement . 2)) (EXCEPTION . 
(simple_statement . 2)) (END . (simple_statement . 2)) (LESS_LESS . 
(simple_statement . 2)) (IDENTIFIER . (simple_statement . 2)) (STRING_LITERAL . 
(simple_statement . 2)) (CHARACTER_LITERAL . (simple_statement . 2)) (ACCEPT . 
(simple_statement . 2)) (ABORT . (simple_statement . 2)) (BEGIN . 
(simple_statement . 2)) (CASE . (simple_statement . 2)) (DECLARE . 
(simple_statement . 2)) (DELAY . (simple_statement . 2)) (EXIT . 
(simple_statement . 2)) (FOR . (simple_statement . 2)) (GOTO . 
(simple_statement . 2)) (IF . (simple_statement . 2)) (LOOP . (simple_statement 
. 2)) (NULL . (simple_statement . 2)) (PRAGMA . (simple_statement . 2)) (RAISE 
. (simple_statement . 2)) (REQUEUE . (simple_statement . 2)) (RETURN . 
(simple_statement . 2)) (SELECT . (simple_statement . 2)) (WHILE . 
(simple_statement . 2)) (ELSE . (simple_statement . 2)) (ELSIF . 
(simple_statement . 2)))
+      ((default . error) (OR . (compound_statement . 4)) (THEN . 
(compound_statement . 4)) (WHEN . (compound_statement . 4)) (EXCEPTION . 
(compound_statement . 4)) (END . (compound_statement . 4)) (LESS_LESS . 
(compound_statement . 4)) (IDENTIFIER . (compound_statement . 4)) 
(STRING_LITERAL . (compound_statement . 4)) (CHARACTER_LITERAL . 
(compound_statement . 4)) (ACCEPT . (compound_statement . 4)) (ABORT . 
(compound_statement . 4)) (BEGIN . (compound_statement . 4)) (CASE . 
(compound_statement . 4)) (DECLARE . (compound_statement . 4)) (DELAY . 
(compound_statement . 4)) (EXIT . (compound_statement . 4)) (FOR . 
(compound_statement . 4)) (GOTO . (compound_statement . 4)) (IF . 
(compound_statement . 4)) (LOOP . (compound_statement . 4)) (NULL . 
(compound_statement . 4)) (PRAGMA . (compound_statement . 4)) (RAISE . 
(compound_statement . 4)) (REQUEUE . (compound_statement . 4)) (RETURN . 
(compound_statement . 4)) (SELECT . (compound_statement . 4)) (WHILE . 
(compound_statement . 4)) (ELSE . (compound_statement . 4)) (ELSIF . 
(compound_statement . 4)))
+      ((default . error) (END .  655))
+      ((default . error) (OR . (compound_statement . 0)) (THEN . 
(compound_statement . 0)) (WHEN . (compound_statement . 0)) (EXCEPTION . 
(compound_statement . 0)) (END . (compound_statement . 0)) (LESS_LESS . 
(compound_statement . 0)) (IDENTIFIER . (compound_statement . 0)) 
(STRING_LITERAL . (compound_statement . 0)) (CHARACTER_LITERAL . 
(compound_statement . 0)) (ACCEPT . (compound_statement . 0)) (ABORT . 
(compound_statement . 0)) (BEGIN . (compound_statement . 0)) (CASE . 
(compound_statement . 0)) (DECLARE . (compound_statement . 0)) (DELAY . 
(compound_statement . 0)) (EXIT . (compound_statement . 0)) (FOR . 
(compound_statement . 0)) (GOTO . (compound_statement . 0)) (IF . 
(compound_statement . 0)) (LOOP . (compound_statement . 0)) (NULL . 
(compound_statement . 0)) (PRAGMA . (compound_statement . 0)) (RAISE . 
(compound_statement . 0)) (REQUEUE . (compound_statement . 0)) (RETURN . 
(compound_statement . 0)) (SELECT . (compound_statement . 0)) (WHILE . 
(compound_statement . 0)) (ELSE . (compound_statement . 0)) (ELSIF . 
(compound_statement . 0)))
+      ((default . error) (LOOP .  654))
+      ((default . error) (NULL .  612) (GOTO .  609) (ABORT .  602) (ACCEPT .  
601) (DECLARE .  605) (BEGIN .  603) (LOOP .  611) (CASE .  604) (IF .  610) 
(PRAGMA .  7) (RAISE .  613) (DELAY .  606) (REQUEUE .  614) (RETURN .  615) 
(EXIT .  607) (IDENTIFIER .  45) (CHARACTER_LITERAL .  47) (STRING_LITERAL .  
46) (WHILE .  617) (FOR .  608) (SELECT .  616))
+      ((default . error) (OR . (compound_statement . 2)) (THEN . 
(compound_statement . 2)) (WHEN . (compound_statement . 2)) (EXCEPTION . 
(compound_statement . 2)) (END . (compound_statement . 2)) (LESS_LESS . 
(compound_statement . 2)) (IDENTIFIER . (compound_statement . 2)) 
(STRING_LITERAL . (compound_statement . 2)) (CHARACTER_LITERAL . 
(compound_statement . 2)) (ACCEPT . (compound_statement . 2)) (ABORT . 
(compound_statement . 2)) (BEGIN . (compound_statement . 2)) (CASE . 
(compound_statement . 2)) (DECLARE . (compound_statement . 2)) (DELAY . 
(compound_statement . 2)) (EXIT . (compound_statement . 2)) (FOR . 
(compound_statement . 2)) (GOTO . (compound_statement . 2)) (IF . 
(compound_statement . 2)) (LOOP . (compound_statement . 2)) (NULL . 
(compound_statement . 2)) (PRAGMA . (compound_statement . 2)) (RAISE . 
(compound_statement . 2)) (REQUEUE . (compound_statement . 2)) (RETURN . 
(compound_statement . 2)) (SELECT . (compound_statement . 2)) (WHILE . 
(compound_statement . 2)) (ELSE . (compound_statement . 2)) (ELSIF . 
(compound_statement . 2)))
+      ((default . error) (DOT .  84) (SEMICOLON .  651) (TICK .  85) 
(COLON_EQUAL .  650) (LEFT_PAREN .  103))
+      ((default . error) (OR . (simple_statement . 10)) (THEN . 
(simple_statement . 10)) (WHEN . (simple_statement . 10)) (EXCEPTION . 
(simple_statement . 10)) (END . (simple_statement . 10)) (LESS_LESS . 
(simple_statement . 10)) (IDENTIFIER . (simple_statement . 10)) (STRING_LITERAL 
. (simple_statement . 10)) (CHARACTER_LITERAL . (simple_statement . 10)) 
(ACCEPT . (simple_statement . 10)) (ABORT . (simple_statement . 10)) (BEGIN . 
(simple_statement . 10)) (CASE . (simple_statement . 10)) (DECLARE . 
(simple_statement . 10)) (DELAY . (simple_statement . 10)) (EXIT . 
(simple_statement . 10)) (FOR . (simple_statement . 10)) (GOTO . 
(simple_statement . 10)) (IF . (simple_statement . 10)) (LOOP . 
(simple_statement . 10)) (NULL . (simple_statement . 10)) (PRAGMA . 
(simple_statement . 10)) (RAISE . (simple_statement . 10)) (REQUEUE . 
(simple_statement . 10)) (RETURN . (simple_statement . 10)) (SELECT . 
(simple_statement . 10)) (WHILE . (simple_statement . 10)) (ELSE . 
(simple_statement . 10)) (ELSIF . (simple_statement . 10)))
+      ((default . error) (OR . (simple_statement . 4)) (THEN . 
(simple_statement . 4)) (WHEN . (simple_statement . 4)) (EXCEPTION . 
(simple_statement . 4)) (END . (simple_statement . 4)) (LESS_LESS . 
(simple_statement . 4)) (IDENTIFIER . (simple_statement . 4)) (STRING_LITERAL . 
(simple_statement . 4)) (CHARACTER_LITERAL . (simple_statement . 4)) (ACCEPT . 
(simple_statement . 4)) (ABORT . (simple_statement . 4)) (BEGIN . 
(simple_statement . 4)) (CASE . (simple_statement . 4)) (DECLARE . 
(simple_statement . 4)) (DELAY . (simple_statement . 4)) (EXIT . 
(simple_statement . 4)) (FOR . (simple_statement . 4)) (GOTO . 
(simple_statement . 4)) (IF . (simple_statement . 4)) (LOOP . (simple_statement 
. 4)) (NULL . (simple_statement . 4)) (PRAGMA . (simple_statement . 4)) (RAISE 
. (simple_statement . 4)) (REQUEUE . (simple_statement . 4)) (RETURN . 
(simple_statement . 4)) (SELECT . (simple_statement . 4)) (WHILE . 
(simple_statement . 4)) (ELSE . (simple_statement . 4)) (ELSIF . 
(simple_statement . 4)))
+      ((default . error) (OR . (simple_statement . 9)) (THEN . 
(simple_statement . 9)) (WHEN . (simple_statement . 9)) (EXCEPTION . 
(simple_statement . 9)) (END . (simple_statement . 9)) (LESS_LESS . 
(simple_statement . 9)) (IDENTIFIER . (simple_statement . 9)) (STRING_LITERAL . 
(simple_statement . 9)) (CHARACTER_LITERAL . (simple_statement . 9)) (ACCEPT . 
(simple_statement . 9)) (ABORT . (simple_statement . 9)) (BEGIN . 
(simple_statement . 9)) (CASE . (simple_statement . 9)) (DECLARE . 
(simple_statement . 9)) (DELAY . (simple_statement . 9)) (EXIT . 
(simple_statement . 9)) (FOR . (simple_statement . 9)) (GOTO . 
(simple_statement . 9)) (IF . (simple_statement . 9)) (LOOP . (simple_statement 
. 9)) (NULL . (simple_statement . 9)) (PRAGMA . (simple_statement . 9)) (RAISE 
. (simple_statement . 9)) (REQUEUE . (simple_statement . 9)) (RETURN . 
(simple_statement . 9)) (SELECT . (simple_statement . 9)) (WHILE . 
(simple_statement . 9)) (ELSE . (simple_statement . 9)) (ELSIF . 
(simple_statement . 9)))
+      ((default . error) (OR . (simple_statement . 6)) (THEN . 
(simple_statement . 6)) (WHEN . (simple_statement . 6)) (EXCEPTION . 
(simple_statement . 6)) (END . (simple_statement . 6)) (LESS_LESS . 
(simple_statement . 6)) (IDENTIFIER . (simple_statement . 6)) (STRING_LITERAL . 
(simple_statement . 6)) (CHARACTER_LITERAL . (simple_statement . 6)) (ACCEPT . 
(simple_statement . 6)) (ABORT . (simple_statement . 6)) (BEGIN . 
(simple_statement . 6)) (CASE . (simple_statement . 6)) (DECLARE . 
(simple_statement . 6)) (DELAY . (simple_statement . 6)) (EXIT . 
(simple_statement . 6)) (FOR . (simple_statement . 6)) (GOTO . 
(simple_statement . 6)) (IF . (simple_statement . 6)) (LOOP . (simple_statement 
. 6)) (NULL . (simple_statement . 6)) (PRAGMA . (simple_statement . 6)) (RAISE 
. (simple_statement . 6)) (REQUEUE . (simple_statement . 6)) (RETURN . 
(simple_statement . 6)) (SELECT . (simple_statement . 6)) (WHILE . 
(simple_statement . 6)) (ELSE . (simple_statement . 6)) (ELSIF . 
(simple_statement . 6)))
+      ((default . error) (OR . (select_statement . 0)) (THEN . 
(select_statement . 0)) (WHEN . (select_statement . 0)) (EXCEPTION . 
(select_statement . 0)) (END . (select_statement . 0)) (LESS_LESS . 
(select_statement . 0)) (IDENTIFIER . (select_statement . 0)) (STRING_LITERAL . 
(select_statement . 0)) (CHARACTER_LITERAL . (select_statement . 0)) (ACCEPT . 
(select_statement . 0)) (ABORT . (select_statement . 0)) (BEGIN . 
(select_statement . 0)) (CASE . (select_statement . 0)) (DECLARE . 
(select_statement . 0)) (DELAY . (select_statement . 0)) (EXIT . 
(select_statement . 0)) (FOR . (select_statement . 0)) (GOTO . 
(select_statement . 0)) (IF . (select_statement . 0)) (LOOP . (select_statement 
. 0)) (NULL . (select_statement . 0)) (PRAGMA . (select_statement . 0)) (RAISE 
. (select_statement . 0)) (REQUEUE . (select_statement . 0)) (RETURN . 
(select_statement . 0)) (SELECT . (select_statement . 0)) (WHILE . 
(select_statement . 0)) (ELSE . (select_statement . 0)) (ELSIF . 
(select_statement . 0)))
+      ((default . error) (OR . (compound_statement . 6)) (THEN . 
(compound_statement . 6)) (WHEN . (compound_statement . 6)) (EXCEPTION . 
(compound_statement . 6)) (END . (compound_statement . 6)) (LESS_LESS . 
(compound_statement . 6)) (IDENTIFIER . (compound_statement . 6)) 
(STRING_LITERAL . (compound_statement . 6)) (CHARACTER_LITERAL . 
(compound_statement . 6)) (ACCEPT . (compound_statement . 6)) (ABORT . 
(compound_statement . 6)) (BEGIN . (compound_statement . 6)) (CASE . 
(compound_statement . 6)) (DECLARE . (compound_statement . 6)) (DELAY . 
(compound_statement . 6)) (EXIT . (compound_statement . 6)) (FOR . 
(compound_statement . 6)) (GOTO . (compound_statement . 6)) (IF . 
(compound_statement . 6)) (LOOP . (compound_statement . 6)) (NULL . 
(compound_statement . 6)) (PRAGMA . (compound_statement . 6)) (RAISE . 
(compound_statement . 6)) (REQUEUE . (compound_statement . 6)) (RETURN . 
(compound_statement . 6)) (SELECT . (compound_statement . 6)) (WHILE . 
(compound_statement . 6)) (ELSE . (compound_statement . 6)) (ELSIF . 
(compound_statement . 6)))
+      ((default . error) (WHEN . (sequence_of_statements_opt . 1)) (THEN . 
(sequence_of_statements_opt . 1)) (OR . (sequence_of_statements_opt . 1)) 
(ELSIF . (sequence_of_statements_opt . 1)) (ELSE . (sequence_of_statements_opt 
. 1)) (END . (sequence_of_statements_opt . 1)) (EXCEPTION . 
(sequence_of_statements_opt . 1)) (ACCEPT . (label_opt . 0)) (BEGIN . 
(label_opt . 0)) (CASE . (label_opt . 0)) (DECLARE . (label_opt . 0)) (FOR . 
(label_opt . 0)) (IF . (label_opt . 0)) (LOOP . (label_opt . 0)) (RETURN . 
(label_opt . 0)) (SELECT . (label_opt . 0)) (WHILE . (label_opt . 0)) 
(STRING_LITERAL . (label_opt . 0)) (CHARACTER_LITERAL . (label_opt . 0)) (ABORT 
. (label_opt . 0)) (DELAY . (label_opt . 0)) (EXIT . (label_opt . 0)) (GOTO . 
(label_opt . 0)) (NULL . (label_opt . 0)) (PRAGMA . (label_opt . 0)) (RAISE . 
(label_opt . 0)) (REQUEUE . (label_opt . 0)) (LESS_LESS .  599) (IDENTIFIER . 
((label_opt . 0)  600)))
+      ((default . error) (END . (handled_sequence_of_statements . 1)) 
(EXCEPTION .  648))
+      ((default . error) (OR . (simple_statement . 5)) (THEN . 
(simple_statement . 5)) (WHEN . (simple_statement . 5)) (EXCEPTION . 
(simple_statement . 5)) (END . (simple_statement . 5)) (LESS_LESS . 
(simple_statement . 5)) (IDENTIFIER . (simple_statement . 5)) (STRING_LITERAL . 
(simple_statement . 5)) (CHARACTER_LITERAL . (simple_statement . 5)) (ACCEPT . 
(simple_statement . 5)) (ABORT . (simple_statement . 5)) (BEGIN . 
(simple_statement . 5)) (CASE . (simple_statement . 5)) (DECLARE . 
(simple_statement . 5)) (DELAY . (simple_statement . 5)) (EXIT . 
(simple_statement . 5)) (FOR . (simple_statement . 5)) (GOTO . 
(simple_statement . 5)) (IF . (simple_statement . 5)) (LOOP . (simple_statement 
. 5)) (NULL . (simple_statement . 5)) (PRAGMA . (simple_statement . 5)) (RAISE 
. (simple_statement . 5)) (REQUEUE . (simple_statement . 5)) (RETURN . 
(simple_statement . 5)) (SELECT . (simple_statement . 5)) (WHILE . 
(simple_statement . 5)) (ELSE . (simple_statement . 5)) (ELSIF . 
(simple_statement . 5)))
+      ((default . error) (WHEN . (sequence_of_statements . 0)) (THEN . 
(sequence_of_statements . 0)) (OR . (sequence_of_statements . 0)) (ELSIF . 
(sequence_of_statements . 0)) (ELSE . (sequence_of_statements . 0)) (EXCEPTION 
. (sequence_of_statements . 0)) (END . (sequence_of_statements . 0)) (LESS_LESS 
. (sequence_of_statements . 0)) (IDENTIFIER . (sequence_of_statements . 0)) 
(STRING_LITERAL . (sequence_of_statements . 0)) (CHARACTER_LITERAL . 
(sequence_of_statements . 0)) (ACCEPT . (sequence_of_statements . 0)) (ABORT . 
(sequence_of_statements . 0)) (BEGIN . (sequence_of_statements . 0)) (CASE . 
(sequence_of_statements . 0)) (DECLARE . (sequence_of_statements . 0)) (DELAY . 
(sequence_of_statements . 0)) (EXIT . (sequence_of_statements . 0)) (FOR . 
(sequence_of_statements . 0)) (GOTO . (sequence_of_statements . 0)) (IF . 
(sequence_of_statements . 0)) (LOOP . (sequence_of_statements . 0)) (NULL . 
(sequence_of_statements . 0)) (PRAGMA . (sequence_of_statements . 0)) (RAISE . 
(sequence_of_statements . 0)) (REQUEUE . (sequence_of_statements . 0)) (RETURN 
. (sequence_of_statements . 0)) (SELECT . (sequence_of_statements . 0)) (WHILE 
. (sequence_of_statements . 0)))
+      ((default . error) (OR . (select_statement . 1)) (THEN . 
(select_statement . 1)) (WHEN . (select_statement . 1)) (EXCEPTION . 
(select_statement . 1)) (END . (select_statement . 1)) (LESS_LESS . 
(select_statement . 1)) (IDENTIFIER . (select_statement . 1)) (STRING_LITERAL . 
(select_statement . 1)) (CHARACTER_LITERAL . (select_statement . 1)) (ACCEPT . 
(select_statement . 1)) (ABORT . (select_statement . 1)) (BEGIN . 
(select_statement . 1)) (CASE . (select_statement . 1)) (DECLARE . 
(select_statement . 1)) (DELAY . (select_statement . 1)) (EXIT . 
(select_statement . 1)) (FOR . (select_statement . 1)) (GOTO . 
(select_statement . 1)) (IF . (select_statement . 1)) (LOOP . (select_statement 
. 1)) (NULL . (select_statement . 1)) (PRAGMA . (select_statement . 1)) (RAISE 
. (select_statement . 1)) (REQUEUE . (select_statement . 1)) (RETURN . 
(select_statement . 1)) (SELECT . (select_statement . 1)) (WHILE . 
(select_statement . 1)) (ELSE . (select_statement . 1)) (ELSIF . 
(select_statement . 1)))
+      ((default . error) (SEMICOLON .  647))
+      ((default . error) (SEMICOLON .  646))
+      ((default . error) (TYPE . (generic_instantiation . 2)) (TASK . 
(generic_instantiation . 2)) (SUBTYPE . (generic_instantiation . 2)) (PROTECTED 
. (generic_instantiation . 2)) (FOR . (generic_instantiation . 2)) (ENTRY . 
(generic_instantiation . 2)) (IDENTIFIER . (generic_instantiation . 2)) (BEGIN 
. (generic_instantiation . 2)) (END . (generic_instantiation . 2)) (WITH . 
(generic_instantiation . 2)) (USE . (generic_instantiation . 2)) (SEPARATE . 
(generic_instantiation . 2)) (PROCEDURE . (generic_instantiation . 2)) (PRIVATE 
. (generic_instantiation . 2)) (PRAGMA . (generic_instantiation . 2)) (PACKAGE 
. (generic_instantiation . 2)) (OVERRIDING . (generic_instantiation . 2)) (NOT 
. (generic_instantiation . 2)) (LIMITED . (generic_instantiation . 2)) (GENERIC 
. (generic_instantiation . 2)) (FUNCTION . (generic_instantiation . 2)) ($EOI . 
(generic_instantiation . 2)))
+      ((default . error) (TYPE . (generic_instantiation . 1)) (TASK . 
(generic_instantiation . 1)) (SUBTYPE . (generic_instantiation . 1)) (PROTECTED 
. (generic_instantiation . 1)) (FOR . (generic_instantiation . 1)) (ENTRY . 
(generic_instantiation . 1)) (IDENTIFIER . (generic_instantiation . 1)) (BEGIN 
. (generic_instantiation . 1)) (END . (generic_instantiation . 1)) (WITH . 
(generic_instantiation . 1)) (USE . (generic_instantiation . 1)) (SEPARATE . 
(generic_instantiation . 1)) (PROCEDURE . (generic_instantiation . 1)) (PRIVATE 
. (generic_instantiation . 1)) (PRAGMA . (generic_instantiation . 1)) (PACKAGE 
. (generic_instantiation . 1)) (OVERRIDING . (generic_instantiation . 1)) (NOT 
. (generic_instantiation . 1)) (LIMITED . (generic_instantiation . 1)) (GENERIC 
. (generic_instantiation . 1)) (FUNCTION . (generic_instantiation . 1)) ($EOI . 
(generic_instantiation . 1)))
+      ((default . error) (END . (exception_handler_list_opt . 0)) (WHEN .  
920))
+      ((default . error) (OR . (sequence_of_statements . 1)) (THEN . 
(sequence_of_statements . 1)) (WHEN . (sequence_of_statements . 1)) (WHILE . 
(sequence_of_statements . 1)) (SELECT . (sequence_of_statements . 1)) (RETURN . 
(sequence_of_statements . 1)) (REQUEUE . (sequence_of_statements . 1)) (RAISE . 
(sequence_of_statements . 1)) (PRAGMA . (sequence_of_statements . 1)) (NULL . 
(sequence_of_statements . 1)) (LOOP . (sequence_of_statements . 1)) (IF . 
(sequence_of_statements . 1)) (GOTO . (sequence_of_statements . 1)) (FOR . 
(sequence_of_statements . 1)) (EXIT . (sequence_of_statements . 1)) (DELAY . 
(sequence_of_statements . 1)) (DECLARE . (sequence_of_statements . 1)) (CASE . 
(sequence_of_statements . 1)) (BEGIN . (sequence_of_statements . 1)) (ABORT . 
(sequence_of_statements . 1)) (ACCEPT . (sequence_of_statements . 1)) 
(CHARACTER_LITERAL . (sequence_of_statements . 1)) (STRING_LITERAL . 
(sequence_of_statements . 1)) (IDENTIFIER . (sequence_of_statements . 1)) 
(LESS_LESS . (sequence_of_statements . 1)) (END . (sequence_of_statements . 1)) 
(EXCEPTION . (sequence_of_statements . 1)) (ELSE . (sequence_of_statements . 
1)) (ELSIF . (sequence_of_statements . 1)))
+      ((default . error) (PLUS .  136) (MINUS .  135) (ABS .  138) (NOT .  
141) (NULL .  142) (NEW .  140) (IDENTIFIER .  45) (CHARACTER_LITERAL .  47) 
(STRING_LITERAL .  46) (LEFT_PAREN .  139))
+      ((default . error) (WHEN . (procedure_call_statement . 0)) (OR . 
(procedure_call_statement . 0)) (THEN . (procedure_call_statement . 0)) (ELSIF 
. (procedure_call_statement . 0)) (ELSE . (procedure_call_statement . 0)) 
(WHILE . (procedure_call_statement . 0)) (SELECT . (procedure_call_statement . 
0)) (RETURN . (procedure_call_statement . 0)) (REQUEUE . 
(procedure_call_statement . 0)) (RAISE . (procedure_call_statement . 0)) 
(PRAGMA . (procedure_call_statement . 0)) (NULL . (procedure_call_statement . 
0)) (LOOP . (procedure_call_statement . 0)) (IF . (procedure_call_statement . 
0)) (GOTO . (procedure_call_statement . 0)) (FOR . (procedure_call_statement . 
0)) (EXIT . (procedure_call_statement . 0)) (DELAY . (procedure_call_statement 
. 0)) (DECLARE . (procedure_call_statement . 0)) (CASE . 
(procedure_call_statement . 0)) (BEGIN . (procedure_call_statement . 0)) (ABORT 
. (procedure_call_statement . 0)) (ACCEPT . (procedure_call_statement . 0)) 
(CHARACTER_LITERAL . (procedure_call_statement . 0)) (STRING_LITERAL . 
(procedure_call_statement . 0)) (IDENTIFIER . (procedure_call_statement . 0)) 
(LESS_LESS . (procedure_call_statement . 0)) (END . (procedure_call_statement . 
0)) (EXCEPTION . (procedure_call_statement . 0)))
+      ((default . error) (OR . (statement . 1)) (THEN . (statement . 1)) (WHEN 
. (statement . 1)) (EXCEPTION . (statement . 1)) (END . (statement . 1)) 
(LESS_LESS . (statement . 1)) (IDENTIFIER . (statement . 1)) (STRING_LITERAL . 
(statement . 1)) (CHARACTER_LITERAL . (statement . 1)) (ACCEPT . (statement . 
1)) (ABORT . (statement . 1)) (BEGIN . (statement . 1)) (CASE . (statement . 
1)) (DECLARE . (statement . 1)) (DELAY . (statement . 1)) (EXIT . (statement . 
1)) (FOR . (statement . 1)) (GOTO . (statement . 1)) (IF . (statement . 1)) 
(LOOP . (statement . 1)) (NULL . (statement . 1)) (PRAGMA . (statement . 1)) 
(RAISE . (statement . 1)) (REQUEUE . (statement . 1)) (RETURN . (statement . 
1)) (SELECT . (statement . 1)) (WHILE . (statement . 1)) (ELSE . (statement . 
1)) (ELSIF . (statement . 1)))
+      ((default . error) (OR . (statement . 0)) (THEN . (statement . 0)) (WHEN 
. (statement . 0)) (EXCEPTION . (statement . 0)) (END . (statement . 0)) 
(LESS_LESS . (statement . 0)) (IDENTIFIER . (statement . 0)) (STRING_LITERAL . 
(statement . 0)) (CHARACTER_LITERAL . (statement . 0)) (ACCEPT . (statement . 
0)) (ABORT . (statement . 0)) (BEGIN . (statement . 0)) (CASE . (statement . 
0)) (DECLARE . (statement . 0)) (DELAY . (statement . 0)) (EXIT . (statement . 
0)) (FOR . (statement . 0)) (GOTO . (statement . 0)) (IF . (statement . 0)) 
(LOOP . (statement . 0)) (NULL . (statement . 0)) (PRAGMA . (statement . 0)) 
(RAISE . (statement . 0)) (REQUEUE . (statement . 0)) (RETURN . (statement . 
0)) (SELECT . (statement . 0)) (WHILE . (statement . 0)) (ELSE . (statement . 
0)) (ELSIF . (statement . 0)))
+      ((default . error) (END . (sequence_of_statements_opt . 0)) (ACCEPT . 
(label_opt . 0)) (BEGIN . (label_opt . 0)) (CASE . (label_opt . 0)) (DECLARE . 
(label_opt . 0)) (FOR . (label_opt . 0)) (IF . (label_opt . 0)) (LOOP . 
(label_opt . 0)) (RETURN . (label_opt . 0)) (SELECT . (label_opt . 0)) (WHILE . 
(label_opt . 0)) (STRING_LITERAL . (label_opt . 0)) (CHARACTER_LITERAL . 
(label_opt . 0)) (ABORT . (label_opt . 0)) (DELAY . (label_opt . 0)) (EXIT . 
(label_opt . 0)) (GOTO . (label_opt . 0)) (NULL . (label_opt . 0)) (PRAGMA . 
(label_opt . 0)) (RAISE . (label_opt . 0)) (REQUEUE . (label_opt . 0)) 
(LESS_LESS .  599) (IDENTIFIER . ((label_opt . 0)  600)))
+      ((default . error) (SEMICOLON . (name_opt . 0)) (IDENTIFIER .  45) 
(CHARACTER_LITERAL .  47) (STRING_LITERAL .  46))
+      ((default . error) (LOOP . (iteration_scheme . 0)))
+      ((default . error) (SEMICOLON .  916))
+      ((default . error) (PLUS .  136) (MINUS .  135) (ABS .  138) (NOT .  
141) (NULL .  142) (NEW .  140) (IDENTIFIER .  45) (CHARACTER_LITERAL .  47) 
(STRING_LITERAL .  46) (LEFT_PAREN .  139))
+      ((default . error) (END . (sequence_of_statements_opt . 0)) (OR . 
(sequence_of_statements_opt . 0)) (ELSE . (sequence_of_statements_opt . 0)) 
(ACCEPT . (label_opt . 0)) (BEGIN . (label_opt . 0)) (CASE . (label_opt . 0)) 
(DECLARE . (label_opt . 0)) (FOR . (label_opt . 0)) (IF . (label_opt . 0)) 
(LOOP . (label_opt . 0)) (RETURN . (label_opt . 0)) (SELECT . (label_opt . 0)) 
(WHILE . (label_opt . 0)) (STRING_LITERAL . (label_opt . 0)) (CHARACTER_LITERAL 
. (label_opt . 0)) (ABORT . (label_opt . 0)) (DELAY . (label_opt . 0)) (EXIT . 
(label_opt . 0)) (GOTO . (label_opt . 0)) (NULL . (label_opt . 0)) (PRAGMA . 
(label_opt . 0)) (RAISE . (label_opt . 0)) (REQUEUE . (label_opt . 0)) 
(LESS_LESS .  599) (IDENTIFIER . ((label_opt . 0)  600)))
+      ((default . error) (ELSE . (select_alternative . 3)) (OR . 
(select_alternative . 3)) (END . (select_alternative . 3)))
+      ((default . error) (OR . (sequence_of_statements_opt . 0)) (END . 
(sequence_of_statements_opt . 0)) (ELSE . (sequence_of_statements_opt . 0)) 
(THEN . (sequence_of_statements_opt . 0)) (ACCEPT . (label_opt . 0)) (BEGIN . 
(label_opt . 0)) (CASE . (label_opt . 0)) (DECLARE . (label_opt . 0)) (FOR . 
(label_opt . 0)) (IF . (label_opt . 0)) (LOOP . (label_opt . 0)) (RETURN . 
(label_opt . 0)) (SELECT . (label_opt . 0)) (WHILE . (label_opt . 0)) 
(STRING_LITERAL . (label_opt . 0)) (CHARACTER_LITERAL . (label_opt . 0)) (ABORT 
. (label_opt . 0)) (DELAY . (label_opt . 0)) (EXIT . (label_opt . 0)) (GOTO . 
(label_opt . 0)) (NULL . (label_opt . 0)) (PRAGMA . (label_opt . 0)) (RAISE . 
(label_opt . 0)) (REQUEUE . (label_opt . 0)) (LESS_LESS .  599) (IDENTIFIER . 
((label_opt . 0)  600)))
+      ((default . error) (ELSE .  911) (OR .  912))
+      ((default . error) (DOT .  84) (SEMICOLON .  651) (TICK .  85) (OR . 
(sequence_of_statements_opt . 0)) (ELSE . (sequence_of_statements_opt . 0)) 
(THEN . (sequence_of_statements_opt . 0)) (LEFT_PAREN .  103) (ACCEPT . 
(label_opt . 0)) (BEGIN . (label_opt . 0)) (CASE . (label_opt . 0)) (DECLARE . 
(label_opt . 0)) (FOR . (label_opt . 0)) (IF . (label_opt . 0)) (LOOP . 
(label_opt . 0)) (RETURN . (label_opt . 0)) (SELECT . (label_opt . 0)) (WHILE . 
(label_opt . 0)) (STRING_LITERAL . (label_opt . 0)) (CHARACTER_LITERAL . 
(label_opt . 0)) (ABORT . (label_opt . 0)) (DELAY . (label_opt . 0)) (EXIT . 
(label_opt . 0)) (GOTO . (label_opt . 0)) (NULL . (label_opt . 0)) (PRAGMA . 
(label_opt . 0)) (RAISE . (label_opt . 0)) (REQUEUE . (label_opt . 0)) 
(LESS_LESS .  599) (IDENTIFIER . ((label_opt . 0)  600)))
+      ((default . error) (OR . (sequence_of_statements_opt . 0)) (ELSE . 
(sequence_of_statements_opt . 0)) (THEN . (sequence_of_statements_opt . 0)) 
(ACCEPT . (label_opt . 0)) (BEGIN . (label_opt . 0)) (CASE . (label_opt . 0)) 
(DECLARE . (label_opt . 0)) (FOR . (label_opt . 0)) (IF . (label_opt . 0)) 
(LOOP . (label_opt . 0)) (RETURN . (label_opt . 0)) (SELECT . (label_opt . 0)) 
(WHILE . (label_opt . 0)) (STRING_LITERAL . (label_opt . 0)) (CHARACTER_LITERAL 
. (label_opt . 0)) (ABORT . (label_opt . 0)) (DELAY . (label_opt . 0)) (EXIT . 
(label_opt . 0)) (GOTO . (label_opt . 0)) (NULL . (label_opt . 0)) (PRAGMA . 
(label_opt . 0)) (RAISE . (label_opt . 0)) (REQUEUE . (label_opt . 0)) 
(LESS_LESS .  599) (IDENTIFIER . ((label_opt . 0)  600)))
+      ((default . error) (ELSE . (select_alternative_list . 0)) (END . 
(select_alternative_list . 0)) (OR . (select_alternative_list . 0)))
+      ((default . error) (ELSE . (select_alternative_list_opt . 1)) (END . 
(select_alternative_list_opt . 1)) (OR .  908))
+      ((default . error) (ELSE .  906) (END .  907))
+      ((default . error) (THEN .  905))
+      ((default . error) (WHEN . (simple_return_statement . 0)) (THEN . 
(simple_return_statement . 0)) (OR . (simple_return_statement . 0)) (ELSIF . 
(simple_return_statement . 0)) (ELSE . (simple_return_statement . 0)) (WHILE . 
(simple_return_statement . 0)) (SELECT . (simple_return_statement . 0)) (RETURN 
. (simple_return_statement . 0)) (REQUEUE . (simple_return_statement . 0)) 
(RAISE . (simple_return_statement . 0)) (PRAGMA . (simple_return_statement . 
0)) (NULL . (simple_return_statement . 0)) (LOOP . (simple_return_statement . 
0)) (IF . (simple_return_statement . 0)) (GOTO . (simple_return_statement . 0)) 
(FOR . (simple_return_statement . 0)) (EXIT . (simple_return_statement . 0)) 
(DELAY . (simple_return_statement . 0)) (DECLARE . (simple_return_statement . 
0)) (CASE . (simple_return_statement . 0)) (BEGIN . (simple_return_statement . 
0)) (ABORT . (simple_return_statement . 0)) (ACCEPT . (simple_return_statement 
. 0)) (CHARACTER_LITERAL . (simple_return_statement . 0)) (STRING_LITERAL . 
(simple_return_statement . 0)) (IDENTIFIER . (simple_return_statement . 0)) 
(LESS_LESS . (simple_return_statement . 0)) (END . (simple_return_statement . 
0)) (EXCEPTION . (simple_return_statement . 0)))
+      ((default . error) (COLON .  904) (STAR_STAR . (name . 0)) (REM . (name 
. 0)) (MOD . (name . 0)) (STAR . (name . 0)) (SLASH . (name . 0)) (SEMICOLON . 
(name . 0)) (SLASH_EQUAL . (name . 0)) (LESS_EQUAL . (name . 0)) (LESS . (name 
. 0)) (GREATER_EQUAL . (name . 0)) (GREATER . (name . 0)) (EQUAL . (name . 0)) 
(NOT . (name . 0)) (IN . (name . 0)) (AMPERSAND . (name . 0)) (MINUS . (name . 
0)) (PLUS . (name . 0)) (LEFT_PAREN . (name . 0)) (AND . (name . 0)) (OR . 
(name . 0)) (XOR . (name . 0)) (DOT . (name . 0)) (TICK . (name . 0)))
+      ((default . error) (SEMICOLON .  903))
+      ((default . error) (DO . (extended_return_object_declaration_opt . 1)) 
(SEMICOLON .  902))
+      ((default . error) (DO .  901))
+      ((default . error) (WITH .  900) (DOT .  84) (TICK .  85) (SEMICOLON .  
899) (LEFT_PAREN .  103))
+      ((default . error) (WHEN . (raise_statement . 0)) (THEN . 
(raise_statement . 0)) (OR . (raise_statement . 0)) (ELSIF . (raise_statement . 
0)) (ELSE . (raise_statement . 0)) (WHILE . (raise_statement . 0)) (SELECT . 
(raise_statement . 0)) (RETURN . (raise_statement . 0)) (REQUEUE . 
(raise_statement . 0)) (RAISE . (raise_statement . 0)) (PRAGMA . 
(raise_statement . 0)) (NULL . (raise_statement . 0)) (LOOP . (raise_statement 
. 0)) (IF . (raise_statement . 0)) (GOTO . (raise_statement . 0)) (FOR . 
(raise_statement . 0)) (EXIT . (raise_statement . 0)) (DELAY . (raise_statement 
. 0)) (DECLARE . (raise_statement . 0)) (CASE . (raise_statement . 0)) (BEGIN . 
(raise_statement . 0)) (ABORT . (raise_statement . 0)) (ACCEPT . 
(raise_statement . 0)) (CHARACTER_LITERAL . (raise_statement . 0)) 
(STRING_LITERAL . (raise_statement . 0)) (IDENTIFIER . (raise_statement . 0)) 
(LESS_LESS . (raise_statement . 0)) (END . (raise_statement . 0)) (EXCEPTION . 
(raise_statement . 0)))
+      ((default . error) (WITH .  898) (DOT .  84) (TICK .  85) (SEMICOLON .  
897) (LEFT_PAREN .  103))
+      ((default . error) (WHEN . (simple_statement . 0)) (THEN . 
(simple_statement . 0)) (OR . (simple_statement . 0)) (ELSIF . 
(simple_statement . 0)) (ELSE . (simple_statement . 0)) (WHILE . 
(simple_statement . 0)) (SELECT . (simple_statement . 0)) (RETURN . 
(simple_statement . 0)) (REQUEUE . (simple_statement . 0)) (RAISE . 
(simple_statement . 0)) (PRAGMA . (simple_statement . 0)) (NULL . 
(simple_statement . 0)) (LOOP . (simple_statement . 0)) (IF . (simple_statement 
. 0)) (GOTO . (simple_statement . 0)) (FOR . (simple_statement . 0)) (EXIT . 
(simple_statement . 0)) (DELAY . (simple_statement . 0)) (DECLARE . 
(simple_statement . 0)) (CASE . (simple_statement . 0)) (BEGIN . 
(simple_statement . 0)) (ABORT . (simple_statement . 0)) (ACCEPT . 
(simple_statement . 0)) (CHARACTER_LITERAL . (simple_statement . 0)) 
(STRING_LITERAL . (simple_statement . 0)) (IDENTIFIER . (simple_statement . 0)) 
(LESS_LESS . (simple_statement . 0)) (END . (simple_statement . 0)) (EXCEPTION 
. (simple_statement . 0)))
+      ((default . error) (END .  896))
+      ((default . error) (THEN .  895))
+      ((default . error) (SEMICOLON .  894))
+      ((default . error) (LOOP . (iterator_specification_opt . 1)))
+      ((default . error) (LOOP . (iteration_scheme . 1)))
+      ((default . error) (WHEN . (identifier_opt . 1)) (SEMICOLON . 
(identifier_opt . 1)))
+      ((default . error) (WHEN .  893) (SEMICOLON .  892))
+      ((default . error) (PLUS .  136) (MINUS .  135) (ABS .  138) (NOT .  
141) (NULL .  142) (NEW .  140) (IDENTIFIER .  45) (CHARACTER_LITERAL .  47) 
(STRING_LITERAL .  46) (LEFT_PAREN .  139))
+      ((default . error) (SEMICOLON .  890))
+      ((default . error) (BEGIN .  889))
+      ((default . error) (IS .  888))
+      ((default . error) (END .  887))
+      ((default . error) (DOT .  84) (TICK .  85) (SEMICOLON .  886) 
(LEFT_PAREN .  103))
+      ((default . error) (SEMICOLON . (actual_parameter_part_opt . 0)) (DO . 
(actual_parameter_part_opt . 0)) (LEFT_PAREN . ((actual_parameter_part_opt . 0) 
 883)))
+      ((default . error) (REQUEUE . (label_opt . 2)) (RAISE . (label_opt . 2)) 
(PRAGMA . (label_opt . 2)) (NULL . (label_opt . 2)) (GOTO . (label_opt . 2)) 
(EXIT . (label_opt . 2)) (DELAY . (label_opt . 2)) (ABORT . (label_opt . 2)) 
(CHARACTER_LITERAL . (label_opt . 2)) (STRING_LITERAL . (label_opt . 2)) 
(IDENTIFIER . (label_opt . 2)) (WHILE . (label_opt . 2)) (SELECT . (label_opt . 
2)) (RETURN . (label_opt . 2)) (LOOP . (label_opt . 2)) (IF . (label_opt . 2)) 
(FOR . (label_opt . 2)) (DECLARE . (label_opt . 2)) (CASE . (label_opt . 2)) 
(BEGIN . (label_opt . 2)) (ACCEPT . (label_opt . 2)))
+      ((default . error) (GREATER_GREATER .  882))
+      ((default . error) (IS .  881))
+      ((default . error) (IS .  880))
+      ((default . error) (COMMA . (pragma_argument_association . 2)) 
(RIGHT_PAREN . (pragma_argument_association . 2)))
+      ((default . error) (ELSE .  876) (RIGHT_PAREN . (if_expression . 3)) 
(ELSIF .  877))
+      ((default . error) (PLUS .  136) (MINUS .  135) (ABS .  138) (NOT .  
141) (NULL .  142) (NEW .  140) (IDENTIFIER .  45) (CHARACTER_LITERAL .  47) 
(STRING_LITERAL .  46) (LEFT_PAREN .  139))
+      ((default . error) (NOT .  724) (IDENTIFIER .  45) (CHARACTER_LITERAL .  
47) (STRING_LITERAL .  46))
+      ((default . error) (REVERSE .  872) (IDENTIFIER .  45) 
(CHARACTER_LITERAL .  47) (STRING_LITERAL .  46) (PLUS .  136) (MINUS .  135) 
(ABS .  138) (NOT .  750) (NULL .  142) (NEW .  140) (LEFT_PAREN .  139))
+      ((default . error) (REVERSE .  870) (IDENTIFIER .  45) 
(CHARACTER_LITERAL .  47) (STRING_LITERAL .  46))
+      ((default . error) (EQUAL_GREATER . (discrete_choice_list . 0)) (BAR . 
(discrete_choice_list . 0)) (OTHERS .  165) (IDENTIFIER .  45) 
(CHARACTER_LITERAL .  47) (STRING_LITERAL .  46) (PLUS .  136) (MINUS .  135) 
(ABS .  138) (NOT .  164) (NULL .  142) (NEW .  140) (LEFT_PAREN .  139))
+      ((default . error) (RIGHT_PAREN . (case_expression_alternative_list . 
0)) (COMMA . (case_expression_alternative_list . 0)))
+      ((default . error) (COMMA .  868) (RIGHT_PAREN . (case_expression . 0)))
+      ((default . error) (DOT .  84) (SEMICOLON . (name_opt . 1)) (TICK .  85) 
(LEFT_PAREN .  103))
+      ((default . error) (SEMICOLON .  867))
+      ((default . error) (END .  866))
+      ((default . error) (IDENTIFIER .  202) (CHARACTER_LITERAL .  47) 
(STRING_LITERAL .  46) (PLUS .  136) (MINUS .  135) (ABS .  138) (NOT .  750) 
(NULL .  142) (NEW .  140) (LEFT_PAREN .  139))
+      ((default . error) (SEMICOLON . (aspect_specification_opt . 0)) (WITH .  
104))
+      ((default . error) (SEMICOLON . (aspect_specification_opt . 0)) (WITH .  
104))
+      ((default . error) (DOT .  84) (TICK .  85) (SEMICOLON . 
(aspect_specification_opt . 0)) (WITH .  104) (LEFT_PAREN .  103))
+      ((default . error) (SEMICOLON . (aspect_specification_opt . 0)) (WITH .  
104))
+      ((default . error) (SEMICOLON . (aspect_specification_opt . 0)) (WITH .  
104))
+      ((default . error) (ARRAY . (constant_opt . 1)) (IDENTIFIER . 
(constant_opt . 1)) (STRING_LITERAL . (constant_opt . 1)) (CHARACTER_LITERAL . 
(constant_opt . 1)) (ACCESS . (constant_opt . 1)) (NOT . (constant_opt . 1)))
+      ((default . error) (ARRAY .  467) (IDENTIFIER .  45) (CHARACTER_LITERAL 
.  47) (STRING_LITERAL .  46) (ACCESS . (null_exclusion_opt . 0)) (NOT .  855))
+      ((default . error) (USE . (exception_declaration . 0)) (TYPE . 
(exception_declaration . 0)) (TASK . (exception_declaration . 0)) (SUBTYPE . 
(exception_declaration . 0)) (PROTECTED . (exception_declaration . 0)) 
(PROCEDURE . (exception_declaration . 0)) (PRAGMA . (exception_declaration . 
0)) (PACKAGE . (exception_declaration . 0)) (OVERRIDING . 
(exception_declaration . 0)) (NOT . (exception_declaration . 0)) (GENERIC . 
(exception_declaration . 0)) (FUNCTION . (exception_declaration . 0)) (FOR . 
(exception_declaration . 0)) (ENTRY . (exception_declaration . 0)) (IDENTIFIER 
. (exception_declaration . 0)) (BEGIN . (exception_declaration . 0)) (END . 
(exception_declaration . 0)) (PRIVATE . (exception_declaration . 0)))
+      ((default . error) (PLUS .  136) (MINUS .  135) (ABS .  138) (NOT .  
141) (NULL .  142) (NEW .  140) (IDENTIFIER .  45) (CHARACTER_LITERAL .  47) 
(STRING_LITERAL .  46) (LEFT_PAREN .  139))
+      ((default . error) (IDENTIFIER .  45) (CHARACTER_LITERAL .  47) 
(STRING_LITERAL .  46))
+      ((default . error) (PRIVATE . (abstract_tagged_limited_opt . 0)) (NULL . 
(abstract_tagged_limited_opt . 0)) (RECORD . (abstract_tagged_limited_opt . 0)) 
(TAGGED .  842) (RANGE .  839) (MOD .  837) (DIGITS .  834) (DELTA .  833) 
(TASK .  479) (PROTECTED .  475) (SYNCHRONIZED .  841) (INTERFACE .  470) 
(ARRAY .  467) (LEFT_PAREN .  835) (ACCESS . (null_exclusion_opt . 0)) (NOT .  
198) (NEW . ((abstract_limited_synchronized_opt . 0) (abstract_limited_opt . 
0))) (LIMITED .  836) (ABSTRACT .  832))
+      ((default . error) (BEGIN . (single_task_declaration . 2)) (IDENTIFIER . 
(single_task_declaration . 2)) (ENTRY . (single_task_declaration . 2)) (FOR . 
(single_task_declaration . 2)) (FUNCTION . (single_task_declaration . 2)) 
(GENERIC . (single_task_declaration . 2)) (NOT . (single_task_declaration . 2)) 
(OVERRIDING . (single_task_declaration . 2)) (PACKAGE . 
(single_task_declaration . 2)) (PRAGMA . (single_task_declaration . 2)) 
(PROCEDURE . (single_task_declaration . 2)) (PROTECTED . 
(single_task_declaration . 2)) (SUBTYPE . (single_task_declaration . 2)) (TASK 
. (single_task_declaration . 2)) (TYPE . (single_task_declaration . 2)) (USE . 
(single_task_declaration . 2)) (PRIVATE . (single_task_declaration . 2)) (END . 
(single_task_declaration . 2)))
+      ((default . error) (NEW .  829) (END . (declarative_part_opt . 0)) 
(PRIVATE . (declarative_part_opt . 0)) (USE .  11) (SUBTYPE .  282) (PRAGMA .  
7) (NOT .  4) (OVERRIDING .  5) (FUNCTION . (overriding_indicator_opt . 2)) 
(PROCEDURE . (overriding_indicator_opt . 2)) (ENTRY . (overriding_indicator_opt 
. 2)) (FOR .  279) (IDENTIFIER .  278) (TYPE .  284) (GENERIC .  2) (PROTECTED 
.  281) (TASK .  283) (PACKAGE .  280))
+      ((default . error) (SEPARATE .  828))
+      ((default . error) (SEMICOLON . (aspect_specification_opt . 0)) (IS . 
(aspect_specification_opt . 0)) (WITH .  104))
+      ((default . error) (NULL .  826))
+      ((default . error) (DO . (subtype_indication . 3)) (OF . 
(subtype_indication . 3)) (AND . (subtype_indication . 3)) (SEMICOLON . 
(subtype_indication . 3)) (WITH . (subtype_indication . 3)) (COLON_EQUAL . 
(subtype_indication . 3)) (DOT .  84) (TICK .  85) (RANGE .  825) (LEFT_PAREN . 
 792))
+      ((default . error) (SEMICOLON . (aspect_specification_opt . 0)) (WITH .  
104))
+      ((default . error) (NEW .  821) (END . (declarative_part_opt . 0)) 
(PRIVATE . (declarative_part_opt . 0)) (USE .  11) (SUBTYPE .  282) (PRAGMA .  
7) (NOT .  4) (OVERRIDING .  5) (FUNCTION . (overriding_indicator_opt . 2)) 
(PROCEDURE . (overriding_indicator_opt . 2)) (ENTRY . (overriding_indicator_opt 
. 2)) (FOR .  279) (IDENTIFIER .  278) (TYPE .  284) (GENERIC .  2) (PROTECTED 
.  281) (TASK .  283) (PACKAGE .  280))
+      ((default . error) (SEPARATE .  820))
+      ((default . error) (IS . (aspect_specification_opt . 0)) (WITH .  104))
+      ((default . error) (SEPARATE .  818))
+      ((default . error) (DOT .  84) (TICK .  85) (SEMICOLON . 
(aspect_specification_opt . 0)) (WITH .  104) (LEFT_PAREN .  103))
+      ((default . error) (SEMICOLON .  816))
+      ((default . error) (PLUS .  136) (MINUS .  135) (ABS .  138) (NOT .  
141) (NULL .  142) (NEW .  140) (IDENTIFIER .  45) (CHARACTER_LITERAL .  47) 
(STRING_LITERAL .  46) (LEFT_PAREN .  139))
+      ((default . error) (IDENTIFIER . (mod_clause_opt . 0)) (AT .  813))
+      ((default . error) (SEMICOLON .  812))
+      ((default . error) (SEMICOLON .  811))
+      ((default . error) (DOT .  84) (TICK .  85) (RENAMES .  810) (LEFT_PAREN 
.  103))
+      ((default . error) (IDENTIFIER .  45) (CHARACTER_LITERAL .  47) 
(STRING_LITERAL .  46))
+      ((default . error) (IDENTIFIER .  45) (CHARACTER_LITERAL .  47) 
(STRING_LITERAL .  46))
+      ((default . error) (XOR . (choice_relation . 0)) (OR . (choice_relation 
. 0)) (BAR . (choice_relation . 0)) (EQUAL_GREATER . (choice_relation . 0)) 
(AND . (choice_relation . 0)))
+      ((default . error) (RIGHT_PAREN .  807))
+      ((default . error) (DO . (membership_choice_list . 1)) (LOOP . 
(membership_choice_list . 1)) (COMMA . (membership_choice_list . 1)) 
(RIGHT_PAREN . (membership_choice_list . 1)) (ELSIF . (membership_choice_list . 
1)) (ELSE . (membership_choice_list . 1)) (EQUAL_GREATER . 
(membership_choice_list . 1)) (DIGITS . (membership_choice_list . 1)) (RANGE . 
(membership_choice_list . 1)) (THEN . (membership_choice_list . 1)) (SEMICOLON 
. (membership_choice_list . 1)) (WITH . (membership_choice_list . 1)) (IS . 
(membership_choice_list . 1)) (AND . (membership_choice_list . 1)) (OR . 
(membership_choice_list . 1)) (XOR . (membership_choice_list . 1)) (BAR . 
(membership_choice_list . 1)))
+      ((default . error) (PLUS .  136) (MINUS .  135) (ABS .  138) (NOT .  
141) (NULL .  142) (NEW .  140) (IDENTIFIER .  45) (CHARACTER_LITERAL .  47) 
(STRING_LITERAL .  46) (LEFT_PAREN .  139))
+      ((default . error) (PLUS .  136) (MINUS .  135) (ABS .  138) (NOT .  
141) (NULL .  142) (NEW .  140) (IDENTIFIER .  45) (CHARACTER_LITERAL .  47) 
(STRING_LITERAL .  46) (LEFT_PAREN .  139))
+      ((default . error) (ACCESS . (null_exclusion_opt . 1)) (IDENTIFIER .  
803) (CHARACTER_LITERAL .  47) (STRING_LITERAL .  46))
+      ((default . error) (NULL . (abstract_tagged_limited_opt . 1)) (RECORD . 
(abstract_tagged_limited_opt . 1)) (PRIVATE . (abstract_tagged_limited_opt . 
1)))
+      ((default . error) (IDENTIFIER .  45) (CHARACTER_LITERAL .  47) 
(STRING_LITERAL .  46))
+      ((default . error) (DOT .  84) (TICK .  85) (SEMICOLON . 
(formal_derived_type_definition . 6)) (WITH . (formal_derived_type_definition . 
6)) (LEFT_PAREN .  103))
+      ((default . error) (IDENTIFIER .  45) (CHARACTER_LITERAL .  47) 
(STRING_LITERAL .  46))
+      ((default . error) (NULL .  800) (NEW .  140) (IDENTIFIER .  45) 
(CHARACTER_LITERAL .  47) (STRING_LITERAL .  46) (LEFT_PAREN .  139))
+      ((default . error) (RIGHT_PAREN . (discrete_subtype_definition_list . 
0)) (COMMA . (discrete_subtype_definition_list . 0)))
+      ((default . error) (COMMA .  798) (RIGHT_PAREN .  799))
+      ((default . error) (RIGHT_PAREN . (index_subtype_definition_list . 0)) 
(COMMA . (index_subtype_definition_list . 0)))
+      ((default . error) (COMMA .  796) (RIGHT_PAREN .  797))
+      ((default . error) (RIGHT_PAREN . (subtype_indication . 3)) (COMMA . 
(subtype_indication . 3)) (PLUS . (primary . 2)) (MINUS . (primary . 2)) 
(AMPERSAND . (primary . 2)) (DOT_DOT . (primary . 2)) (SLASH . (primary . 2)) 
(STAR . (primary . 2)) (MOD . (primary . 2)) (REM . (primary . 2)) (STAR_STAR . 
(primary . 2)) (DOT .  84) (TICK .  261) (RANGE .  793) (LEFT_PAREN .  792))
+      ((default . error) (LOOP . (discrete_subtype_definition . 1)) 
(EQUAL_GREATER . (discrete_subtype_definition . 1)) (COMMA . 
(discrete_subtype_definition . 1)) (RIGHT_PAREN . (discrete_subtype_definition 
. 1)))
+      ((default . error) (DOT_DOT .  250))
+      ((default . error) (LOOP . (discrete_subtype_definition . 0)) 
(EQUAL_GREATER . (discrete_subtype_definition . 0)) (COMMA . 
(discrete_subtype_definition . 0)) (RIGHT_PAREN . (discrete_subtype_definition 
. 0)))
+      ((default . error) (BOX .  791))
+      ((default . error) (WITH . (formal_type_definition . 2)) (SEMICOLON . 
(formal_type_definition . 2)))
+      ((default . error) (IDENTIFIER .  45) (CHARACTER_LITERAL .  47) 
(STRING_LITERAL .  46))
+      ((default . error) (IDENTIFIER .  45) (CHARACTER_LITERAL .  47) 
(STRING_LITERAL .  46))
+      ((default . error) (IDENTIFIER .  45) (CHARACTER_LITERAL .  47) 
(STRING_LITERAL .  46))
+      ((default . error) (PACKAGE . (formal_type_declaration . 1)) (PROCEDURE 
. (formal_type_declaration . 1)) (FUNCTION . (formal_type_declaration . 1)) 
(IDENTIFIER . (formal_type_declaration . 1)) (PRAGMA . (formal_type_declaration 
. 1)) (TYPE . (formal_type_declaration . 1)) (WITH . (formal_type_declaration . 
1)))
+      ((default . error) (IDENTIFIER .  45) (CHARACTER_LITERAL .  47) 
(STRING_LITERAL .  46))
+      ((default . error) (PACKAGE . (formal_type_declaration . 0)) (PROCEDURE 
. (formal_type_declaration . 0)) (FUNCTION . (formal_type_declaration . 0)) 
(IDENTIFIER . (formal_type_declaration . 0)) (PRAGMA . (formal_type_declaration 
. 0)) (TYPE . (formal_type_declaration . 0)) (WITH . (formal_type_declaration . 
0)))
+      ((default . error) (PACKAGE . (formal_subprogram_declaration . 2)) 
(PROCEDURE . (formal_subprogram_declaration . 2)) (FUNCTION . 
(formal_subprogram_declaration . 2)) (IDENTIFIER . 
(formal_subprogram_declaration . 2)) (PRAGMA . (formal_subprogram_declaration . 
2)) (TYPE . (formal_subprogram_declaration . 2)) (WITH . 
(formal_subprogram_declaration . 2)))
+      ((default . error) (BOX .  785) (IDENTIFIER .  45) (STRING_LITERAL .  
46) (CHARACTER_LITERAL .  163) (RIGHT_PAREN . ((association_opt . 0) 
(expression_opt . 0))) (COMMA . ((association_opt . 0) (expression_opt . 0))) 
(EQUAL_GREATER . (discrete_choice_list . 0)) (BAR . (discrete_choice_list . 0)) 
(PLUS .  136) (MINUS .  135) (OTHERS .  165) (ABS .  138) (NOT .  164) (NULL .  
142) (NEW .  140) (LEFT_PAREN .  139))
+      ((default . error) (SEMICOLON . (aspect_specification_opt . 0)) (WITH .  
104))
+      ((default . error) (PACKAGE . (formal_object_declaration . 1)) 
(PROCEDURE . (formal_object_declaration . 1)) (FUNCTION . 
(formal_object_declaration . 1)) (IDENTIFIER . (formal_object_declaration . 1)) 
(PRAGMA . (formal_object_declaration . 1)) (TYPE . (formal_object_declaration . 
1)) (WITH . (formal_object_declaration . 1)))
+      ((default . error) (SEMICOLON . (aspect_specification_opt . 0)) (WITH .  
104))
+      ((default . error) (SEMICOLON .  782))
+      ((default . error) (IDENTIFIER .  69))
+      ((default . error) (RENAMES . (access_definition . 1)) (DO . 
(access_definition . 1)) (RIGHT_PAREN . (access_definition . 1)) (IS . 
(access_definition . 1)) (SEMICOLON . (access_definition . 1)) (WITH . 
(access_definition . 1)) (COLON_EQUAL . (access_definition . 1)))
+      ((default . error) (RENAMES . (access_definition . 2)) (DO . 
(access_definition . 2)) (RIGHT_PAREN . (access_definition . 2)) (IS . 
(access_definition . 2)) (SEMICOLON . (access_definition . 2)) (WITH . 
(access_definition . 2)) (COLON_EQUAL . (access_definition . 2)))
+      ((default . error) (SEMICOLON . (parameter_specification . 2)) 
(RIGHT_PAREN . (parameter_specification . 2)))
+      ((default . error) (IDENTIFIER .  45) (CHARACTER_LITERAL .  47) 
(STRING_LITERAL .  46))
+      ((default . error) (DO . (aggregate . 1)) (LOOP . (aggregate . 1)) 
(RENAMES . (aggregate . 1)) (USE . (aggregate . 1)) (COLON_EQUAL . (aggregate . 
1)) (WHILE . (aggregate . 1)) (SELECT . (aggregate . 1)) (REQUEUE . (aggregate 
. 1)) (RAISE . (aggregate . 1)) (PRAGMA . (aggregate . 1)) (NULL . (aggregate . 
1)) (IF . (aggregate . 1)) (GOTO . (aggregate . 1)) (FOR . (aggregate . 1)) 
(EXIT . (aggregate . 1)) (DELAY . (aggregate . 1)) (DECLARE . (aggregate . 1)) 
(CASE . (aggregate . 1)) (BEGIN . (aggregate . 1)) (ABORT . (aggregate . 1)) 
(ACCEPT . (aggregate . 1)) (CHARACTER_LITERAL . (aggregate . 1)) 
(STRING_LITERAL . (aggregate . 1)) (IDENTIFIER . (aggregate . 1)) (LESS_LESS . 
(aggregate . 1)) (OF . (aggregate . 1)) (ELSIF . (aggregate . 1)) (ELSE . 
(aggregate . 1)) (DIGITS . (aggregate . 1)) (COMMA . (aggregate . 1)) 
(RIGHT_PAREN . (aggregate . 1)) (RANGE . (aggregate . 1)) (THEN . (aggregate . 
1)) (WITH . (aggregate . 1)) (BAR . (aggregate . 1)) (EQUAL_GREATER . 
(aggregate . 1)) (IS . (aggregate . 1)) (SLASH_EQUAL . (aggregate . 1)) 
(LESS_EQUAL . (aggregate . 1)) (LESS . (aggregate . 1)) (GREATER_EQUAL . 
(aggregate . 1)) (GREATER . (aggregate . 1)) (EQUAL . (aggregate . 1)) (NOT . 
(aggregate . 1)) (IN . (aggregate . 1)) (AND . (aggregate . 1)) (OR . 
(aggregate . 1)) (XOR . (aggregate . 1)) (SEMICOLON . (aggregate . 1)) 
(STAR_STAR . (aggregate . 1)) (REM . (aggregate . 1)) (MOD . (aggregate . 1)) 
(STAR . (aggregate . 1)) (SLASH . (aggregate . 1)) (DOT_DOT . (aggregate . 1)) 
(AMPERSAND . (aggregate . 1)) (MINUS . (aggregate . 1)) (PLUS . (aggregate . 
1)) (LEFT_PAREN . (aggregate . 1)) (DOT . (aggregate . 1)) (TICK . (aggregate . 
1)) (RETURN . (aggregate . 1)))
+      ((default . error) (RIGHT_PAREN .  780))
+      ((default . error) (OF . (aggregate . 2)) (LESS_LESS . (aggregate . 2)) 
(IDENTIFIER . (aggregate . 2)) (STRING_LITERAL . (aggregate . 2)) 
(CHARACTER_LITERAL . (aggregate . 2)) (ACCEPT . (aggregate . 2)) (ABORT . 
(aggregate . 2)) (BEGIN . (aggregate . 2)) (CASE . (aggregate . 2)) (DECLARE . 
(aggregate . 2)) (DELAY . (aggregate . 2)) (EXIT . (aggregate . 2)) (FOR . 
(aggregate . 2)) (GOTO . (aggregate . 2)) (IF . (aggregate . 2)) (NULL . 
(aggregate . 2)) (PRAGMA . (aggregate . 2)) (RAISE . (aggregate . 2)) (REQUEUE 
. (aggregate . 2)) (SELECT . (aggregate . 2)) (WHILE . (aggregate . 2)) 
(COLON_EQUAL . (aggregate . 2)) (USE . (aggregate . 2)) (RENAMES . (aggregate . 
2)) (LOOP . (aggregate . 2)) (DO . (aggregate . 2)) (RETURN . (aggregate . 2)) 
(TICK . (aggregate . 2)) (DOT . (aggregate . 2)) (LEFT_PAREN . (aggregate . 2)) 
(PLUS . (aggregate . 2)) (MINUS . (aggregate . 2)) (AMPERSAND . (aggregate . 
2)) (DOT_DOT . (aggregate . 2)) (SLASH . (aggregate . 2)) (STAR . (aggregate . 
2)) (MOD . (aggregate . 2)) (REM . (aggregate . 2)) (STAR_STAR . (aggregate . 
2)) (SEMICOLON . (aggregate . 2)) (XOR . (aggregate . 2)) (OR . (aggregate . 
2)) (AND . (aggregate . 2)) (IN . (aggregate . 2)) (NOT . (aggregate . 2)) 
(EQUAL . (aggregate . 2)) (GREATER . (aggregate . 2)) (GREATER_EQUAL . 
(aggregate . 2)) (LESS . (aggregate . 2)) (LESS_EQUAL . (aggregate . 2)) 
(SLASH_EQUAL . (aggregate . 2)) (IS . (aggregate . 2)) (EQUAL_GREATER . 
(aggregate . 2)) (BAR . (aggregate . 2)) (WITH . (aggregate . 2)) (THEN . 
(aggregate . 2)) (RANGE . (aggregate . 2)) (RIGHT_PAREN . (aggregate . 2)) 
(COMMA . (aggregate . 2)) (DIGITS . (aggregate . 2)) (ELSE . (aggregate . 2)) 
(ELSIF . (aggregate . 2)))
+      ((default . error) (COLON_EQUAL .  1058) (DOT .  84) (TICK .  85) 
(RIGHT_PAREN . (parameter_specification . 1)) (SEMICOLON . 
(parameter_specification . 1)) (LEFT_PAREN .  103))
+      ((default . error) (WITH . (formal_object_declaration . 2)) (TYPE . 
(formal_object_declaration . 2)) (PRAGMA . (formal_object_declaration . 2)) 
(IDENTIFIER . (formal_object_declaration . 2)) (FUNCTION . 
(formal_object_declaration . 2)) (PROCEDURE . (formal_object_declaration . 2)) 
(PACKAGE . (formal_object_declaration . 2)))
+      ((default . error) (SEMICOLON .  1057))
+      ((default . error) (SEMICOLON .  1056))
+      ((default . error) (RIGHT_PAREN .  1055))
+      ((default . error) (AND .  1054) (WITH . (interface_type_definition . 
1)) (SEMICOLON . (interface_type_definition . 1)))
+      ((default . error) (DOT .  84) (SEMICOLON . (interface_list . 0)) (WITH 
. (interface_list . 0)) (AND . (interface_list . 0)) (TICK .  85) (LEFT_PAREN . 
 103))
+      ((default . error) (AND .  1054) (WITH . (interface_type_definition . 
3)) (SEMICOLON . (interface_type_definition . 3)))
+      ((default . error) (AND .  1054) (WITH . (interface_type_definition . 
2)) (SEMICOLON . (interface_type_definition . 2)))
+      ((default . error) (AND .  1054) (WITH . (interface_type_definition . 
0)) (SEMICOLON . (interface_type_definition . 0)))
+      ((default . error) (SEMICOLON . (formal_type_definition . 7)) (WITH . 
(formal_type_definition . 7)))
+      ((default . error) (IDENTIFIER .  45) (STRING_LITERAL .  46) 
(CHARACTER_LITERAL .  163) (RIGHT_PAREN . ((association_opt . 0) 
(expression_opt . 0))) (COMMA . ((association_opt . 0) (expression_opt . 0))) 
(EQUAL_GREATER . (discrete_choice_list . 0)) (BAR . (discrete_choice_list . 0)) 
(PLUS .  136) (MINUS .  135) (OTHERS .  165) (ABS .  138) (NOT .  1051) (NULL . 
 142) (NEW .  140) (LEFT_PAREN .  139))
+      ((default . error) (BOX .  1050) (IDENTIFIER .  45) (CHARACTER_LITERAL . 
 47) (STRING_LITERAL .  46) (PLUS .  136) (MINUS .  135) (ABS .  138) (NOT .  
141) (NULL .  142) (NEW .  140) (LEFT_PAREN .  139))
+      ((default . error) (LOOP . (subtype_indication . 2)) (DO . 
(subtype_indication . 2)) (EQUAL_GREATER . (subtype_indication . 2)) (COMMA . 
(subtype_indication . 2)) (RIGHT_PAREN . (subtype_indication . 2)) (COLON_EQUAL 
. (subtype_indication . 2)) (WITH . (subtype_indication . 2)) (SEMICOLON . 
(subtype_indication . 2)) (AND . (subtype_indication . 2)) (OF . 
(subtype_indication . 2)))
+      ((default . error) (LOOP . (constraint . 1)) (DO . (constraint . 1)) 
(EQUAL_GREATER . (constraint . 1)) (COMMA . (constraint . 1)) (RIGHT_PAREN . 
(constraint . 1)) (COLON_EQUAL . (constraint . 1)) (WITH . (constraint . 1)) 
(SEMICOLON . (constraint . 1)) (AND . (constraint . 1)) (OF . (constraint . 1)))
+      ((default . error) (IDENTIFIER .  45) (CHARACTER_LITERAL .  47) 
(STRING_LITERAL .  46))
+      ((default . error) (OF .  1047))
+      ((default . error) (IDENTIFIER .  45) (CHARACTER_LITERAL .  47) 
(STRING_LITERAL .  46) (PLUS .  136) (MINUS .  135) (ABS .  138) (NOT .  750) 
(NULL .  142) (NEW .  140) (LEFT_PAREN .  139))
+      ((default . error) (OF .  1045))
+      ((default . error) (PLUS . (primary . 0)) (MINUS . (primary . 0)) 
(AMPERSAND . (primary . 0)) (DOT_DOT . (primary . 0)) (SLASH . (primary . 0)) 
(STAR . (primary . 0)) (MOD . (primary . 0)) (REM . (primary . 0)) (IDENTIFIER 
.  45) (CHARACTER_LITERAL .  47) (STRING_LITERAL .  46))
+      ((default . error) (AND .  1043) (DOT .  84) (TICK .  85) (WITH .  1044) 
(LEFT_PAREN .  103))
+      ((default . error) (AND .  1041) (DOT .  84) (TICK .  85) (WITH .  1042) 
(LEFT_PAREN .  103))
+      ((default . error) (DOT . (name . 0)) (LEFT_PAREN . (name . 0)) (TICK . 
(name . 0)) (SEMICOLON . (null_exclusion_opt_name . 2)) (RIGHT_PAREN . 
(null_exclusion_opt_name . 2)) (COLON_EQUAL . (null_exclusion_opt_name . 2)))
+      ((default . error) (DOT . (name . 3)) (LEFT_PAREN . (name . 3)) (TICK . 
(name . 3)) (SEMICOLON . (null_exclusion_opt_name . 3)) (RIGHT_PAREN . 
(null_exclusion_opt_name . 3)) (COLON_EQUAL . (null_exclusion_opt_name . 3)))
+      ((default . error) (SEMICOLON . (discriminant_specification_opt . 3)) 
(RIGHT_PAREN . (discriminant_specification_opt . 3)))
+      ((default . error) (SEMICOLON . (discriminant_specification_opt . 1)) 
(RIGHT_PAREN . (discriminant_specification_opt . 1)))
+      ((default . error) (DO . (range . 0)) (LOOP . (range . 0)) (XOR . (range 
. 0)) (OR . (range . 0)) (AND . (range . 0)) (IS . (range . 0)) (WITH . (range 
. 0)) (SEMICOLON . (range . 0)) (THEN . (range . 0)) (RANGE . (range . 0)) 
(DIGITS . (range . 0)) (ELSE . (range . 0)) (ELSIF . (range . 0)) (COLON_EQUAL 
. (range . 0)) (OF . (range . 0)) (COMMA . (range . 0)) (BAR . (range . 0)) 
(EQUAL_GREATER . (range . 0)) (RIGHT_PAREN . (range . 0)))
+      ((default . error) (DOT .  84) (TICK .  85) (SEMICOLON . 
(aspect_specification_opt . 0)) (WITH .  104) (LEFT_PAREN .  103))
+      ((default . error) (DOT .  84) (TICK .  85) (SEMICOLON . 
(aspect_specification_opt . 0)) (WITH .  104) (LEFT_PAREN .  103))
+      ((default . error) (IDENTIFIER .  45) (CHARACTER_LITERAL .  47) 
(STRING_LITERAL .  46))
+      ((default . error) (WHEN . (record_representation_clause . 0)) (END . 
(record_representation_clause . 0)) (PRIVATE . (record_representation_clause . 
0)) (CASE . (record_representation_clause . 0)) (USE . 
(record_representation_clause . 0)) (TYPE . (record_representation_clause . 0)) 
(TASK . (record_representation_clause . 0)) (SUBTYPE . 
(record_representation_clause . 0)) (PROTECTED . (record_representation_clause 
. 0)) (PROCEDURE . (record_representation_clause . 0)) (PRAGMA . 
(record_representation_clause . 0)) (PACKAGE . (record_representation_clause . 
0)) (OVERRIDING . (record_representation_clause . 0)) (NOT . 
(record_representation_clause . 0)) (GENERIC . (record_representation_clause . 
0)) (FUNCTION . (record_representation_clause . 0)) (FOR . 
(record_representation_clause . 0)) (ENTRY . (record_representation_clause . 
0)) (IDENTIFIER . (record_representation_clause . 0)) (BEGIN . 
(record_representation_clause . 0)))
+      ((default . error) (WHEN . (enumeration_representation_clause . 0)) (END 
. (enumeration_representation_clause . 0)) (PRIVATE . 
(enumeration_representation_clause . 0)) (CASE . 
(enumeration_representation_clause . 0)) (USE . 
(enumeration_representation_clause . 0)) (TYPE . 
(enumeration_representation_clause . 0)) (TASK . 
(enumeration_representation_clause . 0)) (SUBTYPE . 
(enumeration_representation_clause . 0)) (PROTECTED . 
(enumeration_representation_clause . 0)) (PROCEDURE . 
(enumeration_representation_clause . 0)) (PRAGMA . 
(enumeration_representation_clause . 0)) (PACKAGE . 
(enumeration_representation_clause . 0)) (OVERRIDING . 
(enumeration_representation_clause . 0)) (NOT . 
(enumeration_representation_clause . 0)) (GENERIC . 
(enumeration_representation_clause . 0)) (FUNCTION . 
(enumeration_representation_clause . 0)) (FOR . 
(enumeration_representation_clause . 0)) (ENTRY . 
(enumeration_representation_clause . 0)) (IDENTIFIER . 
(enumeration_representation_clause . 0)) (BEGIN . 
(enumeration_representation_clause . 0)))
+      ((default . error) (MOD .  1037))
+      ((default . error) (IDENTIFIER .  1034))
+      ((default . error) (SEMICOLON .  1033))
+      ((default . error) (WHEN . (aspect_clause . 0)) (PRIVATE . 
(aspect_clause . 0)) (END . (aspect_clause . 0)) (CASE . (aspect_clause . 0)) 
(BEGIN . (aspect_clause . 0)) (IDENTIFIER . (aspect_clause . 0)) (ENTRY . 
(aspect_clause . 0)) (FOR . (aspect_clause . 0)) (FUNCTION . (aspect_clause . 
0)) (GENERIC . (aspect_clause . 0)) (NOT . (aspect_clause . 0)) (OVERRIDING . 
(aspect_clause . 0)) (PACKAGE . (aspect_clause . 0)) (PRAGMA . (aspect_clause . 
0)) (PROCEDURE . (aspect_clause . 0)) (PROTECTED . (aspect_clause . 0)) 
(SUBTYPE . (aspect_clause . 0)) (TASK . (aspect_clause . 0)) (TYPE . 
(aspect_clause . 0)) (USE . (aspect_clause . 0)))
+      ((default . error) (SEMICOLON .  1032))
+      ((default . error) (SEMICOLON . (aspect_specification_opt . 0)) (WITH .  
104))
+      ((default . error) (IS .  1030))
+      ((default . error) (SEMICOLON . (aspect_specification_opt . 0)) (WITH .  
104))
+      ((default . error) (IDENTIFIER .  45) (CHARACTER_LITERAL .  47) 
(STRING_LITERAL .  46))
+      ((default . error) (END .  1026) (PRIVATE .  1027))
+      ((default . error) (SEMICOLON .  1025))
+      ((default . error) (SEMICOLON .  1024))
+      ((default . error) (IDENTIFIER .  45) (CHARACTER_LITERAL .  47) 
(STRING_LITERAL .  46) (PLUS .  136) (MINUS .  135) (ABS .  138) (NOT .  141) 
(NULL .  142) (NEW .  140) (LEFT_PAREN .  139))
+      ((default . error) (IDENTIFIER .  45) (CHARACTER_LITERAL .  47) 
(STRING_LITERAL .  46))
+      ((default . error) (SEMICOLON .  1020) (IS .  1021))
+      ((default . error) (SEMICOLON . (aspect_specification_opt . 0)) (WITH .  
104))
+      ((default . error) (IDENTIFIER .  45) (CHARACTER_LITERAL .  47) 
(STRING_LITERAL .  46))
+      ((default . error) (END .  1016) (PRIVATE .  1017))
+      ((default . error) (SEMICOLON .  1015))
+      ((default . error) (SYNCHRONIZED .  1014) (TAGGED .  540) (NEW . 
((abstract_limited_synchronized_opt . 3) (abstract_limited_opt . 3))) (LIMITED 
.  1013))
+      ((default . error) (PLUS .  136) (MINUS .  135) (ABS .  138) (NOT .  
141) (NULL .  142) (NEW .  140) (IDENTIFIER .  45) (CHARACTER_LITERAL .  47) 
(STRING_LITERAL .  46) (LEFT_PAREN .  139))
+      ((default . error) (PLUS .  136) (MINUS .  135) (ABS .  138) (NOT .  
141) (NULL .  142) (NEW .  140) (IDENTIFIER .  45) (CHARACTER_LITERAL .  47) 
(STRING_LITERAL .  46) (LEFT_PAREN .  139))
+      ((default . error) (IDENTIFIER .  1007) (CHARACTER_LITERAL .  1008))
+      ((default . error) (INTERFACE .  532) (PRIVATE . 
(abstract_tagged_limited_opt . 5)) (NULL . (abstract_tagged_limited_opt . 5)) 
(RECORD . (abstract_tagged_limited_opt . 5)) (NEW . 
((abstract_limited_synchronized_opt . 4) (abstract_limited_opt . 2))))
+      ((default . error) (PLUS .  136) (MINUS .  135) (ABS .  138) (NOT .  
141) (NULL .  142) (NEW .  140) (IDENTIFIER .  45) (CHARACTER_LITERAL .  47) 
(STRING_LITERAL .  46) (LEFT_PAREN .  139))
+      ((default . error) (RECORD .  1005))
+      ((default . error) (PLUS .  136) (MINUS .  135) (ABS .  138) (NOT .  
141) (NULL .  142) (NEW .  140) (IDENTIFIER .  45) (CHARACTER_LITERAL .  47) 
(STRING_LITERAL .  46) (LEFT_PAREN .  139))
+      ((default . error) (END . (component_list_opt . 0)) (NULL .  996) (CASE 
.  995) (IDENTIFIER .  69) (FOR .  279))
+      ((default . error) (NEW . (abstract_limited_synchronized_opt . 5)) 
(INTERFACE .  527))
+      ((default . error) (SEMICOLON .  994) (PRIVATE . 
(abstract_tagged_limited_opt . 4)) (NULL . (abstract_tagged_limited_opt . 4)) 
(RECORD . (abstract_tagged_limited_opt . 4)) (LIMITED .  525))
+      ((default . error) (NEW .  993))
+      ((default . error) (NEW .  992))
+      ((default . error) (PRIVATE .  990) (RECORD .  840) (NULL .  838))
+      ((default . error) (WITH . (type_definition . 8)) (SEMICOLON . 
(type_definition . 8)))
+      ((default . error) (WITH . (type_definition . 6)) (SEMICOLON . 
(type_definition . 6)))
+      ((default . error) (WITH . (type_definition . 9)) (SEMICOLON . 
(type_definition . 9)))
+      ((default . error) (WITH . (type_definition . 0)) (SEMICOLON . 
(type_definition . 0)))
+      ((default . error) (WITH . (type_definition . 10)) (SEMICOLON . 
(type_definition . 10)))
+      ((default . error) (WITH . (type_definition . 7)) (SEMICOLON . 
(type_definition . 7)))
+      ((default . error) (SEMICOLON . (aspect_specification_opt . 0)) (WITH .  
104))
+      ((default . error) (DOT .  84) (TICK .  85) (SEMICOLON . 
(package_specification . 0)) (LEFT_PAREN .  103))
+      ((default . error) (SEMICOLON .  988))
+      ((default . error) (NULL .  987))
+      ((default . error) (COLON_EQUAL .  985) (SEMICOLON . 
(aspect_specification_opt . 0)) (WITH .  104))
+      ((default . error) (COLON_EQUAL .  983) (SEMICOLON . 
(aspect_specification_opt . 0)) (WITH .  104))
+      ((default . error) (COLON_EQUAL .  981) (SEMICOLON . 
(aspect_specification_opt . 0)) (WITH .  104))
+      ((default . error) (SEMICOLON .  980))
+      ((default . error) (SEMICOLON .  979))
+      ((default . error) (SEMICOLON .  978))
+      ((default . error) (SEMICOLON .  977))
+      ((default . error) (SEMICOLON .  976))
+      ((default . error) (RIGHT_PAREN .  975))
+      ((default . error) (LOOP . (subtype_indication . 3)) (DOT .  84) (IN . 
(primary . 2)) (NOT . (primary . 2)) (EQUAL . (primary . 2)) (GREATER . 
(primary . 2)) (GREATER_EQUAL . (primary . 2)) (LESS . (primary . 2)) 
(LESS_EQUAL . (primary . 2)) (SLASH_EQUAL . (primary . 2)) (RIGHT_PAREN . 
((subtype_indication . 3) (primary . 2))) (COMMA . ((subtype_indication . 3) 
(primary . 2))) (BAR . (primary . 2)) (EQUAL_GREATER . ((subtype_indication . 
3) (primary . 2))) (AND . (primary . 2)) (OR . (primary . 2)) (XOR . (primary . 
2)) (PLUS . (primary . 2)) (MINUS . (primary . 2)) (AMPERSAND . (primary . 2)) 
(DOT_DOT . (primary . 2)) (SLASH . (primary . 2)) (STAR . (primary . 2)) (MOD . 
(primary . 2)) (REM . (primary . 2)) (STAR_STAR . (primary . 2)) (TICK .  261) 
(RANGE .  825) (LEFT_PAREN .  792))
+      ((default . error) (SEMICOLON . (name_opt . 0)) (IDENTIFIER .  45) 
(CHARACTER_LITERAL .  47) (STRING_LITERAL .  46))
+      ((default . error) (END . (package_body . 1)) (BEGIN . (package_body . 
1)) (IDENTIFIER . (package_body . 1)) (ENTRY . (package_body . 1)) (FOR . 
(package_body . 1)) (PROTECTED . (package_body . 1)) (SUBTYPE . (package_body . 
1)) (TASK . (package_body . 1)) (TYPE . (package_body . 1)) (WITH . 
(package_body . 1)) (USE . (package_body . 1)) (SEPARATE . (package_body . 1)) 
(PROCEDURE . (package_body . 1)) (PRIVATE . (package_body . 1)) (PRAGMA . 
(package_body . 1)) (PACKAGE . (package_body . 1)) (OVERRIDING . (package_body 
. 1)) (NOT . (package_body . 1)) (LIMITED . (package_body . 1)) (GENERIC . 
(package_body . 1)) (FUNCTION . (package_body . 1)) ($EOI . (package_body . 1)))
+      ((default . error) (WHEN .  702))
+      ((default . error) (BAR .  262) (EQUAL_GREATER .  972))
+      ((default . error) (IDENTIFIER .  45) (CHARACTER_LITERAL .  47) 
(STRING_LITERAL .  46))
+      ((default . error) (DOT .  84) (TICK .  85) (LOOP . 
(iterator_specification . 5)) (EQUAL_GREATER . (iterator_specification . 5)) 
(LEFT_PAREN .  103))
+      ((default . error) (IDENTIFIER .  45) (CHARACTER_LITERAL .  47) 
(STRING_LITERAL .  46) (PLUS .  136) (MINUS .  135) (ABS .  138) (NOT .  750) 
(NULL .  142) (NEW .  140) (LEFT_PAREN .  139))
+      ((default . error) (LOOP . (iterator_specification . 1)) (EQUAL_GREATER 
. (iterator_specification . 1)))
+      ((default . error) (OF .  969))
+      ((default . error) (RIGHT_PAREN . (quantified_expression . 0)))
+      ((default . error) (PLUS .  136) (MINUS .  135) (ABS .  138) (NOT .  
141) (NULL .  142) (NEW .  140) (IDENTIFIER .  45) (CHARACTER_LITERAL .  47) 
(STRING_LITERAL .  46) (LEFT_PAREN .  139))
+      ((default . error) (PLUS .  136) (MINUS .  135) (ABS .  138) (NOT .  
141) (NULL .  142) (NEW .  140) (IDENTIFIER .  45) (CHARACTER_LITERAL .  47) 
(STRING_LITERAL .  46) (LEFT_PAREN .  139))
+      ((default . error) (RIGHT_PAREN . (elsif_expression_list . 0)) (ELSE . 
(elsif_expression_list . 0)) (ELSIF . (elsif_expression_list . 0)))
+      ((default . error) (RIGHT_PAREN . (if_expression . 1)) (ELSE .  965) 
(ELSIF .  877))
+      ((default . error) (END . (protected_operation_item_list_opt . 0)) 
(ENTRY .  956) (NOT .  4) (OVERRIDING .  5) (FUNCTION . 
(overriding_indicator_opt . 2)) (PROCEDURE . (overriding_indicator_opt . 2)) 
(FOR .  279))
+      ((default . error) (BEGIN . (declarative_part_opt . 0)) (USE .  11) 
(SUBTYPE .  282) (PRAGMA .  7) (NOT .  4) (OVERRIDING .  5) (FUNCTION . 
(overriding_indicator_opt . 2)) (PROCEDURE . (overriding_indicator_opt . 2)) 
(ENTRY . (overriding_indicator_opt . 2)) (FOR .  279) (IDENTIFIER .  278) (TYPE 
.  284) (GENERIC .  2) (PROTECTED .  281) (TASK .  283) (PACKAGE .  280))
+      ((default . error) (ACCEPT . (label_opt . 1)) (BEGIN . (label_opt . 1)) 
(CASE . (label_opt . 1)) (DECLARE . (label_opt . 1)) (FOR . (label_opt . 1)) 
(IF . (label_opt . 1)) (LOOP . (label_opt . 1)) (RETURN . (label_opt . 1)) 
(SELECT . (label_opt . 1)) (WHILE . (label_opt . 1)) (IDENTIFIER . (label_opt . 
1)) (STRING_LITERAL . (label_opt . 1)) (CHARACTER_LITERAL . (label_opt . 1)) 
(ABORT . (label_opt . 1)) (DELAY . (label_opt . 1)) (EXIT . (label_opt . 1)) 
(GOTO . (label_opt . 1)) (NULL . (label_opt . 1)) (PRAGMA . (label_opt . 1)) 
(RAISE . (label_opt . 1)) (REQUEUE . (label_opt . 1)))
+      ((default . error) (RIGHT_PAREN . ((association_opt . 0) (expression_opt 
. 0))) (COMMA . ((association_opt . 0) (expression_opt . 0))) (EQUAL_GREATER . 
(discrete_choice_list . 0)) (BAR . (discrete_choice_list . 0)) (OTHERS .  165) 
(IDENTIFIER .  45) (CHARACTER_LITERAL .  163) (STRING_LITERAL .  46) (PLUS .  
136) (MINUS .  135) (ABS .  138) (NOT .  164) (NULL .  142) (NEW .  140) 
(LEFT_PAREN .  139))
+      ((default . error) (SEMICOLON . (actual_parameter_part_opt . 1)) 
(LEFT_PAREN . (actual_parameter_part_opt . 1)) (DO . (actual_parameter_part_opt 
. 1)))
+      ((default . error) (DO . (parameter_profile_opt . 0)) (SEMICOLON . 
(parameter_profile_opt . 0)) (LEFT_PAREN .  773))
+      ((default . error) (OR . (simple_statement . 8)) (THEN . 
(simple_statement . 8)) (WHEN . (simple_statement . 8)) (EXCEPTION . 
(simple_statement . 8)) (END . (simple_statement . 8)) (LESS_LESS . 
(simple_statement . 8)) (IDENTIFIER . (simple_statement . 8)) (STRING_LITERAL . 
(simple_statement . 8)) (CHARACTER_LITERAL . (simple_statement . 8)) (ACCEPT . 
(simple_statement . 8)) (ABORT . (simple_statement . 8)) (BEGIN . 
(simple_statement . 8)) (CASE . (simple_statement . 8)) (DECLARE . 
(simple_statement . 8)) (DELAY . (simple_statement . 8)) (EXIT . 
(simple_statement . 8)) (FOR . (simple_statement . 8)) (GOTO . 
(simple_statement . 8)) (IF . (simple_statement . 8)) (LOOP . (simple_statement 
. 8)) (NULL . (simple_statement . 8)) (PRAGMA . (simple_statement . 8)) (RAISE 
. (simple_statement . 8)) (REQUEUE . (simple_statement . 8)) (RETURN . 
(simple_statement . 8)) (SELECT . (simple_statement . 8)) (WHILE . 
(simple_statement . 8)) (ELSE . (simple_statement . 8)) (ELSIF . 
(simple_statement . 8)))
+      ((default . error) (SEMICOLON . (identifier_opt . 0)) (IDENTIFIER .  
683))
+      ((default . error) (WHEN .  950))
+      ((default . error) (END . (sequence_of_statements_opt . 0)) (EXCEPTION . 
(sequence_of_statements_opt . 0)) (ACCEPT . (label_opt . 0)) (BEGIN . 
(label_opt . 0)) (CASE . (label_opt . 0)) (DECLARE . (label_opt . 0)) (FOR . 
(label_opt . 0)) (IF . (label_opt . 0)) (LOOP . (label_opt . 0)) (RETURN . 
(label_opt . 0)) (SELECT . (label_opt . 0)) (WHILE . (label_opt . 0)) 
(STRING_LITERAL . (label_opt . 0)) (CHARACTER_LITERAL . (label_opt . 0)) (ABORT 
. (label_opt . 0)) (DELAY . (label_opt . 0)) (EXIT . (label_opt . 0)) (GOTO . 
(label_opt . 0)) (NULL . (label_opt . 0)) (PRAGMA . (label_opt . 0)) (RAISE . 
(label_opt . 0)) (REQUEUE . (label_opt . 0)) (LESS_LESS .  599) (IDENTIFIER . 
((label_opt . 0)  600)))
+      ((default . error) (WHEN . (delay_statement . 1)) (EXCEPTION . 
(delay_statement . 1)) (ELSIF . (delay_statement . 1)) (THEN . (delay_statement 
. 1)) (ELSE . (delay_statement . 1)) (OR . (delay_statement . 1)) (END . 
(delay_statement . 1)) (LESS_LESS . (delay_statement . 1)) (IDENTIFIER . 
(delay_statement . 1)) (STRING_LITERAL . (delay_statement . 1)) 
(CHARACTER_LITERAL . (delay_statement . 1)) (ACCEPT . (delay_statement . 1)) 
(ABORT . (delay_statement . 1)) (BEGIN . (delay_statement . 1)) (CASE . 
(delay_statement . 1)) (DECLARE . (delay_statement . 1)) (DELAY . 
(delay_statement . 1)) (EXIT . (delay_statement . 1)) (FOR . (delay_statement . 
1)) (GOTO . (delay_statement . 1)) (IF . (delay_statement . 1)) (LOOP . 
(delay_statement . 1)) (NULL . (delay_statement . 1)) (PRAGMA . 
(delay_statement . 1)) (RAISE . (delay_statement . 1)) (REQUEUE . 
(delay_statement . 1)) (RETURN . (delay_statement . 1)) (SELECT . 
(delay_statement . 1)) (WHILE . (delay_statement . 1)))
+      ((default . error) (SEMICOLON .  948))
+      ((default . error) (OR . (exit_statement . 1)) (THEN . (exit_statement . 
1)) (WHEN . (exit_statement . 1)) (EXCEPTION . (exit_statement . 1)) (END . 
(exit_statement . 1)) (LESS_LESS . (exit_statement . 1)) (IDENTIFIER . 
(exit_statement . 1)) (STRING_LITERAL . (exit_statement . 1)) 
(CHARACTER_LITERAL . (exit_statement . 1)) (ACCEPT . (exit_statement . 1)) 
(ABORT . (exit_statement . 1)) (BEGIN . (exit_statement . 1)) (CASE . 
(exit_statement . 1)) (DECLARE . (exit_statement . 1)) (DELAY . (exit_statement 
. 1)) (EXIT . (exit_statement . 1)) (FOR . (exit_statement . 1)) (GOTO . 
(exit_statement . 1)) (IF . (exit_statement . 1)) (LOOP . (exit_statement . 1)) 
(NULL . (exit_statement . 1)) (PRAGMA . (exit_statement . 1)) (RAISE . 
(exit_statement . 1)) (REQUEUE . (exit_statement . 1)) (RETURN . 
(exit_statement . 1)) (SELECT . (exit_statement . 1)) (WHILE . (exit_statement 
. 1)) (ELSE . (exit_statement . 1)) (ELSIF . (exit_statement . 1)))
+      ((default . error) (SEMICOLON . (expression_opt . 0)) (PLUS .  136) 
(MINUS .  135) (ABS .  138) (NOT .  141) (NULL .  142) (NEW .  140) (IDENTIFIER 
.  45) (CHARACTER_LITERAL .  47) (STRING_LITERAL .  46) (LEFT_PAREN .  139))
+      ((default . error) (OR . (simple_statement . 3)) (THEN . 
(simple_statement . 3)) (WHEN . (simple_statement . 3)) (EXCEPTION . 
(simple_statement . 3)) (END . (simple_statement . 3)) (LESS_LESS . 
(simple_statement . 3)) (IDENTIFIER . (simple_statement . 3)) (STRING_LITERAL . 
(simple_statement . 3)) (CHARACTER_LITERAL . (simple_statement . 3)) (ACCEPT . 
(simple_statement . 3)) (ABORT . (simple_statement . 3)) (BEGIN . 
(simple_statement . 3)) (CASE . (simple_statement . 3)) (DECLARE . 
(simple_statement . 3)) (DELAY . (simple_statement . 3)) (EXIT . 
(simple_statement . 3)) (FOR . (simple_statement . 3)) (GOTO . 
(simple_statement . 3)) (IF . (simple_statement . 3)) (LOOP . (simple_statement 
. 3)) (NULL . (simple_statement . 3)) (PRAGMA . (simple_statement . 3)) (RAISE 
. (simple_statement . 3)) (REQUEUE . (simple_statement . 3)) (RETURN . 
(simple_statement . 3)) (SELECT . (simple_statement . 3)) (WHILE . 
(simple_statement . 3)) (ELSE . (simple_statement . 3)) (ELSIF . 
(simple_statement . 3)))
+      ((default . error) (ELSIF . (sequence_of_statements_opt . 0)) (ELSE . 
(sequence_of_statements_opt . 0)) (END . (sequence_of_statements_opt . 0)) 
(ACCEPT . (label_opt . 0)) (BEGIN . (label_opt . 0)) (CASE . (label_opt . 0)) 
(DECLARE . (label_opt . 0)) (FOR . (label_opt . 0)) (IF . (label_opt . 0)) 
(LOOP . (label_opt . 0)) (RETURN . (label_opt . 0)) (SELECT . (label_opt . 0)) 
(WHILE . (label_opt . 0)) (STRING_LITERAL . (label_opt . 0)) (CHARACTER_LITERAL 
. (label_opt . 0)) (ABORT . (label_opt . 0)) (DELAY . (label_opt . 0)) (EXIT . 
(label_opt . 0)) (GOTO . (label_opt . 0)) (NULL . (label_opt . 0)) (PRAGMA . 
(label_opt . 0)) (RAISE . (label_opt . 0)) (REQUEUE . (label_opt . 0)) 
(LESS_LESS .  599) (IDENTIFIER . ((label_opt . 0)  600)))
+      ((default . error) (LOOP .  945))
+      ((default . error) (OR . (raise_statement . 2)) (THEN . (raise_statement 
. 2)) (WHEN . (raise_statement . 2)) (EXCEPTION . (raise_statement . 2)) (END . 
(raise_statement . 2)) (LESS_LESS . (raise_statement . 2)) (IDENTIFIER . 
(raise_statement . 2)) (STRING_LITERAL . (raise_statement . 2)) 
(CHARACTER_LITERAL . (raise_statement . 2)) (ACCEPT . (raise_statement . 2)) 
(ABORT . (raise_statement . 2)) (BEGIN . (raise_statement . 2)) (CASE . 
(raise_statement . 2)) (DECLARE . (raise_statement . 2)) (DELAY . 
(raise_statement . 2)) (EXIT . (raise_statement . 2)) (FOR . (raise_statement . 
2)) (GOTO . (raise_statement . 2)) (IF . (raise_statement . 2)) (LOOP . 
(raise_statement . 2)) (NULL . (raise_statement . 2)) (PRAGMA . 
(raise_statement . 2)) (RAISE . (raise_statement . 2)) (REQUEUE . 
(raise_statement . 2)) (RETURN . (raise_statement . 2)) (SELECT . 
(raise_statement . 2)) (WHILE . (raise_statement . 2)) (ELSE . (raise_statement 
. 2)) (ELSIF . (raise_statement . 2)))
+      ((default . error) (PLUS .  136) (MINUS .  135) (ABS .  138) (NOT .  
141) (NULL .  142) (NEW .  140) (IDENTIFIER .  45) (CHARACTER_LITERAL .  47) 
(STRING_LITERAL .  46) (LEFT_PAREN .  139))
+      ((default . error) (OR . (requeue_statement . 1)) (THEN . 
(requeue_statement . 1)) (WHEN . (requeue_statement . 1)) (EXCEPTION . 
(requeue_statement . 1)) (END . (requeue_statement . 1)) (LESS_LESS . 
(requeue_statement . 1)) (IDENTIFIER . (requeue_statement . 1)) (STRING_LITERAL 
. (requeue_statement . 1)) (CHARACTER_LITERAL . (requeue_statement . 1)) 
(ACCEPT . (requeue_statement . 1)) (ABORT . (requeue_statement . 1)) (BEGIN . 
(requeue_statement . 1)) (CASE . (requeue_statement . 1)) (DECLARE . 
(requeue_statement . 1)) (DELAY . (requeue_statement . 1)) (EXIT . 
(requeue_statement . 1)) (FOR . (requeue_statement . 1)) (GOTO . 
(requeue_statement . 1)) (IF . (requeue_statement . 1)) (LOOP . 
(requeue_statement . 1)) (NULL . (requeue_statement . 1)) (PRAGMA . 
(requeue_statement . 1)) (RAISE . (requeue_statement . 1)) (REQUEUE . 
(requeue_statement . 1)) (RETURN . (requeue_statement . 1)) (SELECT . 
(requeue_statement . 1)) (WHILE . (requeue_statement . 1)) (ELSE . 
(requeue_statement . 1)) (ELSIF . (requeue_statement . 1)))
+      ((default . error) (ABORT .  943))
+      ((default . error) (END . (sequence_of_statements_opt . 0)) (EXCEPTION . 
(sequence_of_statements_opt . 0)) (ACCEPT . (label_opt . 0)) (BEGIN . 
(label_opt . 0)) (CASE . (label_opt . 0)) (DECLARE . (label_opt . 0)) (FOR . 
(label_opt . 0)) (IF . (label_opt . 0)) (LOOP . (label_opt . 0)) (RETURN . 
(label_opt . 0)) (SELECT . (label_opt . 0)) (WHILE . (label_opt . 0)) 
(STRING_LITERAL . (label_opt . 0)) (CHARACTER_LITERAL . (label_opt . 0)) (ABORT 
. (label_opt . 0)) (DELAY . (label_opt . 0)) (EXIT . (label_opt . 0)) (GOTO . 
(label_opt . 0)) (NULL . (label_opt . 0)) (PRAGMA . (label_opt . 0)) (RAISE . 
(label_opt . 0)) (REQUEUE . (label_opt . 0)) (LESS_LESS .  599) (IDENTIFIER . 
((label_opt . 0)  600)))
+      ((default . error) (OR . (extended_return_statement . 1)) (THEN . 
(extended_return_statement . 1)) (WHEN . (extended_return_statement . 1)) 
(EXCEPTION . (extended_return_statement . 1)) (END . (extended_return_statement 
. 1)) (LESS_LESS . (extended_return_statement . 1)) (IDENTIFIER . 
(extended_return_statement . 1)) (STRING_LITERAL . (extended_return_statement . 
1)) (CHARACTER_LITERAL . (extended_return_statement . 1)) (ACCEPT . 
(extended_return_statement . 1)) (ABORT . (extended_return_statement . 1)) 
(BEGIN . (extended_return_statement . 1)) (CASE . (extended_return_statement . 
1)) (DECLARE . (extended_return_statement . 1)) (DELAY . 
(extended_return_statement . 1)) (EXIT . (extended_return_statement . 1)) (FOR 
. (extended_return_statement . 1)) (GOTO . (extended_return_statement . 1)) (IF 
. (extended_return_statement . 1)) (LOOP . (extended_return_statement . 1)) 
(NULL . (extended_return_statement . 1)) (PRAGMA . (extended_return_statement . 
1)) (RAISE . (extended_return_statement . 1)) (REQUEUE . 
(extended_return_statement . 1)) (RETURN . (extended_return_statement . 1)) 
(SELECT . (extended_return_statement . 1)) (WHILE . (extended_return_statement 
. 1)) (ELSE . (extended_return_statement . 1)) (ELSIF . 
(extended_return_statement . 1)))
+      ((default . error) (OR . (simple_return_statement . 1)) (THEN . 
(simple_return_statement . 1)) (WHEN . (simple_return_statement . 1)) 
(EXCEPTION . (simple_return_statement . 1)) (END . (simple_return_statement . 
1)) (LESS_LESS . (simple_return_statement . 1)) (IDENTIFIER . 
(simple_return_statement . 1)) (STRING_LITERAL . (simple_return_statement . 1)) 
(CHARACTER_LITERAL . (simple_return_statement . 1)) (ACCEPT . 
(simple_return_statement . 1)) (ABORT . (simple_return_statement . 1)) (BEGIN . 
(simple_return_statement . 1)) (CASE . (simple_return_statement . 1)) (DECLARE 
. (simple_return_statement . 1)) (DELAY . (simple_return_statement . 1)) (EXIT 
. (simple_return_statement . 1)) (FOR . (simple_return_statement . 1)) (GOTO . 
(simple_return_statement . 1)) (IF . (simple_return_statement . 1)) (LOOP . 
(simple_return_statement . 1)) (NULL . (simple_return_statement . 1)) (PRAGMA . 
(simple_return_statement . 1)) (RAISE . (simple_return_statement . 1)) (REQUEUE 
. (simple_return_statement . 1)) (RETURN . (simple_return_statement . 1)) 
(SELECT . (simple_return_statement . 1)) (WHILE . (simple_return_statement . 
1)) (ELSE . (simple_return_statement . 1)) (ELSIF . (simple_return_statement . 
1)))
+      ((default . error) (CONSTANT . (aliased_opt . 0)) (IDENTIFIER . 
(aliased_opt . 0)) (STRING_LITERAL . (aliased_opt . 0)) (CHARACTER_LITERAL . 
(aliased_opt . 0)) (ACCESS . (aliased_opt . 0)) (NOT . (aliased_opt . 0)) 
(ALIASED .  499))
+      ((default . error) (ABORT .  940))
+      ((default . error) (END . (sequence_of_statements_opt . 0)) (ACCEPT . 
(label_opt . 0)) (BEGIN . (label_opt . 0)) (CASE . (label_opt . 0)) (DECLARE . 
(label_opt . 0)) (FOR . (label_opt . 0)) (IF . (label_opt . 0)) (LOOP . 
(label_opt . 0)) (RETURN . (label_opt . 0)) (SELECT . (label_opt . 0)) (WHILE . 
(label_opt . 0)) (STRING_LITERAL . (label_opt . 0)) (CHARACTER_LITERAL . 
(label_opt . 0)) (ABORT . (label_opt . 0)) (DELAY . (label_opt . 0)) (EXIT . 
(label_opt . 0)) (GOTO . (label_opt . 0)) (NULL . (label_opt . 0)) (PRAGMA . 
(label_opt . 0)) (RAISE . (label_opt . 0)) (REQUEUE . (label_opt . 0)) 
(LESS_LESS .  599) (IDENTIFIER . ((label_opt . 0)  600)))
+      ((default . error) (SELECT .  938))
+      ((default . error) (WHEN .  658) (TERMINATE .  657) (ACCEPT .  601) 
(DELAY .  606))
+      ((default . error) (OR . (entry_call_alternative . 0)) (ELSE . 
(entry_call_alternative . 0)) (THEN . (triggering_alternative . 0)))
+      ((default . error) (OR . (entry_call_alternative . 1)) (ELSE . 
(entry_call_alternative . 1)) (THEN . (triggering_alternative . 1)))
+      ((default . error) (END . (sequence_of_statements_opt . 0)) (ACCEPT . 
(label_opt . 0)) (BEGIN . (label_opt . 0)) (CASE . (label_opt . 0)) (DECLARE . 
(label_opt . 0)) (FOR . (label_opt . 0)) (IF . (label_opt . 0)) (LOOP . 
(label_opt . 0)) (RETURN . (label_opt . 0)) (SELECT . (label_opt . 0)) (WHILE . 
(label_opt . 0)) (STRING_LITERAL . (label_opt . 0)) (CHARACTER_LITERAL . 
(label_opt . 0)) (ABORT . (label_opt . 0)) (DELAY . (label_opt . 0)) (EXIT . 
(label_opt . 0)) (GOTO . (label_opt . 0)) (NULL . (label_opt . 0)) (PRAGMA . 
(label_opt . 0)) (RAISE . (label_opt . 0)) (REQUEUE . (label_opt . 0)) 
(LESS_LESS .  599) (IDENTIFIER . ((label_opt . 0)  600)))
+      ((default . error) (DELAY .  606))
+      ((default . error) (OR . (delay_alternative . 0)) (END . 
(delay_alternative . 0)) (ELSE . (delay_alternative . 0)) (THEN . 
(triggering_alternative . 2)))
+      ((default . error) (END . (select_alternative . 1)) (OR . 
(select_alternative . 1)) (ELSE . (select_alternative . 1)))
+      ((default . error) (EQUAL_GREATER .  933))
+      ((default . error) (END . (select_alternative . 5)) (OR . 
(select_alternative . 5)) (ELSE . (select_alternative . 5)))
+      ((default . error) (SEMICOLON .  932))
+      ((default . error) (END .  931))
+      ((default . error) (SEMICOLON .  930))
+      ((default . error) (OTHERS .  926) (IDENTIFIER .  925) 
(CHARACTER_LITERAL .  47) (STRING_LITERAL .  46))
+      ((default . error) (END . (exception_handler_list . 0)) (WHEN . 
(exception_handler_list . 0)))
+      ((default . error) (END . (exception_handler_list_opt . 1)) (WHEN .  
920))
+      ((default . error) (END . (handled_sequence_of_statements . 0)))
+      ((default . error) (WHEN . (exception_handler_list . 1)) (END . 
(exception_handler_list . 1)))
+      ((default . error) (COLON .  1160) (EQUAL_GREATER . (name . 0)) (BAR . 
(name . 0)) (LEFT_PAREN . (name . 0)) (DOT . (name . 0)) (TICK . (name . 0)))
+      ((default . error) (BAR . (exception_choice . 1)) (EQUAL_GREATER . 
(exception_choice . 1)))
+      ((default . error) (EQUAL_GREATER . (exception_choice_list . 0)) (BAR . 
(exception_choice_list . 0)))
+      ((default . error) (BAR .  1158) (EQUAL_GREATER .  1159))
+      ((default . error) (DOT .  84) (BAR . (exception_choice . 0)) 
(EQUAL_GREATER . (exception_choice . 0)) (TICK .  85) (LEFT_PAREN .  103))
+      ((default . error) (WHEN . (assignment_statement . 0)) (THEN . 
(assignment_statement . 0)) (OR . (assignment_statement . 0)) (ELSIF . 
(assignment_statement . 0)) (ELSE . (assignment_statement . 0)) (WHILE . 
(assignment_statement . 0)) (SELECT . (assignment_statement . 0)) (RETURN . 
(assignment_statement . 0)) (REQUEUE . (assignment_statement . 0)) (RAISE . 
(assignment_statement . 0)) (PRAGMA . (assignment_statement . 0)) (NULL . 
(assignment_statement . 0)) (LOOP . (assignment_statement . 0)) (IF . 
(assignment_statement . 0)) (GOTO . (assignment_statement . 0)) (FOR . 
(assignment_statement . 0)) (EXIT . (assignment_statement . 0)) (DELAY . 
(assignment_statement . 0)) (DECLARE . (assignment_statement . 0)) (CASE . 
(assignment_statement . 0)) (BEGIN . (assignment_statement . 0)) (ABORT . 
(assignment_statement . 0)) (ACCEPT . (assignment_statement . 0)) 
(CHARACTER_LITERAL . (assignment_statement . 0)) (STRING_LITERAL . 
(assignment_statement . 0)) (IDENTIFIER . (assignment_statement . 0)) 
(LESS_LESS . (assignment_statement . 0)) (END . (assignment_statement . 0)) 
(EXCEPTION . (assignment_statement . 0)))
+      ((default . error) (LOOP .  1157))
+      ((default . error) (TYPE . (subprogram_body . 0)) (TASK . 
(subprogram_body . 0)) (SUBTYPE . (subprogram_body . 0)) (PROTECTED . 
(subprogram_body . 0)) (FOR . (subprogram_body . 0)) (ENTRY . (subprogram_body 
. 0)) (IDENTIFIER . (subprogram_body . 0)) (BEGIN . (subprogram_body . 0)) (END 
. (subprogram_body . 0)) ($EOI . (subprogram_body . 0)) (FUNCTION . 
(subprogram_body . 0)) (GENERIC . (subprogram_body . 0)) (LIMITED . 
(subprogram_body . 0)) (NOT . (subprogram_body . 0)) (OVERRIDING . 
(subprogram_body . 0)) (PACKAGE . (subprogram_body . 0)) (PRAGMA . 
(subprogram_body . 0)) (PRIVATE . (subprogram_body . 0)) (PROCEDURE . 
(subprogram_body . 0)) (SEPARATE . (subprogram_body . 0)) (USE . 
(subprogram_body . 0)) (WITH . (subprogram_body . 0)))
+      ((default . error) (TERMINATE .  1154) (ACCEPT .  601) (DELAY .  606))
+      ((default . error) (END .  1153))
+      ((default . error) (END . (sequence_of_statements_opt . 0)) (OR . 
(sequence_of_statements_opt . 0)) (ELSE . (sequence_of_statements_opt . 0)) 
(ACCEPT . (label_opt . 0)) (BEGIN . (label_opt . 0)) (CASE . (label_opt . 0)) 
(DECLARE . (label_opt . 0)) (FOR . (label_opt . 0)) (IF . (label_opt . 0)) 
(LOOP . (label_opt . 0)) (RETURN . (label_opt . 0)) (SELECT . (label_opt . 0)) 
(WHILE . (label_opt . 0)) (STRING_LITERAL . (label_opt . 0)) (CHARACTER_LITERAL 
. (label_opt . 0)) (ABORT . (label_opt . 0)) (DELAY . (label_opt . 0)) (EXIT . 
(label_opt . 0)) (GOTO . (label_opt . 0)) (NULL . (label_opt . 0)) (PRAGMA . 
(label_opt . 0)) (RAISE . (label_opt . 0)) (REQUEUE . (label_opt . 0)) 
(LESS_LESS .  599) (IDENTIFIER . ((label_opt . 0)  600)))
+      ((default . error) (END .  1151))
+      ((default . error) (ELSE . (select_alternative_list . 1)) (END . 
(select_alternative_list . 1)) (OR . (select_alternative_list . 1)))
+      ((default . error) (SEMICOLON .  1150))
+      ((default . error) (END .  1149))
+      ((default . error) (END . (sequence_of_statements_opt . 0)) (ACCEPT . 
(label_opt . 0)) (BEGIN . (label_opt . 0)) (CASE . (label_opt . 0)) (DECLARE . 
(label_opt . 0)) (FOR . (label_opt . 0)) (IF . (label_opt . 0)) (LOOP . 
(label_opt . 0)) (RETURN . (label_opt . 0)) (SELECT . (label_opt . 0)) (WHILE . 
(label_opt . 0)) (STRING_LITERAL . (label_opt . 0)) (CHARACTER_LITERAL . 
(label_opt . 0)) (ABORT . (label_opt . 0)) (DELAY . (label_opt . 0)) (EXIT . 
(label_opt . 0)) (GOTO . (label_opt . 0)) (NULL . (label_opt . 0)) (PRAGMA . 
(label_opt . 0)) (RAISE . (label_opt . 0)) (REQUEUE . (label_opt . 0)) 
(LESS_LESS .  599) (IDENTIFIER . ((label_opt . 0)  600)))
+      ((default . error) (IDENTIFIER . (constant_opt . 0)) (STRING_LITERAL . 
(constant_opt . 0)) (CHARACTER_LITERAL . (constant_opt . 0)) (ACCESS . 
(constant_opt . 0)) (NOT . (constant_opt . 0)) (CONSTANT .  714))
+      ((default . error) (END .  1146))
+      ((default . error) (SEMICOLON .  1145))
+      ((default . error) (SEMICOLON .  1144))
+      ((default . error) (SEMICOLON . (identifier_opt . 0)) (IDENTIFIER .  
683))
+      ((default . error) (ELSE .  1138) (END .  1140) (ELSIF .  1139))
+      ((default . error) (SEMICOLON .  1137))
+      ((default . error) (WHEN . (delay_statement . 0)) (ELSIF . 
(delay_statement . 0)) (EXCEPTION . (delay_statement . 0)) (WHILE . 
(delay_statement . 0)) (SELECT . (delay_statement . 0)) (RETURN . 
(delay_statement . 0)) (REQUEUE . (delay_statement . 0)) (RAISE . 
(delay_statement . 0)) (PRAGMA . (delay_statement . 0)) (NULL . 
(delay_statement . 0)) (LOOP . (delay_statement . 0)) (IF . (delay_statement . 
0)) (GOTO . (delay_statement . 0)) (FOR . (delay_statement . 0)) (EXIT . 
(delay_statement . 0)) (DELAY . (delay_statement . 0)) (DECLARE . 
(delay_statement . 0)) (CASE . (delay_statement . 0)) (BEGIN . (delay_statement 
. 0)) (ABORT . (delay_statement . 0)) (ACCEPT . (delay_statement . 0)) 
(CHARACTER_LITERAL . (delay_statement . 0)) (STRING_LITERAL . (delay_statement 
. 0)) (IDENTIFIER . (delay_statement . 0)) (LESS_LESS . (delay_statement . 0)) 
(END . (delay_statement . 0)) (OR . (delay_statement . 0)) (ELSE . 
(delay_statement . 0)) (THEN . (delay_statement . 0)))
+      ((default . error) (END .  1136))
+      ((default . error) (EQUAL_GREATER . (discrete_choice_list . 0)) (BAR . 
(discrete_choice_list . 0)) (OTHERS .  165) (IDENTIFIER .  45) 
(CHARACTER_LITERAL .  47) (STRING_LITERAL .  46) (PLUS .  136) (MINUS .  135) 
(ABS .  138) (NOT .  164) (NULL .  142) (NEW .  140) (LEFT_PAREN .  139))
+      ((default . error) (END . (case_statement_alternative_list . 0)) (WHEN . 
(case_statement_alternative_list . 0)))
+      ((default . error) (END .  1133) (WHEN .  950))
+      ((default . error) (SEMICOLON .  1132))
+      ((default . error) (DO .  1131) (SEMICOLON .  1130))
+      ((default . error) (BEGIN .  1129))
+      ((default . error) (IDENTIFIER .  1128))
+      ((default . error) (PROCEDURE . (protected_operation_item . 3)) 
(OVERRIDING . (protected_operation_item . 3)) (NOT . (protected_operation_item 
. 3)) (FUNCTION . (protected_operation_item . 3)) (FOR . 
(protected_operation_item . 3)) (ENTRY . (protected_operation_item . 3)) (END . 
(protected_operation_item . 3)))
+      ((default . error) (PROCEDURE . (protected_operation_item . 2)) 
(OVERRIDING . (protected_operation_item . 2)) (NOT . (protected_operation_item 
. 2)) (FUNCTION . (protected_operation_item . 2)) (FOR . 
(protected_operation_item . 2)) (ENTRY . (protected_operation_item . 2)) (END . 
(protected_operation_item . 2)))
+      ((default . error) (FUNCTION .  1) (PROCEDURE .  9))
+      ((default . error) (END . (protected_operation_item_list . 0)) (ENTRY . 
(protected_operation_item_list . 0)) (FOR . (protected_operation_item_list . 
0)) (FUNCTION . (protected_operation_item_list . 0)) (NOT . 
(protected_operation_item_list . 0)) (OVERRIDING . 
(protected_operation_item_list . 0)) (PROCEDURE . 
(protected_operation_item_list . 0)))
+      ((default . error) (END . (protected_operation_item_list_opt . 1)) 
(ENTRY .  956) (NOT .  4) (OVERRIDING .  5) (FUNCTION . 
(overriding_indicator_opt . 2)) (PROCEDURE . (overriding_indicator_opt . 2)) 
(FOR .  279))
+      ((default . error) (END .  1126))
+      ((default . error) (PROCEDURE . (protected_operation_item . 1)) 
(OVERRIDING . (protected_operation_item . 1)) (NOT . (protected_operation_item 
. 1)) (FUNCTION . (protected_operation_item . 1)) (FOR . 
(protected_operation_item . 1)) (ENTRY . (protected_operation_item . 1)) (END . 
(protected_operation_item . 1)))
+      ((default . error) (PROCEDURE . (protected_operation_item . 0)) 
(OVERRIDING . (protected_operation_item . 0)) (NOT . (protected_operation_item 
. 0)) (FUNCTION . (protected_operation_item . 0)) (FOR . 
(protected_operation_item . 0)) (ENTRY . (protected_operation_item . 0)) (END . 
(protected_operation_item . 0)))
+      ((default . error) (PLUS .  136) (MINUS .  135) (ABS .  138) (NOT .  
141) (NULL .  142) (NEW .  140) (IDENTIFIER .  45) (CHARACTER_LITERAL .  47) 
(STRING_LITERAL .  46) (LEFT_PAREN .  139))
+      ((default . error) (ELSIF . (elsif_expression_list . 1)) (ELSE . 
(elsif_expression_list . 1)) (RIGHT_PAREN . (elsif_expression_list . 1)))
+      ((default . error) (THEN .  1124))
+      ((default . error) (RIGHT_PAREN . (if_expression . 2)))
+      ((default . error) (REVERSE .  1122) (IDENTIFIER .  45) 
(CHARACTER_LITERAL .  47) (STRING_LITERAL .  46))
+      ((default . error) (LOOP . (iterator_specification . 0)) (EQUAL_GREATER 
. (iterator_specification . 0)))
+      ((default . error) (DOT .  84) (TICK .  85) (LOOP . 
(iterator_specification . 4)) (EQUAL_GREATER . (iterator_specification . 4)) 
(LEFT_PAREN .  103))
+      ((default . error) (PLUS .  136) (MINUS .  135) (ABS .  138) (NOT .  
141) (NULL .  142) (NEW .  140) (IDENTIFIER .  45) (CHARACTER_LITERAL .  47) 
(STRING_LITERAL .  46) (LEFT_PAREN .  139))
+      ((default . error) (RIGHT_PAREN . (case_expression_alternative_list . 
1)) (COMMA . (case_expression_alternative_list . 1)))
+      ((default . error) (SEMICOLON .  1120))
+      ((default . error) (WITH . (parameter_profile_opt . 0)) (SEMICOLON . 
(parameter_profile_opt . 0)) (LEFT_PAREN .  773))
+      ((default . error) (USE . (entry_declaration . 1)) (TYPE . 
(entry_declaration . 1)) (TASK . (entry_declaration . 1)) (SUBTYPE . 
(entry_declaration . 1)) (PROTECTED . (entry_declaration . 1)) (PROCEDURE . 
(entry_declaration . 1)) (PRAGMA . (entry_declaration . 1)) (PACKAGE . 
(entry_declaration . 1)) (OVERRIDING . (entry_declaration . 1)) (NOT . 
(entry_declaration . 1)) (GENERIC . (entry_declaration . 1)) (FUNCTION . 
(entry_declaration . 1)) (FOR . (entry_declaration . 1)) (ENTRY . 
(entry_declaration . 1)) (IDENTIFIER . (entry_declaration . 1)) (BEGIN . 
(entry_declaration . 1)) (END . (entry_declaration . 1)) (PRIVATE . 
(entry_declaration . 1)))
+      ((default . error) (USE . (null_procedure_declaration . 0)) (TYPE . 
(null_procedure_declaration . 0)) (TASK . (null_procedure_declaration . 0)) 
(SUBTYPE . (null_procedure_declaration . 0)) (PROTECTED . 
(null_procedure_declaration . 0)) (PROCEDURE . (null_procedure_declaration . 
0)) (PRAGMA . (null_procedure_declaration . 0)) (PACKAGE . 
(null_procedure_declaration . 0)) (OVERRIDING . (null_procedure_declaration . 
0)) (NOT . (null_procedure_declaration . 0)) (GENERIC . 
(null_procedure_declaration . 0)) (FUNCTION . (null_procedure_declaration . 0)) 
(FOR . (null_procedure_declaration . 0)) (ENTRY . (null_procedure_declaration . 
0)) (IDENTIFIER . (null_procedure_declaration . 0)) (BEGIN . 
(null_procedure_declaration . 0)) (END . (null_procedure_declaration . 0)) 
(PRIVATE . (null_procedure_declaration . 0)))
+      ((default . error) (BEGIN . (subprogram_renaming_declaration . 0)) 
(IDENTIFIER . (subprogram_renaming_declaration . 0)) (ENTRY . 
(subprogram_renaming_declaration . 0)) (FOR . (subprogram_renaming_declaration 
. 0)) (FUNCTION . (subprogram_renaming_declaration . 0)) (GENERIC . 
(subprogram_renaming_declaration . 0)) (NOT . (subprogram_renaming_declaration 
. 0)) (OVERRIDING . (subprogram_renaming_declaration . 0)) (PACKAGE . 
(subprogram_renaming_declaration . 0)) (PRAGMA . 
(subprogram_renaming_declaration . 0)) (PROCEDURE . 
(subprogram_renaming_declaration . 0)) (PROTECTED . 
(subprogram_renaming_declaration . 0)) (SUBTYPE . 
(subprogram_renaming_declaration . 0)) (TASK . (subprogram_renaming_declaration 
. 0)) (TYPE . (subprogram_renaming_declaration . 0)) (USE . 
(subprogram_renaming_declaration . 0)) (PRIVATE . 
(subprogram_renaming_declaration . 0)) (END . (subprogram_renaming_declaration 
. 0)))
+      ((default . error) (USE . (abstract_subprogram_declaration . 0)) (TYPE . 
(abstract_subprogram_declaration . 0)) (TASK . (abstract_subprogram_declaration 
. 0)) (SUBTYPE . (abstract_subprogram_declaration . 0)) (PROTECTED . 
(abstract_subprogram_declaration . 0)) (PROCEDURE . 
(abstract_subprogram_declaration . 0)) (PRAGMA . 
(abstract_subprogram_declaration . 0)) (PACKAGE . 
(abstract_subprogram_declaration . 0)) (OVERRIDING . 
(abstract_subprogram_declaration . 0)) (NOT . (abstract_subprogram_declaration 
. 0)) (GENERIC . (abstract_subprogram_declaration . 0)) (FUNCTION . 
(abstract_subprogram_declaration . 0)) (FOR . (abstract_subprogram_declaration 
. 0)) (ENTRY . (abstract_subprogram_declaration . 0)) (IDENTIFIER . 
(abstract_subprogram_declaration . 0)) (BEGIN . 
(abstract_subprogram_declaration . 0)) (END . (abstract_subprogram_declaration 
. 0)) (PRIVATE . (abstract_subprogram_declaration . 0)))
+      ((default . error) (USE . (subprogram_body_stub . 0)) (TYPE . 
(subprogram_body_stub . 0)) (TASK . (subprogram_body_stub . 0)) (SUBTYPE . 
(subprogram_body_stub . 0)) (PROTECTED . (subprogram_body_stub . 0)) (PROCEDURE 
. (subprogram_body_stub . 0)) (PRAGMA . (subprogram_body_stub . 0)) (PACKAGE . 
(subprogram_body_stub . 0)) (OVERRIDING . (subprogram_body_stub . 0)) (NOT . 
(subprogram_body_stub . 0)) (GENERIC . (subprogram_body_stub . 0)) (FUNCTION . 
(subprogram_body_stub . 0)) (FOR . (subprogram_body_stub . 0)) (ENTRY . 
(subprogram_body_stub . 0)) (IDENTIFIER . (subprogram_body_stub . 0)) (BEGIN . 
(subprogram_body_stub . 0)) (END . (subprogram_body_stub . 0)) (PRIVATE . 
(subprogram_body_stub . 0)))
+      ((default . error) (PLUS .  136) (MINUS .  135) (ABS .  138) (NOT .  
141) (NULL .  142) (NEW .  140) (IDENTIFIER .  45) (CHARACTER_LITERAL .  47) 
(STRING_LITERAL .  46) (LEFT_PAREN .  139))
+      ((default . error) (SEMICOLON .  1117))
+      ((default . error) (PLUS .  136) (MINUS .  135) (ABS .  138) (NOT .  
141) (NULL .  142) (NEW .  140) (IDENTIFIER .  45) (CHARACTER_LITERAL .  47) 
(STRING_LITERAL .  46) (LEFT_PAREN .  139))
+      ((default . error) (SEMICOLON .  1115))
+      ((default . error) (PLUS .  136) (MINUS .  135) (ABS .  138) (NOT .  
141) (NULL .  142) (NEW .  140) (IDENTIFIER .  45) (CHARACTER_LITERAL .  47) 
(STRING_LITERAL .  46) (LEFT_PAREN .  139))
+      ((default . error) (SEMICOLON .  1113))
+      ((default . error) (ACCESS . (null_exclusion_opt . 1)) (IDENTIFIER .  
45) (CHARACTER_LITERAL .  47) (STRING_LITERAL .  46))
+      ((default . error) (BEGIN . (declaration . 8)) (IDENTIFIER . 
(declaration . 8)) (ENTRY . (declaration . 8)) (FOR . (declaration . 8)) 
(FUNCTION . (declaration . 8)) (GENERIC . (declaration . 8)) (NOT . 
(declaration . 8)) (OVERRIDING . (declaration . 8)) (PACKAGE . (declaration . 
8)) (PRAGMA . (declaration . 8)) (PROCEDURE . (declaration . 8)) (PROTECTED . 
(declaration . 8)) (SUBTYPE . (declaration . 8)) (TASK . (declaration . 8)) 
(TYPE . (declaration . 8)) (USE . (declaration . 8)) (PRIVATE . (declaration . 
8)) (END . (declaration . 8)))
+      ((default . error) (SEMICOLON .  1112))
+      ((default . error) (SEMICOLON . (aspect_specification_opt . 0)) (WITH .  
104))
+      ((default . error) (WITH . (record_type_definition . 0)) (SEMICOLON . 
(record_type_definition . 0)))
+      ((default . error) (IDENTIFIER .  45) (CHARACTER_LITERAL .  47) 
(STRING_LITERAL .  46))
+      ((default . error) (NOT .  724) (IDENTIFIER .  45) (CHARACTER_LITERAL .  
47) (STRING_LITERAL .  46))
+      ((default . error) (BEGIN . (incomplete_type_declaration . 0)) 
(IDENTIFIER . (incomplete_type_declaration . 0)) (ENTRY . 
(incomplete_type_declaration . 0)) (FOR . (incomplete_type_declaration . 0)) 
(FUNCTION . (incomplete_type_declaration . 0)) (GENERIC . 
(incomplete_type_declaration . 0)) (NOT . (incomplete_type_declaration . 0)) 
(OVERRIDING . (incomplete_type_declaration . 0)) (PACKAGE . 
(incomplete_type_declaration . 0)) (PRAGMA . (incomplete_type_declaration . 0)) 
(PROCEDURE . (incomplete_type_declaration . 0)) (PROTECTED . 
(incomplete_type_declaration . 0)) (SUBTYPE . (incomplete_type_declaration . 
0)) (TASK . (incomplete_type_declaration . 0)) (TYPE . 
(incomplete_type_declaration . 0)) (USE . (incomplete_type_declaration . 0)) 
(PRIVATE . (incomplete_type_declaration . 0)) (END . 
(incomplete_type_declaration . 0)))
+      ((default . error) (IDENTIFIER .  1106) (STRING_LITERAL .  1107))
+      ((default . error) (SEMICOLON .  1105))
+      ((default . error) (WHEN . (component_item . 1)) (END . (component_item 
. 1)) (FOR . (component_item . 1)) (IDENTIFIER . (component_item . 1)) (CASE . 
(component_item . 1)))
+      ((default . error) (WHEN . (component_item . 0)) (END . (component_item 
. 0)) (FOR . (component_item . 0)) (IDENTIFIER . (component_item . 0)) (CASE . 
(component_item . 0)))
+      ((default . error) (WHEN . (component_list . 0)) (END . (component_list 
. 0)) (CASE . (component_list . 0)) (IDENTIFIER . (component_list . 0)) (FOR . 
(component_list . 0)))
+      ((default . error) (END . (component_list_opt . 1)) (CASE .  995) 
(IDENTIFIER .  69) (FOR .  279))
+      ((default . error) (END .  1102))
+      ((default . error) (COMMA .  92) (COLON .  1101))
+      ((default . error) (WHEN . (component_list . 3)) (END . (component_list 
. 3)) (CASE . (component_list . 3)) (IDENTIFIER . (component_list . 3)) (FOR . 
(component_list . 3)))
+      ((default . error) (DOT_DOT .  1100))
+      ((default . error) (SEMICOLON . (record_definition . 1)) (WITH . 
(record_definition . 1)))
+      ((default . error) (SEMICOLON . (type_definition . 2)) (WITH . 
(type_definition . 2)))
+      ((default . error) (COMMA . (enumeration_literal . 0)) (RIGHT_PAREN . 
(enumeration_literal . 0)))
+      ((default . error) (COMMA . (enumeration_literal . 1)) (RIGHT_PAREN . 
(enumeration_literal . 1)))
+      ((default . error) (RIGHT_PAREN . (enumeration_literal_list . 0)) (COMMA 
. (enumeration_literal_list . 0)))
+      ((default . error) (COMMA .  1098) (RIGHT_PAREN .  1099))
+      ((default . error) (WITH . (real_range_specification_opt . 0)) 
(SEMICOLON . (real_range_specification_opt . 0)) (RANGE .  1095))
+      ((default . error) (DIGITS .  1094) (WITH . 
(real_range_specification_opt . 0)) (SEMICOLON . (real_range_specification_opt 
. 0)) (RANGE .  1095))
+      ((default . error) (NEW . ((abstract_limited_opt . 1) 
(abstract_limited_synchronized_opt . 1))))
+      ((default . error) (NEW . (abstract_limited_synchronized_opt . 2)))
+      ((default . error) (BEGIN . (single_task_declaration . 1)) (IDENTIFIER . 
(single_task_declaration . 1)) (ENTRY . (single_task_declaration . 1)) (FOR . 
(single_task_declaration . 1)) (FUNCTION . (single_task_declaration . 1)) 
(GENERIC . (single_task_declaration . 1)) (NOT . (single_task_declaration . 1)) 
(OVERRIDING . (single_task_declaration . 1)) (PACKAGE . 
(single_task_declaration . 1)) (PRAGMA . (single_task_declaration . 1)) 
(PROCEDURE . (single_task_declaration . 1)) (PROTECTED . 
(single_task_declaration . 1)) (SUBTYPE . (single_task_declaration . 1)) (TASK 
. (single_task_declaration . 1)) (TYPE . (single_task_declaration . 1)) (USE . 
(single_task_declaration . 1)) (PRIVATE . (single_task_declaration . 1)) (END . 
(single_task_declaration . 1)))
+      ((default . error) (SEMICOLON . (identifier_opt . 0)) (IDENTIFIER .  
683))
+      ((default . error) (END . (declarative_part_opt . 0)) (USE .  11) 
(SUBTYPE .  282) (PRAGMA .  7) (NOT .  4) (OVERRIDING .  5) (FUNCTION . 
(overriding_indicator_opt . 2)) (PROCEDURE . (overriding_indicator_opt . 2)) 
(ENTRY . (overriding_indicator_opt . 2)) (FOR .  279) (IDENTIFIER .  278) (TYPE 
.  284) (GENERIC .  2) (PROTECTED .  281) (TASK .  283) (PACKAGE .  280))
+      ((default . error) (AND .  1054) (WITH .  1091))
+      ((default . error) (SEMICOLON .  1090))
+      ((default . error) (USE . (task_type_declaration . 2)) (TYPE . 
(task_type_declaration . 2)) (TASK . (task_type_declaration . 2)) (SUBTYPE . 
(task_type_declaration . 2)) (PROTECTED . (task_type_declaration . 2)) 
(PROCEDURE . (task_type_declaration . 2)) (PRAGMA . (task_type_declaration . 
2)) (PACKAGE . (task_type_declaration . 2)) (OVERRIDING . 
(task_type_declaration . 2)) (NOT . (task_type_declaration . 2)) (GENERIC . 
(task_type_declaration . 2)) (FUNCTION . (task_type_declaration . 2)) (FOR . 
(task_type_declaration . 2)) (ENTRY . (task_type_declaration . 2)) (IDENTIFIER 
. (task_type_declaration . 2)) (BEGIN . (task_type_declaration . 2)) (END . 
(task_type_declaration . 2)) (PRIVATE . (task_type_declaration . 2)))
+      ((default . error) (NEW .  1088) (END . (declarative_part_opt . 0)) 
(PRIVATE . (declarative_part_opt . 0)) (USE .  11) (SUBTYPE .  282) (PRAGMA .  
7) (NOT .  4) (OVERRIDING .  5) (FUNCTION . (overriding_indicator_opt . 2)) 
(PROCEDURE . (overriding_indicator_opt . 2)) (ENTRY . (overriding_indicator_opt 
. 2)) (FOR .  279) (IDENTIFIER .  278) (TYPE .  284) (GENERIC .  2) (PROTECTED 
.  281) (TASK .  283) (PACKAGE .  280))
+      ((default . error) (DO . (subtype_indication . 1)) (LOOP . 
(subtype_indication . 1)) (COLON_EQUAL . (subtype_indication . 1)) (SEMICOLON . 
(subtype_indication . 1)) (OF . (subtype_indication . 1)) (AND . 
(subtype_indication . 1)) (WITH . (subtype_indication . 1)) (EQUAL_GREATER . 
(subtype_indication . 1)) (COMMA . (subtype_indication . 1)) (RIGHT_PAREN . 
(subtype_indication . 1)) (DOT .  84) (TICK .  85) (RANGE .  825) (LEFT_PAREN . 
 792))
+      ((default . error) (LOOP . (constraint . 0)) (EQUAL_GREATER . 
(constraint . 0)) (DO . (constraint . 0)) (OF . (constraint . 0)) (AND . 
(constraint . 0)) (SEMICOLON . (constraint . 0)) (WITH . (constraint . 0)) 
(COLON_EQUAL . (constraint . 0)) (RIGHT_PAREN . (constraint . 0)) (COMMA . 
(constraint . 0)))
+      ((default . error) (USE . (subtype_declaration . 0)) (TYPE . 
(subtype_declaration . 0)) (TASK . (subtype_declaration . 0)) (SUBTYPE . 
(subtype_declaration . 0)) (PROTECTED . (subtype_declaration . 0)) (PROCEDURE . 
(subtype_declaration . 0)) (PRAGMA . (subtype_declaration . 0)) (PACKAGE . 
(subtype_declaration . 0)) (OVERRIDING . (subtype_declaration . 0)) (NOT . 
(subtype_declaration . 0)) (GENERIC . (subtype_declaration . 0)) (FUNCTION . 
(subtype_declaration . 0)) (FOR . (subtype_declaration . 0)) (ENTRY . 
(subtype_declaration . 0)) (IDENTIFIER . (subtype_declaration . 0)) (BEGIN . 
(subtype_declaration . 0)) (END . (subtype_declaration . 0)) (PRIVATE . 
(subtype_declaration . 0)))
+      ((default . error) (BEGIN . (single_protected_declaration . 1)) 
(IDENTIFIER . (single_protected_declaration . 1)) (ENTRY . 
(single_protected_declaration . 1)) (FOR . (single_protected_declaration . 1)) 
(FUNCTION . (single_protected_declaration . 1)) (GENERIC . 
(single_protected_declaration . 1)) (NOT . (single_protected_declaration . 1)) 
(OVERRIDING . (single_protected_declaration . 1)) (PACKAGE . 
(single_protected_declaration . 1)) (PRAGMA . (single_protected_declaration . 
1)) (PROCEDURE . (single_protected_declaration . 1)) (PROTECTED . 
(single_protected_declaration . 1)) (SUBTYPE . (single_protected_declaration . 
1)) (TASK . (single_protected_declaration . 1)) (TYPE . 
(single_protected_declaration . 1)) (USE . (single_protected_declaration . 1)) 
(PRIVATE . (single_protected_declaration . 1)) (END . 
(single_protected_declaration . 1)))
+      ((default . error) (SEMICOLON . (identifier_opt . 0)) (IDENTIFIER .  
683))
+      ((default . error) (END . (declarative_part_opt . 0)) (USE .  11) 
(SUBTYPE .  282) (PRAGMA .  7) (NOT .  4) (OVERRIDING .  5) (FUNCTION . 
(overriding_indicator_opt . 2)) (PROCEDURE . (overriding_indicator_opt . 2)) 
(ENTRY . (overriding_indicator_opt . 2)) (FOR .  279) (IDENTIFIER .  278) (TYPE 
.  284) (GENERIC .  2) (PROTECTED .  281) (TASK .  283) (PACKAGE .  280))
+      ((default . error) (AND .  1054) (WITH .  1084))
+      ((default . error) (SEMICOLON .  1083))
+      ((default . error) (NEW .  1081) (END . (declarative_part_opt . 0)) 
(PRIVATE . (declarative_part_opt . 0)) (USE .  11) (SUBTYPE .  282) (PRAGMA .  
7) (NOT .  4) (OVERRIDING .  5) (FUNCTION . (overriding_indicator_opt . 2)) 
(PROCEDURE . (overriding_indicator_opt . 2)) (ENTRY . (overriding_indicator_opt 
. 2)) (FOR .  279) (IDENTIFIER .  278) (TYPE .  284) (GENERIC .  2) (PROTECTED 
.  281) (TASK .  283) (PACKAGE .  280))
+      ((default . error) (SEMICOLON .  1080))
+      ((default . error) (BEGIN . (package_renaming_declaration . 0)) 
(IDENTIFIER . (package_renaming_declaration . 0)) (ENTRY . 
(package_renaming_declaration . 0)) (FOR . (package_renaming_declaration . 0)) 
(FUNCTION . (package_renaming_declaration . 0)) (GENERIC . 
(package_renaming_declaration . 0)) (NOT . (package_renaming_declaration . 0)) 
(OVERRIDING . (package_renaming_declaration . 0)) (PACKAGE . 
(package_renaming_declaration . 0)) (PRAGMA . (package_renaming_declaration . 
0)) (PROCEDURE . (package_renaming_declaration . 0)) (PROTECTED . 
(package_renaming_declaration . 0)) (SUBTYPE . (package_renaming_declaration . 
0)) (TASK . (package_renaming_declaration . 0)) (TYPE . 
(package_renaming_declaration . 0)) (USE . (package_renaming_declaration . 0)) 
(PRIVATE . (package_renaming_declaration . 0)) (END . 
(package_renaming_declaration . 0)))
+      ((default . error) (WHEN . (at_clause . 0)) (BEGIN . (at_clause . 0)) 
(IDENTIFIER . (at_clause . 0)) (ENTRY . (at_clause . 0)) (FOR . (at_clause . 
0)) (FUNCTION . (at_clause . 0)) (GENERIC . (at_clause . 0)) (NOT . (at_clause 
. 0)) (OVERRIDING . (at_clause . 0)) (PACKAGE . (at_clause . 0)) (PRAGMA . 
(at_clause . 0)) (PROCEDURE . (at_clause . 0)) (PROTECTED . (at_clause . 0)) 
(SUBTYPE . (at_clause . 0)) (TASK . (at_clause . 0)) (TYPE . (at_clause . 0)) 
(USE . (at_clause . 0)) (CASE . (at_clause . 0)) (PRIVATE . (at_clause . 0)) 
(END . (at_clause . 0)))
+      ((default . error) (AT .  1079))
+      ((default . error) (END . (component_clause_list . 0)) (IDENTIFIER . 
(component_clause_list . 0)))
+      ((default . error) (END .  1077) (IDENTIFIER .  1034))
+      ((default . error) (PLUS .  136) (MINUS .  135) (ABS .  138) (NOT .  
141) (NULL .  142) (NEW .  140) (IDENTIFIER .  45) (CHARACTER_LITERAL .  47) 
(STRING_LITERAL .  46) (LEFT_PAREN .  139))
+      ((default . error) (DOT .  84) (TICK .  85) (SEMICOLON . 
(aspect_specification_opt . 0)) (WITH .  104) (LEFT_PAREN .  103))
+      ((default . error) (SEMICOLON .  1074))
+      ((default . error) (SEMICOLON .  1073))
+      ((default . error) (IDENTIFIER .  45) (CHARACTER_LITERAL .  47) 
(STRING_LITERAL .  46))
+      ((default . error) (PRIVATE .  1071))
+      ((default . error) (IDENTIFIER .  45) (CHARACTER_LITERAL .  47) 
(STRING_LITERAL .  46))
+      ((default . error) (PRIVATE .  1069))
+      ((default . error) (ALIASED .  1064) (IDENTIFIER .  45) 
(CHARACTER_LITERAL .  47) (STRING_LITERAL .  46) (ACCESS . (null_exclusion_opt 
. 0)) (NOT .  855))
+      ((default . error) (RIGHT_PAREN . (discrete_subtype_definition_list . 
1)) (COMMA . (discrete_subtype_definition_list . 1)))
+      ((default . error) (ALIASED .  1064) (IDENTIFIER .  45) 
(CHARACTER_LITERAL .  47) (STRING_LITERAL .  46) (ACCESS . (null_exclusion_opt 
. 0)) (NOT .  855))
+      ((default . error) (RIGHT_PAREN . (index_subtype_definition_list . 1)) 
(COMMA . (index_subtype_definition_list . 1)))
+      ((default . error) (DOT .  84) (RANGE .  1063) (TICK .  85) (LEFT_PAREN 
.  103))
+      ((default . error) (COMMA . (index_subtype_definition . 0)) (RIGHT_PAREN 
. (index_subtype_definition . 0)))
+      ((default . error) (NULL .  1062) (NEW .  140) (IDENTIFIER .  45) 
(CHARACTER_LITERAL .  47) (STRING_LITERAL .  46) (LEFT_PAREN .  139))
+      ((default . error) (COMMA .  798) (RIGHT_PAREN .  1061))
+      ((default . error) (COMMA . (discrete_subtype_definition . 1)) (BAR . 
(discrete_choice . 2)) (EQUAL_GREATER . (discrete_choice . 2)) (RIGHT_PAREN . 
((discrete_subtype_definition . 1)  260)))
+      ((default . error) (IDENTIFIER .  45) (CHARACTER_LITERAL .  47) 
(STRING_LITERAL .  46))
+      ((default . error) (WITH . (formal_package_actual_part . 0)) (SEMICOLON 
. (formal_package_actual_part . 0)))
+      ((default . error) (PACKAGE . (formal_package_declaration . 0)) 
(PROCEDURE . (formal_package_declaration . 0)) (FUNCTION . 
(formal_package_declaration . 0)) (IDENTIFIER . (formal_package_declaration . 
0)) (PRAGMA . (formal_package_declaration . 0)) (TYPE . 
(formal_package_declaration . 0)) (WITH . (formal_package_declaration . 0)))
+      ((default . error) (PACKAGE . (formal_object_declaration . 0)) 
(PROCEDURE . (formal_object_declaration . 0)) (FUNCTION . 
(formal_object_declaration . 0)) (IDENTIFIER . (formal_object_declaration . 0)) 
(PRAGMA . (formal_object_declaration . 0)) (TYPE . (formal_object_declaration . 
0)) (WITH . (formal_object_declaration . 0)))
+      ((default . error) (PLUS .  136) (MINUS .  135) (ABS .  138) (NOT .  
141) (NULL .  142) (NEW .  140) (IDENTIFIER .  45) (CHARACTER_LITERAL .  47) 
(STRING_LITERAL .  46) (LEFT_PAREN .  139))
+      ((default . error) (RIGHT_PAREN . (parameter_specification . 0)) 
(SEMICOLON . (parameter_specification . 0)))
+      ((default . error) (DOT .  84) (TICK .  85) (WITH . (interface_list . 
1)) (SEMICOLON . (interface_list . 1)) (AND . (interface_list . 1)) (LEFT_PAREN 
.  103))
+      ((default . error) (LOOP . (index_constraint . 0)) (DO . 
(index_constraint . 0)) (EQUAL_GREATER . (index_constraint . 0)) (COMMA . 
(index_constraint . 0)) (RIGHT_PAREN . (index_constraint . 0)) (COLON_EQUAL . 
(index_constraint . 0)) (WITH . (index_constraint . 0)) (SEMICOLON . 
(index_constraint . 0)) (AND . (index_constraint . 0)) (OF . (index_constraint 
. 0)))
+      ((default . error) (PLUS . (primary . 0)) (MINUS . (primary . 0)) 
(AMPERSAND . (primary . 0)) (DOT_DOT . (primary . 0)) (SLASH . (primary . 0)) 
(STAR . (primary . 0)) (MOD . (primary . 0)) (REM . (primary . 0)) (XOR . 
(primary . 0)) (OR . (primary . 0)) (AND . (primary . 0)) (EQUAL_GREATER . 
(primary . 0)) (BAR . (primary . 0)) (IN . (primary . 0)) (NOT . (primary . 0)) 
(EQUAL . (primary . 0)) (GREATER . (primary . 0)) (GREATER_EQUAL . (primary . 
0)) (LESS . (primary . 0)) (LESS_EQUAL . (primary . 0)) (SLASH_EQUAL . (primary 
. 0)) (RIGHT_PAREN . (primary . 0)) (COMMA . (primary . 0)) (IDENTIFIER .  45) 
(CHARACTER_LITERAL .  47) (STRING_LITERAL .  46))
+      ((default . error) (BOX .  1050))
+      ((default . error) (ACCESS . (null_exclusion_opt . 0)) (NOT .  855) 
(IDENTIFIER .  45) (CHARACTER_LITERAL .  47) (STRING_LITERAL .  46))
+      ((default . error) (WITH . (component_definition . 3)) (SEMICOLON . 
(component_definition . 3)) (COLON_EQUAL . (component_definition . 3)))
+      ((default . error) (WITH . (array_type_definition . 0)) (SEMICOLON . 
(array_type_definition . 0)) (COLON_EQUAL . (array_type_definition . 0)))
+      ((default . error) (WITH . (component_definition . 1)) (SEMICOLON . 
(component_definition . 1)) (COLON_EQUAL . (component_definition . 1)))
+      ((default . error) (WITH . (array_type_definition . 1)) (SEMICOLON . 
(array_type_definition . 1)) (COLON_EQUAL . (array_type_definition . 1)))
+      ((default . error) (WITH . (formal_derived_type_definition . 4)) 
(SEMICOLON . (formal_derived_type_definition . 4)))
+      ((default . error) (AND .  1054) (WITH . ( 1221 
(formal_derived_type_definition . 2))) (SEMICOLON . 
(formal_derived_type_definition . 2)))
+      ((default . error) (WITH . (formal_derived_type_definition . 5)) 
(SEMICOLON . (formal_derived_type_definition . 5)))
+      ((default . error) (AND .  1054) (WITH . ( 1220 
(formal_derived_type_definition . 3))) (SEMICOLON . 
(formal_derived_type_definition . 3)))
+      ((default . error) (END . (object_renaming_declaration . 2)) (PRIVATE . 
(object_renaming_declaration . 2)) (USE . (object_renaming_declaration . 2)) 
(TYPE . (object_renaming_declaration . 2)) (TASK . (object_renaming_declaration 
. 2)) (SUBTYPE . (object_renaming_declaration . 2)) (PROTECTED . 
(object_renaming_declaration . 2)) (PROCEDURE . (object_renaming_declaration . 
2)) (PRAGMA . (object_renaming_declaration . 2)) (PACKAGE . 
(object_renaming_declaration . 2)) (OVERRIDING . (object_renaming_declaration . 
2)) (NOT . (object_renaming_declaration . 2)) (GENERIC . 
(object_renaming_declaration . 2)) (FUNCTION . (object_renaming_declaration . 
2)) (FOR . (object_renaming_declaration . 2)) (ENTRY . 
(object_renaming_declaration . 2)) (IDENTIFIER . (object_renaming_declaration . 
2)) (BEGIN . (object_renaming_declaration . 2)))
+      ((default . error) (END . (object_renaming_declaration . 1)) (PRIVATE . 
(object_renaming_declaration . 1)) (USE . (object_renaming_declaration . 1)) 
(TYPE . (object_renaming_declaration . 1)) (TASK . (object_renaming_declaration 
. 1)) (SUBTYPE . (object_renaming_declaration . 1)) (PROTECTED . 
(object_renaming_declaration . 1)) (PROCEDURE . (object_renaming_declaration . 
1)) (PRAGMA . (object_renaming_declaration . 1)) (PACKAGE . 
(object_renaming_declaration . 1)) (OVERRIDING . (object_renaming_declaration . 
1)) (NOT . (object_renaming_declaration . 1)) (GENERIC . 
(object_renaming_declaration . 1)) (FUNCTION . (object_renaming_declaration . 
1)) (FOR . (object_renaming_declaration . 1)) (ENTRY . 
(object_renaming_declaration . 1)) (IDENTIFIER . (object_renaming_declaration . 
1)) (BEGIN . (object_renaming_declaration . 1)))
+      ((default . error) (SEMICOLON .  1219))
+      ((default . error) (SEMICOLON .  1218))
+      ((default . error) (RECORD .  1217))
+      ((default . error) (IDENTIFIER . (component_clause_list . 1)) (END . 
(component_clause_list . 1)))
+      ((default . error) (PLUS .  136) (MINUS .  135) (ABS .  138) (NOT .  
141) (NULL .  142) (NEW .  140) (IDENTIFIER .  45) (CHARACTER_LITERAL .  47) 
(STRING_LITERAL .  46) (LEFT_PAREN .  139))
+      ((default . error) (PRIVATE . (package_body_stub . 0)) (END . 
(package_body_stub . 0)) (BEGIN . (package_body_stub . 0)) (IDENTIFIER . 
(package_body_stub . 0)) (ENTRY . (package_body_stub . 0)) (FOR . 
(package_body_stub . 0)) (FUNCTION . (package_body_stub . 0)) (GENERIC . 
(package_body_stub . 0)) (NOT . (package_body_stub . 0)) (OVERRIDING . 
(package_body_stub . 0)) (PACKAGE . (package_body_stub . 0)) (PRAGMA . 
(package_body_stub . 0)) (PROCEDURE . (package_body_stub . 0)) (PROTECTED . 
(package_body_stub . 0)) (SUBTYPE . (package_body_stub . 0)) (TASK . 
(package_body_stub . 0)) (TYPE . (package_body_stub . 0)) (USE . 
(package_body_stub . 0)))
+      ((default . error) (IDENTIFIER .  45) (CHARACTER_LITERAL .  47) 
(STRING_LITERAL .  46))
+      ((default . error) (SEMICOLON .  1214))
+      ((default . error) (PRIVATE . (protected_body_stub . 0)) (END . 
(protected_body_stub . 0)) (BEGIN . (protected_body_stub . 0)) (IDENTIFIER . 
(protected_body_stub . 0)) (ENTRY . (protected_body_stub . 0)) (FOR . 
(protected_body_stub . 0)) (FUNCTION . (protected_body_stub . 0)) (GENERIC . 
(protected_body_stub . 0)) (NOT . (protected_body_stub . 0)) (OVERRIDING . 
(protected_body_stub . 0)) (PACKAGE . (protected_body_stub . 0)) (PRAGMA . 
(protected_body_stub . 0)) (PROCEDURE . (protected_body_stub . 0)) (PROTECTED . 
(protected_body_stub . 0)) (SUBTYPE . (protected_body_stub . 0)) (TASK . 
(protected_body_stub . 0)) (TYPE . (protected_body_stub . 0)) (USE . 
(protected_body_stub . 0)))
+      ((default . error) (END . (declarative_part_opt . 0)) (PRIVATE . 
(declarative_part_opt . 0)) (USE .  11) (SUBTYPE .  282) (PRAGMA .  7) (NOT .  
4) (OVERRIDING .  5) (FUNCTION . (overriding_indicator_opt . 2)) (PROCEDURE . 
(overriding_indicator_opt . 2)) (ENTRY . (overriding_indicator_opt . 2)) (FOR . 
 279) (IDENTIFIER .  278) (TYPE .  284) (GENERIC .  2) (PROTECTED .  281) (TASK 
.  283) (PACKAGE .  280))
+      ((default . error) (END .  1212))
+      ((default . error) (SEMICOLON . (protected_definition . 1)))
+      ((default . error) (LOOP . (subtype_indication . 0)) (DO . 
(subtype_indication . 0)) (RIGHT_PAREN . (subtype_indication . 0)) (COMMA . 
(subtype_indication . 0)) (EQUAL_GREATER . (subtype_indication . 0)) (WITH . 
(subtype_indication . 0)) (AND . (subtype_indication . 0)) (OF . 
(subtype_indication . 0)) (SEMICOLON . (subtype_indication . 0)) (COLON_EQUAL . 
(subtype_indication . 0)))
+      ((default . error) (IDENTIFIER .  45) (CHARACTER_LITERAL .  47) 
(STRING_LITERAL .  46))
+      ((default . error) (SEMICOLON .  1210))
+      ((default . error) (PRIVATE . (task_body_stub . 0)) (END . 
(task_body_stub . 0)) (BEGIN . (task_body_stub . 0)) (IDENTIFIER . 
(task_body_stub . 0)) (ENTRY . (task_body_stub . 0)) (FOR . (task_body_stub . 
0)) (FUNCTION . (task_body_stub . 0)) (GENERIC . (task_body_stub . 0)) (NOT . 
(task_body_stub . 0)) (OVERRIDING . (task_body_stub . 0)) (PACKAGE . 
(task_body_stub . 0)) (PRAGMA . (task_body_stub . 0)) (PROCEDURE . 
(task_body_stub . 0)) (PROTECTED . (task_body_stub . 0)) (SUBTYPE . 
(task_body_stub . 0)) (TASK . (task_body_stub . 0)) (TYPE . (task_body_stub . 
0)) (USE . (task_body_stub . 0)))
+      ((default . error) (END . (declarative_part_opt . 0)) (PRIVATE . 
(declarative_part_opt . 0)) (USE .  11) (SUBTYPE .  282) (PRAGMA .  7) (NOT .  
4) (OVERRIDING .  5) (FUNCTION . (overriding_indicator_opt . 2)) (PROCEDURE . 
(overriding_indicator_opt . 2)) (ENTRY . (overriding_indicator_opt . 2)) (FOR . 
 279) (IDENTIFIER .  278) (TYPE .  284) (GENERIC .  2) (PROTECTED .  281) (TASK 
.  283) (PACKAGE .  280))
+      ((default . error) (END .  1208))
+      ((default . error) (SEMICOLON . (task_definition . 1)))
+      ((default . error) (PLUS .  136) (MINUS .  135) (ABS .  138) (NOT .  
141) (NULL .  142) (NEW .  140) (IDENTIFIER .  45) (CHARACTER_LITERAL .  47) 
(STRING_LITERAL .  46) (LEFT_PAREN .  139))
+      ((default . error) (PLUS .  136) (MINUS .  135) (ABS .  138) (NOT .  
141) (NULL .  142) (NEW .  140) (IDENTIFIER .  45) (CHARACTER_LITERAL .  47) 
(STRING_LITERAL .  46) (LEFT_PAREN .  139))
+      ((default . error) (WITH . (type_definition . 4)) (SEMICOLON . 
(type_definition . 4)))
+      ((default . error) (WITH . (type_definition . 3)) (SEMICOLON . 
(type_definition . 3)))
+      ((default . error) (IDENTIFIER .  1007) (CHARACTER_LITERAL .  1008))
+      ((default . error) (SEMICOLON . (enumeration_type_definition . 0)) (WITH 
. (enumeration_type_definition . 0)))
+      ((default . error) (PLUS .  136) (MINUS .  135) (ABS .  138) (NOT .  
141) (NULL .  142) (NEW .  140) (IDENTIFIER .  45) (CHARACTER_LITERAL .  47) 
(STRING_LITERAL .  46) (LEFT_PAREN .  139))
+      ((default . error) (ALIASED .  1064) (IDENTIFIER .  45) 
(CHARACTER_LITERAL .  47) (STRING_LITERAL .  46) (ACCESS . (null_exclusion_opt 
. 0)) (NOT .  855))
+      ((default . error) (RECORD .  1202))
+      ((default . error) (WHEN . (component_list . 1)) (FOR . (component_list 
. 1)) (IDENTIFIER . (component_list . 1)) (CASE . (component_list . 1)) (END . 
(component_list . 1)))
+      ((default . error) (WHEN . (component_list . 2)) (FOR . (component_list 
. 2)) (IDENTIFIER . (component_list . 2)) (CASE . (component_list . 2)) (END . 
(component_list . 2)))
+      ((default . error) (WHEN . (component_list . 4)) (FOR . (component_list 
. 4)) (IDENTIFIER . (component_list . 4)) (CASE . (component_list . 4)) (END . 
(component_list . 4)))
+      ((default . error) (IS . (direct_name . 0)))
+      ((default . error) (IS . (direct_name . 1)))
+      ((default . error) (IS .  1201))
+      ((default . error) (WITH . (and_interface_list_opt . 0)) (AND .  1198))
+      ((default . error) (SEMICOLON . (derived_type_definition . 1)) (DOT .  
84) (TICK .  85) (WITH . ((derived_type_definition . 1) (and_interface_list_opt 
. 0))) (AND .  1198) (LEFT_PAREN .  103))
+      ((default . error) (SEMICOLON .  1197))
+      ((default . error) (END . (full_type_declaration . 0)) (PRIVATE . 
(full_type_declaration . 0)) (USE . (full_type_declaration . 0)) (TYPE . 
(full_type_declaration . 0)) (TASK . (full_type_declaration . 0)) (SUBTYPE . 
(full_type_declaration . 0)) (PROTECTED . (full_type_declaration . 0)) 
(PROCEDURE . (full_type_declaration . 0)) (PRAGMA . (full_type_declaration . 
0)) (PACKAGE . (full_type_declaration . 0)) (OVERRIDING . 
(full_type_declaration . 0)) (NOT . (full_type_declaration . 0)) (GENERIC . 
(full_type_declaration . 0)) (FUNCTION . (full_type_declaration . 0)) (FOR . 
(full_type_declaration . 0)) (ENTRY . (full_type_declaration . 0)) (IDENTIFIER 
. (full_type_declaration . 0)) (BEGIN . (full_type_declaration . 0)))
+      ((default . error) (PRIVATE . (object_declaration . 3)) (END . 
(object_declaration . 3)) (BEGIN . (object_declaration . 3)) (IDENTIFIER . 
(object_declaration . 3)) (ENTRY . (object_declaration . 3)) (FOR . 
(object_declaration . 3)) (FUNCTION . (object_declaration . 3)) (GENERIC . 
(object_declaration . 3)) (NOT . (object_declaration . 3)) (OVERRIDING . 
(object_declaration . 3)) (PACKAGE . (object_declaration . 3)) (PRAGMA . 
(object_declaration . 3)) (PROCEDURE . (object_declaration . 3)) (PROTECTED . 
(object_declaration . 3)) (SUBTYPE . (object_declaration . 3)) (TASK . 
(object_declaration . 3)) (TYPE . (object_declaration . 3)) (USE . 
(object_declaration . 3)))
+      ((default . error) (SEMICOLON . (aspect_specification_opt . 0)) (WITH .  
104))
+      ((default . error) (PRIVATE . (object_declaration . 5)) (END . 
(object_declaration . 5)) (BEGIN . (object_declaration . 5)) (IDENTIFIER . 
(object_declaration . 5)) (ENTRY . (object_declaration . 5)) (FOR . 
(object_declaration . 5)) (FUNCTION . (object_declaration . 5)) (GENERIC . 
(object_declaration . 5)) (NOT . (object_declaration . 5)) (OVERRIDING . 
(object_declaration . 5)) (PACKAGE . (object_declaration . 5)) (PRAGMA . 
(object_declaration . 5)) (PROCEDURE . (object_declaration . 5)) (PROTECTED . 
(object_declaration . 5)) (SUBTYPE . (object_declaration . 5)) (TASK . 
(object_declaration . 5)) (TYPE . (object_declaration . 5)) (USE . 
(object_declaration . 5)))
+      ((default . error) (SEMICOLON . (aspect_specification_opt . 0)) (WITH .  
104))
+      ((default . error) (PRIVATE . (object_declaration . 1)) (END . 
(object_declaration . 1)) (BEGIN . (object_declaration . 1)) (IDENTIFIER . 
(object_declaration . 1)) (ENTRY . (object_declaration . 1)) (FOR . 
(object_declaration . 1)) (FUNCTION . (object_declaration . 1)) (GENERIC . 
(object_declaration . 1)) (NOT . (object_declaration . 1)) (OVERRIDING . 
(object_declaration . 1)) (PACKAGE . (object_declaration . 1)) (PRAGMA . 
(object_declaration . 1)) (PROCEDURE . (object_declaration . 1)) (PROTECTED . 
(object_declaration . 1)) (SUBTYPE . (object_declaration . 1)) (TASK . 
(object_declaration . 1)) (TYPE . (object_declaration . 1)) (USE . 
(object_declaration . 1)))
+      ((default . error) (SEMICOLON . (aspect_specification_opt . 0)) (WITH .  
104))
+      ((default . error) (SEMICOLON . (aspect_specification_opt . 0)) (WITH .  
104))
+      ((default . error) (END . (package_body . 0)) (BEGIN . (package_body . 
0)) (IDENTIFIER . (package_body . 0)) (ENTRY . (package_body . 0)) (FOR . 
(package_body . 0)) (PROTECTED . (package_body . 0)) (SUBTYPE . (package_body . 
0)) (TASK . (package_body . 0)) (TYPE . (package_body . 0)) (WITH . 
(package_body . 0)) (USE . (package_body . 0)) (SEPARATE . (package_body . 0)) 
(PROCEDURE . (package_body . 0)) (PRIVATE . (package_body . 0)) (PRAGMA . 
(package_body . 0)) (PACKAGE . (package_body . 0)) (OVERRIDING . (package_body 
. 0)) (NOT . (package_body . 0)) (LIMITED . (package_body . 0)) (GENERIC . 
(package_body . 0)) (FUNCTION . (package_body . 0)) ($EOI . (package_body . 0)))
+      ((default . error) (COMMA . (case_expression_alternative . 0)) 
(RIGHT_PAREN . (case_expression_alternative . 0)))
+      ((default . error) (IDENTIFIER .  45) (CHARACTER_LITERAL .  47) 
(STRING_LITERAL .  46))
+      ((default . error) (DOT .  84) (TICK .  85) (LOOP . 
(iterator_specification . 3)) (EQUAL_GREATER . (iterator_specification . 3)) 
(LEFT_PAREN .  103))
+      ((default . error) (PLUS .  136) (MINUS .  135) (ABS .  138) (NOT .  
141) (NULL .  142) (NEW .  140) (IDENTIFIER .  45) (CHARACTER_LITERAL .  47) 
(STRING_LITERAL .  46) (LEFT_PAREN .  139))
+      ((default . error) (RIGHT_PAREN . (if_expression . 0)))
+      ((default . error) (SEMICOLON . (identifier_opt . 0)) (IDENTIFIER .  
683))
+      ((default . error) (PROCEDURE . (protected_operation_item_list . 1)) 
(OVERRIDING . (protected_operation_item_list . 1)) (NOT . 
(protected_operation_item_list . 1)) (FUNCTION . (protected_operation_item_list 
. 1)) (FOR . (protected_operation_item_list . 1)) (ENTRY . 
(protected_operation_item_list . 1)) (END . (protected_operation_item_list . 
1)))
+      ((default . error) (WHEN . (parameter_profile_opt . 0)) (LEFT_PAREN .  
1187))
+      ((default . error) (END . (sequence_of_statements_opt . 0)) (EXCEPTION . 
(sequence_of_statements_opt . 0)) (ACCEPT . (label_opt . 0)) (BEGIN . 
(label_opt . 0)) (CASE . (label_opt . 0)) (DECLARE . (label_opt . 0)) (FOR . 
(label_opt . 0)) (IF . (label_opt . 0)) (LOOP . (label_opt . 0)) (RETURN . 
(label_opt . 0)) (SELECT . (label_opt . 0)) (WHILE . (label_opt . 0)) 
(STRING_LITERAL . (label_opt . 0)) (CHARACTER_LITERAL . (label_opt . 0)) (ABORT 
. (label_opt . 0)) (DELAY . (label_opt . 0)) (EXIT . (label_opt . 0)) (GOTO . 
(label_opt . 0)) (NULL . (label_opt . 0)) (PRAGMA . (label_opt . 0)) (RAISE . 
(label_opt . 0)) (REQUEUE . (label_opt . 0)) (LESS_LESS .  599) (IDENTIFIER . 
((label_opt . 0)  600)))
+      ((default . error) (THEN . (accept_statement . 1)) (WHEN . 
(accept_statement . 1)) (EXCEPTION . (accept_statement . 1)) (ELSIF . 
(accept_statement . 1)) (ELSE . (accept_statement . 1)) (OR . (accept_statement 
. 1)) (END . (accept_statement . 1)) (LESS_LESS . (accept_statement . 1)) 
(IDENTIFIER . (accept_statement . 1)) (STRING_LITERAL . (accept_statement . 1)) 
(CHARACTER_LITERAL . (accept_statement . 1)) (ACCEPT . (accept_statement . 1)) 
(ABORT . (accept_statement . 1)) (BEGIN . (accept_statement . 1)) (CASE . 
(accept_statement . 1)) (DECLARE . (accept_statement . 1)) (DELAY . 
(accept_statement . 1)) (EXIT . (accept_statement . 1)) (FOR . 
(accept_statement . 1)) (GOTO . (accept_statement . 1)) (IF . (accept_statement 
. 1)) (LOOP . (accept_statement . 1)) (NULL . (accept_statement . 1)) (PRAGMA . 
(accept_statement . 1)) (RAISE . (accept_statement . 1)) (REQUEUE . 
(accept_statement . 1)) (RETURN . (accept_statement . 1)) (SELECT . 
(accept_statement . 1)) (WHILE . (accept_statement . 1)))
+      ((default . error) (END . (sequence_of_statements_opt . 0)) (EXCEPTION . 
(sequence_of_statements_opt . 0)) (ACCEPT . (label_opt . 0)) (BEGIN . 
(label_opt . 0)) (CASE . (label_opt . 0)) (DECLARE . (label_opt . 0)) (FOR . 
(label_opt . 0)) (IF . (label_opt . 0)) (LOOP . (label_opt . 0)) (RETURN . 
(label_opt . 0)) (SELECT . (label_opt . 0)) (WHILE . (label_opt . 0)) 
(STRING_LITERAL . (label_opt . 0)) (CHARACTER_LITERAL . (label_opt . 0)) (ABORT 
. (label_opt . 0)) (DELAY . (label_opt . 0)) (EXIT . (label_opt . 0)) (GOTO . 
(label_opt . 0)) (NULL . (label_opt . 0)) (PRAGMA . (label_opt . 0)) (RAISE . 
(label_opt . 0)) (REQUEUE . (label_opt . 0)) (LESS_LESS .  599) (IDENTIFIER . 
((label_opt . 0)  600)))
+      ((default . error) (OR . (block_statement . 1)) (THEN . (block_statement 
. 1)) (WHEN . (block_statement . 1)) (EXCEPTION . (block_statement . 1)) (END . 
(block_statement . 1)) (LESS_LESS . (block_statement . 1)) (IDENTIFIER . 
(block_statement . 1)) (STRING_LITERAL . (block_statement . 1)) 
(CHARACTER_LITERAL . (block_statement . 1)) (ACCEPT . (block_statement . 1)) 
(ABORT . (block_statement . 1)) (BEGIN . (block_statement . 1)) (CASE . 
(block_statement . 1)) (DECLARE . (block_statement . 1)) (DELAY . 
(block_statement . 1)) (EXIT . (block_statement . 1)) (FOR . (block_statement . 
1)) (GOTO . (block_statement . 1)) (IF . (block_statement . 1)) (LOOP . 
(block_statement . 1)) (NULL . (block_statement . 1)) (PRAGMA . 
(block_statement . 1)) (RAISE . (block_statement . 1)) (REQUEUE . 
(block_statement . 1)) (RETURN . (block_statement . 1)) (SELECT . 
(block_statement . 1)) (WHILE . (block_statement . 1)) (ELSE . (block_statement 
. 1)) (ELSIF . (block_statement . 1)))
+      ((default . error) (CASE .  1184))
+      ((default . error) (WHEN . (case_statement_alternative_list . 1)) (END . 
(case_statement_alternative_list . 1)))
+      ((default . error) (BAR .  262) (EQUAL_GREATER .  1183))
+      ((default . error) (SEMICOLON . (identifier_opt . 0)) (IDENTIFIER .  
683))
+      ((default . error) (OR . (exit_statement . 0)) (THEN . (exit_statement . 
0)) (WHEN . (exit_statement . 0)) (EXCEPTION . (exit_statement . 0)) (END . 
(exit_statement . 0)) (LESS_LESS . (exit_statement . 0)) (IDENTIFIER . 
(exit_statement . 0)) (STRING_LITERAL . (exit_statement . 0)) 
(CHARACTER_LITERAL . (exit_statement . 0)) (ACCEPT . (exit_statement . 0)) 
(ABORT . (exit_statement . 0)) (BEGIN . (exit_statement . 0)) (CASE . 
(exit_statement . 0)) (DECLARE . (exit_statement . 0)) (DELAY . (exit_statement 
. 0)) (EXIT . (exit_statement . 0)) (FOR . (exit_statement . 0)) (GOTO . 
(exit_statement . 0)) (IF . (exit_statement . 0)) (LOOP . (exit_statement . 0)) 
(NULL . (exit_statement . 0)) (PRAGMA . (exit_statement . 0)) (RAISE . 
(exit_statement . 0)) (REQUEUE . (exit_statement . 0)) (RETURN . 
(exit_statement . 0)) (SELECT . (exit_statement . 0)) (WHILE . (exit_statement 
. 0)) (ELSE . (exit_statement . 0)) (ELSIF . (exit_statement . 0)))
+      ((default . error) (END . (sequence_of_statements_opt . 0)) (ACCEPT . 
(label_opt . 0)) (BEGIN . (label_opt . 0)) (CASE . (label_opt . 0)) (DECLARE . 
(label_opt . 0)) (FOR . (label_opt . 0)) (IF . (label_opt . 0)) (LOOP . 
(label_opt . 0)) (RETURN . (label_opt . 0)) (SELECT . (label_opt . 0)) (WHILE . 
(label_opt . 0)) (STRING_LITERAL . (label_opt . 0)) (CHARACTER_LITERAL . 
(label_opt . 0)) (ABORT . (label_opt . 0)) (DELAY . (label_opt . 0)) (EXIT . 
(label_opt . 0)) (GOTO . (label_opt . 0)) (NULL . (label_opt . 0)) (PRAGMA . 
(label_opt . 0)) (RAISE . (label_opt . 0)) (REQUEUE . (label_opt . 0)) 
(LESS_LESS .  599) (IDENTIFIER . ((label_opt . 0)  600)))
+      ((default . error) (THEN . (expression_opt . 0)) (PLUS .  136) (MINUS .  
135) (ABS .  138) (NOT .  141) (NULL .  142) (NEW .  140) (IDENTIFIER .  45) 
(CHARACTER_LITERAL .  47) (STRING_LITERAL .  46) (LEFT_PAREN .  139))
+      ((default . error) (IF .  1179))
+      ((default . error) (END . (elsif_statement_list . 0)) (ELSE . 
(elsif_statement_list . 0)) (ELSIF . (elsif_statement_list . 0)))
+      ((default . error) (END .  1177) (ELSE .  1176) (ELSIF .  1139))
+      ((default . error) (SEMICOLON .  1175))
+      ((default . error) (OR . (raise_statement . 1)) (THEN . (raise_statement 
. 1)) (WHEN . (raise_statement . 1)) (EXCEPTION . (raise_statement . 1)) (END . 
(raise_statement . 1)) (LESS_LESS . (raise_statement . 1)) (IDENTIFIER . 
(raise_statement . 1)) (STRING_LITERAL . (raise_statement . 1)) 
(CHARACTER_LITERAL . (raise_statement . 1)) (ACCEPT . (raise_statement . 1)) 
(ABORT . (raise_statement . 1)) (BEGIN . (raise_statement . 1)) (CASE . 
(raise_statement . 1)) (DECLARE . (raise_statement . 1)) (DELAY . 
(raise_statement . 1)) (EXIT . (raise_statement . 1)) (FOR . (raise_statement . 
1)) (GOTO . (raise_statement . 1)) (IF . (raise_statement . 1)) (LOOP . 
(raise_statement . 1)) (NULL . (raise_statement . 1)) (PRAGMA . 
(raise_statement . 1)) (RAISE . (raise_statement . 1)) (REQUEUE . 
(raise_statement . 1)) (RETURN . (raise_statement . 1)) (SELECT . 
(raise_statement . 1)) (WHILE . (raise_statement . 1)) (ELSE . (raise_statement 
. 1)) (ELSIF . (raise_statement . 1)))
+      ((default . error) (OR . (requeue_statement . 0)) (THEN . 
(requeue_statement . 0)) (WHEN . (requeue_statement . 0)) (EXCEPTION . 
(requeue_statement . 0)) (END . (requeue_statement . 0)) (LESS_LESS . 
(requeue_statement . 0)) (IDENTIFIER . (requeue_statement . 0)) (STRING_LITERAL 
. (requeue_statement . 0)) (CHARACTER_LITERAL . (requeue_statement . 0)) 
(ACCEPT . (requeue_statement . 0)) (ABORT . (requeue_statement . 0)) (BEGIN . 
(requeue_statement . 0)) (CASE . (requeue_statement . 0)) (DECLARE . 
(requeue_statement . 0)) (DELAY . (requeue_statement . 0)) (EXIT . 
(requeue_statement . 0)) (FOR . (requeue_statement . 0)) (GOTO . 
(requeue_statement . 0)) (IF . (requeue_statement . 0)) (LOOP . 
(requeue_statement . 0)) (NULL . (requeue_statement . 0)) (PRAGMA . 
(requeue_statement . 0)) (RAISE . (requeue_statement . 0)) (REQUEUE . 
(requeue_statement . 0)) (RETURN . (requeue_statement . 0)) (SELECT . 
(requeue_statement . 0)) (WHILE . (requeue_statement . 0)) (ELSE . 
(requeue_statement . 0)) (ELSIF . (requeue_statement . 0)))
+      ((default . error) (RETURN .  1174))
+      ((default . error) (IDENTIFIER .  45) (CHARACTER_LITERAL .  47) 
(STRING_LITERAL .  46) (ACCESS . (null_exclusion_opt . 0)) (NOT .  855))
+      ((default . error) (END .  1170))
+      ((default . error) (SELECT .  1169))
+      ((default . error) (OR . (selective_accept . 1)) (THEN . 
(selective_accept . 1)) (WHEN . (selective_accept . 1)) (EXCEPTION . 
(selective_accept . 1)) (END . (selective_accept . 1)) (LESS_LESS . 
(selective_accept . 1)) (IDENTIFIER . (selective_accept . 1)) (STRING_LITERAL . 
(selective_accept . 1)) (CHARACTER_LITERAL . (selective_accept . 1)) (ACCEPT . 
(selective_accept . 1)) (ABORT . (selective_accept . 1)) (BEGIN . 
(selective_accept . 1)) (CASE . (selective_accept . 1)) (DECLARE . 
(selective_accept . 1)) (DELAY . (selective_accept . 1)) (EXIT . 
(selective_accept . 1)) (FOR . (selective_accept . 1)) (GOTO . 
(selective_accept . 1)) (IF . (selective_accept . 1)) (LOOP . (selective_accept 
. 1)) (NULL . (selective_accept . 1)) (PRAGMA . (selective_accept . 1)) (RAISE 
. (selective_accept . 1)) (REQUEUE . (selective_accept . 1)) (RETURN . 
(selective_accept . 1)) (SELECT . (selective_accept . 1)) (WHILE . 
(selective_accept . 1)) (ELSE . (selective_accept . 1)) (ELSIF . 
(selective_accept . 1)))
+      ((default . error) (SELECT .  1168))
+      ((default . error) (END . (delay_alternative . 0)) (OR . 
(delay_alternative . 0)) (ELSE . (delay_alternative . 0)))
+      ((default . error) (SELECT .  1167))
+      ((default . error) (SEMICOLON .  1166))
+      ((default . error) (ELSE . (sequence_of_statements_opt . 0)) (OR . 
(sequence_of_statements_opt . 0)) (END . (sequence_of_statements_opt . 0)) 
(ACCEPT . (label_opt . 0)) (BEGIN . (label_opt . 0)) (CASE . (label_opt . 0)) 
(DECLARE . (label_opt . 0)) (FOR . (label_opt . 0)) (IF . (label_opt . 0)) 
(LOOP . (label_opt . 0)) (RETURN . (label_opt . 0)) (SELECT . (label_opt . 0)) 
(WHILE . (label_opt . 0)) (STRING_LITERAL . (label_opt . 0)) (CHARACTER_LITERAL 
. (label_opt . 0)) (ABORT . (label_opt . 0)) (DELAY . (label_opt . 0)) (EXIT . 
(label_opt . 0)) (GOTO . (label_opt . 0)) (NULL . (label_opt . 0)) (PRAGMA . 
(label_opt . 0)) (RAISE . (label_opt . 0)) (REQUEUE . (label_opt . 0)) 
(LESS_LESS .  599) (IDENTIFIER . ((label_opt . 0)  600)))
+      ((default . error) (END . (select_alternative . 2)) (OR . 
(select_alternative . 2)) (ELSE . (select_alternative . 2)))
+      ((default . error) (SEMICOLON . (identifier_opt . 0)) (IDENTIFIER .  
683))
+      ((default . error) (OTHERS .  926) (IDENTIFIER .  45) (CHARACTER_LITERAL 
.  47) (STRING_LITERAL .  46))
+      ((default . error) (WHEN . (sequence_of_statements_opt . 0)) (END . 
(sequence_of_statements_opt . 0)) (ACCEPT . (label_opt . 0)) (BEGIN . 
(label_opt . 0)) (CASE . (label_opt . 0)) (DECLARE . (label_opt . 0)) (FOR . 
(label_opt . 0)) (IF . (label_opt . 0)) (LOOP . (label_opt . 0)) (RETURN . 
(label_opt . 0)) (SELECT . (label_opt . 0)) (WHILE . (label_opt . 0)) 
(STRING_LITERAL . (label_opt . 0)) (CHARACTER_LITERAL . (label_opt . 0)) (ABORT 
. (label_opt . 0)) (DELAY . (label_opt . 0)) (EXIT . (label_opt . 0)) (GOTO . 
(label_opt . 0)) (NULL . (label_opt . 0)) (PRAGMA . (label_opt . 0)) (RAISE . 
(label_opt . 0)) (REQUEUE . (label_opt . 0)) (LESS_LESS .  599) (IDENTIFIER . 
((label_opt . 0)  600)))
+      ((default . error) (OTHERS .  926) (IDENTIFIER .  45) (CHARACTER_LITERAL 
.  47) (STRING_LITERAL .  46))
+      ((default . error) (BAR .  1158) (EQUAL_GREATER .  1268))
+      ((default . error) (WHEN . (exception_handler . 1)) (END . 
(exception_handler . 1)))
+      ((default . error) (EQUAL_GREATER . (exception_choice_list . 1)) (BAR . 
(exception_choice_list . 1)))
+      ((default . error) (SEMICOLON .  1267))
+      ((default . error) (ELSE . (select_alternative . 0)) (OR . 
(select_alternative . 0)) (END . (select_alternative . 0)))
+      ((default . error) (ELSE . (select_alternative . 4)) (OR . 
(select_alternative . 4)) (END . (select_alternative . 4)))
+      ((default . error) (SEMICOLON .  1266))
+      ((default . error) (SEMICOLON .  1265))
+      ((default . error) (SEMICOLON .  1264))
+      ((default . error) (SELECT .  1263))
+      ((default . error) (DO . (return_subtype_indication . 1)) (SEMICOLON . 
(return_subtype_indication . 1)) (COLON_EQUAL . (return_subtype_indication . 
1)))
+      ((default . error) (DO . (extended_return_object_declaration . 1)) 
(SEMICOLON . (extended_return_object_declaration . 1)) (COLON_EQUAL .  1262))
+      ((default . error) (DO . (return_subtype_indication . 0)) (SEMICOLON . 
(return_subtype_indication . 0)) (COLON_EQUAL . (return_subtype_indication . 
0)))
+      ((default . error) (SEMICOLON .  1261))
+      ((default . error) (WHEN . (loop_statement . 1)) (THEN . (loop_statement 
. 1)) (OR . (loop_statement . 1)) (ELSIF . (loop_statement . 1)) (ELSE . 
(loop_statement . 1)) (WHILE . (loop_statement . 1)) (SELECT . (loop_statement 
. 1)) (RETURN . (loop_statement . 1)) (REQUEUE . (loop_statement . 1)) (RAISE . 
(loop_statement . 1)) (PRAGMA . (loop_statement . 1)) (NULL . (loop_statement . 
1)) (LOOP . (loop_statement . 1)) (IF . (loop_statement . 1)) (GOTO . 
(loop_statement . 1)) (FOR . (loop_statement . 1)) (EXIT . (loop_statement . 
1)) (DELAY . (loop_statement . 1)) (DECLARE . (loop_statement . 1)) (CASE . 
(loop_statement . 1)) (BEGIN . (loop_statement . 1)) (ABORT . (loop_statement . 
1)) (ACCEPT . (loop_statement . 1)) (CHARACTER_LITERAL . (loop_statement . 1)) 
(STRING_LITERAL . (loop_statement . 1)) (IDENTIFIER . (loop_statement . 1)) 
(LESS_LESS . (loop_statement . 1)) (END . (loop_statement . 1)) (EXCEPTION . 
(loop_statement . 1)))
+      ((default . error) (END . (sequence_of_statements_opt . 0)) (ACCEPT . 
(label_opt . 0)) (BEGIN . (label_opt . 0)) (CASE . (label_opt . 0)) (DECLARE . 
(label_opt . 0)) (FOR . (label_opt . 0)) (IF . (label_opt . 0)) (LOOP . 
(label_opt . 0)) (RETURN . (label_opt . 0)) (SELECT . (label_opt . 0)) (WHILE . 
(label_opt . 0)) (STRING_LITERAL . (label_opt . 0)) (CHARACTER_LITERAL . 
(label_opt . 0)) (ABORT . (label_opt . 0)) (DELAY . (label_opt . 0)) (EXIT . 
(label_opt . 0)) (GOTO . (label_opt . 0)) (NULL . (label_opt . 0)) (PRAGMA . 
(label_opt . 0)) (RAISE . (label_opt . 0)) (REQUEUE . (label_opt . 0)) 
(LESS_LESS .  599) (IDENTIFIER . ((label_opt . 0)  600)))
+      ((default . error) (IF .  1259))
+      ((default . error) (ELSIF . (elsif_statement_list . 1)) (ELSE . 
(elsif_statement_list . 1)) (END . (elsif_statement_list . 1)))
+      ((default . error) (SEMICOLON .  1258))
+      ((default . error) (THEN .  1257))
+      ((default . error) (END .  1256))
+      ((default . error) (SEMICOLON .  1255))
+      ((default . error) (END . (sequence_of_statements_opt . 0)) (WHEN . 
(sequence_of_statements_opt . 0)) (ACCEPT . (label_opt . 0)) (BEGIN . 
(label_opt . 0)) (CASE . (label_opt . 0)) (DECLARE . (label_opt . 0)) (FOR . 
(label_opt . 0)) (IF . (label_opt . 0)) (LOOP . (label_opt . 0)) (RETURN . 
(label_opt . 0)) (SELECT . (label_opt . 0)) (WHILE . (label_opt . 0)) 
(STRING_LITERAL . (label_opt . 0)) (CHARACTER_LITERAL . (label_opt . 0)) (ABORT 
. (label_opt . 0)) (DELAY . (label_opt . 0)) (EXIT . (label_opt . 0)) (GOTO . 
(label_opt . 0)) (NULL . (label_opt . 0)) (PRAGMA . (label_opt . 0)) (RAISE . 
(label_opt . 0)) (REQUEUE . (label_opt . 0)) (LESS_LESS .  599) (IDENTIFIER . 
((label_opt . 0)  600)))
+      ((default . error) (SEMICOLON .  1253))
+      ((default . error) (END .  1252))
+      ((default . error) (END .  1251))
+      ((default . error) (FOR .  1250) (IDENTIFIER .  69))
+      ((default . error) (WHEN .  1249))
+      ((default . error) (WHEN . (entry_body_formal_part . 1)))
+      ((default . error) (SEMICOLON .  1248))
+      ((default . error) (ELSE . (elsif_expression_item . 0)) (ELSIF . 
(elsif_expression_item . 0)) (RIGHT_PAREN . (elsif_expression_item . 0)))
+      ((default . error) (DOT .  84) (TICK .  85) (LOOP . 
(iterator_specification . 2)) (EQUAL_GREATER . (iterator_specification . 2)) 
(LEFT_PAREN .  103))
+      ((default . error) (SEMICOLON .  1247))
+      ((default . error) (SEMICOLON .  1246))
+      ((default . error) (SEMICOLON .  1245))
+      ((default . error) (SEMICOLON .  1244))
+      ((default . error) (BEGIN . (private_type_declaration . 0)) (IDENTIFIER 
. (private_type_declaration . 0)) (ENTRY . (private_type_declaration . 0)) (FOR 
. (private_type_declaration . 0)) (FUNCTION . (private_type_declaration . 0)) 
(GENERIC . (private_type_declaration . 0)) (NOT . (private_type_declaration . 
0)) (OVERRIDING . (private_type_declaration . 0)) (PACKAGE . 
(private_type_declaration . 0)) (PRAGMA . (private_type_declaration . 0)) 
(PROCEDURE . (private_type_declaration . 0)) (PROTECTED . 
(private_type_declaration . 0)) (SUBTYPE . (private_type_declaration . 0)) 
(TASK . (private_type_declaration . 0)) (TYPE . (private_type_declaration . 0)) 
(USE . (private_type_declaration . 0)) (PRIVATE . (private_type_declaration . 
0)) (END . (private_type_declaration . 0)))
+      ((default . error) (IDENTIFIER .  45) (CHARACTER_LITERAL .  47) 
(STRING_LITERAL .  46))
+      ((default . error) (WITH .  1242))
+      ((default . error) (WITH .  1241))
+      ((default . error) (WHEN .  1238))
+      ((default . error) (SEMICOLON . (record_definition . 0)) (WITH . 
(record_definition . 0)))
+      ((default . error) (COLON_EQUAL .  1236) (SEMICOLON . 
(aspect_specification_opt . 0)) (WITH .  104))
+      ((default . error) (SEMICOLON . (type_definition . 1)) (WITH . 
(type_definition . 1)))
+      ((default . error) (RIGHT_PAREN . (enumeration_literal_list . 1)) (COMMA 
. (enumeration_literal_list . 1)))
+      ((default . error) (DOT_DOT .  1235))
+      ((default . error) (WITH . (real_range_specification_opt . 0)) 
(SEMICOLON . (real_range_specification_opt . 0)) (RANGE .  1095))
+      ((default . error) (SEMICOLON . (identifier_opt . 0)) (IDENTIFIER .  
683))
+      ((default . error) (SEMICOLON .  1232))
+      ((default . error) (USE . (task_type_declaration . 1)) (TYPE . 
(task_type_declaration . 1)) (TASK . (task_type_declaration . 1)) (SUBTYPE . 
(task_type_declaration . 1)) (PROTECTED . (task_type_declaration . 1)) 
(PROCEDURE . (task_type_declaration . 1)) (PRAGMA . (task_type_declaration . 
1)) (PACKAGE . (task_type_declaration . 1)) (OVERRIDING . 
(task_type_declaration . 1)) (NOT . (task_type_declaration . 1)) (GENERIC . 
(task_type_declaration . 1)) (FUNCTION . (task_type_declaration . 1)) (FOR . 
(task_type_declaration . 1)) (ENTRY . (task_type_declaration . 1)) (IDENTIFIER 
. (task_type_declaration . 1)) (BEGIN . (task_type_declaration . 1)) (END . 
(task_type_declaration . 1)) (PRIVATE . (task_type_declaration . 1)))
+      ((default . error) (AND .  1054) (WITH .  1231))
+      ((default . error) (SEMICOLON . (identifier_opt . 0)) (IDENTIFIER .  
683))
+      ((default . error) (SEMICOLON .  1229))
+      ((default . error) (USE . (protected_type_declaration . 1)) (TYPE . 
(protected_type_declaration . 1)) (TASK . (protected_type_declaration . 1)) 
(SUBTYPE . (protected_type_declaration . 1)) (PROTECTED . 
(protected_type_declaration . 1)) (PROCEDURE . (protected_type_declaration . 
1)) (PRAGMA . (protected_type_declaration . 1)) (PACKAGE . 
(protected_type_declaration . 1)) (OVERRIDING . (protected_type_declaration . 
1)) (NOT . (protected_type_declaration . 1)) (GENERIC . 
(protected_type_declaration . 1)) (FUNCTION . (protected_type_declaration . 1)) 
(FOR . (protected_type_declaration . 1)) (ENTRY . (protected_type_declaration . 
1)) (IDENTIFIER . (protected_type_declaration . 1)) (BEGIN . 
(protected_type_declaration . 1)) (END . (protected_type_declaration . 1)) 
(PRIVATE . (protected_type_declaration . 1)))
+      ((default . error) (AND .  1054) (WITH .  1228))
+      ((default . error) (RANGE .  1227))
+      ((default . error) (SEMICOLON . (record_rep . 0)))
+      ((default . error) (IDENTIFIER . (mod_clause_opt . 1)))
+      ((default . error) (BEGIN . (object_renaming_declaration . 0)) 
(IDENTIFIER . (object_renaming_declaration . 0)) (ENTRY . 
(object_renaming_declaration . 0)) (FOR . (object_renaming_declaration . 0)) 
(FUNCTION . (object_renaming_declaration . 0)) (GENERIC . 
(object_renaming_declaration . 0)) (NOT . (object_renaming_declaration . 0)) 
(OVERRIDING . (object_renaming_declaration . 0)) (PACKAGE . 
(object_renaming_declaration . 0)) (PRAGMA . (object_renaming_declaration . 0)) 
(PROCEDURE . (object_renaming_declaration . 0)) (PROTECTED . 
(object_renaming_declaration . 0)) (SUBTYPE . (object_renaming_declaration . 
0)) (TASK . (object_renaming_declaration . 0)) (TYPE . 
(object_renaming_declaration . 0)) (USE . (object_renaming_declaration . 0)) 
(PRIVATE . (object_renaming_declaration . 0)) (END . 
(object_renaming_declaration . 0)))
+      ((default . error) (PRIVATE .  1226))
+      ((default . error) (PRIVATE .  1225))
+      ((default . error) (COLON_EQUAL . (component_definition . 2)) (SEMICOLON 
. (component_definition . 2)) (WITH . (component_definition . 2)))
+      ((default . error) (COLON_EQUAL . (component_definition . 0)) (SEMICOLON 
. (component_definition . 0)) (WITH . (component_definition . 0)))
+      ((default . error) (RIGHT_PAREN . (subtype_indication . 1)) (COMMA . 
(subtype_indication . 1)) (DOT .  84) (TICK .  85) (BAR . (discrete_choice . 
1)) (EQUAL_GREATER . (discrete_choice . 1)) (RANGE .  825) (LEFT_PAREN .  792))
+      ((default . error) (WITH . (formal_derived_type_definition . 0)) 
(SEMICOLON . (formal_derived_type_definition . 0)))
+      ((default . error) (WITH . (formal_derived_type_definition . 1)) 
(SEMICOLON . (formal_derived_type_definition . 1)))
+      ((default . error) (PLUS .  136) (MINUS .  135) (ABS .  138) (NOT .  
141) (NULL .  142) (NEW .  140) (IDENTIFIER .  45) (CHARACTER_LITERAL .  47) 
(STRING_LITERAL .  46) (LEFT_PAREN .  139))
+      ((default . error) (END . (declarative_part_opt . 0)) (PRIVATE . 
(declarative_part_opt . 0)) (USE .  11) (SUBTYPE .  282) (PRAGMA .  7) (NOT .  
4) (OVERRIDING .  5) (FUNCTION . (overriding_indicator_opt . 2)) (PROCEDURE . 
(overriding_indicator_opt . 2)) (ENTRY . (overriding_indicator_opt . 2)) (FOR . 
 279) (IDENTIFIER .  278) (TYPE .  284) (GENERIC .  2) (PROTECTED .  281) (TASK 
.  283) (PACKAGE .  280))
+      ((default . error) (END . (single_protected_declaration . 0)) (PRIVATE . 
(single_protected_declaration . 0)) (USE . (single_protected_declaration . 0)) 
(TYPE . (single_protected_declaration . 0)) (TASK . 
(single_protected_declaration . 0)) (SUBTYPE . (single_protected_declaration . 
0)) (PROTECTED . (single_protected_declaration . 0)) (PROCEDURE . 
(single_protected_declaration . 0)) (PRAGMA . (single_protected_declaration . 
0)) (PACKAGE . (single_protected_declaration . 0)) (OVERRIDING . 
(single_protected_declaration . 0)) (NOT . (single_protected_declaration . 0)) 
(GENERIC . (single_protected_declaration . 0)) (FUNCTION . 
(single_protected_declaration . 0)) (FOR . (single_protected_declaration . 0)) 
(ENTRY . (single_protected_declaration . 0)) (IDENTIFIER . 
(single_protected_declaration . 0)) (BEGIN . (single_protected_declaration . 
0)))
+      ((default . error) (SEMICOLON . (protected_definition . 0)))
+      ((default . error) (END . (declarative_part_opt . 0)) (PRIVATE . 
(declarative_part_opt . 0)) (USE .  11) (SUBTYPE .  282) (PRAGMA .  7) (NOT .  
4) (OVERRIDING .  5) (FUNCTION . (overriding_indicator_opt . 2)) (PROCEDURE . 
(overriding_indicator_opt . 2)) (ENTRY . (overriding_indicator_opt . 2)) (FOR . 
 279) (IDENTIFIER .  278) (TYPE .  284) (GENERIC .  2) (PROTECTED .  281) (TASK 
.  283) (PACKAGE .  280))
+      ((default . error) (END . (single_task_declaration . 0)) (PRIVATE . 
(single_task_declaration . 0)) (USE . (single_task_declaration . 0)) (TYPE . 
(single_task_declaration . 0)) (TASK . (single_task_declaration . 0)) (SUBTYPE 
. (single_task_declaration . 0)) (PROTECTED . (single_task_declaration . 0)) 
(PROCEDURE . (single_task_declaration . 0)) (PRAGMA . (single_task_declaration 
. 0)) (PACKAGE . (single_task_declaration . 0)) (OVERRIDING . 
(single_task_declaration . 0)) (NOT . (single_task_declaration . 0)) (GENERIC . 
(single_task_declaration . 0)) (FUNCTION . (single_task_declaration . 0)) (FOR 
. (single_task_declaration . 0)) (ENTRY . (single_task_declaration . 0)) 
(IDENTIFIER . (single_task_declaration . 0)) (BEGIN . (single_task_declaration 
. 0)))
+      ((default . error) (SEMICOLON . (task_definition . 0)))
+      ((default . error) (WITH . (type_definition . 5)) (SEMICOLON . 
(type_definition . 5)))
+      ((default . error) (PLUS .  136) (MINUS .  135) (ABS .  138) (NOT .  
141) (NULL .  142) (NEW .  140) (IDENTIFIER .  45) (CHARACTER_LITERAL .  47) 
(STRING_LITERAL .  46) (LEFT_PAREN .  139))
+      ((default . error) (PLUS .  136) (MINUS .  135) (ABS .  138) (NOT .  
141) (NULL .  142) (NEW .  140) (IDENTIFIER .  45) (CHARACTER_LITERAL .  47) 
(STRING_LITERAL .  46) (LEFT_PAREN .  139))
+      ((default . error) (SEMICOLON .  1285))
+      ((default . error) (EQUAL_GREATER . (discrete_choice_list . 0)) (BAR . 
(discrete_choice_list . 0)) (OTHERS .  165) (IDENTIFIER .  45) 
(CHARACTER_LITERAL .  47) (STRING_LITERAL .  46) (PLUS .  136) (MINUS .  135) 
(ABS .  138) (NOT .  164) (NULL .  142) (NEW .  140) (LEFT_PAREN .  139))
+      ((default . error) (END .  1282) (WHEN .  1238))
+      ((default . error) (END . (variant_list . 0)) (WHEN . (variant_list . 
0)))
+      ((default . error) (PRIVATE .  1281))
+      ((default . error) (RECORD .  840) (NULL .  838))
+      ((default . error) (AND .  1054) (WITH . (and_interface_list_opt . 1)))
+      ((default . error) (PRIVATE . (object_declaration . 2)) (END . 
(object_declaration . 2)) (BEGIN . (object_declaration . 2)) (IDENTIFIER . 
(object_declaration . 2)) (ENTRY . (object_declaration . 2)) (FOR . 
(object_declaration . 2)) (FUNCTION . (object_declaration . 2)) (GENERIC . 
(object_declaration . 2)) (NOT . (object_declaration . 2)) (OVERRIDING . 
(object_declaration . 2)) (PACKAGE . (object_declaration . 2)) (PRAGMA . 
(object_declaration . 2)) (PROCEDURE . (object_declaration . 2)) (PROTECTED . 
(object_declaration . 2)) (SUBTYPE . (object_declaration . 2)) (TASK . 
(object_declaration . 2)) (TYPE . (object_declaration . 2)) (USE . 
(object_declaration . 2)))
+      ((default . error) (PRIVATE . (object_declaration . 4)) (END . 
(object_declaration . 4)) (BEGIN . (object_declaration . 4)) (IDENTIFIER . 
(object_declaration . 4)) (ENTRY . (object_declaration . 4)) (FOR . 
(object_declaration . 4)) (FUNCTION . (object_declaration . 4)) (GENERIC . 
(object_declaration . 4)) (NOT . (object_declaration . 4)) (OVERRIDING . 
(object_declaration . 4)) (PACKAGE . (object_declaration . 4)) (PRAGMA . 
(object_declaration . 4)) (PROCEDURE . (object_declaration . 4)) (PROTECTED . 
(object_declaration . 4)) (SUBTYPE . (object_declaration . 4)) (TASK . 
(object_declaration . 4)) (TYPE . (object_declaration . 4)) (USE . 
(object_declaration . 4)))
+      ((default . error) (PRIVATE . (object_declaration . 0)) (END . 
(object_declaration . 0)) (BEGIN . (object_declaration . 0)) (IDENTIFIER . 
(object_declaration . 0)) (ENTRY . (object_declaration . 0)) (FOR . 
(object_declaration . 0)) (FUNCTION . (object_declaration . 0)) (GENERIC . 
(object_declaration . 0)) (NOT . (object_declaration . 0)) (OVERRIDING . 
(object_declaration . 0)) (PACKAGE . (object_declaration . 0)) (PRAGMA . 
(object_declaration . 0)) (PROCEDURE . (object_declaration . 0)) (PROTECTED . 
(object_declaration . 0)) (SUBTYPE . (object_declaration . 0)) (TASK . 
(object_declaration . 0)) (TYPE . (object_declaration . 0)) (USE . 
(object_declaration . 0)))
+      ((default . error) (PRIVATE . (entry_declaration . 0)) (END . 
(entry_declaration . 0)) (BEGIN . (entry_declaration . 0)) (IDENTIFIER . 
(entry_declaration . 0)) (ENTRY . (entry_declaration . 0)) (FOR . 
(entry_declaration . 0)) (FUNCTION . (entry_declaration . 0)) (GENERIC . 
(entry_declaration . 0)) (NOT . (entry_declaration . 0)) (OVERRIDING . 
(entry_declaration . 0)) (PACKAGE . (entry_declaration . 0)) (PRAGMA . 
(entry_declaration . 0)) (PROCEDURE . (entry_declaration . 0)) (PROTECTED . 
(entry_declaration . 0)) (SUBTYPE . (entry_declaration . 0)) (TASK . 
(entry_declaration . 0)) (TYPE . (entry_declaration . 0)) (USE . 
(entry_declaration . 0)))
+      ((default . error) (PRIVATE . (protected_body . 0)) (END . 
(protected_body . 0)) (BEGIN . (protected_body . 0)) (IDENTIFIER . 
(protected_body . 0)) (ENTRY . (protected_body . 0)) (FOR . (protected_body . 
0)) (FUNCTION . (protected_body . 0)) (GENERIC . (protected_body . 0)) (NOT . 
(protected_body . 0)) (OVERRIDING . (protected_body . 0)) (PACKAGE . 
(protected_body . 0)) (PRAGMA . (protected_body . 0)) (PROCEDURE . 
(protected_body . 0)) (PROTECTED . (protected_body . 0)) (SUBTYPE . 
(protected_body . 0)) (TASK . (protected_body . 0)) (TYPE . (protected_body . 
0)) (USE . (protected_body . 0)) ($EOI . (protected_body . 0)) (LIMITED . 
(protected_body . 0)) (SEPARATE . (protected_body . 0)) (WITH . (protected_body 
. 0)))
+      ((default . error) (IS . (expression_opt . 0)) (PLUS .  136) (MINUS .  
135) (ABS .  138) (NOT .  141) (NULL .  142) (NEW .  140) (IDENTIFIER .  45) 
(CHARACTER_LITERAL .  47) (STRING_LITERAL .  46) (LEFT_PAREN .  139))
+      ((default . error) (IDENTIFIER .  1278))
+      ((default . error) (SEMICOLON . (identifier_opt . 0)) (IDENTIFIER .  
683))
+      ((default . error) (SEMICOLON . (identifier_opt . 0)) (IDENTIFIER .  
683))
+      ((default . error) (OR . (case_statement . 0)) (THEN . (case_statement . 
0)) (WHEN . (case_statement . 0)) (EXCEPTION . (case_statement . 0)) (END . 
(case_statement . 0)) (LESS_LESS . (case_statement . 0)) (IDENTIFIER . 
(case_statement . 0)) (STRING_LITERAL . (case_statement . 0)) 
(CHARACTER_LITERAL . (case_statement . 0)) (ACCEPT . (case_statement . 0)) 
(ABORT . (case_statement . 0)) (BEGIN . (case_statement . 0)) (CASE . 
(case_statement . 0)) (DECLARE . (case_statement . 0)) (DELAY . (case_statement 
. 0)) (EXIT . (case_statement . 0)) (FOR . (case_statement . 0)) (GOTO . 
(case_statement . 0)) (IF . (case_statement . 0)) (LOOP . (case_statement . 0)) 
(NULL . (case_statement . 0)) (PRAGMA . (case_statement . 0)) (RAISE . 
(case_statement . 0)) (REQUEUE . (case_statement . 0)) (RETURN . 
(case_statement . 0)) (SELECT . (case_statement . 0)) (WHILE . (case_statement 
. 0)) (ELSE . (case_statement . 0)) (ELSIF . (case_statement . 0)))
+      ((default . error) (END . (case_statement_alternative . 0)) (WHEN . 
(case_statement_alternative . 0)))
+      ((default . error) (OR . (block_statement . 0)) (THEN . (block_statement 
. 0)) (WHEN . (block_statement . 0)) (EXCEPTION . (block_statement . 0)) (END . 
(block_statement . 0)) (LESS_LESS . (block_statement . 0)) (IDENTIFIER . 
(block_statement . 0)) (STRING_LITERAL . (block_statement . 0)) 
(CHARACTER_LITERAL . (block_statement . 0)) (ACCEPT . (block_statement . 0)) 
(ABORT . (block_statement . 0)) (BEGIN . (block_statement . 0)) (CASE . 
(block_statement . 0)) (DECLARE . (block_statement . 0)) (DELAY . 
(block_statement . 0)) (EXIT . (block_statement . 0)) (FOR . (block_statement . 
0)) (GOTO . (block_statement . 0)) (IF . (block_statement . 0)) (LOOP . 
(block_statement . 0)) (NULL . (block_statement . 0)) (PRAGMA . 
(block_statement . 0)) (RAISE . (block_statement . 0)) (REQUEUE . 
(block_statement . 0)) (RETURN . (block_statement . 0)) (SELECT . 
(block_statement . 0)) (WHILE . (block_statement . 0)) (ELSE . (block_statement 
. 0)) (ELSIF . (block_statement . 0)))
+      ((default . error) (IF .  1275))
+      ((default . error) (ELSE . (sequence_of_statements_opt . 0)) (ELSIF . 
(sequence_of_statements_opt . 0)) (END . (sequence_of_statements_opt . 0)) 
(ACCEPT . (label_opt . 0)) (BEGIN . (label_opt . 0)) (CASE . (label_opt . 0)) 
(DECLARE . (label_opt . 0)) (FOR . (label_opt . 0)) (IF . (label_opt . 0)) 
(LOOP . (label_opt . 0)) (RETURN . (label_opt . 0)) (SELECT . (label_opt . 0)) 
(WHILE . (label_opt . 0)) (STRING_LITERAL . (label_opt . 0)) (CHARACTER_LITERAL 
. (label_opt . 0)) (ABORT . (label_opt . 0)) (DELAY . (label_opt . 0)) (EXIT . 
(label_opt . 0)) (GOTO . (label_opt . 0)) (NULL . (label_opt . 0)) (PRAGMA . 
(label_opt . 0)) (RAISE . (label_opt . 0)) (REQUEUE . (label_opt . 0)) 
(LESS_LESS .  599) (IDENTIFIER . ((label_opt . 0)  600)))
+      ((default . error) (OR . (if_statement . 3)) (THEN . (if_statement . 3)) 
(WHEN . (if_statement . 3)) (EXCEPTION . (if_statement . 3)) (END . 
(if_statement . 3)) (LESS_LESS . (if_statement . 3)) (IDENTIFIER . 
(if_statement . 3)) (STRING_LITERAL . (if_statement . 3)) (CHARACTER_LITERAL . 
(if_statement . 3)) (ACCEPT . (if_statement . 3)) (ABORT . (if_statement . 3)) 
(BEGIN . (if_statement . 3)) (CASE . (if_statement . 3)) (DECLARE . 
(if_statement . 3)) (DELAY . (if_statement . 3)) (EXIT . (if_statement . 3)) 
(FOR . (if_statement . 3)) (GOTO . (if_statement . 3)) (IF . (if_statement . 
3)) (LOOP . (if_statement . 3)) (NULL . (if_statement . 3)) (PRAGMA . 
(if_statement . 3)) (RAISE . (if_statement . 3)) (REQUEUE . (if_statement . 3)) 
(RETURN . (if_statement . 3)) (SELECT . (if_statement . 3)) (WHILE . 
(if_statement . 3)) (ELSE . (if_statement . 3)) (ELSIF . (if_statement . 3)))
+      ((default . error) (SEMICOLON .  1273))
+      ((default . error) (END .  1272))
+      ((default . error) (OR . (extended_return_statement . 0)) (THEN . 
(extended_return_statement . 0)) (WHEN . (extended_return_statement . 0)) 
(EXCEPTION . (extended_return_statement . 0)) (END . (extended_return_statement 
. 0)) (LESS_LESS . (extended_return_statement . 0)) (IDENTIFIER . 
(extended_return_statement . 0)) (STRING_LITERAL . (extended_return_statement . 
0)) (CHARACTER_LITERAL . (extended_return_statement . 0)) (ACCEPT . 
(extended_return_statement . 0)) (ABORT . (extended_return_statement . 0)) 
(BEGIN . (extended_return_statement . 0)) (CASE . (extended_return_statement . 
0)) (DECLARE . (extended_return_statement . 0)) (DELAY . 
(extended_return_statement . 0)) (EXIT . (extended_return_statement . 0)) (FOR 
. (extended_return_statement . 0)) (GOTO . (extended_return_statement . 0)) (IF 
. (extended_return_statement . 0)) (LOOP . (extended_return_statement . 0)) 
(NULL . (extended_return_statement . 0)) (PRAGMA . (extended_return_statement . 
0)) (RAISE . (extended_return_statement . 0)) (REQUEUE . 
(extended_return_statement . 0)) (RETURN . (extended_return_statement . 0)) 
(SELECT . (extended_return_statement . 0)) (WHILE . (extended_return_statement 
. 0)) (ELSE . (extended_return_statement . 0)) (ELSIF . 
(extended_return_statement . 0)))
+      ((default . error) (PLUS .  136) (MINUS .  135) (ABS .  138) (NOT .  
141) (NULL .  142) (NEW .  140) (IDENTIFIER .  45) (CHARACTER_LITERAL .  47) 
(STRING_LITERAL .  46) (LEFT_PAREN .  139))
+      ((default . error) (SEMICOLON .  1270))
+      ((default . error) (OR . (selective_accept . 0)) (THEN . 
(selective_accept . 0)) (WHEN . (selective_accept . 0)) (EXCEPTION . 
(selective_accept . 0)) (END . (selective_accept . 0)) (LESS_LESS . 
(selective_accept . 0)) (IDENTIFIER . (selective_accept . 0)) (STRING_LITERAL . 
(selective_accept . 0)) (CHARACTER_LITERAL . (selective_accept . 0)) (ACCEPT . 
(selective_accept . 0)) (ABORT . (selective_accept . 0)) (BEGIN . 
(selective_accept . 0)) (CASE . (selective_accept . 0)) (DECLARE . 
(selective_accept . 0)) (DELAY . (selective_accept . 0)) (EXIT . 
(selective_accept . 0)) (FOR . (selective_accept . 0)) (GOTO . 
(selective_accept . 0)) (IF . (selective_accept . 0)) (LOOP . (selective_accept 
. 0)) (NULL . (selective_accept . 0)) (PRAGMA . (selective_accept . 0)) (RAISE 
. (selective_accept . 0)) (REQUEUE . (selective_accept . 0)) (RETURN . 
(selective_accept . 0)) (SELECT . (selective_accept . 0)) (WHILE . 
(selective_accept . 0)) (ELSE . (selective_accept . 0)) (ELSIF . 
(selective_accept . 0)))
+      ((default . error) (OR . (conditional_entry_call . 0)) (THEN . 
(conditional_entry_call . 0)) (WHEN . (conditional_entry_call . 0)) (EXCEPTION 
. (conditional_entry_call . 0)) (END . (conditional_entry_call . 0)) (LESS_LESS 
. (conditional_entry_call . 0)) (IDENTIFIER . (conditional_entry_call . 0)) 
(STRING_LITERAL . (conditional_entry_call . 0)) (CHARACTER_LITERAL . 
(conditional_entry_call . 0)) (ACCEPT . (conditional_entry_call . 0)) (ABORT . 
(conditional_entry_call . 0)) (BEGIN . (conditional_entry_call . 0)) (CASE . 
(conditional_entry_call . 0)) (DECLARE . (conditional_entry_call . 0)) (DELAY . 
(conditional_entry_call . 0)) (EXIT . (conditional_entry_call . 0)) (FOR . 
(conditional_entry_call . 0)) (GOTO . (conditional_entry_call . 0)) (IF . 
(conditional_entry_call . 0)) (LOOP . (conditional_entry_call . 0)) (NULL . 
(conditional_entry_call . 0)) (PRAGMA . (conditional_entry_call . 0)) (RAISE . 
(conditional_entry_call . 0)) (REQUEUE . (conditional_entry_call . 0)) (RETURN 
. (conditional_entry_call . 0)) (SELECT . (conditional_entry_call . 0)) (WHILE 
. (conditional_entry_call . 0)) (ELSE . (conditional_entry_call . 0)) (ELSIF . 
(conditional_entry_call . 0)))
+      ((default . error) (OR . (timed_entry_call . 0)) (THEN . 
(timed_entry_call . 0)) (WHEN . (timed_entry_call . 0)) (EXCEPTION . 
(timed_entry_call . 0)) (END . (timed_entry_call . 0)) (LESS_LESS . 
(timed_entry_call . 0)) (IDENTIFIER . (timed_entry_call . 0)) (STRING_LITERAL . 
(timed_entry_call . 0)) (CHARACTER_LITERAL . (timed_entry_call . 0)) (ACCEPT . 
(timed_entry_call . 0)) (ABORT . (timed_entry_call . 0)) (BEGIN . 
(timed_entry_call . 0)) (CASE . (timed_entry_call . 0)) (DECLARE . 
(timed_entry_call . 0)) (DELAY . (timed_entry_call . 0)) (EXIT . 
(timed_entry_call . 0)) (FOR . (timed_entry_call . 0)) (GOTO . 
(timed_entry_call . 0)) (IF . (timed_entry_call . 0)) (LOOP . (timed_entry_call 
. 0)) (NULL . (timed_entry_call . 0)) (PRAGMA . (timed_entry_call . 0)) (RAISE 
. (timed_entry_call . 0)) (REQUEUE . (timed_entry_call . 0)) (RETURN . 
(timed_entry_call . 0)) (SELECT . (timed_entry_call . 0)) (WHILE . 
(timed_entry_call . 0)) (ELSE . (timed_entry_call . 0)) (ELSIF . 
(timed_entry_call . 0)))
+      ((default . error) (OR . (loop_statement . 0)) (THEN . (loop_statement . 
0)) (WHEN . (loop_statement . 0)) (EXCEPTION . (loop_statement . 0)) (END . 
(loop_statement . 0)) (LESS_LESS . (loop_statement . 0)) (IDENTIFIER . 
(loop_statement . 0)) (STRING_LITERAL . (loop_statement . 0)) 
(CHARACTER_LITERAL . (loop_statement . 0)) (ACCEPT . (loop_statement . 0)) 
(ABORT . (loop_statement . 0)) (BEGIN . (loop_statement . 0)) (CASE . 
(loop_statement . 0)) (DECLARE . (loop_statement . 0)) (DELAY . (loop_statement 
. 0)) (EXIT . (loop_statement . 0)) (FOR . (loop_statement . 0)) (GOTO . 
(loop_statement . 0)) (IF . (loop_statement . 0)) (LOOP . (loop_statement . 0)) 
(NULL . (loop_statement . 0)) (PRAGMA . (loop_statement . 0)) (RAISE . 
(loop_statement . 0)) (REQUEUE . (loop_statement . 0)) (RETURN . 
(loop_statement . 0)) (SELECT . (loop_statement . 0)) (WHILE . (loop_statement 
. 0)) (ELSE . (loop_statement . 0)) (ELSIF . (loop_statement . 0)))
+      ((default . error) (WHEN . (sequence_of_statements_opt . 0)) (END . 
(sequence_of_statements_opt . 0)) (ACCEPT . (label_opt . 0)) (BEGIN . 
(label_opt . 0)) (CASE . (label_opt . 0)) (DECLARE . (label_opt . 0)) (FOR . 
(label_opt . 0)) (IF . (label_opt . 0)) (LOOP . (label_opt . 0)) (RETURN . 
(label_opt . 0)) (SELECT . (label_opt . 0)) (WHILE . (label_opt . 0)) 
(STRING_LITERAL . (label_opt . 0)) (CHARACTER_LITERAL . (label_opt . 0)) (ABORT 
. (label_opt . 0)) (DELAY . (label_opt . 0)) (EXIT . (label_opt . 0)) (GOTO . 
(label_opt . 0)) (NULL . (label_opt . 0)) (PRAGMA . (label_opt . 0)) (RAISE . 
(label_opt . 0)) (REQUEUE . (label_opt . 0)) (LESS_LESS .  599) (IDENTIFIER . 
((label_opt . 0)  600)))
+      ((default . error) (WHEN . (exception_handler . 0)) (END . 
(exception_handler . 0)))
+      ((default . error) (WHEN . (asynchronous_select . 0)) (THEN . 
(asynchronous_select . 0)) (OR . (asynchronous_select . 0)) (ELSIF . 
(asynchronous_select . 0)) (ELSE . (asynchronous_select . 0)) (WHILE . 
(asynchronous_select . 0)) (SELECT . (asynchronous_select . 0)) (RETURN . 
(asynchronous_select . 0)) (REQUEUE . (asynchronous_select . 0)) (RAISE . 
(asynchronous_select . 0)) (PRAGMA . (asynchronous_select . 0)) (NULL . 
(asynchronous_select . 0)) (LOOP . (asynchronous_select . 0)) (IF . 
(asynchronous_select . 0)) (GOTO . (asynchronous_select . 0)) (FOR . 
(asynchronous_select . 0)) (EXIT . (asynchronous_select . 0)) (DELAY . 
(asynchronous_select . 0)) (DECLARE . (asynchronous_select . 0)) (CASE . 
(asynchronous_select . 0)) (BEGIN . (asynchronous_select . 0)) (ABORT . 
(asynchronous_select . 0)) (ACCEPT . (asynchronous_select . 0)) 
(CHARACTER_LITERAL . (asynchronous_select . 0)) (STRING_LITERAL . 
(asynchronous_select . 0)) (IDENTIFIER . (asynchronous_select . 0)) (LESS_LESS 
. (asynchronous_select . 0)) (END . (asynchronous_select . 0)) (EXCEPTION . 
(asynchronous_select . 0)))
+      ((default . error) (DO . (extended_return_object_declaration . 0)) 
(SEMICOLON . (extended_return_object_declaration . 0)))
+      ((default . error) (IF .  1303))
+      ((default . error) (WHEN . (if_statement . 1)) (THEN . (if_statement . 
1)) (OR . (if_statement . 1)) (ELSIF . (if_statement . 1)) (ELSE . 
(if_statement . 1)) (WHILE . (if_statement . 1)) (SELECT . (if_statement . 1)) 
(RETURN . (if_statement . 1)) (REQUEUE . (if_statement . 1)) (RAISE . 
(if_statement . 1)) (PRAGMA . (if_statement . 1)) (NULL . (if_statement . 1)) 
(LOOP . (if_statement . 1)) (IF . (if_statement . 1)) (GOTO . (if_statement . 
1)) (FOR . (if_statement . 1)) (EXIT . (if_statement . 1)) (DELAY . 
(if_statement . 1)) (DECLARE . (if_statement . 1)) (CASE . (if_statement . 1)) 
(BEGIN . (if_statement . 1)) (ABORT . (if_statement . 1)) (ACCEPT . 
(if_statement . 1)) (CHARACTER_LITERAL . (if_statement . 1)) (STRING_LITERAL . 
(if_statement . 1)) (IDENTIFIER . (if_statement . 1)) (LESS_LESS . 
(if_statement . 1)) (END . (if_statement . 1)) (EXCEPTION . (if_statement . 1)))
+      ((default . error) (ELSE . (elsif_statement_item . 0)) (ELSIF . 
(elsif_statement_item . 0)) (END . (elsif_statement_item . 0)))
+      ((default . error) (SEMICOLON .  1302))
+      ((default . error) (SEMICOLON .  1301))
+      ((default . error) (SEMICOLON .  1300))
+      ((default . error) (IN .  1299))
+      ((default . error) (IS .  1298))
+      ((default . error) (WITH . (derived_type_definition . 0)) (SEMICOLON . 
(derived_type_definition . 0)))
+      ((default . error) (SEMICOLON . (aspect_specification_opt . 0)) (WITH .  
104))
+      ((default . error) (CASE .  1296))
+      ((default . error) (WHEN . (variant_list . 1)) (END . (variant_list . 
1)))
+      ((default . error) (BAR .  262) (EQUAL_GREATER .  1295))
+      ((default . error) (WHEN . (component_declaration . 1)) (END . 
(component_declaration . 1)) (CASE . (component_declaration . 1)) (IDENTIFIER . 
(component_declaration . 1)) (FOR . (component_declaration . 1)))
+      ((default . error) (SEMICOLON . (aspect_specification_opt . 0)) (WITH .  
104))
+      ((default . error) (SEMICOLON . (real_range_specification_opt . 1)) 
(WITH . (real_range_specification_opt . 1)))
+      ((default . error) (SEMICOLON .  1293))
+      ((default . error) (SEMICOLON .  1292))
+      ((default . error) (DOT_DOT .  1291))
+      ((default . error) (PLUS .  136) (MINUS .  135) (ABS .  138) (NOT .  
141) (NULL .  142) (NEW .  140) (IDENTIFIER .  45) (CHARACTER_LITERAL .  47) 
(STRING_LITERAL .  46) (LEFT_PAREN .  139))
+      ((default . error) (PRIVATE . (protected_type_declaration . 0)) (END . 
(protected_type_declaration . 0)) (BEGIN . (protected_type_declaration . 0)) 
(IDENTIFIER . (protected_type_declaration . 0)) (ENTRY . 
(protected_type_declaration . 0)) (FOR . (protected_type_declaration . 0)) 
(FUNCTION . (protected_type_declaration . 0)) (GENERIC . 
(protected_type_declaration . 0)) (NOT . (protected_type_declaration . 0)) 
(OVERRIDING . (protected_type_declaration . 0)) (PACKAGE . 
(protected_type_declaration . 0)) (PRAGMA . (protected_type_declaration . 0)) 
(PROCEDURE . (protected_type_declaration . 0)) (PROTECTED . 
(protected_type_declaration . 0)) (SUBTYPE . (protected_type_declaration . 0)) 
(TASK . (protected_type_declaration . 0)) (TYPE . (protected_type_declaration . 
0)) (USE . (protected_type_declaration . 0)))
+      ((default . error) (PRIVATE . (task_type_declaration . 0)) (END . 
(task_type_declaration . 0)) (BEGIN . (task_type_declaration . 0)) (IDENTIFIER 
. (task_type_declaration . 0)) (ENTRY . (task_type_declaration . 0)) (FOR . 
(task_type_declaration . 0)) (FUNCTION . (task_type_declaration . 0)) (GENERIC 
. (task_type_declaration . 0)) (NOT . (task_type_declaration . 0)) (OVERRIDING 
. (task_type_declaration . 0)) (PACKAGE . (task_type_declaration . 0)) (PRAGMA 
. (task_type_declaration . 0)) (PROCEDURE . (task_type_declaration . 0)) 
(PROTECTED . (task_type_declaration . 0)) (SUBTYPE . (task_type_declaration . 
0)) (TASK . (task_type_declaration . 0)) (TYPE . (task_type_declaration . 0)) 
(USE . (task_type_declaration . 0)))
+      ((default . error) (SEMICOLON .  1310))
+      ((default . error) (NULL .  996) (CASE .  995) (IDENTIFIER .  69) (FOR . 
 279))
+      ((default . error) (SEMICOLON .  1308))
+      ((default . error) (SEMICOLON .  1307))
+      ((default . error) (BEGIN . (declarative_part_opt . 0)) (USE .  11) 
(SUBTYPE .  282) (PRAGMA .  7) (NOT .  4) (OVERRIDING .  5) (FUNCTION . 
(overriding_indicator_opt . 2)) (PROCEDURE . (overriding_indicator_opt . 2)) 
(ENTRY . (overriding_indicator_opt . 2)) (FOR .  279) (IDENTIFIER .  278) (TYPE 
.  284) (GENERIC .  2) (PROTECTED .  281) (TASK .  283) (PACKAGE .  280))
+      ((default . error) (IDENTIFIER .  45) (CHARACTER_LITERAL .  47) 
(STRING_LITERAL .  46) (PLUS .  136) (MINUS .  135) (ABS .  138) (NOT .  750) 
(NULL .  142) (NEW .  140) (LEFT_PAREN .  139))
+      ((default . error) (PRIVATE . (task_body . 0)) (END . (task_body . 0)) 
(BEGIN . (task_body . 0)) (IDENTIFIER . (task_body . 0)) (ENTRY . (task_body . 
0)) (FOR . (task_body . 0)) (FUNCTION . (task_body . 0)) (GENERIC . (task_body 
. 0)) (NOT . (task_body . 0)) (OVERRIDING . (task_body . 0)) (PACKAGE . 
(task_body . 0)) (PRAGMA . (task_body . 0)) (PROCEDURE . (task_body . 0)) 
(PROTECTED . (task_body . 0)) (SUBTYPE . (task_body . 0)) (TASK . (task_body . 
0)) (TYPE . (task_body . 0)) (USE . (task_body . 0)) ($EOI . (task_body . 0)) 
(LIMITED . (task_body . 0)) (SEPARATE . (task_body . 0)) (WITH . (task_body . 
0)))
+      ((default . error) (THEN . (accept_statement . 0)) (WHEN . 
(accept_statement . 0)) (EXCEPTION . (accept_statement . 0)) (ELSIF . 
(accept_statement . 0)) (ELSE . (accept_statement . 0)) (OR . (accept_statement 
. 0)) (END . (accept_statement . 0)) (LESS_LESS . (accept_statement . 0)) 
(IDENTIFIER . (accept_statement . 0)) (STRING_LITERAL . (accept_statement . 0)) 
(CHARACTER_LITERAL . (accept_statement . 0)) (ACCEPT . (accept_statement . 0)) 
(ABORT . (accept_statement . 0)) (BEGIN . (accept_statement . 0)) (CASE . 
(accept_statement . 0)) (DECLARE . (accept_statement . 0)) (DELAY . 
(accept_statement . 0)) (EXIT . (accept_statement . 0)) (FOR . 
(accept_statement . 0)) (GOTO . (accept_statement . 0)) (IF . (accept_statement 
. 0)) (LOOP . (accept_statement . 0)) (NULL . (accept_statement . 0)) (PRAGMA . 
(accept_statement . 0)) (RAISE . (accept_statement . 0)) (REQUEUE . 
(accept_statement . 0)) (RETURN . (accept_statement . 0)) (SELECT . 
(accept_statement . 0)) (WHILE . (accept_statement . 0)))
+      ((default . error) (OR . (if_statement . 2)) (THEN . (if_statement . 2)) 
(WHEN . (if_statement . 2)) (EXCEPTION . (if_statement . 2)) (END . 
(if_statement . 2)) (LESS_LESS . (if_statement . 2)) (IDENTIFIER . 
(if_statement . 2)) (STRING_LITERAL . (if_statement . 2)) (CHARACTER_LITERAL . 
(if_statement . 2)) (ACCEPT . (if_statement . 2)) (ABORT . (if_statement . 2)) 
(BEGIN . (if_statement . 2)) (CASE . (if_statement . 2)) (DECLARE . 
(if_statement . 2)) (DELAY . (if_statement . 2)) (EXIT . (if_statement . 2)) 
(FOR . (if_statement . 2)) (GOTO . (if_statement . 2)) (IF . (if_statement . 
2)) (LOOP . (if_statement . 2)) (NULL . (if_statement . 2)) (PRAGMA . 
(if_statement . 2)) (RAISE . (if_statement . 2)) (REQUEUE . (if_statement . 2)) 
(RETURN . (if_statement . 2)) (SELECT . (if_statement . 2)) (WHILE . 
(if_statement . 2)) (ELSE . (if_statement . 2)) (ELSIF . (if_statement . 2)))
+      ((default . error) (SEMICOLON .  1304))
+      ((default . error) (WHEN . (if_statement . 0)) (THEN . (if_statement . 
0)) (OR . (if_statement . 0)) (ELSIF . (if_statement . 0)) (ELSE . 
(if_statement . 0)) (WHILE . (if_statement . 0)) (SELECT . (if_statement . 0)) 
(RETURN . (if_statement . 0)) (REQUEUE . (if_statement . 0)) (RAISE . 
(if_statement . 0)) (PRAGMA . (if_statement . 0)) (NULL . (if_statement . 0)) 
(LOOP . (if_statement . 0)) (IF . (if_statement . 0)) (GOTO . (if_statement . 
0)) (FOR . (if_statement . 0)) (EXIT . (if_statement . 0)) (DELAY . 
(if_statement . 0)) (DECLARE . (if_statement . 0)) (CASE . (if_statement . 0)) 
(BEGIN . (if_statement . 0)) (ABORT . (if_statement . 0)) (ACCEPT . 
(if_statement . 0)) (CHARACTER_LITERAL . (if_statement . 0)) (STRING_LITERAL . 
(if_statement . 0)) (IDENTIFIER . (if_statement . 0)) (LESS_LESS . 
(if_statement . 0)) (END . (if_statement . 0)) (EXCEPTION . (if_statement . 0)))
+      ((default . error) (RIGHT_PAREN .  1314))
+      ((default . error) (BEGIN .  1313))
+      ((default . error) (BEGIN . (private_extension_declaration . 0)) 
(IDENTIFIER . (private_extension_declaration . 0)) (ENTRY . 
(private_extension_declaration . 0)) (FOR . (private_extension_declaration . 
0)) (FUNCTION . (private_extension_declaration . 0)) (GENERIC . 
(private_extension_declaration . 0)) (NOT . (private_extension_declaration . 
0)) (OVERRIDING . (private_extension_declaration . 0)) (PACKAGE . 
(private_extension_declaration . 0)) (PRAGMA . (private_extension_declaration . 
0)) (PROCEDURE . (private_extension_declaration . 0)) (PROTECTED . 
(private_extension_declaration . 0)) (SUBTYPE . (private_extension_declaration 
. 0)) (TASK . (private_extension_declaration . 0)) (TYPE . 
(private_extension_declaration . 0)) (USE . (private_extension_declaration . 
0)) (PRIVATE . (private_extension_declaration . 0)) (END . 
(private_extension_declaration . 0)))
+      ((default . error) (WHEN . (variant_part . 0)) (END . (variant_part . 
0)) (CASE . (variant_part . 0)) (IDENTIFIER . (variant_part . 0)) (FOR . 
(variant_part . 0)))
+      ((default . error) (END . (variant . 0)) (WHEN . (variant . 0)) (CASE .  
995) (IDENTIFIER .  69) (FOR .  279))
+      ((default . error) (WHEN . (component_declaration . 0)) (END . 
(component_declaration . 0)) (CASE . (component_declaration . 0)) (IDENTIFIER . 
(component_declaration . 0)) (FOR . (component_declaration . 0)))
+      ((default . error) (SEMICOLON .  1312))
+      ((default . error) (END . (component_clause . 0)) (IDENTIFIER . 
(component_clause . 0)))
+      ((default . error) (END . (sequence_of_statements_opt . 0)) (EXCEPTION . 
(sequence_of_statements_opt . 0)) (ACCEPT . (label_opt . 0)) (BEGIN . 
(label_opt . 0)) (CASE . (label_opt . 0)) (DECLARE . (label_opt . 0)) (FOR . 
(label_opt . 0)) (IF . (label_opt . 0)) (LOOP . (label_opt . 0)) (RETURN . 
(label_opt . 0)) (SELECT . (label_opt . 0)) (WHILE . (label_opt . 0)) 
(STRING_LITERAL . (label_opt . 0)) (CHARACTER_LITERAL . (label_opt . 0)) (ABORT 
. (label_opt . 0)) (DELAY . (label_opt . 0)) (EXIT . (label_opt . 0)) (GOTO . 
(label_opt . 0)) (NULL . (label_opt . 0)) (PRAGMA . (label_opt . 0)) (RAISE . 
(label_opt . 0)) (REQUEUE . (label_opt . 0)) (LESS_LESS .  599) (IDENTIFIER . 
((label_opt . 0)  600)))
+      ((default . error) (WHEN . (parameter_profile_opt . 0)) (LEFT_PAREN .  
773))
+      ((default . error) (WHEN . (entry_body_formal_part . 0)))
+      ((default . error) (END .  1317))
+      ((default . error) (SEMICOLON . (identifier_opt . 0)) (IDENTIFIER .  
683))
+      ((default . error) (SEMICOLON .  1319))
+      ((default . error) (PROCEDURE . (entry_body . 0)) (OVERRIDING . 
(entry_body . 0)) (NOT . (entry_body . 0)) (FUNCTION . (entry_body . 0)) (FOR . 
(entry_body . 0)) (ENTRY . (entry_body . 0)) (END . (entry_body . 0)))]
+     [((compilation_unit . 13)(compilation_unit_list . 14)(context_item . 
15)(generic_declaration . 16)(generic_formal_part . 17)(generic_instantiation . 
18)(generic_package_declaration . 19)(generic_renaming_declaration . 
20)(generic_subprogram_declaration . 21)(library_item . 
22)(library_unit_declaration . 23)(library_unit_renaming_declaration . 
24)(overriding_indicator_opt . 25)(package_body . 26)(package_declaration . 
27)(package_specification . 28)(pragma . 29)(procedure_specification . 
30)(subprogram_body . 31)(subprogram_declaration . 32)(subunit . 33)(use_clause 
. 34)(with_clause . 35))
+      ((attribute_reference . 48)(name . 83)(qualified_expression . 
51)(selected_component . 52))
+      ((formal_object_declaration . 75)(formal_subprogram_declaration . 
76)(formal_type_declaration . 77)(formal_package_declaration . 
78)(generic_formal_parameter_declarations . 
79)(generic_formal_parameter_declaration . 80)(identifier_list . 81)(pragma . 
82))
+      nil
+      nil
+      nil
+      ((attribute_reference . 48)(name . 65)(qualified_expression . 
51)(selected_component . 52))
+      nil
+      ((generic_declaration . 16)(generic_formal_part . 
17)(generic_instantiation . 18)(generic_package_declaration . 
19)(generic_subprogram_declaration . 21)(library_unit_declaration . 
61)(overriding_indicator_opt . 62)(package_declaration . 
27)(package_specification . 28)(procedure_specification . 
30)(subprogram_declaration . 32))
+      ((attribute_reference . 48)(name . 57)(qualified_expression . 
51)(selected_component . 52))
+      nil
+      ((attribute_reference . 48)(name_list . 55)(name . 
50)(qualified_expression . 51)(selected_component . 52))
+      ((attribute_reference . 48)(name_list . 49)(name . 
50)(qualified_expression . 51)(selected_component . 52))
+      nil
+      ((compilation_unit . 44)(context_item . 15)(generic_declaration . 
16)(generic_formal_part . 17)(generic_instantiation . 
18)(generic_package_declaration . 19)(generic_renaming_declaration . 
20)(generic_subprogram_declaration . 21)(library_item . 
22)(library_unit_declaration . 23)(library_unit_renaming_declaration . 
24)(overriding_indicator_opt . 25)(package_body . 26)(package_declaration . 
27)(package_specification . 28)(pragma . 29)(procedure_specification . 
30)(subprogram_body . 31)(subprogram_declaration . 32)(subunit . 33)(use_clause 
. 34)(with_clause . 35))
+      nil
+      nil
+      ((package_specification . 41)(procedure_specification . 
30)(subprogram_specification . 42))
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      ((procedure_specification . 30)(subprogram_specification . 39))
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      ((attribute_reference . 48)(name . 125)(qualified_expression . 
51)(selected_component . 52))
+      ((attribute_reference . 48)(name . 124)(qualified_expression . 
51)(selected_component . 52))
+      ((aspect_specification_opt . 123))
+      ((attribute_reference . 48)(name . 121)(qualified_expression . 
51)(selected_component . 52))
+      nil
+      ((aspect_specification_opt . 119))
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      ((actual_parameter_part . 88))
+      nil
+      nil
+      nil
+      ((attribute_reference . 48)(name_list . 116)(name . 
50)(qualified_expression . 51)(selected_component . 52))
+      nil
+      ((attribute_reference . 48)(name . 113)(qualified_expression . 
51)(selected_component . 52))
+      ((actual_parameter_part . 88)(formal_part . 111)(parameter_profile_opt . 
112))
+      ((formal_object_declaration . 75)(formal_subprogram_declaration . 
76)(formal_type_declaration . 77)(formal_package_declaration . 
78)(generic_formal_parameter_declarations . 
79)(generic_formal_parameter_declaration . 80)(identifier_list . 81)(pragma . 
82))
+      ((attribute_reference . 48)(name . 65)(qualified_expression . 
51)(selected_component . 52))
+      ((attribute_reference . 48)(name_list . 110)(name . 
50)(qualified_expression . 51)(selected_component . 52))
+      nil
+      ((procedure_specification . 30)(subprogram_specification . 109))
+      nil
+      ((attribute_reference . 48)(name . 106)(qualified_expression . 
51)(selected_component . 52))
+      ((actual_parameter_part . 88)(aspect_specification_opt . 105))
+      nil
+      nil
+      ((attribute_reference . 48)(name_list . 100)(name . 
50)(qualified_expression . 51)(selected_component . 52))
+      nil
+      ((attribute_reference . 48)(name . 99)(qualified_expression . 
51)(selected_component . 52))
+      ((attribute_reference . 48)(name . 98)(qualified_expression . 
51)(selected_component . 52))
+      ((attribute_reference . 48)(name . 97)(qualified_expression . 
51)(selected_component . 52))
+      nil
+      ((procedure_specification . 30)(subprogram_specification . 95))
+      nil
+      nil
+      nil
+      nil
+      ((formal_object_declaration . 75)(formal_subprogram_declaration . 
76)(formal_type_declaration . 77)(formal_package_declaration . 
78)(generic_formal_parameter_declaration . 93)(identifier_list . 81)(pragma . 
82))
+      nil
+      nil
+      nil
+      ((actual_parameter_part . 88)(formal_part . 
89)(parameter_and_result_profile . 90))
+      nil
+      ((aggregate . 211)(attribute_reference . 48)(attribute_designator . 
212)(name . 213)(qualified_expression . 51)(selected_component . 52))
+      ((aggregate . 143)(association_opt . 166)(association_list . 
167)(attribute_reference . 48)(choice_expression . 
168)(choice_relation_and_list . 169)(choice_relation_or_list . 
170)(choice_relation_xor_list . 171)(choice_relation_and_then_list . 
172)(choice_relation_or_else_list . 173)(choice_relation . 174)(discrete_choice 
. 175)(discrete_choice_list . 176)(expression . 177)(expression_opt . 
178)(factor . 145)(identifier_list . 203)(name . 179)(parameter_specification . 
204)(parameter_specification_list . 205)(primary . 149)(qualified_expression . 
51)(range . 180)(relation_and_list . 150)(relation_and_then_list . 
151)(relation_or_list . 152)(relation_or_else_list . 153)(relation_xor_list . 
154)(relation . 155)(selected_component . 52)(simple_expression . 181)(term . 
157)(term_list . 158)(unary_adding_operator . 159))
+      ((access_definition . 199)(attribute_reference . 48)(name . 
200)(null_exclusion_opt . 201)(qualified_expression . 51)(selected_component . 
52))
+      nil
+      nil
+      nil
+      ((mode_opt . 196))
+      nil
+      nil
+      ((attribute_reference . 48)(name . 192)(qualified_expression . 
51)(selected_component . 52))
+      ((aspect_specification_opt . 191))
+      ((discriminant_part_opt . 189))
+      ((actual_parameter_part . 88))
+      ((actual_parameter_part . 88))
+      ((actual_parameter_part . 88))
+      nil
+      ((attribute_reference . 48)(name_list . 183)(name . 
50)(qualified_expression . 51)(selected_component . 52))
+      nil
+      ((aggregate . 143)(association_opt . 166)(association_list . 
167)(attribute_reference . 48)(choice_expression . 
168)(choice_relation_and_list . 169)(choice_relation_or_list . 
170)(choice_relation_xor_list . 171)(choice_relation_and_then_list . 
172)(choice_relation_or_else_list . 173)(choice_relation . 174)(discrete_choice 
. 175)(discrete_choice_list . 176)(expression . 177)(expression_opt . 
178)(factor . 145)(name . 179)(primary . 149)(qualified_expression . 51)(range 
. 180)(relation_and_list . 150)(relation_and_then_list . 151)(relation_or_list 
. 152)(relation_or_else_list . 153)(relation_xor_list . 154)(relation . 
155)(selected_component . 52)(simple_expression . 181)(term . 157)(term_list . 
158)(unary_adding_operator . 159))
+      nil
+      nil
+      ((actual_parameter_part . 88)(aspect_specification_opt . 160))
+      nil
+      ((aggregate . 143)(attribute_reference . 48)(expression . 144)(factor . 
145)(name . 146)(pragma_argument_association . 
147)(pragma_argument_association_list . 148)(primary . 
149)(qualified_expression . 51)(relation_and_list . 150)(relation_and_then_list 
. 151)(relation_or_list . 152)(relation_or_else_list . 153)(relation_xor_list . 
154)(relation . 155)(selected_component . 52)(simple_expression . 156)(term . 
157)(term_list . 158)(unary_adding_operator . 159))
+      nil
+      nil
+      nil
+      nil
+      ((actual_parameter_part . 88))
+      ((attribute_reference . 48)(name . 132)(qualified_expression . 
51)(selected_component . 52))
+      nil
+      nil
+      ((attribute_reference . 48)(name_list . 130)(name . 
50)(qualified_expression . 51)(selected_component . 52))
+      nil
+      nil
+      nil
+      ((actual_parameter_part . 88)(aspect_specification_opt . 105))
+      nil
+      nil
+      ((actual_parameter_part . 88)(formal_part . 111)(parameter_profile_opt . 
112))
+      ((actual_parameter_part . 88)(formal_part . 
89)(parameter_and_result_profile . 90))
+      nil
+      nil
+      ((abstract_subprogram_declaration . 285)(aspect_clause . 286)(at_clause 
. 287)(body . 288)(body_stub . 289)(declaration . 290)(declarations . 
291)(declarative_part_opt . 370)(entry_declaration . 
293)(enumeration_representation_clause . 294)(exception_declaration . 
295)(full_type_declaration . 296)(generic_declaration . 
297)(generic_formal_part . 17)(generic_instantiation . 
298)(generic_package_declaration . 19)(generic_renaming_declaration . 
299)(generic_subprogram_declaration . 21)(identifier_list . 
300)(incomplete_type_declaration . 301)(null_procedure_declaration . 
302)(object_declaration . 303)(object_renaming_declaration . 
304)(overriding_indicator_opt . 305)(package_body . 306)(package_body_stub . 
307)(package_declaration . 308)(package_renaming_declaration . 
309)(package_specification . 28)(pragma . 310)(private_extension_declaration . 
311)(private_type_declaration . 312)(procedure_specification . 30)(proper_body 
. 313)(protected_body . 314)(protected_body_stub . 
315)(protected_type_declaration . 316)(record_representation_clause . 
317)(renaming_declaration . 318)(single_protected_declaration . 
319)(single_task_declaration . 320)(subprogram_body . 321)(subprogram_body_stub 
. 322)(subprogram_declaration . 323)(subprogram_renaming_declaration . 
324)(subtype_declaration . 325)(task_body . 326)(task_body_stub . 
327)(task_type_declaration . 328)(type_declaration . 329)(use_clause . 330))
+      nil
+      nil
+      nil
+      ((actual_parameter_part . 88))
+      ((overriding_indicator_opt . 367)(package_body . 
306)(procedure_specification . 30)(proper_body . 368)(protected_body . 
314)(subprogram_body . 321)(task_body . 326))
+      nil
+      nil
+      nil
+      nil
+      ((aggregate . 143)(attribute_reference . 48)(name . 146)(primary . 
361)(qualified_expression . 51)(selected_component . 52))
+      ((aggregate . 143)(association_opt . 166)(association_list . 
219)(attribute_reference . 48)(case_expression . 358)(choice_expression . 
168)(choice_relation_and_list . 169)(choice_relation_or_list . 
170)(choice_relation_xor_list . 171)(choice_relation_and_then_list . 
172)(choice_relation_or_else_list . 173)(choice_relation . 174)(discrete_choice 
. 175)(discrete_choice_list . 176)(expression . 220)(expression_opt . 
178)(factor . 145)(if_expression . 359)(name . 179)(primary . 
149)(qualified_expression . 51)(quantified_expression . 360)(range . 
221)(relation_and_list . 150)(relation_and_then_list . 151)(relation_or_list . 
152)(relation_or_else_list . 153)(relation_xor_list . 154)(relation . 
155)(selected_component . 52)(simple_expression . 181)(term . 157)(term_list . 
158)(unary_adding_operator . 159))
+      ((attribute_reference . 48)(name . 354)(qualified_expression . 
51)(selected_component . 52))
+      ((aggregate . 143)(attribute_reference . 48)(name . 146)(primary . 
275)(qualified_expression . 51)(selected_component . 52))
+      nil
+      nil
+      nil
+      nil
+      ((actual_parameter_part . 88))
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      ((relational_operator . 342))
+      ((multiplying_operator . 341))
+      ((binary_adding_operator . 336))
+      ((aggregate . 143)(attribute_reference . 48)(factor . 145)(name . 
146)(primary . 149)(qualified_expression . 51)(selected_component . 52)(term . 
157)(term_list . 332))
+      nil
+      ((abstract_subprogram_declaration . 285)(aspect_clause . 286)(at_clause 
. 287)(body . 288)(body_stub . 289)(declaration . 290)(declarations . 
291)(declarative_part_opt . 292)(entry_declaration . 
293)(enumeration_representation_clause . 294)(exception_declaration . 
295)(full_type_declaration . 296)(generic_declaration . 
297)(generic_formal_part . 17)(generic_instantiation . 
298)(generic_package_declaration . 19)(generic_renaming_declaration . 
299)(generic_subprogram_declaration . 21)(identifier_list . 
300)(incomplete_type_declaration . 301)(null_procedure_declaration . 
302)(object_declaration . 303)(object_renaming_declaration . 
304)(overriding_indicator_opt . 305)(package_body . 306)(package_body_stub . 
307)(package_declaration . 308)(package_renaming_declaration . 
309)(package_specification . 28)(pragma . 310)(private_extension_declaration . 
311)(private_type_declaration . 312)(procedure_specification . 30)(proper_body 
. 313)(protected_body . 314)(protected_body_stub . 
315)(protected_type_declaration . 316)(record_representation_clause . 
317)(renaming_declaration . 318)(single_protected_declaration . 
319)(single_task_declaration . 320)(subprogram_body . 321)(subprogram_body_stub 
. 322)(subprogram_declaration . 323)(subprogram_renaming_declaration . 
324)(subtype_declaration . 325)(task_body . 326)(task_body_stub . 
327)(task_type_declaration . 328)(type_declaration . 329)(use_clause . 330))
+      nil
+      nil
+      ((aggregate . 143)(attribute_reference . 48)(name . 146)(primary . 
275)(qualified_expression . 51)(selected_component . 52))
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      ((actual_parameter_part . 88))
+      nil
+      ((relational_operator . 259))
+      ((attribute_reference . 48)(name . 249)(qualified_expression . 
51)(selected_component . 52))
+      nil
+      nil
+      ((attribute_reference . 48)(name . 247)(qualified_expression . 
51)(selected_component . 52))
+      ((attribute_reference . 48)(name . 246)(qualified_expression . 
51)(selected_component . 52))
+      ((attribute_reference . 48)(name . 245)(qualified_expression . 
51)(selected_component . 52))
+      ((discriminant_specification_opt . 242)(discriminant_specification_list 
. 243)(identifier_list . 244))
+      ((aspect_specification_opt . 240))
+      ((attribute_reference . 48)(name . 237)(qualified_expression . 
51)(selected_component . 52)(subprogram_default . 238))
+      nil
+      ((actual_parameter_part . 88))
+      nil
+      nil
+      nil
+      ((access_definition . 229)(null_exclusion_opt . 230))
+      ((access_definition . 227)(null_exclusion_opt . 228))
+      nil
+      nil
+      ((actual_parameter_part . 88))
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      ((aggregate . 143)(association_opt . 166)(association_list . 
219)(attribute_reference . 48)(choice_expression . 
168)(choice_relation_and_list . 169)(choice_relation_or_list . 
170)(choice_relation_xor_list . 171)(choice_relation_and_then_list . 
172)(choice_relation_or_else_list . 173)(choice_relation . 174)(discrete_choice 
. 175)(discrete_choice_list . 176)(expression . 220)(expression_opt . 
178)(factor . 145)(name . 179)(primary . 149)(qualified_expression . 51)(range 
. 221)(relation_and_list . 150)(relation_and_then_list . 151)(relation_or_list 
. 152)(relation_or_else_list . 153)(relation_xor_list . 154)(relation . 
155)(selected_component . 52)(simple_expression . 181)(term . 157)(term_list . 
158)(unary_adding_operator . 159))
+      nil
+      nil
+      nil
+      ((actual_parameter_part . 88))
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      ((identifier_list . 203)(parameter_specification . 502))
+      nil
+      ((access_definition . 500)(aliased_opt . 501)(null_exclusion_opt . 201))
+      ((general_access_modifier_opt . 497)(protected_opt . 498))
+      nil
+      nil
+      ((attribute_reference . 48)(name . 493)(qualified_expression . 
51)(selected_component . 52))
+      ((aspect_specification_opt . 492))
+      ((attribute_reference . 48)(name . 490)(qualified_expression . 
51)(selected_component . 52))
+      nil
+      nil
+      nil
+      nil
+      ((aspect_specification_opt . 487)(attribute_reference . 48)(name . 
237)(qualified_expression . 51)(selected_component . 52)(subprogram_default . 
488))
+      nil
+      ((actual_parameter_part . 88))
+      ((aspect_specification_opt . 486))
+      ((abstract_tagged_limited_opt . 480)(access_definition . 
481)(array_type_definition . 482)(formal_type_definition . 
483)(formal_derived_type_definition . 484)(interface_type_definition . 
485)(null_exclusion_opt . 201))
+      nil
+      nil
+      nil
+      nil
+      nil
+      ((actual_parameter_part . 88)(aspect_specification_opt . 460))
+      ((actual_parameter_part . 88)(aspect_specification_opt . 459))
+      ((actual_parameter_part . 88)(aspect_specification_opt . 458))
+      nil
+      ((actual_parameter_part . 88)(aspect_specification_opt . 457))
+      ((aggregate . 143)(attribute_reference . 48)(factor . 145)(name . 
146)(primary . 149)(qualified_expression . 51)(selected_component . 
52)(simple_expression . 456)(term . 157)(term_list . 158)(unary_adding_operator 
. 159))
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      ((aggregate . 143)(attribute_reference . 48)(factor . 
145)(membership_choice_list . 452)(membership_choice . 453)(name . 179)(primary 
. 149)(qualified_expression . 51)(range . 454)(selected_component . 
52)(simple_expression . 455)(term . 157)(term_list . 158)(unary_adding_operator 
. 159))
+      nil
+      ((aggregate . 143)(attribute_reference . 48)(factor . 145)(name . 
146)(primary . 149)(qualified_expression . 51)(selected_component . 
52)(simple_expression . 450)(term . 157)(term_list . 158)(unary_adding_operator 
. 159))
+      nil
+      ((aggregate . 211)(attribute_reference . 48)(attribute_designator . 
212)(name . 213)(qualified_expression . 51)(selected_component . 52))
+      ((aggregate . 143)(attribute_reference . 48)(choice_expression . 
168)(choice_relation_and_list . 169)(choice_relation_or_list . 
170)(choice_relation_xor_list . 171)(choice_relation_and_then_list . 
172)(choice_relation_or_else_list . 173)(choice_relation . 174)(discrete_choice 
. 447)(factor . 145)(name . 179)(primary . 149)(qualified_expression . 
51)(range . 221)(selected_component . 52)(simple_expression . 448)(term . 
157)(term_list . 158)(unary_adding_operator . 159))
+      ((aggregate . 143)(attribute_reference . 48)(expression . 446)(factor . 
145)(name . 146)(primary . 149)(qualified_expression . 51)(relation_and_list . 
150)(relation_and_then_list . 151)(relation_or_list . 
152)(relation_or_else_list . 153)(relation_xor_list . 154)(relation . 
155)(selected_component . 52)(simple_expression . 156)(term . 157)(term_list . 
158)(unary_adding_operator . 159))
+      ((aggregate . 143)(attribute_reference . 48)(choice_relation . 
444)(factor . 145)(name . 146)(primary . 149)(qualified_expression . 
51)(selected_component . 52)(simple_expression . 435)(term . 157)(term_list . 
158)(unary_adding_operator . 159))
+      ((aggregate . 143)(attribute_reference . 48)(choice_relation . 
442)(factor . 145)(name . 146)(primary . 149)(qualified_expression . 
51)(selected_component . 52)(simple_expression . 435)(term . 157)(term_list . 
158)(unary_adding_operator . 159))
+      ((aggregate . 143)(attribute_reference . 48)(choice_relation . 
440)(factor . 145)(name . 146)(primary . 149)(qualified_expression . 
51)(selected_component . 52)(simple_expression . 435)(term . 157)(term_list . 
158)(unary_adding_operator . 159))
+      nil
+      nil
+      ((aggregate . 143)(attribute_reference . 48)(choice_relation . 
437)(factor . 145)(name . 146)(primary . 149)(qualified_expression . 
51)(selected_component . 52)(simple_expression . 435)(term . 157)(term_list . 
158)(unary_adding_operator . 159))
+      ((aggregate . 143)(attribute_reference . 48)(choice_relation . 
436)(factor . 145)(name . 146)(primary . 149)(qualified_expression . 
51)(selected_component . 52)(simple_expression . 435)(term . 157)(term_list . 
158)(unary_adding_operator . 159))
+      ((aggregate . 143)(attribute_reference . 48)(choice_relation . 
434)(factor . 145)(name . 146)(primary . 149)(qualified_expression . 
51)(selected_component . 52)(simple_expression . 435)(term . 157)(term_list . 
158)(unary_adding_operator . 159))
+      ((aggregate . 143)(association_opt . 433)(attribute_reference . 
48)(choice_expression . 168)(choice_relation_and_list . 
169)(choice_relation_or_list . 170)(choice_relation_xor_list . 
171)(choice_relation_and_then_list . 172)(choice_relation_or_else_list . 
173)(choice_relation . 174)(discrete_choice . 175)(discrete_choice_list . 
176)(expression . 177)(expression_opt . 178)(factor . 145)(name . 179)(primary 
. 149)(qualified_expression . 51)(range . 221)(relation_and_list . 
150)(relation_and_then_list . 151)(relation_or_list . 
152)(relation_or_else_list . 153)(relation_xor_list . 154)(relation . 
155)(selected_component . 52)(simple_expression . 181)(term . 157)(term_list . 
158)(unary_adding_operator . 159))
+      nil
+      ((attribute_reference . 48)(name . 432)(qualified_expression . 
51)(selected_component . 52))
+      nil
+      ((aggregate . 143)(attribute_reference . 48)(expression . 431)(factor . 
145)(name . 146)(primary . 149)(qualified_expression . 51)(relation_and_list . 
150)(relation_and_then_list . 151)(relation_or_list . 
152)(relation_or_else_list . 153)(relation_xor_list . 154)(relation . 
155)(selected_component . 52)(simple_expression . 156)(term . 157)(term_list . 
158)(unary_adding_operator . 159))
+      ((aggregate . 143)(attribute_reference . 48)(expression . 429)(factor . 
145)(name . 146)(primary . 149)(qualified_expression . 51)(relation_and_list . 
150)(relation_and_then_list . 151)(relation_or_list . 
152)(relation_or_else_list . 153)(relation_xor_list . 154)(relation . 
155)(selected_component . 52)(simple_expression . 156)(term . 157)(term_list . 
158)(unary_adding_operator . 159))
+      nil
+      ((attribute_reference . 425)(direct_name . 426)(name . 
427)(qualified_expression . 51)(selected_component . 52))
+      ((attribute_reference . 48)(name . 422)(qualified_expression . 
51)(selected_component . 52))
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      ((abstract_subprogram_declaration . 285)(aspect_clause . 286)(at_clause 
. 287)(body . 288)(body_stub . 289)(declaration . 412)(entry_declaration . 
293)(enumeration_representation_clause . 294)(exception_declaration . 
295)(full_type_declaration . 296)(generic_declaration . 
297)(generic_formal_part . 17)(generic_instantiation . 
298)(generic_package_declaration . 19)(generic_renaming_declaration . 
299)(generic_subprogram_declaration . 21)(identifier_list . 
300)(incomplete_type_declaration . 301)(null_procedure_declaration . 
302)(object_declaration . 303)(object_renaming_declaration . 
304)(overriding_indicator_opt . 305)(package_body . 306)(package_body_stub . 
307)(package_declaration . 308)(package_renaming_declaration . 
309)(package_specification . 28)(pragma . 310)(private_extension_declaration . 
311)(private_type_declaration . 312)(procedure_specification . 30)(proper_body 
. 313)(protected_body . 314)(protected_body_stub . 
315)(protected_type_declaration . 316)(record_representation_clause . 
317)(renaming_declaration . 318)(single_protected_declaration . 
319)(single_task_declaration . 320)(subprogram_body . 321)(subprogram_body_stub 
. 322)(subprogram_declaration . 323)(subprogram_renaming_declaration . 
324)(subtype_declaration . 325)(task_body . 326)(task_body_stub . 
327)(task_type_declaration . 328)(type_declaration . 329)(use_clause . 330))
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      ((procedure_specification . 407)(subprogram_specification . 408))
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      ((abstract_subprogram_declaration . 285)(aspect_clause . 286)(at_clause 
. 287)(body . 288)(body_stub . 289)(declaration . 290)(declarations . 
291)(declarative_part_opt . 405)(entry_declaration . 
293)(enumeration_representation_clause . 294)(exception_declaration . 
295)(full_type_declaration . 296)(generic_declaration . 
297)(generic_formal_part . 17)(generic_instantiation . 
298)(generic_package_declaration . 19)(generic_renaming_declaration . 
299)(generic_subprogram_declaration . 21)(identifier_list . 
300)(incomplete_type_declaration . 301)(null_procedure_declaration . 
302)(object_declaration . 303)(object_renaming_declaration . 
304)(overriding_indicator_opt . 305)(package_body . 306)(package_body_stub . 
307)(package_declaration . 308)(package_renaming_declaration . 
309)(package_specification . 28)(pragma . 310)(private_extension_declaration . 
311)(private_type_declaration . 312)(procedure_specification . 30)(proper_body 
. 313)(protected_body . 314)(protected_body_stub . 
315)(protected_type_declaration . 316)(record_representation_clause . 
317)(renaming_declaration . 318)(single_protected_declaration . 
319)(single_task_declaration . 320)(subprogram_body . 321)(subprogram_body_stub 
. 322)(subprogram_declaration . 323)(subprogram_renaming_declaration . 
324)(subtype_declaration . 325)(task_body . 326)(task_body_stub . 
327)(task_type_declaration . 328)(type_declaration . 329)(use_clause . 330))
+      ((binary_adding_operator . 336))
+      nil
+      nil
+      nil
+      ((aggregate . 143)(attribute_reference . 48)(factor . 145)(name . 
146)(primary . 149)(qualified_expression . 51)(selected_component . 52)(term . 
404))
+      nil
+      nil
+      nil
+      nil
+      ((aggregate . 143)(attribute_reference . 48)(factor . 403)(name . 
146)(primary . 149)(qualified_expression . 51)(selected_component . 52))
+      ((aggregate . 143)(attribute_reference . 48)(factor . 145)(name . 
146)(primary . 149)(qualified_expression . 51)(selected_component . 
52)(simple_expression . 402)(term . 157)(term_list . 158)(unary_adding_operator 
. 159))
+      ((aggregate . 143)(attribute_reference . 48)(factor . 145)(name . 
146)(primary . 149)(qualified_expression . 51)(relation . 
401)(selected_component . 52)(simple_expression . 156)(term . 157)(term_list . 
158)(unary_adding_operator . 159))
+      ((aggregate . 143)(attribute_reference . 48)(factor . 145)(name . 
146)(primary . 149)(qualified_expression . 51)(relation . 
399)(selected_component . 52)(simple_expression . 156)(term . 157)(term_list . 
158)(unary_adding_operator . 159))
+      ((aggregate . 143)(attribute_reference . 48)(factor . 145)(name . 
146)(primary . 149)(qualified_expression . 51)(relation . 
397)(selected_component . 52)(simple_expression . 156)(term . 157)(term_list . 
158)(unary_adding_operator . 159))
+      ((aggregate . 143)(attribute_reference . 48)(factor . 145)(name . 
146)(primary . 149)(qualified_expression . 51)(relation . 
396)(selected_component . 52)(simple_expression . 156)(term . 157)(term_list . 
158)(unary_adding_operator . 159))
+      nil
+      ((aggregate . 143)(attribute_reference . 48)(factor . 145)(name . 
146)(primary . 149)(qualified_expression . 51)(relation . 
394)(selected_component . 52)(simple_expression . 156)(term . 157)(term_list . 
158)(unary_adding_operator . 159))
+      nil
+      ((aggregate . 143)(attribute_reference . 48)(factor . 145)(name . 
146)(primary . 149)(qualified_expression . 51)(relation . 
392)(selected_component . 52)(simple_expression . 156)(term . 157)(term_list . 
158)(unary_adding_operator . 159))
+      ((aggregate . 143)(attribute_reference . 48)(name . 146)(primary . 
391)(qualified_expression . 51)(selected_component . 52))
+      ((aggregate . 143)(attribute_reference . 48)(expression . 144)(factor . 
145)(name . 146)(pragma_argument_association . 390)(primary . 
149)(qualified_expression . 51)(relation_and_list . 150)(relation_and_then_list 
. 151)(relation_or_list . 152)(relation_or_else_list . 153)(relation_xor_list . 
154)(relation . 155)(selected_component . 52)(simple_expression . 156)(term . 
157)(term_list . 158)(unary_adding_operator . 159))
+      nil
+      ((actual_parameter_part . 88))
+      ((aggregate . 143)(attribute_reference . 48)(expression . 388)(factor . 
145)(name . 146)(primary . 149)(qualified_expression . 51)(relation_and_list . 
150)(relation_and_then_list . 151)(relation_or_list . 
152)(relation_or_else_list . 153)(relation_xor_list . 154)(relation . 
155)(selected_component . 52)(simple_expression . 156)(term . 157)(term_list . 
158)(unary_adding_operator . 159))
+      ((quantifier . 387))
+      ((aggregate . 143)(attribute_reference . 48)(expression . 384)(factor . 
145)(name . 146)(primary . 149)(qualified_expression . 51)(relation_and_list . 
150)(relation_and_then_list . 151)(relation_or_list . 
152)(relation_or_else_list . 153)(relation_xor_list . 154)(relation . 
155)(selected_component . 52)(simple_expression . 156)(term . 157)(term_list . 
158)(unary_adding_operator . 159))
+      nil
+      nil
+      nil
+      nil
+      ((aggregate . 143)(attribute_reference . 48)(expression . 380)(factor . 
145)(name . 146)(primary . 149)(qualified_expression . 51)(relation_and_list . 
150)(relation_and_then_list . 151)(relation_or_list . 
152)(relation_or_else_list . 153)(relation_xor_list . 154)(relation . 
155)(selected_component . 52)(simple_expression . 156)(term . 157)(term_list . 
158)(unary_adding_operator . 159))
+      nil
+      nil
+      nil
+      nil
+      ((procedure_specification . 30)(subprogram_specification . 376))
+      nil
+      nil
+      nil
+      ((attribute_reference . 48)(name . 374)(qualified_expression . 
51)(selected_component . 52))
+      ((attribute_reference . 48)(name . 373)(qualified_expression . 
51)(selected_component . 52))
+      ((actual_parameter_part . 88)(aspect_specification_opt . 645))
+      ((actual_parameter_part . 88)(aspect_specification_opt . 644))
+      ((accept_statement . 618)(assignment_statement . 
619)(asynchronous_select . 620)(attribute_reference . 48)(block_statement . 
621)(case_statement . 622)(conditional_entry_call . 623)(delay_statement . 
624)(exit_statement . 625)(extended_return_statement . 
626)(handled_sequence_of_statements . 627)(if_statement . 628)(iteration_scheme 
. 629)(label_opt . 630)(loop_statement . 631)(name . 632)(pragma . 
633)(procedure_call_statement . 634)(qualified_expression . 51)(raise_statement 
. 635)(requeue_statement . 636)(selected_component . 52)(selective_accept . 
637)(select_statement . 638)(sequence_of_statements . 
639)(sequence_of_statements_opt . 640)(simple_return_statement . 641)(statement 
. 642)(timed_entry_call . 643))
+      ((aspect_specification_opt . 123))
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      ((iterator_specification . 594))
+      nil
+      nil
+      nil
+      nil
+      nil
+      ((aggregate . 143)(attribute_reference . 48)(factor . 145)(name . 
146)(primary . 149)(qualified_expression . 51)(relation . 
591)(selected_component . 52)(simple_expression . 156)(term . 157)(term_list . 
158)(unary_adding_operator . 159))
+      nil
+      ((aggregate . 143)(attribute_reference . 48)(factor . 145)(name . 
146)(primary . 149)(qualified_expression . 51)(relation . 
590)(selected_component . 52)(simple_expression . 156)(term . 157)(term_list . 
158)(unary_adding_operator . 159))
+      nil
+      nil
+      ((aggregate . 143)(attribute_reference . 48)(factor . 145)(name . 
146)(primary . 149)(qualified_expression . 51)(relation . 
589)(selected_component . 52)(simple_expression . 156)(term . 157)(term_list . 
158)(unary_adding_operator . 159))
+      nil
+      ((aggregate . 143)(attribute_reference . 48)(factor . 145)(name . 
146)(primary . 149)(qualified_expression . 51)(relation . 
588)(selected_component . 52)(simple_expression . 156)(term . 157)(term_list . 
158)(unary_adding_operator . 159))
+      nil
+      nil
+      nil
+      ((multiplying_operator . 341))
+      nil
+      nil
+      nil
+      ((aspect_specification_opt . 123))
+      ((aliased_opt . 581))
+      ((attribute_reference . 48)(name . 578)(qualified_expression . 
51)(selected_component . 52))
+      ((abstract_subprogram_declaration . 285)(aspect_clause . 286)(at_clause 
. 287)(body . 288)(body_stub . 289)(declaration . 290)(declarations . 
291)(declarative_part_opt . 577)(entry_declaration . 
293)(enumeration_representation_clause . 294)(exception_declaration . 
295)(full_type_declaration . 296)(generic_declaration . 
297)(generic_formal_part . 17)(generic_instantiation . 
298)(generic_package_declaration . 19)(generic_renaming_declaration . 
299)(generic_subprogram_declaration . 21)(identifier_list . 
300)(incomplete_type_declaration . 301)(null_procedure_declaration . 
302)(object_declaration . 303)(object_renaming_declaration . 
304)(overriding_indicator_opt . 305)(package_body . 306)(package_body_stub . 
307)(package_declaration . 308)(package_renaming_declaration . 
309)(package_specification . 28)(pragma . 310)(private_extension_declaration . 
311)(private_type_declaration . 312)(procedure_specification . 30)(proper_body 
. 313)(protected_body . 314)(protected_body_stub . 
315)(protected_type_declaration . 316)(record_representation_clause . 
317)(renaming_declaration . 318)(single_protected_declaration . 
319)(single_task_declaration . 320)(subprogram_body . 321)(subprogram_body_stub 
. 322)(subprogram_declaration . 323)(subprogram_renaming_declaration . 
324)(subtype_declaration . 325)(task_body . 326)(task_body_stub . 
327)(task_type_declaration . 328)(type_declaration . 329)(use_clause . 330))
+      nil
+      ((discriminant_part_opt . 576))
+      ((aspect_specification_opt . 574))
+      nil
+      nil
+      nil
+      ((aspect_specification_opt . 570))
+      nil
+      nil
+      ((attribute_reference . 48)(name . 567)(qualified_expression . 
51)(selected_component . 52))
+      ((actual_parameter_part . 88)(aspect_specification_opt . 105))
+      nil
+      nil
+      nil
+      nil
+      ((actual_parameter_part . 88))
+      ((access_definition . 561)(null_exclusion_opt . 562))
+      nil
+      nil
+      nil
+      ((actual_parameter_part . 88))
+      nil
+      nil
+      ((relational_operator . 555))
+      nil
+      nil
+      ((aggregate . 143)(attribute_reference . 48)(choice_relation . 
559)(factor . 145)(name . 146)(primary . 149)(qualified_expression . 
51)(selected_component . 52)(simple_expression . 435)(term . 157)(term_list . 
158)(unary_adding_operator . 159))
+      ((aggregate . 143)(attribute_reference . 48)(choice_relation . 
558)(factor . 145)(name . 146)(primary . 149)(qualified_expression . 
51)(selected_component . 52)(simple_expression . 435)(term . 157)(term_list . 
158)(unary_adding_operator . 159))
+      nil
+      ((aggregate . 143)(attribute_reference . 48)(choice_relation . 
557)(factor . 145)(name . 146)(primary . 149)(qualified_expression . 
51)(selected_component . 52)(simple_expression . 435)(term . 157)(term_list . 
158)(unary_adding_operator . 159))
+      nil
+      ((aggregate . 143)(attribute_reference . 48)(choice_relation . 
556)(factor . 145)(name . 146)(primary . 149)(qualified_expression . 
51)(selected_component . 52)(simple_expression . 435)(term . 157)(term_list . 
158)(unary_adding_operator . 159))
+      nil
+      nil
+      nil
+      nil
+      ((relational_operator . 555))
+      nil
+      nil
+      ((aggregate . 143)(attribute_reference . 48)(factor . 
145)(membership_choice_list . 553)(membership_choice . 453)(name . 179)(primary 
. 149)(qualified_expression . 51)(range . 454)(selected_component . 
52)(simple_expression . 455)(term . 157)(term_list . 158)(unary_adding_operator 
. 159))
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      ((access_definition . 544)(attribute_reference . 48)(name . 
545)(null_exclusion_opt . 201)(null_exclusion_opt_name . 
546)(qualified_expression . 51)(selected_component . 547))
+      ((discriminant_specification_opt . 541)(identifier_list . 244))
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      ((attribute_reference . 48)(name . 530)(qualified_expression . 
51)(selected_component . 52))
+      nil
+      nil
+      nil
+      ((aspect_specification_opt . 526))
+      nil
+      nil
+      nil
+      nil
+      ((aspect_specification_opt . 522))
+      nil
+      nil
+      nil
+      nil
+      ((aspect_specification_opt . 519))
+      ((attribute_reference . 48)(name . 518)(qualified_expression . 
51)(selected_component . 52))
+      ((actual_parameter_part . 88)(aspect_specification_opt . 517))
+      ((aggregate . 143)(attribute_reference . 48)(expression . 515)(factor . 
145)(name . 146)(primary . 149)(qualified_expression . 51)(relation_and_list . 
150)(relation_and_then_list . 151)(relation_or_list . 
152)(relation_or_else_list . 153)(relation_xor_list . 154)(relation . 
155)(selected_component . 52)(simple_expression . 156)(term . 157)(term_list . 
158)(unary_adding_operator . 159))
+      nil
+      ((actual_parameter_part . 88))
+      nil
+      nil
+      nil
+      ((attribute_reference . 48)(name . 513)(qualified_expression . 
51)(selected_component . 52))
+      nil
+      nil
+      nil
+      ((mode_opt . 509))
+      nil
+      ((aggregate . 143)(association_opt . 166)(association_list . 
508)(attribute_reference . 48)(choice_expression . 
168)(choice_relation_and_list . 169)(choice_relation_or_list . 
170)(choice_relation_xor_list . 171)(choice_relation_and_then_list . 
172)(choice_relation_or_else_list . 173)(choice_relation . 174)(discrete_choice 
. 175)(discrete_choice_list . 176)(expression . 177)(expression_opt . 
178)(factor . 145)(name . 179)(primary . 149)(qualified_expression . 51)(range 
. 221)(relation_and_list . 150)(relation_and_then_list . 151)(relation_or_list 
. 152)(relation_or_else_list . 153)(relation_xor_list . 154)(relation . 
155)(selected_component . 52)(simple_expression . 181)(term . 157)(term_list . 
158)(unary_adding_operator . 159))
+      nil
+      nil
+      nil
+      nil
+      nil
+      ((null_exclusion_opt . 777))
+      ((aggregate . 143)(attribute_reference . 48)(expression . 776)(factor . 
145)(name . 146)(primary . 149)(qualified_expression . 51)(relation_and_list . 
150)(relation_and_then_list . 151)(relation_or_list . 
152)(relation_or_else_list . 153)(relation_xor_list . 154)(relation . 
155)(selected_component . 52)(simple_expression . 156)(term . 157)(term_list . 
158)(unary_adding_operator . 159))
+      ((formal_part . 89)(parameter_and_result_profile . 775))
+      ((formal_part . 111)(parameter_profile_opt . 774))
+      ((actual_parameter_part . 88))
+      nil
+      ((aspect_specification_opt . 772))
+      ((aggregate . 143)(attribute_reference . 48)(expression . 771)(factor . 
145)(name . 146)(primary . 149)(qualified_expression . 51)(relation_and_list . 
150)(relation_and_then_list . 151)(relation_or_list . 
152)(relation_or_else_list . 153)(relation_xor_list . 154)(relation . 
155)(selected_component . 52)(simple_expression . 156)(term . 157)(term_list . 
158)(unary_adding_operator . 159))
+      nil
+      ((actual_parameter_part . 88)(formal_package_actual_part . 769))
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      ((actual_parameter_part . 88))
+      nil
+      nil
+      nil
+      nil
+      nil
+      ((aggregate . 143)(attribute_reference . 48)(discrete_subtype_definition 
. 751)(discrete_subtype_definition_list . 752)(factor . 
145)(index_subtype_definition . 753)(index_subtype_definition_list . 754)(name 
. 755)(primary . 149)(qualified_expression . 51)(range . 
756)(selected_component . 52)(simple_expression . 757)(subtype_indication . 
758)(term . 157)(term_list . 158)(unary_adding_operator . 159))
+      nil
+      ((attribute_reference . 48)(name . 748)(qualified_expression . 
51)(selected_component . 52))
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      ((actual_parameter_part . 88))
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      ((aggregate . 143)(attribute_reference . 48)(factor . 
145)(membership_choice . 742)(name . 179)(primary . 149)(qualified_expression . 
51)(range . 454)(selected_component . 52)(simple_expression . 455)(term . 
157)(term_list . 158)(unary_adding_operator . 159))
+      nil
+      ((aggregate . 143)(attribute_reference . 48)(expression . 741)(factor . 
145)(name . 146)(primary . 149)(qualified_expression . 51)(relation_and_list . 
150)(relation_and_then_list . 151)(relation_or_list . 
152)(relation_or_else_list . 153)(relation_xor_list . 154)(relation . 
155)(selected_component . 52)(simple_expression . 156)(term . 157)(term_list . 
158)(unary_adding_operator . 159))
+      ((aggregate . 143)(attribute_reference . 48)(factor . 145)(name . 
146)(primary . 149)(qualified_expression . 51)(selected_component . 
52)(simple_expression . 740)(term . 157)(term_list . 158)(unary_adding_operator 
. 159))
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      ((attribute_reference . 48)(name . 737)(qualified_expression . 
51)(selected_component . 52))
+      ((aggregate . 735)(record_rep . 736))
+      nil
+      ((aggregate . 143)(attribute_reference . 48)(expression . 732)(factor . 
145)(name . 146)(primary . 149)(qualified_expression . 51)(relation_and_list . 
150)(relation_and_then_list . 151)(relation_or_list . 
152)(relation_or_else_list . 153)(relation_xor_list . 154)(relation . 
155)(selected_component . 52)(simple_expression . 156)(term . 157)(term_list . 
158)(unary_adding_operator . 159))
+      ((attribute_reference . 48)(name . 731)(qualified_expression . 
51)(selected_component . 52))
+      ((actual_parameter_part . 88)(aspect_specification_opt . 160))
+      ((discriminant_part_opt . 729))
+      ((aspect_specification_opt . 695))
+      nil
+      ((attribute_reference . 48)(name . 725)(qualified_expression . 
51)(selected_component . 52)(subtype_indication . 726))
+      ((discriminant_part_opt . 723))
+      ((aspect_specification_opt . 694))
+      nil
+      nil
+      nil
+      nil
+      ((actual_parameter_part . 88))
+      nil
+      nil
+      ((constant_opt . 715))
+      nil
+      ((attribute_reference . 48)(name . 711)(qualified_expression . 
51)(selected_component . 52))
+      nil
+      ((formal_part . 111)(parameter_profile_opt . 709))
+      ((accept_statement . 618)(assignment_statement . 
619)(asynchronous_select . 620)(attribute_reference . 48)(block_statement . 
621)(case_statement . 622)(conditional_entry_call . 623)(delay_statement . 
624)(exit_statement . 625)(extended_return_statement . 
626)(handled_sequence_of_statements . 707)(if_statement . 628)(iteration_scheme 
. 629)(label_opt . 630)(loop_statement . 631)(name . 632)(pragma . 
633)(procedure_call_statement . 634)(qualified_expression . 51)(raise_statement 
. 635)(requeue_statement . 636)(selected_component . 52)(selective_accept . 
637)(select_statement . 638)(sequence_of_statements . 
639)(sequence_of_statements_opt . 640)(simple_return_statement . 641)(statement 
. 642)(timed_entry_call . 643))
+      ((attribute_reference . 48)(name . 705)(name_opt . 
706)(qualified_expression . 51)(selected_component . 52))
+      nil
+      nil
+      nil
+      nil
+      ((case_expression_alternative . 703)(case_expression_alternative_list . 
704))
+      nil
+      nil
+      ((aggregate . 143)(attribute_reference . 48)(expression . 697)(factor . 
145)(name . 146)(primary . 149)(qualified_expression . 51)(relation_and_list . 
150)(relation_and_then_list . 151)(relation_or_list . 
152)(relation_or_else_list . 153)(relation_xor_list . 154)(relation . 
155)(selected_component . 52)(simple_expression . 156)(term . 157)(term_list . 
158)(unary_adding_operator . 159))
+      ((aggregate . 143)(attribute_reference . 48)(expression . 696)(factor . 
145)(name . 146)(primary . 149)(qualified_expression . 51)(relation_and_list . 
150)(relation_and_then_list . 151)(relation_or_list . 
152)(relation_or_else_list . 153)(relation_xor_list . 154)(relation . 
155)(selected_component . 52)(simple_expression . 156)(term . 157)(term_list . 
158)(unary_adding_operator . 159))
+      ((aspect_specification_opt . 695))
+      ((aspect_specification_opt . 694))
+      nil
+      nil
+      nil
+      ((attribute_reference . 48)(name . 690)(qualified_expression . 
51)(selected_component . 52))
+      ((accept_statement . 618)(assignment_statement . 
619)(asynchronous_select . 620)(attribute_reference . 48)(block_statement . 
621)(case_statement . 622)(conditional_entry_call . 623)(delay_statement . 
624)(exit_statement . 625)(extended_return_statement . 
626)(handled_sequence_of_statements . 689)(if_statement . 628)(iteration_scheme 
. 629)(label_opt . 630)(loop_statement . 631)(name . 632)(pragma . 
633)(procedure_call_statement . 634)(qualified_expression . 51)(raise_statement 
. 635)(requeue_statement . 636)(selected_component . 52)(selective_accept . 
637)(select_statement . 638)(sequence_of_statements . 
639)(sequence_of_statements_opt . 640)(simple_return_statement . 641)(statement 
. 642)(timed_entry_call . 643))
+      ((aggregate . 143)(attribute_reference . 48)(expression . 688)(factor . 
145)(name . 146)(primary . 149)(qualified_expression . 51)(relation_and_list . 
150)(relation_and_then_list . 151)(relation_or_list . 
152)(relation_or_else_list . 153)(relation_xor_list . 154)(relation . 
155)(selected_component . 52)(simple_expression . 156)(term . 157)(term_list . 
158)(unary_adding_operator . 159))
+      ((abstract_subprogram_declaration . 285)(aspect_clause . 286)(at_clause 
. 287)(body . 288)(body_stub . 289)(declaration . 290)(declarations . 
291)(declarative_part_opt . 687)(entry_declaration . 
293)(enumeration_representation_clause . 294)(exception_declaration . 
295)(full_type_declaration . 296)(generic_declaration . 
297)(generic_formal_part . 17)(generic_instantiation . 
298)(generic_package_declaration . 19)(generic_renaming_declaration . 
299)(generic_subprogram_declaration . 21)(identifier_list . 
300)(incomplete_type_declaration . 301)(null_procedure_declaration . 
302)(object_declaration . 303)(object_renaming_declaration . 
304)(overriding_indicator_opt . 305)(package_body . 306)(package_body_stub . 
307)(package_declaration . 308)(package_renaming_declaration . 
309)(package_specification . 28)(pragma . 310)(private_extension_declaration . 
311)(private_type_declaration . 312)(procedure_specification . 30)(proper_body 
. 313)(protected_body . 314)(protected_body_stub . 
315)(protected_type_declaration . 316)(record_representation_clause . 
317)(renaming_declaration . 318)(single_protected_declaration . 
319)(single_task_declaration . 320)(subprogram_body . 321)(subprogram_body_stub 
. 322)(subprogram_declaration . 323)(subprogram_renaming_declaration . 
324)(subtype_declaration . 325)(task_body . 326)(task_body_stub . 
327)(task_type_declaration . 328)(type_declaration . 329)(use_clause . 330))
+      ((aggregate . 143)(attribute_reference . 48)(expression . 686)(factor . 
145)(name . 146)(primary . 149)(qualified_expression . 51)(relation_and_list . 
150)(relation_and_then_list . 151)(relation_or_list . 
152)(relation_or_else_list . 153)(relation_xor_list . 154)(relation . 
155)(selected_component . 52)(simple_expression . 156)(term . 157)(term_list . 
158)(unary_adding_operator . 159))
+      ((identifier_opt . 684))
+      ((iterator_specification . 681)(iterator_specification_opt . 682))
+      nil
+      ((aggregate . 143)(attribute_reference . 48)(expression . 
177)(expression_opt . 679)(factor . 145)(name . 146)(primary . 
149)(qualified_expression . 51)(relation_and_list . 150)(relation_and_then_list 
. 151)(relation_or_list . 152)(relation_or_else_list . 153)(relation_xor_list . 
154)(relation . 155)(selected_component . 52)(simple_expression . 156)(term . 
157)(term_list . 158)(unary_adding_operator . 159))
+      ((accept_statement . 618)(assignment_statement . 
619)(asynchronous_select . 620)(attribute_reference . 48)(block_statement . 
621)(case_statement . 622)(conditional_entry_call . 623)(delay_statement . 
624)(exit_statement . 625)(extended_return_statement . 626)(if_statement . 
628)(iteration_scheme . 629)(label_opt . 630)(loop_statement . 631)(name . 
632)(pragma . 633)(procedure_call_statement . 634)(qualified_expression . 
51)(raise_statement . 635)(requeue_statement . 636)(selected_component . 
52)(selective_accept . 637)(select_statement . 638)(sequence_of_statements . 
639)(sequence_of_statements_opt . 678)(simple_return_statement . 641)(statement 
. 642)(timed_entry_call . 643))
+      nil
+      ((attribute_reference . 48)(name . 676)(qualified_expression . 
51)(selected_component . 52))
+      ((attribute_reference . 48)(name . 674)(qualified_expression . 
51)(selected_component . 52))
+      ((aggregate . 143)(attribute_reference . 48)(expression . 
671)(extended_return_object_declaration . 
672)(extended_return_object_declaration_opt . 673)(factor . 145)(name . 
146)(primary . 149)(qualified_expression . 51)(relation_and_list . 
150)(relation_and_then_list . 151)(relation_or_list . 
152)(relation_or_else_list . 153)(relation_xor_list . 154)(relation . 
155)(selected_component . 52)(simple_expression . 156)(term . 157)(term_list . 
158)(unary_adding_operator . 159))
+      ((accept_statement . 659)(attribute_reference . 48)(delay_alternative . 
660)(delay_statement . 661)(entry_call_alternative . 662)(name . 
663)(procedure_call_statement . 664)(qualified_expression . 
51)(selected_component . 52)(select_alternative . 665)(select_alternative_list 
. 666)(select_alternative_list_opt . 667)(triggering_alternative . 668))
+      ((aggregate . 143)(attribute_reference . 48)(expression . 
177)(expression_opt . 656)(factor . 145)(name . 146)(primary . 
149)(qualified_expression . 51)(relation_and_list . 150)(relation_and_then_list 
. 151)(relation_or_list . 152)(relation_or_else_list . 153)(relation_xor_list . 
154)(relation . 155)(selected_component . 52)(simple_expression . 156)(term . 
157)(term_list . 158)(unary_adding_operator . 159))
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      ((accept_statement . 618)(assignment_statement . 
619)(asynchronous_select . 620)(attribute_reference . 48)(block_statement . 
621)(case_statement . 622)(compound_statement . 652)(conditional_entry_call . 
623)(delay_statement . 624)(exit_statement . 625)(extended_return_statement . 
626)(if_statement . 628)(iteration_scheme . 629)(loop_statement . 631)(name . 
632)(pragma . 633)(procedure_call_statement . 634)(qualified_expression . 
51)(raise_statement . 635)(requeue_statement . 636)(selected_component . 
52)(selective_accept . 637)(select_statement . 638)(simple_return_statement . 
641)(simple_statement . 653)(timed_entry_call . 643))
+      nil
+      ((actual_parameter_part . 88))
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      ((accept_statement . 618)(assignment_statement . 
619)(asynchronous_select . 620)(attribute_reference . 48)(block_statement . 
621)(case_statement . 622)(conditional_entry_call . 623)(delay_statement . 
624)(exit_statement . 625)(extended_return_statement . 626)(if_statement . 
628)(iteration_scheme . 629)(label_opt . 630)(loop_statement . 631)(name . 
632)(pragma . 633)(procedure_call_statement . 634)(qualified_expression . 
51)(raise_statement . 635)(requeue_statement . 636)(selected_component . 
52)(selective_accept . 637)(select_statement . 638)(simple_return_statement . 
641)(statement . 649)(timed_entry_call . 643))
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      ((exception_handler . 921)(exception_handler_list . 
922)(exception_handler_list_opt . 923))
+      nil
+      ((aggregate . 143)(attribute_reference . 48)(expression . 919)(factor . 
145)(name . 146)(primary . 149)(qualified_expression . 51)(relation_and_list . 
150)(relation_and_then_list . 151)(relation_or_list . 
152)(relation_or_else_list . 153)(relation_xor_list . 154)(relation . 
155)(selected_component . 52)(simple_expression . 156)(term . 157)(term_list . 
158)(unary_adding_operator . 159))
+      nil
+      nil
+      nil
+      ((accept_statement . 618)(assignment_statement . 
619)(asynchronous_select . 620)(attribute_reference . 48)(block_statement . 
621)(case_statement . 622)(conditional_entry_call . 623)(delay_statement . 
624)(exit_statement . 625)(extended_return_statement . 626)(if_statement . 
628)(iteration_scheme . 629)(label_opt . 630)(loop_statement . 631)(name . 
632)(pragma . 633)(procedure_call_statement . 634)(qualified_expression . 
51)(raise_statement . 635)(requeue_statement . 636)(selected_component . 
52)(selective_accept . 637)(select_statement . 638)(sequence_of_statements . 
639)(sequence_of_statements_opt . 918)(simple_return_statement . 641)(statement 
. 642)(timed_entry_call . 643))
+      ((attribute_reference . 48)(name . 705)(name_opt . 
917)(qualified_expression . 51)(selected_component . 52))
+      nil
+      nil
+      ((aggregate . 143)(attribute_reference . 48)(expression . 915)(factor . 
145)(name . 146)(primary . 149)(qualified_expression . 51)(relation_and_list . 
150)(relation_and_then_list . 151)(relation_or_list . 
152)(relation_or_else_list . 153)(relation_xor_list . 154)(relation . 
155)(selected_component . 52)(simple_expression . 156)(term . 157)(term_list . 
158)(unary_adding_operator . 159))
+      ((accept_statement . 618)(assignment_statement . 
619)(asynchronous_select . 620)(attribute_reference . 48)(block_statement . 
621)(case_statement . 622)(conditional_entry_call . 623)(delay_statement . 
624)(exit_statement . 625)(extended_return_statement . 626)(if_statement . 
628)(iteration_scheme . 629)(label_opt . 630)(loop_statement . 631)(name . 
632)(pragma . 633)(procedure_call_statement . 634)(qualified_expression . 
51)(raise_statement . 635)(requeue_statement . 636)(selected_component . 
52)(selective_accept . 637)(select_statement . 638)(sequence_of_statements . 
639)(sequence_of_statements_opt . 914)(simple_return_statement . 641)(statement 
. 642)(timed_entry_call . 643))
+      nil
+      ((accept_statement . 618)(assignment_statement . 
619)(asynchronous_select . 620)(attribute_reference . 48)(block_statement . 
621)(case_statement . 622)(conditional_entry_call . 623)(delay_statement . 
624)(exit_statement . 625)(extended_return_statement . 626)(if_statement . 
628)(iteration_scheme . 629)(label_opt . 630)(loop_statement . 631)(name . 
632)(pragma . 633)(procedure_call_statement . 634)(qualified_expression . 
51)(raise_statement . 635)(requeue_statement . 636)(selected_component . 
52)(selective_accept . 637)(select_statement . 638)(sequence_of_statements . 
639)(sequence_of_statements_opt . 913)(simple_return_statement . 641)(statement 
. 642)(timed_entry_call . 643))
+      nil
+      ((accept_statement . 618)(actual_parameter_part . 
88)(assignment_statement . 619)(asynchronous_select . 620)(attribute_reference 
. 48)(block_statement . 621)(case_statement . 622)(conditional_entry_call . 
623)(delay_statement . 624)(exit_statement . 625)(extended_return_statement . 
626)(if_statement . 628)(iteration_scheme . 629)(label_opt . 
630)(loop_statement . 631)(name . 632)(pragma . 633)(procedure_call_statement . 
634)(qualified_expression . 51)(raise_statement . 635)(requeue_statement . 
636)(selected_component . 52)(selective_accept . 637)(select_statement . 
638)(sequence_of_statements . 639)(sequence_of_statements_opt . 
910)(simple_return_statement . 641)(statement . 642)(timed_entry_call . 643))
+      ((accept_statement . 618)(assignment_statement . 
619)(asynchronous_select . 620)(attribute_reference . 48)(block_statement . 
621)(case_statement . 622)(conditional_entry_call . 623)(delay_statement . 
624)(exit_statement . 625)(extended_return_statement . 626)(if_statement . 
628)(iteration_scheme . 629)(label_opt . 630)(loop_statement . 631)(name . 
632)(pragma . 633)(procedure_call_statement . 634)(qualified_expression . 
51)(raise_statement . 635)(requeue_statement . 636)(selected_component . 
52)(selective_accept . 637)(select_statement . 638)(sequence_of_statements . 
639)(sequence_of_statements_opt . 909)(simple_return_statement . 641)(statement 
. 642)(timed_entry_call . 643))
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      ((actual_parameter_part . 88))
+      nil
+      ((actual_parameter_part . 88))
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      ((aggregate . 143)(attribute_reference . 48)(expression . 891)(factor . 
145)(name . 146)(primary . 149)(qualified_expression . 51)(relation_and_list . 
150)(relation_and_then_list . 151)(relation_or_list . 
152)(relation_or_else_list . 153)(relation_xor_list . 154)(relation . 
155)(selected_component . 52)(simple_expression . 156)(term . 157)(term_list . 
158)(unary_adding_operator . 159))
+      nil
+      nil
+      nil
+      nil
+      ((actual_parameter_part . 88))
+      ((actual_parameter_part . 884)(actual_parameter_part_opt . 885))
+      nil
+      nil
+      nil
+      nil
+      nil
+      ((elsif_expression_item . 878)(elsif_expression_list . 879))
+      ((aggregate . 143)(attribute_reference . 48)(expression . 875)(factor . 
145)(name . 146)(primary . 149)(qualified_expression . 51)(relation_and_list . 
150)(relation_and_then_list . 151)(relation_or_list . 
152)(relation_or_else_list . 153)(relation_xor_list . 154)(relation . 
155)(selected_component . 52)(simple_expression . 156)(term . 157)(term_list . 
158)(unary_adding_operator . 159))
+      ((attribute_reference . 48)(name . 725)(qualified_expression . 
51)(selected_component . 52)(subtype_indication . 874))
+      ((aggregate . 143)(attribute_reference . 48)(discrete_subtype_definition 
. 873)(factor . 145)(name . 865)(primary . 149)(qualified_expression . 
51)(range . 756)(selected_component . 52)(simple_expression . 
757)(subtype_indication . 758)(term . 157)(term_list . 
158)(unary_adding_operator . 159))
+      ((attribute_reference . 48)(name . 871)(qualified_expression . 
51)(selected_component . 52))
+      ((aggregate . 143)(attribute_reference . 48)(choice_expression . 
168)(choice_relation_and_list . 169)(choice_relation_or_list . 
170)(choice_relation_xor_list . 171)(choice_relation_and_then_list . 
172)(choice_relation_or_else_list . 173)(choice_relation . 174)(discrete_choice 
. 175)(discrete_choice_list . 869)(factor . 145)(name . 179)(primary . 
149)(qualified_expression . 51)(range . 221)(selected_component . 
52)(simple_expression . 448)(term . 157)(term_list . 158)(unary_adding_operator 
. 159))
+      nil
+      nil
+      ((actual_parameter_part . 88))
+      nil
+      nil
+      ((aggregate . 143)(attribute_reference . 48)(discrete_subtype_definition 
. 864)(factor . 145)(identifier_list . 203)(name . 865)(parameter_specification 
. 204)(parameter_specification_list . 205)(primary . 149)(qualified_expression 
. 51)(range . 756)(selected_component . 52)(simple_expression . 
757)(subtype_indication . 758)(term . 157)(term_list . 
158)(unary_adding_operator . 159))
+      ((aspect_specification_opt . 863))
+      ((aspect_specification_opt . 862))
+      ((actual_parameter_part . 88)(aspect_specification_opt . 861))
+      ((aspect_specification_opt . 860))
+      ((aspect_specification_opt . 859))
+      nil
+      ((access_definition . 856)(array_type_definition . 
857)(attribute_reference . 48)(name . 725)(null_exclusion_opt . 
201)(qualified_expression . 51)(selected_component . 52)(subtype_indication . 
858))
+      nil
+      ((aggregate . 143)(attribute_reference . 48)(expression . 854)(factor . 
145)(name . 146)(primary . 149)(qualified_expression . 51)(relation_and_list . 
150)(relation_and_then_list . 151)(relation_or_list . 
152)(relation_or_else_list . 153)(relation_xor_list . 154)(relation . 
155)(selected_component . 52)(simple_expression . 156)(term . 157)(term_list . 
158)(unary_adding_operator . 159))
+      ((attribute_reference . 48)(name . 853)(qualified_expression . 
51)(selected_component . 52))
+      ((abstract_limited_synchronized_opt . 843)(abstract_limited_opt . 
844)(abstract_tagged_limited_opt . 845)(access_definition . 
846)(array_type_definition . 847)(derived_type_definition . 
848)(enumeration_type_definition . 849)(interface_type_definition . 
850)(null_exclusion_opt . 201)(record_type_definition . 851)(type_definition . 
852))
+      nil
+      ((abstract_subprogram_declaration . 285)(aspect_clause . 286)(at_clause 
. 287)(body . 288)(body_stub . 289)(declaration . 290)(declarations . 
291)(declarative_part_opt . 830)(entry_declaration . 
293)(enumeration_representation_clause . 294)(exception_declaration . 
295)(full_type_declaration . 296)(generic_declaration . 
297)(generic_formal_part . 17)(generic_instantiation . 
298)(generic_package_declaration . 19)(generic_renaming_declaration . 
299)(generic_subprogram_declaration . 21)(identifier_list . 
300)(incomplete_type_declaration . 301)(null_procedure_declaration . 
302)(object_declaration . 303)(object_renaming_declaration . 
304)(overriding_indicator_opt . 305)(package_body . 306)(package_body_stub . 
307)(package_declaration . 308)(package_renaming_declaration . 
309)(package_specification . 28)(pragma . 310)(private_extension_declaration . 
311)(private_type_declaration . 312)(procedure_specification . 30)(proper_body 
. 313)(protected_body . 314)(protected_body_stub . 
315)(protected_type_declaration . 316)(record_representation_clause . 
317)(renaming_declaration . 318)(single_protected_declaration . 
319)(single_task_declaration . 320)(subprogram_body . 321)(subprogram_body_stub 
. 322)(subprogram_declaration . 323)(subprogram_renaming_declaration . 
324)(subtype_declaration . 325)(task_body . 326)(task_body_stub . 
327)(task_definition . 831)(task_type_declaration . 328)(type_declaration . 
329)(use_clause . 330))
+      nil
+      ((aspect_specification_opt . 827))
+      nil
+      ((actual_parameter_part . 88)(constraint . 794)(index_constraint . 795))
+      ((aspect_specification_opt . 824))
+      ((abstract_subprogram_declaration . 285)(aspect_clause . 286)(at_clause 
. 287)(body . 288)(body_stub . 289)(declaration . 290)(declarations . 
291)(declarative_part_opt . 822)(entry_declaration . 
293)(enumeration_representation_clause . 294)(exception_declaration . 
295)(full_type_declaration . 296)(generic_declaration . 
297)(generic_formal_part . 17)(generic_instantiation . 
298)(generic_package_declaration . 19)(generic_renaming_declaration . 
299)(generic_subprogram_declaration . 21)(identifier_list . 
300)(incomplete_type_declaration . 301)(null_procedure_declaration . 
302)(object_declaration . 303)(object_renaming_declaration . 
304)(overriding_indicator_opt . 305)(package_body . 306)(package_body_stub . 
307)(package_declaration . 308)(package_renaming_declaration . 
309)(package_specification . 28)(pragma . 310)(private_extension_declaration . 
311)(private_type_declaration . 312)(procedure_specification . 30)(proper_body 
. 313)(protected_body . 314)(protected_body_stub . 315)(protected_definition . 
823)(protected_type_declaration . 316)(record_representation_clause . 
317)(renaming_declaration . 318)(single_protected_declaration . 
319)(single_task_declaration . 320)(subprogram_body . 321)(subprogram_body_stub 
. 322)(subprogram_declaration . 323)(subprogram_renaming_declaration . 
324)(subtype_declaration . 325)(task_body . 326)(task_body_stub . 
327)(task_type_declaration . 328)(type_declaration . 329)(use_clause . 330))
+      nil
+      ((aspect_specification_opt . 819))
+      nil
+      ((actual_parameter_part . 88)(aspect_specification_opt . 817))
+      nil
+      ((aggregate . 143)(attribute_reference . 48)(expression . 815)(factor . 
145)(name . 146)(primary . 149)(qualified_expression . 51)(relation_and_list . 
150)(relation_and_then_list . 151)(relation_or_list . 
152)(relation_or_else_list . 153)(relation_xor_list . 154)(relation . 
155)(selected_component . 52)(simple_expression . 156)(term . 157)(term_list . 
158)(unary_adding_operator . 159))
+      ((mod_clause_opt . 814))
+      nil
+      nil
+      ((actual_parameter_part . 88))
+      ((attribute_reference . 48)(name . 809)(qualified_expression . 
51)(selected_component . 52))
+      ((attribute_reference . 48)(name . 808)(qualified_expression . 
51)(selected_component . 52))
+      nil
+      nil
+      nil
+      ((aggregate . 143)(attribute_reference . 48)(expression . 806)(factor . 
145)(name . 146)(primary . 149)(qualified_expression . 51)(relation_and_list . 
150)(relation_and_then_list . 151)(relation_or_list . 
152)(relation_or_else_list . 153)(relation_xor_list . 154)(relation . 
155)(selected_component . 52)(simple_expression . 156)(term . 157)(term_list . 
158)(unary_adding_operator . 159))
+      ((aggregate . 143)(attribute_reference . 48)(expression . 805)(factor . 
145)(name . 146)(primary . 149)(qualified_expression . 51)(relation_and_list . 
150)(relation_and_then_list . 151)(relation_or_list . 
152)(relation_or_else_list . 153)(relation_xor_list . 154)(relation . 
155)(selected_component . 52)(simple_expression . 156)(term . 157)(term_list . 
158)(unary_adding_operator . 159))
+      ((attribute_reference . 48)(name . 545)(qualified_expression . 
51)(selected_component . 804))
+      nil
+      ((attribute_reference . 48)(name . 802)(qualified_expression . 
51)(selected_component . 52))
+      ((actual_parameter_part . 88))
+      ((attribute_reference . 48)(name . 801)(qualified_expression . 
51)(selected_component . 52))
+      ((aggregate . 143)(attribute_reference . 48)(name . 146)(primary . 
275)(qualified_expression . 51)(selected_component . 52))
+      nil
+      nil
+      nil
+      nil
+      ((actual_parameter_part . 88)(constraint . 794)(index_constraint . 795))
+      nil
+      nil
+      nil
+      nil
+      nil
+      ((attribute_reference . 48)(interface_list . 790)(name . 
787)(qualified_expression . 51)(selected_component . 52))
+      ((attribute_reference . 48)(interface_list . 789)(name . 
787)(qualified_expression . 51)(selected_component . 52))
+      ((attribute_reference . 48)(interface_list . 788)(name . 
787)(qualified_expression . 51)(selected_component . 52))
+      nil
+      ((attribute_reference . 48)(interface_list . 786)(name . 
787)(qualified_expression . 51)(selected_component . 52))
+      nil
+      nil
+      ((aggregate . 143)(association_opt . 166)(association_list . 
167)(attribute_reference . 48)(choice_expression . 
168)(choice_relation_and_list . 169)(choice_relation_or_list . 
170)(choice_relation_xor_list . 171)(choice_relation_and_then_list . 
172)(choice_relation_or_else_list . 173)(choice_relation . 174)(discrete_choice 
. 175)(discrete_choice_list . 176)(expression . 177)(expression_opt . 
178)(factor . 145)(name . 179)(primary . 149)(qualified_expression . 51)(range 
. 180)(relation_and_list . 150)(relation_and_then_list . 151)(relation_or_list 
. 152)(relation_or_else_list . 153)(relation_xor_list . 154)(relation . 
155)(selected_component . 52)(simple_expression . 181)(term . 157)(term_list . 
158)(unary_adding_operator . 159))
+      ((aspect_specification_opt . 784))
+      nil
+      ((aspect_specification_opt . 783))
+      nil
+      ((identifier_list . 203)(parameter_specification . 
204)(parameter_specification_list . 205))
+      nil
+      nil
+      nil
+      ((attribute_reference . 48)(name . 781)(qualified_expression . 
51)(selected_component . 52))
+      nil
+      nil
+      nil
+      ((actual_parameter_part . 88))
+      nil
+      nil
+      nil
+      nil
+      nil
+      ((actual_parameter_part . 88))
+      nil
+      nil
+      nil
+      nil
+      ((aggregate . 143)(association_opt . 166)(association_list . 
167)(attribute_reference . 48)(choice_expression . 
168)(choice_relation_and_list . 169)(choice_relation_or_list . 
170)(choice_relation_xor_list . 171)(choice_relation_and_then_list . 
172)(choice_relation_or_else_list . 173)(choice_relation . 174)(discrete_choice 
. 175)(discrete_choice_list . 176)(discrete_subtype_definition . 
751)(discrete_subtype_definition_list . 1052)(expression . 177)(expression_opt 
. 178)(factor . 145)(name . 865)(primary . 149)(qualified_expression . 
51)(range . 1053)(relation_and_list . 150)(relation_and_then_list . 
151)(relation_or_list . 152)(relation_or_else_list . 153)(relation_xor_list . 
154)(relation . 155)(selected_component . 52)(simple_expression . 
181)(subtype_indication . 758)(term . 157)(term_list . 
158)(unary_adding_operator . 159))
+      ((aggregate . 143)(attribute_reference . 48)(factor . 145)(name . 
179)(primary . 149)(qualified_expression . 51)(range . 1023)(selected_component 
. 52)(simple_expression . 757)(term . 157)(term_list . 
158)(unary_adding_operator . 159))
+      nil
+      nil
+      ((attribute_reference . 48)(index_subtype_definition . 1048)(name . 
1049)(qualified_expression . 51)(selected_component . 52))
+      nil
+      ((aggregate . 143)(attribute_reference . 48)(discrete_subtype_definition 
. 1046)(factor . 145)(name . 865)(primary . 149)(qualified_expression . 
51)(range . 756)(selected_component . 52)(simple_expression . 
757)(subtype_indication . 758)(term . 157)(term_list . 
158)(unary_adding_operator . 159))
+      nil
+      ((attribute_reference . 48)(name . 1022)(qualified_expression . 
51)(selected_component . 52))
+      ((actual_parameter_part . 88))
+      ((actual_parameter_part . 88))
+      nil
+      nil
+      nil
+      nil
+      nil
+      ((actual_parameter_part . 88)(aspect_specification_opt . 1040))
+      ((actual_parameter_part . 88)(aspect_specification_opt . 1039))
+      ((attribute_reference . 48)(name . 1038)(qualified_expression . 
51)(selected_component . 52))
+      nil
+      nil
+      nil
+      ((component_clause . 1035)(component_clause_list . 1036))
+      nil
+      nil
+      nil
+      ((aspect_specification_opt . 1031))
+      nil
+      ((aspect_specification_opt . 1029))
+      ((attribute_reference . 48)(interface_list . 1028)(name . 
787)(qualified_expression . 51)(selected_component . 52))
+      nil
+      nil
+      nil
+      ((aggregate . 143)(attribute_reference . 48)(factor . 145)(name . 
179)(primary . 149)(qualified_expression . 51)(range . 1023)(selected_component 
. 52)(simple_expression . 757)(term . 157)(term_list . 
158)(unary_adding_operator . 159))
+      ((attribute_reference . 48)(name . 1022)(qualified_expression . 
51)(selected_component . 52))
+      nil
+      ((aspect_specification_opt . 1019))
+      ((attribute_reference . 48)(interface_list . 1018)(name . 
787)(qualified_expression . 51)(selected_component . 52))
+      nil
+      nil
+      nil
+      ((aggregate . 143)(attribute_reference . 48)(expression . 1012)(factor . 
145)(name . 146)(primary . 149)(qualified_expression . 51)(relation_and_list . 
150)(relation_and_then_list . 151)(relation_or_list . 
152)(relation_or_else_list . 153)(relation_xor_list . 154)(relation . 
155)(selected_component . 52)(simple_expression . 156)(term . 157)(term_list . 
158)(unary_adding_operator . 159))
+      ((aggregate . 143)(attribute_reference . 48)(expression . 1011)(factor . 
145)(name . 146)(primary . 149)(qualified_expression . 51)(relation_and_list . 
150)(relation_and_then_list . 151)(relation_or_list . 
152)(relation_or_else_list . 153)(relation_xor_list . 154)(relation . 
155)(selected_component . 52)(simple_expression . 156)(term . 157)(term_list . 
158)(unary_adding_operator . 159))
+      ((enumeration_literal . 1009)(enumeration_literal_list . 1010))
+      nil
+      ((aggregate . 143)(attribute_reference . 48)(expression . 1006)(factor . 
145)(name . 146)(primary . 149)(qualified_expression . 51)(relation_and_list . 
150)(relation_and_then_list . 151)(relation_or_list . 
152)(relation_or_else_list . 153)(relation_xor_list . 154)(relation . 
155)(selected_component . 52)(simple_expression . 156)(term . 157)(term_list . 
158)(unary_adding_operator . 159))
+      nil
+      ((aggregate . 143)(attribute_reference . 48)(factor . 145)(name . 
146)(primary . 149)(qualified_expression . 51)(selected_component . 
52)(simple_expression . 1004)(term . 157)(term_list . 
158)(unary_adding_operator . 159))
+      ((aspect_clause . 997)(at_clause . 287)(component_declaration . 
998)(component_item . 999)(component_list . 1000)(component_list_opt . 
1001)(enumeration_representation_clause . 294)(identifier_list . 
1002)(record_representation_clause . 317)(variant_part . 1003))
+      nil
+      nil
+      nil
+      nil
+      ((record_definition . 991))
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      ((aspect_specification_opt . 989))
+      ((actual_parameter_part . 88))
+      nil
+      nil
+      ((aspect_specification_opt . 986))
+      ((aspect_specification_opt . 984))
+      ((aspect_specification_opt . 982))
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      ((actual_parameter_part . 88)(constraint . 794)(index_constraint . 795))
+      ((attribute_reference . 48)(name . 705)(name_opt . 
974)(qualified_expression . 51)(selected_component . 52))
+      nil
+      ((case_expression_alternative . 973))
+      nil
+      ((attribute_reference . 48)(name . 971)(qualified_expression . 
51)(selected_component . 52))
+      ((actual_parameter_part . 88))
+      ((aggregate . 143)(attribute_reference . 48)(discrete_subtype_definition 
. 970)(factor . 145)(name . 865)(primary . 149)(qualified_expression . 
51)(range . 756)(selected_component . 52)(simple_expression . 
757)(subtype_indication . 758)(term . 157)(term_list . 
158)(unary_adding_operator . 159))
+      nil
+      nil
+      nil
+      ((aggregate . 143)(attribute_reference . 48)(expression . 968)(factor . 
145)(name . 146)(primary . 149)(qualified_expression . 51)(relation_and_list . 
150)(relation_and_then_list . 151)(relation_or_list . 
152)(relation_or_else_list . 153)(relation_xor_list . 154)(relation . 
155)(selected_component . 52)(simple_expression . 156)(term . 157)(term_list . 
158)(unary_adding_operator . 159))
+      ((aggregate . 143)(attribute_reference . 48)(expression . 967)(factor . 
145)(name . 146)(primary . 149)(qualified_expression . 51)(relation_and_list . 
150)(relation_and_then_list . 151)(relation_or_list . 
152)(relation_or_else_list . 153)(relation_xor_list . 154)(relation . 
155)(selected_component . 52)(simple_expression . 156)(term . 157)(term_list . 
158)(unary_adding_operator . 159))
+      nil
+      ((elsif_expression_item . 966))
+      ((aspect_clause . 957)(at_clause . 287)(entry_body . 
958)(enumeration_representation_clause . 294)(overriding_indicator_opt . 
959)(procedure_specification . 30)(protected_operation_item . 
960)(protected_operation_item_list . 961)(protected_operation_item_list_opt . 
962)(record_representation_clause . 317)(subprogram_body . 
963)(subprogram_declaration . 964))
+      ((abstract_subprogram_declaration . 285)(aspect_clause . 286)(at_clause 
. 287)(body . 288)(body_stub . 289)(declaration . 290)(declarations . 
291)(declarative_part_opt . 955)(entry_declaration . 
293)(enumeration_representation_clause . 294)(exception_declaration . 
295)(full_type_declaration . 296)(generic_declaration . 
297)(generic_formal_part . 17)(generic_instantiation . 
298)(generic_package_declaration . 19)(generic_renaming_declaration . 
299)(generic_subprogram_declaration . 21)(identifier_list . 
300)(incomplete_type_declaration . 301)(null_procedure_declaration . 
302)(object_declaration . 303)(object_renaming_declaration . 
304)(overriding_indicator_opt . 305)(package_body . 306)(package_body_stub . 
307)(package_declaration . 308)(package_renaming_declaration . 
309)(package_specification . 28)(pragma . 310)(private_extension_declaration . 
311)(private_type_declaration . 312)(procedure_specification . 30)(proper_body 
. 313)(protected_body . 314)(protected_body_stub . 
315)(protected_type_declaration . 316)(record_representation_clause . 
317)(renaming_declaration . 318)(single_protected_declaration . 
319)(single_task_declaration . 320)(subprogram_body . 321)(subprogram_body_stub 
. 322)(subprogram_declaration . 323)(subprogram_renaming_declaration . 
324)(subtype_declaration . 325)(task_body . 326)(task_body_stub . 
327)(task_type_declaration . 328)(type_declaration . 329)(use_clause . 330))
+      nil
+      ((aggregate . 143)(association_opt . 166)(association_list . 
167)(attribute_reference . 48)(choice_expression . 
168)(choice_relation_and_list . 169)(choice_relation_or_list . 
170)(choice_relation_xor_list . 171)(choice_relation_and_then_list . 
172)(choice_relation_or_else_list . 173)(choice_relation . 174)(discrete_choice 
. 175)(discrete_choice_list . 176)(expression . 177)(expression_opt . 
178)(factor . 145)(name . 179)(primary . 149)(qualified_expression . 51)(range 
. 221)(relation_and_list . 150)(relation_and_then_list . 151)(relation_or_list 
. 152)(relation_or_else_list . 153)(relation_xor_list . 154)(relation . 
155)(selected_component . 52)(simple_expression . 181)(term . 157)(term_list . 
158)(unary_adding_operator . 159))
+      nil
+      ((formal_part . 111)(parameter_profile_opt . 954))
+      nil
+      ((identifier_opt . 953))
+      ((case_statement_alternative . 951)(case_statement_alternative_list . 
952))
+      ((accept_statement . 618)(assignment_statement . 
619)(asynchronous_select . 620)(attribute_reference . 48)(block_statement . 
621)(case_statement . 622)(conditional_entry_call . 623)(delay_statement . 
624)(exit_statement . 625)(extended_return_statement . 
626)(handled_sequence_of_statements . 949)(if_statement . 628)(iteration_scheme 
. 629)(label_opt . 630)(loop_statement . 631)(name . 632)(pragma . 
633)(procedure_call_statement . 634)(qualified_expression . 51)(raise_statement 
. 635)(requeue_statement . 636)(selected_component . 52)(selective_accept . 
637)(select_statement . 638)(sequence_of_statements . 
639)(sequence_of_statements_opt . 640)(simple_return_statement . 641)(statement 
. 642)(timed_entry_call . 643))
+      nil
+      nil
+      nil
+      ((aggregate . 143)(attribute_reference . 48)(expression . 
177)(expression_opt . 947)(factor . 145)(name . 146)(primary . 
149)(qualified_expression . 51)(relation_and_list . 150)(relation_and_then_list 
. 151)(relation_or_list . 152)(relation_or_else_list . 153)(relation_xor_list . 
154)(relation . 155)(selected_component . 52)(simple_expression . 156)(term . 
157)(term_list . 158)(unary_adding_operator . 159))
+      nil
+      ((accept_statement . 618)(assignment_statement . 
619)(asynchronous_select . 620)(attribute_reference . 48)(block_statement . 
621)(case_statement . 622)(conditional_entry_call . 623)(delay_statement . 
624)(exit_statement . 625)(extended_return_statement . 626)(if_statement . 
628)(iteration_scheme . 629)(label_opt . 630)(loop_statement . 631)(name . 
632)(pragma . 633)(procedure_call_statement . 634)(qualified_expression . 
51)(raise_statement . 635)(requeue_statement . 636)(selected_component . 
52)(selective_accept . 637)(select_statement . 638)(sequence_of_statements . 
639)(sequence_of_statements_opt . 946)(simple_return_statement . 641)(statement 
. 642)(timed_entry_call . 643))
+      nil
+      nil
+      ((aggregate . 143)(attribute_reference . 48)(expression . 944)(factor . 
145)(name . 146)(primary . 149)(qualified_expression . 51)(relation_and_list . 
150)(relation_and_then_list . 151)(relation_or_list . 
152)(relation_or_else_list . 153)(relation_xor_list . 154)(relation . 
155)(selected_component . 52)(simple_expression . 156)(term . 157)(term_list . 
158)(unary_adding_operator . 159))
+      nil
+      nil
+      ((accept_statement . 618)(assignment_statement . 
619)(asynchronous_select . 620)(attribute_reference . 48)(block_statement . 
621)(case_statement . 622)(conditional_entry_call . 623)(delay_statement . 
624)(exit_statement . 625)(extended_return_statement . 
626)(handled_sequence_of_statements . 942)(if_statement . 628)(iteration_scheme 
. 629)(label_opt . 630)(loop_statement . 631)(name . 632)(pragma . 
633)(procedure_call_statement . 634)(qualified_expression . 51)(raise_statement 
. 635)(requeue_statement . 636)(selected_component . 52)(selective_accept . 
637)(select_statement . 638)(sequence_of_statements . 
639)(sequence_of_statements_opt . 640)(simple_return_statement . 641)(statement 
. 642)(timed_entry_call . 643))
+      nil
+      nil
+      ((aliased_opt . 941))
+      nil
+      ((accept_statement . 618)(assignment_statement . 
619)(asynchronous_select . 620)(attribute_reference . 48)(block_statement . 
621)(case_statement . 622)(conditional_entry_call . 623)(delay_statement . 
624)(exit_statement . 625)(extended_return_statement . 626)(if_statement . 
628)(iteration_scheme . 629)(label_opt . 630)(loop_statement . 631)(name . 
632)(pragma . 633)(procedure_call_statement . 634)(qualified_expression . 
51)(raise_statement . 635)(requeue_statement . 636)(selected_component . 
52)(selective_accept . 637)(select_statement . 638)(sequence_of_statements . 
639)(sequence_of_statements_opt . 939)(simple_return_statement . 641)(statement 
. 642)(timed_entry_call . 643))
+      nil
+      ((accept_statement . 659)(delay_alternative . 660)(delay_statement . 
935)(select_alternative . 937))
+      nil
+      nil
+      ((accept_statement . 618)(assignment_statement . 
619)(asynchronous_select . 620)(attribute_reference . 48)(block_statement . 
621)(case_statement . 622)(conditional_entry_call . 623)(delay_statement . 
624)(exit_statement . 625)(extended_return_statement . 626)(if_statement . 
628)(iteration_scheme . 629)(label_opt . 630)(loop_statement . 631)(name . 
632)(pragma . 633)(procedure_call_statement . 634)(qualified_expression . 
51)(raise_statement . 635)(requeue_statement . 636)(selected_component . 
52)(selective_accept . 637)(select_statement . 638)(sequence_of_statements . 
639)(sequence_of_statements_opt . 936)(simple_return_statement . 641)(statement 
. 642)(timed_entry_call . 643))
+      ((delay_alternative . 934)(delay_statement . 935))
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      ((attribute_reference . 48)(exception_choice . 
927)(exception_choice_list . 928)(name . 929)(qualified_expression . 
51)(selected_component . 52))
+      nil
+      ((exception_handler . 924))
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      ((actual_parameter_part . 88))
+      nil
+      nil
+      nil
+      ((accept_statement . 1155)(delay_alternative . 1156)(delay_statement . 
935))
+      nil
+      ((accept_statement . 618)(assignment_statement . 
619)(asynchronous_select . 620)(attribute_reference . 48)(block_statement . 
621)(case_statement . 622)(conditional_entry_call . 623)(delay_statement . 
624)(exit_statement . 625)(extended_return_statement . 626)(if_statement . 
628)(iteration_scheme . 629)(label_opt . 630)(loop_statement . 631)(name . 
632)(pragma . 633)(procedure_call_statement . 634)(qualified_expression . 
51)(raise_statement . 635)(requeue_statement . 636)(selected_component . 
52)(selective_accept . 637)(select_statement . 638)(sequence_of_statements . 
639)(sequence_of_statements_opt . 1152)(simple_return_statement . 
641)(statement . 642)(timed_entry_call . 643))
+      nil
+      nil
+      nil
+      nil
+      ((accept_statement . 618)(assignment_statement . 
619)(asynchronous_select . 620)(attribute_reference . 48)(block_statement . 
621)(case_statement . 622)(conditional_entry_call . 623)(delay_statement . 
624)(exit_statement . 625)(extended_return_statement . 626)(if_statement . 
628)(iteration_scheme . 629)(label_opt . 630)(loop_statement . 631)(name . 
632)(pragma . 633)(procedure_call_statement . 634)(qualified_expression . 
51)(raise_statement . 635)(requeue_statement . 636)(selected_component . 
52)(selective_accept . 637)(select_statement . 638)(sequence_of_statements . 
639)(sequence_of_statements_opt . 1148)(simple_return_statement . 
641)(statement . 642)(timed_entry_call . 643))
+      ((constant_opt . 1147))
+      nil
+      nil
+      nil
+      ((identifier_opt . 1143))
+      ((elsif_statement_item . 1141)(elsif_statement_list . 1142))
+      nil
+      nil
+      nil
+      ((aggregate . 143)(attribute_reference . 48)(choice_expression . 
168)(choice_relation_and_list . 169)(choice_relation_or_list . 
170)(choice_relation_xor_list . 171)(choice_relation_and_then_list . 
172)(choice_relation_or_else_list . 173)(choice_relation . 174)(discrete_choice 
. 175)(discrete_choice_list . 1135)(factor . 145)(name . 179)(primary . 
149)(qualified_expression . 51)(range . 221)(selected_component . 
52)(simple_expression . 448)(term . 157)(term_list . 158)(unary_adding_operator 
. 159))
+      nil
+      ((case_statement_alternative . 1134))
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      ((procedure_specification . 30)(subprogram_specification . 39))
+      nil
+      ((aspect_clause . 957)(at_clause . 287)(entry_body . 
958)(enumeration_representation_clause . 294)(overriding_indicator_opt . 
959)(procedure_specification . 30)(protected_operation_item . 
1127)(record_representation_clause . 317)(subprogram_body . 
963)(subprogram_declaration . 964))
+      nil
+      nil
+      nil
+      ((aggregate . 143)(attribute_reference . 48)(expression . 1125)(factor . 
145)(name . 146)(primary . 149)(qualified_expression . 51)(relation_and_list . 
150)(relation_and_then_list . 151)(relation_or_list . 
152)(relation_or_else_list . 153)(relation_xor_list . 154)(relation . 
155)(selected_component . 52)(simple_expression . 156)(term . 157)(term_list . 
158)(unary_adding_operator . 159))
+      nil
+      nil
+      nil
+      ((attribute_reference . 48)(name . 1123)(qualified_expression . 
51)(selected_component . 52))
+      nil
+      ((actual_parameter_part . 88))
+      ((aggregate . 143)(attribute_reference . 48)(expression . 1121)(factor . 
145)(name . 146)(primary . 149)(qualified_expression . 51)(relation_and_list . 
150)(relation_and_then_list . 151)(relation_or_list . 
152)(relation_or_else_list . 153)(relation_xor_list . 154)(relation . 
155)(selected_component . 52)(simple_expression . 156)(term . 157)(term_list . 
158)(unary_adding_operator . 159))
+      nil
+      nil
+      ((formal_part . 111)(parameter_profile_opt . 1119))
+      nil
+      nil
+      nil
+      nil
+      nil
+      ((aggregate . 143)(attribute_reference . 48)(expression . 1118)(factor . 
145)(name . 146)(primary . 149)(qualified_expression . 51)(relation_and_list . 
150)(relation_and_then_list . 151)(relation_or_list . 
152)(relation_or_else_list . 153)(relation_xor_list . 154)(relation . 
155)(selected_component . 52)(simple_expression . 156)(term . 157)(term_list . 
158)(unary_adding_operator . 159))
+      nil
+      ((aggregate . 143)(attribute_reference . 48)(expression . 1116)(factor . 
145)(name . 146)(primary . 149)(qualified_expression . 51)(relation_and_list . 
150)(relation_and_then_list . 151)(relation_or_list . 
152)(relation_or_else_list . 153)(relation_xor_list . 154)(relation . 
155)(selected_component . 52)(simple_expression . 156)(term . 157)(term_list . 
158)(unary_adding_operator . 159))
+      nil
+      ((aggregate . 143)(attribute_reference . 48)(expression . 1114)(factor . 
145)(name . 146)(primary . 149)(qualified_expression . 51)(relation_and_list . 
150)(relation_and_then_list . 151)(relation_or_list . 
152)(relation_or_else_list . 153)(relation_xor_list . 154)(relation . 
155)(selected_component . 52)(simple_expression . 156)(term . 157)(term_list . 
158)(unary_adding_operator . 159))
+      nil
+      ((attribute_reference . 48)(name . 1022)(qualified_expression . 
51)(selected_component . 52))
+      nil
+      nil
+      ((aspect_specification_opt . 1111))
+      nil
+      ((attribute_reference . 48)(name . 1110)(qualified_expression . 
51)(selected_component . 52))
+      ((attribute_reference . 48)(name . 725)(qualified_expression . 
51)(selected_component . 52)(subtype_indication . 1109))
+      nil
+      ((direct_name . 1108))
+      nil
+      nil
+      nil
+      nil
+      ((aspect_clause . 997)(at_clause . 287)(component_declaration . 
998)(component_item . 1103)(enumeration_representation_clause . 
294)(identifier_list . 1002)(record_representation_clause . 317)(variant_part . 
1104))
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      ((real_range_specification_opt . 1097))
+      ((real_range_specification_opt . 1096))
+      nil
+      nil
+      nil
+      ((identifier_opt . 1093))
+      ((abstract_subprogram_declaration . 285)(aspect_clause . 286)(at_clause 
. 287)(body . 288)(body_stub . 289)(declaration . 290)(declarations . 
291)(declarative_part_opt . 1092)(entry_declaration . 
293)(enumeration_representation_clause . 294)(exception_declaration . 
295)(full_type_declaration . 296)(generic_declaration . 
297)(generic_formal_part . 17)(generic_instantiation . 
298)(generic_package_declaration . 19)(generic_renaming_declaration . 
299)(generic_subprogram_declaration . 21)(identifier_list . 
300)(incomplete_type_declaration . 301)(null_procedure_declaration . 
302)(object_declaration . 303)(object_renaming_declaration . 
304)(overriding_indicator_opt . 305)(package_body . 306)(package_body_stub . 
307)(package_declaration . 308)(package_renaming_declaration . 
309)(package_specification . 28)(pragma . 310)(private_extension_declaration . 
311)(private_type_declaration . 312)(procedure_specification . 30)(proper_body 
. 313)(protected_body . 314)(protected_body_stub . 
315)(protected_type_declaration . 316)(record_representation_clause . 
317)(renaming_declaration . 318)(single_protected_declaration . 
319)(single_task_declaration . 320)(subprogram_body . 321)(subprogram_body_stub 
. 322)(subprogram_declaration . 323)(subprogram_renaming_declaration . 
324)(subtype_declaration . 325)(task_body . 326)(task_body_stub . 
327)(task_type_declaration . 328)(type_declaration . 329)(use_clause . 330))
+      nil
+      nil
+      nil
+      ((abstract_subprogram_declaration . 285)(aspect_clause . 286)(at_clause 
. 287)(body . 288)(body_stub . 289)(declaration . 290)(declarations . 
291)(declarative_part_opt . 830)(entry_declaration . 
293)(enumeration_representation_clause . 294)(exception_declaration . 
295)(full_type_declaration . 296)(generic_declaration . 
297)(generic_formal_part . 17)(generic_instantiation . 
298)(generic_package_declaration . 19)(generic_renaming_declaration . 
299)(generic_subprogram_declaration . 21)(identifier_list . 
300)(incomplete_type_declaration . 301)(null_procedure_declaration . 
302)(object_declaration . 303)(object_renaming_declaration . 
304)(overriding_indicator_opt . 305)(package_body . 306)(package_body_stub . 
307)(package_declaration . 308)(package_renaming_declaration . 
309)(package_specification . 28)(pragma . 310)(private_extension_declaration . 
311)(private_type_declaration . 312)(procedure_specification . 30)(proper_body 
. 313)(protected_body . 314)(protected_body_stub . 
315)(protected_type_declaration . 316)(record_representation_clause . 
317)(renaming_declaration . 318)(single_protected_declaration . 
319)(single_task_declaration . 320)(subprogram_body . 321)(subprogram_body_stub 
. 322)(subprogram_declaration . 323)(subprogram_renaming_declaration . 
324)(subtype_declaration . 325)(task_body . 326)(task_body_stub . 
327)(task_definition . 1089)(task_type_declaration . 328)(type_declaration . 
329)(use_clause . 330))
+      ((actual_parameter_part . 88)(constraint . 1087)(index_constraint . 795))
+      nil
+      nil
+      nil
+      ((identifier_opt . 1086))
+      ((abstract_subprogram_declaration . 285)(aspect_clause . 286)(at_clause 
. 287)(body . 288)(body_stub . 289)(declaration . 290)(declarations . 
291)(declarative_part_opt . 1085)(entry_declaration . 
293)(enumeration_representation_clause . 294)(exception_declaration . 
295)(full_type_declaration . 296)(generic_declaration . 
297)(generic_formal_part . 17)(generic_instantiation . 
298)(generic_package_declaration . 19)(generic_renaming_declaration . 
299)(generic_subprogram_declaration . 21)(identifier_list . 
300)(incomplete_type_declaration . 301)(null_procedure_declaration . 
302)(object_declaration . 303)(object_renaming_declaration . 
304)(overriding_indicator_opt . 305)(package_body . 306)(package_body_stub . 
307)(package_declaration . 308)(package_renaming_declaration . 
309)(package_specification . 28)(pragma . 310)(private_extension_declaration . 
311)(private_type_declaration . 312)(procedure_specification . 30)(proper_body 
. 313)(protected_body . 314)(protected_body_stub . 
315)(protected_type_declaration . 316)(record_representation_clause . 
317)(renaming_declaration . 318)(single_protected_declaration . 
319)(single_task_declaration . 320)(subprogram_body . 321)(subprogram_body_stub 
. 322)(subprogram_declaration . 323)(subprogram_renaming_declaration . 
324)(subtype_declaration . 325)(task_body . 326)(task_body_stub . 
327)(task_type_declaration . 328)(type_declaration . 329)(use_clause . 330))
+      nil
+      nil
+      ((abstract_subprogram_declaration . 285)(aspect_clause . 286)(at_clause 
. 287)(body . 288)(body_stub . 289)(declaration . 290)(declarations . 
291)(declarative_part_opt . 822)(entry_declaration . 
293)(enumeration_representation_clause . 294)(exception_declaration . 
295)(full_type_declaration . 296)(generic_declaration . 
297)(generic_formal_part . 17)(generic_instantiation . 
298)(generic_package_declaration . 19)(generic_renaming_declaration . 
299)(generic_subprogram_declaration . 21)(identifier_list . 
300)(incomplete_type_declaration . 301)(null_procedure_declaration . 
302)(object_declaration . 303)(object_renaming_declaration . 
304)(overriding_indicator_opt . 305)(package_body . 306)(package_body_stub . 
307)(package_declaration . 308)(package_renaming_declaration . 
309)(package_specification . 28)(pragma . 310)(private_extension_declaration . 
311)(private_type_declaration . 312)(procedure_specification . 30)(proper_body 
. 313)(protected_body . 314)(protected_body_stub . 315)(protected_definition . 
1082)(protected_type_declaration . 316)(record_representation_clause . 
317)(renaming_declaration . 318)(single_protected_declaration . 
319)(single_task_declaration . 320)(subprogram_body . 321)(subprogram_body_stub 
. 322)(subprogram_declaration . 323)(subprogram_renaming_declaration . 
324)(subtype_declaration . 325)(task_body . 326)(task_body_stub . 
327)(task_type_declaration . 328)(type_declaration . 329)(use_clause . 330))
+      nil
+      nil
+      nil
+      nil
+      nil
+      ((component_clause . 1078))
+      ((aggregate . 143)(attribute_reference . 48)(expression . 1076)(factor . 
145)(name . 146)(primary . 149)(qualified_expression . 51)(relation_and_list . 
150)(relation_and_then_list . 151)(relation_or_list . 
152)(relation_or_else_list . 153)(relation_xor_list . 154)(relation . 
155)(selected_component . 52)(simple_expression . 156)(term . 157)(term_list . 
158)(unary_adding_operator . 159))
+      ((actual_parameter_part . 88)(aspect_specification_opt . 1075))
+      nil
+      nil
+      ((attribute_reference . 48)(interface_list . 1072)(name . 
787)(qualified_expression . 51)(selected_component . 52))
+      nil
+      ((attribute_reference . 48)(interface_list . 1070)(name . 
787)(qualified_expression . 51)(selected_component . 52))
+      nil
+      ((access_definition . 1065)(attribute_reference . 
48)(component_definition . 1068)(name . 725)(null_exclusion_opt . 
201)(qualified_expression . 51)(selected_component . 52)(subtype_indication . 
1067))
+      nil
+      ((access_definition . 1065)(attribute_reference . 
48)(component_definition . 1066)(name . 725)(null_exclusion_opt . 
201)(qualified_expression . 51)(selected_component . 52)(subtype_indication . 
1067))
+      nil
+      ((actual_parameter_part . 88))
+      nil
+      ((aggregate . 143)(attribute_reference . 48)(name . 146)(primary . 
275)(qualified_expression . 51)(selected_component . 52))
+      nil
+      nil
+      ((attribute_reference . 48)(name . 1060)(qualified_expression . 
51)(selected_component . 52))
+      nil
+      nil
+      nil
+      ((aggregate . 143)(attribute_reference . 48)(expression . 1059)(factor . 
145)(name . 146)(primary . 149)(qualified_expression . 51)(relation_and_list . 
150)(relation_and_then_list . 151)(relation_or_list . 
152)(relation_or_else_list . 153)(relation_xor_list . 154)(relation . 
155)(selected_component . 52)(simple_expression . 156)(term . 157)(term_list . 
158)(unary_adding_operator . 159))
+      nil
+      ((actual_parameter_part . 88))
+      nil
+      ((attribute_reference . 48)(name . 1224)(qualified_expression . 
51)(selected_component . 52))
+      nil
+      ((access_definition . 1222)(attribute_reference . 48)(name . 
725)(null_exclusion_opt . 201)(qualified_expression . 51)(selected_component . 
52)(subtype_indication . 1223))
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      ((aggregate . 143)(attribute_reference . 48)(factor . 145)(name . 
146)(primary . 149)(qualified_expression . 51)(selected_component . 
52)(simple_expression . 1216)(term . 157)(term_list . 
158)(unary_adding_operator . 159))
+      nil
+      ((attribute_reference . 48)(interface_list . 1215)(name . 
787)(qualified_expression . 51)(selected_component . 52))
+      nil
+      nil
+      ((abstract_subprogram_declaration . 285)(aspect_clause . 286)(at_clause 
. 287)(body . 288)(body_stub . 289)(declaration . 290)(declarations . 
291)(declarative_part_opt . 822)(entry_declaration . 
293)(enumeration_representation_clause . 294)(exception_declaration . 
295)(full_type_declaration . 296)(generic_declaration . 
297)(generic_formal_part . 17)(generic_instantiation . 
298)(generic_package_declaration . 19)(generic_renaming_declaration . 
299)(generic_subprogram_declaration . 21)(identifier_list . 
300)(incomplete_type_declaration . 301)(null_procedure_declaration . 
302)(object_declaration . 303)(object_renaming_declaration . 
304)(overriding_indicator_opt . 305)(package_body . 306)(package_body_stub . 
307)(package_declaration . 308)(package_renaming_declaration . 
309)(package_specification . 28)(pragma . 310)(private_extension_declaration . 
311)(private_type_declaration . 312)(procedure_specification . 30)(proper_body 
. 313)(protected_body . 314)(protected_body_stub . 315)(protected_definition . 
1213)(protected_type_declaration . 316)(record_representation_clause . 
317)(renaming_declaration . 318)(single_protected_declaration . 
319)(single_task_declaration . 320)(subprogram_body . 321)(subprogram_body_stub 
. 322)(subprogram_declaration . 323)(subprogram_renaming_declaration . 
324)(subtype_declaration . 325)(task_body . 326)(task_body_stub . 
327)(task_type_declaration . 328)(type_declaration . 329)(use_clause . 330))
+      nil
+      nil
+      nil
+      ((attribute_reference . 48)(interface_list . 1211)(name . 
787)(qualified_expression . 51)(selected_component . 52))
+      nil
+      nil
+      ((abstract_subprogram_declaration . 285)(aspect_clause . 286)(at_clause 
. 287)(body . 288)(body_stub . 289)(declaration . 290)(declarations . 
291)(declarative_part_opt . 830)(entry_declaration . 
293)(enumeration_representation_clause . 294)(exception_declaration . 
295)(full_type_declaration . 296)(generic_declaration . 
297)(generic_formal_part . 17)(generic_instantiation . 
298)(generic_package_declaration . 19)(generic_renaming_declaration . 
299)(generic_subprogram_declaration . 21)(identifier_list . 
300)(incomplete_type_declaration . 301)(null_procedure_declaration . 
302)(object_declaration . 303)(object_renaming_declaration . 
304)(overriding_indicator_opt . 305)(package_body . 306)(package_body_stub . 
307)(package_declaration . 308)(package_renaming_declaration . 
309)(package_specification . 28)(pragma . 310)(private_extension_declaration . 
311)(private_type_declaration . 312)(procedure_specification . 30)(proper_body 
. 313)(protected_body . 314)(protected_body_stub . 
315)(protected_type_declaration . 316)(record_representation_clause . 
317)(renaming_declaration . 318)(single_protected_declaration . 
319)(single_task_declaration . 320)(subprogram_body . 321)(subprogram_body_stub 
. 322)(subprogram_declaration . 323)(subprogram_renaming_declaration . 
324)(subtype_declaration . 325)(task_body . 326)(task_body_stub . 
327)(task_definition . 1209)(task_type_declaration . 328)(type_declaration . 
329)(use_clause . 330))
+      nil
+      nil
+      ((aggregate . 143)(attribute_reference . 48)(expression . 1207)(factor . 
145)(name . 146)(primary . 149)(qualified_expression . 51)(relation_and_list . 
150)(relation_and_then_list . 151)(relation_or_list . 
152)(relation_or_else_list . 153)(relation_xor_list . 154)(relation . 
155)(selected_component . 52)(simple_expression . 156)(term . 157)(term_list . 
158)(unary_adding_operator . 159))
+      ((aggregate . 143)(attribute_reference . 48)(factor . 145)(name . 
146)(primary . 149)(qualified_expression . 51)(selected_component . 
52)(simple_expression . 1206)(term . 157)(term_list . 
158)(unary_adding_operator . 159))
+      nil
+      nil
+      ((enumeration_literal . 1205))
+      nil
+      ((aggregate . 143)(attribute_reference . 48)(factor . 145)(name . 
146)(primary . 149)(qualified_expression . 51)(selected_component . 
52)(simple_expression . 1204)(term . 157)(term_list . 
158)(unary_adding_operator . 159))
+      ((access_definition . 1065)(attribute_reference . 
48)(component_definition . 1203)(name . 725)(null_exclusion_opt . 
201)(qualified_expression . 51)(selected_component . 52)(subtype_indication . 
1067))
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      ((and_interface_list_opt . 1200))
+      ((actual_parameter_part . 88)(and_interface_list_opt . 1199))
+      nil
+      nil
+      nil
+      ((aspect_specification_opt . 1196))
+      nil
+      ((aspect_specification_opt . 1195))
+      nil
+      ((aspect_specification_opt . 1194))
+      ((aspect_specification_opt . 1193))
+      nil
+      nil
+      ((attribute_reference . 48)(name . 1192)(qualified_expression . 
51)(selected_component . 52))
+      ((actual_parameter_part . 88))
+      ((aggregate . 143)(attribute_reference . 48)(expression . 1191)(factor . 
145)(name . 146)(primary . 149)(qualified_expression . 51)(relation_and_list . 
150)(relation_and_then_list . 151)(relation_or_list . 
152)(relation_or_else_list . 153)(relation_xor_list . 154)(relation . 
155)(selected_component . 52)(simple_expression . 156)(term . 157)(term_list . 
158)(unary_adding_operator . 159))
+      nil
+      ((identifier_opt . 1190))
+      nil
+      ((entry_body_formal_part . 1188)(formal_part . 
111)(parameter_profile_opt . 1189))
+      ((accept_statement . 618)(assignment_statement . 
619)(asynchronous_select . 620)(attribute_reference . 48)(block_statement . 
621)(case_statement . 622)(conditional_entry_call . 623)(delay_statement . 
624)(exit_statement . 625)(extended_return_statement . 
626)(handled_sequence_of_statements . 1186)(if_statement . 
628)(iteration_scheme . 629)(label_opt . 630)(loop_statement . 631)(name . 
632)(pragma . 633)(procedure_call_statement . 634)(qualified_expression . 
51)(raise_statement . 635)(requeue_statement . 636)(selected_component . 
52)(selective_accept . 637)(select_statement . 638)(sequence_of_statements . 
639)(sequence_of_statements_opt . 640)(simple_return_statement . 641)(statement 
. 642)(timed_entry_call . 643))
+      nil
+      ((accept_statement . 618)(assignment_statement . 
619)(asynchronous_select . 620)(attribute_reference . 48)(block_statement . 
621)(case_statement . 622)(conditional_entry_call . 623)(delay_statement . 
624)(exit_statement . 625)(extended_return_statement . 
626)(handled_sequence_of_statements . 1185)(if_statement . 
628)(iteration_scheme . 629)(label_opt . 630)(loop_statement . 631)(name . 
632)(pragma . 633)(procedure_call_statement . 634)(qualified_expression . 
51)(raise_statement . 635)(requeue_statement . 636)(selected_component . 
52)(selective_accept . 637)(select_statement . 638)(sequence_of_statements . 
639)(sequence_of_statements_opt . 640)(simple_return_statement . 641)(statement 
. 642)(timed_entry_call . 643))
+      nil
+      nil
+      nil
+      nil
+      ((identifier_opt . 1182))
+      nil
+      ((accept_statement . 618)(assignment_statement . 
619)(asynchronous_select . 620)(attribute_reference . 48)(block_statement . 
621)(case_statement . 622)(conditional_entry_call . 623)(delay_statement . 
624)(exit_statement . 625)(extended_return_statement . 626)(if_statement . 
628)(iteration_scheme . 629)(label_opt . 630)(loop_statement . 631)(name . 
632)(pragma . 633)(procedure_call_statement . 634)(qualified_expression . 
51)(raise_statement . 635)(requeue_statement . 636)(selected_component . 
52)(selective_accept . 637)(select_statement . 638)(sequence_of_statements . 
639)(sequence_of_statements_opt . 1181)(simple_return_statement . 
641)(statement . 642)(timed_entry_call . 643))
+      ((aggregate . 143)(attribute_reference . 48)(expression . 
177)(expression_opt . 1180)(factor . 145)(name . 146)(primary . 
149)(qualified_expression . 51)(relation_and_list . 150)(relation_and_then_list 
. 151)(relation_or_list . 152)(relation_or_else_list . 153)(relation_xor_list . 
154)(relation . 155)(selected_component . 52)(simple_expression . 156)(term . 
157)(term_list . 158)(unary_adding_operator . 159))
+      nil
+      nil
+      ((elsif_statement_item . 1178))
+      nil
+      nil
+      nil
+      nil
+      ((access_definition . 1171)(attribute_reference . 48)(name . 
725)(null_exclusion_opt . 201)(qualified_expression . 
51)(return_subtype_indication . 1172)(selected_component . 
52)(subtype_indication . 1173))
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      ((accept_statement . 618)(assignment_statement . 
619)(asynchronous_select . 620)(attribute_reference . 48)(block_statement . 
621)(case_statement . 622)(conditional_entry_call . 623)(delay_statement . 
624)(exit_statement . 625)(extended_return_statement . 626)(if_statement . 
628)(iteration_scheme . 629)(label_opt . 630)(loop_statement . 631)(name . 
632)(pragma . 633)(procedure_call_statement . 634)(qualified_expression . 
51)(raise_statement . 635)(requeue_statement . 636)(selected_component . 
52)(selective_accept . 637)(select_statement . 638)(sequence_of_statements . 
639)(sequence_of_statements_opt . 1165)(simple_return_statement . 
641)(statement . 642)(timed_entry_call . 643))
+      nil
+      ((identifier_opt . 1164))
+      ((attribute_reference . 48)(exception_choice . 1163)(name . 
929)(qualified_expression . 51)(selected_component . 52))
+      ((accept_statement . 618)(assignment_statement . 
619)(asynchronous_select . 620)(attribute_reference . 48)(block_statement . 
621)(case_statement . 622)(conditional_entry_call . 623)(delay_statement . 
624)(exit_statement . 625)(extended_return_statement . 626)(if_statement . 
628)(iteration_scheme . 629)(label_opt . 630)(loop_statement . 631)(name . 
632)(pragma . 633)(procedure_call_statement . 634)(qualified_expression . 
51)(raise_statement . 635)(requeue_statement . 636)(selected_component . 
52)(selective_accept . 637)(select_statement . 638)(sequence_of_statements . 
639)(sequence_of_statements_opt . 1162)(simple_return_statement . 
641)(statement . 642)(timed_entry_call . 643))
+      ((attribute_reference . 48)(exception_choice . 
927)(exception_choice_list . 1161)(name . 929)(qualified_expression . 
51)(selected_component . 52))
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      ((accept_statement . 618)(assignment_statement . 
619)(asynchronous_select . 620)(attribute_reference . 48)(block_statement . 
621)(case_statement . 622)(conditional_entry_call . 623)(delay_statement . 
624)(exit_statement . 625)(extended_return_statement . 626)(if_statement . 
628)(iteration_scheme . 629)(label_opt . 630)(loop_statement . 631)(name . 
632)(pragma . 633)(procedure_call_statement . 634)(qualified_expression . 
51)(raise_statement . 635)(requeue_statement . 636)(selected_component . 
52)(selective_accept . 637)(select_statement . 638)(sequence_of_statements . 
639)(sequence_of_statements_opt . 1260)(simple_return_statement . 
641)(statement . 642)(timed_entry_call . 643))
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      ((accept_statement . 618)(assignment_statement . 
619)(asynchronous_select . 620)(attribute_reference . 48)(block_statement . 
621)(case_statement . 622)(conditional_entry_call . 623)(delay_statement . 
624)(exit_statement . 625)(extended_return_statement . 626)(if_statement . 
628)(iteration_scheme . 629)(label_opt . 630)(loop_statement . 631)(name . 
632)(pragma . 633)(procedure_call_statement . 634)(qualified_expression . 
51)(raise_statement . 635)(requeue_statement . 636)(selected_component . 
52)(selective_accept . 637)(select_statement . 638)(sequence_of_statements . 
639)(sequence_of_statements_opt . 1254)(simple_return_statement . 
641)(statement . 642)(timed_entry_call . 643))
+      nil
+      nil
+      nil
+      ((identifier_list . 203)(parameter_specification . 
204)(parameter_specification_list . 205))
+      nil
+      nil
+      nil
+      nil
+      ((actual_parameter_part . 88))
+      nil
+      nil
+      nil
+      nil
+      nil
+      ((attribute_reference . 48)(interface_list . 1243)(name . 
787)(qualified_expression . 51)(selected_component . 52))
+      nil
+      nil
+      ((variant_list . 1239)(variant . 1240))
+      nil
+      ((aspect_specification_opt . 1237))
+      nil
+      nil
+      nil
+      ((real_range_specification_opt . 1234))
+      ((identifier_opt . 1233))
+      nil
+      nil
+      nil
+      ((identifier_opt . 1230))
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      ((actual_parameter_part . 88)(constraint . 1087)(index_constraint . 795))
+      nil
+      nil
+      ((aggregate . 143)(attribute_reference . 48)(factor . 145)(name . 
146)(primary . 149)(qualified_expression . 51)(selected_component . 
52)(simple_expression . 1290)(term . 157)(term_list . 
158)(unary_adding_operator . 159))
+      ((abstract_subprogram_declaration . 285)(aspect_clause . 286)(at_clause 
. 287)(body . 288)(body_stub . 289)(declaration . 290)(declarations . 
291)(declarative_part_opt . 822)(entry_declaration . 
293)(enumeration_representation_clause . 294)(exception_declaration . 
295)(full_type_declaration . 296)(generic_declaration . 
297)(generic_formal_part . 17)(generic_instantiation . 
298)(generic_package_declaration . 19)(generic_renaming_declaration . 
299)(generic_subprogram_declaration . 21)(identifier_list . 
300)(incomplete_type_declaration . 301)(null_procedure_declaration . 
302)(object_declaration . 303)(object_renaming_declaration . 
304)(overriding_indicator_opt . 305)(package_body . 306)(package_body_stub . 
307)(package_declaration . 308)(package_renaming_declaration . 
309)(package_specification . 28)(pragma . 310)(private_extension_declaration . 
311)(private_type_declaration . 312)(procedure_specification . 30)(proper_body 
. 313)(protected_body . 314)(protected_body_stub . 315)(protected_definition . 
1289)(protected_type_declaration . 316)(record_representation_clause . 
317)(renaming_declaration . 318)(single_protected_declaration . 
319)(single_task_declaration . 320)(subprogram_body . 321)(subprogram_body_stub 
. 322)(subprogram_declaration . 323)(subprogram_renaming_declaration . 
324)(subtype_declaration . 325)(task_body . 326)(task_body_stub . 
327)(task_type_declaration . 328)(type_declaration . 329)(use_clause . 330))
+      nil
+      nil
+      ((abstract_subprogram_declaration . 285)(aspect_clause . 286)(at_clause 
. 287)(body . 288)(body_stub . 289)(declaration . 290)(declarations . 
291)(declarative_part_opt . 830)(entry_declaration . 
293)(enumeration_representation_clause . 294)(exception_declaration . 
295)(full_type_declaration . 296)(generic_declaration . 
297)(generic_formal_part . 17)(generic_instantiation . 
298)(generic_package_declaration . 19)(generic_renaming_declaration . 
299)(generic_subprogram_declaration . 21)(identifier_list . 
300)(incomplete_type_declaration . 301)(null_procedure_declaration . 
302)(object_declaration . 303)(object_renaming_declaration . 
304)(overriding_indicator_opt . 305)(package_body . 306)(package_body_stub . 
307)(package_declaration . 308)(package_renaming_declaration . 
309)(package_specification . 28)(pragma . 310)(private_extension_declaration . 
311)(private_type_declaration . 312)(procedure_specification . 30)(proper_body 
. 313)(protected_body . 314)(protected_body_stub . 
315)(protected_type_declaration . 316)(record_representation_clause . 
317)(renaming_declaration . 318)(single_protected_declaration . 
319)(single_task_declaration . 320)(subprogram_body . 321)(subprogram_body_stub 
. 322)(subprogram_declaration . 323)(subprogram_renaming_declaration . 
324)(subtype_declaration . 325)(task_body . 326)(task_body_stub . 
327)(task_definition . 1288)(task_type_declaration . 328)(type_declaration . 
329)(use_clause . 330))
+      nil
+      nil
+      nil
+      ((aggregate . 143)(attribute_reference . 48)(factor . 145)(name . 
146)(primary . 149)(qualified_expression . 51)(selected_component . 
52)(simple_expression . 1287)(term . 157)(term_list . 
158)(unary_adding_operator . 159))
+      ((aggregate . 143)(attribute_reference . 48)(expression . 1286)(factor . 
145)(name . 146)(primary . 149)(qualified_expression . 51)(relation_and_list . 
150)(relation_and_then_list . 151)(relation_or_list . 
152)(relation_or_else_list . 153)(relation_xor_list . 154)(relation . 
155)(selected_component . 52)(simple_expression . 156)(term . 157)(term_list . 
158)(unary_adding_operator . 159))
+      nil
+      ((aggregate . 143)(attribute_reference . 48)(choice_expression . 
168)(choice_relation_and_list . 169)(choice_relation_or_list . 
170)(choice_relation_xor_list . 171)(choice_relation_and_then_list . 
172)(choice_relation_or_else_list . 173)(choice_relation . 174)(discrete_choice 
. 175)(discrete_choice_list . 1284)(factor . 145)(name . 179)(primary . 
149)(qualified_expression . 51)(range . 221)(selected_component . 
52)(simple_expression . 448)(term . 157)(term_list . 158)(unary_adding_operator 
. 159))
+      ((variant . 1283))
+      nil
+      nil
+      ((record_definition . 1280))
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      ((aggregate . 143)(attribute_reference . 48)(expression . 
177)(expression_opt . 1279)(factor . 145)(name . 146)(primary . 
149)(qualified_expression . 51)(relation_and_list . 150)(relation_and_then_list 
. 151)(relation_or_list . 152)(relation_or_else_list . 153)(relation_xor_list . 
154)(relation . 155)(selected_component . 52)(simple_expression . 156)(term . 
157)(term_list . 158)(unary_adding_operator . 159))
+      nil
+      ((identifier_opt . 1277))
+      ((identifier_opt . 1276))
+      nil
+      nil
+      nil
+      nil
+      ((accept_statement . 618)(assignment_statement . 
619)(asynchronous_select . 620)(attribute_reference . 48)(block_statement . 
621)(case_statement . 622)(conditional_entry_call . 623)(delay_statement . 
624)(exit_statement . 625)(extended_return_statement . 626)(if_statement . 
628)(iteration_scheme . 629)(label_opt . 630)(loop_statement . 631)(name . 
632)(pragma . 633)(procedure_call_statement . 634)(qualified_expression . 
51)(raise_statement . 635)(requeue_statement . 636)(selected_component . 
52)(selective_accept . 637)(select_statement . 638)(sequence_of_statements . 
639)(sequence_of_statements_opt . 1274)(simple_return_statement . 
641)(statement . 642)(timed_entry_call . 643))
+      nil
+      nil
+      nil
+      nil
+      ((aggregate . 143)(attribute_reference . 48)(expression . 1271)(factor . 
145)(name . 146)(primary . 149)(qualified_expression . 51)(relation_and_list . 
150)(relation_and_then_list . 151)(relation_or_list . 
152)(relation_or_else_list . 153)(relation_xor_list . 154)(relation . 
155)(selected_component . 52)(simple_expression . 156)(term . 157)(term_list . 
158)(unary_adding_operator . 159))
+      nil
+      nil
+      nil
+      nil
+      nil
+      ((accept_statement . 618)(assignment_statement . 
619)(asynchronous_select . 620)(attribute_reference . 48)(block_statement . 
621)(case_statement . 622)(conditional_entry_call . 623)(delay_statement . 
624)(exit_statement . 625)(extended_return_statement . 626)(if_statement . 
628)(iteration_scheme . 629)(label_opt . 630)(loop_statement . 631)(name . 
632)(pragma . 633)(procedure_call_statement . 634)(qualified_expression . 
51)(raise_statement . 635)(requeue_statement . 636)(selected_component . 
52)(selective_accept . 637)(select_statement . 638)(sequence_of_statements . 
639)(sequence_of_statements_opt . 1269)(simple_return_statement . 
641)(statement . 642)(timed_entry_call . 643))
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      ((aspect_specification_opt . 1297))
+      nil
+      nil
+      nil
+      nil
+      ((aspect_specification_opt . 1294))
+      nil
+      nil
+      nil
+      nil
+      ((aggregate . 143)(attribute_reference . 48)(factor . 145)(name . 
146)(primary . 149)(qualified_expression . 51)(selected_component . 
52)(simple_expression . 1311)(term . 157)(term_list . 
158)(unary_adding_operator . 159))
+      nil
+      nil
+      nil
+      ((aspect_clause . 997)(at_clause . 287)(component_declaration . 
998)(component_item . 999)(component_list . 
1309)(enumeration_representation_clause . 294)(identifier_list . 
1002)(record_representation_clause . 317)(variant_part . 1003))
+      nil
+      nil
+      ((abstract_subprogram_declaration . 285)(aspect_clause . 286)(at_clause 
. 287)(body . 288)(body_stub . 289)(declaration . 290)(declarations . 
291)(declarative_part_opt . 1306)(entry_declaration . 
293)(enumeration_representation_clause . 294)(exception_declaration . 
295)(full_type_declaration . 296)(generic_declaration . 
297)(generic_formal_part . 17)(generic_instantiation . 
298)(generic_package_declaration . 19)(generic_renaming_declaration . 
299)(generic_subprogram_declaration . 21)(identifier_list . 
300)(incomplete_type_declaration . 301)(null_procedure_declaration . 
302)(object_declaration . 303)(object_renaming_declaration . 
304)(overriding_indicator_opt . 305)(package_body . 306)(package_body_stub . 
307)(package_declaration . 308)(package_renaming_declaration . 
309)(package_specification . 28)(pragma . 310)(private_extension_declaration . 
311)(private_type_declaration . 312)(procedure_specification . 30)(proper_body 
. 313)(protected_body . 314)(protected_body_stub . 
315)(protected_type_declaration . 316)(record_representation_clause . 
317)(renaming_declaration . 318)(single_protected_declaration . 
319)(single_task_declaration . 320)(subprogram_body . 321)(subprogram_body_stub 
. 322)(subprogram_declaration . 323)(subprogram_renaming_declaration . 
324)(subtype_declaration . 325)(task_body . 326)(task_body_stub . 
327)(task_type_declaration . 328)(type_declaration . 329)(use_clause . 330))
+      ((aggregate . 143)(attribute_reference . 48)(discrete_subtype_definition 
. 1305)(factor . 145)(name . 865)(primary . 149)(qualified_expression . 
51)(range . 756)(selected_component . 52)(simple_expression . 
757)(subtype_indication . 758)(term . 157)(term_list . 
158)(unary_adding_operator . 159))
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      ((aspect_clause . 997)(at_clause . 287)(component_declaration . 
998)(component_item . 1103)(enumeration_representation_clause . 
294)(identifier_list . 1002)(record_representation_clause . 317)(variant_part . 
1104))
+      nil
+      nil
+      nil
+      ((accept_statement . 618)(assignment_statement . 
619)(asynchronous_select . 620)(attribute_reference . 48)(block_statement . 
621)(case_statement . 622)(conditional_entry_call . 623)(delay_statement . 
624)(exit_statement . 625)(extended_return_statement . 
626)(handled_sequence_of_statements . 1316)(if_statement . 
628)(iteration_scheme . 629)(label_opt . 630)(loop_statement . 631)(name . 
632)(pragma . 633)(procedure_call_statement . 634)(qualified_expression . 
51)(raise_statement . 635)(requeue_statement . 636)(selected_component . 
52)(selective_accept . 637)(select_statement . 638)(sequence_of_statements . 
639)(sequence_of_statements_opt . 640)(simple_return_statement . 641)(statement 
. 642)(timed_entry_call . 643))
+      ((formal_part . 111)(parameter_profile_opt . 1315))
+      nil
+      nil
+      ((identifier_opt . 1318))
+      nil
+      nil]))
+  "Parser table.")
+
+(provide 'ada-grammar-wy)
+
+;; end of file
diff --git a/packages/ada-mode/ada-imenu.el b/packages/ada-mode/ada-imenu.el
new file mode 100755
index 0000000..459aa12
--- /dev/null
+++ b/packages/ada-mode/ada-imenu.el
@@ -0,0 +1,77 @@
+;;; ada-imenu.el - Ada mode interface to imenu for Ada Mode
+
+;; Copyright (C) 2012, 2013  Free Software Foundation, Inc.
+;;
+;; Author: Simon Wright <address@hidden>
+;; Contributors: see ada-mode.el, and specifically Christian Egli
+;;     <address@hidden> for ada-imenu-generic-expression
+;;
+;; 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/>.
+;;
+;;; History: see ada_mode.el
+;;
+
+(require 'ada-mode)
+(require 'imenu)
+
+(defconst ada--imenu-comment-re "\\([ \t]*--.*\\)?")
+
+(defconst ada--imenu-subprogram-menu-re
+  (concat "^[ \t]*\\(overriding[ \t]*\\)?\\(procedure\\|function\\)[ \t\n]+"
+         "\\(\\(\\sw\\|_\\)+\\)[ \t\n]*\\([ \t\n]\\|([^)]+)"
+         ada--imenu-comment-re
+         "\\)[ \t\n]*"
+         "\\(return[ \t\n]+\\(\\sw\\|[_.]\\)+[ \t\n]*\\)?is[ \t\n]"))
+
+(defvar ada--imenu-generic-expression
+  (list
+   (list nil ada--imenu-subprogram-menu-re 3)
+   (list "*Specs*"
+        (concat
+         "^[ \t]*\\(procedure\\|function\\)[ \t\n]+\\(\\(\\sw\\|_\\)+\\)"
+         "\\("
+         "\\(" ada--imenu-comment-re "[ \t\n]+\\|[ \t\n]*([^)]+)"
+         ada--imenu-comment-re "\\)";; parameter list or simple space
+         "\\([ \t\n]*return[ \t\n]+\\(\\sw\\|[_.]\\)+[ \t\n]*\\)?"
+         "\\)?;") 2)
+   '("*Tasks*" "^[ \t]*task[ \t]+\\(type[ \t]+\\)?\\(\\(body[ 
\t]+\\)?\\(\\sw\\|_\\)+\\)" 2)
+   '("*Type Defs*" "^[ \t]*\\(sub\\)?type[ \t]+\\(\\(\\sw\\|_\\)+\\)" 2)
+   '("*Protected*"
+     "^[ \t]*protected[ \t]+\\(type[ \t]+\\)?\\(\\(body[ 
\t]+\\)?\\(\\sw\\|_\\)+\\)" 2)
+   '("*Packages*" "^[ \t]*package[ \t]+\\(\\(body[ 
\t]+\\)?\\(\\sw\\|[_.]\\)+\\)" 1))
+  "Imenu generic expression for Ada mode.
+See `imenu-generic-expression'.  This variable will create several submenus for
+each type of entity that can be found in an Ada file.")
+
+(defun ada--imenu-mode ()
+  ;;  In 4.01, these were called in 'ada-mode or required to be set in
+  ;;  the user's .emacs.
+
+  (setq imenu-auto-rescan t)
+  (setq imenu-case-fold-search t)
+  (setq imenu-generic-expression ada--imenu-generic-expression)
+  (setq imenu-sort-function 'imenu--sort-by-name)
+  (setq imenu-use-markers nil)
+
+  (imenu-add-to-menubar "Entities")
+)
+
+;; ada--imenu-mode does not depend on file local variables
+(add-hook 'ada-mode-hook 'ada--imenu-mode)
+
+(provide 'ada-imenu)
+
+;;; ada-imenu.el ends here
diff --git a/packages/ada-mode/ada-indent-user-options.el 
b/packages/ada-mode/ada-indent-user-options.el
new file mode 100755
index 0000000..fabe076
--- /dev/null
+++ b/packages/ada-mode/ada-indent-user-options.el
@@ -0,0 +1,230 @@
+;;; user options shared by Ada mode indentation engines
+;;
+;; Copyright (C) 2012, 2013  Free Software Foundation, Inc.
+;;
+;; Author: Stephen Leake <address@hidden>
+;; Contributors: Simon Wright <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/>.
+;;
+;;; History: see ada_mode.el
+
+;;;; code
+
+(defgroup ada-indentation nil
+  "Indentation options for Ada source."
+  :group 'ada)
+
+(defcustom ada-indent 3
+  "Size of Ada default indentation, when no other indentation is used.
+
+Example :
+procedure Foo is
+begin
+>>>null;"
+  :type 'integer
+  :group 'ada-indentation
+  :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)
+  "Indentation for the continuation of a broken line.
+
+Example :
+   My_Var : My_Type :=
+   >>(Field1 => Value);"
+  :type  'integer
+  :group 'ada-indentation
+  :safe  'integerp)
+(make-variable-buffer-local 'ada-indent-broken)
+
+(defcustom ada-indent-comment-col-0 nil
+  "If non-nil, comments currently starting in column 0 are left in column 0.
+Otherwise, they are indented with previous comments or code."
+  :type  'boolean
+  :group 'ada-indentation
+  :safe  'booleanp)
+(make-variable-buffer-local 'ada-indent-comment-col-0)
+
+(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.
+  "Indentation for a loop, block, or statement label, relative to the item it 
labels.
+
+Example :
+   Label_1 :
+   <<<<declare
+
+   <<Label_2>>
+   <<<<Foo := 0;"
+  :type  'integer
+  :group 'ada-indentation
+  :safe  'integerp)
+(make-variable-buffer-local 'ada-indent-label)
+
+(defcustom ada-indent-record-rel-type 3
+  "Indentation for 'record' relative to 'type' or 'use'.
+
+An example is:
+   type A is
+   >>>record"
+  :type  'integer
+  :group 'ada-indent
+  :safe  'integerp)
+(make-variable-buffer-local 'ada-indent-record-rel-type)
+
+(defcustom ada-indent-renames 2
+  "Indentation for 'renames' relative to the matching subprogram keyword.
+
+For 'renames' of non-subprograms the indentation is
+`ada-indent-broken' relative to the line containing the matching
+keyword.
+
+If the subprogram has parameters then if `ada-indent-renames' is
+zero or less the indentation is abs `ada-indent-renames' relative
+to the open parenthesis; if `ada-indent-renames' is one or more
+the indentation is relative to the line containing the keyword.
+
+If the subprogram has no parameters then `ada-indent-broken' the
+indentation is relative to the indentation of the line containing
+the keyword.
+
+Examples:
+   ada-indent-renames = 2
+   generic function A (B : Integer) return C
+   >>renames Foo;
+
+   ada-indent-renames = -1
+   function A (B : Integer)
+               return C
+   >>>>>>>>>>>renames Foo;"
+  :type  'integer
+  :group 'ada-indent
+  :safe  'integerp)
+(make-variable-buffer-local 'ada-indent-renames)
+
+(defcustom ada-indent-return 0
+  "Indentation for 'return' relative to the matching 'function' keyword.
+
+If the function has parameters, then if `ada-indent-return' is
+zero or less the indentation is abs `ada-indent-return' relative
+to the open parenthesis; if `ada-indent-return' is one or more,
+indentation is relative to line containing 'function'.
+
+If the function has no parameters, `ada-indent-broken' is used
+relative to line containing 'function'.
+
+An example is:
+   function A (B : Integer)
+   >>>>>>>>>>>return C;"
+  :type  'integer
+  :group 'ada-indent
+  :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)
+  "Indentation for the lines in a 'use' statement.
+
+An example is:
+   use Ada.Text_IO,
+   >>Ada.Numerics;"
+  :type  'integer
+  :group 'ada
+  :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)
+  "Indentation for 'when' relative to 'exception', 'case', 'or' in select.
+
+An example is:
+   case A is
+   >>>when B =>"
+  :type  'integer
+  :group 'ada-indent
+  :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)
+  "Indentation for the lines in a 'with' context clause.
+
+An example is:
+   with Ada.Text_IO,
+   >>Ada.Numerics;"
+  :type  'integer
+  :group 'ada
+  :safe  'integerp)
+(make-variable-buffer-local 'ada-indent-with)
+
+(provide 'ada-indent-user-options)
+
+;; end file
diff --git a/packages/ada-mode/ada-mode-compat-23.4.el 
b/packages/ada-mode/ada-mode-compat-23.4.el
new file mode 100755
index 0000000..236d607
--- /dev/null
+++ b/packages/ada-mode/ada-mode-compat-23.4.el
@@ -0,0 +1,24 @@
+;;; Implement current Emacs features not present in Emacs 23.4
+
+(defvar compilation-filter-start (make-marker)
+  "")
+
+(defun compilation-filter-start (proc)
+  ""
+  (set-marker compilation-filter-start (point-max)))
+
+(defun compilation--put-prop (matchnum prop val)
+  (when (and (integerp matchnum) (match-beginning matchnum))
+    (put-text-property
+     (match-beginning matchnum) (match-end matchnum)
+     prop val)))
+
+;; FIXME: emacs 24.x manages compilation-filter-start, emacs 23.4 does not
+;;
+;; gnat-core.el gnat-prj-parse-emacs-final needs:
+;;    (add-hook 'compilation-start-hook 'ada-gnat-compilation-start))
+;;
+;; ada-gnat.el ada-gnat-compilation-filter needs:
+;;    (set-marker compilation-filter-start (point)))
+
+;; end of file
diff --git a/packages/ada-mode/ada-mode.el b/packages/ada-mode/ada-mode.el
new file mode 100755
index 0000000..c7c32bc
--- /dev/null
+++ b/packages/ada-mode/ada-mode.el
@@ -0,0 +1,2627 @@
+;;; ada-mode.el --- major-mode for editing Ada sources
+;;
+;;; Copyright (C) 1994, 1995, 1997 - 2013  Free Software Foundation, Inc.
+;;
+;; Author: Stephen Leake <address@hidden>
+;; Maintainer: Stephen Leake <address@hidden>
+;; Keywords FIXME: languages, ada ELPA broken for multiple keywords
+;; Version: 5.0
+;; package-requires: ((wisi "1.0"))
+;; url: http://stephe-leake.org/emacs/ada-mode/emacs-ada-mode.html
+;;
+;; (Gnu ELPA requires single digits between dots in versions)
+;;
+;; 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/>.
+;;
+;;; Usage:
+;;
+;; Emacs should enter Ada mode automatically when you load an Ada
+;; file, based on the file extension.  The default extensions for Ada
+;; files are .ads, .adb; use ada-add-extensions to add other
+;; extensions.
+;;
+;; 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.
+;;
+;; 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.
+;;
+;; 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.
+;;
+;; 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 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-parse-file-ext' uses this style.
+
+;;; History:
+;;
+;; The first Ada mode for GNU Emacs was written by V. Broman in
+;; 1985. He based his work on the already existing Modula-2 mode.
+;; This was distributed as ada.el in versions of Emacs prior to 19.29.
+;;
+;; Lynn Slater wrote an extensive Ada mode in 1989. It consisted of
+;; several files with support for dired commands and other nice
+;; things.
+;;
+;; The probably very first Ada mode (called electric-ada.el) was
+;; written by Steven D. Litvintchouk and Steven M. Rosen for the
+;; Gosling Emacs. L. Slater based his development on ada.el and
+;; electric-ada.el.
+;;
+;; A complete rewrite by Rolf Ebert <address@hidden> and Markus
+;; Heritsch <address@hidden> was done at
+;; some point.  Some ideas from the Ada mode mailing list have been
+;; added.  Some of the functionality of L. Slater's mode has not (yet)
+;; been recoded in this new mode.
+;;
+;; A complete rewrite for Emacs-20 / GNAT-3.11 was done by Emmanuel
+;; Briot <address@hidden> at Ada Core Technologies.
+;;
+;; 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>.
+
+;;; Credits:
+;;
+;;   Many thanks to John McCabe <address@hidden> for sending so
+;;     many patches included in this package.
+;;   Christian Egli <address@hidden>:
+;;     ada-imenu-generic-expression
+;;   Many thanks also to the following persons that have contributed
+;;   to the ada-mode
+;;     Philippe Waroquiers (PW) <address@hidden> in particular,
+;;     address@hidden (John Woodruff)
+;;     address@hidden (Jesper Joergensen)
+;;     address@hidden (Scott Evans)
+;;     address@hidden (Cyrille Comar)
+;;     address@hidden
+;;    and others for their valuable hints.
+
+(require 'find-file)
+(require 'align)
+(require 'which-func)
+(require 'compile)
+
+(eval-when-compile (require 'cl-macs))
+
+(defun ada-mode-version ()
+  "Return Ada mode version."
+  (interactive)
+  (let ((version-string "5.0"))
+    ;; must match:
+    ;; ada-mode.texi
+    ;; README
+    ;; gpr-mode.el
+    ;; Version: above
+    (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
+  ;; can be per-buffer
+  "Buffer-local value that may override project variable `auto_case'.
+Global value is default for project variable `auto_case'.
+Non-nil means automatically change case of preceding word while typing.
+Casing of Ada keywords is done according to `ada-case-keyword',
+identifiers are Mixed_Case."
+  :type  'boolean
+  :group 'ada
+  :safe  'booleanp)
+(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))
+  :group 'ada
+  :safe  'listp)
+
+(defcustom ada-case-keyword 'downcase-word
+  "Buffer-local value that may override project variable `case_keyword'.
+Global value is default for project variable `case_keyword'.
+Function to call to adjust the case of an Ada keywords."
+  :type '(choice (const downcase-word)
+                (const upcase-word))
+  :group 'ada
+  :safe  'functionp)
+(make-variable-buffer-local 'ada-case-keyword)
+
+(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
+  :group 'ada
+  :safe  'booleanp)
+(make-variable-buffer-local 'ada-case-strict)
+
+(defcustom ada-language-version 'ada2012
+  "Ada language version; one of `ada83', `ada95', `ada2005'.
+Only affects the keywords to highlight."
+  :type '(choice (const ada83)
+                (const ada95)
+                (const ada2005)
+                (const ada2012))
+  :group 'ada
+  :safe  'symbolp)
+(make-variable-buffer-local 'ada-language-version)
+
+(defcustom ada-fill-comment-prefix "-- "
+  "Comment fill prefix."
+  :type 'string
+  :group 'ada)
+
+(defcustom ada-fill-comment-postfix " --"
+  "Comment fill postfix."
+  :type 'string
+  :group 'ada)
+
+(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
+  :group 'ada)
+
+(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
+  :group 'ada)
+
+;;;;; 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.")
+
+(defvar ada-xref-tool nil
+  "Default Ada cross reference tool; can be overridden in project files.
+Values defined by cross reference packages.")
+
+;;;; keymap and menus
+
+(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-indent-newline-indent)
+    (define-key map "\C-c`"     'ada-show-secondary-error)
+    (define-key map "\C-c\M-`"          'ada-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-m"   'ada-build-set-make)
+    (define-key map "\C-c\C-n"          'ada-next-statement-keyword)
+    (define-key map "\C-c\C-o"          'ada-find-other-file)
+    (define-key map "\C-c\M-o"          'ada-find-other-file-noset)
+    (define-key map "\C-c\C-p"          'ada-prev-statement-keyword)
+    (define-key map "\C-c\C-q"          'ada-xref-refresh)
+    (define-key map "\C-c\C-r"          'ada-show-references)
+    (define-key map "\C-c\M-r"          'ada-build-run)
+    (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\M-y"   'ada-case-create-partial-exception)
+    (define-key map [C-down-mouse-3] 'ada-popup-menu)
+
+    map
+  )  "Local keymap used for Ada mode.")
+
+(defvar ada-mode-menu (make-sparse-keymap "Ada"))
+(easy-menu-define ada-mode-menu ada-mode-map "Menu keymap for Ada mode"
+  '("Ada"
+    ("Help"
+     ["Ada Mode"             (info "ada-mode") t]
+     ["Ada Reference Manual" (info "arm2012") t]
+     ["Key bindings"         describe-bindings t]
+     )
+    ["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]
+    )
+    ("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]
+     ["Check syntax"               ada-build-check       t]
+     ["Show main"                  ada-build-show-main   t]
+     ["Build"                      ada-build-make        t]
+     ["Set main and Build"         ada-build-set-make    t]
+     ["Run"                        ada-build-run         t]
+     )
+    ("Navigate"
+     ["Other file"                    ada-find-other-file          t]
+     ["Other file don't find decl"    ada-find-other-file-noset    t]
+     ["Goto declaration/body"         ada-goto-declaration         t]
+     ["Goto next statement keyword"   ada-next-statement-keyword   t]
+     ["Goto prev statement keyword"   ada-next-statement-keyword   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]
+     )
+    ("Edit"
+     ["Expand skeleton"             ada-expand              t]
+     ["Indent line"                 indent-for-tab-command  t]
+     ["Indent current statement"    ada-indent-statement    t]
+     ["Indent lines in file"        (indent-region (point-min) (point-max))  t]
+     ["Align"                       ada-align               t]
+     ["Comment selection"           comment-region          t]
+     ["Uncomment selection"         (comment-region t)      t]
+     ["Fill comment paragraph"         ada-fill-comment-paragraph           t]
+     ["Fill comment paragraph justify" (ada-fill-comment-paragraph 'full)   t]
+     ["Fill comment paragraph postfix" (ada-fill-comment-paragraph 'full t) t]
+     ["Make body for subprogram"    ada-make-subprogram-body     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]
+     )
+    ("Misc"
+     ["Show last parse error"         ada-show-parse-error         t]
+     ["Refresh cross reference cache" ada-xref-refresh             t]
+     )))
+
+;; This doesn't need to be buffer-local because there can be only one
+;; popup menu at a time.
+(defvar ada-context-menu-on-identifier nil)
+
+(easy-menu-define ada-context-menu nil
+  "Context menu keymap for Ada mode"
+  '("Ada"
+    ["Make body for subprogram"      ada-make-subprogram-body     t] ;; FIXME: 
include only if will succeed
+    ["Goto declaration/body"         ada-goto-declaration         :included 
ada-context-menu-on-identifier]
+    ["Show parent declarations"      ada-show-declaration-parents :included 
ada-context-menu-on-identifier]
+    ["Show references"               ada-show-references          :included 
ada-context-menu-on-identifier]
+    ["Show overriding"               ada-show-overriding          :included 
ada-context-menu-on-identifier]
+    ["Show overridden"               ada-show-overridden          :included 
ada-context-menu-on-identifier]
+    ["Expand skeleton"               ada-expand                        t] ;; 
FIXME: only if skeleton
+    ["Create full case exception"    ada-case-create-exception         t]
+    ["Create partial case exception" ada-case-create-partial-exception t]
+
+    ["-"                nil nil]
+    ["Align"                       ada-align                  t]
+    ["Adjust case at point"        ada-case-adjust-at-point   (not 
(use-region-p))]
+    ["Adjust case region"          ada-case-adjust-region     (use-region-p)]
+    ["Indent current statement"    ada-indent-statement       t]
+    ["Goto next statement keyword" ada-next-statement-keyword t]
+    ["Goto prev statement keyword" ada-next-statement-keyword t]
+    ["Other File"                  ada-find-other-file        t]
+    ["Other file don't find decl"  ada-find-other-file-noset  t]))
+
+(defun ada-popup-menu (position)
+  "Pops up a `ada-context-menu', with `ada-context-menu-on-identifer' set 
appropriately.
+POSITION is the location the mouse was clicked on.
+Sets `ada-context-menu-last-point' to the current position before
+displaying the menu.  When a function from the menu is called,
+point is where the mouse button was clicked."
+  (interactive "e")
+
+  (mouse-set-point last-input-event)
+
+  (setq ada-context-menu-on-identifier
+       (and (char-after)
+            (or (= (char-syntax (char-after)) ?w)
+                (= (char-after) ?_))
+            (not (ada-in-string-or-comment-p))
+            (save-excursion (skip-syntax-forward "w")
+                            (not (ada-after-keyword-p)))
+            ))
+    (popup-menu ada-context-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.
+  (newline)
+  (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)))
+
+;;;; abbrev, align
+
+(defvar ada-mode-abbrev-table nil
+  "Local abbrev table for Ada mode.")
+
+(defvar ada-align-rules
+  '((ada-declaration-assign
+     (regexp  . "[^:]\\(\\s-*\\)\\(:\\)[^:]")
+     (valid   . (lambda () (ada-align-valid)))
+     (repeat . t)
+     (modes   . '(ada-mode)))
+    (ada-associate
+     (regexp  . "[^=]\\(\\s-*\\)\\(=>\\)")
+     (valid   . (lambda () (ada-align-valid)))
+     (modes   . '(ada-mode)))
+    (ada-comment
+     (regexp  . "\\(\\s-*\\)--")
+     (modes   . '(ada-mode)))
+    (ada-use
+     (regexp  . "\\(\\s-*\\)\\<\\(use\\s-\\)")
+     (valid   . (lambda () (ada-align-valid)))
+     (modes   . '(ada-mode)))
+    (ada-at
+     (regexp . "\\(\\s-+\\)\\(at\\)\\>")
+     (valid   . (lambda () (ada-align-valid)))
+     (modes . '(ada-mode))))
+  "Rules to use to align different lines.")
+
+(defun ada-align-valid ()
+  "See use in `ada-align-rules'."
+  (save-excursion
+    ;; we don't put "when (match-beginning 2)" here; missing a match
+    ;; is a bug in the regexp.
+    (goto-char (match-beginning 2))
+    (not (ada-in-string-or-comment-p))))
+
+(defconst ada-align-region-separate
+  (eval-when-compile
+    (concat
+     "^\\s-*\\($\\|\\("
+     "begin\\|"
+     "declare\\|"
+     "else\\|"
+     "end\\|"
+     "exception\\|"
+     "for\\|"
+     "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
+    (cond
+     ((ada-in-paramlist-p)
+        (ada-format-paramlist))
+
+     (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 no arguments.")
+
+(defun ada-in-paramlist-p ()
+  "Return t if point is inside the parameter-list of a subprogram declaration."
+  (when ada-in-paramlist-p
+    (funcall ada-in-paramlist-p)))
+
+(defun ada-format-paramlist ()
+  "Reformat the parameter list point is in."
+  (interactive)
+  (ada-goto-open-paren)
+  (funcall indent-line-function); so new list is indented properly
+
+  (let* ((inibit-modification-hooks t)
+        (begin (point))
+        (delend (progn (forward-sexp) (point))); just after matching closing 
paren
+        (end (progn (backward-char) (forward-comment (- (point))) (point))); 
end of last parameter-declaration
+        (multi-line (> end (save-excursion (goto-char begin) 
(line-end-position))))
+        (paramlist (ada-scan-paramlist (1+ begin) end)))
+
+    (when paramlist
+      ;; delete the original parameter-list
+      (delete-region begin delend)
+
+      ;; insert the new parameter-list
+      (goto-char begin)
+      (if multi-line
+         (ada-insert-paramlist-multi-line paramlist)
+       (ada-insert-paramlist-single-line paramlist)))
+    ))
+
+(defvar ada-scan-paramlist nil
+  ;; Supplied by indentation engine parser
+  "Function to scan a region, return a list of subprogram parameter 
declarations (in inverse declaration order).
+Function is called with two args BEGIN END (the region).
+Each parameter declaration is represented by a list
+'((identifier ...) in-p out-p not-null-p access-p constant-p protected-p type 
default)."
+  ;; mode is 'in | out | in out | [not null] access [constant | protected]'
+  ;; IMPROVEME: handle single-line trailing comments, or longer comments, in 
paramlist?
+  )
+
+(defun ada-scan-paramlist (begin end)
+  (when ada-scan-paramlist
+    (funcall ada-scan-paramlist begin end)))
+
+(defun ada-insert-paramlist-multi-line (paramlist)
+  "Insert a multi-line formatted PARAMLIST in the buffer."
+  (let ((i (length paramlist))
+       param
+       j
+       len
+       (ident-len 0)
+       (type-len 0)
+       (in-p nil)
+       (out-p nil)
+       (not-null-p nil)
+       (access-p nil)
+       ident-col
+       colon-col
+       out-col
+       type-col
+       default-col)
+
+    ;; accumulate info across all params
+    (while (not (zerop i))
+      (setq i (1- i))
+      (setq param (nth i paramlist))
+
+      ;; identifier list
+      (setq len 0
+           j   0)
+      (mapc (lambda (ident)
+             (setq j (1+ j))
+             (setq len (+ len (length ident))))
+           (nth 0 param))
+      (setq len (+ len (* 2 (1- j)))); space for commas
+      (setq ident-len (max ident-len len))
+
+      ;; we align the defaults after the types that have defaults, not after 
all types.
+      ;; "constant", "protected" are treated as part of 'type'
+      (when (nth 8 param)
+       (setq type-len
+             (max type-len
+                  (+ (length (nth 7 param))
+                     (if (nth 5 param) 10 0); "constant "
+                     (if (nth 6 param) 10 0); protected
+                     ))))
+
+      (setq in-p (or in-p (nth 1 param)))
+      (setq out-p (or out-p (nth 2 param)))
+      (setq not-null-p (or not-null-p (nth 3 param)))
+      (setq access-p (or access-p (nth 4 param)))
+      )
+
+    (unless (save-excursion (skip-chars-backward " \t") (bolp))
+      ;; paramlist starts on same line as subprogram identifier; clean up 
whitespace
+      (end-of-line)
+      (delete-char (- (skip-syntax-backward " ")))
+      (insert " "))
+
+    (insert "(")
+
+    ;; compute columns.
+    (setq ident-col (current-column))
+    (setq colon-col (+ ident-col ident-len 1))
+    (setq out-col (+ colon-col (if in-p 5 0))); ": in "
+    (setq type-col
+         (+ colon-col
+            (cond
+             (not-null-p 18);    ": not null access "
+             (access-p 9);        ": access"
+             ((and in-p out-p) 9); ": in out "
+             (out-p 6);           ": out "
+             (in-p 5);            ": in "
+             (t 2))));           ": "
+
+    (setq default-col (+ 1 type-col type-len))
+
+    (setq i (length paramlist))
+    (while (not (zerop i))
+      (setq i (1- i))
+      (setq param (nth i paramlist))
+
+      ;; insert identifiers, space and colon
+      (mapc (lambda (ident)
+             (insert ident)
+             (insert ", "))
+           (nth 0 param))
+      (delete-char -2); last ", "
+      (indent-to colon-col)
+      (insert ": ")
+
+      (when (nth 1 param)
+       (insert "in "))
+
+      (when (nth 2 param)
+       (indent-to out-col)
+       (insert "out "))
+
+      (when (nth 3 param)
+       (insert "not null "))
+
+      (when (nth 4 param)
+       (insert "access "))
+
+      (indent-to type-col)
+      (when (nth 5 param)
+       (insert "constant "))
+      (when (nth 6 param)
+       (insert "protected "))
+      (insert (nth 7 param)); type
+
+      (when (nth 8 param); default
+       (indent-to default-col)
+       (insert ":= ")
+       (insert (nth 8 param)))
+
+      (if (zerop i)
+         (insert ")")
+       (insert ";")
+       (newline)
+       (indent-to ident-col))
+      )
+    ))
+
+(defun ada-insert-paramlist-single-line (paramlist)
+  "Insert a single-line formatted PARAMLIST in the buffer."
+  (let ((i (length paramlist))
+       param)
+
+    ;; clean up whitespace
+    (skip-syntax-forward " ")
+    (delete-char (- (skip-syntax-backward " ")))
+    (insert " (")
+
+    (setq i (length paramlist))
+    (while (not (zerop i))
+      (setq i (1- i))
+      (setq param (nth i paramlist))
+
+      ;; insert identifiers, space and colon
+      (mapc (lambda (ident)
+             (insert ident)
+             (insert ", "))
+           (nth 0 param))
+      (delete-char -2); last ", "
+
+      (insert " : ")
+
+      (when (nth 1 param)
+       (insert "in "))
+
+      (when (nth 2 param)
+       (insert "out "))
+
+      (when (nth 3 param)
+       (insert "not null "))
+
+      (when (nth 4 param)
+       (insert "access "))
+
+      (when (nth 5 param)
+       (insert "constant "))
+      (when (nth 6 param)
+       (insert "protected "))
+      (insert (nth 7 param)); type
+
+      (when (nth 8 param); default
+       (insert " := ")
+       (insert (nth 8 param)))
+
+      (if (zerop i)
+         (if (= (char-after) ?\;)
+             (insert ")")
+           (insert ") "))
+       (insert "; "))
+      )
+    ))
+
+(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
+`ada-case-exception-file' full word exceptions. Indexed by
+properly cased word; value is t.")
+
+(defvar ada-case-partial-exceptions '()
+  "Alist of partial words that have special casing, built from
+`ada-case-exception-file' partial word exceptions. Indexed by
+properly cased word; value is t.")
+
+(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)
+                   (add-to-list 'partial-exceptions (cons word t))))
+
+             ;; full word exception
+             (unless (assoc-string word full-exceptions t)
+               (add-to-list 'full-exceptions (cons word t))))
+
+           (forward-line 1))
+         )
+       (cons full-exceptions partial-exceptions))
+
+    ;; else file not readable; might be a new project with no
+    ;; exceptions yet, so just warn user, return empty pair
+    (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)
+      (add-to-list 'result item)))
+  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 `ada-case-exception-file',
+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)
+    (add-to-list 'exceptions (cons word t)))
+  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
+           (error
+            "No exception file specified. See variable 
`ada-case-exception-file'")))
+         ))
+
+  (unless word
+    (if (use-region-p)
+       (setq word (buffer-substring-no-properties (region-beginning) 
(region-end)))
+      (save-excursion
+       (skip-syntax-backward "w_")
+       (setq word
+             (buffer-substring-no-properties
+              (point)
+              (progn (skip-syntax-forward "w_") (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-numeric-literal-p ()
+  "Return t if point is after a prefix of a numeric literal."
+  (looking-back "\\([0-9]+#[0-9a-fA-F_]+\\)"))
+
+(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-adjust-identifier ()
+  "Adjust case of the previous word as an identifier.
+Uses Mixed_Case, 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 Mixed_Case and partial-exceptions
+       (if ada-case-strict
+           (downcase-region start end))
+       (while (not done)
+         (setq next
+               (or
+                (save-excursion (when (search-forward "_" end t) 
(point-marker)))
+                (copy-marker (1+ end))))
+
+         (if (setq match (assoc-string (buffer-substring-no-properties start 
(1- next))
+                                       ada-case-partial-exceptions t))
+             (progn
+               ;; see comment above at 'full word exception' for why
+               ;; we do insert first.
+               (insert (car match))
+               (delete-region (point) (1- next)))
+
+           ;; else upcase first char
+           (insert-char (upcase (following-char)) 1)
+           (delete-char 1))
+
+         (goto-char next)
+         (if (< (point) end)
+             (setq start (point))
+           (setq done t))
+       )))))
+
+(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."
+  (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-numeric-literal-p))
+                ))
+
+      (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))
+
+       ((and
+        (not in-comment)
+        (not (eq typed-char ?_))
+        (ada-after-keyword-p))
+       (funcall ada-case-keyword -1))
+
+       (t (ada-case-adjust-identifier))
+       ))
+    ))
+
+(defun ada-case-adjust-at-point (&optional in-comment)
+  "Adjust case of word at point, move to end of word.
+With prefix arg, adjust case even if in comment."
+  (interactive "P")
+  (when
+      (and (not (eobp))
+          (memq (char-syntax (char-after)) '(?w ?_)))
+    (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)
+  "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))
+
+    (cond
+     ((eq lastk ?\n)
+      (ada-case-adjust lastk)
+      (funcall ada-lfd-binding))
+
+     ((eq lastk ?\r)
+      (ada-case-adjust lastk)
+      (funcall ada-ret-binding))
+
+     (t
+      (ada-case-adjust lastk)
+      (self-insert-command (prefix-numeric-value arg)))
+     )
+  ))
+
+(defvar ada-ret-binding nil)
+(defvar ada-lfd-binding nil)
+
+(defun ada-case-activate-keys ()
+  "Modify the key bindings for all the keys that should adjust casing."
+  (interactive)
+  ;; We can't use post-self-insert-hook for \n, \r, because they are
+  ;; not self-insert.  So we make ada-mode-map buffer local, and don't
+  ;; call this function if ada-auto-case is off. That means
+  ;; ada-auto-case cannot be changed after an Ada buffer is created.
+
+  ;; The 'or ...' is there to be sure that the value will not be
+  ;; changed again when Ada mode is called more than once, since we
+  ;; are rebinding the keys.
+  (or ada-ret-binding (setq ada-ret-binding (key-binding "\C-M")))
+  (or ada-lfd-binding (setq ada-lfd-binding (key-binding "\C-j")))
+
+  (mapcar (function
+          (lambda(key)
+            (define-key
+              ada-mode-map
+              (char-to-string key)
+              'ada-case-adjust-interactive)))
+         '( ?_ ?% ?& ?* ?( ?) ?- ?= ?+
+               ?| ?\; ?: ?' ?\" ?< ?, ?. ?> ?/ ?\n 32 ?\r ))
+  )
+
+;;;; 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'."
+  (plist-get (or plist ada-prj-current-project) prop))
+
+(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. 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 ()
+  "Return the default project properties list.
+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
+      'ada_ref_tool    ada-xref-tool
+      'auto_case       ada-auto-case
+      'case_keyword    ada-case-keyword
+      '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        process-environment
+      'src_dir         (list ".")
+      '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.
+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
+  (let ((project (ada-prj-default))
+       (parser (cdr (assoc (file-name-extension prj-file) 
ada-prj-parser-alist))))
+
+    (setq prj-file (expand-file-name prj-file))
+
+    (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."
+  (ada-parse-prj-file ada-prj-current-file)
+  (ada-select-prj-file ada-prj-current-file))
+
+(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
+       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_strict")
+           (setq project (plist-put project 'case_strict (intern (match-string 
2)))))
+
+          ((string= (match-string 1) "casing")
+           (add-to-list 'casing
+                        (expand-file-name
+                         (substitute-in-file-name (match-string 2)))))
+
+          ((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")
+           (add-to-list 'src_dir
+                        (file-name-as-directory
+                         (expand-file-name (match-string 2)))))
+
+          ((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.
+             (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 (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 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 (set 'project (plist-put project 'casing (reverse casing))))
+    (if src_dir (set 'project (plist-put project 'src_dir (reverse src_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-project-search-path nil
+  "Search path for finding Ada project files")
+
+(defvar ada-select-prj-compiler nil
+  "Alist of functions to call for compiler specific project file selection.
+Indexed by project variable ada_compiler.")
+
+(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-select-prj-file (prj-file)
+  "Select PRJ-FILE as the current project file."
+  (interactive)
+  (setq prj-file (expand-file-name prj-file))
+
+  (setq ada-prj-current-project (cdr (assoc prj-file ada-prj-alist)))
+
+  (when (null ada-prj-current-project)
+    (setq ada-prj-current-file nil)
+    (error "Project file '%s' was not previously parsed." 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))
+  (setq ada-project-search-path (ada-prj-get 'prj_dir))
+
+  (let ((func (cdr (assq (ada-prj-get 'ada_compiler) 
ada-select-prj-compiler))))
+    (when func (funcall func)))
+
+  (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-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-show ()
+  "Show current Emacs Ada mode project file."
+  (interactive)
+  (message "current Emacs Ada mode project file: %s" ada-prj-current-file))
+
+;;;; syntax properties
+
+(defvar ada-mode-syntax-table
+  (let ((table (make-syntax-table)))
+    ;; (info "(elisp)Syntax Class Table" "*info syntax class table*")
+    ;; make-syntax-table sets all alphanumeric to w, etc; so we only
+    ;; have to add ada-specific things.
+
+    ;; string brackets. `%' is the obsolete alternative string
+    ;; bracket (arm J.2); if we make it syntax class ", it throws
+    ;; font-lock and indentation off the track, so we use syntax class
+    ;; $.
+    (modify-syntax-entry ?%  "$" table)
+    (modify-syntax-entry ?\" "\"" table)
+
+    ;; punctuation; operators etc
+    (modify-syntax-entry ?#  "w" table); based number - word syntax, since we 
don't need the number
+    (modify-syntax-entry ?&  "." table)
+    (modify-syntax-entry ?*  "." table)
+    (modify-syntax-entry ?+  "." table)
+    (modify-syntax-entry ?-  ". 12" table); operator; see 
ada-syntax-propertize for 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); 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)
+
+    ;; and \f and \n end a comment
+    (modify-syntax-entry ?\f  ">" table)
+    (modify-syntax-entry ?\n  ">" table)
+
+    (modify-syntax-entry ?_ "_" table); symbol constituents, not word.
+
+    (modify-syntax-entry ?\( "()" table)
+    (modify-syntax-entry ?\) ")(" table)
+
+    ;; skeleton placeholder delimiters; see ada-skel.el. We use generic
+    ;; comment delimiter class, not comment starter/comment ender, so
+    ;; these can be distinguished from line end.
+    (modify-syntax-entry ?{ "!" table)
+    (modify-syntax-entry ?} "!" table)
+
+    table
+    )
+  "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)
+  "Assign `syntax-table' properties in accessible part of buffer.
+In particular, character constants are set to have string syntax."
+  ;; (info "(elisp)Syntax Properties")
+  (let ((modified (buffer-modified-p))
+       (buffer-undo-list t)
+       (inhibit-read-only t)
+       (inhibit-point-motion-hooks t)
+       (inhibit-modification-hooks t))
+    (goto-char start)
+    (while (re-search-forward
+           (concat
+            "[^a-zA-Z0-9)]\\('\\)[^'\n]\\('\\)"; 1, 2: character constants, 
not attributes
+            "\\|[^a-zA-Z0-9)]\\('''\\)"; 3: character constant '''
+            "\\|\\(--\\)"; 4: comment start
+            )
+           end t)
+      ;; The help for syntax-propertize-extend-region-functions
+      ;; implies that 'start end' will always include whole lines, in
+      ;; which case we don't need
+      ;; syntax-propertize-extend-region-functions
+      (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) (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)
+    (unless modified
+      (restore-buffer-modified-p nil))))
+
+(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-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")
+  "List of possible suffixes for Ada body files.
+The extensions should include a `.' if needed.")
+
+(defvar ada-spec-suffixes '(".ads")
+  "List of possible suffixes for Ada spec files.
+The extensions should include a `.' if needed.")
+
+(defvar ada-other-file-alist
+  '(("\\.ads$" (".adb"))
+    ("\\.adb$" (".ads")))
+  "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
+  ;; depends on ada-compiler, per-project
+  "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."
+  (funcall ada-file-name-from-ada-name ada-name))
+
+(defvar ada-ada-name-from-file-name nil
+  ;; depends on ada-compiler, per-project
+  "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."
+  (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
+   (or
+    (ff-get-file-name
+     compilation-search-path
+     (ada-file-name-from-ada-name ff-function-name)
+     ada-spec-suffixes)
+    (error "parent '%s' not found; set project file?" ff-function-name))))
+
+(defun ada-ff-special-extract-separate ()
+  (let ((package-name (match-string 1)))
+    (save-excursion
+      (goto-char (match-end 0))
+      (when (eolp) (forward-char 1))
+      (skip-syntax-forward " ")
+      (looking-at
+       (concat "\\(function\\|package body\\|procedure\\|protected body\\|task 
body\\)\\s +"
+              ada-name-regexp))
+      (setq ff-function-name (match-string 0))
+      )
+    (file-name-nondirectory
+     (or
+      (ff-get-file-name
+       compilation-search-path
+       (ada-file-name-from-ada-name package-name)
+       ada-body-suffixes)
+      (error "package '%s' not found; set project file?" package-name)))))
+
+(defun ada-ff-special-with ()
+  (let ((package-name (match-string 1)))
+    (setq ff-function-name (concat "^package\\s-+" package-name 
"\\([^_]\\|$\\)"))
+    (file-name-nondirectory
+     (or
+      (ff-get-file-name
+       compilation-search-path
+       (ada-file-name-from-ada-name package-name)
+       (append ada-spec-suffixes ada-body-suffixes))
+      (error "package '%s' not found; set project file?" package-name)))
+    ))
+
+(defun ada-set-ff-special-constructs ()
+  "Add Ada-specific pairs to `ff-special-constructs'."
+  (set (make-local-variable 'ff-special-constructs) nil)
+  (mapc (lambda (pair) (add-to-list 'ff-special-constructs pair))
+       ;; Each car is a regexp; if it matches at point, the cdr is invoked.
+       ;; Each cdr should set ff-function-name to a string or regexp
+       ;; for ada-set-point-accordingly, and return the file name
+       ;; (sans directory, must include suffix) to go to.
+       (list
+        ;; Top level child package declaration (not body), or child
+        ;; subprogram declaration or body; go to the parent package.
+        (cons (concat "^\\(?:private[ 
\t]+\\)?\\(?:package\\|procedure\\|function\\)[ \t]+"
+                      ada-parent-name-regexp "\\(?:;\\|[ \t]+\\|$\\)")
+              'ada-ff-special-extract-parent)
+
+        ;; A "separate" clause.
+        (cons (concat "^separate[ \t\n]*(" ada-name-regexp ")")
+              'ada-ff-special-extract-separate)
+
+        ;; A "with" clause. Note that it may refer to a procedure body, as 
well as a spec
+        (cons (concat "^\\(?:limited[ \t]+\\)?\\(?:private[ \t]+\\)?with[ 
\t]+" ada-name-regexp)
+              '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 no parameters; it should return the name
+of the package, protected type, subprogram, or task type whose
+definition/declaration point is in or just after, or nil.  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 ()
+  "See `ada-which-function' variable."
+  (interactive)
+  (when ada-which-function
+    (funcall ada-which-function)))
+
+(defun ada-add-log-current-function ()
+  "For `add-log-current-defun-function'; uses `ada-which-function'."
+  ;; add-log-current-defun is typically called with point at the start
+  ;; of an ediff change section, which is before the start of the
+  ;; declaration of a new item. So go to the end of the current line
+  ;; first, then call `ada-which-function'
+  (save-excursion
+    (end-of-line 1)
+    (ada-which-function)))
+
+(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."
+  (when ff-function-name
+    (let ((done nil)
+         (found nil))
+      (goto-char (point-min))
+      ;; We are looking for an Ada declaration, so don't stop for strings or 
comments
+      ;;
+      ;; This will still be confused by multiple references; we need
+      ;; to use compiler cross reference info for more precision.
+      (while (not done)
+       (when (search-forward-regexp ff-function-name nil t)
+         (setq found (match-beginning 0)))
+       (if (ada-in-string-or-comment-p)
+           (setq found nil)
+         (setq done t)))
+      (when found
+       (goto-char found)
+       ;; different parsers find different points on the line; normalize here
+       (back-to-indentation))
+      (setq ff-function-name nil))))
+
+(defun ada-find-other-file-noset (other-window)
+  "Same as `ada-find-other-file', but preserve point in the other file,
+don't move to corresponding declaration."
+  (interactive "P")
+  (ada-find-other-file other-window t))
+
+(defun ada-find-other-file (other-window &optional no-set-point)
+  "Move to the corresponding declaration in another file.
+
+- If region is active, assume it contains a package name;
+  position point on that package declaration.
+
+- If point is in the start line of a non-nested child package or
+  subprogram declaration, position point on the corresponding
+  parent package specification.
+
+- If point is in the start line of a separate body,
+  position point on the corresponding separate stub declaration.
+
+- If point is in a context clause line, position point on the
+  first package declaration that is mentioned.
+
+- If point is in a subprogram body or specification, position point
+  on the corresponding specification or body.
+
+If OTHER-WINDOW (set by interactive prefix) is non-nil, show the
+buffer in another window.
+
+If NO-SET-POINT is nil, set point in the other file on the
+corresponding declaration. If non-nil, preserve existing point in
+the other file."
+
+  ;; ff-get-file, ff-find-other file first process
+  ;; ff-special-constructs, then run the following hooks:
+  ;;
+  ;; ff-pre-load-hook      set to ada-which-function
+  ;; ff-file-created-hook  set to ada-ff-create-body
+  ;; ff-post-load-hook     set to ada-set-point-accordingly,
+  ;;                       or to a compiler-specific function that
+  ;;                       uses compiler-generated cross reference
+  ;;                       information
+
+  (interactive "P")
+  (when (null (car compilation-search-path))
+    (error "no file search path defined; set project file?"))
+
+  (if mark-active
+      (progn
+       (setq ff-function-name (buffer-substring-no-properties (point) (mark)))
+       (ff-get-file
+        compilation-search-path
+        (ada-file-name-from-ada-name ff-function-name)
+        ada-spec-suffixes
+        other-window)
+       (deactivate-mark))
+
+    ;; else use name at point
+    (ff-find-other-file other-window)))
+
+(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 function name."
+
+  (when (ada-in-comment-p)
+    (error "Inside comment"))
+
+  (let (identifier)
+
+    (skip-chars-backward "a-zA-Z0-9_<>=+\\-\\*/&")
+
+    ;; Just in front of, or inside, a string => we could have an operator
+    (cond
+     ((ada-in-string-p)
+      (cond
+
+       ((and (= (char-before) ?\")
+            (progn
+              (forward-char -1)
+              (looking-at (concat "\"\\(" ada-operator-re "\\)\""))))
+       (setq identifier (concat "\"" (match-string-no-properties 1) "\"")))
+
+       (t
+       (error "Inside string or character constant"))
+       ))
+
+     ((and (= (char-after) ?\")
+          (looking-at (concat "\"\\(" ada-operator-re "\\)\"")))
+      (setq identifier (concat "\"" (match-string-no-properties 1) "\"")))
+
+     ((looking-at "[a-zA-Z0-9_]+")
+      (setq identifier (match-string-no-properties 0)))
+
+     (t
+      (error "No identifier around"))
+     )))
+
+(defun ada-goto-source (file line column other-window)
+  "Find and select FILE, at LINE and COLUMN.
+FILE may be absolute, or on `compilation-search-path'.
+
+If OTHER-WINDOW is non-nil, show the buffer in another window."
+  (setq file (ff-get-file-name compilation-search-path file))
+  (let ((buffer (get-file-buffer file)))
+    (cond
+     ((bufferp buffer)
+      (cond
+       ((null other-window)
+       (switch-to-buffer buffer))
+
+       (t (switch-to-buffer-other-window buffer))
+       ))
+
+     ((file-exists-p file)
+      (cond
+       ((null other-window)
+       (find-file file))
+
+       (t
+       (find-file-other-window 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 ()
+  "Refresh cross reference information cache, if any."
+  (interactive)
+
+  (when (null ada-xref-refresh-function)
+    (error "no cross reference information available"))
+
+  (funcall ada-xref-refresh-function)
+  )
+
+(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
+- line number containing the identifier
+- 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'.  If point is
+at the specification, the corresponding location is the body, and vice
+versa.")
+
+(defun ada-goto-declaration (other-window)
+  "Move to the declaration or body of the identifier around point.
+If at the declaration, go to the body, and vice versa.
+
+If OTHER-WINDOW (set by interactive prefix) is non-nil, show the
+buffer in another window."
+  (interactive "P")
+
+  (when (null ada-xref-other-function)
+    (error "no cross reference information available"))
+
+    (let ((target
+          (funcall ada-xref-other-function
+                   (ada-identifier-at-point)
+                   (file-name-nondirectory (buffer-file-name))
+                   (line-number-at-pos)
+                   (1+ (current-column))
+                   )))
+
+      (ada-goto-source (nth 0 target)
+                      (nth 1 target)
+                      (nth 2 target)
+                      other-window)
+    ))
+
+(defvar ada-xref-parent-function nil
+  ;; 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
+- 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)
+  (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)
+          (1+ (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
+- column of the start of the identifier
+Displays a buffer in compilation-mode giving locations where the
+identifier is declared or referenced.")
+
+(defun ada-show-references ()
+  "Show all references of identifier at point."
+  (interactive)
+
+  (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)
+          (cl-case (char-after)
+            (?\" (+ 2 (current-column))) ;; FIXME: work around bug in gnat find
+            (t (1+ (current-column)))))
+  )
+
+(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
+- 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)
+
+  (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)
+          (1+ (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
+- 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 (other-window)
+  "Show the overridden declaration of identifier at point."
+  (interactive "P")
+
+  (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)
+                 (1+ (current-column)))))
+
+    (ada-goto-source (nth 0 target)
+                    (nth 1 target)
+                    (nth 2 target)
+                    other-window)
+
+  ))
+
+;; This is autoloaded because it may be used in ~/.emacs
+;;;###autoload
+(defun ada-add-extensions (spec body)
+  "Define SPEC and BODY as being valid extensions for Ada files.
+SPEC and BODY are two regular expressions that must match against
+the file name."
+  (let* ((reg (concat (regexp-quote body) "$"))
+        (tmp (assoc reg ada-other-file-alist)))
+    (if tmp
+       (setcdr tmp (list (cons spec (cadr tmp))))
+      (add-to-list 'ada-other-file-alist (list reg (list spec)))))
+
+  (let* ((reg (concat (regexp-quote spec) "$"))
+        (tmp (assoc reg ada-other-file-alist)))
+    (if tmp
+       (setcdr tmp (list (cons body (cadr tmp))))
+      (add-to-list 'ada-other-file-alist (list reg (list body)))))
+
+  (add-to-list 'auto-mode-alist
+              (cons (concat (regexp-quote spec) "\\'") 'ada-mode))
+  (add-to-list 'auto-mode-alist
+              (cons (concat (regexp-quote body) "\\'") 'ada-mode))
+
+  (add-to-list 'ada-spec-suffixes spec)
+  (add-to-list 'ada-body-suffixes body)
+
+  (when (fboundp 'speedbar-add-supported-extension)
+    (speedbar-add-supported-extension spec)
+    (speedbar-add-supported-extension body))
+  )
+
+(defun ada-show-secondary-error (other-window)
+  "Show the next secondary file reference in the compilation buffer.
+A secondary file reference is defined by text having text
+property `ada-secondary-error'.  These can be set by
+compiler-specific compilation filters.
+
+If OTHER-WINDOW (set by interactive prefix) is non-nil, show the
+buffer in another window."
+  (interactive "P")
+
+  ;; preserving the current window works only if the frame
+  ;; doesn't change, at least on Windows.
+  (let ((start-buffer (current-buffer))
+       (start-window (selected-window))
+       pos item file)
+    (set-buffer compilation-last-buffer)
+    (setq pos (next-single-property-change (point) 'ada-secondary-error))
+    (when pos
+      (setq item (get-text-property pos 'ada-secondary-error))
+      ;; file-relative-name handles absolute Windows paths from
+      ;; g++. Do this in compilation buffer to get correct
+      ;; default-directory.
+      (setq file (file-relative-name (nth 0 item)))
+
+      ;; Set point in compilation buffer past this secondary error, so
+      ;; user can easily go to the next one. For some reason, this
+      ;; doesn't change the visible point!?
+      (forward-line 1))
+
+    (set-buffer start-buffer);; for windowing history
+    (when item
+      (ada-goto-source
+       file
+       (nth 1 item); line
+       (nth 2 item); column
+       other-window)
+      (select-window start-window)
+      )
+    ))
+
+(defvar ada-goto-declaration-start 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 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 ()
+  "Call `ada-goto-declaration-start'."
+  (when ada-goto-declaration-start
+    (funcall ada-goto-declaration-start)))
+
+(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'."
+  (when ada-goto-declarative-region-start
+    (funcall ada-goto-declarative-region-start)))
+
+(defvar ada-next-statement-keyword nil
+  ;; Supplied by indentation engine
+  "Function called with no parameters; it should move forward to
+the next keyword in the statement following the one point is
+in (ie from 'if' to 'then').  If not in a keyword, move forward
+to the next keyword in the current statement. If at the last keyword,
+move forward to the first keyword in the next statement or next
+keyword in the containing statement.")
+
+(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)))
+
+(defun ada-next-statement-keyword ()
+  ;; Supplied by indentation engine
+  "See `ada-next-statement-keyword' variable."
+  (interactive)
+  (when ada-next-statement-keyword
+    (funcall ada-next-statement-keyword)))
+
+(defvar ada-prev-statement-keyword nil
+  ;; Supplied by indentation engine
+  "Function called with no parameters; it should move to the previous
+keyword in the statement following the one point is in (ie from
+'then' to 'if').  If at the first keyword, move to the previous
+keyword in the previous statement or containing statement.")
+
+(defun ada-prev-statement-keyword ()
+  "See `ada-prev-statement-keyword' variable."
+  (interactive)
+  (when ada-prev-statement-keyword
+    (funcall ada-prev-statement-keyword)))
+
+;;;; 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)
+  (ada-goto-declaration-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 compiler
+  "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)
+  (if ada-make-package-body
+      (funcall ada-make-package-body body-file-name)
+    (error "`ada-make-package-body' not set")))
+
+(defun ada-ff-create-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.
+  (let ((body-file-name (buffer-file-name)))
+    (ff-find-the-other-file)
+    (ada-make-package-body body-file-name)
+    ;; FIXME (later): if 'ada-make-package-body' fails, delete the body buffer
+    ;; so it doesn't get written to disk, and we can try again.
+
+    ;; back to the body, read in from the disk.
+    (ff-find-the-other-file)
+    (revert-buffer t t)
+    ))
+
+;;;; fill-comment
+
+(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."
+  (interactive "P")
+  (if (and (not (ada-in-comment-p))
+          (not (looking-at "[ \t]*--")))
+      (error "Not inside comment"))
+
+  (let* (indent from to
+        (opos (point-marker))
+        ;; we bind `fill-prefix' here rather than in ada-mode because
+        ;; setting it in ada-mode causes indent-region to use it for
+        ;; all indentation.
+        (fill-prefix ada-fill-comment-prefix)
+        (fill-column (current-fill-column)))
+
+    ;;  Find end of comment paragraph
+    (back-to-indentation)
+    (while (and (not (eobp)) (looking-at ".*--[ \t]*[^ \t\n]"))
+      (forward-line 1)
+
+      ;;  If we were at the last line in the buffer, create a dummy empty
+      ;;  line at the end of the buffer.
+      (if (eobp)
+         (insert "\n")
+       (back-to-indentation)))
+    (beginning-of-line)
+    (setq to (point-marker))
+    (goto-char opos)
+
+    ;;  Find beginning of paragraph
+    (back-to-indentation)
+    (while (and (not (bobp)) (looking-at ".*--[ \t]*[^ \t\n]"))
+      (forward-line -1)
+      (back-to-indentation))
+
+    (unless (bobp)
+      (forward-line 1))
+    (beginning-of-line)
+    (setq from (point-marker))
+
+    ;;  Calculate the indentation we will need for the paragraph
+    (back-to-indentation)
+    (setq indent (current-column))
+    ;;  unindent the first line of the paragraph
+    (delete-region from (point))
+
+    ;;  Remove the old postfixes
+    (goto-char from)
+    (while (re-search-forward (concat "\\(" ada-fill-comment-postfix "\\)" 
"\n") to t)
+      (delete-region (match-beginning 1) (match-end 1)))
+
+    (goto-char (1- to))
+    (setq to (point-marker))
+
+    ;;  Indent and justify the paragraph
+    (set-left-margin from to indent)
+    (if postfix
+       (setq fill-column (- fill-column (length ada-fill-comment-postfix))))
+
+    (fill-region-as-paragraph from to justify)
+
+    ;;  Add the postfixes if required
+    (if postfix
+       (save-restriction
+         (goto-char from)
+         (narrow-to-region from to)
+         (while (not (eobp))
+           (end-of-line)
+           (insert-char ?  (- fill-column (current-column)))
+           (insert ada-fill-comment-postfix)
+           (forward-line))
+         ))
+
+    (goto-char opos)))
+
+;;;; support for font-lock.el
+
+;; casing keywords defined here to keep the two lists together
+(defconst ada-83-keywords
+  '("abort" "abs" "accept" "access" "all" "and" "array" "at" "begin"
+    "body" "case" "constant" "declare" "delay" "delta" "digits" "do"
+    "else" "elsif" "end" "entry" "exception" "exit" "for" "function"
+    "generic" "goto" "if" "in" "is" "limited" "loop" "mod" "new"
+    "not" "null" "of" "or" "others" "out" "package" "pragma" "private"
+    "procedure" "raise" "range" "record" "rem" "renames" "return"
+    "reverse" "select" "separate" "subtype" "task" "terminate" "then"
+    "type" "use" "when" "while" "with" "xor")
+  "List of Ada 83 keywords.")
+
+(defconst ada-95-keywords
+  '("abstract" "aliased" "protected" "requeue" "tagged" "until")
+  "List of keywords new in Ada 95.")
+
+(defconst ada-2005-keywords
+  '("interface" "overriding" "synchronized")
+  "List of keywords new in Ada 2005.")
+
+(defconst ada-2012-keywords
+  '("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'."
+  (list
+
+   ;; keywords followed by a name that should be in function-name-face.
+   (list
+    (apply
+     'concat
+     (append
+      '("\\<\\("
+       "accept\\|"
+       "entry\\|"
+       "function\\|"
+       "package[ \t]+body\\|"
+       "package\\|"
+       "pragma\\|"
+       "procedure\\|"
+       "task[ \t]+body\\|"
+       "task[ \t]+type\\|"
+       "task\\|"
+       )
+      (when (member ada-language-version '(ada95 ada2005 ada2012))
+       '("\\|"
+         "protected[ \t]+body\\|"
+         "protected[ \t]+function\\|"
+         "protected[ \t]+procedure\\|"
+         "protected[ \t]+type\\|"
+         "protected"
+         ))
+      (list
+       "\\)\\>[ \t]*"
+       ada-name-regexp "?")))
+    '(1 font-lock-keyword-face) '(2 font-lock-function-name-face nil t))
+
+   ;; keywords followed by a name that should be in type-face.
+   (list (concat
+         "\\<\\("
+         "access[ \t]+all\\|"
+         "access[ \t]+constant\\|"
+         "access\\|"
+         "constant\\|"
+         "in[ \t]+reverse\\|"; loop iterator
+         "in[ \t]+not[ \t]+null\\|"
+         "in[ \t]+out[ \t]+not[ \t]+null\\|"
+         "in[ \t]+out\\|"
+         "in\\|"
+         ;; "return\\|" can't distinguish between 'function ... return 
<type>;' and 'return ...;'
+         ;; An indentation engine can, so a rule for this is added there
+         "of[ \t]+reverse\\|"
+         "of\\|"
+         "out\\|"
+         "subtype\\|"
+         "type"
+         "\\)\\>[ \t]*"
+         ada-name-regexp "?")
+        '(1 font-lock-keyword-face nil t) '(2 font-lock-type-face nil t))
+
+   ;; Keywords not treated elsewhere. After above so it doesn't
+   ;; override fontication of second or third word in those patterns.
+   (list (concat
+         "\\<"
+         (regexp-opt
+          (append
+           '("abort" "abs" "accept" "all"
+             "and" "array" "at" "begin" "case" "declare" "delay" "delta"
+             "digits" "do" "else" "elsif" "entry" "exception" "exit" "for"
+             "generic" "if" "in" "limited" "loop" "mod" "not"
+             "null" "or" "others" "private" "raise"
+             "range" "record" "rem" "renames" "reverse"
+             "select" "separate" "task" "terminate"
+             "then" "when" "while" "xor")
+           (when (member ada-language-version '(ada95 ada2005 ada2012))
+             '("abstract" "aliased" "requeue" "tagged" "until"))
+           (when (member ada-language-version '(ada2005 ada2012))
+             '("interface" "overriding" "synchronized"))
+           (when (member ada-language-version '(ada2012))
+             '("some"))
+           )
+          t)
+         "\\>")
+        '(0 font-lock-keyword-face))
+
+   ;; object and parameter declarations; word after ":" should be in
+   ;; type-face if not already fontified or an exception.
+   (list (concat
+         ":[ \t]*"
+         ada-name-regexp
+         "[ \t]*\\(=>\\)?")
+     '(1 (if (match-beginning 2)
+            'default
+          font-lock-type-face)
+        nil t))
+
+   ;; keywords followed by a name that should be in function-name-face if not 
already fontified
+   (list (concat
+         "\\<\\("
+         "end"
+         "\\)\\>[ \t]*"
+         ada-name-regexp "?")
+     '(1 font-lock-keyword-face) '(2 font-lock-function-name-face nil t))
+
+   ;; Keywords followed by a name that could be a type or a function (generic 
instantiation).
+   (list (concat
+         "\\<\\("
+         "new"
+         "\\)\\>[ \t]*"
+         ada-name-regexp "?[ \t]*\\((\\)?")
+        '(1 font-lock-keyword-face)
+        '(2 (if (match-beginning 3)
+                font-lock-function-name-face
+              font-lock-type-face)
+            nil t))
+
+   ;; keywords followed by a name that should be in type-face if not already 
fontified (for subtypes)
+   ;; after "new" to handle "is new"
+   (list (concat
+         "\\<\\("
+         "is"
+         "\\)\\>[ \t]*"
+         ada-name-regexp "?")
+     '(1 font-lock-keyword-face) '(2 font-lock-type-face nil t))
+
+   ;; Keywords followed by a comma separated list of names which
+   ;; should be in constant-face, unless already fontified. Ada mode 4.01 used 
this.
+   (list (concat
+         "\\<\\("
+         "goto\\|"
+         "use\\|"
+         ;; don't need "limited" "private" here; they are matched separately
+         "with"; context clause
+         "\\)\\>[ \t]*"
+         "\\(\\(?:\\sw\\|[_., \t]\\)+\\>\\)?"; ada-name-regexp, plus ", \t"
+         )
+        '(1 font-lock-keyword-face) '(2 font-lock-constant-face nil t))
+
+   ;; statement labels
+   '("<<\\(\\sw+\\)>>" 1 font-lock-constant-face)
+
+   ;; based numberic literals
+   (list "\\([0-9]+#[0-9a-fA-F_]+#\\)" '(1 font-lock-constant-face t))
+
+   ;; numeric literals
+   (list "\\W\\([-+]?[0-9._]+\\)\\>" '(1 font-lock-constant-face))
+
+   ))
+
+;;;; ada-mode
+
+;; 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
+
+  (interactive)
+  (kill-all-local-variables)
+  (setq major-mode 'ada-mode)
+  (setq mode-name "Ada")
+  (use-local-map ada-mode-map)
+  (set-syntax-table ada-mode-syntax-table)
+  (define-abbrev-table 'ada-mode-abbrev-table ())
+  (setq local-abbrev-table ada-mode-abbrev-table)
+
+  (set (make-local-variable 'syntax-propertize-function) 
'ada-syntax-propertize)
+  (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 (make-local-variable 'comment-start) "--")
+  (set (make-local-variable 'comment-end) "")
+  (set (make-local-variable 'comment-start-skip) "---*[ \t]*")
+  (set (make-local-variable 'comment-multi-line) nil)
+
+  ;; we _don't_ set `fill-prefix' here because that causes
+  ;; indent-region to use it for all indentation. See
+  ;; ada-fill-comment-paragraph.
+
+  ;; AdaCore standard style (enforced by -gnaty) requires two spaces
+  ;; after '--' in comments; this makes it easier to distinguish
+  ;; special comments that have something else after '--'
+  (set (make-local-variable 'comment-padding) "  ")
+
+  (set (make-local-variable 'require-final-newline) t)
+
+  (setq font-lock-defaults
+       '(ada-font-lock-keywords
+         nil t
+         ((?\_ . "w")))); treat underscore as a word component
+
+  (set (make-local-variable 'ff-other-file-alist)
+       '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-which-function)
+  (setq ff-search-directories 'compilation-search-path)
+  (ada-set-ff-special-constructs)
+
+  (set (make-local-variable 'add-log-current-defun-function)
+       'ada-add-log-current-function)
+
+  (add-hook 'which-func-functions 'ada-which-function nil t)
+
+  ;;  Support for align
+  (add-to-list 'align-dq-string-modes 'ada-mode)
+  (add-to-list 'align-open-comment-modes 'ada-mode)
+  (set (make-local-variable 'align-region-separate) ada-align-region-separate)
+  (set (make-local-variable 'align-indent-before-aligning) t)
+
+  ;; Exclude comments alone on line from alignment.
+  (add-to-list 'align-exclude-rules-list
+              '(ada-solo-comment
+                (regexp  . "^\\(\\s-*\\)--")
+                (modes   . '(ada-mode))))
+  (add-to-list 'align-exclude-rules-list
+              '(ada-solo-use
+                (regexp  . "^\\(\\s-*\\)\\<use\\>")
+                (modes   . '(ada-mode))))
+
+  (setq align-mode-rules-list ada-align-rules)
+
+  (easy-menu-add ada-mode-menu ada-mode-map)
+
+  (run-mode-hooks 'ada-mode-hook)
+
+  ;; If global-font-lock is not enabled, ada-syntax-propertize is
+  ;; not run when the text is first loaded into the buffer. Recover
+  ;; from that.
+  (syntax-ppss-flush-cache (point-min))
+  (syntax-propertize (point-max))
+
+  (add-hook 'hack-local-variables-hook 'ada-mode-post-local-vars nil t)
+  )
+
+(defun ada-mode-post-local-vars ()
+  ;; These are run after ada-mode-hook and file local variables
+  ;; because users or other ada-* files might set the relevant
+  ;; variable inside the hook or file local variables (file local
+  ;; variables are processed after the mode is set, and thus after
+  ;; ada-mode is run).
+
+  ;; This means to fully set ada-mode interactively, user must
+  ;; do M-x ada-mode M-; (hack-local-variables)
+
+  (when ada-auto-case (ada-case-activate-keys))
+
+  (when global-font-lock-mode
+    ;; This calls ada-font-lock-keywords, which depends on
+    ;; ada-language-version
+    (font-lock-refresh-defaults))
+
+  (cl-case ada-language-version
+   (ada83
+    (setq ada-keywords ada-83-keywords))
+
+   (ada95
+    (setq ada-keywords
+         (append ada-83-keywords
+                 ada-95-keywords)))
+
+   (ada2005
+    (setq ada-keywords
+         (append ada-83-keywords
+                 ada-95-keywords
+                 ada-2005-keywords)))
+   (ada2012
+    (setq ada-keywords
+         (append ada-83-keywords
+                 ada-95-keywords
+                 ada-2005-keywords
+                 ada-2012-keywords))))
+  )
+
+(put 'ada-mode 'custom-mode-group 'ada)
+
+(provide 'ada-mode)
+
+;;;;; Global initializations
+
+(require 'ada-build)
+
+(unless (featurep 'ada-indent-engine)
+  (require 'ada-wisi))
+
+(unless (featurep 'ada-compiler)
+  (require 'ada-gnat-compile))
+
+(unless (featurep 'ada-xref-tool)
+  (require 'ada-gnat-xref))
+
+(unless (featurep 'ada-skeletons)
+  (require 'ada-skel))
+
+;;; end of file
diff --git a/packages/ada-mode/ada-mode.info b/packages/ada-mode/ada-mode.info
new file mode 100644
index 0000000..da08d6c
--- /dev/null
+++ b/packages/ada-mode/ada-mode.info
@@ -0,0 +1,2347 @@
+This is ../ada-mode.info, produced by makeinfo version 4.13 from
+../ada-mode.texi.
+
+Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
+2008, 2009, 2010, 2011, 2012, 2013  Free Software Foundation, Inc.
+
+     Permission is granted to copy, distribute and/or modify this
+     document under the terms of the GNU Free Documentation License,
+     Version 1.3 or any later version published by the Free Software
+     Foundation; with no Invariant Sections, with the Front-Cover texts
+     being "A GNU Manual", and with the Back-Cover Texts as in (a)
+     below.  A copy of the license is included in the section entitled
+     "GNU Free Documentation License".
+
+     (a) The FSF's Back-Cover Text is: "You have the freedom to copy and
+     modify this GNU manual.  Buying copies from the FSF supports it in
+     developing GNU and promoting software freedom."
+
+INFO-DIR-SECTION Emacs editing modes
+START-INFO-DIR-ENTRY
+* Ada mode: (ada-mode).         Emacs mode for editing and navigating Ada code.
+END-INFO-DIR-ENTRY
+
+
+File: ada-mode.info,  Node: Top,  Next: Overview,  Prev: (dir),  Up: (dir)
+
+   Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
+2008, 2009, 2010, 2011, 2012, 2013  Free Software Foundation, Inc.
+
+     Permission is granted to copy, distribute and/or modify this
+     document under the terms of the GNU Free Documentation License,
+     Version 1.3 or any later version published by the Free Software
+     Foundation; with no Invariant Sections, with the Front-Cover texts
+     being "A GNU Manual", and with the Back-Cover Texts as in (a)
+     below.  A copy of the license is included in the section entitled
+     "GNU Free Documentation License".
+
+     (a) The FSF's Back-Cover Text is: "You have the freedom to copy and
+     modify this GNU manual.  Buying copies from the FSF supports it in
+     developing GNU and promoting software freedom."
+
+* Menu:
+
+* Overview::
+* Installation::                Installing Ada mode on your system
+* Customization::               Setting up Ada mode to your taste
+* Compiling Executing::         Working with your application within Emacs
+* Project files::               Describing the organization of your project
+* Moving Through Ada Code::     Moving easily through Ada sources
+* Identifier completion::       Finishing words automatically
+* Indentation::                 Indenting your code automatically as you type
+* Statement skeletons::
+* Aligning code::
+* Automatic casing::            Adjusting the case of words automatically
+* Comment Handling::            Reformatting comments easily
+* Key summary::
+* Developer overview::
+* GNU Free Documentation License::
+* Index::
+
+
+File: ada-mode.info,  Node: Overview,  Next: Installation,  Prev: Top,  Up: Top
+
+1 Overview
+**********
+
+The Emacs mode for programming in Ada helps the user in reading
+existing code and facilitates writing new code.
+
+   When the Gnu Ada compiler GNAT is used, the cross-reference
+information output by the compiler is used to provide powerful code
+navigation (jump to definition, find all uses, etc).
+
+   When you open a file with a file extension of `.ads' or `.adb',
+Emacs will automatically load and activate Ada mode.
+
+   Ada mode works without any customization, if you are using the GNAT
+compiler (`https://libre2.adacore.com/') and the GNAT default naming
+convention.
+
+   You must customize a few things if you are using a different file
+naming convention or compiler; *Note Other compiler::, *Note
+Non-standard file names::.
+
+   In addition, you may want to customize the indentation,
+capitalization, and other things; *Note Other customization::.
+
+   Finally, for large Ada projects, you will want to set up an Emacs
+Ada mode project file for each project; *Note Project files::. Note
+that these are different from the GNAT project files used by gnatmake
+and other GNAT commands.
+
+   *Note Running Debuggers Under Emacs: (emacs)Running Debuggers Under
+Emacs, for general information on debugging.
+
+
+File: ada-mode.info,  Node: Installation,  Next: Customization,  Prev: 
Overview,  Up: Top
+
+2 Installation
+**************
+
+Ada mode is part of the standard Emacs distribution; if you use that,
+no files need to be installed.
+
+   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'. The
+separate distribution may be more recent.
+
+   For installing the separate distribution, see the `README' file in
+the distribution.
+
+   To see what version of Ada mode you have installed, do `M-x
+ada-mode-version'.
+
+* Menu:
+
+* gnatinspect::
+
+
+File: ada-mode.info,  Node: gnatinspect,  Prev: Installation,  Up: Installation
+
+2.1 gnatinspect
+===============
+
+Ada mode has experimental support for the new AdaCore cross reference
+tool `gnatinspect', which supports Ada, C, C++, and any other language
+for which gcc provices the `-fdump-xref'.
+
+   `gnatinspect' is distributed as part of `gnatcoll'. Ada mode
+requires the very latest version, in `gnatcoll 1.7w' distributed with
+GNATPro 7.2 preview.
+
+   To build `gnatinspect':
+     tar xf ~/Downloads/gnatcoll-1.7w-src.tgz
+     cd gnatcoll-1.7w-src
+     ./configure --prefix=/usr/gnat-7.1.2
+     make Gnatcoll_Build=Debug
+     sudo make Gnatcoll_Build=Debug install
+
+
+File: ada-mode.info,  Node: Customization,  Next: Compiling Executing,  Prev: 
Installation,  Up: Top
+
+3 Customizing Ada mode
+**********************
+
+Here we assume you are familiar with setting variables in Emacs, either
+thru 'customize' or in elisp (in your `.emacs' file). For a basic
+introduction to customize, elisp, and Emacs in general, see the
+tutorial (`C-h t').
+
+* Menu:
+
+* Non-standard file names::
+* Other compiler::
+* Other cross-reference::
+* Other customization::
+
+
+File: ada-mode.info,  Node: Non-standard file names,  Next: Other compiler,  
Prev: Customization,  Up: Customization
+
+3.1 Non-standard file names
+===========================
+
+By default, Ada mode is configured to use the GNAT file naming
+convention, where file names are a simple modification of the Ada
+names, and the extension for specs and bodies are `.ads' and `.adb',
+respectively.
+
+   Emacs uses the file extension to enable Ada mode; Ada mode uses the
+file extentions to allow moving from a package body to the
+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.
+
+   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
+`.emacs' file:
+
+     ;; Tell Ada mode about spec and body extensions
+     (ada-add-extensions "_s.ada" "_b.ada")
+
+     ;; Tell Emacs to use Ada mode for those extensions
+     (add-to-list 'auto-mode-alist '("\\.ada\\'" . ada-mode))
+
+   You can define additional extensions:
+
+     (ada-add-extensions ".ads" "_b.ada")
+     (ada-add-extensions ".ads" ".body")
+
+   This means that whenever Ada mode looks for the body for a file
+whose extension is `.ads', it will take the first available file that
+ends with either `.adb', `_b.ada' or `.body'.
+
+   Simililarly, if Ada mode is looking for a spec, it will look for
+`.ads' or `_s.ada'.
+
+   If the filename excluding the extension is not derived from the Ada
+name following the GNAT convention, you need to provide an alternate
+function for `ada-file-name-from-ada-name'. Doing that is beyond the
+scope of this manual; see the current definitions in `ada-mode.el' and
+`ada-gnat.el' for examples.
+
+
+File: ada-mode.info,  Node: Other compiler,  Next: Other cross-reference,  
Prev: Non-standard file names,  Up: Customization
+
+3.2 Other compiler
+==================
+
+The project variable `ada_compiler' (default elisp variable
+`ada-compiler') is used to index several variables that point to the
+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.
+
+
+File: ada-mode.info,  Node: Other cross-reference,  Next: Other customization, 
 Prev: Other compiler,  Up: Customization
+
+3.3 Other cross-reference
+=========================
+
+The project variable `ada_xref' (default elisp variable
+`ada-xref-tool') is used to index several variables that point to the
+cross-reference-tool-specific functions for corresponding Ada mode
+operations.
+
+   To use a cross reference tool other than gnatxref, you must write
+Emacs lisp code that provides the interface to the compiler, and set
+`ada-xref-tool' and the indirection variables. This has already been
+done for `gnatinspect'; set `ada-xref-tool' to `'gnat_inspect'.
+
+   See `ada-gnat-xref.el' and `gnat-inspect.el' for examples.
+
+
+File: ada-mode.info,  Node: Other customization,  Prev: Other cross-reference, 
 Up: Customization
+
+3.4 Other customization
+=======================
+
+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.
+
+   To modify a specific variable, you can directly call the function
+`customize-variable'; just type `M-x customize-variable <RET>
+VARIABLE-NAME <RET>').
+
+   Alternately, you can specify variable settings in the Emacs
+configuration file, `~/.emacs'. This file is coded in Emacs lisp, and
+the syntax to set a variable is the following:
+     (setq variable-name value)
+
+   Some general Emacs settings that are useful for Ada files:
+`delete-trailing-whitespace'
+     Deletes space, tab at end of line and blank lines at end of buffer.
+
+`untabify'
+     Deletes tab characters that have crept into the file.
+
+`indent-tabs-mode'
+     Don't insert tab characters when indenting.
+
+`copyright-update'
+     Updates the copyright date in the file header comment, to the
+     current year.
+
+`electric-pair-mode'
+     Insert a matching right paren when you type a left paren.
+
+`hippie-expand'
+     Bind hippie-expand to a key; it expands the word before point,
+     using words from current buffer, other buffers, file names, etc;
+     see `hippie-expand-try-functions-list'. You can also add
+     `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::).
+
+   The above can all be set by the following code in your `~/.emacs'.
+Note that some are functions are added to `before-save-hook'; they run
+just before a buffer is written to disk.
+     (setq-default indent-tabs-mode nil)
+     (electric-pair-mode 1)
+     (require 'ada-mode)
+     (add-to-list 'hippie-expand-try-functions-list 'ada-skel-hippie-try)
+     (define-key ada-mode-map "\C-e"     'hippie-expand)
+     (add-hook 'ada-mode-hook
+        (lambda ()
+         (add-hook 'before-save-hook 'delete-trailing-whitespace nil t)
+         (add-hook 'before-save-hook 'copyright-update nil t)
+         (add-hook 'before-save-hook
+                   (lambda () (untabify (point-min) (point-max)))
+                    nil t)))
+
+
+File: ada-mode.info,  Node: Compiling Executing,  Next: Project files,  Prev: 
Customization,  Up: Top
+
+4 Compiling Executing
+*********************
+
+Ada projects can be compiled, linked, and executed using commands on
+the Ada menu. All of these commands can be customized via a project
+file (*note Project files::), but the defaults are sufficient for using
+the 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.
+
+* Menu:
+
+* Compile commands::
+* Compiling Examples::
+* Compiler errors::
+
+
+File: ada-mode.info,  Node: Compile commands,  Next: Compiling Examples,  
Prev: Compiling Executing,  Up: Compiling Executing
+
+4.1 Compile commands
+====================
+
+Here are the commands for building an Ada project and running the main
+program.
+
+   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
+to the current file if not yet set, but is also set by the "set main
+and build" command.
+
+`Check file'
+     Compiles the current file in syntax check mode, by running
+     `check_cmd' defined in the current project file. This typically
+     runs faster than full compile mode, speeding up finding and fixing
+     compilation errors.
+
+     This sets `main' only if it has not been set yet.
+
+`Compile file'
+     Compiles the current file, by running `comp_cmd' from the current
+     project file.
+
+     This does not set `main'.
+
+`Set main and Build'
+     Sets `main' to the current file, then executes the Build command.
+
+`Show main'
+     Display `main' in the message buffer.
+
+`Build'
+     Compiles all obsolete units of the current `main', and links
+     `main', by running `make_cmd' from the current project.
+
+     This sets `main' only if it has not been set yet.
+
+`Run'
+     Executes the main program in a shell, displayed in a separate Emacs
+     buffer. This runs `run_cmd' from the current project. The
+     execution buffer allows for interactive input/output.
+
+     To modify the run command, in particular to provide or change the
+     command line arguments, type `C-u' before invoking the command.
+
+     This command is not available for a cross-compilation toolchain.
+
+   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 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.
+
+   Note that Build can be invoked from any Ada buffer; typically you
+will be fixing errors in files other than the main, but you don't have
+to switch back to the main to invoke the compiler again.
+
+   Novices and students typically work on single-file Ada projects. In
+this case, `C-c C-m' will normally be the only command needed; it will
+build the current file, rather than the last-built main.
+
+   There are three ways to change `main':
+
+  1. Invoke `Ada | Set main and Build', which sets `main' to the
+     current file.
+
+  2. Invoke `Ada | Project | Edit', edit `main' and `main', and click
+     `[save]'
+
+  3. Invoke `Ada | Project | Load', and load a project file that
+     specifies `main'
+
+
+
+File: ada-mode.info,  Node: Compiling Examples,  Next: Compiler errors,  Prev: 
Compile commands,  Up: Compiling Executing
+
+4.2 Compiling Examples
+======================
+
+We present several small projects, and walk thru the process of
+compiling, linking, and running them.
+
+   The first example illustrates more Ada mode features than the others;
+you should work thru that example before doing the others.
+
+   All of these examples assume you are using GNAT.
+
+   The source for these examples is available on the Emacs Ada mode
+website mentioned in *Note Installation::.
+
+* Menu:
+
+* 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 multiple GNAT project files::
+* Use a Makefile::
+
+
+File: ada-mode.info,  Node: No project files,  Next: Set compiler options,  
Prev: Compiling Examples,  Up: Compiling Examples
+
+4.2.1 No project files
+----------------------
+
+This example uses no project files.
+
+   First, create a directory `Example_1', containing:
+
+   `hello.adb':
+
+     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
+compiler error handling.
+
+   `hello_2.adb':
+
+     with Hello_Pkg;
+     procedure Hello_2
+     is begin
+        Hello_Pkg.Say_Hello;
+     end Hello_2;
+
+   This file has no errors.
+
+   `hello_pkg.ads':
+
+     package Hello_Pkg is
+        procedure Say_Hello;
+     end Hello_Pkg;
+
+   This file has no errors.
+
+   `hello_pkg.adb':
+
+     with Ada.Text_IO;
+     package Hello_Pkg is
+        procedure Say_Hello
+        is begin
+           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.
+
+   In buffer `hello.adb', invoke the menu entry `Ada | Build | Check
+syntax'. 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_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
+     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
+
+     Compilation exited abnormally with code 4 at Fri Oct 18 04:23:54
+
+   The lines with actual errors (starting with `hello.adb') are
+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.
+
+   To fix the error, invoke `Ada | Build | Fix compilation error'; this
+adds "Ada.Text_Io." to the line:
+
+         Ada.Text_Io.Put_Line ("hello from hello.adb");
+
+   Now invoke `Ada | Build | Show main'; this displays `Ada mode main:
+hello'.
+
+   Now (in buffer `hello.adb'), invoke `Ada | Build | Build'. You are
+prompted to save the file (if you haven't already). Then the
+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
+
+     Compilation finished at Fri Oct 18 20:39:34
+
+   The compilation has succeeded without errors; `hello.exe' now exists
+in the same directory as `hello.adb'.
+
+   Now invoke `Ada | Build | Run'. The `*compilation*' buffer is
+displayed, containing
+
+     -*- mode: compilation; default-directory: 
"c:/Projects/org.emacs.ada-mode.stephe-1/test/Example_1/" -*-
+     Compilation started at Fri Oct 18 20:41:53
+
+     ./hello
+     Hello from hello.adb
+
+     Compilation finished at Fri Oct 18 20:41:53
+
+   That completes the first part of this example.
+
+   Now we will compile a multi-file project. Open the file
+`hello_2.adb', invoke `Ada | Build | Set main and Build'. This finds an
+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
+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::.
+
+   Invoke `Ada | Build | Show main'; this displays `Ada mode main:
+hello_2'.
+
+   Move to the error with `C-x `', and fix the error by adding `body':
+
+     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
+has remembered the main file, in the project variable `main', and used
+it for the Build command.
+
+   Finally, again while in `hello_pkg.adb', invoke `Ada | Build | Run'.
+The `*compilation*' buffer displays `Hello from hello_pkg.adb'.
+
+   One final point. If you switch back to buffer `hello.adb', and
+invoke `Ada | Build | Run', `hello_2.exe' will be run. That is because
+`main' is still set to `hello_2', as you can see when you invoke `Ada |
+Build | Show main'.
+
+   There are two ways to change `main':
+
+  1. Invoke `Ada | Build | Set main and Build', which sets `main' to
+     the current file.
+
+  2. Invoke `Ada | Build | Set Project ...', and select a project file
+     that specifies `main'.
+
+
+
+File: ada-mode.info,  Node: Set compiler options,  Next: Set source search 
path,  Prev: No project files,  Up: Compiling Examples
+
+4.2.2 Set compiler options
+--------------------------
+
+This example illustrates using an Emacs Ada mode 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
+buffer)'.
+
+   In directory `Example_2', create these files:
+
+   `hello.adb':
+
+     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
+argument list.
+
+   `hello.adp':
+
+     comp_opt=-gnatyt
+
+   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
+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
+     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:12: (style) space required
+     gnatmake: "hello.adb" compilation error
+
+   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.
+
+   Fixing the error, linking and running the code proceed as in *note
+No project files::.
+
+
+File: ada-mode.info,  Node: Set source search path,  Next: Use GNAT 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.
+
+   Create the directory `Example_3', containing:
+
+   `hello_pkg.ads':
+
+     package Hello_Pkg is
+        procedure Say_Hello;
+     end Hello_Pkg;
+
+   `hello_pkg.adb':
+
+     with Ada.Text_IO;
+     package Hello_Pkg is
+        procedure Say_Hello
+        is begin
+           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/hello_3.adb':
+
+     with Hello_Pkg;
+     with Ada.Text_IO; use Ada.Text_IO;
+     procedure Hello_3
+     is begin
+        Hello_Pkg.Say_Hello;
+        Put_Line ("From hello_3");
+     end Hello_3;
+
+   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
+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.
+
+   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
+     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.
+
+   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.
+
+   Fixing the error, linking and running the code proceed as in *note
+No project files::.
+
+
+File: ada-mode.info,  Node: Use GNAT project file,  Next: Use multiple GNAT 
project files,  Prev: Set source search path,  Up: Compiling Examples
+
+4.2.4 Use GNAT project file
+---------------------------
+
+In this example, we show how to use a GNAT project file, with no Ada
+mode project file.
+
+   Create the directory `Example_4', containing:
+
+   `hello_pkg.ads':
+
+     package Hello_Pkg is
+        procedure Say_Hello;
+     end Hello_Pkg;
+
+   `hello_pkg.adb':
+
+     with Ada.Text_IO;
+     package Hello_Pkg is
+        procedure Say_Hello
+        is begin
+           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_4/Gnat_Project', containing
+these files:
+
+   `Gnat_Project/hello_4.adb':
+
+     with Hello_Pkg;
+     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.
+
+   `Gnat_Project/hello_4.gpr':
+
+     project Hello_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::.
+
+
+File: ada-mode.info,  Node: Use multiple GNAT project files,  Next: Use a 
Makefile,  Prev: Use GNAT 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.
+
+   Create the directory `Example_4' as specified in *note Use GNAT
+project file::.
+
+   Create the directory `Example_5', containing:
+
+   `hello_5.adb':
+
+     with Hello_Pkg;
+     with Ada.Text_IO; use Ada.Text_IO;
+     procedure Hello_5
+     is begin
+        Hello_Pkg.Say_Hello;
+        Put_Line ("From hello_5");
+     end Hello_5;
+
+   There are no errors in this file.
+
+   `hello_5.adp':
+
+     ada_project_path=../Example_4/Gnat_Project
+     gpr_file=hello_5.gpr
+
+   `hello_5.gpr':
+
+     with "hello_4";
+     project Hello_5 is
+        for Source_Dirs use (".");
+        package Compiler is
+           for Default_Switches ("Ada") use ("-g", "-gnatyt");
+        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.
+
+   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/" -*-
+     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
+
+   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.
+
+
+File: ada-mode.info,  Node: Use a Makefile,  Prev: Use multiple GNAT project 
files,  Up: Compiling Examples
+
+4.2.6 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 `Example_4, Example_5' as specified in *note
+Use GNAT project file::,  *note Use multiple GNAT project files::.
+
+   In `Example_5', add the file:
+
+   `Makefile':
+
+     # build and run hello_5 project
+
+     all : build run
+
+     .PHONY : force
+
+     build : force
+             gprbuild -Phello_5.gpr hello_5
+
+     run :
+             ./hello_5
+
+     clean :
+             gnatclean -r -Phello_5
+
+     export GPR_PROJECT_PATH = ../Example_4/Gnat_Project
+
+     # Local Variables:
+     # eval:(ada-parse-prj-file "hello_5.adp")
+     # eval:(ada-select-prj-file "hello_5.adp")
+     # End:
+
+   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'.
+
+   In `Makefile', invoke `Tools | Compile...', and accept the default
+make command. This runs the `all' target, which builds `hello_5' and
+runs it.
+
+
+File: ada-mode.info,  Node: Compiler errors,  Prev: Compiling Examples,  Up: 
Compiling Executing
+
+4.3 Compiler errors
+===================
+
+The `Check syntax' and `Build' commands, or running `make', place
+compilation errors in a separate buffer named `*compilation*'.
+
+   Each line in this buffer will become active: you can simply click on
+it with the middle button of the mouse, or move point to it and press
+<RET>. Emacs will then display the relevant source file and put point
+on the line and column where the error was found.
+
+   You can also press the `C-x `' key (`next-error'), and Emacs will
+jump to the first error. If you press that key again, it will move you
+to the second error, and so on.
+
+   Some error messages also include references to other files. These
+references are accessed via `C-c `'.
+
+
+File: ada-mode.info,  Node: Project files,  Next: Moving Through Ada Code,  
Prev: Compiling Executing,  Up: Top
+
+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.
+
+   The default file extension for Ada mode project files is `*.adp'.
+You can use a different extension by adding it 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.
+
+* Menu:
+
+* Project file overview::
+* Project file variables::
+
+
+File: ada-mode.info,  Node: Project file overview,  Next: Project file 
variables,  Prev: Project files,  Up: Project files
+
+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
+
+   Some variables (like `src_dir') are lists; multiple occurrences are
+concatenated.
+
+   There must be no space between the variable name and "=", and no
+trailing spaces.
+
+   The current project file is given by the lisp variable
+`ada-prj-default-project-file'.
+
+   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:
+
+   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. Any other extension is 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.
+
+
+File: ada-mode.info,  Node: Project file variables,  Prev: Project file 
overview,  Up: Project files
+
+5.2 Project file variables
+==========================
+
+Some project file variables can also be defined in elisp variables.
+
+   To set a project variable that is a list, specify each element of the
+list on a separate line in the project file.
+
+   Process environment variables can be referenced using the normal
+`$var' syntax.
+
+   Most project variables have defaults that can be changed by setting
+elisp variables; the table below identifies the lisp 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 to absolute
+relative to the directory containing the project file.
+
+   Ada mode defines some project variables; others are defined by the
+compiler.
+
+   Here is the list of variables valid for all compilers. 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.
+
+`case_keyword'   [default: `ada-case-keyword, downcase-word']
+     Function to call to adjust the case of an Ada keywords.
+
+`case_strict'    [default: `ada-case-strict, t']
+     If non-nil, force Mixed_Case for identifiers.  Otherwise, allow
+     UPPERCASE for identifiers.
+
+`casing'         [default: `ada-case-exception-file, nil']
+     List of files containing casing exceptions. *Note Automatic
+     casing::.
+
+`src_dir'        [default: `"."']
+     A list of directories to search for source files.
+
+`xref_tool'      [default: `ada-xref-tool, gnat-xref']
+     Cross reference tool for this project.
+
+
+   The following variables are valid with the GNAT compiler:
+
+`ada_project_path'   [default: `""']
+     A list of directories to search for GNAT project files.
+
+     If set, the `ADA_PROJECT_PATH' process environment variable is set
+     to this value in the child process that runs GNAT tools. If not
+     set, `ADA_PROJECT_PATH' in the child process is inherited from the
+     Emacs process.
+
+     If you have the `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.
+
+`gpr_file'   [default: `""']
+     The GNAT project file.
+
+     If set, the source and project directories specified in the GNAT
+     project file are appended to `src_dir' and `ada_project_path'.
+     This allows specifying Ada source directories with a GNAT project
+     file, and other source directories with the Emacs project file.
+
+
+
+File: ada-mode.info,  Node: Moving Through Ada Code,  Next: Identifier 
completion,  Prev: Project files,  Up: Top
+
+6 Moving Through Ada Code
+*************************
+
+There are several commands to navigate through Ada code. All these
+functions are available through the Ada menu and keybindings.
+
+   Some of these commands rely on facilities provided by the compiler;
+the standard Emacs Ada mode only supports the GNAT compiler, but others
+can be added.
+
+`C-c C-d'
+     Move from any use of an identifier to its declaration, for from a
+     declaration to its body.
+
+`C-c M-d'
+     Move from a child type declaration to the parent type declaration.
+
+`C-c C-n'
+     Move to the next keyword in the current statement.
+
+     For example, if point is on `if', move to `then'.
+
+`C-c C-p'
+     Move to the previous keyword in the current statement.
+
+     For example, if point is on `then', move to `if'.
+
+`C-c C-o'
+     Switch between corresponding spec and body. There are several
+     special cases:
+        *     If the region is active, it is assumed to contain an Ada
+          package     name; position point on the corresponding package
+          declaration.
+
+        *     If point is in the start line of a top level child package
+             declaration (but not package body), or a child subprogram
+          spec or     body, position point on the corresponding parent
+          package     declaration.
+
+        *     If point is in the start line of a top level separate
+          body,     position point on the corresponding separate stub
+          declaration.
+
+        *     If point is in a subprogram, position point on the
+          corresponding     declaration or body in the other file.
+
+
+`C-c C-r'
+     Show all references to the identifier surrounding point. Use `C-x
+     `' (`next-error') to visit each reference (as for compilation
+     errors).
+
+`C-c C-x'
+     Show all declarations that override the primitive procedure at
+     point. Use `C-x `' (`next-error') to visit each reference (as for
+     compilation errors).
+
+`C-u SPACE'
+     Jump back to the previous location.
+
+
+
+File: ada-mode.info,  Node: Identifier completion,  Next: Indentation,  Prev: 
Moving Through Ada Code,  Up: Top
+
+7 Identifier completion
+***********************
+
+Emacs provides a general way of completing identifiers: `M-/' (bound to
+`dabbrev-expand'). This is an easy way to type faster: you just have to
+type the first few letters of an identifier, and then loop through all
+the possible completions.
+
+   `M-/' works by parsing all open Ada files for possible completions.
+
+   For instance, if the words `my_identifier' and `my_subprogram' are
+the only words starting with `my' in any of the open Ada files, then
+you will have this scenario:
+
+     You type:  myM-/
+     Emacs inserts:  `my_identifier'
+     If you press M-/ once again, Emacs replaces `my_identifier' with
+     `my_subprogram'.
+     Pressing M-/ once more will bring you back to `my_identifier'.
+
+   This is a very fast way to do completion, and the casing of words
+will also be respected.
+
+
+File: ada-mode.info,  Node: Indentation,  Next: Statement skeletons,  Prev: 
Identifier completion,  Up: Top
+
+8 Indentation
+*************
+
+Ada mode comes with a full set of rules for automatic indentation. You
+can also configure the indentation, via the following variables:
+
+`ada-indent'                  (default value: 3)
+     Number of columns for default indentation.
+
+`ada-indent-broken'           (default value: 2)
+     Number of columns to indent the continuation of a broken line.
+
+`ada-indent-comment-col-0'  (default value: nil)
+     If non-nil, comments currently starting in column 0 are left in
+     column 0.  Otherwise, they are indented with previous comments or
+     code.
+
+`ada-indent-label'            (default value: -3)
+     Number of columns to indent a label.
+
+`ada-indent-record-rel-type'  (default value: 3)
+     Indentation for `record' relative to `type' or `use'.
+
+`ada-indent-renames'           (default value: 2)
+     Indentation for `renames' relative to the matching subprogram
+     keyword.
+
+     If the subprogram has parameters then if `ada-indent-renames' is
+     zero or less the indentation is abs `ada-indent-renames' relative
+     to the open parenthesis; if `ada-indent-renames' is one or more
+     the indentation is relative to the line containing the keyword.
+
+     If the subprogram has no parameters then `ada-indent-broken' the
+     indentation is relative to the indentation of the line containing
+     the keyword.
+
+`ada-indent-return'           (default value: 0)
+     Indentation for `return' relative to the matching  `function'.
+
+     If the function has parameters, then if `ada-indent-return' is
+     zero or less the indentation is abs `ada-indent-return' relative
+     to the open parenthesis; if `ada-indent-return' is one or more,
+     indentation is relative to line containing `function'.
+
+     If the function has no parameters, `ada-indent-broken' is used
+     relative to line containing `function'.
+
+`ada-indent-use'  (default value: ada-indent-broken)
+     Indentation for the lines in a `use' statement.
+
+`ada-indent-when'             (default value: 3)
+     Indentation for `when' relative to `exception', `case', or `or' in
+     `select'.
+
+`ada-indent-with'             (default value: ada-indent-broken)
+     Indentation for the lines in a `with' context clause.
+
+
+   The following keys indent portions of the text:
+`RET'
+     Insert and indent a new line.
+
+`TAB'
+     Indent the current line, or the current region.
+
+`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 correct. 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:
+
+     if A then
+        B;
+     end if;
+
+   when you type `RET B', `B' is indented to the same column as `if'.
+Then when you type the final `;', 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::.
+
+
+File: ada-mode.info,  Node: Statement skeletons,  Next: Aligning code,  Prev: 
Indentation,  Up: Top
+
+9 Statement skeletons
+*********************
+
+`C-c C-e' expands the previous one or two words into a statment
+skeleton. For example, `if C-c C-e' expands to:
+
+     if  then
+     elsif  then
+     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 statement from the word before
+that. Some expansions prompt for more information, such as whether a
+spec or body is desired. For example, `package A_Package C-c C-e' first
+prompts for "body" or "spec". If "spec" is selected, the following code
+is inserted:
+
+     package A_Package is
+     private
+     end A_Package;
+
+   Named blocks work similarly: `declare A_Block C-c C-e' expands
+(without prompting) to:
+
+     A_Block:
+        declare
+        begin
+        exception
+        end A_Block;
+
+   Note that the order of the keyword `declare' and the name `A_Block'
+are reversed in the expansion; this may take some getting used to.
+
+
+File: ada-mode.info,  Node: Aligning code,  Next: Automatic casing,  Prev: 
Statement skeletons,  Up: Top
+
+10 Aligning code
+****************
+
+Aligning code adds space in each line so that similar parts of
+successive lines are aligned vertically. For example, a sequence of
+declarations:
+
+     A : Integer;
+     Another : Float := 1.0;
+     More : Integer := 2;
+
+   changes to this when aligned:
+
+     A       : Integer;
+     Another : Float   := 1.0;
+     More    : Integer := 2;
+
+   Alignment is invoked by `C-c C-a', which aligns the sequence of
+statements surrounding point, or within the selected region.
+
+   Parameter lists are also aligned:
+
+        procedure Foo
+          (A : in Integer;
+           Another : out Float := 1.0;
+           More : in out Integer := 2);
+
+   is aligned to:
+
+        procedure Foo
+          (A       : in     Integer;
+           Another :    out Float   := 1.0;
+           More    : in out Integer := 2);
+
+
+File: ada-mode.info,  Node: Automatic casing,  Next: Comment Handling,  Prev: 
Aligning code,  Up: Top
+
+11 Automatic casing
+*******************
+
+Casing of identifiers, attributes and keywords is automatically
+performed while typing when the variable `ada-auto-case' is non-nil.
+Every time you type a word separator, the previous word is
+automatically cased.
+
+   You can customize the automatic casing with the following variables:
+
+`ada-case-keyword'
+     Value must be one of:
+    `downcase-word'
+          Ada keywords will be lowercase.
+
+    `upcase-word'
+          Ada keywords will be uppercase.
+
+`ada-case-strict'
+     If non-nil, all identifiers are forced to `Mixed_Case'; first
+     letter, and letter following "_" are uppercase; rest are lowercase.
+
+     If nil, the mixed case characters in identifiers are forced to
+     upper case, but the other characters are not modified. That allows
+     typing all uppercase identifiers without defining an 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.
+
+   If the word starts with an asterisk (`*'), it defines the casing of
+a word fragemnt (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' (`C-c C-y', `ada-case-create-exception') or `Ada | Casing |
+Create partial exception' (`C-c C-M-y').  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.
+
+   Other keys and menu entries are defined:
+
+`C-c C-w'
+     Adjust case of the word at point. With prefix arg, adjust case
+     even if in comment. Normally, comments are not affected by case
+     adjust.
+
+`Ada | Casing | Adjust case region'
+     Adjust case in the active region.
+
+`Ada | Casing | Adjust case buffer'
+     Adjust case in the active buffer.
+
+
+
+File: ada-mode.info,  Node: Comment Handling,  Next: Key summary,  Prev: 
Automatic casing,  Up: Top
+
+12 Comment Handling
+*******************
+
+By default, comment lines get indented like Ada code. There are a few
+additional functions to handle comments:
+
+`M-;'
+     If the region is active, comment or uncomment it.
+
+     If the current line is empty, start a comment.
+
+     Otherwise, add a comment at the end of the line, in a column given
+     by `comment-column'.
+
+`M-q'
+     Fill the current comment paragraph.
+
+
+File: ada-mode.info,  Node: Key summary,  Next: Developer overview,  Prev: 
Comment Handling,  Up: Top
+
+13 Key summary
+**************
+
+`M-/'
+     *Note Identifier completion::.  Complete the word before point;
+     repeat to cycle thru possible completions.
+
+`M-;'
+     *Note Comment Handling::.  If the region is active, comment or
+     uncomment it.
+
+`RET'
+     *Note Indentation::.  Insert and indent a new line.
+
+`TAB'
+     *Note Indentation::.  Indent the current line, or the current
+     region.
+
+`C-c TAB'
+     *Note Indentation::.  Indent the current statement or declaration.
+
+`C-c `'
+     *Note Compiler errors::.  Move to the location of the secondary
+     reference in the current compilation error.
+
+`C-c C-a'
+     *Note Aligning code::.  Align code.
+
+`C-c C-d'
+     *Note Moving Through Ada Code::.  Move from any use of an
+     identifier to its declaration, for from a declaration to its body.
+
+`C-c M-d'
+     *Note Moving Through Ada Code::.  Move from a child type
+     declaration to the parent type declaration.
+
+`C-c C-e'
+     *Note Statement skeletons::.  Expand previous one or two words
+     into a statement or declaration skeleton.
+
+`C-c C-n'
+     *Note Moving Through Ada Code::.  Move to the next keyword in the
+     current statement.
+
+`C-c C-o'
+     *Note Moving Through Ada Code::.  Switch between corresponding
+     spec and body, or find other spec.
+
+`C-c C-p'
+     *Note Moving Through Ada Code::.  Move to the previous keyword in
+     the current statement.
+
+`C-c C-r'
+     *Note Moving Through Ada Code::.  Show all references to the
+     identifier surrounding point.
+
+`C-c C-w'
+     *Note Automatic casing::.  Adjust case of the word at point. With
+     prefix arg, adjust case even if in comment.
+
+`C-c C-x'
+     *Note Moving Through Ada Code::.  Show all declarations that
+     override the primitive procedure at point.
+
+`C-c C-y'
+     *Note Automatic casing::.  Create case exception.
+
+`C-x `'
+     *Note Compiler errors::.  Move to the location of the next
+     compilation error or show result.
+
+`M-q'
+     *Note Comment Handling::.  Fill the current comment paragraph.
+
+
+
+File: ada-mode.info,  Node: Developer overview,  Next: GNU Free Documentation 
License,  Prev: Key summary,  Up: Top
+
+14 Developer overview
+*********************
+
+If you'd like to contribute to Ada mode, or just understand the
+sources, here's an overview.
+
+* Menu:
+
+* Directory structure::
+* Package organization::
+* OpenToken::
+
+
+File: ada-mode.info,  Node: Directory structure,  Next: Package organization,  
Prev: Developer overview,  Up: Developer overview
+
+14.1 Directory structure
+========================
+
+`org.emacs.ada-mode.stephe-1'
+     Main source.
+
+     File extensions:
+    `*.el'
+          Elisp files; main code.
+
+    `*.elc'
+          Byte-compiled elisp files, not in the distribution. Generated
+          by the Makefile target `byte-compile'.
+
+          Compiling the parse tables (`*-wy.el') speeds up loading them
+          significantly. Compiling other files speeds up parsing, but
+          not noticeably.
+
+          One reason to byte-compile files is to find errors; the byte
+          compiler reports undefined variables, wrong argument counts,
+          etc.
+
+    `*-wy.el'
+          Parse tables, generated from the corresponding grammar `*.wy'
+          by the OpenToken tool `wisi-generate.exe'. These are in the
+          tarball distribution and the monotone so users and Elisp
+          developers don't have to install OpenToken.
+
+    `*-wy.output'
+          Diagnostic output from `wisi-generate.exe', useful for tracing
+          parses while debugging a grammar issue. Not in the tarball
+          distribution or the monotone repository.
+
+    `*.wy'
+          Grammar files, specifying the language to be parsed. The
+          syntax for these grammar files is similar to that for bison
+          and wisent, but not the same; see the OpenToken documentation
+          for more info.
+
+          The wisi parser (in `wisi-parse.el') is a generalized LALR
+          parser, so it tolerates some conflicts and ambiguities. This
+          makes the grammars easier to write, and in particular makes
+          it possible to let the Ada grammar closely match Annex P of
+          the Ada Language Reference Manual (the syntax summary).
+
+    `*.texi'
+          Texinfo source for the user guides.
+
+    `*.html'
+          Generated user guide in HTML format.
+
+    `*.info'
+          Generated user guide in Emacs info format.
+
+
+`build'
+     Makefiles for byte-compiling, running tests, making zips.
+
+`build/wisi'
+     Makefiles for building and testing with the wisi-based parser.
+     Separate from `build', because there used to be a SMIE-based
+     parser, and there might be another one someday.
+
+     The emacs used to byte-compile and run tests is given by the 'make'
+     variable EMACS_EXE, which defaults to 'emacs'; it can be
+     overridden on the make command line or by an environment variable.
+
+`test'
+     All tests for Ada mode, gpr mode, parser.
+
+     Each test is run in a separate invocation of Emacs, so it is
+     completely independent of all other tests.
+
+     The tests are driven by the elisp code in `build/*.el'.
+
+     In general, the Ada mode tests open the file, execute test actions,
+     re-indent, and re-captialize the entire file. The result is diffed
+     with the original, and must match.
+
+     The test actions are defined by comments with the prefix
+     `--EMACSCMD:'; they are elisp forms that invoke Ada mode
+     functions. This is used to test navigation features and other
+     parser effects.
+
+`test/Example_*'
+     Starting files for examples in user guide.
+
+`test/gpr'
+     Tests for gpr mode.
+
+`test/subdir'
+     More tests; allows testing path search features.
+
+`test/wisi'
+     Tests of the elisp wisi grammar compiler and parser.
+
+
+File: ada-mode.info,  Node: Package organization,  Next: OpenToken,  Prev: 
Directory structure,  Up: Developer overview
+
+14.2 Package organization
+=========================
+
+* Menu:
+
+* Ada mode::
+* gpr mode::
+* GNAT core::
+* Wisi::
+
+
+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-grammar.*'
+     The Ada language grammar, and files generated from it by the
+     OpenToken tool `wisi-generate.exe'.
+
+`ada-indent-user-options.el'
+     All user-settable options for the Ada indentation engine.
+
+`ada-mode-compat-23.4.el'
+     A start on defining functions used by Ada mode but not in Emacs
+     23.4.
+
+     Emacs Ada mode is written for Emacs 24.3. Emacs version 23.4 is
+     partially supported. Earlier versions of Emacs are not supported.
+
+`ada-mode.texi'
+     The Ada mode user guide source and compiled versions.
+
+`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-opentoken.el'
+     Indentation functions useful when editing OpenToken code; an
+     example of extending the Ada mode indentation engine for special
+     circumstances.
+
+`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 `gnat-inspect.el',
+     which is still experimental.
+
+     More code currently in `ada-mode.el' could be migrated to
+     `gnat-core.el', in particular the project file support.
+
+`gnat-inspect.el'
+     Provides an experimental interface to the experimental
+     multi-language cross-reference tool `gnatinspect' from AdaCore,
+     which will supercede `gnatxref'.
+
+     Implements the Ada mode cross-reference functions for the
+     `gnatinspect' 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. "wisi" used to be an acronym, but now it's just a
+name.
+
+`wisi.el'
+     Implements the lexer, the main parser driver, parser actions that
+     cache parser information in text properties, utilities for
+     indenting and navigating using the cached information, and general
+     setup.
+
+`wisi-compile.el'
+     Implements the parse table compiler. `wisi-generate.exe' processes
+     the grammar source `*.wy' into an elisp source representation of a
+     parse table `*-wy.el'. That is compiled into an internal structure
+     containing the state transitions and executable actions. The
+     actions can be any elisp form; the intent is that they be calls to
+     the action functions provided by `wisi.el'. `wisi-compile.el' uses
+     some features provided by `semantic'.
+
+`wisi-parse.el'
+     Implements the generalized LALR parser.
+
+
+File: ada-mode.info,  Node: OpenToken,  Prev: Package organization,  Up: 
Developer overview
+
+14.3 OpenToken
+==============
+
+Ada mode uses the OpenToken tool `wisi-generate.exe' to process the
+grammar sources into elisp parse tables. See
+`http://stephe-leake.org/emacs/ada-mode/emacs-ada-mode.html' for
+current information about which version of OpenToken is required, and
+how to get it.
+
+   The Makefile variable `WISI_OPENTOKEN' gives the path to the build
+directory for OpenToken; you probably need to override it with an
+external environment variable or on the `make' command line.
+
+
+File: ada-mode.info,  Node: GNU Free Documentation License,  Next: Index,  
Prev: Developer overview,  Up: Top
+
+Appendix A GNU Free Documentation License
+*****************************************
+
+                     Version 1.3, 3 November 2008
+
+     Copyright (C) 2000, 2001, 2002, 2007, 2008, 2009 Free Software 
Foundation, Inc.
+     `http://fsf.org/'
+
+     Everyone is permitted to copy and distribute verbatim copies
+     of this license document, but changing it is not allowed.
+
+  0. PREAMBLE
+
+     The purpose of this License is to make a manual, textbook, or other
+     functional and useful document "free" in the sense of freedom: to
+     assure everyone the effective freedom to copy and redistribute it,
+     with or without modifying it, either commercially or
+     noncommercially.  Secondarily, this License preserves for the
+     author and publisher a way to get credit for their work, while not
+     being considered responsible for modifications made by others.
+
+     This License is a kind of "copyleft", which means that derivative
+     works of the document must themselves be free in the same sense.
+     It complements the GNU General Public License, which is a copyleft
+     license designed for free software.
+
+     We have designed this License in order to use it for manuals for
+     free software, because free software needs free documentation: a
+     free program should come with manuals providing the same freedoms
+     that the software does.  But this License is not limited to
+     software manuals; it can be used for any textual work, regardless
+     of subject matter or whether it is published as a printed book.
+     We recommend this License principally for works whose purpose is
+     instruction or reference.
+
+  1. APPLICABILITY AND DEFINITIONS
+
+     This License applies to any manual or other work, in any medium,
+     that contains a notice placed by the copyright holder saying it
+     can be distributed under the terms of this License.  Such a notice
+     grants a world-wide, royalty-free license, unlimited in duration,
+     to use that work under the conditions stated herein.  The
+     "Document", below, refers to any such manual or work.  Any member
+     of the public is a licensee, and is addressed as "you".  You
+     accept the license if you copy, modify or distribute the work in a
+     way requiring permission under copyright law.
+
+     A "Modified Version" of the Document means any work containing the
+     Document or a portion of it, either copied verbatim, or with
+     modifications and/or translated into another language.
+
+     A "Secondary Section" is a named appendix or a front-matter section
+     of the Document that deals exclusively with the relationship of the
+     publishers or authors of the Document to the Document's overall
+     subject (or to related matters) and contains nothing that could
+     fall directly within that overall subject.  (Thus, if the Document
+     is in part a textbook of mathematics, a Secondary Section may not
+     explain any mathematics.)  The relationship could be a matter of
+     historical connection with the subject or with related matters, or
+     of legal, commercial, philosophical, ethical or political position
+     regarding them.
+
+     The "Invariant Sections" are certain Secondary Sections whose
+     titles are designated, as being those of Invariant Sections, in
+     the notice that says that the Document is released under this
+     License.  If a section does not fit the above definition of
+     Secondary then it is not allowed to be designated as Invariant.
+     The Document may contain zero Invariant Sections.  If the Document
+     does not identify any Invariant Sections then there are none.
+
+     The "Cover Texts" are certain short passages of text that are
+     listed, as Front-Cover Texts or Back-Cover Texts, in the notice
+     that says that the Document is released under this License.  A
+     Front-Cover Text may be at most 5 words, and a Back-Cover Text may
+     be at most 25 words.
+
+     A "Transparent" copy of the Document means a machine-readable copy,
+     represented in a format whose specification is available to the
+     general public, that is suitable for revising the document
+     straightforwardly with generic text editors or (for images
+     composed of pixels) generic paint programs or (for drawings) some
+     widely available drawing editor, and that is suitable for input to
+     text formatters or for automatic translation to a variety of
+     formats suitable for input to text formatters.  A copy made in an
+     otherwise Transparent file format whose markup, or absence of
+     markup, has been arranged to thwart or discourage subsequent
+     modification by readers is not Transparent.  An image format is
+     not Transparent if used for any substantial amount of text.  A
+     copy that is not "Transparent" is called "Opaque".
+
+     Examples of suitable formats for Transparent copies include plain
+     ASCII without markup, Texinfo input format, LaTeX input format,
+     SGML or XML using a publicly available DTD, and
+     standard-conforming simple HTML, PostScript or PDF designed for
+     human modification.  Examples of transparent image formats include
+     PNG, XCF and JPG.  Opaque formats include proprietary formats that
+     can be read and edited only by proprietary word processors, SGML or
+     XML for which the DTD and/or processing tools are not generally
+     available, and the machine-generated HTML, PostScript or PDF
+     produced by some word processors for output purposes only.
+
+     The "Title Page" means, for a printed book, the title page itself,
+     plus such following pages as are needed to hold, legibly, the
+     material this License requires to appear in the title page.  For
+     works in formats which do not have any title page as such, "Title
+     Page" means the text near the most prominent appearance of the
+     work's title, preceding the beginning of the body of the text.
+
+     The "publisher" means any person or entity that distributes copies
+     of the Document to the public.
+
+     A section "Entitled XYZ" means a named subunit of the Document
+     whose title either is precisely XYZ or contains XYZ in parentheses
+     following text that translates XYZ in another language.  (Here XYZ
+     stands for a specific section name mentioned below, such as
+     "Acknowledgements", "Dedications", "Endorsements", or "History".)
+     To "Preserve the Title" of such a section when you modify the
+     Document means that it remains a section "Entitled XYZ" according
+     to this definition.
+
+     The Document may include Warranty Disclaimers next to the notice
+     which states that this License applies to the Document.  These
+     Warranty Disclaimers are considered to be included by reference in
+     this License, but only as regards disclaiming warranties: any other
+     implication that these Warranty Disclaimers may have is void and
+     has no effect on the meaning of this License.
+
+  2. VERBATIM COPYING
+
+     You may copy and distribute the Document in any medium, either
+     commercially or noncommercially, provided that this License, the
+     copyright notices, and the license notice saying this License
+     applies to the Document are reproduced in all copies, and that you
+     add no other conditions whatsoever to those of this License.  You
+     may not use technical measures to obstruct or control the reading
+     or further copying of the copies you make or distribute.  However,
+     you may accept compensation in exchange for copies.  If you
+     distribute a large enough number of copies you must also follow
+     the conditions in section 3.
+
+     You may also lend copies, under the same conditions stated above,
+     and you may publicly display copies.
+
+  3. COPYING IN QUANTITY
+
+     If you publish printed copies (or copies in media that commonly
+     have printed covers) of the Document, numbering more than 100, and
+     the Document's license notice requires Cover Texts, you must
+     enclose the copies in covers that carry, clearly and legibly, all
+     these Cover Texts: Front-Cover Texts on the front cover, and
+     Back-Cover Texts on the back cover.  Both covers must also clearly
+     and legibly identify you as the publisher of these copies.  The
+     front cover must present the full title with all words of the
+     title equally prominent and visible.  You may add other material
+     on the covers in addition.  Copying with changes limited to the
+     covers, as long as they preserve the title of the Document and
+     satisfy these conditions, can be treated as verbatim copying in
+     other respects.
+
+     If the required texts for either cover are too voluminous to fit
+     legibly, you should put the first ones listed (as many as fit
+     reasonably) on the actual cover, and continue the rest onto
+     adjacent pages.
+
+     If you publish or distribute Opaque copies of the Document
+     numbering more than 100, you must either include a
+     machine-readable Transparent copy along with each Opaque copy, or
+     state in or with each Opaque copy a computer-network location from
+     which the general network-using public has access to download
+     using public-standard network protocols a complete Transparent
+     copy of the Document, free of added material.  If you use the
+     latter option, you must take reasonably prudent steps, when you
+     begin distribution of Opaque copies in quantity, to ensure that
+     this Transparent copy will remain thus accessible at the stated
+     location until at least one year after the last time you
+     distribute an Opaque copy (directly or through your agents or
+     retailers) of that edition to the public.
+
+     It is requested, but not required, that you contact the authors of
+     the Document well before redistributing any large number of
+     copies, to give them a chance to provide you with an updated
+     version of the Document.
+
+  4. MODIFICATIONS
+
+     You may copy and distribute a Modified Version of the Document
+     under the conditions of sections 2 and 3 above, provided that you
+     release the Modified Version under precisely this License, with
+     the Modified Version filling the role of the Document, thus
+     licensing distribution and modification of the Modified Version to
+     whoever possesses a copy of it.  In addition, you must do these
+     things in the Modified Version:
+
+       A. Use in the Title Page (and on the covers, if any) a title
+          distinct from that of the Document, and from those of
+          previous versions (which should, if there were any, be listed
+          in the History section of the Document).  You may use the
+          same title as a previous version if the original publisher of
+          that version gives permission.
+
+       B. List on the Title Page, as authors, one or more persons or
+          entities responsible for authorship of the modifications in
+          the Modified Version, together with at least five of the
+          principal authors of the Document (all of its principal
+          authors, if it has fewer than five), unless they release you
+          from this requirement.
+
+       C. State on the Title page the name of the publisher of the
+          Modified Version, as the publisher.
+
+       D. Preserve all the copyright notices of the Document.
+
+       E. Add an appropriate copyright notice for your modifications
+          adjacent to the other copyright notices.
+
+       F. Include, immediately after the copyright notices, a license
+          notice giving the public permission to use the Modified
+          Version under the terms of this License, in the form shown in
+          the Addendum below.
+
+       G. Preserve in that license notice the full lists of Invariant
+          Sections and required Cover Texts given in the Document's
+          license notice.
+
+       H. Include an unaltered copy of this License.
+
+       I. Preserve the section Entitled "History", Preserve its Title,
+          and add to it an item stating at least the title, year, new
+          authors, and publisher of the Modified Version as given on
+          the Title Page.  If there is no section Entitled "History" in
+          the Document, create one stating the title, year, authors,
+          and publisher of the Document as given on its Title Page,
+          then add an item describing the Modified Version as stated in
+          the previous sentence.
+
+       J. Preserve the network location, if any, given in the Document
+          for public access to a Transparent copy of the Document, and
+          likewise the network locations given in the Document for
+          previous versions it was based on.  These may be placed in
+          the "History" section.  You may omit a network location for a
+          work that was published at least four years before the
+          Document itself, or if the original publisher of the version
+          it refers to gives permission.
+
+       K. For any section Entitled "Acknowledgements" or "Dedications",
+          Preserve the Title of the section, and preserve in the
+          section all the substance and tone of each of the contributor
+          acknowledgements and/or dedications given therein.
+
+       L. Preserve all the Invariant Sections of the Document,
+          unaltered in their text and in their titles.  Section numbers
+          or the equivalent are not considered part of the section
+          titles.
+
+       M. Delete any section Entitled "Endorsements".  Such a section
+          may not be included in the Modified Version.
+
+       N. Do not retitle any existing section to be Entitled
+          "Endorsements" or to conflict in title with any Invariant
+          Section.
+
+       O. Preserve any Warranty Disclaimers.
+
+     If the Modified Version includes new front-matter sections or
+     appendices that qualify as Secondary Sections and contain no
+     material copied from the Document, you may at your option
+     designate some or all of these sections as invariant.  To do this,
+     add their titles to the list of Invariant Sections in the Modified
+     Version's license notice.  These titles must be distinct from any
+     other section titles.
+
+     You may add a section Entitled "Endorsements", provided it contains
+     nothing but endorsements of your Modified Version by various
+     parties--for example, statements of peer review or that the text
+     has been approved by an organization as the authoritative
+     definition of a standard.
+
+     You may add a passage of up to five words as a Front-Cover Text,
+     and a passage of up to 25 words as a Back-Cover Text, to the end
+     of the list of Cover Texts in the Modified Version.  Only one
+     passage of Front-Cover Text and one of Back-Cover Text may be
+     added by (or through arrangements made by) any one entity.  If the
+     Document already includes a cover text for the same cover,
+     previously added by you or by arrangement made by the same entity
+     you are acting on behalf of, you may not add another; but you may
+     replace the old one, on explicit permission from the previous
+     publisher that added the old one.
+
+     The author(s) and publisher(s) of the Document do not by this
+     License give permission to use their names for publicity for or to
+     assert or imply endorsement of any Modified Version.
+
+  5. COMBINING DOCUMENTS
+
+     You may combine the Document with other documents released under
+     this License, under the terms defined in section 4 above for
+     modified versions, provided that you include in the combination
+     all of the Invariant Sections of all of the original documents,
+     unmodified, and list them all as Invariant Sections of your
+     combined work in its license notice, and that you preserve all
+     their Warranty Disclaimers.
+
+     The combined work need only contain one copy of this License, and
+     multiple identical Invariant Sections may be replaced with a single
+     copy.  If there are multiple Invariant Sections with the same name
+     but different contents, make the title of each such section unique
+     by adding at the end of it, in parentheses, the name of the
+     original author or publisher of that section if known, or else a
+     unique number.  Make the same adjustment to the section titles in
+     the list of Invariant Sections in the license notice of the
+     combined work.
+
+     In the combination, you must combine any sections Entitled
+     "History" in the various original documents, forming one section
+     Entitled "History"; likewise combine any sections Entitled
+     "Acknowledgements", and any sections Entitled "Dedications".  You
+     must delete all sections Entitled "Endorsements."
+
+  6. COLLECTIONS OF DOCUMENTS
+
+     You may make a collection consisting of the Document and other
+     documents released under this License, and replace the individual
+     copies of this License in the various documents with a single copy
+     that is included in the collection, provided that you follow the
+     rules of this License for verbatim copying of each of the
+     documents in all other respects.
+
+     You may extract a single document from such a collection, and
+     distribute it individually under this License, provided you insert
+     a copy of this License into the extracted document, and follow
+     this License in all other respects regarding verbatim copying of
+     that document.
+
+  7. AGGREGATION WITH INDEPENDENT WORKS
+
+     A compilation of the Document or its derivatives with other
+     separate and independent documents or works, in or on a volume of
+     a storage or distribution medium, is called an "aggregate" if the
+     copyright resulting from the compilation is not used to limit the
+     legal rights of the compilation's users beyond what the individual
+     works permit.  When the Document is included in an aggregate, this
+     License does not apply to the other works in the aggregate which
+     are not themselves derivative works of the Document.
+
+     If the Cover Text requirement of section 3 is applicable to these
+     copies of the Document, then if the Document is less than one half
+     of the entire aggregate, the Document's Cover Texts may be placed
+     on covers that bracket the Document within the aggregate, or the
+     electronic equivalent of covers if the Document is in electronic
+     form.  Otherwise they must appear on printed covers that bracket
+     the whole aggregate.
+
+  8. TRANSLATION
+
+     Translation is considered a kind of modification, so you may
+     distribute translations of the Document under the terms of section
+     4.  Replacing Invariant Sections with translations requires special
+     permission from their copyright holders, but you may include
+     translations of some or all Invariant Sections in addition to the
+     original versions of these Invariant Sections.  You may include a
+     translation of this License, and all the license notices in the
+     Document, and any Warranty Disclaimers, provided that you also
+     include the original English version of this License and the
+     original versions of those notices and disclaimers.  In case of a
+     disagreement between the translation and the original version of
+     this License or a notice or disclaimer, the original version will
+     prevail.
+
+     If a section in the Document is Entitled "Acknowledgements",
+     "Dedications", or "History", the requirement (section 4) to
+     Preserve its Title (section 1) will typically require changing the
+     actual title.
+
+  9. TERMINATION
+
+     You may not copy, modify, sublicense, or distribute the Document
+     except as expressly provided under this License.  Any attempt
+     otherwise to copy, modify, sublicense, or distribute it is void,
+     and will automatically terminate your rights under this License.
+
+     However, if you cease all violation of this License, then your
+     license from a particular copyright holder is reinstated (a)
+     provisionally, unless and until the copyright holder explicitly
+     and finally terminates your license, and (b) permanently, if the
+     copyright holder fails to notify you of the violation by some
+     reasonable means prior to 60 days after the cessation.
+
+     Moreover, your license from a particular copyright holder is
+     reinstated permanently if the copyright holder notifies you of the
+     violation by some reasonable means, this is the first time you have
+     received notice of violation of this License (for any work) from
+     that copyright holder, and you cure the violation prior to 30 days
+     after your receipt of the notice.
+
+     Termination of your rights under this section does not terminate
+     the licenses of parties who have received copies or rights from
+     you under this License.  If your rights have been terminated and
+     not permanently reinstated, receipt of a copy of some or all of
+     the same material does not give you any rights to use it.
+
+ 10. FUTURE REVISIONS OF THIS LICENSE
+
+     The Free Software Foundation may publish new, revised versions of
+     the GNU Free Documentation License from time to time.  Such new
+     versions will be similar in spirit to the present version, but may
+     differ in detail to address new problems or concerns.  See
+     `http://www.gnu.org/copyleft/'.
+
+     Each version of the License is given a distinguishing version
+     number.  If the Document specifies that a particular numbered
+     version of this License "or any later version" applies to it, you
+     have the option of following the terms and conditions either of
+     that specified version or of any later version that has been
+     published (not as a draft) by the Free Software Foundation.  If
+     the Document does not specify a version number of this License,
+     you may choose any version ever published (not as a draft) by the
+     Free Software Foundation.  If the Document specifies that a proxy
+     can decide which future versions of this License can be used, that
+     proxy's public statement of acceptance of a version permanently
+     authorizes you to choose that version for the Document.
+
+ 11. RELICENSING
+
+     "Massive Multiauthor Collaboration Site" (or "MMC Site") means any
+     World Wide Web server that publishes copyrightable works and also
+     provides prominent facilities for anybody to edit those works.  A
+     public wiki that anybody can edit is an example of such a server.
+     A "Massive Multiauthor Collaboration" (or "MMC") contained in the
+     site means any set of copyrightable works thus published on the MMC
+     site.
+
+     "CC-BY-SA" means the Creative Commons Attribution-Share Alike 3.0
+     license published by Creative Commons Corporation, a not-for-profit
+     corporation with a principal place of business in San Francisco,
+     California, as well as future copyleft versions of that license
+     published by that same organization.
+
+     "Incorporate" means to publish or republish a Document, in whole or
+     in part, as part of another Document.
+
+     An MMC is "eligible for relicensing" if it is licensed under this
+     License, and if all works that were first published under this
+     License somewhere other than this MMC, and subsequently
+     incorporated in whole or in part into the MMC, (1) had no cover
+     texts or invariant sections, and (2) were thus incorporated prior
+     to November 1, 2008.
+
+     The operator of an MMC Site may republish an MMC contained in the
+     site under CC-BY-SA on the same site at any time before August 1,
+     2009, provided the MMC is eligible for relicensing.
+
+
+ADDENDUM: How to use this License for your documents
+====================================================
+
+To use this License in a document you have written, include a copy of
+the License in the document and put the following copyright and license
+notices just after the title page:
+
+       Copyright (C)  YEAR  YOUR NAME.
+       Permission is granted to copy, distribute and/or modify this document
+       under the terms of the GNU Free Documentation License, Version 1.3
+       or any later version published by the Free Software Foundation;
+       with no Invariant Sections, no Front-Cover Texts, and no Back-Cover
+       Texts.  A copy of the license is included in the section entitled ``GNU
+       Free Documentation License''.
+
+   If you have Invariant Sections, Front-Cover Texts and Back-Cover
+Texts, replace the "with...Texts." line with this:
+
+         with the Invariant Sections being LIST THEIR TITLES, with
+         the Front-Cover Texts being LIST, and with the Back-Cover Texts
+         being LIST.
+
+   If you have Invariant Sections without Cover Texts, or some other
+combination of the three, merge those two alternatives to suit the
+situation.
+
+   If your document contains nontrivial examples of program code, we
+recommend releasing these examples in parallel under your choice of
+free software license, such as the GNU General Public License, to
+permit their use in free software.
+
+
+File: ada-mode.info,  Node: Index,  Prev: GNU Free Documentation License,  Up: 
Top
+
+Index
+*****
+
+[index]
+* Menu:
+
+* ada-case-adjust-at-point:              Automatic casing.     (line 65)
+* ada-case-create-exception:             Automatic casing.     (line 47)
+* ada-find-other-file:                   Moving Through Ada Code.
+                                                               (line 31)
+* 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 21)
+* ada-prev-statement-keyword:            Moving Through Ada Code.
+                                                               (line 26)
+* ada-show-overriding:                   Moving Through Ada Code.
+                                                               (line 56)
+* ada-show-references:                   Moving Through Ada Code.
+                                                               (line 51)
+* comment-dwim:                          Comment Handling.     (line 10)
+* fill-paragraph:                        Comment Handling.     (line 18)
+
+
+
+Tag Table:
+Node: Top1031
+Node: Overview2675
+Node: Installation3984
+Node: gnatinspect4607
+Node: Customization5280
+Node: Non-standard file names5761
+Node: Other compiler7595
+Node: Other cross-reference8174
+Node: Other customization8892
+Node: Compiling Executing11155
+Node: Compile commands11889
+Node: Compiling Examples14621
+Node: No project files15453
+Node: Set compiler options20838
+Node: Set source search path22796
+Node: Use GNAT project file25245
+Node: Use multiple GNAT project files28018
+Node: Use a Makefile30735
+Node: Compiler errors32049
+Node: Project files32863
+Node: Project file overview33700
+Node: Project file variables35055
+Node: Moving Through Ada Code37979
+Node: Identifier completion40087
+Node: Indentation41048
+Node: Statement skeletons44731
+Node: Aligning code45932
+Node: Automatic casing46876
+Node: Comment Handling49600
+Node: Key summary50118
+Node: Developer overview52236
+Node: Directory structure52567
+Node: Package organization55955
+Node: Ada mode56190
+Node: gpr mode58393
+Node: GNAT core58675
+Node: Wisi59621
+Node: OpenToken60583
+Node: GNU Free Documentation License61171
+Node: Index86351
+
+End Tag Table
diff --git a/packages/ada-mode/ada-skel.el b/packages/ada-mode/ada-skel.el
new file mode 100755
index 0000000..398f314
--- /dev/null
+++ b/packages/ada-mode/ada-skel.el
@@ -0,0 +1,437 @@
+;;; ada-skel.el --- an extension to Ada mode for inserting statement skeletons
+
+;; Copyright (C) 1987, 1993, 1994, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
+;;   2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2013
+;;   Free Software Foundation, Inc.
+
+;; Authors: 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/>.
+
+;;; Design:
+;;
+;; The primary user command is `ada-skel-expand', which inserts the
+;; skeleton associated with the previous word (possibly skipping a
+;; name).
+;;
+;; We don't define skeletons that prompt for most of the content; it
+;; 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.
+
+;;; History:
+
+;; Created May 1987.
+;; Original version from V. Bowman as in ada.el of Emacs-18
+;; (borrowed heavily from Mick Jordan's Modula-2 package for GNU,
+;; as modified by Peter Robinson, Michael Schmidt, and Tom Perrine.)
+;;
+;; Sep 1993. Daniel Pfeiffer <address@hidden> (DP)
+;; Introduced statement.el for smaller code and user configurability.
+;;
+;; Nov 1993. Rolf Ebert <address@hidden> (RE) Moved the
+;; skeleton generation into this separate file. The code still is
+;; essentially written by DP
+;;
+;; Adapted Jun 1994. Markus Heritsch
+;; <address@hidden> (MH)
+;; added menu bar support for templates
+;;
+;; 1994/12/02  Christian Egli <address@hidden>
+;; General cleanup and bug fixes.
+;;
+;; 1995/12/20  John Hutchison <address@hidden>
+;; made it work with skeleton.el from Emacs-19.30. Several
+;; enhancements and bug fixes.
+;;
+;; Sep 2013 Stephen Leake renamed to ada-skel (to match skeleton.el),
+;; complete re-write: added ada-skel-alist (to get some of the
+;; functionality of the sadly missed Else package). Simplified
+;; skeletons; just make it easier to work with the ada-wisi parser,
+;; don't try to teach syntax.
+
+(require 'skeleton nil t)
+
+;;;;; user variables, example skeletons intended to be overwritten
+
+(defcustom ada-skel-initial-string "header"
+  "*String to insert in empty buffer.
+This could end in a token recognized by `ada-skel-expand'."
+  :type 'string
+  :group 'ada
+  :safe 'stringp)
+
+(define-skeleton ada-skel-user-restricted
+  "Example copyright/license skeleton, with automatic year and owner."
+  ()
+  "--  Copyright (C) " (format-time-string "%Y ") user-full-name " All Rights 
Reserved.\n"
+  "\n"
+  "pragma License (Restricted);\n"
+)
+
+(define-skeleton ada-skel-gpl
+  "Example copyright/license skeleton, with automatic year and owner, GPLv3."
+  ()
+  "--  Copyright (C) " (format-time-string "%Y ") user-full-name " All Rights 
Reserved.\n"
+  "--\n"
+  "--  This program is free software; you can redistribute it and/or\n"
+  "--  modify it under terms of the GNU General Public License as\n"
+  "--  published by the Free Software Foundation; either version 3, or (at\n"
+  "--  your option) any later version. This program is distributed in the\n"
+  "--  hope that it will be useful, but WITHOUT ANY WARRANTY; without even\n"
+  "--  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR\n"
+  "--  PURPOSE. See the GNU General Public License for more details. You\n"
+  "--  should have received a copy of the GNU General Public License\n"
+  "--  distributed with this program; see file COPYING. If not, write to\n"
+  "--  the Free Software Foundation, 51 Franklin Street, Suite 500, Boston,\n"
+  "--  MA 02110-1335, USA.\n"
+  "\n"
+  "pragma License (GPL);\n"
+
+)
+
+;;;;; Ada skeletons (alphabetical)
+
+(define-skeleton ada-skel-accept
+  "Insert accept statement with name from `str'."
+  ()
+  "accept " str " do\n"
+  "end " str ";")
+
+(define-skeleton ada-skel-case
+  "Insert case statement."
+  ()
+  "case " str " is\n"
+  "when " _ "=>\n"
+  "end case;")
+
+(define-skeleton ada-skel-declare
+  "Insert a block statement with an optional name (from `str')."
+  ()
+  str & ":\n"
+  "declare\n"
+  _
+  "begin\n"
+  "exception\n"
+  "end " str | -1 ?\;)
+
+(define-skeleton ada-skel-entry
+  "Insert entry statement with name from `str'."
+  ()
+  "entry " str " when " _ "\n"
+  "is\n"
+  "begin\n"
+  "end " str ";")
+
+(define-skeleton ada-skel-for
+  "Insert a for loop statement with an optional name (from `str')."
+  ()
+  str & ":\n"
+  "for " _ " loop\n"
+  "end loop " str | -1 ";")
+
+(define-skeleton ada-skel-function-body
+  "Insert a function body with name from `str'."
+  ()
+  "function " str " return \n"
+  "is\n"
+  "begin\n"
+  _
+  "end " str ";")
+
+(define-skeleton ada-skel-function-spec
+  "Insert a function type specification with name from `str'."
+  ()
+  "function " str " return ;")
+
+(define-skeleton ada-skel-header
+  "Insert a file header comment, with automatic copyright year and prompt for 
copyright owner/license.
+Each user will probably want to override this."
+  ()
+  "--  Abstract :\n"
+  "--\n"
+  "--  " _ "\n"
+  "--\n"
+  "{copyright_license}\n"
+  )
+
+(define-skeleton ada-skel-if
+  "Insert an if statement."
+  ()
+  "if " _ " then\n"
+  "elsif  then\n"
+  "else\n"
+  "end if;")
+
+(define-skeleton ada-skel-loop
+  "Insert a loop statement with an optional name (from `str')."
+  ()
+  str & ":\n"
+  "loop\n"
+  "exit " str | -1 " when " _ ";\n"
+  "end loop " str | -1 ";")
+
+(define-skeleton ada-skel-package-body
+  "Insert a package body with name from `str'."
+  ()
+  "package body " str " is\n"
+  _
+  "begin\n"
+  "end " str ";")
+
+(define-skeleton ada-skel-package-spec
+  "Insert a package specification with name from `str'.
+See `ada-find-other-file' to create library level package body from spec."
+  ()
+  "package " str " is\n"
+  _
+  "private\n"
+  "end " str ";")
+
+(define-skeleton ada-skel-procedure-body
+  "Insert a procedure body with name from `str'."
+  ()
+  "procedure " str "\n"
+  "is\n"
+  "begin\n"
+  _
+  "end " str ";")
+
+(define-skeleton ada-skel-procedure-spec
+  "Insert a procedure type specification with name from `str'."
+  ()
+  "procedure " str ";")
+
+(define-skeleton ada-skel-protected-body
+  "Insert a protected body with name from `str'."
+  ()
+  "protected body " str " is\n"
+  _
+  "end " str ";")
+
+(define-skeleton ada-skel-protected-spec
+  "Insert a protected type specification with name from `str'."
+  ()
+  "protected type " str " is\n"
+  _
+  "private\n"
+  "end " str ";")
+
+(define-skeleton ada-skel-record
+  "Insert a record type declaration with a type name from `str'."
+  ()
+  "type " str " is record\n"
+  _
+  "end record;")
+
+(define-skeleton ada-skel-return
+  "Insert an extended return statement."
+  ()
+  "return" _ "\n"
+  "do\n"
+  "end return;")
+
+(define-skeleton ada-skel-select
+  "Insert a select statement."
+  ()
+  "select\n"
+  _
+  "else\n"
+  "end select;")
+
+(define-skeleton ada-skel-task-body
+  "Insert a task body with name from `str'."
+  ()
+  "task body " str "\n"
+  "is\n"
+  _
+  "begin\n"
+  "end " str ";")
+
+(define-skeleton ada-skel-task-spec
+  "Insert a task specification with name from `str'."
+  ()
+  "task " str " is\n"
+  _
+  "end " str ";")
+
+(define-skeleton ada-skel-while
+  "Insert a while loop statement with an optional name (from `str')."
+  ()
+  str & ":\n"
+  "while " _ " loop\n"
+  "end loop " str | -1 ";")
+
+(define-skeleton ada-skel-with-use
+  "Insert with and use context clauses with name from `str'."
+  ()
+  "with " str "; use " str ";")
+
+;;;;; token alist, other functions
+
+(defconst ada-skel-token-alist
+  '(("accept" . ada-skel-accept)
+    ("begin" . ada-skel-declare) ;; easy enough to delete the declare
+    ("case" . ada-skel-case)
+    ("copyright_license"
+     ("GPL" . ada-skel-gpl)
+     ("restricted" . ada-skel-user-restricted))
+    ("declare" . ada-skel-declare)
+    ("entry" . ada-skel-entry)
+    ("for" . ada-skel-for)
+    ("function"
+     ("body" . ada-skel-function-body)
+     ("spec" . ada-skel-function-spec))
+    ("header" . ada-skel-header)
+    ("if" . ada-skel-if)
+    ("loop" . ada-skel-loop)
+    ("package"
+     ("body" . ada-skel-package-body)
+     ("spec" . ada-skel-package-spec))
+    ("procedure"
+     ("body" . ada-skel-procedure-body)
+     ("spec" . ada-skel-procedure-spec))
+    ("protected"
+     ("body" . ada-skel-protected-body)
+     ("spec" . ada-skel-protected-spec))
+    ("record" . ada-skel-record)
+    ("return" . ada-skel-return)
+    ("select" . ada-skel-select)
+    ("task"
+     ("body" . ada-skel-task-body)
+     ("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 " | ") " | ... : "))
+  ))
+
+;;;###autoload
+(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-boundary)
+      (condition-case nil
+         (progn
+           (ada-skel-expand)
+           t)
+       ('error
+        ;; undo ada-case-adjust, motion
+        (undo)
+        (goto-char pos)
+        nil)))))
+
+(defun ada-skel-setup ()
+  "Setup a buffer ada-skel."
+  (add-hook 'skeleton-end-hook 'ada-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)
+
+(add-hook 'ada-mode-hook 'ada-skel-setup)
+
+;;; ada-skel.el ends here
diff --git a/packages/ada-mode/ada-wisi-opentoken.el 
b/packages/ada-mode/ada-wisi-opentoken.el
new file mode 100755
index 0000000..08d3b4d
--- /dev/null
+++ b/packages/ada-mode/ada-wisi-opentoken.el
@@ -0,0 +1,59 @@
+;;; An indentation function for ada-wisi that indents OpenToken
+;;; grammar statements nicely.
+;;;
+;;; This is an example of a user-added indentation rule.
+;;
+;; In ~/.emacs (or project-specific config):
+;; (require 'ada-wisi-opentoken)
+;;
+;; In each file that declares OpenToken grammars:
+;;
+;; Local Variables:
+;; ada-indent-opentoken: t
+;; End:
+
+(require 'ada-mode)
+(require 'wisi)
+
+(defcustom ada-indent-opentoken nil
+  "If non-nil, apply `ada-wisi-opentoken' indentation rule."
+  :type  'boolean
+  :group 'ada-indentation
+  :safe  'booleanp)
+(make-variable-buffer-local 'ada-indent-opentoken)
+
+(defun ada-wisi-opentoken ()
+  "Return appropriate indentation (an integer column) for continuation lines 
in an OpenToken grammar statement."
+  ;; We don't do any checking to see if we actually are in an
+  ;; OpenToken grammar statement, since this rule should only be
+  ;; included in package specs that exist solely to define OpenToken
+  ;; grammar fragments.
+  (when ada-indent-opentoken
+    (save-excursion
+      (let ((token-text (nth 1 (wisi-backward-token))))
+       (cond
+        ((equal token-text "<=")
+         (back-to-indentation)
+         (+ (current-column) ada-indent-broken))
+
+        ((member token-text '("+" "&"))
+         (while (not (equal "<=" (nth 1 (wisi-backward-token)))))
+         (back-to-indentation)
+         (+ (current-column) ada-indent-broken))
+        )))))
+
+(defun ada-wisi-opentoken-setup ()
+  (add-to-list 'wisi-indent-calculate-functions 'ada-wisi-opentoken))
+
+;; This must be after ada-wisi-setup on ada-mode-hook, because
+;; ada-wisi-setup resets wisi-indent-calculate-functions
+(add-hook 'ada-mode-hook 'ada-wisi-opentoken-setup t)
+
+(add-to-list 'ada-align-rules
+            '(ada-opentoken
+              (regexp  . "[^=]\\(\\s-*\\)<=")
+              (valid   . (lambda() (not (ada-in-comment-p))))
+              (modes   . '(ada-mode))))
+
+(provide 'ada-wisi-opentoken)
+;; end of file
diff --git a/packages/ada-mode/ada-wisi.el b/packages/ada-mode/ada-wisi.el
new file mode 100755
index 0000000..aef5c78
--- /dev/null
+++ b/packages/ada-mode/ada-wisi.el
@@ -0,0 +1,1390 @@
+;;; An indentation engine for Ada mode, using the wisi generalized LALR parser
+;;
+;; [1] ISO/IEC 8652:2012(E); Ada 2012 reference manual
+;;
+;; Copyright (C) 2012, 2013  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/>.
+;;
+;;; History:
+;;
+;; implementation started Jan 2013
+;;
+;;; code style
+;;
+;; not using lexical-binding or cl-lib because we support Emacs 23
+;;
+;;;;
+
+(require 'ada-fix-error)
+(require 'ada-grammar-wy)
+(require 'ada-indent-user-options)
+(require 'wisi)
+
+(eval-when-compile (require 'cl-macs))
+
+(defconst ada-wisi-class-list
+  '(
+    block-end
+    block-middle ;; not start of statement
+    block-start ;; start of block is start of statement
+    close-paren
+    list-break
+    name
+    name-paren ;; anything that looks like a procedure call, since the grammar 
can't distinguish most of them
+    open-paren
+    return
+    return-1
+    return-2
+    statement-end
+    statement-other
+    statement-start
+    type
+    ))
+
+;;;; indentation
+
+(defun ada-wisi-indent-cache (offset cache)
+  "Return indentation of OFFSET plus indentation of line containing point. 
Point must be at CACHE."
+  (let ((indent (current-indentation)))
+    (cond
+     ;; special cases
+     ;;
+     ((eq 'LEFT_PAREN (wisi-cache-token cache))
+      ;; test/ada_mode-long_paren.adb
+      ;; (RT                            => RT,
+      ;;  Monitor                       => True,
+      ;;  RX_Enable                     =>
+      ;;    (RX_Torque_Subaddress |
+      ;;   indenting '(RX_'
+      ;;
+      ;; test/ada_mode-parens.adb
+      ;; return Float (
+      ;;               Integer'Value
+      ;;                 (Local_6));
+      ;;   indenting '(local_6)'; 'offset' = ada-indent - 1
+      (+ (current-column) 1 offset))
+
+     ((save-excursion
+       (let ((containing (wisi-goto-containing-paren cache)))
+         (and containing
+              ;; test/ada_mode-conditional_expressions.adb
+              ;; K2 : Integer := (if J > 42
+              ;;                  then -1
+              ;;   indenting 'then'; offset = 0
+              ;;
+              ;; need get-start, not just get-containing, because of:
+              ;; L1 : Integer := (case J is
+              ;;                     when 42 => -1,
+              ;;
+              ;; _not_ (ada-in-paren-p), because of:
+              ;; test/indent.ads
+              ;; C_S_Controls : constant
+              ;;   CSCL_Type :=
+              ;;     CSCL_Type'
+              ;;       (
+              ;;        1 =>  --  Used to be aligned on "CSCL_Type'"
+              ;;              --  aligned with previous comment.
+              ;;          IO_CPU_Control_State_S_Pkg.CPU2_Fault_Status_Type'
+              ;;            (Unused2  => 10,  -- Used to be aligned on "1 =>"
+              ;;  indenting '(Unused2'
+              (+ (current-column) offset)))))
+
+     ;; all other structures
+     (t
+      ;; current cache may be preceded by something on same
+      ;; line. Handle common cases nicely.
+      (while (and cache
+                 (or
+                  (not (= (current-column) indent))
+                  (eq 'EQUAL_GREATER (wisi-cache-token cache))))
+       (when (and
+              (eq 'WHEN (wisi-cache-token cache))
+              (not (eq 'exit_statement (wisi-cache-nonterm cache))))
+         (setq offset (+ offset ada-indent-when)))
+       (setq cache (wisi-goto-containing cache))
+       (setq indent (current-indentation)))
+
+      (cond
+       ((null cache)
+       ;; test/ada_mode-opentoken.ads
+       ;; private package GDS.Commands.Add_Statement is
+       ;;    type Instance is new Nonterminal.Instance with null record;
+       offset)
+
+       ((eq 'label_opt (wisi-cache-token cache))
+       (+ indent (- ada-indent-label) offset))
+
+       (t
+       ;; test/ada_mode-generic_instantiation.ads
+       ;; function Function_1 is new Instance.Generic_Function
+       ;;   (Param_Type  => Integer,
+       ;;
+       ;; test/ada_mode-nested_packages.adb
+       ;; function Create (Model   : in Integer;
+       ;;                  Context : in String) return String is
+       ;;    ...
+       ;;    Cache : array (1 .. 10) of Boolean := (True, False, others => 
False);
+       (+ indent offset))
+       ))
+     )))
+
+(defun ada-wisi-indent-containing (offset cache &optional before)
+  "Return indentation of OFFSET plus indentation of token containing CACHE.
+BEFORE should be t when called from ada-wisi-before-cache, nil otherwise."
+  (save-excursion
+    (cond
+     ((markerp (wisi-cache-containing cache))
+      (ada-wisi-indent-cache offset (wisi-goto-containing cache)))
+
+     (t
+      (cond
+       ((ada-in-paren-p)
+       (ada-goto-open-paren 1)
+       (+ (current-column) offset))
+
+       (t
+       ;; at outermost containing statement. If called from
+       ;; ada-wisi-before-cache, we want to ignore OFFSET (indenting
+       ;; 'package' in a package spec). If called from
+       ;; ada-wisi-after-cache, we want to include offset (indenting
+       ;; first declaration in the package).
+       (if before 0 offset))
+       ))
+      )))
+
+(defun ada-wisi-before-cache ()
+  "Point is at indentation, before a cached token. Return new indentation for 
point."
+  (let ((pos-0 (point))
+       (cache (wisi-get-cache (point))))
+    (when cache
+      (cl-ecase (wisi-cache-class cache)
+       (block-start
+        (cl-case (wisi-cache-token cache)
+          (IS ;; subprogram body
+           (ada-wisi-indent-containing 0 cache t))
+
+          (RECORD
+           (ada-wisi-indent-containing ada-indent-record-rel-type cache t))
+
+          (t ;; other
+           (ada-wisi-indent-containing ada-indent cache t))))
+
+       (block-end
+        (cl-case (wisi-cache-nonterm cache)
+          (record_definition
+           (save-excursion
+             (wisi-goto-containing cache);; now on 'record'
+             (current-indentation)))
+
+          (t
+           (ada-wisi-indent-containing 0 cache t))
+          ))
+
+       (block-middle
+        (cl-case (wisi-cache-token cache)
+          (WHEN
+           (ada-wisi-indent-containing ada-indent-when cache t))
+
+          (t
+           (ada-wisi-indent-containing 0 cache t))
+          ))
+
+       (close-paren (wisi-indent-paren 0))
+
+       (name
+        (ada-wisi-indent-containing ada-indent-broken cache t))
+
+       (name-paren
+        (let ((containing (wisi-goto-containing cache)))
+          (cl-case (wisi-cache-class containing)
+            (open-paren
+             ;; test/ada_mode-slices.adb
+             ;; Put_Line(Day'Image(D1) & " - " & Day'Image(D2) & " = " &
+             ;;            Integer'Image(N));
+             ;;
+             ;; test/ada_mode-parens.adb
+             ;; return Float (
+             ;;               Integer'Value
+             ;; indenting 'Integer'
+             ;;
+             ;; We distinguish the two cases by going to the first token,
+             ;; and comparing point to pos-0.
+             (let ((paren-column (current-column)))
+               (wisi-forward-token t); "("
+               (forward-comment (point-max))
+               (if (= (point) pos-0)
+                   ;; 2)
+                   (1+ paren-column)
+                 ;; 1)
+                 (+ paren-column 1 ada-indent-broken))))
+
+            (list-break
+             ;; test/parent.adb
+             ;; Append_To (Formals,
+             ;;            Make_Parameter_Specification (Loc,
+             (wisi-indent-paren 1))
+
+            (t
+             ;; test/ada_mode-generic_instantiation.ads
+             ;;   procedure Procedure_6 is new
+             ;;     Instance.Generic_Procedure (Integer, Function_1);
+             ;; indenting 'Instance'; containing is 'new'
+             (ada-wisi-indent-cache ada-indent-broken containing))
+            )))
+
+       (open-paren
+        (let ((containing (wisi-goto-containing cache)))
+          (cl-case (wisi-cache-token containing)
+            (COMMA
+             ;; test/ada_mode-parens.adb
+             ;; A : Matrix_Type :=
+             ;;   ((1, 2, 3),
+             ;;    (4, 5, 6),
+             ;; indenting (4
+             (ada-wisi-indent-containing 0 containing))
+
+            (EQUAL_GREATER
+             (setq containing (wisi-goto-containing containing))
+             (cl-ecase (wisi-cache-token containing)
+               (COMMA
+                ;; test/ada_mode-long_paren.adb
+                ;; (RT                            => RT,
+                ;;  Monitor                       => True,
+                ;;  RX_Enable                     =>
+                ;;    (RX_Torque_Subaddress |
+                ;; indenting (RX_Torque
+                (ada-wisi-indent-containing (1- ada-indent) containing t))
+               (LEFT_PAREN
+                ;; test/ada_mode-parens.adb
+                ;; (1 =>
+                ;;    (1 => 12,
+                ;; indenting '(1 => 12'; containing is '=>'
+                (ada-wisi-indent-cache (1- ada-indent) containing))
+               (WHEN
+                ;; test/ada_mode-conditional_expressions.adb
+                ;;  when 1 =>
+                ;;    (if J > 42
+                ;; indenting '(if'; containing is '=>'
+                (+ (current-column) -1 ada-indent))
+               ))
+
+            ((FUNCTION PROCEDURE)
+             ;; test/ada_mode-nominal.adb
+             ;; function Function_Access_11
+             ;;   (A_Param : in Float)
+             ;;   --  EMACSCMD:(test-face "function" font-lock-keyword-face)
+             ;;   return access function
+             ;;     (A_Param : in Float)
+             ;;     return
+             ;;     Standard.Float -- Ada mode 4.01, GPS do this differently
+             ;; indenting second '(A_Param)
+             (+ (current-indentation) -1 ada-indent))
+
+            (LEFT_PAREN
+             ;; test/ada_mode-parens.adb
+             ;; or else ((B.all
+             ;;             and then C)
+             ;;            or else
+             ;;            (D
+             ;; indenting (D
+             (+ (current-column) 1 ada-indent-broken))
+
+            (name
+             ;; test/indent.ads
+             ;; CSCL_Type'
+             ;;   (
+             ;; identing (
+             ;;
+             ;; test/ada_mode-parens.adb
+             ;; Check
+             ;;   ("foo bar",
+             ;;    A
+             ;;      (1),
+             ;;    A(2));
+             ;; indenting (1)
+             (+ (current-indentation) ada-indent-broken))
+
+            (t
+             (cond
+               ((memq (wisi-cache-class containing) '(block-start 
statement-start))
+                ;; test/ada_mode-nominal.adb
+                ;; entry E2
+                ;;   (X : Integer)
+                ;; indenting (X
+                (ada-wisi-indent-cache ada-indent-broken containing))
+
+               ((and
+                 (eq (wisi-cache-nonterm containing) 'entry_body)
+                 (eq (wisi-cache-token containing) 'WHEN))
+                ;; test/ada_mode-nominal.adb
+                ;; when Local_1 = 0 and not
+                ;;   (Local_2 = 1)
+                ;; indenting (Local_2
+                (+ (current-column) ada-indent-broken))
+
+               (t
+                ;; Open paren in an expression.
+                ;;
+                ;; test/ada_mode-conditional_expressions.adb
+                ;; L0 : Integer :=
+                ;;   (case J is when 42 => -1, when Integer'First .. 41 => 0, 
when others => 1);
+                ;; indenting (case
+                (ada-wisi-indent-containing ada-indent-broken containing t))
+               ))
+            )))
+
+       (return-1;; parameter list
+        (let ((return-pos (point)))
+          (wisi-goto-containing cache nil) ;; matching 'function'
+          (cond
+           ((<= ada-indent-return 0)
+            ;; indent relative to "("
+            (wisi-forward-find-class 'open-paren return-pos)
+            (+ (current-column) (- ada-indent-return)))
+
+           (t
+            (+ (current-column) ada-indent-return))
+           )))
+
+       (return-2;; no parameter list
+        (wisi-goto-containing cache nil) ;; matching 'function'
+        (+ (current-column) ada-indent-broken))
+
+       (statement-end
+        (ada-wisi-indent-containing ada-indent-broken cache t))
+
+       (statement-other
+        (let ((containing (wisi-goto-containing cache nil)))
+          (cl-case (wisi-cache-token cache)
+            (EQUAL_GREATER
+             (+ (current-column) ada-indent-broken))
+
+            (ELSIF
+             ;; test/g-comlin.adb
+             ;;   elsif Current_Argument < CL.Argument_Count then
+             (ada-wisi-indent-cache 0 containing))
+
+            (RENAMES
+             (cl-ecase (wisi-cache-nonterm containing)
+               ((generic_renaming_declaration subprogram_renaming_declaration)
+                (wisi-forward-find-token '(FUNCTION PROCEDURE) pos-0)
+                (let ((pos-subprogram (point))
+                      (has-params
+                       ;; this is wrong for one return access
+                       ;; function case: overriding function Foo
+                       ;; return access Bar (...) renames ...;
+                       (wisi-forward-find-token 'LEFT_PAREN pos-0 t)))
+                  (if has-params
+                      (if (<= ada-indent-renames 0)
+                          ;; indent relative to paren
+                          (+ (current-column) (- ada-indent-renames))
+                        ;; else relative to line containing keyword
+                        (goto-char pos-subprogram)
+                        (+ (current-indentation) ada-indent-renames))
+
+                    ;; no params
+                    (goto-char pos-subprogram)
+                    (+ (current-indentation) ada-indent-broken))
+                  ))
+
+               (object_renaming_declaration
+                (+ (current-indentation) ada-indent-broken))
+               ))
+
+            (t
+             (while (not (wisi-cache-nonterm containing))
+               (setq containing (wisi-goto-containing containing)))
+
+             (cl-ecase (wisi-cache-nonterm containing)
+               (aggregate
+                ;; indenting 'with'
+                (+ (current-column) 1))
+
+               (association_opt
+                ;; test/indent.ads
+                ;; 1 =>  --  Used to be aligned on "CSCL_Type'"
+                ;;       --  aligned with previous comment.
+                ;;   IO_CPU_Control_State_S_Pkg.CPU2_Fault_Status_Type'
+                (ada-wisi-indent-cache ada-indent-broken containing))
+
+               (asynchronous_select
+                ;; indenting 'abort'
+                (+ (current-column) ada-indent-broken))
+
+               (component_declaration
+                ;; test/ada_mode-nominal.ads record_type_3
+                (+ (current-column) ada-indent-broken))
+
+               (entry_body
+                ;; indenting 'when'
+                (+ (current-column) ada-indent-broken))
+
+               (formal_package_declaration
+                ;; test/ada_mode-generic_package.ads
+                ;; with package A_Package_7 is
+                ;;   new Ada.Text_IO.Integer_IO (Num => 
Formal_Signed_Integer_Type);
+                ;; indenting 'new'
+                (+ (current-column) ada-indent-broken))
+
+               (full_type_declaration
+                ;; test/ada_mode-nominal.ads
+                ;; type Unconstrained_Array_Type_3 is array (Integer range <>, 
Standard.Character range <>)
+                ;;   of Object_Access_Type_1;
+                ;; indenting 'of'
+                ;;
+                ;; type Object_Access_Type_7
+                ;;   is access all Integer;
+                ;; indenting 'is'
+                (while (not (eq 'TYPE (wisi-cache-token containing)))
+                  (setq containing (wisi-goto-containing containing)))
+                (+ (current-column) ada-indent-broken))
+
+               (generic_instantiation
+                ;; test/ada_mode-generic_instantiation.ads
+                ;; procedure Procedure_7 is
+                ;;   new Instance.Generic_Procedure (Integer, Function_1);
+                ;; indenting 'new'
+                (+ (current-column) ada-indent-broken))
+
+               (generic_renaming_declaration
+                ;; indenting keyword following 'generic'
+                (current-column))
+
+               (object_declaration
+                (cl-ecase (wisi-cache-token containing)
+                  (COLON
+                   ;; test/ada_mode-nominal.ads
+                   ;; Anon_Array_3 : array (1 .. 10)
+                   ;;   of Integer;
+                   ;; indenting 'of'
+                   (+ (current-indentation) ada-indent-broken))
+
+                  (COLON_EQUAL
+                   ;; test/indent.ads
+                   ;; C_S_Controls : constant
+                   ;;   CSCL_Type :=
+                   ;;     CSCL_Type'
+                   ;; indenting 'CSCL_Type'
+                   (+ (current-indentation) ada-indent-broken))
+
+                  (identifier_list
+                   ;; test/ada_mode-nominal.adb
+                   ;; Local_2 : constant Float
+                   ;;   := Local_1;
+                   (+ (current-indentation) ada-indent-broken))
+                  ))
+
+               (qualified_expression
+                ;; test/ada_mode-nominal-child.ads
+                ;; Child_Obj_5 : constant Child_Type_1 :=
+                ;;   (Parent_Type_1'
+                ;;     (Parent_Element_1 => 1,
+                (ada-wisi-indent-cache ada-indent-broken containing))
+
+               (statement
+                (cl-case (wisi-cache-token containing)
+                  (label_opt
+                   (- (current-column) ada-indent-label))
+
+                  (t
+                   ;; test/ada_mode-nominal.adb
+                   ;; select
+                   ;;    delay 1.0;
+                   ;; then
+                   ;;    -- ...
+                   ;;   abort
+                   (ada-wisi-indent-cache ada-indent-broken cache))
+                  ))
+
+               ((subprogram_body subprogram_declaration 
subprogram_specification null_procedure_declaration)
+                (cl-ecase (wisi-cache-token cache)
+                  (OVERRIDING
+                   ;; indenting 'overriding' following 'not'
+                   (current-column))
+
+                  ((PROCEDURE FUNCTION)
+                   ;; indenting 'procedure' or 'function following 'overriding'
+                   (current-column))
+                  ))
+
+               (subtype_declaration
+                ;; test/adacore_9717_001.ads A_Long_Name
+                (+ (current-column) ada-indent-broken))
+
+               ))))) ;; end statement-other
+
+       (statement-start
+        (cond
+         ((eq 'label_opt (wisi-cache-token cache))
+          (ada-wisi-indent-containing (+ ada-indent-label ada-indent) cache t))
+
+         (t
+          (let ((containing-cache (wisi-get-containing-cache cache)))
+            (if (not containing-cache)
+                ;; at bob
+                0
+              ;; not at bob
+              (cl-case (wisi-cache-class containing-cache)
+                ((block-start block-middle)
+                 (wisi-goto-containing cache)
+                 (cl-case (wisi-cache-nonterm containing-cache)
+                   (record_definition
+                    (+ (current-indentation) ada-indent))
+
+                   (t
+                    (ada-wisi-indent-cache ada-indent containing-cache))
+                   ))
+
+                (list-break
+                 ;; test/ada_mode-generic_instantiation.ads
+                 ;; function Function_1 is new Instance.Generic_Function
+                 ;;   (Param_Type  => Integer,
+                 ;;    Result_Type => Boolean,
+                 ;;    Threshold   => 2);
+                 ;;   indenting 'Result_Type'
+                 (wisi-indent-paren 1))
+
+                (statement-other
+                 (cl-case (wisi-cache-token containing-cache)
+                   (LEFT_PAREN
+                    ;; test/ada_mode-parens.adb
+                    ;; return Float (
+                    ;;               Integer'Value
+                    ;;   indenting 'Integer'
+                    (wisi-indent-paren 1))
+
+                   (EQUAL_GREATER
+                    ;; test/ada_mode-nested_packages.adb
+                    ;; exception
+                    ;;    when Io.Name_Error =>
+                    ;;       null;
+                    (ada-wisi-indent-containing ada-indent containing-cache t))
+
+                   (t
+                    ;; test/ada_mode-generic_instantiation.ads
+                    ;; procedure Procedure_6 is new
+                    ;;   Instance.Generic_Procedure (Integer, Function_1);
+                    ;;   indenting 'Instance'
+                    (ada-wisi-indent-containing ada-indent-broken cache t))
+                   ))
+                ))))
+            ))
+
+       (type
+        (ada-wisi-indent-containing ada-indent-broken cache t))
+       ))
+    ))
+
+(defun ada-wisi-after-cache ()
+  "Point is at indentation, not before a cached token. Find previous
+cached token, return new indentation for point."
+  (let ((start (point))
+       (prev-token (save-excursion (wisi-backward-token)))
+       (cache (wisi-backward-cache)))
+
+    (cond
+     ((not cache) ;; bob
+       0)
+
+     (t
+      (while (memq (wisi-cache-class cache) '(name name-paren type))
+       ;; not useful for indenting
+       (setq cache (wisi-backward-cache)))
+
+      (cl-ecase (wisi-cache-class cache)
+       (block-end
+        ;; indenting block/subprogram name after 'end'
+        (wisi-indent-current ada-indent-broken))
+
+       (block-middle
+        (cl-case (wisi-cache-token cache)
+          (IS
+           (cl-case (wisi-cache-nonterm cache)
+             (case_statement
+              ;; between 'case .. is' and first 'when'; most likely a comment
+              (ada-wisi-indent-containing 0 cache t))
+
+             (t
+              (+ (ada-wisi-indent-containing ada-indent cache t)))
+             ))
+
+          ((THEN ELSE)
+           (let ((indent
+                  (cl-ecase (wisi-cache-nonterm (wisi-get-containing-cache 
cache))
+                    ((statement if_statement elsif_statement_item) ada-indent)
+                    ((if_expression elsif_expression_item) 
ada-indent-broken))))
+             (ada-wisi-indent-containing indent cache t)))
+
+          (WHEN
+           ;; between 'when' and '=>'
+           (+ (current-column) ada-indent-broken))
+
+          (t
+           ;; block-middle keyword may not be on separate line:
+           ;;       function Create (Model   : in Integer;
+           ;;                        Context : in String) return String is
+           (ada-wisi-indent-containing ada-indent cache nil))
+          ))
+
+       (block-start
+        (cl-case (wisi-cache-nonterm cache)
+          (exception_handler
+           ;; between 'when' and '=>'
+           (+ (current-column) ada-indent-broken))
+
+          (if_expression
+           (ada-wisi-indent-containing ada-indent-broken cache nil))
+
+          (select_alternative
+           (ada-wisi-indent-containing (+ ada-indent-when ada-indent-broken) 
cache nil))
+
+          (t ;; other; normal block statement
+           (ada-wisi-indent-cache ada-indent cache))
+          ))
+
+       (close-paren
+        ;; actual_parameter_part: test/ada_mode-nominal.adb
+        ;; return 1.0 +
+        ;;   Foo (Bar) + -- multi-line expression that happens to have a cache 
at a line start
+        ;;   12;
+        ;; indenting '12'; don't indent relative to containing function name
+        ;;
+        ;; attribute_designator: test/ada_mode-nominal.adb
+        ;; raise Constraint_Error with Count'Image (Line (File)) &
+        ;;    "foo";
+        ;; indenting '"foo"'; relative to raise
+        (when (memq (wisi-cache-nonterm cache)
+                    '(actual_parameter_part attribute_designator))
+          (setq cache (wisi-goto-containing cache)))
+        (ada-wisi-indent-containing ada-indent-broken cache nil))
+
+       (list-break
+        (save-excursion
+          (let ((break-point (point))
+                (containing (wisi-goto-containing cache)))
+            (cl-ecase (wisi-cache-token containing)
+              (LEFT_PAREN
+               (let*
+                   ((list-element-token (wisi-cache-token (save-excursion 
(wisi-forward-cache))))
+                    (indent
+                     (cl-case list-element-token
+                       (WHEN ada-indent-when)
+                       (t 0))))
+                 (if (equal break-point (cl-caddr prev-token))
+                     ;; we are indenting the first token after the list-break; 
not hanging.
+                     (+ (current-column) 1 indent)
+                   ;; else hanging
+                   (+ (current-column) 1 ada-indent-broken indent))))
+
+              (IS
+               ;; ada_mode-conditional_expressions.adb
+               ;; L1 : Integer := (case J is
+               ;;                     when 42 => -1,
+               ;;                     -- comment aligned with 'when'
+               ;; indenting '-- comment'
+               (wisi-indent-paren (+ 1 ada-indent-when)))
+
+              (WITH
+               (cl-ecase (wisi-cache-nonterm containing)
+                 (aggregate
+                  ;; ada_mode-nominal-child.ads
+                  ;; (Default_Parent with
+                  ;;  Child_Element_1 => 10,
+                  ;;  Child_Element_2 => 12.0,
+                  (wisi-indent-paren 1))
+                 ))
+              ))))
+
+       (open-paren
+        ;; 1) A parenthesized expression, or the first item in an aggregate:
+        ;;
+        ;;    (foo +
+        ;;       bar)
+        ;;    (foo =>
+        ;;       bar)
+        ;;
+        ;;     we are indenting 'bar'
+        ;;
+        ;; 2) A parenthesized expression, or the first item in an
+        ;;    aggregate, and there is whitespace between
+        ;;    ( and the first token:
+        ;;
+        ;; test/ada_mode-parens.adb
+        ;; Local_9 : String := (
+        ;;                      "123"
+        ;;
+        ;; 3) A parenthesized expression, or the first item in an
+        ;;    aggregate, and there is a comment between
+        ;;    ( and the first token:
+        ;;
+        ;; test/ada_mode-nominal.adb
+        ;; A :=
+        ;;   (
+        ;;    -- a comment between paren and first association
+        ;;    1 =>
+        ;;
+        (let ((paren-column (current-column))
+              (start-is-comment (save-excursion (goto-char start) (looking-at 
comment-start-skip))))
+          (wisi-forward-token t); point is now after paren
+          (if start-is-comment
+              (skip-syntax-forward " >"); point is now on comment
+            (forward-comment (point-max)); point is now on first token
+            )
+          (if (= (point) start)
+              ;; case 2) or 3)
+              (1+ paren-column)
+            ;; 1)
+            (+ paren-column 1 ada-indent-broken))))
+
+       ((return-1 return-2)
+        ;; hanging. Intent relative to line containing matching 'function'
+        (ada-prev-statement-keyword)
+        (back-to-indentation)
+        (+ (current-column) ada-indent-broken))
+
+       (statement-end
+        (ada-wisi-indent-containing 0 cache nil))
+
+       (statement-other
+        (cl-ecase (wisi-cache-token cache)
+          (ABORT
+           ;; select
+           ;;    Please_Abort;
+           ;; then
+           ;;   abort
+           ;;    -- 'abort' indented with ada-broken-indent, since this is part
+           ;;    Titi;
+           (ada-wisi-indent-containing ada-indent cache))
+
+           ;; test/subdir/ada_mode-separate_task_body.adb
+          ((COLON COLON_EQUAL)
+           ;; Local_3 : constant Float :=
+           ;;   Local_2;
+           (ada-wisi-indent-cache ada-indent-broken cache))
+
+          (COMMA
+           (cl-ecase (wisi-cache-nonterm cache)
+             (name_list
+              (cl-ecase (wisi-cache-nonterm (wisi-get-containing-cache cache))
+                (use_clause
+                 ;; test/with_use1.adb
+                 (ada-wisi-indent-containing ada-indent-use cache))
+
+                (with_clause
+                 ;; test/ada_mode-nominal.ads
+                 ;; limited private with Ada.Strings.Bounded,
+                 ;;   --EMACSCMD:(test-face "Ada.Containers" 'default)
+                 ;;   Ada.Containers;
+                 ;;
+                 ;; test/with_use1.adb
+                 (ada-wisi-indent-containing ada-indent-with cache))
+                ))
+             ))
+
+          (ELSIF
+           ;; test/g-comlin.adb
+           ;; elsif Index_Switches + Max_Length <= Switches'Last
+           ;;   and then Switches (Index_Switches + Max_Length) = '?'
+           (ada-wisi-indent-cache ada-indent-broken cache))
+
+          (EQUAL_GREATER
+           (cl-ecase (wisi-cache-nonterm (wisi-goto-containing cache nil))
+             (actual_parameter_part
+              ;; ada_mode-generic_package.ads
+              ;; with package A_Package_2 is new Ada.Text_IO.Integer_IO (Num =>
+              ;;                                                           
Formal_Signed_Integer_Type);
+              ;;  indenting 'Formal_Signed_...', point on '(Num'
+              (+ (current-column) 1 ada-indent-broken))
+
+             (association_list
+              ;; test/ada_mode-parens.adb
+              ;; (1      => 1,
+              ;;  2      =>
+              ;;    1 + 2 * 3,
+              ;; point is on ','
+              (wisi-indent-paren (1+ ada-indent-broken)))
+
+             ((case_expression_alternative case_statement_alternative 
exception_handler)
+              ;; containing is 'when'
+              (+ (current-column) ada-indent))
+
+             (generic_renaming_declaration
+              ;; not indenting keyword following 'generic'
+              (+ (current-column) ada-indent-broken))
+
+             (primary
+              ;; test/ada_mode-quantified_expressions.adb
+              ;; if (for some J in 1 .. 10 =>
+              ;;       J/2 = 0)
+              (ada-wisi-indent-containing ada-indent-broken cache))
+
+             ))
+
+          (IS
+           (setq cache (wisi-goto-containing cache))
+           (cl-ecase (wisi-cache-nonterm cache)
+             (full_type_declaration
+              ;; ada_mode/nominal.ads
+              ;; type Limited_Derived_Type_1a is abstract limited new
+              ;;    Private_Type_1 with record
+              ;;       Component_1 : Integer;
+              ;; indenting 'Private_Type_1'; look for 'record'
+              (let ((type-column (current-column)))
+                (goto-char start)
+                (if (wisi-forward-find-token 'RECORD (line-end-position) t)
+                    ;; 'record' on line being indented
+                    (+ type-column ada-indent-record-rel-type)
+                  ;; 'record' on later line
+                  (+ type-column ada-indent-broken))))
+
+             ((formal_type_declaration
+               ;; test/ada_mode-generic_package.ads
+               ;; type Synchronized_Formal_Derived_Type is abstract 
synchronized new Formal_Private_Type and Interface_Type
+               ;;   with private;
+
+               subtype_declaration)
+               ;; test/ada_mode-nominal.ads
+               ;;    subtype Subtype_2 is Signed_Integer_Type range 10 ..
+               ;;      20;
+
+              (+ (current-column) ada-indent-broken))
+             ))
+
+          (LEFT_PAREN
+           ;; test/indent.ads
+           ;; C_S_Controls : constant
+           ;;   CSCL_Type :=
+           ;;     CSCL_Type'
+           ;;       (
+           ;;        1 =>
+           (+ (current-column) 1))
+
+          (OF
+           ;; ada_mode-nominal.ads
+           ;; Anon_Array_2 : array (1 .. 10) of
+           ;;   Integer;
+           (ada-wisi-indent-containing ada-indent-broken cache))
+
+          (NEW
+           ;; ada_mode-nominal.ads
+           ;; type Limited_Derived_Type_2 is abstract limited new 
Private_Type_1 with
+           ;;   private;
+           (ada-wisi-indent-containing ada-indent-broken cache))
+
+          (WHEN
+           ;; test/ada_mode-parens.adb
+           ;; exit when A.all
+           ;;   or else B.all
+           (ada-wisi-indent-containing ada-indent-broken cache))
+
+          (WITH
+           ;; extension aggregate: test/ada_mode-nominal-child.ads
+           ;;      (Default_Parent with
+           ;;       10, 12.0, True);
+           ;;   indenting '10'; containing is '('
+           ;;
+           ;; raise_statement: test/ada_mode-nominal.adb
+           ;; raise Constraint_Error with
+            ;;    "help!";
+           (cl-case (wisi-cache-nonterm cache)
+             (aggregate
+              (ada-wisi-indent-containing 0 cache nil))
+             (raise_statement
+              (ada-wisi-indent-containing ada-indent-broken cache nil))
+             ))
+
+          ;; otherwise just hanging
+          ((ACCEPT FUNCTION PROCEDURE RENAMES)
+           (back-to-indentation)
+           (+ (current-column) ada-indent-broken))
+
+         ))
+
+       (statement-start
+        (cl-case (wisi-cache-token cache)
+          (WITH ;; with_clause
+           (+ (current-column) ada-indent-with))
+
+          (label_opt
+           ;; comment after label
+           (+ (current-column) (- ada-indent-label)))
+
+          (t
+           ;; procedure Procedure_8
+           ;;   is new Instance.Generic_Procedure (Integer, Function_1);
+           ;; indenting 'is'; hanging
+           ;;      (+ (current-column) ada-indent-broken))
+           (ada-wisi-indent-cache ada-indent-broken cache))
+          ))
+       )))
+    ))
+
+(defun ada-wisi-comment ()
+  "Compute indentation of a comment. For `wisi-indent-functions'."
+  ;; 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.
+  (when (= 11 (syntax-class (syntax-after (point))))
+
+    ;; We are at a comment; indent to previous code or comment.
+    (cond
+     ((and ada-indent-comment-col-0
+          (= 0 (current-column)))
+      0)
+
+     ((or
+       (save-excursion (forward-line -1) (looking-at "\\s *$"))
+       (save-excursion (forward-comment -1)(not (looking-at comment-start))))
+      ;; comment is after a blank line or code; indent as if code
+      ;;
+      ;; ada-wisi-before-cache will find the keyword _after_ the
+      ;; comment, which could be a block-middle or block-end, and that
+      ;; would align the comment with the block-middle, which is wrong. So
+      ;; we only call ada-wisi-after-cache.
+
+      ;; FIXME: need option to match gnat style check; change indentation to 
match (ie mod 3)
+      (ada-wisi-after-cache))
+
+      (t
+       ;; comment is after a comment
+       (forward-comment -1)
+       (current-column))
+      )))
+
+(defun ada-wisi-post-parse-fail ()
+  "For `wisi-post-parse-fail-hook'."
+  (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."
+  (cl-case (wisi-cache-token cache)
+   (DECLARE t)
+   (IS
+    (memq (wisi-cache-class cache) '(block-start block-middle)))
+   (t nil)
+   ))
+
+(defun ada-wisi-context-clause ()
+  "For `ada-fix-context-clause'."
+  (wisi-validate-cache (point-max))
+  (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 nil)
+         (use_clause nil)
+         (with_clause
+          (when (not begin)
+            (setq begin (point-at-bol))))
+         (t
+          ;; start of compilation unit
+          (setq end (point-at-bol))
+          (unless begin
+            (setq begin end)))
+         ))
+      (cons begin end)
+    )))
+
+(defun ada-wisi-goto-declaration-start ()
+  "For `ada-goto-declaration-start', which see.
+Also return cache at start."
+  (wisi-validate-cache (point))
+  (let ((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)
+                   ((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))
+
+                   ((subprogram_body subprogram_declaration 
null_procedure_declaration)
+                    (memq (wisi-cache-token cache) '(NOT OVERRIDING FUNCTION 
PROCEDURE)))
+
+                   (task_type_declaration
+                    (eq (wisi-cache-token cache) 'TASK))
+
+                   ))
+           (unless done
+             (setq cache (wisi-goto-containing cache nil))))
+       (setq done t))
+       )
+    cache))
+
+(defun ada-wisi-goto-declarative-region-start ()
+  "For `ada-goto-declarative-region-start', which see."
+  (wisi-validate-cache (point))
+  (let ((done nil)
+       (first t)
+       (cache
+        (or
+         (wisi-get-cache (point))
+         ;; we use forward-cache here, to handle the case where point is after 
a subprogram declaration:
+         ;; declare
+         ;;     ...
+         ;;     function ... is ... end;
+         ;;     <point>
+         ;;     function ... is ... end;
+         (wisi-forward-cache))))
+    (while (not done)
+      (if (ada-wisi-declarative-region-start-p cache)
+         (progn
+           (wisi-forward-token t)
+           (setq done t))
+       (cl-case (wisi-cache-class cache)
+         ((block-middle block-end)
+          (setq cache (wisi-prev-statement-cache cache)))
+
+         (statement-start
+          ;; 1) test/ada_mode-nominal.adb
+          ;;    protected body Protected_1 is -- target 2
+          ;;        <point>
+          ;;    want target 2
+          ;;
+          ;; 2) test/ada_mode-nominal.adb
+          ;;    function Function_Access_1
+          ;;      (A_Param <point> : in Float)
+          ;;      return
+          ;;        Standard.Float
+          ;;    is -- target 1
+          ;;    want target 1
+          ;;
+          ;; 3) test/ada_mode-nominal-child.adb
+          ;;    overriding <point> function Function_2c (Param : in 
Child_Type_1)
+          ;;                                    return Float
+          ;;    is -- target Function_2c
+          ;;    want target
+
+          (if first
+              ;; case 1
+              (setq cache (wisi-goto-containing cache t))
+            ;; case 2, 3
+            (cl-case (wisi-cache-nonterm cache)
+              (subprogram_body
+               (while (not (eq 'IS (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)))
+         ))
+      (when first (setq first nil)))
+    ))
+
+(defun ada-wisi-in-paramlist-p ()
+  "For `ada-in-paramlist-p'."
+  (wisi-validate-cache (point))
+  ;; (info "(elisp)Parser State" "*syntax-ppss*")
+  (let* ((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-make-subprogram-body ()
+  "For `ada-make-subprogram-body'."
+  (wisi-validate-cache (point))
+  (when wisi-parse-failed
+    (error "syntax parse failed; cannot create body"))
+
+  (let* ((begin (point))
+        (end (save-excursion (wisi-forward-find-class 'statement-end 
(point-max)) (point)))
+        (cache (wisi-forward-find-class 'name end))
+        (name (buffer-substring-no-properties
+               (point)
+               (+ (point) (wisi-cache-last cache)))))
+    (goto-char end)
+    (newline)
+    (insert " is begin\nnull;\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); before 'null;'
+    ))
+
+(defun ada-wisi-scan-paramlist (begin end)
+  "For `ada-scan-paramlist'."
+  (wisi-validate-cache end)
+  (goto-char begin)
+  (let (token
+       text
+       identifiers
+       (in-p nil)
+       (out-p nil)
+       (not-null-p nil)
+       (access-p nil)
+       (constant-p nil)
+       (protected-p nil)
+       (type nil)
+       type-begin
+       type-end
+       (default nil)
+       (default-begin nil)
+       param
+       paramlist
+       (done nil))
+    (while (not done)
+      (let ((token-text (wisi-forward-token)))
+       (setq token (nth 0 token-text))
+       (setq text  (nth 1 token-text)))
+      (cond
+       ((equal token 'COMMA) nil);; multiple identifiers
+
+       ((equal token 'COLON)
+       ;; identifiers done. find type-begin; there may be no mode
+       (skip-syntax-forward " ")
+       (setq type-begin (point))
+       (save-excursion
+         (while (member (car (wisi-forward-token)) '(IN OUT NOT NULL ACCESS 
CONSTANT PROTECTED))
+           (skip-syntax-forward " ")
+           (setq type-begin (point)))))
+
+       ((equal token 'IN) (setq in-p t))
+       ((equal token 'OUT) (setq out-p t))
+       ((and (not type-end)
+            (member token '(NOT NULL)))
+       ;; "not", "null" could be part of the default expression
+       (setq not-null-p t))
+       ((equal token 'ACCESS) (setq access-p t))
+       ((equal token 'CONSTANT) (setq constant-p t))
+       ((equal token 'PROTECTED) (setq protected-p t))
+
+       ((equal token 'COLON_EQUAL)
+       (setq type-end (save-excursion (backward-char 2) (skip-syntax-backward 
" ") (point)))
+       (skip-syntax-forward " ")
+       (setq default-begin (point))
+       (wisi-forward-find-token 'SEMICOLON end t))
+
+       ((member token '(SEMICOLON RIGHT_PAREN))
+       (if (equal token 'RIGHT_PAREN)
+           ;; all done
+           (progn
+             (setq done t)
+             (when (not type-end) (setq type-end (1- (point))))
+             (when default-begin (setq default (buffer-substring-no-properties 
default-begin (1- (point)))))
+             )
+         ;; else semicolon - one param done
+         (when (not type-end) (setq type-end (1- (point))))
+         (when default-begin (setq default (buffer-substring-no-properties 
default-begin (1- (point)))))
+         )
+
+       (setq type (buffer-substring-no-properties type-begin type-end))
+       (setq param (list (reverse identifiers)
+                         in-p out-p not-null-p access-p constant-p protected-p
+                         type default))
+       (if paramlist
+           (add-to-list 'paramlist param)
+         (setq paramlist (list param)))
+       (setq identifiers nil
+             in-p nil
+             out-p nil
+             not-null-p nil
+             access-p nil
+             constant-p nil
+             protected-p nil
+             type nil
+             type-begin nil
+             type-end nil
+             default nil
+             default-begin nil))
+
+       (t
+       (when (not type-begin)
+         (if identifiers
+             (add-to-list 'identifiers text)
+           (setq identifiers (list text)))))
+       ))
+    paramlist))
+
+(defun ada-wisi-which-function-1 (keyword add-body)
+  "used in `ada-wisi-which-function'."
+  (let (region
+       result
+       (cache (wisi-forward-find-class 'name (point-max))))
+
+    (setq result (wisi-cache-text cache))
+
+    (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 ()
+  "For `ada-which-function'."
+  (wisi-validate-cache (point))
+  (save-excursion
+    (let ((result nil)
+         (cache (ada-wisi-goto-declaration-start)))
+      (if (null cache)
+         ;; bob
+         (setq result "")
+
+       (cl-case (wisi-cache-nonterm cache)
+         ((generic_package_declaration generic_subprogram_declaration)
+          ;; name is after next statement keyword
+          (wisi-next-statement-cache cache)
+          (setq cache (wisi-get-cache (point))))
+         )
+
+       ;; add or delete 'body' as needed
+       (cl-ecase (wisi-cache-nonterm cache)
+         (package_body
+          (setq result (ada-wisi-which-function-1 "package" nil)))
+
+         ((package_declaration
+           generic_package_declaration) ;; 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)))
+
+         ((subprogram_declaration
+           subprogram_specification ;; after 'generic'
+           null_procedure_declaration)
+          (setq result (ada-wisi-which-function-1
+                        (wisi-cache-text (wisi-forward-find-token '(FUNCTION 
PROCEDURE) (point-max)))
+                        nil))) ;; no 'body' keyword in subprogram bodies
+
+         (subprogram_body
+          (setq result (ada-wisi-which-function-1
+                        (wisi-cache-text (wisi-forward-find-token '(FUNCTION 
PROCEDURE) (point-max)))
+                        nil)))
+
+         (task_type_declaration
+          (setq result (ada-wisi-which-function-1 "task" t)))
+
+         ))
+      result)))
+
+;;;; debugging
+(defun ada-wisi-debug-keys ()
+  "Add debug key definitions to `ada-mode-map'."
+  (interactive)
+  (define-key ada-mode-map "\M-e" 'wisi-show-parse-error)
+  (define-key ada-mode-map "\M-h" 'wisi-show-containing-or-previous-cache)
+  (define-key ada-mode-map "\M-i" 'wisi-goto-end)
+  (define-key ada-mode-map "\M-j" 'wisi-show-cache)
+  (define-key ada-mode-map "\M-k" 'wisi-show-token)
+  )
+
+;;;###autoload
+(defun ada-wisi-setup ()
+  "Set up a buffer for parsing Ada files with wisi."
+  (wisi-setup '(ada-wisi-comment
+               ada-wisi-before-cache
+               ada-wisi-after-cache)
+             'ada-wisi-post-parse-fail
+             ada-wisi-class-list
+             ada-grammar-wy--keyword-table
+             ada-grammar-wy--token-table
+             ada-grammar-wy--parse-table)
+  (setq wisi-string-quote-escape-doubled t)
+
+  (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 ()
+  ;; run after file local variables are read because font-lock-add-keywords
+  ;; evaluates font-lock-defaults, which depends on ada-language-version.
+  (font-lock-add-keywords 'ada-mode
+   ;; use keyword cache to distinguish between 'function ... return <type>;' 
and 'return ...;'
+   (list
+    (list
+     (concat
+      "\\<\\("
+      "return[ \t]+access[ \t]+constant\\|"
+      "return[ \t]+access\\|"
+      "return"
+      "\\)\\>[ \t]*"
+      ada-name-regexp "?")
+     '(1 font-lock-keyword-face)
+     '(2 (if (eq (when (not (ada-in-string-or-comment-p))
+                  (wisi-validate-cache (match-end 2))
+                  (and (wisi-get-cache (match-beginning 2))
+                       (wisi-cache-class (wisi-get-cache (match-beginning 
2)))))
+                'type)
+            font-lock-type-face
+          'default)
+        nil t)
+     )))
+
+  (when global-font-lock-mode
+    ;; ensure the modified keywords are applied
+    (font-lock-refresh-defaults))
+  )
+
+(add-hook 'ada-mode-hook 'ada-wisi-setup)
+
+(setq ada-fix-context-clause 'ada-wisi-context-clause)
+(setq ada-goto-declaration-start 'ada-wisi-goto-declaration-start)
+(setq ada-goto-declarative-region-start 
'ada-wisi-goto-declarative-region-start)
+(setq ada-goto-end 'wisi-goto-end)
+(setq ada-in-paramlist-p 'ada-wisi-in-paramlist-p)
+(setq ada-indent-statement 'wisi-indent-statement)
+(setq ada-make-subprogram-body 'ada-wisi-make-subprogram-body)
+(setq ada-next-statement-keyword 'wisi-forward-statement-keyword)
+(setq ada-prev-statement-keyword 'wisi-backward-statement-keyword)
+(setq ada-scan-paramlist 'ada-wisi-scan-paramlist)
+(setq ada-show-parse-error 'wisi-show-parse-error)
+(setq ada-which-function 'ada-wisi-which-function)
+
+(provide 'ada-wisi)
+(provide 'ada-indent-engine)
+
+;; end of file
diff --git a/packages/ada-mode/ada_license.text 
b/packages/ada-mode/ada_license.text
new file mode 100755
index 0000000..995a753
--- /dev/null
+++ b/packages/ada-mode/ada_license.text
@@ -0,0 +1,127 @@
+Copyright © 1992, 1993, 1994, 1995  Intermetrics, Inc.
+
+Copyright © 2000  The MITRE Corporation, Inc.
+
+Copyright © 2004, 2005, 2006  AXE Consultants
+
+Copyright © 2004, 2005, 2006  Ada-Europe
+
+Copyright © 2008, 2009, 2010, 2011, 2012  AXE Consultants
+
+
+Ada Reference Manual - Language and Standard Libraries
+
+Copyright © 1992, 1993, 1994, 1995, Intermetrics, Inc.
+
+This copyright is assigned to the U.S. Government.  All rights reserved.
+
+This document may be copied, in whole or in part, in any form or by any
+means, as is or with alterations, provided that (1) alterations are
+clearly marked as alterations and (2) this copyright notice is included
+unmodified in any copy. Compiled copies of standard library units and
+examples need not contain this copyright notice so long as the notice
+is included in all copies of source code and documentation.
+
+---------
+
+Technical Corrigendum 1
+
+Copyright © 2000, The MITRE Corporation.  All Rights Reserved.
+
+This document may be copied, in whole or in part, in any form or by any
+means, as is, or with alterations, provided that (1) alterations are
+clearly marked as alterations and (2) this copyright notice is included
+unmodified in any copy. Any other use or distribution of this document
+is prohibited without the prior express permission of MITRE.
+
+You use this document on the condition that you indemnify and hold
+harmless MITRE, its Board of Trustees, officers, agents, and employees,
+from any and all liability or damages to yourself or your hardware or
+software, or third parties, including attorneys' fees, court costs, and
+other related costs and expenses, arising out of your use of this
+document irrespective of the cause of said liability.
+
+MITRE MAKES THIS DOCUMENT AVAILABLE ON AN "AS IS" BASIS AND MAKES NO
+WARRANTY, EXPRESS OR IMPLIED, AS TO THE ACCURACY, CAPABILITY,
+EFFICIENCY MERCHANTABILITY, OR FUNCTIONING OF THIS DOCUMENT.  IN NO
+EVENT WILL MITRE BE LIABLE FOR ANY GENERAL, CONSEQUENTIAL, INDIRECT,
+INCIDENTAL, EXEMPLARY, OR SPECIAL DAMAGES, EVEN IF MITRE HAS BEEN
+ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+
+
+
+Amendment 1
+
+Copyright © 2004, 2005, 2006, 2007, AXE Consultants.  All Rights
+Reserved.
+
+This document may be copied, in whole or in part, in any form or by any
+means, as is, or with alterations, provided that (1) alterations are
+clearly marked as alterations and (2) this copyright notice is included
+unmodified in any copy. Any other use or distribution of this document
+is prohibited without the prior express permission of AXE.
+
+You use this document on the condition that you indemnify and hold
+harmless AXE, its board, officers, agents, and employees, from any and
+all liability or damages to yourself or your hardware or software, or
+third parties, including attorneys' fees, court costs, and other
+related costs and expenses, arising out of your use of this document
+irrespective of the cause of said liability.
+
+AXE MAKES THIS DOCUMENT AVAILABLE ON AN "AS IS" BASIS AND MAKES NO
+WARRANTY, EXPRESS OR IMPLIED, AS TO THE ACCURACY, CAPABILITY,
+EFFICIENCY MERCHANTABILITY, OR FUNCTIONING OF THIS DOCUMENT. IN NO
+EVENT WILL AXE BE LIABLE FOR ANY GENERAL, CONSEQUENTIAL, INDIRECT,
+INCIDENTAL, EXEMPLARY, OR SPECIAL DAMAGES, EVEN IF AXE HAS BEEN ADVISED
+OF THE POSSIBILITY OF SUCH DAMAGES.
+
+Third Edition
+
+Copyright © 2008, 2009, 2010, 2011, 2012 AXE Consultants.  All Rights
+Reserved.
+
+This document may be copied, in whole or in part, in any form or by any
+means, as is, or with alterations, provided that (1) alterations are
+clearly marked as alterations and (2) this copyright notice is included
+unmodified in any copy. Any other use or distribution of this document
+is prohibited without the prior express permission of AXE.
+
+You use this document on the condition that you indemnify and hold
+harmless AXE, its board, officers, agents, and employees, from any and
+all liability or damages to yourself or your hardware or software, or
+third parties, including attorneys' fees, court costs, and other
+related costs and expenses, arising out of your use of this document
+irrespective of the cause of said liability.
+
+AXE MAKES THIS DOCUMENT AVAILABLE ON AN "AS IS" BASIS AND MAKES NO
+WARRANTY, EXPRESS OR IMPLIED, AS TO THE ACCURACY, CAPABILITY,
+EFFICIENCY MERCHANTABILITY, OR FUNCTIONING OF THIS DOCUMENT. IN NO
+EVENT WILL AXE BE LIABLE FOR ANY GENERAL, CONSEQUENTIAL, INDIRECT,
+INCIDENTAL, EXEMPLARY, OR SPECIAL DAMAGES, EVEN IF AXE HAS BEEN ADVISED
+OF THE POSSIBILITY OF SUCH DAMAGES.
+
+
+
+Ada 2005 Consolidated Standard
+
+Copyright © 2004, 2005, 2006, Ada-Europe.
+
+This document may be copied, in whole or in part, in any form or by any
+means, as is, or with alterations, provided that (1) alterations are
+clearly marked as alterations and (2) this copyright notice is included
+unmodified in any copy. Any other use or distribution of this document
+is prohibited without the prior express permission of Ada-Europe.
+
+You use this document on the condition that you indemnify and hold
+harmless Ada-Europe and its Board from any and all liability or damages
+to yourself or your hardware or software, or third parties, including
+attorneys' fees, court costs, and other related costs and expenses,
+arising out of your use of this document irrespective of the cause of
+said liability.
+
+ADA-EUROPE MAKES THIS DOCUMENT AVAILABLE ON AN "AS IS" BASIS AND MAKES
+NO WARRANTY, EXPRESS OR IMPLIED, AS TO THE ACCURACY, CAPABILITY,
+EFFICIENCY MERCHANTABILITY, OR FUNCTIONING OF THIS DOCUMENT. IN NO
+EVENT WILL ADA-EUROPE BE LIABLE FOR ANY GENERAL, CONSEQUENTIAL,
+INDIRECT, INCIDENTAL, EXEMPLARY, OR SPECIAL DAMAGES, EVEN IF ADA-EUROPE
+HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
diff --git a/packages/ada-mode/gnat-core.el b/packages/ada-mode/gnat-core.el
new file mode 100755
index 0000000..c6e597f
--- /dev/null
+++ b/packages/ada-mode/gnat-core.el
@@ -0,0 +1,400 @@
+;; Support for running GNAT tools, which support multiple programming
+;; languages.
+;;
+;; GNAT is provided by AdaCore; see http://libre.adacore.com/
+;;
+;;; Copyright (C) 2012, 2013  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/>.
+
+;; We use cl-delete-if, defined in cl-seq.el. cl-seq.el has no
+;; 'provide'.  autoload for cl-delete-if is defined in cl-loaddefs.el,
+;; which is not pre-loaded.  cl-lib does (load "cl-loaddefs.el"), so
+;; that seems to be the thing to do
+(require 'cl-lib)
+
+;;;;; code
+
+;;;; project file handling
+
+(defun gnat-prj-add-prj-dir (dir project)
+  "Add DIR to 'prj_dir and to GPR_PROJECT_PATH in 'proc_env. Return new 
project."
+  (let ((prj-dir (plist-get project 'prj_dir)))
+
+    (cond
+     ((listp prj-dir)
+       (add-to-list 'prj-dir dir))
+
+     (prj-dir
+      (setq prj-dir (list dir)))
+
+     (t nil))
+
+    (setq project (plist-put project 'prj_dir prj-dir))
+
+    (let ((process-environment (plist-get project 'proc_env)))
+      (setenv "GPR_PROJECT_PATH"
+             (mapconcat 'identity
+                        (plist-get project 'prj_dir)
+                        (plist-get project 'path_sep)))
+
+      (setq project (plist-put project 'proc_env process-environment))
+      )
+
+    project))
+
+(defun gnat-prj-parse-emacs-one (name value project)
+  "Handle gnat-specific Emacs Ada project file settings.
+Return new PROJECT if NAME recognized, nil otherwise.
+See also `gnat-parse-emacs-final'."
+  (let ((process-environment (plist-get project 'proc_env))); for 
substitute-in-file-name
+    (cond
+     ((or
+       ;; we allow either name here for backward compatibility
+       (string= name "gpr_project_path")
+       (string= name "ada_project_path"))
+      ;; We maintain two project values for this;
+      ;; 'prj_dir - a list of directories, for gpr-ff-special-with
+      ;; GPR_PROJECT_PATH in 'proc_env, for gnat-run
+      (gnat-prj-add-prj-dir (expand-file-name (substitute-in-file-name value)) 
project))
+
+     ((string= (match-string 1) "gpr_file")
+      ;; The file is parsed in `gnat-parse-emacs-prj-file-final', so
+      ;; it can add to user-specified src_dir.
+      (setq project
+           (plist-put project
+                      'gpr_file
+                      (expand-file-name (substitute-in-file-name value))))
+      project)
+     )))
+
+(defun gnat-prj-parse-emacs-final (project)
+  "Final processing of gnat-specific Emacs Ada project file settings."
+  (when (buffer-live-p (get-buffer (gnat-run-buffer-name)))
+    (kill-buffer (gnat-run-buffer-name))); things may have changed, force 
re-create
+
+  (if (ada-prj-get 'gpr_file project)
+      (set 'project (gnat-parse-gpr (ada-prj-get 'gpr_file project) project))
+
+    ;; add the compiler libraries to src_dir
+    (setq project (gnat-get-paths project))
+    )
+
+  project)
+
+(defun gnat-get-paths (project)
+  "Add project and/or compiler source, object paths to PROJECT src_dir and/or 
prc_dir."
+  (with-current-buffer (gnat-run-buffer)
+    ;; gnat list -v -P can return status 0 or 4; always lists compiler dirs
+    (let ((src-dirs (ada-prj-get 'src_dir project))
+         (prj-dirs (ada-prj-get 'prj_dir project)))
+
+      (gnat-run-gnat "list" (list "-v") '(0 4))
+
+      (goto-char (point-min))
+
+      (condition-case nil
+         (progn
+           ;; Source path
+           (search-forward "Source Search Path:")
+           (forward-line 1)
+           (while (not (looking-at "^$")) ; terminate on blank line
+             (back-to-indentation) ; skip whitespace forward
+             (if (looking-at "<Current_Directory>")
+                 (add-to-list 'src-dirs  (directory-file-name 
default-directory))
+               (add-to-list 'src-dirs
+                            (expand-file-name ; canonicalize path part
+                             (directory-file-name
+                              (buffer-substring-no-properties (point) 
(point-at-eol))))))
+             (forward-line 1))
+
+           ;; Project path
+           ;;
+           ;; These are also added to src_dir, so compilation errors
+           ;; reported in project files are found.
+           (search-forward "Project Search Path:")
+           (forward-line 1)
+           (while (not (looking-at "^$"))
+             (back-to-indentation)
+             (if (looking-at "<Current_Directory>")
+                 (add-to-list 'prj-dirs ".")
+               (add-to-list 'prj-dirs
+                            (expand-file-name
+                             (buffer-substring-no-properties (point) 
(point-at-eol))))
+               (add-to-list 'src-dirs
+                            (expand-file-name
+                             (buffer-substring-no-properties (point) 
(point-at-eol)))))
+             (forward-line 1))
+
+           )
+       ('error
+        (pop-to-buffer (current-buffer))
+        ;; search-forward failed
+        (error "parse gpr failed")
+        ))
+
+      (setq project (plist-put project 'src_dir (reverse src-dirs)))
+      (mapc (lambda (dir) (gnat-prj-add-prj-dir dir project))
+           (reverse prj-dirs))
+      ))
+  project)
+
+(defun gnat-parse-gpr (gpr-file project)
+  "Append to src_dir and prj_dir in PROJECT by parsing GPR-FILE.
+Return new value of PROJECT.
+GPR-FILE must be full path to file, normalized.
+src_dir will include compiler runtime."
+  ;; this can take a long time; let the user know what's up
+  (message "Parsing %s ..." gpr-file)
+
+  (if (ada-prj-get 'gpr_file project)
+      ;; gpr-file defined in Emacs Ada mode project file
+      (when (not (equal gpr-file (ada-prj-get 'gpr_file project)))
+       (error "Ada project file %s defines a different GNAT project file than 
%s"
+              ada-prj-current-file
+              gpr-file))
+
+    ;; gpr-file is top level Ada mode project file
+    (setq project (plist-put project 'gpr_file gpr-file))
+    )
+
+  (setq project (gnat-get-paths project))
+
+  (message "Parsing %s ... done" gpr-file)
+  project)
+
+;;;; command line tool interface
+
+(defun gnat-run-buffer-name (&optional prefix)
+  (concat (or prefix " *gnat-run-")
+         (or (ada-prj-get 'gpr_file)
+             ada-prj-current-file)
+         "*"))
+
+(defun gnat-run-buffer (&optional buffer-name-prefix)
+  "Return a buffer suitable for running gnat command line tools for the 
current project."
+  (ada-require-project-file)
+  (let* ((name (gnat-run-buffer-name buffer-name-prefix))
+        (buffer (get-buffer name)))
+    (if buffer
+       buffer
+      (setq buffer (get-buffer-create name))
+      (with-current-buffer buffer
+       (setq default-directory
+             (file-name-directory
+              (or (ada-prj-get 'gpr_file)
+                  ada-prj-current-file)))
+       )
+      buffer)))
+
+(defun gnat-run (exec command &optional err-msg expected-status)
+  "Run a gnat command line tool, as \"EXEC COMMAND\".
+EXEC must be an executable found on `exec-path'. COMMAND must be a list of 
strings.
+ERR-MSG must be nil or a string.
+EXPECTED-STATUS must be nil or a list of integers.
+Return process status.
+Assumes current buffer is (gnat-run-buffer)"
+  (set 'buffer-read-only nil)
+  (erase-buffer)
+
+  (setq command (cl-delete-if 'null command))
+
+  (let ((process-environment (ada-prj-get 'proc_env)) ;; for GPR_PROJECT_PATH
+       status)
+
+    (insert (format "GPR_PROJECT_PATH=%s\n%s " (getenv "GPR_PROJECT_PATH") 
exec)); for debugging
+    (mapc (lambda (str) (insert (concat str " "))) command); for debugging
+    (newline)
+
+    (setq status (apply 'call-process exec nil t nil command))
+    (cond
+     ((memq status (or expected-status '(0))); success
+      nil)
+
+     (t ; failure
+      (pop-to-buffer (current-buffer))
+      (if err-msg
+         (error "%s %s failed; %s" exec (car command) err-msg)
+       (error "%s %s failed" exec (car command))
+       ))
+     )))
+
+(defun gnat-run-gnat (command &optional switches-args expected-status)
+  "Run the \"gnat\" command line tool, as \"gnat COMMAND -P<prj> 
SWITCHES-ARGS\".
+COMMAND must be a string, SWITCHES-ARGS a list of strings.
+EXPECTED-STATUS must be nil or a list of integers.
+Return process status.
+Assumes current buffer is (gnat-run-buffer)"
+  (let* ((project-file-switch
+         (when (ada-prj-get 'gpr_file)
+           (concat "-P" (file-name-nondirectory (ada-prj-get 'gpr_file)))))
+        (cmd (append (list command) (list project-file-switch) switches-args)))
+
+    (gnat-run "gnat" cmd nil expected-status)
+    ))
+
+(defun gnat-run-no-prj (command &optional dir)
+  "Run the gnat command line tool, as \"gnat COMMAND\", with DIR as current 
directory.
+Return process status.  Assumes current buffer
+is (gnat-run-buffer)"
+  (set 'buffer-read-only nil)
+  (erase-buffer)
+
+  (setq command (cl-delete-if 'null command))
+  (mapc (lambda (str) (insert (concat str " "))) command)
+  (newline)
+
+  (let ((default-directory (or dir default-directory))
+       status)
+
+    (setq status (apply 'call-process "gnat" nil t nil command))
+    (cond
+     ((= status 0); success
+      nil)
+
+     (t ; failure
+      (pop-to-buffer (current-buffer))
+      (error "gnat %s failed" (car command)))
+     )))
+
+;;;; gnatprep utils
+
+(defun gnatprep-indent ()
+  "If point is on a gnatprep keyword, return indentation column
+for it. Otherwise return nil.  Intended to be added to
+`wisi-indent-calculate-functions' or other indentation function
+list."
+  ;; gnatprep keywords are:
+  ;;
+  ;; #if identifier [then]
+  ;; #elsif identifier [then]
+  ;; #else
+  ;; #end if;
+  ;;
+  ;; they are all indented at column 0.
+  (when (equal (char-after) ?\#) 0))
+
+(defun gnatprep-syntax-propertize (start end)
+  (goto-char start)
+  (while (re-search-forward
+         "^[ \t]*\\(#\\(?:if\\|else\\|elsif\\|end\\)\\)"; gnatprep keywords.
+         end t)
+    (cond
+     ((match-beginning 1)
+      (put-text-property
+       (match-beginning 1) (match-end 1) 'syntax-table '(11 . ?\n)))
+     )
+    ))
+
+;;;; support for ada-gnat-xref and ada-gnatinspect
+(defun ada-gnat-file-name-from-ada-name (ada-name)
+  "For `ada-file-name-from-ada-name'."
+  (let ((result nil))
+
+    (while (string-match "\\." ada-name)
+      (setq ada-name (replace-match "-" t t ada-name)))
+
+    (setq ada-name (downcase ada-name))
+
+    (with-current-buffer (gnat-run-buffer)
+      (gnat-run-no-prj
+       (list
+       "krunch"
+       ada-name
+       ;; "0" means only krunch GNAT library names
+       "0"))
+
+      (goto-char (point-min))
+      (forward-line 1); skip  cmd
+      (setq result (buffer-substring-no-properties (line-beginning-position) 
(line-end-position)))
+      )
+    result))
+
+(defconst ada-gnat-predefined-package-alist
+  '(("a-textio" . "Ada.Text_IO")
+    ("a-chahan" . "Ada.Characters.Handling")
+    ("a-comlin" . "Ada.Command_Line")
+    ("a-except" . "Ada.Exceptions")
+    ("a-numeri" . "Ada.Numerics")
+    ("a-string" . "Ada.Strings")
+    ("a-strmap" . "Ada.Strings.Maps")
+    ("a-strunb" . "Ada.Strings.Unbounded")
+    ("g-socket" . "GNAT.Sockets")
+    ("interfac" . "Interfaces")
+    ("i-c"      . "Interfaces.C")
+    ("i-cstrin" . "Interfaces.C.Strings")
+    ("s-stoele" . "System.Storage_Elements")
+    ("unchconv" . "Unchecked_Conversion") ; Ada 83 name
+    )
+  "Alist (filename . package name) of GNAT file names for predefined Ada 
packages.")
+
+(defun ada-gnat-ada-name-from-file-name (file-name)
+  "For `ada-ada-name-from-file-name'."
+  (let* (status
+        (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)))
+
+(defun ada-gnat-make-package-body (body-file-name)
+  "For `ada-make-package-body'."
+  ;; WORKAROUND: gnat stub 7.1w does not accept aggregate project files,
+  ;; and doesn't use the gnatstub package if it is in a 'with'd
+  ;; project file; see AdaCore ticket LC30-001. On the other hand we
+  ;; need a project file to specify the source dirs so the tree file
+  ;; can be generated. So we use gnat-run-no-prj, and the user
+  ;; must specify the proper project file in gnat_stub_opts.
+  ;;
+  ;; 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 pass a directory to gnat-run-no-prj.
+  (let ((start-buffer (current-buffer))
+       (start-file (buffer-file-name))
+       ;; can also specify gnat stub options/switches in .gpr file, in package 
'gnatstub'.
+       (opts (when (ada-prj-get 'gnat_stub_opts)
+               (split-string (ada-prj-get 'gnat_stub_opts))))
+       (switches (when (ada-prj-get 'gnat_stub_switches)
+                   (split-string (ada-prj-get 'gnat_stub_switches))))
+       )
+
+    ;; Make sure all relevant files are saved to disk. This also saves
+    ;; the bogus body buffer created by ff-find-the-other-file, so we
+    ;; need -f gnat stub option. We won't get here if there is an
+    ;; existing body file.
+    (save-some-buffers t)
+    (add-to-list 'opts "-f")
+    (with-current-buffer (gnat-run-buffer)
+      (gnat-run-no-prj
+       (append (list "stub") opts (list start-file "-cargs") switches)
+       (file-name-directory body-file-name))
+
+      (find-file body-file-name)
+      (indent-region (point-min) (point-max))
+      (save-buffer)
+      (set-buffer start-buffer)
+      )
+    nil))
+
+(provide 'gnat-core)
+
+;; end of file
diff --git a/packages/ada-mode/gnat-inspect.el 
b/packages/ada-mode/gnat-inspect.el
new file mode 100755
index 0000000..055f942
--- /dev/null
+++ b/packages/ada-mode/gnat-inspect.el
@@ -0,0 +1,542 @@
+;;; gnat-inspect.el --- minor-mode for navigating sources using the
+;;; AdaCore cross reference tool gnatinspect.
+;;;
+;;; gnatinspect supports Ada and any gcc language that supports the
+;;; -fdump-xref switch (which includes C, C++).
+;;
+;;; Copyright (C) 2013  Free Software Foundation, Inc.
+
+;; Author: Stephen Leake <address@hidden>
+;; Maintainer: Stephen Leake <address@hidden>
+;; Version: 1.0
+
+;; 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/>.
+
+;;; Usage:
+;;
+;; M-x gnat-inspect
+
+(require 'compile)
+(require 'ada-mode) ;; for ada-prj-*, some other things
+(eval-when-compile (require 'cl-macs))
+
+;;;;; sessions
+
+;; gnatinspect reads the project files and the database at startup,
+;; which is noticeably slow for a reasonably sized project. But
+;; running queries after startup is fast. So we leave gnatinspect
+;; running, and send it new queries via stdin, getting responses via
+;; stdout.
+;;
+;; We maintain a cache of active sessions, one per gnat project.
+
+(cl-defstruct (gnat-inspect--session)
+  (process nil) ;; running gnatinspect
+  (buffer nil)  ;; receives output of gnatinspect
+  (sent-kill-p nil)
+  (closed-p nil))
+
+(defconst gnat-inspect-buffer-name-prefix " *gnatinspect-")
+
+(defun gnat-inspect--start-process (session)
+  "Start the session process running gnatinspect."
+  (unless (buffer-live-p (gnat-inspect--session-buffer session))
+    ;; user may have killed buffer
+    (setf (gnat-inspect--session-buffer session) (gnat-run-buffer 
gnat-inspect-buffer-name-prefix)))
+
+  (with-current-buffer (gnat-inspect--session-buffer session)
+    (let ((process-environment (ada-prj-get 'proc_env)) ;; for GPR_PROJECT_PATH
+
+         ;; WORKAROUND: gnatinspect from gnatcoll-1.6w-20130902 can't handle 
aggregate projects; M910-032
+         (project-file (file-name-nondirectory
+                        (or (ada-prj-get 'gnat_inspect_gpr_file)
+                            (ada-prj-get 'gpr_file)))))
+      (erase-buffer); delete any previous messages, prompt
+      (setf (gnat-inspect--session-process session)
+           ;; FIXME: need good error message on bad project file:
+           ;;          "can't handle aggregate projects? - set 
gnat_inspect_gpr_file")
+           (start-process (concat "gnatinspect " (buffer-name))
+                          (gnat-inspect--session-buffer session)
+                          "gnatinspect"
+                          (concat "--project=" project-file)))
+      (set-process-query-on-exit-flag (gnat-inspect--session-process session) 
nil)
+      (gnat-inspect-session-wait session)
+      )))
+
+(defun gnat-inspect--make-session ()
+  "Create and return a session for the current project file."
+  (let ((session
+        (make-gnat-inspect--session
+         :buffer (gnat-run-buffer gnat-inspect-buffer-name-prefix))))
+    (gnat-inspect--start-process session)
+    session))
+
+(defvar gnat-inspect--sessions '()
+  "Assoc list of sessions, indexed by absolute GNAT project file name.")
+
+(defun gnat-inspect-cached-session ()
+  "Return a session for the current project file, creating it if necessary."
+  (let* ((session (cdr (assoc ada-prj-current-file gnat-inspect--sessions))))
+    (if session
+       (progn
+         (unless (process-live-p (gnat-inspect--session-process session))
+           (gnat-inspect--start-process session))
+         session)
+      ;; else
+      (prog1
+          (setq session (gnat-inspect--make-session))
+       (setq gnat-inspect--sessions
+             (cl-acons ada-prj-current-file session gnat-inspect--sessions))))
+    ))
+
+(defconst gnat-inspect-prompt "^>>> $"
+  ;; gnatinspect output ends with this
+  "Regexp matching gnatinspect prompt; indicates previous command is 
complete.")
+
+(defun gnat-inspect-session-wait (session)
+  "Wait for the current command to complete."
+  (with-current-buffer (gnat-inspect--session-buffer session)
+    (let ((process (gnat-inspect--session-process session))
+         (search-start (point-min))
+         (wait-count 0))
+      (while (progn
+              ;; process output is inserted before point, so move back over it 
to search it
+              (goto-char search-start)
+              (not (re-search-forward gnat-inspect-prompt (point-max) 1)));; 
don't search same text again
+       (setq search-start (point))
+       (message (concat "running gnatinspect ..." (make-string wait-count ?.)))
+       (accept-process-output process 1.0)
+       (setq wait-count (1+ wait-count)))
+      (message (concat "running gnatinspect ... done"))
+      )))
+
+(defun gnat-inspect-session-send (cmd wait)
+  "Send CMD to gnatinspect session for current project.
+If WAIT is non-nil, wait for command to complete.
+Return buffer that holds output."
+  (let ((session (gnat-inspect-cached-session)))
+    (with-current-buffer (gnat-inspect--session-buffer session)
+      (erase-buffer)
+      (process-send-string (gnat-inspect--session-process session)
+                          (concat cmd "\n"))
+      (when wait
+       (gnat-inspect-session-wait session))
+      (current-buffer)
+      )))
+
+(defun gnat-inspect-session-kill (session)
+  (when (process-live-p (gnat-inspect--session-process session))
+    (process-send-string (gnat-inspect--session-process session) "exit\n")))
+
+(defun gnat-inspect-kill-all-sessions ()
+  (interactive)
+  (mapc (lambda (assoc) (gnat-inspect-session-kill (cdr assoc))) 
gnat-inspect--sessions))
+
+;;;;; utils
+
+(defconst gnat-inspect-ident-file-regexp
+  ;; 
Write_Message:C:\Projects\GDS\work_dscovr_release\common\1553\gds-mil_std_1553-utf.ads:252:25
+  ;; 
Write_Message:/Projects/GDS/work_dscovr_release/common/1553/gds-mil_std_1553-utf.ads:252:25
+  
"\\([^:]*\\):\\(\\(?:.:\\\|/\\)[^:]*\\):\\([0123456789]+\\):\\([0123456789]+\\)"
+  "Regexp matching <identifier>:<file>:<line>:<column>")
+
+(defconst gnat-inspect-ident-file-regexp-alist
+  (list (concat "^" gnat-inspect-ident-file-regexp) 2 3 4)
+  "For compilation-error-regexp-alist, matching `gnatinspect 
overriding_recursive' output")
+
+(defconst gnat-inspect-ident-file-type-regexp
+  (concat gnat-inspect-ident-file-regexp " (\\(.*\\))")
+  "Regexp matching <identifier>:<file>:<line>:<column> (<type>)")
+
+(defconst gnat-inspect-ident-file-scope-regexp-alist
+  ;; RX_Enable:C:\common\1553\gds-hardware-bus_1553-raw_read_write.adb:163:13 
(write reference) 
scope=New_Packet_TX:C:\common\1553\gds-hardware-bus_1553-raw_read_write.adb:97:14
+
+  (list (concat
+        gnat-inspect-ident-file-regexp
+        " (.*) "
+        "scope="
+        gnat-inspect-ident-file-regexp
+        )
+       2 3 4;; file line column
+       ;; 2 ;; type = error
+       ;; nil ;; hyperlink
+       ;; (list 4 'gnat-inspect-scope-secondary-error)
+       )
+  "For compilation-error-regexp-alist, matching `gnatinspect refs' output")
+
+;; debugging:
+;; in *compilation-gnatinspect-refs*, run
+;;  (progn (set-text-properties (point-min)(point-max) 
nil)(compilation-parse-errors (point-min)(point-max) 
gnat-inspect-ident-file-scope-regexp-alist))
+
+(defun gnat-inspect-compilation (identifier file line col cmd comp-err)
+  "Run gnatinspect IDENTIFIER:FILE:LINE:COL CMD,
+set compilation-mode with compilation-error-regexp-alist set to COMP-ERR."
+  (let ((cmd-1 (format "%s %s:%s:%d:%d" cmd identifier file line col))
+       (result-count 0)
+       file line column)
+    (with-current-buffer (gnat-inspect--session-buffer 
(gnat-inspect-cached-session))
+      (compilation-mode)
+      (setq buffer-read-only nil)
+      (set (make-local-variable 'compilation-error-regexp-alist) (list 
comp-err))
+      (gnat-inspect-session-send cmd-1 t)
+      ;; at EOB. gnatinspect returns one line per result
+      (setq result-count (- (line-number-at-pos) 1))
+      (font-lock-fontify-buffer)
+      ;; font-lock-fontify-buffer applies compilation-message text properties
+      ;; IMPROVEME: for some reason, next-error works, but the font
+      ;; colors are not right (no koolaid!)
+      (goto-char (point-min))
+
+      (cl-case result-count
+       (0
+        (error "gnatinspect returned no results"))
+       (1
+        ;; just go there, don't display session-buffer. We have to
+        ;; fetch the compilation-message while in the session-buffer.
+        (let* ((msg (compilation-next-error 0 nil (point-min)))
+               (loc (compilation--message->loc msg)))
+          (setq file (caar (compilation--loc->file-struct loc))
+                line (caar (cddr (compilation--loc->file-struct loc)))
+                column (1- (compilation--loc->col loc)))
+          ))
+
+       ));; case, with-currrent-buffer
+
+    ;; compilation-next-error-function assumes there is not at error
+    ;; at point-min; work around that by moving forward 0 errors for
+    ;; the first one.
+    (if (> result-count 1)
+       ;; more than one result; display session buffer
+       (next-error 0 t)
+      ;; else don't display
+      (ada-goto-source file line column nil))
+    ))
+
+(defun gnat-inspect-dist (found-line line found-col col)
+  "Return non-nil if found-line, -col is closer to line, col than 
min-distance."
+  (+ (abs (- found-line line))
+     (* (abs (- found-col col)) 250)))
+
+;;;;; user interface functions
+
+(defun gnat-inspect-refresh ()
+  "For `ada-xref-refresh-function', using gnatinspect."
+  (with-current-buffer (gnat-inspect-session-send "refresh" t)))
+
+(defun gnat-inspect-other (identifier file line col)
+  "For `ada-xref-other-function', using gnatinspect."
+  (unless (ada-prj-get 'gpr_file)
+    (error "no gnat project file defined."))
+
+  (when (eq ?\" (aref identifier 0))
+    ;; gnatinspect wants the quotes stripped
+    (setq col (+ 1 col))
+    (setq identifier (substring identifier 1 (1- (length identifier))))
+    )
+
+  (let ((cmd (format "refs %s:%s:%d:%d" identifier (file-name-nondirectory 
file) line col))
+       (decl-loc nil)
+       (body-loc nil)
+       (search-type nil)
+       (min-distance (1- (expt 2 29)))
+       (result nil))
+
+    (with-current-buffer (gnat-inspect-session-send cmd t)
+      ;; 'gnatinspect refs' returns a list containing the declaration,
+      ;; the body, and all the references, in no particular order.
+      ;;
+      ;; We search the list, looking for the input location,
+      ;; declaration and body, then return the declaration or body as
+      ;; appropriate.
+      ;;
+      ;; the format of each line is name:file:line:column (type) 
scope=name:file:line:column
+      ;;                            1    2    3    4       5
+      ;;
+      ;; 'type' can be:
+      ;;   body
+      ;;   declaration
+      ;;   full declaration  (for a private type)
+      ;;   implicit reference
+      ;;   reference
+      ;;   static call
+      ;;
+      ;; 
Module_Type:/home/Projects/GDS/work_stephe_2/common/1553/gds-hardware-bus_1553-wrapper.ads:171:9
 (full declaration) 
scope=Wrapper:/home/Projects/GDS/work_stephe_2/common/1553/gds-hardware-bus_1553-wrapper.ads:49:31
+      ;;
+      ;; 
itc_assert:/home/Projects/GDS/work_stephe_2/common/itc/opsim/itc_dscovr_gdsi/Gds1553/src/Gds1553.cpp:830:9
 (reference) 
scope=Gds1553WriteSubaddress:/home/Projects/GDS/work_stephe_2/common/itc/opsim/itc_dscovr_gdsi/Gds1553/inc/Gds1553.hpp:173:24
+
+      (message "parsing result ...")
+
+      (goto-char (point-min))
+
+      (while (not (eobp))
+       (cond
+        ((looking-at gnat-inspect-ident-file-type-regexp)
+         ;; process line
+         (let* ((found-file (file-name-nondirectory (match-string 2)))
+                (found-line (string-to-number (match-string 3)))
+                (found-col  (string-to-number (match-string 4)))
+                (found-type (match-string 5))
+                (dist       (gnat-inspect-dist found-line line found-col col))
+                )
+
+           (when (string-equal found-type "declaration")
+             (setq decl-loc (list found-file found-line (1- found-col))))
+
+           (when (or
+                  (string-equal found-type "body")
+                  (string-equal found-type "full declaration"))
+             (setq body-loc (list found-file found-line (1- found-col))))
+
+           (when
+               ;; In general, we don't know where in the gnatinspect
+               ;; output the search item occurs, so we search for it.
+               ;;
+               ;; We use the same distance algorithm as gnatinspect
+               ;; to allow a fuzzy match on edited code.
+               (and (equal found-file file)
+                    (< dist min-distance))
+             (setq min-distance dist)
+             (setq search-type found-type))
+           ))
+
+        (t ;; ignore line
+         ;;
+         ;; This skips GPR_PROJECT_PATH and echoed command at start of buffer.
+         ;;
+         ;; It also skips warning lines. For example,
+         ;; gnatcoll-1.6w-20130902 can't handle the Auto_Text_IO
+         ;; language, because it doesn't use the gprconfig
+         ;; configuration project. That gives lines like:
+         ;;
+         ;; common_text_io.gpr:15:07: language unknown for 
"gds-hardware-bus_1553-time_tone.ads"
+         ;;
+         ;; There are probably other warnings that might be reported as well.
+         )
+        )
+       (forward-line 1)
+       )
+
+      (cond
+       ((null search-type)
+       (pop-to-buffer (current-buffer))
+       (error "gnatinspect did not return other item"))
+
+       ((and
+        (string-equal search-type "declaration")
+        body-loc)
+       (setq result body-loc))
+
+       (decl-loc
+       (setq result decl-loc))
+       )
+
+      (when (null result)
+       (pop-to-buffer (current-buffer))
+       (error "gnatinspect did not return other item"))
+
+      (message "parsing result ... done")
+      result)))
+
+(defun gnat-inspect-all (identifier file line col)
+  "For `ada-xref-all-function', using gnatinspect."
+  ;; This will in general return a list of references, so we use
+  ;; `compilation-start' to run gnatinspect, so the user can navigate
+  ;; to each result in turn via `next-error'.
+  (gnat-inspect-compilation identifier file line col "refs" 
'gnat-inspect-ident-file))
+
+(defun gnat-inspect-parents (identifier file line col)
+  "For `ada-xref-parent-function', using gnatinspect."
+  (gnat-inspect-compilation identifier file line col "parent_types" 
'gnat-inspect-ident-file))
+
+(defun gnat-inspect-overriding (identifier file line col)
+  "For `ada-xref-overriding-function', using gnatinspect."
+  (gnat-inspect-compilation identifier file line col "overridden_recursive" 
'gnat-inspect-ident-file))
+
+(defun gnat-inspect-overridden-1 (identifier file line col)
+  "For `ada-xref-overridden-function', using gnatinspect."
+  (unless (or (ada-prj-get 'gnat_inspect_gpr_file)
+                            (ada-prj-get 'gpr_file))
+    (error "no gnat project file defined."))
+
+  (when (eq ?\" (aref identifier 0))
+    ;; gnatinspect wants the quotes stripped
+    (setq col (+ 1 col))
+    (setq identifier (substring identifier 1 (1- (length identifier))))
+    )
+
+  (let ((cmd (format "overrides %s:%s:%d:%d" identifier 
(file-name-nondirectory file) line col))
+       result)
+    (with-current-buffer (gnat-inspect-session-send cmd t)
+
+      (goto-char (point-min))
+      (when (looking-at gnat-inspect-ident-file-regexp)
+       (setq result
+             (list
+              (match-string 2)
+              (string-to-number (match-string 3))
+              (string-to-number (match-string 4)))))
+
+      (when (null result)
+       (pop-to-buffer (current-buffer))
+       (error "gnatinspect did not return other item"))
+
+      (message "parsing result ... done")
+      result)))
+
+(defun gnat-inspect-overridden (other-window)
+  "Move to the overridden declaration of the identifier around point.
+If OTHER-WINDOW (set by interactive prefix) is non-nil, show the
+buffer in another window."
+  (interactive "P")
+
+  (let ((target
+        (gnat-inspect-overridden-1
+         (thing-at-point 'symbol)
+         (buffer-file-name)
+         (line-number-at-pos)
+         (save-excursion
+           (goto-char (car (bounds-of-thing-at-point 'symbol)))
+           (1+ (current-column)))
+         )))
+
+    (ada-goto-source (nth 0 target)
+                    (nth 1 target)
+                    (nth 2 target)
+                    other-window)
+    ))
+
+(defun gnat-inspect-goto-declaration (other-window)
+  "Move to the declaration or body of the identifier around point.
+If at the declaration, go to the body, and vice versa. If at a
+reference, goto the declaration.
+
+If OTHER-WINDOW (set by interactive prefix) is non-nil, show the
+buffer in another window."
+  (interactive "P")
+
+  (let ((target
+        (gnat-inspect-other
+         (thing-at-point 'symbol)
+         (buffer-file-name)
+         (line-number-at-pos)
+         (save-excursion
+           (goto-char (car (bounds-of-thing-at-point 'symbol)))
+           (1+ (current-column)))
+         )))
+
+    (ada-goto-source (nth 0 target)
+                    (nth 1 target)
+                    (nth 2 target)
+                    other-window)
+    ))
+
+(defvar gnat-inspect-map
+  (let ((map (make-sparse-keymap)))
+    ;; C-c <letter> are reserved for users
+
+    (define-key map "\C-c\C-d" 'gnat-inspect-goto-declaration)
+    ;; FIXME: (define-key map "\C-c\M-d" 'gnat-inspect-parents)
+    ;; FIXME: overriding
+    (define-key map "\C-c\C-r" 'gnat-inspect-all)
+    map
+  )  "Local keymap used for GNAT inspect minor mode.")
+
+;; FIXME: define menu
+
+(define-minor-mode gnat-inspect
+  "Minor mode for navigating sources using GNAT cross reference tool.
+Enable mode if ARG is positive"
+  :initial-value t
+  :lighter       " gnat-inspect"   ;; mode line
+
+  ;; just enable the menu and keymap
+  )
+
+;;;;; support for Ada mode
+
+(defun ada-gnat-inspect-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)
+
+  (add-hook 'ada-syntax-propertize-hook 'gnatprep-syntax-propertize)
+
+  ;; must be after indentation engine setup, because that resets the
+  ;; indent function list.
+  (add-hook 'ada-mode-hook 'ada-gnat-inspect-setup t)
+
+  (setq ada-xref-refresh-function    'gnat-inspect-refresh)
+  (setq ada-xref-all-function        'gnat-inspect-all)
+  (setq ada-xref-other-function      'gnat-inspect-other)
+  (setq ada-xref-parent-function     'gnat-inspect-parents)
+  (setq ada-xref-all-function        'gnat-inspect-all)
+  (setq ada-xref-overriding-function 'gnat-inspect-overriding)
+  (setq ada-xref-overridden-function 'gnat-inspect-overridden-1)
+
+  (add-to-list 'completion-ignored-extensions ".ali") ;; gnat library files, 
used for cross reference
+  )
+
+(defun ada-gnat-inspect-deselect-prj ()
+  (setq ada-file-name-from-ada-name nil)
+  (setq ada-ada-name-from-file-name nil)
+  (setq ada-make-package-body       nil)
+
+  (setq ada-syntax-propertize-hook (delq 'gnatprep-syntax-propertize 
ada-syntax-propertize-hook))
+  (setq ada-mode-hook (delq 'ada-gnat-inspect-setup ada-mode-hook))
+
+  (setq ada-xref-other-function      nil)
+  (setq ada-xref-parent-function     nil)
+  (setq ada-xref-all-function        nil)
+  (setq ada-xref-overriding-function nil)
+  (setq ada-xref-overridden-function nil)
+
+  (setq completion-ignored-extensions (delete ".ali" 
completion-ignored-extensions))
+  )
+
+(defun ada-gnat-inspect-setup ()
+  (when (boundp 'wisi-indent-calculate-functions)
+    (add-to-list 'wisi-indent-calculate-functions 'gnatprep-indent))
+  )
+
+(defun ada-gnat-inspect ()
+  "Set Ada mode global vars to use gnatinspect."
+  (add-to-list 'ada-prj-parser-alist       '("gpr" . gnat-parse-gpr))
+  (add-to-list 'ada-select-prj-xref-tool   '(gnat_inspect  . 
ada-gnat-inspect-select-prj))
+  (add-to-list 'ada-deselect-prj-xref-tool '(gnat_inspect  . 
ada-gnat-inspect-deselect-prj))
+
+  ;; no parse-*-xref
+
+  (font-lock-add-keywords 'ada-mode
+   ;; gnatprep preprocessor line
+   (list (list "^[ \t]*\\(#.*\n\\)"  '(1 font-lock-type-face t))))
+
+  (add-hook 'ada-gnat-fix-error-hook 'ada-gnat-fix-error)
+  )
+
+(provide 'gnat-inspect)
+
+(add-to-list 'compilation-error-regexp-alist-alist
+            (cons 'gnat-inspect-ident-file       
gnat-inspect-ident-file-regexp-alist))
+(add-to-list 'compilation-error-regexp-alist-alist
+            (cons 'gnat-inspect-ident-file-scope 
gnat-inspect-ident-file-scope-regexp-alist))
+
+(unless (and (boundp 'ada-xref-tool)
+            (default-value 'ada-xref-tool))
+  (setq ada-xref-tool 'gnat_inspect))
+
+(ada-gnat-inspect)
+
+;;; end of file
diff --git a/packages/ada-mode/gpr-grammar-wy.el 
b/packages/ada-mode/gpr-grammar-wy.el
new file mode 100755
index 0000000..4b1d45f
--- /dev/null
+++ b/packages/ada-mode/gpr-grammar-wy.el
@@ -0,0 +1,460 @@
+;;; gpr-grammar-wy.el --- Generated parser support file
+
+;; Copyright (C) 2013 Stephen Leake.  All Rights Reserved.
+
+;; 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 2, or (at
+;; your option) any later version.
+;;
+;; This software 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, Inc., 51 Franklin Street, Fifth Floor,
+;; Boston, MA 02110-1301, USA.
+
+;; PLEASE DO NOT MANUALLY EDIT THIS FILE!  It is automatically
+;; generated from the grammar file gpr-grammar.wy
+
+(require 'wisi)
+(require 'semantic/lex)
+(require 'wisi-compile)
+
+(defconst gpr-grammar-wy--keyword-table
+  (semantic-lex-make-keyword-table
+   '(
+    ("abstract" . ABSTRACT)
+    ("aggregate" . AGGREGATE)
+    ("case" . CASE)
+    ("configuration" . CONFIGURATION)
+    ("end" . END)
+    ("external" . EXTERNAL)
+    ("external_as_list" . EXTERNAL_AS_LIST)
+    ("for" . FOR)
+    ("is" . IS)
+    ("(" . LEFT_PAREN)
+    ("library" . LIBRARY)
+    ("null" . NULL)
+    ("others" . OTHERS)
+    ("package" . PACKAGE)
+    ("project" . PROJECT)
+    (")" . RIGHT_PAREN)
+    ("standard" . STANDARD)
+    ("type" . TYPE)
+    ("use" . USE)
+    ("when" . WHEN)
+    ("with" . WITH)
+    )
+   nil)
+  "Table of language keywords.")
+
+(defconst gpr-grammar-wy--token-table
+  (semantic-lex-make-type-table
+   '(
+     ("punctuation"
+      (AMPERSAND . "&")
+      (COLON . ":")
+      (COLON_EQUALS . ":=")
+      (COMMA . ",")
+      (DOT . ".")
+      (EQUAL_GREATER . "=>")
+      (QUOTE . "'")
+      (SEMICOLON . ";")
+      (VERTICAL_BAR . "|")
+     )
+     ("symbol"
+      (IDENTIFIER)
+     )
+     ("string-double"
+      (STRING_LITERAL)
+     )
+    )
+   nil)
+  "Table of language tokens.")
+
+(defconst gpr-grammar-wy--parse-table
+   (wisi-compile-grammar
+   '((AMPERSAND COLON COLON_EQUALS COMMA DOT EQUAL_GREATER QUOTE SEMICOLON 
VERTICAL_BAR IDENTIFIER STRING_LITERAL ABSTRACT AGGREGATE CASE CONFIGURATION 
END EXTERNAL EXTERNAL_AS_LIST FOR IS LEFT_PAREN LIBRARY NULL OTHERS PACKAGE 
PROJECT RIGHT_PAREN STANDARD TYPE USE WHEN WITH )
+     ((attribute_declaration
+       ((FOR IDENTIFIER USE expression SEMICOLON )
+        (progn
+        (wisi-statement-action 1 'statement-start 3 'statement-other 5 
'statement-end)
+        (wisi-containing-action 3 4)))
+       ((FOR IDENTIFIER LEFT_PAREN STRING_LITERAL RIGHT_PAREN USE expression 
SEMICOLON )
+        (progn
+        (wisi-statement-action 1 'statement-start 3 'open-paren 5 'close-paren 
6 'statement-other 8 'statement-end)
+        (wisi-containing-action 6 7))))
+      (attribute_prefix
+       ((PROJECT ))
+       ((name )))
+      (attribute_reference
+       ((attribute_prefix QUOTE IDENTIFIER ))
+       ((attribute_prefix QUOTE IDENTIFIER LEFT_PAREN STRING_LITERAL 
RIGHT_PAREN )
+        (wisi-statement-action 4 'open-paren 6 'close-paren)))
+      (case_statement
+       ((CASE name IS case_items END CASE SEMICOLON )
+        (progn
+        (wisi-statement-action 1 'statement-start 3 'block-start 5 'block-end 
7 'statement-end)
+        (wisi-containing-action 3 4))))
+      (case_item
+       ((WHEN discrete_choice_list EQUAL_GREATER declarative_items )
+        (progn
+        (wisi-statement-action 1 'block-middle 3 'block-start)
+        (wisi-containing-action 3 4))))
+      (case_items
+       ((case_item ))
+       ((case_items case_item )))
+      (compilation_unit
+       ((context_clause_opt project_qualifier_opt project_declaration )))
+      (context_clause
+       ((with_clause ))
+       ((context_clause with_clause )))
+      (context_clause_opt
+       (())
+       ((context_clause )))
+      (declarative_item
+       ((simple_declarative_item ))
+       ((typed_string_declaration ))
+       ((package_declaration )))
+      (declarative_items
+       ((declarative_item ))
+       ((declarative_items declarative_item )))
+      (discrete_choice
+       ((STRING_LITERAL ))
+       ((OTHERS )))
+      (discrete_choice_list
+       ((discrete_choice ))
+       ((discrete_choice_list VERTICAL_BAR discrete_choice )))
+      (expression
+       ((term ))
+       ((expression AMPERSAND term )))
+      (external_value
+       ((EXTERNAL LEFT_PAREN string_list RIGHT_PAREN )
+        (wisi-statement-action 2 'open-paren 4 'close-paren))
+       ((EXTERNAL_AS_LIST LEFT_PAREN string_list RIGHT_PAREN )
+        (wisi-statement-action 2 'open-paren 4 'close-paren)))
+      (name
+       ((IDENTIFIER ))
+       ((name DOT IDENTIFIER )))
+      (project_declaration
+       ((simple_project_declaration )))
+      (package_declaration
+       ((package_spec )))
+      (package_spec
+       ((PACKAGE IDENTIFIER IS simple_declarative_items END IDENTIFIER 
SEMICOLON )
+        (progn
+        (wisi-statement-action 1 'statement-start 3 'block-start 5 'block-end 
7 'statement-end)
+        (wisi-containing-action 3 4))))
+      (project_qualifier_opt
+       (())
+       ((ABSTRACT ))
+       ((STANDARD ))
+       ((AGGREGATE ))
+       ((AGGREGATE LIBRARY ))
+       ((LIBRARY ))
+       ((CONFIGURATION )))
+      (simple_declarative_item
+       ((IDENTIFIER COLON_EQUALS expression SEMICOLON )
+        (progn
+        (wisi-statement-action 1 'statement-start 4 'statement-end)
+        (wisi-containing-action 1 3)))
+       ((IDENTIFIER COLON IDENTIFIER COLON_EQUALS expression SEMICOLON )
+        (progn
+        (wisi-statement-action 1 'statement-start 6 'statement-end)
+        (wisi-containing-action 1 5)))
+       ((attribute_declaration ))
+       ((case_statement ))
+       ((NULL SEMICOLON )
+        (wisi-statement-action 1 'statement-start 2 'statement-end)))
+      (simple_declarative_items
+       ((simple_declarative_item ))
+       ((simple_declarative_items simple_declarative_item )))
+      (simple_project_declaration
+       ((PROJECT IDENTIFIER IS declarative_items END IDENTIFIER SEMICOLON )
+        (progn
+        (wisi-statement-action 1 'statement-start 3 'block-start 5 'block-end 
7 'statement-end)
+        (wisi-containing-action 3 4))))
+      (string_expression
+       ((string_primary ))
+       ((string_expression AMPERSAND string_primary )))
+      (string_primary
+       ((STRING_LITERAL ))
+       ((name ))
+       ((external_value ))
+       ((attribute_reference )))
+      (string_list
+       ((string_expression ))
+       ((string_list COMMA string_expression )))
+      (term
+       ((string_expression ))
+       ((LEFT_PAREN RIGHT_PAREN ))
+       ((LEFT_PAREN string_list RIGHT_PAREN )
+        (wisi-statement-action
+        1 'open-paren
+        3 'close-paren)))
+      (typed_string_declaration
+       ((TYPE IDENTIFIER IS LEFT_PAREN string_list RIGHT_PAREN SEMICOLON )
+        (wisi-statement-action 1 'statement-start 4 'open-paren 6 'close-paren 
7 'statement-end)))
+      (with_clause
+       ((WITH string_list SEMICOLON ))))
+     [((default . error) (ABSTRACT . (context_clause_opt . 0)) (AGGREGATE . 
(context_clause_opt . 0)) (CONFIGURATION . (context_clause_opt . 0)) (LIBRARY . 
(context_clause_opt . 0)) (STANDARD . (context_clause_opt . 0)) (PROJECT . 
(context_clause_opt . 0)) (WITH .  7))
+      ((default . error) (PROJECT . (project_qualifier_opt . 1)))
+      ((default . error) (LIBRARY .  29) (PROJECT . (project_qualifier_opt . 
3)))
+      ((default . error) (PROJECT . (project_qualifier_opt . 6)))
+      ((default . error) (PROJECT . (project_qualifier_opt . 5)))
+      ((default . error) (IDENTIFIER .  28))
+      ((default . error) (PROJECT . (project_qualifier_opt . 2)))
+      ((default . error) (STRING_LITERAL .  17) (EXTERNAL .  18) 
(EXTERNAL_AS_LIST .  19) (IDENTIFIER .  16) (PROJECT .  20))
+      ((default . error) ($EOI .  15))
+      ((default . error) (ABSTRACT . (context_clause_opt . 1)) (AGGREGATE . 
(context_clause_opt . 1)) (CONFIGURATION . (context_clause_opt . 1)) (LIBRARY . 
(context_clause_opt . 1)) (STANDARD . (context_clause_opt . 1)) (PROJECT . 
(context_clause_opt . 1)) (WITH .  7))
+      ((default . error) (PROJECT . (project_qualifier_opt . 0)) (ABSTRACT .  
1) (STANDARD .  6) (AGGREGATE .  2) (LIBRARY .  4) (CONFIGURATION .  3))
+      ((default . error) ($EOI . (project_declaration . 0)))
+      ((default . error) (PROJECT . (context_clause . 0)) (STANDARD . 
(context_clause . 0)) (LIBRARY . (context_clause . 0)) (CONFIGURATION . 
(context_clause . 0)) (AGGREGATE . (context_clause . 0)) (ABSTRACT . 
(context_clause . 0)) (WITH . (context_clause . 0)))
+      ((default . error) (PROJECT .  5))
+      ((default . error) (WITH . (context_clause . 1)) (ABSTRACT . 
(context_clause . 1)) (AGGREGATE . (context_clause . 1)) (CONFIGURATION . 
(context_clause . 1)) (LIBRARY . (context_clause . 1)) (STANDARD . 
(context_clause . 1)) (PROJECT . (context_clause . 1)))
+      ((default . error) ($EOI . accept) (WITH . accept) (WHEN . accept) (USE 
. accept) (TYPE . accept) (STANDARD . accept) (RIGHT_PAREN . accept) (PROJECT . 
accept) (PACKAGE . accept) (OTHERS . accept) (NULL . accept) (LIBRARY . accept) 
(LEFT_PAREN . accept) (IS . accept) (FOR . accept) (EXTERNAL_AS_LIST . accept) 
(EXTERNAL . accept) (END . accept) (CONFIGURATION . accept) (CASE . accept) 
(AGGREGATE . accept) (ABSTRACT . accept) (STRING_LITERAL . accept) (IDENTIFIER 
. accept) (VERTICAL_BAR . accept) (SEMICOLON . accept) (QUOTE . accept) 
(EQUAL_GREATER . accept) (DOT . accept) (COMMA . accept) (COLON_EQUALS . 
accept) (COLON . accept) (AMPERSAND . accept))
+      ((default . error) (IS . (name . 0)) (COMMA . (name . 0)) (RIGHT_PAREN . 
(name . 0)) (SEMICOLON . (name . 0)) (AMPERSAND . (name . 0)) (DOT . (name . 
0)) (QUOTE . (name . 0)))
+      ((default . error) (RIGHT_PAREN . (string_primary . 0)) (COMMA . 
(string_primary . 0)) (AMPERSAND . (string_primary . 0)) (SEMICOLON . 
(string_primary . 0)))
+      ((default . error) (LEFT_PAREN .  37))
+      ((default . error) (LEFT_PAREN .  36))
+      ((default . error) (QUOTE . (attribute_prefix . 0)))
+      ((default . error) (QUOTE .  35))
+      ((default . error) (RIGHT_PAREN . (string_primary . 3)) (COMMA . 
(string_primary . 3)) (AMPERSAND . (string_primary . 3)) (SEMICOLON . 
(string_primary . 3)))
+      ((default . error) (RIGHT_PAREN . (string_primary . 2)) (COMMA . 
(string_primary . 2)) (AMPERSAND . (string_primary . 2)) (SEMICOLON . 
(string_primary . 2)))
+      ((default . error) (RIGHT_PAREN . (string_primary . 1)) (COMMA . 
(string_primary . 1)) (AMPERSAND . (string_primary . 1)) (SEMICOLON . 
(string_primary . 1)) (DOT .  34) (QUOTE . (attribute_prefix . 1)))
+      ((default . error) (SEMICOLON . (string_list . 0)) (RIGHT_PAREN . 
(string_list . 0)) (COMMA . (string_list . 0)) (AMPERSAND .  33))
+      ((default . error) (COMMA . (string_expression . 0)) (RIGHT_PAREN . 
(string_expression . 0)) (SEMICOLON . (string_expression . 0)) (AMPERSAND . 
(string_expression . 0)))
+      ((default . error) (COMMA .  31) (SEMICOLON .  32))
+      ((default . error) (IS .  30))
+      ((default . error) (PROJECT . (project_qualifier_opt . 4)))
+      ((default . error) (TYPE .  50) (IDENTIFIER .  45) (NULL .  48) (CASE .  
46) (FOR .  47) (PACKAGE .  49))
+      ((default . error) (STRING_LITERAL .  17) (EXTERNAL .  18) 
(EXTERNAL_AS_LIST .  19) (IDENTIFIER .  16) (PROJECT .  20))
+      ((default . error) (WITH . (with_clause . 0)) (ABSTRACT . (with_clause . 
0)) (AGGREGATE . (with_clause . 0)) (CONFIGURATION . (with_clause . 0)) 
(LIBRARY . (with_clause . 0)) (STANDARD . (with_clause . 0)) (PROJECT . 
(with_clause . 0)))
+      ((default . error) (STRING_LITERAL .  17) (EXTERNAL .  18) 
(EXTERNAL_AS_LIST .  19) (IDENTIFIER .  16) (PROJECT .  20))
+      ((default . error) (IDENTIFIER .  42))
+      ((default . error) (IDENTIFIER .  41))
+      ((default . error) (STRING_LITERAL .  17) (EXTERNAL .  18) 
(EXTERNAL_AS_LIST .  19) (IDENTIFIER .  16) (PROJECT .  20))
+      ((default . error) (STRING_LITERAL .  17) (EXTERNAL .  18) 
(EXTERNAL_AS_LIST .  19) (IDENTIFIER .  16) (PROJECT .  20))
+      ((default . error) ($EOI . (compilation_unit . 0)))
+      ((default . error) (COMMA .  31) (RIGHT_PAREN .  70))
+      ((default . error) (COMMA .  31) (RIGHT_PAREN .  69))
+      ((default . error) (LEFT_PAREN .  68) (COMMA . (attribute_reference . 
0)) (RIGHT_PAREN . (attribute_reference . 0)) (SEMICOLON . (attribute_reference 
. 0)) (AMPERSAND . (attribute_reference . 0)))
+      ((default . error) (IS . (name . 1)) (COMMA . (name . 1)) (RIGHT_PAREN . 
(name . 1)) (SEMICOLON . (name . 1)) (AMPERSAND . (name . 1)) (DOT . (name . 
1)) (QUOTE . (name . 1)))
+      ((default . error) (SEMICOLON . (string_expression . 1)) (COMMA . 
(string_expression . 1)) (RIGHT_PAREN . (string_expression . 1)) (AMPERSAND . 
(string_expression . 1)))
+      ((default . error) (AMPERSAND .  33) (RIGHT_PAREN . (string_list . 1)) 
(SEMICOLON . (string_list . 1)) (COMMA . (string_list . 1)))
+      ((default . error) (COLON .  66) (COLON_EQUALS .  67))
+      ((default . error) (IDENTIFIER .  16))
+      ((default . error) (IDENTIFIER .  64))
+      ((default . error) (SEMICOLON .  63))
+      ((default . error) (IDENTIFIER .  62))
+      ((default . error) (IDENTIFIER .  61))
+      ((default . error) (WHEN . (simple_declarative_item . 2)) (END . 
(simple_declarative_item . 2)) (IDENTIFIER . (simple_declarative_item . 2)) 
(CASE . (simple_declarative_item . 2)) (FOR . (simple_declarative_item . 2)) 
(NULL . (simple_declarative_item . 2)) (PACKAGE . (simple_declarative_item . 
2)) (TYPE . (simple_declarative_item . 2)))
+      ((default . error) (WHEN . (simple_declarative_item . 3)) (END . 
(simple_declarative_item . 3)) (IDENTIFIER . (simple_declarative_item . 3)) 
(CASE . (simple_declarative_item . 3)) (FOR . (simple_declarative_item . 3)) 
(NULL . (simple_declarative_item . 3)) (PACKAGE . (simple_declarative_item . 
3)) (TYPE . (simple_declarative_item . 3)))
+      ((default . error) (WHEN . (declarative_items . 0)) (END . 
(declarative_items . 0)) (IDENTIFIER . (declarative_items . 0)) (CASE . 
(declarative_items . 0)) (FOR . (declarative_items . 0)) (NULL . 
(declarative_items . 0)) (PACKAGE . (declarative_items . 0)) (TYPE . 
(declarative_items . 0)))
+      ((default . error) (END .  59) (TYPE .  50) (IDENTIFIER .  45) (NULL .  
48) (CASE .  46) (FOR .  47) (PACKAGE .  49))
+      ((default . error) (WHEN . (declarative_item . 2)) (END . 
(declarative_item . 2)) (TYPE . (declarative_item . 2)) (PACKAGE . 
(declarative_item . 2)) (NULL . (declarative_item . 2)) (FOR . 
(declarative_item . 2)) (CASE . (declarative_item . 2)) (IDENTIFIER . 
(declarative_item . 2)))
+      ((default . error) (WHEN . (package_declaration . 0)) (END . 
(package_declaration . 0)) (IDENTIFIER . (package_declaration . 0)) (CASE . 
(package_declaration . 0)) (FOR . (package_declaration . 0)) (NULL . 
(package_declaration . 0)) (PACKAGE . (package_declaration . 0)) (TYPE . 
(package_declaration . 0)))
+      ((default . error) (WHEN . (declarative_item . 0)) (END . 
(declarative_item . 0)) (TYPE . (declarative_item . 0)) (PACKAGE . 
(declarative_item . 0)) (NULL . (declarative_item . 0)) (FOR . 
(declarative_item . 0)) (CASE . (declarative_item . 0)) (IDENTIFIER . 
(declarative_item . 0)))
+      ((default . error) (WHEN . (declarative_item . 1)) (END . 
(declarative_item . 1)) (TYPE . (declarative_item . 1)) (PACKAGE . 
(declarative_item . 1)) (NULL . (declarative_item . 1)) (FOR . 
(declarative_item . 1)) (CASE . (declarative_item . 1)) (IDENTIFIER . 
(declarative_item . 1)))
+      ((default . error) (IDENTIFIER .  82))
+      ((default . error) (WHEN . (declarative_items . 1)) (TYPE . 
(declarative_items . 1)) (PACKAGE . (declarative_items . 1)) (NULL . 
(declarative_items . 1)) (FOR . (declarative_items . 1)) (CASE . 
(declarative_items . 1)) (IDENTIFIER . (declarative_items . 1)) (END . 
(declarative_items . 1)))
+      ((default . error) (IS .  81))
+      ((default . error) (IS .  80))
+      ((default . error) (WHEN . (simple_declarative_item . 4)) (TYPE . 
(simple_declarative_item . 4)) (PACKAGE . (simple_declarative_item . 4)) (NULL 
. (simple_declarative_item . 4)) (FOR . (simple_declarative_item . 4)) (CASE . 
(simple_declarative_item . 4)) (IDENTIFIER . (simple_declarative_item . 4)) 
(END . (simple_declarative_item . 4)))
+      ((default . error) (USE .  79) (LEFT_PAREN .  78))
+      ((default . error) (DOT .  34) (IS .  77))
+      ((default . error) (IDENTIFIER .  76))
+      ((default . error) (LEFT_PAREN .  72) (STRING_LITERAL .  17) (EXTERNAL . 
 18) (EXTERNAL_AS_LIST .  19) (IDENTIFIER .  16) (PROJECT .  20))
+      ((default . error) (STRING_LITERAL .  71))
+      ((default . error) (AMPERSAND . (external_value . 1)) (SEMICOLON . 
(external_value . 1)) (RIGHT_PAREN . (external_value . 1)) (COMMA . 
(external_value . 1)))
+      ((default . error) (AMPERSAND . (external_value . 0)) (SEMICOLON . 
(external_value . 0)) (RIGHT_PAREN . (external_value . 0)) (COMMA . 
(external_value . 0)))
+      ((default . error) (RIGHT_PAREN .  97))
+      ((default . error) (RIGHT_PAREN .  95) (STRING_LITERAL .  17) (EXTERNAL 
.  18) (EXTERNAL_AS_LIST .  19) (IDENTIFIER .  16) (PROJECT .  20))
+      ((default . error) (AMPERSAND .  93) (SEMICOLON .  94))
+      ((default . error) (SEMICOLON . (term . 0)) (AMPERSAND . ((term . 0)  
33)))
+      ((default . error) (SEMICOLON . (expression . 0)) (AMPERSAND . 
(expression . 0)))
+      ((default . error) (COLON_EQUALS .  92))
+      ((default . error) (WHEN .  89))
+      ((default . error) (STRING_LITERAL .  88))
+      ((default . error) (LEFT_PAREN .  72) (STRING_LITERAL .  17) (EXTERNAL . 
 18) (EXTERNAL_AS_LIST .  19) (IDENTIFIER .  16) (PROJECT .  20))
+      ((default . error) (IDENTIFIER .  45) (NULL .  48) (CASE .  46) (FOR .  
47))
+      ((default . error) (LEFT_PAREN .  84))
+      ((default . error) (SEMICOLON .  83))
+      ((default . error) ($EOI . (simple_project_declaration . 0)))
+      ((default . error) (STRING_LITERAL .  17) (EXTERNAL .  18) 
(EXTERNAL_AS_LIST .  19) (IDENTIFIER .  16) (PROJECT .  20))
+      ((default . error) (END . (simple_declarative_items . 0)) (IDENTIFIER . 
(simple_declarative_items . 0)) (CASE . (simple_declarative_items . 0)) (FOR . 
(simple_declarative_items . 0)) (NULL . (simple_declarative_items . 0)))
+      ((default . error) (END .  109) (IDENTIFIER .  45) (NULL .  48) (CASE .  
46) (FOR .  47))
+      ((default . error) (AMPERSAND .  93) (SEMICOLON .  108))
+      ((default . error) (RIGHT_PAREN .  107))
+      ((default . error) (STRING_LITERAL .  103) (OTHERS .  104))
+      ((default . error) (END . (case_items . 0)) (WHEN . (case_items . 0)))
+      ((default . error) (END .  101) (WHEN .  89))
+      ((default . error) (LEFT_PAREN .  72) (STRING_LITERAL .  17) (EXTERNAL . 
 18) (EXTERNAL_AS_LIST .  19) (IDENTIFIER .  16) (PROJECT .  20))
+      ((default . error) (LEFT_PAREN .  72) (STRING_LITERAL .  17) (EXTERNAL . 
 18) (EXTERNAL_AS_LIST .  19) (IDENTIFIER .  16) (PROJECT .  20))
+      ((default . error) (WHEN . (simple_declarative_item . 0)) (TYPE . 
(simple_declarative_item . 0)) (PACKAGE . (simple_declarative_item . 0)) (NULL 
. (simple_declarative_item . 0)) (FOR . (simple_declarative_item . 0)) (CASE . 
(simple_declarative_item . 0)) (IDENTIFIER . (simple_declarative_item . 0)) 
(END . (simple_declarative_item . 0)))
+      ((default . error) (SEMICOLON . (term . 1)) (AMPERSAND . (term . 1)))
+      ((default . error) (COMMA .  31) (RIGHT_PAREN .  98))
+      ((default . error) (AMPERSAND . (attribute_reference . 1)) (SEMICOLON . 
(attribute_reference . 1)) (RIGHT_PAREN . (attribute_reference . 1)) (COMMA . 
(attribute_reference . 1)))
+      ((default . error) (AMPERSAND . (term . 2)) (SEMICOLON . (term . 2)))
+      ((default . error) (SEMICOLON . (expression . 1)) (AMPERSAND . 
(expression . 1)))
+      ((default . error) (AMPERSAND .  93) (SEMICOLON .  118))
+      ((default . error) (CASE .  117))
+      ((default . error) (WHEN . (case_items . 1)) (END . (case_items . 1)))
+      ((default . error) (VERTICAL_BAR . (discrete_choice . 0)) (EQUAL_GREATER 
. (discrete_choice . 0)))
+      ((default . error) (VERTICAL_BAR . (discrete_choice . 1)) (EQUAL_GREATER 
. (discrete_choice . 1)))
+      ((default . error) (EQUAL_GREATER . (discrete_choice_list . 0)) 
(VERTICAL_BAR . (discrete_choice_list . 0)))
+      ((default . error) (VERTICAL_BAR .  116) (EQUAL_GREATER .  115))
+      ((default . error) (USE .  114))
+      ((default . error) (WHEN . (attribute_declaration . 0)) (END . 
(attribute_declaration . 0)) (TYPE . (attribute_declaration . 0)) (PACKAGE . 
(attribute_declaration . 0)) (NULL . (attribute_declaration . 0)) (FOR . 
(attribute_declaration . 0)) (CASE . (attribute_declaration . 0)) (IDENTIFIER . 
(attribute_declaration . 0)))
+      ((default . error) (IDENTIFIER .  113))
+      ((default . error) (NULL . (simple_declarative_items . 1)) (FOR . 
(simple_declarative_items . 1)) (CASE . (simple_declarative_items . 1)) 
(IDENTIFIER . (simple_declarative_items . 1)) (END . (simple_declarative_items 
. 1)))
+      ((default . error) (COMMA .  31) (RIGHT_PAREN .  112))
+      ((default . error) (SEMICOLON .  124))
+      ((default . error) (SEMICOLON .  123))
+      ((default . error) (LEFT_PAREN .  72) (STRING_LITERAL .  17) (EXTERNAL . 
 18) (EXTERNAL_AS_LIST .  19) (IDENTIFIER .  16) (PROJECT .  20))
+      ((default . error) (TYPE .  50) (IDENTIFIER .  45) (NULL .  48) (CASE .  
46) (FOR .  47) (PACKAGE .  49))
+      ((default . error) (STRING_LITERAL .  103) (OTHERS .  104))
+      ((default . error) (SEMICOLON .  119))
+      ((default . error) (WHEN . (simple_declarative_item . 1)) (TYPE . 
(simple_declarative_item . 1)) (PACKAGE . (simple_declarative_item . 1)) (NULL 
. (simple_declarative_item . 1)) (FOR . (simple_declarative_item . 1)) (CASE . 
(simple_declarative_item . 1)) (IDENTIFIER . (simple_declarative_item . 1)) 
(END . (simple_declarative_item . 1)))
+      ((default . error) (WHEN . (case_statement . 0)) (END . (case_statement 
. 0)) (TYPE . (case_statement . 0)) (PACKAGE . (case_statement . 0)) (NULL . 
(case_statement . 0)) (FOR . (case_statement . 0)) (CASE . (case_statement . 
0)) (IDENTIFIER . (case_statement . 0)))
+      ((default . error) (EQUAL_GREATER . (discrete_choice_list . 1)) 
(VERTICAL_BAR . (discrete_choice_list . 1)))
+      ((default . error) (END . (case_item . 0)) (WHEN . (case_item . 0)) 
(TYPE .  50) (IDENTIFIER .  45) (NULL .  48) (CASE .  46) (FOR .  47) (PACKAGE 
.  49))
+      ((default . error) (AMPERSAND .  93) (SEMICOLON .  125))
+      ((default . error) (WHEN . (package_spec . 0)) (END . (package_spec . 
0)) (TYPE . (package_spec . 0)) (PACKAGE . (package_spec . 0)) (NULL . 
(package_spec . 0)) (FOR . (package_spec . 0)) (CASE . (package_spec . 0)) 
(IDENTIFIER . (package_spec . 0)))
+      ((default . error) (WHEN . (typed_string_declaration . 0)) (END . 
(typed_string_declaration . 0)) (IDENTIFIER . (typed_string_declaration . 0)) 
(CASE . (typed_string_declaration . 0)) (FOR . (typed_string_declaration . 0)) 
(NULL . (typed_string_declaration . 0)) (PACKAGE . (typed_string_declaration . 
0)) (TYPE . (typed_string_declaration . 0)))
+      ((default . error) (WHEN . (attribute_declaration . 1)) (IDENTIFIER . 
(attribute_declaration . 1)) (CASE . (attribute_declaration . 1)) (FOR . 
(attribute_declaration . 1)) (NULL . (attribute_declaration . 1)) (PACKAGE . 
(attribute_declaration . 1)) (TYPE . (attribute_declaration . 1)) (END . 
(attribute_declaration . 1)))]
+     [((compilation_unit . 8)(context_clause . 9)(context_clause_opt . 
10)(simple_project_declaration . 11)(with_clause . 12))
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      ((attribute_prefix . 21)(attribute_reference . 22)(external_value . 
23)(name . 24)(string_expression . 25)(string_primary . 26)(string_list . 27))
+      nil
+      ((with_clause . 14))
+      ((project_qualifier_opt . 13))
+      nil
+      nil
+      ((project_declaration . 38)(simple_project_declaration . 11))
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      ((attribute_declaration . 51)(case_statement . 52)(declarative_item . 
53)(declarative_items . 54)(package_declaration . 55)(package_spec . 
56)(simple_declarative_item . 57)(typed_string_declaration . 58))
+      ((attribute_prefix . 21)(attribute_reference . 22)(external_value . 
23)(name . 24)(string_expression . 44)(string_primary . 26))
+      nil
+      ((attribute_prefix . 21)(attribute_reference . 22)(external_value . 
23)(name . 24)(string_primary . 43))
+      nil
+      nil
+      ((attribute_prefix . 21)(attribute_reference . 22)(external_value . 
23)(name . 24)(string_expression . 25)(string_primary . 26)(string_list . 40))
+      ((attribute_prefix . 21)(attribute_reference . 22)(external_value . 
23)(name . 24)(string_expression . 25)(string_primary . 26)(string_list . 39))
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      ((name . 65))
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      ((attribute_declaration . 51)(case_statement . 52)(declarative_item . 
60)(package_declaration . 55)(package_spec . 56)(simple_declarative_item . 
57)(typed_string_declaration . 58))
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      ((attribute_prefix . 21)(attribute_reference . 22)(expression . 
73)(external_value . 23)(name . 24)(string_expression . 74)(string_primary . 
26)(term . 75))
+      nil
+      nil
+      nil
+      nil
+      ((attribute_prefix . 21)(attribute_reference . 22)(external_value . 
23)(name . 24)(string_expression . 25)(string_primary . 26)(string_list . 96))
+      nil
+      nil
+      nil
+      nil
+      ((case_item . 90)(case_items . 91))
+      nil
+      ((attribute_prefix . 21)(attribute_reference . 22)(expression . 
87)(external_value . 23)(name . 24)(string_expression . 74)(string_primary . 
26)(term . 75))
+      ((attribute_declaration . 51)(case_statement . 
52)(simple_declarative_item . 85)(simple_declarative_items . 86))
+      nil
+      nil
+      nil
+      ((attribute_prefix . 21)(attribute_reference . 22)(external_value . 
23)(name . 24)(string_expression . 25)(string_primary . 26)(string_list . 111))
+      nil
+      ((attribute_declaration . 51)(case_statement . 
52)(simple_declarative_item . 110))
+      nil
+      nil
+      ((discrete_choice . 105)(discrete_choice_list . 106))
+      nil
+      ((case_item . 102))
+      ((attribute_prefix . 21)(attribute_reference . 22)(expression . 
100)(external_value . 23)(name . 24)(string_expression . 74)(string_primary . 
26)(term . 75))
+      ((attribute_prefix . 21)(attribute_reference . 22)(external_value . 
23)(name . 24)(string_expression . 74)(string_primary . 26)(term . 99))
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      nil
+      ((attribute_prefix . 21)(attribute_reference . 22)(expression . 
122)(external_value . 23)(name . 24)(string_expression . 74)(string_primary . 
26)(term . 75))
+      ((attribute_declaration . 51)(case_statement . 52)(declarative_item . 
53)(declarative_items . 121)(package_declaration . 55)(package_spec . 
56)(simple_declarative_item . 57)(typed_string_declaration . 58))
+      ((discrete_choice . 120))
+      nil
+      nil
+      nil
+      nil
+      ((attribute_declaration . 51)(case_statement . 52)(declarative_item . 
60)(package_declaration . 55)(package_spec . 56)(simple_declarative_item . 
57)(typed_string_declaration . 58))
+      nil
+      nil
+      nil
+      nil]))
+  "Parser table.")
+
+(provide 'gpr-grammar-wy)
+
+;; end of file
diff --git a/packages/ada-mode/gpr-mode.el b/packages/ada-mode/gpr-mode.el
new file mode 100755
index 0000000..81aa760
--- /dev/null
+++ b/packages/ada-mode/gpr-mode.el
@@ -0,0 +1,278 @@
+;;; gpr-mode --- major-mode for editing GNAT project files
+
+;; Copyright (C) 2007, 2008, 2012, 2013  Stephen Leake
+;; Copyright (C) 2004  Rolf Ebert
+
+;; Author: Stephen Leake <address@hidden>
+;; Maintainer: Stephen Leake <address@hidden>
+;; Version: 5.0
+
+;; This file is part of GNU Emacs.
+
+;; gpr-mode 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.
+
+;; gpr-mode 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, Inc., 59 Temple Place - Suite 330,
+;; Boston, MA 02111-1307, USA.
+;;
+;;; Commentary:
+;;
+;;; History:
+;;
+;; The first gpr-mode was written by Rolf Ebert
+;; <address@hidden> in 2004.
+;;
+;; Stephen Leake <address@hidden> rewrote it in 2013 to
+;; use the wisi indentation engine.
+;;
+;;;;; Code:
+
+;; we reuse several ada-mode functions
+(require 'ada-mode)
+
+(defun gpr-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))
+
+    (align-current)
+    ))
+
+(defvar gpr-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-indent-newline-indent)
+    (define-key map "\C-c`"    'ada-show-secondary-error)
+    (define-key map "\C-c\C-a" 'gpr-align)
+    (define-key map "\C-c\C-c" 'compile)
+    (define-key map "\C-c\C-e" 'gpr-expand)
+    (define-key map "\C-c\C-f" 'gpr-show-parse-error)
+    (define-key map "\C-c\C-i" 'gpr-indent-statement)
+            ;; FIXME (later): implement?
+    ;; (define-key map "\C-c\C-n" 'ada-next-statement-keyword)
+    ;; (define-key map "\C-c\C-p" 'ada-prev-statement-keyword)
+    (define-key map "\C-c\C-S-p" 'gpr-set-as-project)
+    (define-key map "\C-c\C-t" 'ada-case-read-all-exceptions)
+    (define-key map "\C-c\C-w" 'ada-case-adjust-at-point)
+    (define-key map "\C-c\C-y" 'ada-case-create-exception)
+    (define-key map "\C-c\C-\M-y" (lambda () (ada-case-create-exception nil 
nil t)))
+    map
+  )  "Local keymap used for GPR mode.")
+
+(defvar gpr-mode-menu (make-sparse-keymap "gpr"))
+(easy-menu-define gpr-mode-menu gpr-mode-map "Menu keymap for gpr mode"
+  '("gpr"
+    ("Help"
+     ["gpr Mode"              (info "gpr-mode") t]
+     ["GNAT Reference Manual" (info "gnat_rm") t]
+     ["GNAT User Guide"       (info "gnat_ugn") t]
+     ["Key bindings"          describe-bindings t]
+     )
+
+    ["Customize"     (customize-group 'ada)];; we reuse the Ada indentation 
options
+    ["------"        nil nil]
+    ["Find and select project ..." ada-build-prompt-select-prj-file t]
+    ["Select project ..."          ada-prj-select                   t]
+    ["Set as current project"      gpr-set-as-project               t]
+    ["Show current project"        ada-prj-show                     t]
+    ["Next compilation error"      next-error                       t]
+    ["Show secondary error"        ada-show-secondary-error         t]
+    ["Show last parse error"       gpr-show-parse-error             t]
+    ("Edit"
+     ["Indent Line"                 indent-for-tab-command         t]
+     ["Indent Lines in Selection"   indent-region                  t]
+     ["Indent Lines in File"        (indent-region (point-min) (point-max))  t]
+     ["Expand skeleton"             gpr-expand                     t] ;; 
FIXME: only if skeleton
+     ["Align"                       gpr-align                      t]
+     ["Comment Selection"           comment-region                 t]
+     ["Uncomment Selection"         (lambda () (comment-region t)) t]
+     ["Fill Comment Paragraph"      fill-paragraph                 t]
+
+     ["Fill Comment Paragraph Justify" ada-fill-comment-paragraph-justify t]
+     ["Fill Comment Paragraph Postfix" ada-fill-comment-paragraph-postfix t]
+     )
+    ))
+
+(defvar gpr-show-parse-error nil
+  ;; Supplied by indentation engine parser
+  "Function to show last error reported by indentation parser."
+  )
+
+(defun gpr-show-parse-error ()
+  (interactive)
+  (when gpr-show-parse-error
+    (funcall gpr-show-parse-error)))
+
+(defvar gpr-expand nil
+  ;; skeleton function
+  "Function to call to expand tokens (ie insert skeletons).")
+
+(defun gpr-expand ()
+  "Expand previous word into a statement skeleton."
+  (interactive)
+  (when gpr-expand
+    (funcall gpr-expand)))
+
+(defvar gpr-indent-statement nil
+  ;; indentation function
+  "Function to indent the statement/declaration point is in or after.
+Function is called with no arguments.")
+
+(defun gpr-indent-statement ()
+  "Indent current statement."
+  (interactive)
+  (when gpr-indent-statement
+    (funcall gpr-indent-statement)))
+
+(defvar gpr-font-lock-keywords
+  (progn
+    (list
+     ;;
+     ;; keyword plus name.
+     (list (concat
+           "\\<\\("
+           "package\\|"
+           "project\\|"
+           "for"
+           "\\)\\>[ \t]*"
+           "\\(\\sw+\\(\\.\\sw*\\)*\\)?")
+          '(1 font-lock-keyword-face) '(2 font-lock-function-name-face nil t))
+     ;;
+     ;; Main keywords
+     (list (concat "\\<"
+                  (regexp-opt
+                   '("abstract" "aggregate" "case" "configuration" "external" 
"is" "library" "null" "others"
+                     "renames" "standard" "type" "use" "when" "with") t)
+                  "\\>")
+          '(1 font-lock-keyword-face))
+     ;;
+     ;; Anything following end and not already fontified is a body name.
+     '("\\<\\(end\\)\\>\\([ \t]+\\)?\\(\\(\\sw\\|[_.]\\)+\\)?"
+       (1 font-lock-keyword-face) (3 font-lock-function-name-face nil t))
+     ;;
+     ))
+  "Expressions to highlight in gpr mode.")
+
+(defun gpr-ff-special-with ()
+  (ada-require-project-file)
+  (let ((project-path (match-string 1)))
+    ;; project-path may be any of "foo", "foo.gpr", "../foo.gpr"
+    ;;
+    ;; The result of ff-special-constructs is used by
+    ;; ff-find-the-other-file with ff-search-directories and nil
+    ;; suffix list, so it must contain the relative path and the
+    ;; suffix
+    (if (file-name-extension project-path)
+       project-path
+      (concat project-path ".gpr"))
+    ))
+
+(defun gpr-set-ff-special-constructs ()
+  "Add gpr-specific pairs to `ff-special-constructs'."
+  (set (make-local-variable 'ff-special-constructs) nil)
+  (mapc (lambda (pair) (add-to-list 'ff-special-constructs pair))
+       ;; Each car is a regexp; if it matches at point, the cdr is
+       ;; invoked.  Each cdr should return the absolute file name to
+       ;; go to.
+       (list
+        ;; A "with" clause; allow "foo_bar.gpr" and "../foo"
+        (cons "^with[ \t]+\"\\(\\(?:\\(?:\\sw\\|\\s.\\)\\|\\s_\\)+\\)\";"
+              'gpr-ff-special-with)
+        )))
+
+(defvar gpr-which-function nil
+  ;; supplied by the indentation engine
+  "Function called with no parameters; it should return the name
+of the package or project point is in or just after, or nil.")
+
+(defun gpr-which-function ()
+  "See `gpr-which-function' variable."
+  (when gpr-which-function
+    (funcall gpr-which-function)))
+
+(defun gpr-add-log-current-function ()
+  "For `add-log-current-defun-function'. Returns enclosing package or project 
name."
+  ;; add-log-current-defun is typically called with point at the start
+  ;; of an ediff change section, which is before the start of the
+  ;; declaration of a new item. So go to the end of the current line
+  ;; first
+  (save-excursion
+    (end-of-line 1)
+    (gpr-which-function)))
+
+(defun gpr-set-as-project (&optional file)
+  "Set FILE (default current buffer file) as Emacs project file."
+  (interactive)
+  (ada-parse-prj-file (or file (buffer-file-name)))
+  (ada-select-prj-file (or file (buffer-file-name))))
+
+;;;;
+(defun gpr-mode ()
+  "The major mode for editing GNAT project files."
+
+  (interactive)
+  (kill-all-local-variables)
+  (setq major-mode 'gpr-mode)
+  (setq mode-name "GNAT Project")
+  (use-local-map gpr-mode-map)
+  (set-syntax-table ada-mode-syntax-table)
+  (set (make-local-variable 'syntax-begin-function) nil)
+  (set 'case-fold-search t); gpr is case insensitive; the syntax parsing 
requires this setting
+  (set (make-local-variable 'comment-start) "--")
+  (set (make-local-variable 'comment-end) "")
+  (set (make-local-variable 'comment-start-skip) "---*[ \t]*")
+  (set (make-local-variable 'comment-multi-line) nil)
+
+  (set (make-local-variable 'require-final-newline) t)
+
+  (set (make-local-variable 'font-lock-defaults)
+       '(gpr-font-lock-keywords
+        nil t
+        ((?\_ . "w"))))
+
+  (gpr-set-ff-special-constructs)
+  (setq ff-search-directories 'ada-project-search-path)
+
+  (set (make-local-variable 'add-log-current-defun-function)
+       'gpr-add-log-current-function)
+
+  ;; used by autofill to break a comment line and continue it on
+  ;; another line. The reason we need this one is that the default
+  ;; behavior does not work correctly with the definition of
+  ;; paragraph-start above when the comment is right after a
+  ;; multi-line subprogram declaration (the comments are aligned under
+  ;; the latest parameter, not under the declaration start).
+  ;; FIXME: need test - should be in gpr-wisi?
+  (set (make-local-variable 'comment-line-break-function)
+       (lambda (&optional soft) (let ((fill-prefix nil))
+                                 (indent-new-comment-line soft))))
+
+  (run-hooks 'gpr-mode-hook)
+
+  )
+
+;; user needs to add this somewhere:
+;; FIXME: add autoload processing?
+(add-to-list 'auto-mode-alist '("\\.gpr\\'" . gpr-mode))  ; GNAT project files
+
+(provide 'gpr-mode)
+
+(unless (featurep 'gpr-indent-engine)
+  (require 'gpr-wisi))
+
+;;; end of file
diff --git a/packages/ada-mode/gpr-mode.info b/packages/ada-mode/gpr-mode.info
new file mode 100644
index 0000000..6d2e6bf
--- /dev/null
+++ b/packages/ada-mode/gpr-mode.info
@@ -0,0 +1,589 @@
+This is ../gpr-mode.info, produced by makeinfo version 4.13 from
+../gpr-mode.texi.
+
+Copyright (C) 2013  Free Software Foundation, Inc.
+
+     Permission is granted to copy, distribute and/or modify this
+     document under the terms of the GNU Free Documentation License,
+     Version 1.3 or any later version published by the Free Software
+     Foundation; with no Invariant Sections, with the Front-Cover texts
+     being "A GNU Manual", and with the Back-Cover Texts as in (a)
+     below.  A copy of the license is included in the section entitled
+     "GNU Free Documentation License".
+
+     (a) The FSF's Back-Cover Text is: "You have the freedom to copy and
+     modify this GNU manual.  Buying copies from the FSF supports it in
+     developing GNU and promoting software freedom."
+
+INFO-DIR-SECTION Emacs editing modes
+START-INFO-DIR-ENTRY
+* gpr mode: (gpr-mode).         Emacs mode for editing and navigating gpr 
files (gnat project files).
+END-INFO-DIR-ENTRY
+
+
+File: gpr-mode.info,  Node: Top,  Next: Overview,  Prev: (dir),  Up: (dir)
+
+   Copyright (C) 2013  Free Software Foundation, Inc.
+
+     Permission is granted to copy, distribute and/or modify this
+     document under the terms of the GNU Free Documentation License,
+     Version 1.3 or any later version published by the Free Software
+     Foundation; with no Invariant Sections, with the Front-Cover texts
+     being "A GNU Manual", and with the Back-Cover Texts as in (a)
+     below.  A copy of the license is included in the section entitled
+     "GNU Free Documentation License".
+
+     (a) The FSF's Back-Cover Text is: "You have the freedom to copy and
+     modify this GNU manual.  Buying copies from the FSF supports it in
+     developing GNU and promoting software freedom."
+
+* Menu:
+
+* Overview::
+* Installation::
+* GNU Free Documentation License::
+* Index::
+
+
+File: gpr-mode.info,  Node: Overview,  Next: Installation,  Prev: Top,  Up: Top
+
+1 Overview
+**********
+
+gpr files are the project files used by the GNAT compiler and
+associated tools. They describe search paths, compiler options, etc.
+
+   *Note GNAT Project Manager: (gnat_ugn)GNAT Project Manager, for
+general information on gpr files.
+
+   The Emacs mode for gpr files helps the user in reading existing code
+and facilitates writing new code.
+
+   When you open a file with a file extension of `.gpr', Emacs will
+automatically load and activate gpr mode.
+
+
+File: gpr-mode.info,  Node: Installation,  Prev: Overview,  Up: Top
+
+2 Installation
+**************
+
+gpr mode is part of the standard Emacs distribution; if you use that,
+no files need to be installed.
+
+   gpr mode is also available as a separate distribution (bundled with
+Ada mode), from the Emacs Ada mode website
+`http://stephe-leake.org/emacs/ada-mode/emacs-ada-mode.html'. The
+separate distribution may be more recent.
+
+   For installing the separate distribution, see the `README' file in
+the distribution.
+
+   gpr mode does not have a separate version; it uses the Ada mode
+version number. To see what version of Ada mode you have installed, do
+`M-x ada-mode-version'.
+
+
+File: gpr-mode.info,  Node: GNU Free Documentation License,  Next: Index,  Up: 
Top
+
+Appendix A GNU Free Documentation License
+*****************************************
+
+                     Version 1.3, 3 November 2008
+
+     Copyright (C) 2000, 2001, 2002, 2007, 2008, 2009 Free Software 
Foundation, Inc.
+     `http://fsf.org/'
+
+     Everyone is permitted to copy and distribute verbatim copies
+     of this license document, but changing it is not allowed.
+
+  0. PREAMBLE
+
+     The purpose of this License is to make a manual, textbook, or other
+     functional and useful document "free" in the sense of freedom: to
+     assure everyone the effective freedom to copy and redistribute it,
+     with or without modifying it, either commercially or
+     noncommercially.  Secondarily, this License preserves for the
+     author and publisher a way to get credit for their work, while not
+     being considered responsible for modifications made by others.
+
+     This License is a kind of "copyleft", which means that derivative
+     works of the document must themselves be free in the same sense.
+     It complements the GNU General Public License, which is a copyleft
+     license designed for free software.
+
+     We have designed this License in order to use it for manuals for
+     free software, because free software needs free documentation: a
+     free program should come with manuals providing the same freedoms
+     that the software does.  But this License is not limited to
+     software manuals; it can be used for any textual work, regardless
+     of subject matter or whether it is published as a printed book.
+     We recommend this License principally for works whose purpose is
+     instruction or reference.
+
+  1. APPLICABILITY AND DEFINITIONS
+
+     This License applies to any manual or other work, in any medium,
+     that contains a notice placed by the copyright holder saying it
+     can be distributed under the terms of this License.  Such a notice
+     grants a world-wide, royalty-free license, unlimited in duration,
+     to use that work under the conditions stated herein.  The
+     "Document", below, refers to any such manual or work.  Any member
+     of the public is a licensee, and is addressed as "you".  You
+     accept the license if you copy, modify or distribute the work in a
+     way requiring permission under copyright law.
+
+     A "Modified Version" of the Document means any work containing the
+     Document or a portion of it, either copied verbatim, or with
+     modifications and/or translated into another language.
+
+     A "Secondary Section" is a named appendix or a front-matter section
+     of the Document that deals exclusively with the relationship of the
+     publishers or authors of the Document to the Document's overall
+     subject (or to related matters) and contains nothing that could
+     fall directly within that overall subject.  (Thus, if the Document
+     is in part a textbook of mathematics, a Secondary Section may not
+     explain any mathematics.)  The relationship could be a matter of
+     historical connection with the subject or with related matters, or
+     of legal, commercial, philosophical, ethical or political position
+     regarding them.
+
+     The "Invariant Sections" are certain Secondary Sections whose
+     titles are designated, as being those of Invariant Sections, in
+     the notice that says that the Document is released under this
+     License.  If a section does not fit the above definition of
+     Secondary then it is not allowed to be designated as Invariant.
+     The Document may contain zero Invariant Sections.  If the Document
+     does not identify any Invariant Sections then there are none.
+
+     The "Cover Texts" are certain short passages of text that are
+     listed, as Front-Cover Texts or Back-Cover Texts, in the notice
+     that says that the Document is released under this License.  A
+     Front-Cover Text may be at most 5 words, and a Back-Cover Text may
+     be at most 25 words.
+
+     A "Transparent" copy of the Document means a machine-readable copy,
+     represented in a format whose specification is available to the
+     general public, that is suitable for revising the document
+     straightforwardly with generic text editors or (for images
+     composed of pixels) generic paint programs or (for drawings) some
+     widely available drawing editor, and that is suitable for input to
+     text formatters or for automatic translation to a variety of
+     formats suitable for input to text formatters.  A copy made in an
+     otherwise Transparent file format whose markup, or absence of
+     markup, has been arranged to thwart or discourage subsequent
+     modification by readers is not Transparent.  An image format is
+     not Transparent if used for any substantial amount of text.  A
+     copy that is not "Transparent" is called "Opaque".
+
+     Examples of suitable formats for Transparent copies include plain
+     ASCII without markup, Texinfo input format, LaTeX input format,
+     SGML or XML using a publicly available DTD, and
+     standard-conforming simple HTML, PostScript or PDF designed for
+     human modification.  Examples of transparent image formats include
+     PNG, XCF and JPG.  Opaque formats include proprietary formats that
+     can be read and edited only by proprietary word processors, SGML or
+     XML for which the DTD and/or processing tools are not generally
+     available, and the machine-generated HTML, PostScript or PDF
+     produced by some word processors for output purposes only.
+
+     The "Title Page" means, for a printed book, the title page itself,
+     plus such following pages as are needed to hold, legibly, the
+     material this License requires to appear in the title page.  For
+     works in formats which do not have any title page as such, "Title
+     Page" means the text near the most prominent appearance of the
+     work's title, preceding the beginning of the body of the text.
+
+     The "publisher" means any person or entity that distributes copies
+     of the Document to the public.
+
+     A section "Entitled XYZ" means a named subunit of the Document
+     whose title either is precisely XYZ or contains XYZ in parentheses
+     following text that translates XYZ in another language.  (Here XYZ
+     stands for a specific section name mentioned below, such as
+     "Acknowledgements", "Dedications", "Endorsements", or "History".)
+     To "Preserve the Title" of such a section when you modify the
+     Document means that it remains a section "Entitled XYZ" according
+     to this definition.
+
+     The Document may include Warranty Disclaimers next to the notice
+     which states that this License applies to the Document.  These
+     Warranty Disclaimers are considered to be included by reference in
+     this License, but only as regards disclaiming warranties: any other
+     implication that these Warranty Disclaimers may have is void and
+     has no effect on the meaning of this License.
+
+  2. VERBATIM COPYING
+
+     You may copy and distribute the Document in any medium, either
+     commercially or noncommercially, provided that this License, the
+     copyright notices, and the license notice saying this License
+     applies to the Document are reproduced in all copies, and that you
+     add no other conditions whatsoever to those of this License.  You
+     may not use technical measures to obstruct or control the reading
+     or further copying of the copies you make or distribute.  However,
+     you may accept compensation in exchange for copies.  If you
+     distribute a large enough number of copies you must also follow
+     the conditions in section 3.
+
+     You may also lend copies, under the same conditions stated above,
+     and you may publicly display copies.
+
+  3. COPYING IN QUANTITY
+
+     If you publish printed copies (or copies in media that commonly
+     have printed covers) of the Document, numbering more than 100, and
+     the Document's license notice requires Cover Texts, you must
+     enclose the copies in covers that carry, clearly and legibly, all
+     these Cover Texts: Front-Cover Texts on the front cover, and
+     Back-Cover Texts on the back cover.  Both covers must also clearly
+     and legibly identify you as the publisher of these copies.  The
+     front cover must present the full title with all words of the
+     title equally prominent and visible.  You may add other material
+     on the covers in addition.  Copying with changes limited to the
+     covers, as long as they preserve the title of the Document and
+     satisfy these conditions, can be treated as verbatim copying in
+     other respects.
+
+     If the required texts for either cover are too voluminous to fit
+     legibly, you should put the first ones listed (as many as fit
+     reasonably) on the actual cover, and continue the rest onto
+     adjacent pages.
+
+     If you publish or distribute Opaque copies of the Document
+     numbering more than 100, you must either include a
+     machine-readable Transparent copy along with each Opaque copy, or
+     state in or with each Opaque copy a computer-network location from
+     which the general network-using public has access to download
+     using public-standard network protocols a complete Transparent
+     copy of the Document, free of added material.  If you use the
+     latter option, you must take reasonably prudent steps, when you
+     begin distribution of Opaque copies in quantity, to ensure that
+     this Transparent copy will remain thus accessible at the stated
+     location until at least one year after the last time you
+     distribute an Opaque copy (directly or through your agents or
+     retailers) of that edition to the public.
+
+     It is requested, but not required, that you contact the authors of
+     the Document well before redistributing any large number of
+     copies, to give them a chance to provide you with an updated
+     version of the Document.
+
+  4. MODIFICATIONS
+
+     You may copy and distribute a Modified Version of the Document
+     under the conditions of sections 2 and 3 above, provided that you
+     release the Modified Version under precisely this License, with
+     the Modified Version filling the role of the Document, thus
+     licensing distribution and modification of the Modified Version to
+     whoever possesses a copy of it.  In addition, you must do these
+     things in the Modified Version:
+
+       A. Use in the Title Page (and on the covers, if any) a title
+          distinct from that of the Document, and from those of
+          previous versions (which should, if there were any, be listed
+          in the History section of the Document).  You may use the
+          same title as a previous version if the original publisher of
+          that version gives permission.
+
+       B. List on the Title Page, as authors, one or more persons or
+          entities responsible for authorship of the modifications in
+          the Modified Version, together with at least five of the
+          principal authors of the Document (all of its principal
+          authors, if it has fewer than five), unless they release you
+          from this requirement.
+
+       C. State on the Title page the name of the publisher of the
+          Modified Version, as the publisher.
+
+       D. Preserve all the copyright notices of the Document.
+
+       E. Add an appropriate copyright notice for your modifications
+          adjacent to the other copyright notices.
+
+       F. Include, immediately after the copyright notices, a license
+          notice giving the public permission to use the Modified
+          Version under the terms of this License, in the form shown in
+          the Addendum below.
+
+       G. Preserve in that license notice the full lists of Invariant
+          Sections and required Cover Texts given in the Document's
+          license notice.
+
+       H. Include an unaltered copy of this License.
+
+       I. Preserve the section Entitled "History", Preserve its Title,
+          and add to it an item stating at least the title, year, new
+          authors, and publisher of the Modified Version as given on
+          the Title Page.  If there is no section Entitled "History" in
+          the Document, create one stating the title, year, authors,
+          and publisher of the Document as given on its Title Page,
+          then add an item describing the Modified Version as stated in
+          the previous sentence.
+
+       J. Preserve the network location, if any, given in the Document
+          for public access to a Transparent copy of the Document, and
+          likewise the network locations given in the Document for
+          previous versions it was based on.  These may be placed in
+          the "History" section.  You may omit a network location for a
+          work that was published at least four years before the
+          Document itself, or if the original publisher of the version
+          it refers to gives permission.
+
+       K. For any section Entitled "Acknowledgements" or "Dedications",
+          Preserve the Title of the section, and preserve in the
+          section all the substance and tone of each of the contributor
+          acknowledgements and/or dedications given therein.
+
+       L. Preserve all the Invariant Sections of the Document,
+          unaltered in their text and in their titles.  Section numbers
+          or the equivalent are not considered part of the section
+          titles.
+
+       M. Delete any section Entitled "Endorsements".  Such a section
+          may not be included in the Modified Version.
+
+       N. Do not retitle any existing section to be Entitled
+          "Endorsements" or to conflict in title with any Invariant
+          Section.
+
+       O. Preserve any Warranty Disclaimers.
+
+     If the Modified Version includes new front-matter sections or
+     appendices that qualify as Secondary Sections and contain no
+     material copied from the Document, you may at your option
+     designate some or all of these sections as invariant.  To do this,
+     add their titles to the list of Invariant Sections in the Modified
+     Version's license notice.  These titles must be distinct from any
+     other section titles.
+
+     You may add a section Entitled "Endorsements", provided it contains
+     nothing but endorsements of your Modified Version by various
+     parties--for example, statements of peer review or that the text
+     has been approved by an organization as the authoritative
+     definition of a standard.
+
+     You may add a passage of up to five words as a Front-Cover Text,
+     and a passage of up to 25 words as a Back-Cover Text, to the end
+     of the list of Cover Texts in the Modified Version.  Only one
+     passage of Front-Cover Text and one of Back-Cover Text may be
+     added by (or through arrangements made by) any one entity.  If the
+     Document already includes a cover text for the same cover,
+     previously added by you or by arrangement made by the same entity
+     you are acting on behalf of, you may not add another; but you may
+     replace the old one, on explicit permission from the previous
+     publisher that added the old one.
+
+     The author(s) and publisher(s) of the Document do not by this
+     License give permission to use their names for publicity for or to
+     assert or imply endorsement of any Modified Version.
+
+  5. COMBINING DOCUMENTS
+
+     You may combine the Document with other documents released under
+     this License, under the terms defined in section 4 above for
+     modified versions, provided that you include in the combination
+     all of the Invariant Sections of all of the original documents,
+     unmodified, and list them all as Invariant Sections of your
+     combined work in its license notice, and that you preserve all
+     their Warranty Disclaimers.
+
+     The combined work need only contain one copy of this License, and
+     multiple identical Invariant Sections may be replaced with a single
+     copy.  If there are multiple Invariant Sections with the same name
+     but different contents, make the title of each such section unique
+     by adding at the end of it, in parentheses, the name of the
+     original author or publisher of that section if known, or else a
+     unique number.  Make the same adjustment to the section titles in
+     the list of Invariant Sections in the license notice of the
+     combined work.
+
+     In the combination, you must combine any sections Entitled
+     "History" in the various original documents, forming one section
+     Entitled "History"; likewise combine any sections Entitled
+     "Acknowledgements", and any sections Entitled "Dedications".  You
+     must delete all sections Entitled "Endorsements."
+
+  6. COLLECTIONS OF DOCUMENTS
+
+     You may make a collection consisting of the Document and other
+     documents released under this License, and replace the individual
+     copies of this License in the various documents with a single copy
+     that is included in the collection, provided that you follow the
+     rules of this License for verbatim copying of each of the
+     documents in all other respects.
+
+     You may extract a single document from such a collection, and
+     distribute it individually under this License, provided you insert
+     a copy of this License into the extracted document, and follow
+     this License in all other respects regarding verbatim copying of
+     that document.
+
+  7. AGGREGATION WITH INDEPENDENT WORKS
+
+     A compilation of the Document or its derivatives with other
+     separate and independent documents or works, in or on a volume of
+     a storage or distribution medium, is called an "aggregate" if the
+     copyright resulting from the compilation is not used to limit the
+     legal rights of the compilation's users beyond what the individual
+     works permit.  When the Document is included in an aggregate, this
+     License does not apply to the other works in the aggregate which
+     are not themselves derivative works of the Document.
+
+     If the Cover Text requirement of section 3 is applicable to these
+     copies of the Document, then if the Document is less than one half
+     of the entire aggregate, the Document's Cover Texts may be placed
+     on covers that bracket the Document within the aggregate, or the
+     electronic equivalent of covers if the Document is in electronic
+     form.  Otherwise they must appear on printed covers that bracket
+     the whole aggregate.
+
+  8. TRANSLATION
+
+     Translation is considered a kind of modification, so you may
+     distribute translations of the Document under the terms of section
+     4.  Replacing Invariant Sections with translations requires special
+     permission from their copyright holders, but you may include
+     translations of some or all Invariant Sections in addition to the
+     original versions of these Invariant Sections.  You may include a
+     translation of this License, and all the license notices in the
+     Document, and any Warranty Disclaimers, provided that you also
+     include the original English version of this License and the
+     original versions of those notices and disclaimers.  In case of a
+     disagreement between the translation and the original version of
+     this License or a notice or disclaimer, the original version will
+     prevail.
+
+     If a section in the Document is Entitled "Acknowledgements",
+     "Dedications", or "History", the requirement (section 4) to
+     Preserve its Title (section 1) will typically require changing the
+     actual title.
+
+  9. TERMINATION
+
+     You may not copy, modify, sublicense, or distribute the Document
+     except as expressly provided under this License.  Any attempt
+     otherwise to copy, modify, sublicense, or distribute it is void,
+     and will automatically terminate your rights under this License.
+
+     However, if you cease all violation of this License, then your
+     license from a particular copyright holder is reinstated (a)
+     provisionally, unless and until the copyright holder explicitly
+     and finally terminates your license, and (b) permanently, if the
+     copyright holder fails to notify you of the violation by some
+     reasonable means prior to 60 days after the cessation.
+
+     Moreover, your license from a particular copyright holder is
+     reinstated permanently if the copyright holder notifies you of the
+     violation by some reasonable means, this is the first time you have
+     received notice of violation of this License (for any work) from
+     that copyright holder, and you cure the violation prior to 30 days
+     after your receipt of the notice.
+
+     Termination of your rights under this section does not terminate
+     the licenses of parties who have received copies or rights from
+     you under this License.  If your rights have been terminated and
+     not permanently reinstated, receipt of a copy of some or all of
+     the same material does not give you any rights to use it.
+
+ 10. FUTURE REVISIONS OF THIS LICENSE
+
+     The Free Software Foundation may publish new, revised versions of
+     the GNU Free Documentation License from time to time.  Such new
+     versions will be similar in spirit to the present version, but may
+     differ in detail to address new problems or concerns.  See
+     `http://www.gnu.org/copyleft/'.
+
+     Each version of the License is given a distinguishing version
+     number.  If the Document specifies that a particular numbered
+     version of this License "or any later version" applies to it, you
+     have the option of following the terms and conditions either of
+     that specified version or of any later version that has been
+     published (not as a draft) by the Free Software Foundation.  If
+     the Document does not specify a version number of this License,
+     you may choose any version ever published (not as a draft) by the
+     Free Software Foundation.  If the Document specifies that a proxy
+     can decide which future versions of this License can be used, that
+     proxy's public statement of acceptance of a version permanently
+     authorizes you to choose that version for the Document.
+
+ 11. RELICENSING
+
+     "Massive Multiauthor Collaboration Site" (or "MMC Site") means any
+     World Wide Web server that publishes copyrightable works and also
+     provides prominent facilities for anybody to edit those works.  A
+     public wiki that anybody can edit is an example of such a server.
+     A "Massive Multiauthor Collaboration" (or "MMC") contained in the
+     site means any set of copyrightable works thus published on the MMC
+     site.
+
+     "CC-BY-SA" means the Creative Commons Attribution-Share Alike 3.0
+     license published by Creative Commons Corporation, a not-for-profit
+     corporation with a principal place of business in San Francisco,
+     California, as well as future copyleft versions of that license
+     published by that same organization.
+
+     "Incorporate" means to publish or republish a Document, in whole or
+     in part, as part of another Document.
+
+     An MMC is "eligible for relicensing" if it is licensed under this
+     License, and if all works that were first published under this
+     License somewhere other than this MMC, and subsequently
+     incorporated in whole or in part into the MMC, (1) had no cover
+     texts or invariant sections, and (2) were thus incorporated prior
+     to November 1, 2008.
+
+     The operator of an MMC Site may republish an MMC contained in the
+     site under CC-BY-SA on the same site at any time before August 1,
+     2009, provided the MMC is eligible for relicensing.
+
+
+ADDENDUM: How to use this License for your documents
+====================================================
+
+To use this License in a document you have written, include a copy of
+the License in the document and put the following copyright and license
+notices just after the title page:
+
+       Copyright (C)  YEAR  YOUR NAME.
+       Permission is granted to copy, distribute and/or modify this document
+       under the terms of the GNU Free Documentation License, Version 1.3
+       or any later version published by the Free Software Foundation;
+       with no Invariant Sections, no Front-Cover Texts, and no Back-Cover
+       Texts.  A copy of the license is included in the section entitled ``GNU
+       Free Documentation License''.
+
+   If you have Invariant Sections, Front-Cover Texts and Back-Cover
+Texts, replace the "with...Texts." line with this:
+
+         with the Invariant Sections being LIST THEIR TITLES, with
+         the Front-Cover Texts being LIST, and with the Back-Cover Texts
+         being LIST.
+
+   If you have Invariant Sections without Cover Texts, or some other
+combination of the three, merge those two alternatives to suit the
+situation.
+
+   If your document contains nontrivial examples of program code, we
+recommend releasing these examples in parallel under your choice of
+free software license, such as the GNU General Public License, to
+permit their use in free software.
+
+
+File: gpr-mode.info,  Node: Index,  Prev: GNU Free Documentation License,  Up: 
Top
+
+Index
+*****
+
+[index]
+* Menu:
+
+
+Tag Table:
+Node: Top969
+Node: Overview1840
+Node: Installation2398
+Node: GNU Free Documentation License3077
+Node: Index28230
+
+End Tag Table
diff --git a/packages/ada-mode/gpr-skel.el b/packages/ada-mode/gpr-skel.el
new file mode 100755
index 0000000..7f09566
--- /dev/null
+++ b/packages/ada-mode/gpr-skel.el
@@ -0,0 +1,258 @@
+;;; gpr-skel.el --- an extension to Gpr mode for inserting statement skeletons
+
+;; Copyright (C) 2013
+;;   Free Software Foundation, Inc.
+
+;; Authors: 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/>.
+
+;;; Design:
+;;
+;; The primary user command is `gpr-skel-expand', which inserts the
+;; skeleton associated with the previous word (possibly skipping a
+;; name).
+;;
+;; We don't define skeletons that prompt for most of the content; it
+;; 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 gpr-wisi parser
+;; likes, and handle repeated names nicely.
+
+;;; History:
+
+;; Created Dec 2013
+
+(require 'skeleton)
+(require 'gpr-mode)
+
+;;;;; user variables, example skeletons intended to be overwritten
+
+(defcustom gpr-skel-initial-string "header\nproject"
+  "*String to insert in empty buffer.
+This could end in a token recognized by `gpr-skel-expand'."
+  :type 'string
+  :group 'gpr
+  :safe 'stringp)
+
+(define-skeleton gpr-skel-user-restricted
+  "Example copyright/license skeleton, with automatic year and owner."
+  ()
+  "--  Copyright (C) " (format-time-string "%Y ") user-full-name " All Rights 
Reserved.\n"
+)
+
+(define-skeleton gpr-skel-gpl
+  "Example copyright/license skeleton, with automatic year and owner, GPLv3."
+  ()
+  "--  Copyright (C) " (format-time-string "%Y ") user-full-name " All Rights 
Reserved.\n"
+  "--\n"
+  "--  This program is free software; you can redistribute it and/or\n"
+  "--  modify it under terms of the GNU General Public License as\n"
+  "--  published by the Free Software Foundation; either version 3, or (at\n"
+  "--  your option) any later version. This program is distributed in the\n"
+  "--  hope that it will be useful, but WITHOUT ANY WARRANTY; without even\n"
+  "--  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR\n"
+  "--  PURPOSE. See the GNU General Public License for more details. You\n"
+  "--  should have received a copy of the GNU General Public License\n"
+  "--  distributed with this program; see file COPYING. If not, write to\n"
+  "--  the Free Software Foundation, 51 Franklin Street, Suite 500, Boston,\n"
+  "--  MA 02110-1335, USA.\n"
+)
+
+;;;;; Gpr skeletons (alphabetical)
+
+(define-skeleton gpr-skel-case
+  "Insert case statement."
+  ()
+  "case " str " is\n"
+  "when " _ "=>\n"
+  "end case;")
+
+(define-skeleton gpr-skel-header
+  "Insert a file header comment, with automatic copyright year and prompt for 
copyright owner/license.
+Each user will probably want to override this."
+  ()
+  "--  Abstract :\n"
+  "--\n"
+  "--  " _ "\n"
+  "--\n"
+  "{copyright_license}\n"
+  )
+
+(define-skeleton gpr-skel-package
+  "Insert a package with name from `str'."
+  ()
+  "package " str " is\n"
+  _
+  "end " str ";")
+
+(define-skeleton gpr-skel-project
+  "Insert a project with name from `str'."
+  ()
+  "project " str " is\n"
+  _
+  "end " str ";")
+
+;;;;; skeleton extensions
+
+;; FIXME: code below should be in skeleton.el
+
+(defvar-local skeleton-token-alist nil
+  "Symbol giving skeleton token alist of elements (STRING ELEMENT).
+See `skeleton-expand'.
+STRING must be a symbol in the current syntax, and is normally
+the first keyword in the skeleton. All strings must be
+lowercase; `skeleton-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. ")
+
+(defun skeleton-add-skeleton (token skel alist &optional where)
+  "Add an element (TOKEN . SKEL) to ALIST by side-effect.
+If WHERE is nil, prepend to ALIST; otherwise, prepend to sublist
+at WHERE."
+  (if (null where)
+      (setf alist (cons (cons token skel) alist))
+    (setf (cdr (assoc where alist))
+         (cons (cons token skel) (cdr (assoc where alist))))
+    ))
+
+(defvar skeleton-test-input nil
+  "When non-nil, bypasses prompt in alist token expansions - used for unit 
testing.")
+
+(defun skeleton-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 " | ") " | ... : "))
+  ))
+
+;;;###autoload
+(defun skeleton-expand (&optional name)
+  "Expand the token or placeholder before point to a skeleton, as defined by 
`skeleton-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 `gpr-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 
Gpr.Text_IO
+  (let* ((end (prog1 (point) (skip-syntax-backward "w_.")))
+        (token (downcase (buffer-substring-no-properties (point) end)))
+        (skel (assoc-string token (symbol-value skeleton-token-alist)))
+        (handled nil))
+
+    (if skel
+       (progn
+         (when (listp (cdr skel))
+           (let* ((alist (cdr skel))
+                  (prompt (skeleton-build-prompt alist 4)))
+             (setq skel (assoc-string
+                         (or skeleton-test-input
+                             (completing-read prompt alist))
+                         alist))
+             (setq skeleton-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.
+       ;; FIXME: hook for Ada case adjust
+
+       (setq token (buffer-substring-no-properties (point) end))
+
+       (skeleton-expand token)
+       (setq handled t)))
+
+    (when (not handled)
+      (error "undefined skeleton token: %s" name))
+    ))
+
+(defun skeleton-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-boundary)
+      (condition-case nil
+         (progn
+           (skeleton-expand)
+           t)
+       ('error
+        ;; undo hook action, motion
+        (undo)
+        (goto-char pos)
+        nil)))))
+;; end FIXME:
+
+;;;;; token alist, setup
+
+(defconst gpr-skel-token-alist
+  '(("case" . gpr-skel-case)
+    ("copyright_license"
+     ("GPL" . gpr-skel-gpl)
+     ("restricted" . gpr-skel-user-restricted))
+    ("header" . gpr-skel-header)
+    ("package" . gpr-skel-package)
+    ("project" . gpr-skel-project))
+"For skeleton-token-alist")
+
+(defun gpr-skel-setup ()
+  "Setup a buffer gpr-skel."
+  (setq skeleton-token-alist 'gpr-skel-token-alist)
+  (add-hook 'skeleton-end-hook 'gpr-indent-statement nil t)
+  (when (and gpr-skel-initial-string
+            (= (buffer-size) 0))
+    (insert gpr-skel-initial-string))
+  )
+
+(provide 'gpr-skeletons)
+(provide 'gpr-skel)
+
+(setq gpr-expand 'skeleton-expand)
+
+(add-hook 'gpr-mode-hook 'gpr-skel-setup)
+
+;;; end of file
diff --git a/packages/ada-mode/gpr-wisi.el b/packages/ada-mode/gpr-wisi.el
new file mode 100755
index 0000000..9efaa48
--- /dev/null
+++ b/packages/ada-mode/gpr-wisi.el
@@ -0,0 +1,195 @@
+;;; An indentation engine for gpr mode, using the wisent LALR parser
+;;
+;; [1] GNAT user guide (info "gnat_ugn")
+;;
+;; Copyright (C) 2013 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/>.
+;;
+;;; History: first version Jan 2013
+;;
+;;; code style
+;;
+;; not using lexical-binding or cl-lib because we support Emacs 23
+;;
+;; I don't use 'pcase', because it gives _really_ confusing errors
+;; when I forget a ')' somewhere. Even worse, the error message is
+;; given when you use edebug on a defun, not when you eval it. This
+;; code is hard enough to debug!
+;;
+;;;;
+
+;; we reuse some stuff from ada-mode
+(require 'ada-indent-user-options)
+(require 'gpr-grammar-wy)
+(require 'gpr-mode)
+(require 'wisi)
+
+(defconst gpr-wisi-class-list
+  '(
+    block-start
+    block-middle
+    block-end
+    close-paren
+    open-paren
+    statement-end
+    statement-other
+    statement-start
+    ))
+
+(defun gpr-wisi-indent-cache (offset cache)
+  "Return indentation of OFFSET relative to CACHE or containing ancestor of 
CACHE that is at a line beginning."
+  (let ((indent (current-indentation)))
+    (while (and cache
+               (not (= (current-column) indent)))
+      (when (eq 'WHEN (wisi-cache-token cache))
+       (setq offset (+ offset ada-indent-when)))
+      (setq cache (wisi-goto-containing cache))
+      (setq indent (current-indentation)))
+  (+ (current-indentation) offset)
+  ))
+
+(defun gpr-wisi-indent-containing (offset cache)
+  "Return indentation of OFFSET relative to containing ancestor of CACHE that 
is at a line beginning."
+  (gpr-wisi-indent-cache offset (wisi-goto-containing cache)))
+
+(defun gpr-wisi-before-cache ()
+  (let ((cache (wisi-get-cache (point))))
+    (when cache
+      (cl-ecase (wisi-cache-class cache)
+       (block-start (wisi-indent-start ada-indent (wisi-backward-cache)))
+       (block-end (wisi-indent-start 0 cache))
+       (block-middle
+        (wisi-indent-start
+         (if (eq (wisi-cache-token cache) 'WHEN) ada-indent-when 0)
+         ;; FIXME (later): need test of ada-indent-when in gpr
+         cache))
+       (close-paren (wisi-indent-paren 0))
+       (open-paren nil); let after-keyword handle it
+       (statement-start
+        (if (not (wisi-get-containing-cache cache))
+            ;; at bob
+            0
+          ;; not at bob
+          (gpr-wisi-indent-containing ada-indent cache)))
+       ))
+    ))
+
+(defun gpr-wisi-after-cache ()
+  (let ((cache (wisi-backward-cache)))
+    (if (not cache)
+       ;; bob
+       0
+      (cl-ecase (wisi-cache-class cache)
+       (block-end
+        (wisi-indent-current 0))
+
+       (block-middle
+        (cl-case (wisi-cache-token cache)
+          (WHEN
+           (gpr-wisi-indent-cache ada-indent-broken cache))
+          (t
+           (gpr-wisi-indent-cache ada-indent cache))
+          ))
+
+       (block-start
+        (cl-case (wisi-cache-token cache)
+          (EQUAL_GREATER
+           (gpr-wisi-indent-containing ada-indent cache))
+          (t
+           (gpr-wisi-indent-cache ada-indent cache))
+          ))
+
+       (open-paren
+        (1+ (current-column)))
+
+       (statement-end
+        (wisi-indent-start 0 cache))
+
+       ((statement-other close-paren)
+        ;; test/gpr/simple.gpr
+        ;; ) & Style_Checks
+        ;; & Standard_Common.Compiler'Default_Switches;
+        ;;
+        ;; for Source_Dirs use
+        ;;   ("../auto",
+        (wisi-indent-start ada-indent-broken cache))
+
+       (statement-start
+        ;; test/gpr/simple.gpr
+        ;; type GNAT_Version_Type
+        ;;   is ("7.0.1",
+        ;; hanging
+        (gpr-wisi-indent-cache ada-indent-broken cache))
+       ))
+    ))
+
+(defun gpr-wisi-post-parse-fail ()
+  "For `wisi-post-parse-fail-hook'."
+  ;; keep it simple :)
+  nil)
+
+(defun gpr-wisi-which-function ()
+  "For `gpr-which-function'."
+  (wisi-validate-cache (point))
+  (let ((cache (wisi-backward-cache)))
+    (while (and cache
+               (not (and
+                     (memq (wisi-cache-nonterm cache) '(package_spec 
simple_project_declaration))
+                     (eq (wisi-cache-class cache) 'statement-start))))
+      (setq cache (wisi-goto-containing cache)))
+    (when cache
+      (wisi-forward-token); package | project
+      (wisi-forward-token t); name
+      )))
+
+;;; debugging
+(defun gpr-wisi-debug-keys ()
+  "Add debug key definitions to `gpr-mode-map'."
+  (interactive)
+  (define-key gpr-mode-map "\M-h" 'wisi-show-containing-or-previous-cache)
+  (define-key gpr-mode-map "\M-j" 'wisi-show-cache)
+  (define-key gpr-mode-map "\M-k" 'wisi-show-token)
+  )
+
+;;;;
+;;;###autoload
+(defun gpr-wisi-setup ()
+  "Set up a buffer for parsing Ada files with wisi."
+  (wisi-setup '(gpr-wisi-before-cache
+               gpr-wisi-after-cache)
+             'gpr-wisi-post-parse-fail
+             gpr-wisi-class-list
+             gpr-grammar-wy--keyword-table
+             gpr-grammar-wy--token-table
+             gpr-grammar-wy--parse-table)
+
+  (setq gpr-indent-statement 'wisi-indent-statement)
+  (set (make-local-variable 'comment-indent-function) 'wisi-comment-indent)
+  )
+
+(add-hook 'gpr-mode-hook 'gpr-wisi-setup)
+
+(setq gpr-which-function 'gpr-wisi-which-function)
+
+(setq gpr-show-parse-error 'wisi-show-parse-error)
+
+(provide 'gpr-wisi)
+(provide 'gpr-indent-engine)
+
+;; end of file
diff --git a/packages/wisi/wisi-compile.el b/packages/wisi/wisi-compile.el
new file mode 100755
index 0000000..39ed689
--- /dev/null
+++ b/packages/wisi/wisi-compile.el
@@ -0,0 +1,223 @@
+;;; Grammar compiler for the wisent LALR parser, integrating Wisi OpenToken 
output.
+;;
+;; Copyright (C) 2012, 2013 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/>.
+;;
+;;; History: first experimental version Jan 2013
+;;
+;;; Context
+;;
+;; Semantic (info "(semantic)Top") provides an LALR(1) parser
+;; wisent-parse. The grammar used is defined by the functions
+;; semantic-grammar-create-package, which reads a bison-like source
+;; file and produces corresponding elisp source, and
+;; wisent-compile-grammar, which generates a parser table.
+;;
+;; However, the algorithm used in wisent-compile-grammar cannot cope
+;; with the grammar for the Ada language, because it is not
+;; LALR(1). So we provide a generalized LALR parser, which spawns
+;; parallel LALR parsers at each conflict. Instead of also rewriting
+;; the entire semantic grammar compiler, we use the OpenToken LALR
+;; parser generator, which is easier to modify (it is written in Ada,
+;; not Lisp).
+;;
+;; The Ada function Wisi.Generate reads the bison-like input and
+;; produces corresponding elisp source code, similar to that
+;; produced by semantic-grammar-create-package.
+;;
+;; wisi-compile-grammar (provided here) generate the automaton
+;; structure required by wisi-parse, using functions from
+;; wisent/comp.el
+;;
+;;;;
+
+(eval-when-compile
+  ;; can't just 'require'; `wisent-with-context' doesn't work.
+  ;; also can't load .elc; must load .el
+  (load (locate-library "semantic/wisent/comp.el")))
+
+(eval-and-compile
+  (require 'semantic/wisent/comp))
+
+(defun wisi-compose-action (value symbol-array nonterms)
+  (let ((symbol (intern-soft (format "%s:%d" (car value) (cdr value)) 
symbol-array))
+       (prod (car (nth (cdr value) (cdr (assoc (car value) nonterms))))))
+    (if symbol
+       (list (car value) symbol (length prod))
+      (error "%s not in symbol-array" symbol))))
+
+(defun wisi-replace-actions (action symbol-array nonterms)
+  "Replace semantic action symbol names in ACTION with list as defined in 
`wisi-compile-grammar'.
+ACTION is the alist for one state from the grammar; NONTERMS is from the 
grammar.
+Return the new alist."
+  ;; result is (nonterm index action-symbol token-count)
+  (let (result item)
+    (while action
+     (setq item (pop action))
+     (cond
+      ((or
+       (memq (cdr item) '(error accept))
+       (numberp (cdr item)))
+       (push item result))
+
+      ((listp (cdr item))
+       (let ((value (cdr item)))
+        (cond
+         ((symbolp (car value))
+          ;; reduction
+          (push (cons (car item)
+                      (wisi-compose-action value symbol-array nonterms))
+                result))
+
+         ((integerp (car value))
+          ;; shift/reduce conflict
+          (push (cons (car item)
+                      (list (car value)
+                            (wisi-compose-action (cadr value) symbol-array 
nonterms)))
+                result))
+
+         ((integerp (cadr value))
+          ;; reduce/shift conflict
+          (push (cons (car item)
+                      (list (wisi-compose-action (car value) symbol-array 
nonterms)
+